A tiling window manager written in Rust

Sounds like my exact setup, except I use Conkeror as a browser (it's an Emacs-like UI on Firefox's engine). I also use Xmonad as my (tiling) window manager, even though I usually cycle through fullscreen windows on various desktops, as you say.

I'll second using Emacs as the primary graphical shell. It shouldn't really be surprising that it's good for that task, since the interface is (or so it seems to me) heavily influenced by Genera's X interface. If Emacs let you display an external program such as Firefox in a buffer, I'd as well do away with Openbox and just run Emacs.

And xfwm4 has a great plug-in/patch available that enables tiling!

To add a little consensus, this is almost my exact setup too, though I'm on OS X and use Chrome for browsing.

As well as using C-x 2 and C-x 3, I've started using perspective.el (https://github.com/nex3/perspective-el), which means I can switch between different projects each with their own buffer set and window configuration, as well as switch to an IRC perspective. It's such a well-executed extension, definitely recommend it if you've never tried it.

Tiling for Emacs: http://www.emacswiki.org/emacs/tiling.el

(I use it rather rarely, because I have a small screen and generally have no more than 3 windows open at the same time; I jump between Emacs' "workspaces" with help of Elscreen)

OTOH I use urxvt with tmux for most command line stuff because it works better with zsh completions and colors and such. So I have three WM-level windows open (on separate virtual desktops, each maximized): urxvt, chrome and emacs with urxvt and emacs being further split into windows organized in a tiling manner. Works great for me :)

I do this too, with workspaces on OS X and Windows (using VirtuaWin on Windows). Was always on a tiling wm on Linux before I switched to OS X (and now using Windows too a bunch), don't really miss them that much any more after starting to use emacs + evil.

shrug I've heard this argument many times, but this is clearly a different strokes situation.

I set my window layout up once at the start of a multi-hour working session. Most of the time, that's either 1) a large MacVim window and a terminal or 2) that plus a browser. It takes ~10 seconds to get it how I like it. After that, cmd+tab works just fine.

Even on my 27" display, I usually prefer to have a little overlap where all three windows rest in such a way as to permit the most relevant bits to be visible simultaneously, while allowing for overall larger space when an individual app is focused. Tiling window managers tend to distort windows to less than ideal proportions, as they strictly eliminate overlap. That said, I utilize splits (ie tiling) within vim to great extent.

I've never worked in a situation where I could use a tiling window manager (OS X here), but I've always wondered how that's supposed to work when my normal workflow involves opening and closing a lot of windows. Especially terminal windows. I open throwaway terminal windows all the time, and then close them if I'm done with them, or keep them open behind my other windows if they have some information in them I need to reference later.

Often when I'm done working, I end up closing perhaps a dozen scratch terminal windows.

I find keyboard-driven grid-based window flingers to be Good Enough.

On OS X, that's SizeUp (or Divvy, ...) with a custom grid to suit my screen and then I never have to use the mouse to move/resize windows.

Agreed in concept, but you can get similar if not greater productivity gains from stacking/floating WMs that let you move and resize windows into a tiling-like configuration. Examples are goomwwm and subtle.

