Floating and tiling window managers
In the X Window System, the window manager is that piece of software that places
your windows and allows you to move them, resize them, hide them, etc. If your windows
have titles on top of them, with buttons to close them or reduce them, it is thanks to
the window manager. There are two major types of window managers:
- Floating window managers
- They are the most usual window managers, that allow you to place
an size your windows freely on the screen, in a way where they are
independent of each other, possibly overlapping, just as you would
be able to place sheets of paper on your desk.
- Tiling window managers
- They are a more elitist type of window manager, that adjust the
size and position of the windows so there is no overlapping and no
space lost between windows, thus tiling the screen.
Floating window management
Tiling window management
The frontier between these two types is not very tight, because some
floating window managers have limited tiling features, and almost all
the tiling window manager have floating modes for programs that are not
adapted to tiling.
For what it is worth, here is a report on my experience with three tiling window
managers. Perhaps it may help people that are still hesitating to switch to tiling
window management?Using tiling window managers
Five years ago I switched to tiling window management, feeling that
managing windows was the window manager's job (a quote from larswm).
At that time, I started using wmii
, then switched to awesome
, and now I am
wmii: three columns, first one
awesome: fair layout
i3: three containers, second one
stacked, third one tabbed
For people in a hurry, here is a comparative table:
| ||wmii ||awesome ||i3|
||any language, 9P-based
||any language, socket-based|
||flexible, manual tiling-based|
notification area, dock windows
- tag-based workspace system
convention to locate the config file
- real framework for customization
is a rather
minimalist window manager which used to be part of the suckless
project, but is now hosted
at Google Code and seems to have lost all its documentation during the
move (why is it that all the software I have seen hosted at Google Code
or worst, at Launchpad, have almost not documentation, and never, ever a
It uses a column-based layout:
you place windows in a number
of columns, and for each column you can choose either vertical split,
stacking or full column mode. This system is very simple to control
flexible enough for most situations, but it does not allow for arbitrary
It is fully scriptable in any language,
in an interesting
way: it exposes all its functions on a 9P virtual filesystem. In fact,
wmii itself only implements window management functions, and all the
user interaction logic takes place in a distinct script which calls that
functions using that 9P filesystem. wmii comes with a default script,
written in shell, which makes it a bit hard to extend, and slow if you
start calling external programs such as grep, sed and co. You can script
it in any language you like however, and there are some already made
implementations in Ruby and Python IIRC.
A special feature of wmii is that its workspaces are in fact
and that you can tag a window so that it will appear in
several ones. While this is interesting, in practice I did not find much
use for that feature.
It is explicitly minimalist, and the developers used to impose
themselves a limit on its numbers of lines of codes (not sure if this is
still true with the switch to Google Code). While I was using it, it had
no notification area, no support for
fonts and it sucked with multiple monitors, which is the reason I
switched to awesome.
is a very
flexible window manager that provides advanced automatic layouts. It has
become quite popular, and it has a very well documented wiki. It is not
officially a tiling window manager but a framework window manager, and
to emphasize on that it start in floating mode by default. I think most
people use it in tiling mode however.
It uses automatic layouts,
that place your windows according
to rules, for instance the fair layout, which tiles in columns and
rows so that each window occupies a similar space. Thanks to that
automation, this system is very easy to control and to get used to, and
although it certainly does not allow arbitrary tiling, you can cycle
between several available layouts which are suitable for most
situations (most of them are entirely automatic, but some have
parameters you can modify, such as the number and width of columns), and
if you miss one, I think you can even code your own.
It is fully scriptable using the Lua language.
In fact, just
as wmii, the user interaction logic is defined in the configuration
file, which allows efficient customization. The Lua API is fully
documented, and there is a series of useful libraries to extend the
basic configuration in any way you like, which is why awesome calls
itself a framework window manager .
It is not designed to be minimalist, and it implements some
such as using XCB
rather than Xlib, a
notification area, and specific support for dock or utility-type windows
such as GIMP's tools.
is a window manager inspired by
wmii, although they do not have much in common in my opinion. for what I
have seen, I think it would be closer the defunct Ion.
It uses a layout based on manual splitting: as you open windows you
can choose to split an existing window either vertically or
horizontally, leading to arbitrarily complex layouts. In addition to
that you can tab or stack windows in containers instead of splitting
them. This system is very flexible but it requires more user
In its standard mode of operation, i3 is simply configured in a
regular way, which allows to customize the user interaction but not to
script it in an arbitrary way. It offers an IPC system that can be used
for that however, by the mean of a Unix socket, so it can actually be
scripted in any language too if needed, although this possibility is
probably not as popular and easy as with wmii and awesome.
It implements modern features such as XCB
a notification area and a
powerful status bar that uses the standard output of a dedicated program
that is easy to replace by your own if you need.