I’ve spent the last couple months trying out and tinkering with various tiling window managers. And I’ve learned some important things.
Tiling window managers are a type of window manager. However, instead of forcing you to open windows at one location and one size and moving and resizing them yourself, like more common floating WMs, tiling ones move and resize them for you. No window can be behind another. Linux’s multiple desktops make this feature especially handy. When I open a new window, my window manager automatically moves and resizes the existing windows on my screen to make room for my new window. No dragging, no clicking, and no empty space. It makes the screen of my very small netbook seem perfectly adequate for heavy-duty use.
There are two kinds of tiling window managers: dynamic and manual. Dynamic ones do this tiling behavior right out of the box, according to some algorithm. I tend to favor those, largely because I’m a lazy bum. 🙂 Dynamic tiling window managers generally use a master-slave system, where a set number of windows (generally one) takes up the larger master area in the screen, and the smaller slave area gets divided amongst the other open windows in some algorithm. In the screenshot, Chromium is in the master area.
Manual ones, on the other hand, allow the user to specify the size and location of windows on the screen. They still tile, but in a user-chosen pattern (as opposed to in a given algorithm). I could, say, decide that the upper 40% of my screen only has Chromium in it, and the lower half of my screen is divided horizontally, with the left 20% a terminal and the right 80% blank until further notice. Like window managers in general, to each his own.
I’ve tried quite a few dynamic window managers. The beauty of Linux is that you have so many options; I wanted to find just the perfect one (for my admittedly eclectic, picky tastes). Eventually, I discovered that I wanted, in order of importance: a lightweight dynamic tiling window manager, with a lightweight statusbar, allowing the newest window to be a slave instead of a master, with per-tag layouts.
After just a bit of research into the tiling WM concept, one quickly learns that many of them reference DWM, dynamic window manager. With a stated intent of remaining within 2000 lines of code, it’s pretty lightweight. Configuration is done in a C header file, config.h. The only way to enable that configuration is to recompile the code. Doing so is fairly simple on Arch Linux, a simple “makepkg -efi”. DWM also has a very active userbase and a multitude of useful patches. I personally used attachaside (makes new windows slaves instead of masters), pertag (allows setting individual layouts per screen; doesn’t always play well with other patches), fibonnacci (a layout algorithm), and grid (another layout algorithm). many smaller tiling WMs were based off of DWM and some combination of its patches. DWM comes with its own statusbar, which displays window and desktop information and can show additional information using xsetroot.
Another one is Awesome. I used it for quite a long time. Although it was originally based on DWM, it’s now been rewritten in the Lua scripting language. It’s extremely customizable, due in large part to its configuration file. Now, that can be overwhelming. Instead of a regular line-by-line configuration, it’s actually a long rc.lua of actual Lua code, executed by the program. I’ve broken it many times by using improper syntax. However, lua isn’t incredibly hard to learn, and using rc.lua allows Awesome to be incredibly tweakable. It comes with an optional statusbar, which can be populated with just about anything, along with configurable keybinds, several layout algorithms used per-tag, master-slave adjustments, and many many options. Frustratingly, Awesome also has a tendency to change configuration syntax with major updates, forcing a partial rewrite of the configuration file. Documentation tends to be slim as well, or is only in reference to previous versions. Also, Awesome is not quite as lightweight as most other tiling window managers available on Linux.
Echinus is another DWM lovechild. However, it’s configured in a text .Xresources-like manner, and does not require recompilation to enable changes in its configuration file. It also is one of the few tiling window managers that is EWMH compliant, which means that many popular taskbars can be used with it. For example, Fbpanel works beautifully with Echinus. One thing that bothered me about it was that it has no option to open windows as slaves instead of masters, but a quick one-line change to the source code and a recompilation solved that. It allows per-tag layouts.
But recently, I’ve found my favorite. MonsterWM is a relatively new window manager, based on DWM with several differences. The pertag and attachaside patches are there by default, though attachside can be changed. The configuration file is still config.h with recompilation, but that’s no problem at all. It doesn’t come with its own statusbar, but it does output parseable information that can be used in a statusbar; I do so with dzen2, and I also pipe other information into dzen2 as well. Layout patches can be added as well, though I haven’t used them; I’m happy with the default tile layout. Development is ongoing and very active, and I haven’t had a single thing to complain about it. It’s also incredibly lightweight.
I’m constantly trying out new window managers, but right now I’m very happy with MonsterWM.