Linux: Tiling Window Managers

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.

Tagged , , , , , ,

4 thoughts on “Linux: Tiling Window Managers

  1. tPenguinLTG says:

    This post is almost a year old, but that’s no reason for me to comment on it.

    dwm is very popular, but I prefer wmii, the WM from which dwm drew inspiration, also developed by suckless. I find it much easier to use than dwm, especially being a Vim user (the default keybindings are based on those in vi).
    It’s too bad almost all of the developers flocked to dwm, though. There are features slated for wmii-4 that sound quite appealing. Having said that, wmii-3 works very well and wouldn’t really suffer from not being updated.
    I’d love to use a window-tiling solution for Windows like bug.n, but with all the stuff I have on here, it would probably break something. The closest thing I have is WindowPad.

  2. Maybe also Wingo would interest you, it’s quite new and written in Go, with good config options but stable and not overwhelming, and a good mix of manual and dynamic.

  3. schillingklaus says:

    I dislike dynamic window management, graphical elements whatsoever, and especially the mouse; ergo, I use Ratpoison instead.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: