Sometime ago I
said that I intend to move from
GNOME to an alternative, keyboard-centric tiling WM (Window Manager). Any such change requires some getting used to. Any such WM has its own philosophy regarding both its users and what it means to manage windows. Each of these WMs has its own set of default key bindings and different methods of configuration. That's the problem with freedom: one has to choose.
In my case I find that I'm most comfortable when every application window that I use is maximized to span most of the screen area. Sometimes I split the screen between two applications windows, usually horizontally. I also want (but I don't need) a simple status bar at the top of the screen, showing (at least) the name of the active window, some info (date/clock, load average) and maybe tray icons. Oh, and I want to still be able to run applications in floating-windows mode just like any other (read: normal) WM (
the GIMP is probably the ultimate test here).
I attempted to get this behavior in GNOME using
Devil's Pie - a cool little WM-like utility that lets you control window behavior using lisp-like scripts. For example, I made
urxvt always open up maximized, without any window decorations, using the following Devil's Pie script
~/.devilspie/urxvt.ds :
(if (is
(window_class)
"URxvt")
(begin
(maximize)
(undecorate)
(focus)))
But don't be misled by the appearance of this
.ds script: this is not a real programming language (no loops, no functions, no variables). Furthermore, Devil's Pie does not manage windows - it only serves as a startup hook that's applied to windows upon being first displayed. This just wasn't good enough for me.
This is actually my second round of WM evaluation. Last time was almost 3 years ago, at work - I was in a process of reinventing my work environment. Heck, I even tried using
vim for two weeks (definitely not for me, thank you very much :q!). Eventually, I narrowed down my options to
larswm,
ion3,
ratpoison and
wmii. I ended up running an early release of
ion3, heavily customized to do my bidding, together with a custom keyboard setup.
This time around I was shopping for a WM for my old laptop at home. I wasn't going to try
ion3 - it's not in Debian testing, and may never be, due to its
moronic non-free license. It was the most polished and stable WM of its kind, at the time. But there are better options these days. Plus, I was looking for a setup that would work almost out of the box, with little or no customization. I just couldn't stand the frustration of re-customizing my setup after each major release of the WM (I solved the problem at work by not upgrading
ion3, can you believe?).
So I started using
ratpoison at home, even though I knew it does not support floating windows, because, apart for that, it seemed to fit my usage patterns like a glove. I hit a dead-end though when I tried running some Window$ applications using
Wine - there were some serious issues there (e.g. I could not select multiple files in the Window$ standard file-open dialog box). And, as much as I pretended not to, I really did need the WM to support floating windows. I simply had to switch over to a different WM.
I tried
stumpwm, which is written in
Common Lisp, by the same guy who wrote
ratpoison, based on the same concepts. So cool. So flexible. And oh so very slow. It takes almost two minutes (!) for it to load on my old laptop. Not cool. Ah, and it does not support floating windows.
This meant one thing: I had to leave the comfort of static tiling WMs and go dynamic. With a static tiling WM, like
ion3,
ratpoison and
stumpwm, you can arrange window layouts in advance, and place and move windows from one part of the layout to the other. A dynamic tiling WM arranges windows on its own, based on one or more layout algorithms.
I considered
wmii: I tried it several times in the past, and was impressed by the underlying architecture and concepts (window tagging, floating layer, etc.). I was, however, repeatedly put off by its instability. I believe I sampled v2.5, v3.2 and v3.5, but I have no records to prove this. To be fair, it's been a while, so maybe things are better now. I decided to skip it anyway.
I tried
dwm when it first came out. It was written by
wmii's original author, after he got fed up with its complexity. It was very easy to pick up, very minimal, fast - quite cool. Well, not really -
dwm can only be configured by editing its C source code and recompiling it. While it can be argued that this isn't too different than writing
Lua scripts for
ion3, it still feels wrong. Add to that the author's little fetish: one of his major goals is to pack the WM into as few lines of source code as he possibly can. I never bothered to follow its development. Next.
How about
XMonad? it's written and configured in
Haskell, which I don't grok. For a while, after it came out, it looked like The Great White Hope of tiling WMs: a lively, fun project, with a lot of features planned for the future, no ties to existing code, with some great coders hacking it, an ever growing number of contributed extensions, and a core code-base that is provably correct. It also seemed like a good opportunity for me to get into Haskell - I've been hearing about it all over the 'Net, and I wanted to see what the fuss is about.
It must be said that XMonad requires very little Haskell in order to get up and running, but in my mind using this WM meant getting knee-deep into Haskell. But between a day job, a growing family and this blog, it soon started to look daunting - I decided I should probably see what else is out there, dismiss the other WMs, go back to XMonad, and then put effort into it. I figured that by then it would mature and that its support for floating windows would improve.
Enter
awesome - it started as a fork of
dwm, but soon became a completely different WM. It has built-in, proper support for floating windows, built-in status bar, a simple configuration file (the upcoming version 3 has switched to Lua scripts),
wmii-style window tagging system, built-in support for
Xinerama (which I don't use) and a lot more. While the authors of most of the other tiling WMs attempt to achieve some form of technical purity, the stated goal of
awesome is for it to simply be an awesome WM.
And it's on the right path.
During the first few days of using it (version 2.2) I would hide the status bar and work in max-mode - the effect was very similar to my
ratpoison experience. I then started using the status bar, and configured some rules for window tagging and keyboard shortcuts, to support my usage patterns.
It's the only WM of the pack that supports anti-aliased fonts, via the
Pango text layout and rendering library (since version 2.3). Pango also provides bi-directional text rendering - so that window titles are correctly rendered, even if Hebrew text is included.
Version 3 will include some major changes - Lua for extension scripting, status bar enhancements (tray icons!), tabbed windows and a lot of internal changes that suggest that
awesome will be even more awesome than it already is.
So
awesome is my WM of choice for the foreseeable future. As for Haskell - well, it seems that I need a different excuse for learning it.
