Tiling window managers

(repost from https://coolvibe.org/posts/tiling-window-managers/ )

Window manager and desktop environments. If you run a Unix-like desktop, you probably use them. Most people just use what comes with their distribution. They either run Cinnamon, GNOME or maybe even KDE/Plasma.

That's fine. But I am a tinkerer, and I'll be damned if I won't tinker.

I do like KDE, but it is a big piece of bloat. So is GNOME. So is Cinnamon. Not that they are bad environments to work in, but they aren't really efficient. They have swathes of code that isn't even used a lot. I would be
surprised if there wasn't a whole damn heap of dead code in those projects.

So, since I do like efficient and small programs that do a lot, I broke away from the big desktop environments. Since I mostly live on the commandline anyway, I ventured to find or build an environment that lets me do everything I
did before, but without all the fluff and bloat that the big desktop environments brought along.

I didn't take long to find the small window managers like Windowmaker, fvwm, twm and other old hands I used in the past. But they were just that. Old. Done that before. I know how they work (or I remembered, hehe). That didn't really tickle my fancy. Also, the old favourites don't handle multiple monitors well, and I would venture that the new desktop environments don't either.

So, what was I after?

Multiscreen sanity

One thing that has always irritated me is where modern desktop environments place windows when I start programs. It always starts on the screen where I don't want it. Even bloody Windows does this.

One type of window managers that does it right, or at least consistently, are tiling window managers. Where your mouse pointer is, that's where your window will be. And if it's still in the wrong place, then a quick keyboard shortcut will set it right.

Keyboard Cowboy

I live mainly on the command-line. My routine behind a computer mainly revolves around dealing with either text input or output. As the screenshot above hints, I usually have tons of terminals open. Even more starkly, to get work done, the only things I really need is a terminal with a shell, and a webbrowser. If I have those, I can pretty much do anything.

You might ask me: "Why run a graphical shell at all?", well video sucks on the console, and a graphical subsystem is really handy to display lots of terminals on the screen, in several ways.

Tiling window managers also emphasise keyboard use. You don't go for the mouse that much. I don't care either way, but folks dealing with carpal tunnel might find that interesting

Light weight

Simple window managers are the opposite of bloat. They don't have a gazillion processes and threads running in the background. Many of them actually are single threaded. It's telling that the thing that composits and manages window has a larger memory footprint than the graphical subsystem it's running on.

The trials

I tried several window managers, and yes, as the title suggest, I did try a couple of tiling ones.

awesomewm: https://awesomewm.org/

I really liked awesomewm. But the lua-config kinda put me off. Although I think lua is nice and embeddable, I don't find it pleasant to write code in. I spent about a week in awesomewm, but I was also actively looking for something else. But my appetite was wet.

I did tinker with the config a bit, but eventually went with something I found on github: https://github.com/lcpz/awesome-copycats

It's a nice ricey bunch of themes, but it wasn't mine.

Suckless DWM: https://dwm.suckless.org/

DWM is a bit of an odd one. I wanted to try it because it is what awesomewm was based on. What piqued my interest is that you configure this window manager with C. Yes, C. C is one of the languages I did cut my teeth on, and DWM has given me plenty of nostalgia, both good and bad.

You change a header file, and recompile the whole window manager again. This sounds hairy, but since DWM is really, REALLY small (< 2000 lines of code by default), it's actually quite quick and painless. It comes with a makefile, so the workflow is:

1. Change code
2. run make
3. fix eventual breakages, rollback fubars
4. run sudo make install

And it's done. Create a git repository beforehand and import it, and you have a surefire way to rollback (if you remember to commit and push your changes). Speaking of git repository, mine can be found on github here: https://github.com/ekollof/mydwm.

I even made a statusline/bar thingy for it in python. Enjoy.

DWM has downsides though. Because it is so minimal, forget having window state. Restart DWM, and all your windows jump to your primary screen and all your tags are gone. If you want it to keep state, you would have to code that in yourself. I personally would be interested in that patch ;)

Qtile: http://www.qtile.org/

I'm playing with this one at the moment. What I find interesting is that the entire window manager is made in Python. I do a lot in Python, so that's right up my alley. I'm still getting my setup sorted out and getting to grips with it's features, so no judgement on this one yet, other than that what I've got now is pretty functional.

UPDATE: My current Qtile setup looks like this:

Conclusion

Yeah, tiling window managers are pretty nifty, if you can wrap your brain around them. I personally have been enjoying the experience. If you live mostly inside a terminal, you should definitely give a tiling window a try. But don't go by my list. Go out and explore. :)