balance windows

[agzam]

I've been trying to implement seemingly simple feature in my config - balancing windows, i.e., in the dwindle layout I want to be able to make all existing windows in the active workspace to be of the equal width and height.

I've been scratching my head on this one and I just can't figure it out - every time I dispatch resizewindowpixel Hyprland re-adjusts the windows making it nearly impossible to achieve what I want.

I'm pretty sure this is a solved problem and I just don't know the answer to it. I'd appreciate if someone shares some thoughts on this.

[vaxerski]

It's likely not, as that makes little sense on dwindle, as dwindle is a binary space partitioning algorithm.

[agzam]

Oh wow, I really did not expect it to be so complicated, but turns out, you're right - BSP indeed makes things much more difficult.

I have wasted hours yelling at LLM and I was able to bake a semi-functional solution, which isn't always accurate, and frankly I don't know if it's worth trying to improve it. If someone comes up with a proper, better algorithm, please share your thoughts

I started with balance-windows-width, because for my use case that is more important than balancing heights, well, at least for my main monitor. My secondary is in portrait mode, so balancing heights would be handy there.

I built my config in Clojure, using babashka - I know - quite unconventional approach, but Lisp has a REPL, that allows me to play around with things, trying them on the go, and I love it. I made (hypr-cmd) function that sends hyprctl commands figuring out the proper socket, handling json parsing, etc.

Basically, this is how it works:

balance-windows-width

1. Gets all non-floating windows in the current workspace and sorts them by X position (left to right)

2. Finds vertical splits - looks for gaps between windows where one window's right edge is close to another's left edge (within ~14 pixels, accounting for gaps and borders)

3. Recursively processes groups:

   • When a vertical split is found, divides windows into left and right groups
   • Counts "horizontal slots" (unique X positions) in each group
   • Calculates how much width each group should get based on the ratio of slots
   • Resizes the rightmost window of the left group to achieve this ratio
   • Recursively processes each subgroup

balance-windows-height

Works similarly but for vertical distribution:

1. Finds vertical columns first by looking for vertical splits between windows

