Tux Training

An Introduction to Tiling Window Managers

October 20, 2008, 8:48 am

In computing, a tiling window manager is a window manager with an organization of the screen into mutually non-overlapping frames, as opposed to the more popular approach of coordinate-based stacking of overlapping objects (windows) that tries to fully emulate the desktop metaphor.

There are many TWMs to chose from, below covers the most popular ones around.

DWM

dwm is a minimalist dynamic tiling window manager for X11. It is externally similar to wmii, but internally much simpler. dwm is written purely in C and, for simplicity, lacks any configuration interface besides editing the source code. One of the project’s guidelines is that the source code will never exceed 2000 lines, and options meant to be user-configurable are all contained in a single header file.

An interesting feature of dwm is that it optionally displays its STDIN in a status bar at the top of the screen. This is often used to show information that would appear in the notification area of other desktop environments – a clock, system load info, laptop battery and network status, music player information and the like, by piping text in from dwm’s parent process (usually an .xsession script.) This status line is often complemented with dmenu, a textual application launcher from the same developer as dwm.

dwm has some properties that may be considered drawbacks by users of more conventional window-management systems:

No configuration files; display properties can only be changed by editing the source code and recompiling the executable
Click-to-focus model not supported; rather, it uses a combination of focus-follows-mouse and keyboard focus switch
Does not display a window titlebar, or support the conventional click/drag method of moving or resizing windows. The MOD key must be held down, requiring two hands.

wmii

wmii is a dynamic tiling window manager for X11. It supports classic and dynamic window management with extended keyboard, mouse, and filesystem based remote control. It replaces the workspace paradigm with a new tagging approach.

Its minimalist philosophy attempts to not exceed 10,000 lines of code (including all shipped utilities and libraries), to enforce simplicity and clarity.

In its default configuration, wmii’s interface is similar to that of the Vi text editor; you control the windows with H,J,K,L and combine them with either Alt or Alt+Shift. However, the window manager offers extensive configuration through a virtual filesystem similar to that offered by Plan 9 from Bell Labs. Every window, tag, and column is represented in the virtual filesystem, and windows are controlled by manipulating their file objects. If plan9port is found in the user’s machine, wmii can be configured directly using the plan9port tools and the rc scripting language; otherwise, wmii can be scripted via the wmiir utility, which interfaces with the aforementioned virtual filesystem.

Like the similar dwm, wmii is initially configured to use dmenu for program launching, and supports quick access to custom scripts located in a subdirectory of the user’s home directory.

xmonad

xmonad is a tiling window manager for the X Window System, written in the functional programming language Haskell.

Begun in March 2007, it is similar to dwm, larswm, StumpWM and other members of the tiling window manager family, in that it strives to make it possible for the user to productively manage windows without the use of the mouse. Xmonad is packaged & distributed on a wide range of Unix-like operating systems.

While originally a clone of dwm (derivative in areas such as default keybindings), xmonad supports features not available to dwm users such as per-workspace layout, tiling reflection, state preservation, layout mirroring, GNOME support and per-screen status bars; it can be customised by modifying an external configuration file and ‘reloaded’ while running. XMonad features have begun to influence other tiling window managers – dwm has borrowed “urgency hooks” from XMonad, has also included Xinerama support (for multihead displays) with release 4.8, and reimplemented XMonad’s Fibonacci layout.

Extensions to the core system, including emulation of other window managers and unusual layout algorithms, such as window tiling based on the Fibonacci spiral, have been implemented by the active community and are available as a library.

In addition to obviating the need for the mouse, the xmonad developers make heavy use of semi-formal methods and program derivation for improving reliability and enabling a total line of code count less than 1200, as of version 0.7; window manager properties (such as the behavior of window focus) are checked through use of QuickCheck. This emphasis makes xmonad unusual in a number of ways; besides being the first window manager written in Haskell, it is also the first to use the zipper data structure for automatically managing focus, and its core has been proven to be safe with respect to pattern matches, contributing further to reliability. The developers write:

“xmonad is a tiling window manager for the X Window system, implemented, configured and dynamically extensible in Haskell. This demonstration presents the case that software dominated by side effects can be developed with the precision and efficiency we expect from Haskell by utilising purely functional data structures, an expressive type system, extended static checking and property- based testing. In addition, we describe the use of Haskell as an application configuration and extension language.”

It makes use of Haskell features and tools such as: QuickCheck, GHC extensions like pattern guards, monads, monad transformers, zippers, and the Cabal packaging system, in addition to Haskell bindings to Xlib and xft fonts (with rebinding to XCB planned when the Haskell bindings are released).

awesome

awesome is a dynamic window manager for the X Window System. Its development began in September 2007 as a fork of dwm. It aims at being extremely small and fast and supports multiple layouts such as floating, tiling, and maximized. Like many other tiling window managers, it strives to make it possible for the user to productively manage windows without the use of the mouse.

The 3.0 version, released September 18, 2008, uses the XCB library to communicate with the X server, making awesome the first window manager to use this library instead of Xlib. It also supports the pango markup language, and D-Bus for communication.

Awesome currently features:

Multiple and per screen status bars, including a variety of widgets (text and icon boxes, graphs, progress bars, and so on).
Zero mouse dependency. Keyboard accelerated desktop environment.
Multihead support (XRandR, Xinerama or Zaphod mode).
EWMH support.
Real transparency support (using Composite extension and xcompmgr).
Customized entirely through editing a configuration file.
Each function for manipulating the environment is bindable to keys/ mouse buttons and executable remotely via a socket (awesome-client).

Ion

Ion was written as an experiment on a different kind of window management model. It tries to address the navigation problem by dividing the screen into mutually non-overlapping frames that take up the whole screen. Big displays have so much space that this should be convenient and smaller displays couldn’t show more than one window at a time anyway. The frame layout is, of course, dynamic and different on each workspace. Given the organized tree based instead of an unorganised coordinate-based frame layout, moving between the frames can be conveniently done from the keyboard. As in PWM, the frames may have multiple clients attached, each indicated with a tab.

While this model makes using well-designed and well-behaving programs a joy, some applications, obviously, don’t work well in this model. These are in particular those applications that do not conform to the ICCCM (Inter-Client Communications Conventions Manual; the standard on how WM:s and applications should communicate) and expect a particular window management model. Badly-designed applications with multiple top-level windows that affect a single document are also not particularly well suited to the Ion model and should be fixed, although can be occasionally kludged to be compatible. Below is a summary of Ion features

Tiled workspaces with tabbed frames, as discussed above.
Designed to be primarily used from the keyboard.
Fully documented configuration and scripting interface on top of the lightweight Lua extension language.
Modular design. The main binary implements only basic window manager functionality. Additional modules implement extra features and window management policies.
The query module implements a line editor similar to mini buffers in many text editors. It is used to implement many different queries with tab-completion support: show manual page, run program, open SSH session, view file, goto named client window or workspace, etc. Menus are also displayed as queries.
A statusbar that adapts to the tilings, taking only the space it really needs, modulo constraints of the layout. The statusbar can also be configured to swallow other (small) windows, and does so automatically for Window Maker protocol dockapps, and KDE-protocol system tray icons.
Full screen client windows are seen as workspaces on their own. It is possible to switch to a normal workspace while keeping several client windows in full screen state and also switch clients that do not themselves support full screen mode to this state.
The scratchpad module provides a conveniently toggleable area for random tasks, akin to the consoles of many FPS games.
To run those particularly badly behaving programs, Ion also supports floating windows of the PWM flavour. These can be had as separate workspaces without an underlying tiling, or floating on top of a tiling. Tiled windows can be detached to float, and reattached.