It's very lightweight and highly customizable. The configuration file is just a shell script of bspc (client) commands. It doesn't handle keybindings on its own, but leverages another awesome tool by the same author: https://github.com/baskerville/sxhkd
Which also simply calls bspc, but can be used for generic hotkeys as well.
It's just an awesomely simple pair of tools that work great, stay out of my way, are rock solid and well maintained. Pure gems of the open source world. Please consider donating to support the author: https://github.com/baskerville/bspwm/blob/master/doc/CONTRIB... (I have no affiliation, just a very happy user.)
This WM is the only thing besides habit keeping me from switching to Wayland. Though I guess I could get used to Sway.
Another feature I appreciate is that it does not bind any keys. It is left up to the user to implement. I get to choose which keys are used, and what they do. I wish all programs I used allowed me to configure their key bindings like this.
bspwm is less of a window manager in the traditional sense, and more of a tool that can be used to build your own window manager.
An example I've implemented for myself: When opening a single app in an empty workspace, by default bspwm stretches the window to fit the whole screen (as usual with tiling window managers). On big monitors, this can be pretty annoying (e.g. staring at the very upper left corner of your 32" monitor when using a terminal). Using bspc, I can listen to when new windows are added, inspect bspwm's state to see if the new window is in a workspace on its own, and then use bspc to adjust the margins on the workspace to make the window a more comfortable size in the center of the screen. Even in Python I can do this in ~100ms.
But it's a nice trick and I will fully admit it :)
Focus will still follow your mouse I believe.
The binary tree concept just is a way of sorting the windows such that the rotation is predictable regardless of tiling layout.
It's similar to bspwm.
- Both are controlled over a socket by a client program. Anything you can do to windows with a mouse or keyboard you can do with a script, and vice versa.
- The configuration for both is an rc file that's executed.
- Both are dynamic tiling managers, with a binary tree of containers.
- Both compare well to i3 by limiting the container tree to a binary tree, and eliminating keybindings to change container focus or move containers.
For examples of various window managers and accessories https://www.reddit.com/r/unixporn/
I don’t think dwm has them, they seem like a manual tiling thing.
I'm not the author of the video. I just remember watching this about a year ago and thinking it was the best resource I found to see what bspwm can do and how to use it. Highly recommend it (and watching it at 2x speed).
It's very comfy. The client is close to the shell, and you can have both automatic and manual tiling modes. When there is some feature you like that the author did not account for, you can query the state of the world in json and make decisions based on that.
A comment here mentions herbstluftwm, which came before BSPWM and I would even call a sister WM -- Baskerville even announced BSPWM on the Herbstluftwm mailing list when it was initially released. I would say BSPWM has less to think about than in the other window manager (everything is a node vs climbing frames with nested layouts). It can be thought of as a kit for building what you want, even. For instance, I use a tag-based workflow, where I toggle the hidden flag of nodes, and keep only one desktop.
WRT the windows being kept as nodes in a binary tree, this is useful because you can then climb the tree and perform balances and rotations within a subselection of the whole thing. You can also use the tree datastructure to enforce layout, like here, a DWM-like stacking layout.
With monocle mode, you can add fake padding for fullscreen windows, allowing you to have comfy fullscreen stuff that still accounts for a panel presence. With an external rules script, you can make decisions about what to do with windows as they appear, allowing dynamic layouts and decision making.
I'm sure at the end of the day, you can get what you need with any window manager if you drill far enough (year of the linux desktop is here, if you are willing to read the source). BSPWM has been a nice base for flexible workflow types for me. I will also share screenshots I've taken over the years here: https://notes.neeasade.net/rice.html (all bspwm past mid 2014).
Possible "correct" positions I can think of is: move a window to a different workspace (so not all are visible at the same time). Make a window floating (I often have a small terminal open that I shove into deadspace of another window).
2) It can serve as a selection pane. Half of the screen is devoted to the current window, While the other half (possibly sized to take up less than half the screen) is storing a bunch of windows to be swapped in for the current one.
(Let’s do this.)
Oh, and it wasn’t stable for me. That might be related to the prior comment, since I really don’t know Haskell at all.
Later I switched to i3 but kept using Haskell.
Even later, I mostly use Macs with a smattering of Debian with vanilla GNOME, so no Xmonad or any other tiling window manager. Still use Haskell.
Thus it's really easy to have layouts like accordion or other partially overlapping tiles, or having one big window in middle and the rest in circles around, or just adding a bit of flex based on preserving proportions.