This "manual tiling" approach is also probably the only viable option for tiling-like window management on OS X. While not nearly as powerful or productivity-promoting as the above-mentioned WMs or conventional tiling ones, the OS X program Spectacle (http://spectacleapp.com) makes life a lot easier on OS X for those of us who are used to the screen real estate and keyboard control afforded by tiling WMs.

Edit: Another commenter mentioned the non-free Optimal Layout (http://most-advantageous.com/optimal-layout) for OS X. I haven't downloaded the trial yet, but the website makes it look very promising.

I find that "follow mouse" mode helps alleviate this pain a lot: when you can interact with a window (mouse or keyboard) without having to bring that window in the foreground, you end up moving windows around a lot less.

I like tiling in general but doing it well requires a big monitor.

I thought OSX autosized everything. I have never used it personally.

I just use Slate to snap window to left or right. It's not quite like tilting wm but it works quite well. I have no problem with it. And I do use Emacs, so there wouldn't any problem of splitting with those either. The only thing I miss from tilting wm is its minimal an simplicity. I used to use arch linux with dwm, configuring, patching creating shortcut just take a few line of code here and there, love it :)

My issue with tiling WMs is that there just isn't enough room. I use vim splits in a full-screen terminal but can only fit 2 columns comfortably. I can pull off 3 but then I can't see the full 80 characters in each.

I use i3 and I love it. You can steal from my config if you like:

https://github.com/SirCmpwn/dotfiles/blob/master/i3/config

I use awesomeWM, http://awesome.naquadah.org/, we have about 10 converts in our office now. It seems to be fairly well documented and has plenty of addons to make it look better (although I use just the bare minimum).

I just wish I could find a decent tilinging manager for OS X (divvy and amethyst do not fit my requirements)

I'm running i3wm.

I wouldn't consider myself an expert and found the change (I'm otherwise a Gnome kind of guy) easy enough. Is there anything specific you have trouble with?

I was in a similar situation and ended happy with bspwm beacause it's very minimal and simple to figure out.

i3 is pretty easy to learn and configure I'd say having dabbled with most of the popular window managers bar Xmonad. Nowadays I just use the Xfce window manager.

I'm a fan of i3wm. It has fairly good documentation (I learned it on my own, primarily from the documentation), and a relatively active irc channel.

The nicest things about a tiling manager? You can control nearly everything from the keyboard. It's very quick and easy to set up side-by-side windows (or side/top-bottom, and so on), and resizing one automatically resizes the other. It really helps on smaller screens, since by default everything is full screen with minimal window decoration.

Some nice features of i3wm in particular - well developed manual control, most layouts can be expressed as the composition of simpler layouts, and the config file is just a config file, not a full fledged program.

Also, it's worth remembering that on Linux you can have multiple WMs installed at the same time. You can log in to i3wm, and if there's something you really can't figure out, you can log out and switch to gnome/kde/etc. I don't know if there's a way to switch WMs without shutting down the whole x session though. Would be interested to know if it's possible.

I use I3 and highly recommend it. I used to use Awesome - i3 has felt much easier to work with and configure. The docs are pretty good.

I can't go back to a non-tiling manager now!

I used to use xmonad, but ditched it because it wasn't working well with Android Studio. I read somewhere that other tiling window managers have problems to display Android Studio under some video drivers.

Now I'm back to the default window manager of xfce4, which is ok since I tend to use only emacs and a browser, so I have have one workspace for each.

It took me an evening to get fully switched to i3wm. It's simple, and fast, and easy to understand and configure.

I use i3 since about two months.

I got same issues like you and here's my advice: install i3 and try to use it, after 2-3 days you'll be able to move windows, switch them or run apps with only keyboard (keybindings are pretty intuitive, but you need to try). Don't try to use it for every task or force yourself to use only it - I hate it when have to deal with some windows apps in wine, which are opening alerts and windows like shit, and then simply switch to gnome or sth. Don't try to customize everything at once, but rather slowly find your real needs and google around how to make your system your best tool.

I've been using them on and off, and the first thing I'd like to mention is that they're in no way magical -- both when it comes to using them (which is mostly knowing a few shortcuts and internalizing the layout system), but also in regard to how much they help you.

Sure, they certainly do look snazzy, especially when coupled with the movie hacker-approved unified dark color scheme. New windows pop up and quickly assume their rightful space and everything just looks so darn tidy.

But for certain usage patterns, that doesn't get you a lot. Even if you're popping up disposable shell windows left and right, you might also do that within screen/tmux, where the window manager doesn't come into play at all (or have some drop-down quake-like console). Also, your running applications and especially their different configurations might not change that often, in which case you're really saving yourself some manual layout fiddling once. So a lot of people would perform pretty much the same with just alt-tab window cycling and virtual desktops (which seem orthogonal to the whole deal).

