Window manager

Related articles
Comparison of tiling window managers
Xdg-menu
xinit
From
Window manager
:
A window manager is
system software
that controls the placement and appearance of
windows
within a
windowing system
in a
graphical user interface
.
It can be part of a
desktop environment
or be used standalone.
Note
Window managers are unique to
Xorg
. The equivalent of window managers on
Wayland
are called
compositors
because they also act as
compositing window managers
.
Overview
Window managers are X clients that control the appearance and behaviour of the frames ("windows") where the various graphical applications are drawn. They determine the border, title bar, size, and ability to resize windows, and often provide other functionality such as reserved areas for sticking
dockapps
like
Window Maker
, or the ability to tab windows like
Fluxbox
. Some window managers are even bundled with simple utilities like menus to start programs or to configure the window manager itself.
The
Extended Window Manager Hints
specification is used to allow window managers to interact in standard ways with the server and the other clients.
Some window managers are developed as part of a more comprehensive
desktop environment
, usually allowing the other provided applications to better interact with each other, giving a more consistent experience to the user, complete with features like desktop icons, fonts, toolbars, wallpapers, or desktop widgets.
Other window managers are instead designed to be used
standalone
, giving the user complete freedom over the choice of the other applications to be used. This allows the user to create a more lightweight and customized environment, tailored to their own specific needs. "Extras" like an
application launcher
, a
file manager
, a
notification daemon
, a
taskbar
, a
wallpaper setter
, or desktop widgets, if needed, will have to be added with additional dedicated applications.
Some standalone window managers can be also used to replace the default window manager of a desktop environment, just like some desktop environment–oriented window managers can be used standalone too.
Prior to installing a window manager, a functional X server installation is required. See
Xorg
for detailed information.
Types
Stacking
(aka floating) window managers provide the traditional desktop metaphor used in commercial operating systems like Windows and macOS. Windows act like pieces of paper on a desk, and can be stacked on top of each other. For available Arch Wiki pages see
Category:Stacking window managers
.
Tiling
window managers "tile" the windows so that none are overlapping. They usually make very extensive use of key-bindings and have less (or no) reliance on the mouse. Tiling window managers may be manual, offer predefined layouts, or both. For available Arch Wiki pages see
Category:Tiling window managers
.
Dynamic
window managers can dynamically switch between tiling or floating window layout. For available Arch Wiki pages see
Category:Dynamic window managers
.
See
Comparison of tiling window managers
and
Wikipedia:Comparison of X window managers
for comparison of window managers.
List of window managers
Stacking window managers
2bwm
— Fast floating window manager, with the particularity of having 2 borders, written over the XCB library and derived from mcwm written by Michael Cardell. In 2bwm everything is accessible from the keyboard but a pointing device can be used for move, resize and raise/lower.
https://github.com/venam/2bwm
||
2bwm
AUR
9wm
— X11 window manager inspired by Plan 9's rio.
https://github.com/9wm/9wm
||
9wm
AUR
aewm++
— Minimal window manager based on aewm. It keeps aewm's minimalist look and feel but is written in C++, and adds some modern features like virtual desktops.
https://github.com/frankhale/aewmpp
||
aewm++
AUR
AfterStep
— Originally based on the look and feel of the NeXTStep interface, it provides end users with a consistent, clean, and elegant desktop. The goal of AfterStep development is to provide for flexibility of desktop configuration, improving aesthetics, and efficient use of system resources.
http://www.afterstep.org/
||
afterstep
AUR
berry
— Bite-sized window manager written in C. It is controlled via a command-line client, allowing users to control windows via a hotkey daemon such as
sxhkd
or expand functionality via shell scripts. It provides extensible theming options with double borders, title bars, and window text. Berry places new windows in unoccupied spaces and supports virtual desktops.
https://berrywm.org/
||
berry
AUR
Blackbox
— Fast, lightweight window manager for X, without all those annoying library dependencies. Blackbox is built with C++ and contains completely original code (even though the graphics implementation is similar to that of WindowMaker).
https://github.com/bbidulock/blackboxwm
||
blackbox
Compiz
— OpenGL compositing manager that uses GLX_EXT_texture_from_pixmap for binding redirected top-level windows to texture objects. It has a flexible plug-in system and is designed to run well on most graphics hardware.
https://launchpad.net/compiz
|| 0.9:
compiz
AUR
, 0.8:
compiz-core
AUR
CTWM
— Claude's Tab Window Manager, based on twm. It provides titlebars, shaped windows, virtual screens (workspaces), several forms of icon management, user-defined macro functions, click-to-type and pointer-driven keyboard focus, and user-specified key and pointer button bindings.
https://www.ctwm.org/
||
ctwm
cwm
— Originally deriving from evilwm, but later re-written from scratch, cwm aims to be simple, and offers helpful features such as searching for windows.
https://github.com/leahneukirchen/cwm
||
cwm
AUR
E16
— Predecessor of Enlightenment, a fast, flexible and extensible window manager.
https://www.enlightenment.org/e16
||
e16
eggwm
— A lightweight QT4/QT5 window manager.
https://code.google.com/archive/p/eggwm/
|| Qt 5:
eggwm-qt5
AUR
, Qt 4:
eggwm
AUR
EMWM
— Fork of the Motif Window Manager with fixes and enhancements. Supports Xinerama, Xrandr, UTF-8/Xft, and relevant EWMH.
https://fastestcode.org/emwm.html
||
emwm
AUR
Enlightenment
— Enlightenment is not just a window manager for Linux/X11 and others, but also a suite of libraries to help you create beautiful user interfaces with much less work than doing it the old fashioned way and fighting with traditional toolkits, not to mention a traditional window manager.
https://www.enlightenment.org/
||
enlightenment
evilwm
— Minimalist window manager for the X Window System. 'Minimalist' here does not mean it is too bare to be usable – it means it omits a lot of the stuff that make other window managers
un
usable.
https://www.6809.org.uk/evilwm/
||
evilwm
AUR
Fluxbox
— Window manager for X that was based on the Blackbox 0.61.1 code. It is very light on resources and easy to handle but yet full of features to make an easy and extremely fast desktop experience. It is built using C++ and licensed under the MIT License.
https://github.com/fluxbox/fluxbox
||
fluxbox
FLWM
— Lightweight, FLTK-based window manager. The primary influence and code base is from wm2.
https://flwm.sourceforge.net/
||
flwm
AUR
FVWM
— Powerful ICCCM-compliant multiple virtual desktop window manager for the X Window system. Development is active, and support is excellent.
https://www.fvwm.org/
||
fvwm3
Gala
— A beautiful window manager from elementaryos, part of
Pantheon
. Also as a compositing manager, based on libmutter.
https://launchpad.net/gala
||
gala
Goomwwm
— X11 window manager implemented in C as a cleanroom software project. It manages windows in a minimal floating layout, while providing flexible keyboard-driven controls for window switching, sizing, moving, tagging, and tiling. It is also fast, lightweight, modeless, Xinerama-aware, and EWMH compatible wherever possible.
https://github.com/seanpringle/goomwwm
||
goomwwm
AUR
IceWM
— Window manager for X. The goal of IceWM is speed, simplicity, and not getting in the user's way.
https://ice-wm.org/
||
icewm
jbwm
— Based on evilwm, with a minimal configuration size of approximately 16kb, focused on small binary size and usability, incorporating optional title-bars and XFT title-bar font rendering as compile-time options, jbwm also features easier to use keybindings than evilwm.
https://github.com/jefbed/jbwm
||
jbwm
AUR
JWM
— Window manager for X. JWM is written in C and uses only Xlib at a minimum.
https://joewing.net/projects/jwm/
||
jwm
Karmen
— Window manager for X, written by Johan Veenhuizen. It is designed to "just work." There is no configuration file and no library dependencies other than Xlib. The input focus model is click-to-focus. Karmen aims at ICCCM and EWMH compliance.
https://karmen.sourceforge.net/
||
karmen
AUR
KWin
— The standard KDE window manager since KDE 4.0, which is also a compositing manager. This allows KWin to provide advanced graphical effects, similar to Compiz, while also providing all the features from previous KDE releases (such as very good integration with the rest of KDE, advanced configurability, focus stealing prevention, a well-tested window manager, robust handling of misbehaving applications/toolkits, etc.). Also serves as a compositor for
Wayland
.
https://techbase.kde.org/Projects/KWin
||
kwin-x11
lwm
— Window manager for X that tries to keep out of your face. There are no icons, no button bars, no icon docks, no root menus, no nothing: if you want all that, then other programs can provide it. There is no configurability either: if you want that, you want a different window manager; one that helps your operating system in its evil conquest of your disc space and its annexation of your physical memory.
http://www.jfc.org.uk/software/lwm.html
||
lwm
AUR
Marco
— The MATE window manager, fork of Metacity.
https://github.com/mate-desktop/marco
||
marco
Metacity
— This window manager strives to be quiet, small, stable, get on with its job, and stay out of your attention. It is used by the legacy GNOME 2 and GNOME flashback sessions, and superseded by Mutter.
https://blogs.gnome.org/metacity/
||
metacity
Muffin
— Window and compositing manager for Cinnamon. A fork of Mutter, based on Clutter, uses OpenGL.
https://github.com/linuxmint/muffin/
||
muffin
MWM
— The Motif Window Manager (MWM) is an X window manager based on the Motif toolkit.
https://sourceforge.net/projects/motif/
||
openmotif
Openbox
— Highly configurable window manager with extensive standards support. The *box visual style is well known for its minimalistic appearance. Openbox uses the *box visual style, while providing a greater number of options for theme developers than previous *box implementations. Has been "feature complete" since 2010 but continues to be maintained.
https://openbox.org/
||
openbox
PekWM
— Window manager that once upon a time was based on the aewm++ window manager, but it has evolved enough that it no longer resembles aewm++ at all. It has a much expanded feature-set, including window grouping (similar to Ion, PWM, or Fluxbox), auto-properties, Xinerama, keygrabber that supports keychains, and much more.
https://www.pekwm.se/
||
pekwm
progman
— Simple X11 window manager modeled after the Windows 3 era.
https://github.com/jcs/progman
||
progman
AUR
Sawfish
— Extensible window manager using a Lisp-based scripting language. Its policy is very minimal compared to most window managers. Its aim is simply to manage windows in the most flexible and attractive manner possible. All high-level window manager functions are implemented in Lisp for future extensibility or redefinition.
https://sawfish.wikia.com/wiki/Main_Page
||
sawfish
AUR
sowm
— Simple Opinionated Window Manager that provides fullscreen toggling, window centering and a mixed workflow (i.e. mouse and keyboard).
https://github.com/dylanaraps/sowm
||
sowm
AUR
TinyWM
— Tiny window manager created as an exercise in minimalism. It may be helpful in learning some of the very basics of creating a window manager. It is comprised of approximately 50 lines of C. There is also a Python version using python-xlib.
http://incise.org/tinywm.html
||
tinywm
AUR
twm
— Simple window manager for X, the default/fallback used by Xorg since 1989. It provides titlebars, shaped windows, several forms of icon management, user-defined macro functions, click-to-type and pointer-driven keyboard focus, and user-specified key and pointer button bindings.
https://gitlab.freedesktop.org/xorg/app/twm/
||
xorg-twm
UWM
— Easy to use window manager which has an original look and feel. It has no title bars or window buttons. Window actions can be accessed from a honeycomb by clicking on the window border.
https://udeproject.sourceforge.net/
||
ude
AUR
VTWM
— One of many TWM descendants, implements a Virtual Desktop, meaning that what is currently on screen is just a portion of a larger workspace. What portion of the virtual desktop that is displayed, and whatever windows might be visible within it, are simple point-and-click operations within a scaled representation of the workspace.
http://www.vtwm.org/
||
vtwm
AUR
WindowLab
— Small and simple window manager of novel design. It has a click-to-focus but not raise-on-focus policy, a window resizing mechanism that allows one or many edges of a window to be changed in one action, and an innovative menubar that shares the same part of the screen as the taskbar. Window titlebars are prevented from going off the edge of the screen by constraining the mouse pointer, and when appropriate the pointer is also constrained to the taskbar/menubar in order to make target menu items easier to hit.
https://github.com/nickgravgaard/windowlab
||
windowlab
AUR
Window Maker
— X11 window manager originally designed to provide integration support for the GNUstep Desktop Environment. In every way possible, it reproduces the elegant look and feel of the NEXTSTEP user interface. It is fast, feature rich, easy to configure, and easy to use.
https://windowmaker.org/
||
windowmaker
wm2
— Window manager for X. It provides an unusual style of window decoration and as little functionality as its author feels comfortable with in a window manager. wm2 is not configurable, except by editing the source and recompiling the code, and is really intended for people who do not particularly want their window manager to be too friendly.
https://www.all-day-breakfast.com/wm2/
||
wm2
AUR
wmx
— Window manager for X. It's based on wm2, and it retains a similar look and feel, but it's intended to provide an experimental vehicle for features that fall comfortably outside the scope of the manifesto for the original wm2.
https://www.all-day-breakfast.com/wmx/
||
wmx
AUR
worm
— Worm is a is a dynamic, tag-based window manager for X11. It supports both a floating layout and a master-stack tiling layout and is developed openly. It is also written in the Nim programming language.
https://github.com/codic12/worm
||
worm
AUR
Xfwm
— The
Xfce
window manager manages the placement of application windows on the screen, provides beautiful window decorations, manages workspaces or virtual desktops and natively supports multi screen mode. It provides its own compositing manager (from the X.Org Composite extension) for true transparency and shadows. The Xfce window manager also includes a keyboard shortcuts editor for user specific commands and basic windows manipulations and provides a preferences dialog for advanced tweaks.
https://docs.xfce.org/xfce/xfwm4/start
||
xfwm4
Tiling window managers
Bspwm
— bspwm is a tiling window manager that represents windows as the leaves of a full binary tree. It has support for EWMH and multiple monitors, and is configured and controlled through messages.
https://github.com/baskerville/bspwm
||
bspwm
EXWM
— EXWM (Emacs X Window Manager) is a full-featured tiling X window manager for Emacs built on top of XELB. It features fully keyboard-driven operations, hybrid layout modes (tiling & stacking), dynamic workspace support, ICCCM/EWMH compliance, RandR (multi-monitor) support, and a built-in system tray.
https://github.com/emacs-exwm/exwm
||
emacs-exwm
AUR
Herbstluftwm
— Manual tiling window manager for X11 using Xlib and Glib. The layout is based on splitting frames into subframes which can be split again or can be filled with windows (similar to i3/ musca). Tags (or workspaces or virtual desktops or …) can be added/removed at runtime. Each tag contains its own layout. Exactly one tag is viewed on each monitor. The tags are monitor independent (similar to xmonad). It is configured at runtime via ipc calls from herbstclient. So the configuration file is just a script which is run on startup. (similar to wmii/musca).
https://herbstluftwm.org
||
herbstluftwm
i3
— Tiling window manager, completely written from scratch. i3 was created because wmii, the developers' favorite window manager at the time, did not provide some features we wanted (multi-monitor done right, for example), had some bugs, did not progress for quite some time, and was not easy to hack at all (source code comments/documentation completely lacking). Notable differences are in the areas of multi-monitor support and the tree metaphor. For speed the Plan 9 interface of wmii is not implemented.
https://i3wm.org/
||
i3-wm
Larswm
— A tiling window manager based on 9wm.
http://porneia.free.fr/larswm/larswm.html
||
larswm
AUR
LeftWM
— A tiling window manager written in
Rust
.
https://leftwm.org
||
leftwm
AUR
Matchbox
— Window manager intended for embedded systems. It only shows one window at a time.
https://git.yoctoproject.org/matchbox-window-manager/
||
matchbox-window-manager
AUR
Notion
— Tiling, tabbed window manager for the X window system that utilizes 'tiles' and 'tabbed' windows.
Tiling: you divide the screen into non-overlapping 'tiles'. Every window occupies one tile, and is maximized to it
Tabbing: a tile may contain multiple windows - they will be 'tabbed'.
Static: most tiled window managers are 'dynamic', meaning they automatically resize and move around tiles as windows appear and disappear. Notion, by contrast, does not automatically change the tiling.
Notion is a fork of Ion3.
https://notionwm.net/
||
notion
Ratpoison
— Simple Window Manager with no fat library dependencies, no fancy graphics, no window decorations, and no rodent dependence. It is largely modeled after GNU Screen which has done wonders in the virtual terminal market. Ratpoison is configured with a simple text file. The information bar in Ratpoison is somewhat different, as it shows only when needed. It serves as both an application launcher as well as a notification bar. Ratpoison does not include a system tray.
https://www.nongnu.org/ratpoison/
||
ratpoison
AUR
Stumpwm
— Tiling, keyboard driven X11 Window Manager written entirely in Common Lisp. Stumpwm attempts to be customizable yet visually minimal. It does have various hooks to attach your personal customizations, and variables to tweak, and can be reconfigured and reloaded while running. There are no window decorations, no icons and no buttons. Its information bar can be set to show constantly or only when needed.
https://stumpwm.github.io/
||
stumpwm
ZWM
— A minimalistic tiling window manager written in C, it uses the XCB api to communicate with Xorg server. It supports multi-monitors, supports a subset of EWMH specs, and offers extensive configurability.
https://github.com/Yazeed1s/zwm
||
zwm-git
AUR
Dynamic window managers
awesome
— Highly configurable, next generation framework window manager for X. It is very fast, extensible and licensed under the GNU GPLv2 license. Configured in Lua, it has a system tray, information bar, and launcher built in. There are extensions available to it written in Lua. Awesome uses XCB as opposed to Xlib, which may result in a speed increase. Awesome has other features as well, such as an early replacement for notification-daemon, a right-click menu similar to that of the *box window managers, and many other things.
https://awesomewm.org/
||
awesome
dk
— A list based tiling window manager in the vein of dwm, bspwm, and xmonad.
https://bitbucket.org/natemaia/dk/src/master/
||
dk
AUR
dwm
— Dynamic window manager for X. It manages windows in tiled, monocle and floating layouts. All of the layouts can be applied dynamically, optimising the environment for the application in use and the task performed. Does not include a system tray or automatic launcher, although dmenu integrates well with it, as they are from the same author. It has no text configuration file. Configuration is done entirely by modifying the C source code, and it must be recompiled and restarted each time it is changed.
https://dwm.suckless.org/
||
dwm
AUR
echinus
— Simple and lightweight tiling and floating window manager for X11. Started as a dwm fork with easier configuration, echinus became full-featured re-parenting window manager with EWMH support. It has an EWMH-compatible panel/taskbar, called
ourico
AUR
.
http://plhk.ru
||
echinus
AUR
FrankenWM
— Basically monsterwm with floating done right. Features that are added on top of basic mwm include: more layouts (fibonacci, equal stack, dual stack), gaps (and borders) are adjustable on the fly, minimize/maximize single windows, hide/show all windows, resizing master and stack individually, invert stack.
https://github.com/sulami/FrankenWM
||
frankenwm
AUR
Qtile
— Full-featured, hackable tiling window manager written in Python. Qtile is simple, small, and extensible. It is easy to write your own layouts, widgets, and built-in commands.It is written and configured entirely in Python, which means you can leverage the full power and flexibility of the language to make it fit your needs.
https://github.com/qtile/qtile
||
qtile
spectrwm
— Small dynamic tiling window manager for X11, largely inspired by xmonad and dwm. It tries to stay out of the way so that valuable screen real estate can be used for much more important stuff. It has sane defaults and is configured with a text file. It was written by hackers for hackers and it strives to be small, compact and fast. It has a built-in status bar fed from a user-defined script.
https://github.com/conformal/spectrwm/
||
spectrwm
AUR
Wingo
— Fully featured true hybrid window manager that supports per-monitor workspaces, and neither the floating or tiling modes are after thoughts. This allows one to have tiling on one workspace while floating on the other. Wingo can be scripted with its own command language, is completely themeable, and supports user defined hooks. Wingo is written in Go and has no runtime dependencies.
https://github.com/BurntSushi/wingo
||
wingo-git
AUR
xmonad
— Dynamically tiling X11 window manager that is written and configured in
Haskell
. In a normal WM, you spend half your time aligning and searching for windows. Xmonad makes work easier, by automating this. XMonad is configured in Haskell. For all configuration changes, xmonad must be recompiled, so the Haskell compiler (over 100MB) must be installed. A large library called
xmonad-contrib
provides many additional features.
https://xmonad.org/
||
xmonad
See also
The Window Manager Report
What are the best window managers for Linux?
A Memory Comparison of Light Linux Desktops