2. Within each column, finds horizontal splits (gaps between windows' bottom and top edges)

3. Balances each column independently:

   • Counts "vertical slots" (unique Y positions)
   • Calculates target heights based on slot ratios
   • Resizes the window at the split boundary to achieve balance
   • Recursively processes subgroups

Limitations

• Works best with simple layouts (2-4 windows)
• Complex layouts with many nested splits may not balance perfectly
• Windows are processed in tree order, so earlier adjustments can affect later ones
• The BSP structure means resizing one window affects its neighbors, making perfect balance difficult

The functions essentially try to give equal space to each "slot" (row or column position) rather than each window, which typically (not always) produces visually pleasing results even if not exactly accurate.

Clojure code

    (defn get-window-gap []
      (let [gaps-data (:custom (hypr-cmd "getoption general:gaps_in"))
            gaps      (map #(Integer/parseInt %) (clojure.string/split gaps-data #" "))]
        ;; gaps format is [top right bottom left] or [all]
        ;; for horizontal gaps between windows, we want left/right
        (if (= (count gaps) 1)
          (first gaps)
          (second gaps))))

    (defn balance-windows-width []
      (let [workspace-id (->> (hypr-cmd "activeworkspace") :id)
            clients      (->> (hypr-cmd "clients")
                              (filter #(-> % :workspace :id (= workspace-id)))
                              (remove :floating)
                              (remove :hidden)
                              (sort-by #(first (:at %))))
            gap          (get-window-gap)]

        (letfn [(find-vertical-split [windows]
                  (first (for [w1    windows
                               w2    windows
                               :let  [w1-right (+ (first (:at w1)) (first (:size w1)))
                                      w2-left (first (:at w2))]
                               :when (and (not= w1 w2)
                                          (< w1-right w2-left)
                                          (<= (- w2-left w1-right) (* gap 3)))]
                           w1-right)))

                ;; Count horizontal slots (unique X positions) not individual windows!
                (count-horizontal-slots [windows]
                  (count (distinct (map #(first (:at %)) windows))))

                (balance-group [windows depth]
                  (when (< 1 (count windows))
                    (when-let [split-x (find-vertical-split windows)]
                      (let [left-group  (filter #(< (first (:at %)) split-x) windows)
                            right-group (filter #(< split-x (first (:at %))) windows)]

                        (when (and (seq left-group) (seq right-group))
                          (let [;; Count horizontal slots, not windows!
                                left-slots         (count-horizontal-slots left-group)
                                right-slots        (count-horizontal-slots right-group)
                                total-slots        (+ left-slots right-slots)
                                leftmost-x         (apply min (map #(first (:at %)) windows))
                                rightmost-x        (apply max (map #(+ (first (:at %)) (first (:size %))) windows))
                                total-span         (- rightmost-x leftmost-x)
                                gaps-between-slots (* gap (dec total-slots))
                                usable-width       (- total-span gaps-between-slots)
                                target-left-ratio  (/ left-slots total-slots)
                                current-left-width (reduce + (distinct (map #(first (:size %)) left-group)))
                                target-left-width  (int (* usable-width target-left-ratio))
                                width-diff         (- target-left-width current-left-width)]

                            (println (str (apply str (repeat depth "  "))
                                          "Left has " left-slots " slots, right has " right-slots))

                            (when (< 2 (Math/abs width-diff))
                              (let [resize-window (last (sort-by :at left-group))]
                                (hypr-cmd (str "dispatch resizewindowpixel "
                                               width-diff " 0,address:" (:address resize-window)))))

                            (balance-group left-group (inc depth))
                            (balance-group right-group (inc depth))))))))]

          (balance-group clients 0))))

    (defn balance-windows-height []
      (let [workspace-id (->> (hypr-cmd "activeworkspace") :id)
            clients (->> (hypr-cmd "clients")
                         (filter #(-> % :workspace :id (= workspace-id)))
                         (remove :floating)
                         (remove :hidden))
            gap (get-window-gap)]

        (letfn [(find-vertical-split [windows]
                  (first (for [w1 windows
                               w2 windows
                               :let [w1-right (+ (first (:at w1)) (first (:size w1)))
                                     w2-left (first (:at w2))]
                               :when (and (not= w1 w2)
                                          (< w1-right w2-left)
                                          (<= (- w2-left w1-right) (* gap 3)))]
                           w1-right)))

                (find-horizontal-split [windows]
                  (first (for [w1 windows
                               w2 windows
                               :let [w1-bottom (+ (second (:at w1)) (second (:size w1)))
                                     w2-top (second (:at w2))]
                               :when (and (not= w1 w2)
                                          (< w1-bottom w2-top)
                                          (<= (- w2-top w1-bottom) (* gap 3)))]
                           w1-bottom)))

                (count-vertical-slots [windows]
                  (count (distinct (map #(second (:at %)) windows))))

                (balance-column-heights [windows depth]
                  (when (< 1 (count windows))
                    (when-let [split-y (find-horizontal-split windows)]
                      (let [top-group (filter #(< (second (:at %)) split-y) windows)
                            bottom-group (filter #(< split-y (second (:at %))) windows)]

                        (when (and (seq top-group) (seq bottom-group))
                          (let [top-slots (count-vertical-slots top-group)
                                bottom-slots (count-vertical-slots bottom-group)
                                total-slots (+ top-slots bottom-slots)
                                topmost-y (apply min (map #(second (:at %)) windows))
                                bottommost-y (apply max (map #(+ (second (:at %)) (second (:size %))) windows))
                                total-span (- bottommost-y topmost-y)
                                gaps-between-slots (* gap (dec total-slots))
                                usable-height (- total-span gaps-between-slots)
                                target-top-ratio (/ top-slots total-slots)
                                current-top-height (- split-y topmost-y)
                                target-top-height (int (* usable-height target-top-ratio))
                                height-diff (- target-top-height current-top-height)
                                resize-window (first (filter #(= (+ (second (:at %)) (second (:size %))) split-y) 
                                                             top-group))]
                            (when (and resize-window (< 2 (Math/abs height-diff)))
                              (hypr-cmd (str "dispatch resizewindowpixel "
                                             "0 " height-diff ",address:" (:address resize-window))))

                            (balance-column-heights top-group (inc depth))
                            (balance-column-heights bottom-group (inc depth))))))))

                (balance-all-columns [windows depth]
                  ;; First try to split into columns
                  (if-let [split-x (find-vertical-split windows)]
                    (let [left-col (filter #(< (first (:at %)) split-x) windows)
                          right-col (filter #(< split-x (first (:at %))) windows)]
                      (balance-all-columns left-col (inc depth))
                      (balance-all-columns right-col (inc depth)))
                    ;; No vertical split found, balance heights in this column
                    (balance-column-heights windows depth)))]

          (balance-all-columns clients 0))))

[vaxerski]

The proper solution is probably to not use dwindle. Maybe try hy3?