I mean, if you look at the vast majority of screenshots, you don't even see that much work. The obligatory IRC client, fake-GUI music players and/or file managers and probably an editor with the configuration file or some minor coursework open. It's not exactly Scotty and his Mac Plus.

Having said that, I'd add my vote to i3wm, as it isn't as ideologically pure as some others (you still have window titles if you want them, and the layout remains somewhat manual). Plus a rather readable configuration format, even if the default configuration is seemingly intended to drive vi-users mad.

My alternative would be bspwm, the binary space partitioning wm. A lot more minimal, but the automatic layout algorithm is rather tractable and one certainly wouldn't be confused with too many options.

Same here, but I prefer a WM that supports (for want of a better term) "packing" 80 column wide Xterms and Emacs windows into the screen and doing static placement of things like Pidgin. The tiling WMs I've briefly looked at all seem to re-size windows to fill the available screen real estate; I'm old school and want my Xterms and Emacs windows to be 80 chars wide.

Are there any tiling WMs which support this layout style or can be easily configured to do so?

I use StumpWM, but it can be a real pain in the ass to get running and configured. I like that it has static layouts: you manually split the screen into panes and windows go in those panes, rather than everything resizing & shuffling whenever you open a terminal. I also really like the keybindings, which are by default all preceded by C-t, so you'd hit "C-t c" to open a new terminal--this avoids the whole "window manager ate all my alt-key combinations" problem you'll run into with i3 and a lot of other WMs. The problem is that it's Common Lisp, so the binary is huge and it takes a long time to start up, and sometimes it crashes in interesting ways. But on the other hand, it's Common Lisp, so you can connect to it from Emacs and play with the code... at least until you crash it.

I'm thinking about trying the new Guile window manager that popped up here a few days back, it looks like it has a StumpWM-esque style and maybe Guile is a little more light-weight/less flaky than most Common Lisp implementations.

I like i3 quite a bit. It was easy to pick up and a huge improvement over KDE for what I do. Especially on the laptop. The 3 second X startup is nice too. It did take a little work to get it set up and comfortable.

Do i3. It's one of the easiest to learn and the only way I was able to get into tiling window managers. I outgrew it when I got a 4K TV as it wasn't able to handle it well, but as others have said, it's "less pure" of a window manager. It's extremely dynamic, easy to move things around, and easy to resize. If you've used vim before it'll be even easier.

Mate... I will tell you that the one that I find have the easier learning curve is AwesomeWM.

The main advantage of it tho, is not the tiling window managing facilities... But the run-or-raise plugin.

It allows you to run (start) or raise (go to the window) of any application with an assigned shortcut.

Mine are: Mod+e - Emacs Mod+u - Browser (Conkeror) Mod+y - Browser (Chromium) Mod+k - Konsole Mod+. - Keepass Mod+x - Pidgin chat window Mod+i - Skype chat window

The choice of shortcuts may seen arbitrary, but I'm a Dvorak user and all the keys are easily accessible.

With this setup, from my editor I'm a Mod+u / Ctrl+g g to a search on google, and from there I'm a Mod+k from my terminal (from where I run tmux... ;P) and a Mod+e from Emacs.

I'm also using a dropdown terminal with another tmux where I have access, from any where on my system just pressing F1, to my MTA (mutt), file manager (mc), IRC (irssi), Music player (cmus) and a root shell.

Honestly... With this setup there is definetly no going back... Every thing on the tips of my fingers... Some shortcut away.

I almost feel part of the machine! :)

I thought tiling window managers were traditionally written in Haskell :-p

My understanding is that C++11 and eventually C++14 have plenty of modern language features. How does Rust compare?

The thing is, most languages can be used for writing a Window manager.

But since the alternatives to C and C++ kind of faded away from mainstream and they are anyway the UNIX system languages, most developers seldom look for alternatives.

With Rust, Go, D, Haskell, OCaml, .NET Native/Mono AOT, Java AOT compilers, hopefully developers will eventually realize that not everything needs to be coded in C or C++.

The first part is merely a rough setup. Tutorial is unfinished. At the moment I am writing my thesis, but I'll try to do a few parts over the holidays.

I think that's better to link to, instead of the code itself.

As for the xlib stuff, I can't really write tests for that. But I will write a more extensive test suite for the core components, especially the ones in src/core.rs

For the methods in window_manager.rs, they often depend on the window system, but that shouldn't be a problem as I could simply insert a dummy interface.

Tests will follow. Last weeks were just filled with thesis and preparations for my last exam. So I used the coding for relaxation and kinda omitted the tests. I know, I know...behaviour.

Except for 2 exceptions, only for interfacing with xlib, as the calls to rust-xlib involve raw pointers (because rust-xlib is just a plain c-binding wrapper around xlib).

The 2 exceptions are: loading of the config library. The config file is compiled to a dynamic lib at startup, and I need to read the symbol out of that library to access the configure function. The DynamicLibrary module is unfortunately unsafe. The second exception is in one of the default handler methods, managing the on-the-fly restart of the WM (akin to xmonad). This involves a call to execvp in the libc:: module, and therefore also unfortunately requiring an unsafe block (split into 2 unsafe block, for pointer handling and calling).

I agree, with the exception of to_string() and as_slice() all over the place when dealing with a lot of text.

If you want to see ugly code, you could look at the compiler's source code. A lot of code in it is clunky because it has evolved since Rust was a very young language, with gradual changes rather than full rewrites.

> Tell me, what does it bring to the table compared to other window managers ?

This kind of window managers are often coupled to a programming language and the end user is expected to modify the source to their liking. For example, dwm is written in C, Xmonad in Haskell, awesome in Lua and there's even ones written in Scheme and Common Lisp. In all of these, the idea is that the source code is the configuration, and you're expected to hack on it.

Of course there's some appeal in just doing it in another programming language, even if it has been done before. A tiling window manager is a few thousand lines of code, so it's a neatly sized practice project.

Writing a window manager in Rust is interesting precisely because it's written in Rust.

I wouldn't be surprised if this homebrewed WM didn't hold up in features or performance to alternatives like xmonad, dwm, Awesome, i3, etc.

However, the linked repo is an interesting way to showcase both a relatively new technology (Rust) and the innards of WMs, which most people don't look at very often. It gives non-Rust-users a glimpse into Rust's features and capabilities, and a glimpse at how simple (150 loc + 125 lines of config) a window manager can be.

I found it insightful.

What makes you think that it isn't already?

The web ecosystem in Rust is still very early. There have been some awesome efforts recently in pushing a full-featured http library [0] (Hyper is now powering Servo [1]). The web ecosystem can't expand fully without a strong http library and previously, an unmaintained rust-http was used.

The next issue, if we're talking about high-performance http is asynchronous I/O which Rust doesn't currently bundle with (now that Rust has dismantled it's green threading runtime and is now sticking with native threading). However, mio [2], a lower-level Rust library in providing proper I/O abstractions that support async apis and the like is progressing pretty well.

The awesome part about Rust is that you have full control over the system. This allows one to build something like mio even though Rust doesn't support async I/O or a more efficient threading model, etc...

[0]: https://github.com/hyperium/hyper [1]: https://github.com/servo/servo/pull/4198 [2]: https://github.com/carllerche/mio

That's just for testing.

Xephyr is just for testing. You can run wtftw completely standalone when you use it in your .xinitrc for example.

It's still a bit buggy though. Works perfectly fine here. Been using it as my default WM for 2 weeks straight now. But some bugs do seem to creep up on other machines.

Xephyr isn't a window manager. It's an X display server that runs inside a window on another host X server.

Author here. I am sorry about the confusion. It happened later in the project when I split it into 3 components (4 as soon as I add Wayland support). I should probably mention that in the Readme.

Thank you.

The triangle logo is the logo of Arch Linux distribution.