Website review
This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.
What is xmonad?
xmonad is a dynamically tiling window manager for the X11 display system, written and configured in Haskell. Instead of letting you drag and resize overlapping windows, it arranges them automatically so they tile the screen without gaps or wasted space. You drive it primarily from the keyboard, which means you spend less time hunting for windows and aligning them by hand.
xmonad
What "tiling" means in practice
In a conventional window manager, every window floats and you position each one yourself. A tiling manager like xmonad assigns windows to a layout automatically: a common arrangement is one large master window beside a stack of others, and you move focus or swap windows with keybindings rather than the mouse. The site describes this as automating the common task of arranging windows so you can concentrate on your work.
Who it suits
- Keyboard-centric users who prefer shortcuts over mouse dragging.
- People who keep many terminals, editors, or browser windows open at once and want them visible without manual rearrangement.
- Tinkerers comfortable editing a configuration file: because configuration is done in Haskell, you get precise control, but the trade-off is a real learning curve if you don't know the language.
- Multi-monitor users, since the project highlights per-screen workspaces and Xinerama support.
Who should look elsewhere
If you want a familiar desktop with a taskbar, desktop icons, and a start menu out of the box, xmonad is deliberately minimal: the site states it ships with no window decorations, no status bar, and no icon dock. Those can be added through its extension library, but that is extra setup. Anyone unwilling to touch a config file will find it harder to get started than a conventional desktop environment.
A quick decision guide
| Your priority | xmonad fit |
|---|---|
| Automatic window arrangement | Strong |
| Keyboard-only workflow | Strong |
| Minimal, uncluttered screen | Strong |
| Zero-configuration setup | Weak |
| Rich built-in desktop furniture | Weak (extensions needed) |
A realistic first step
Install it on a spare machine or in a virtual machine rather than your main work computer, then follow the official documentation to get a basic session running before you customize anything. That way a broken configuration won't interrupt your daily work. If you're comparing options, other tiling window managers worth knowing about include i3 and awesome, which take different approaches to configuration.
How do I install and configure xmonad on my system?
Install xmonad through your distribution's package manager, then configure it by editing a Haskell file (~/.xmonad/xmonad.hs) and reloading with a keybinding. The official site points you to its download and documentation pages for the current release (xmonad 0.18.1 with xmonad-contrib 0.18.2) and to its community channels for help: xmonad.
The install path
- Install the
xmonadpackage for your distro (most Linux and BSD package collections carry it), plusxmonad-contribif you want the extension library. - Install a Haskell toolchain only if your distro doesn't ship prebuilt packages, or if you plan to build from source.
- Log out, then pick xmonad as your session in your display manager, or add
exec xmonadto~/.xinitrcand start withstartx. - Press Mod+Shift+Enter to open a terminal. If nothing appears, you have no terminal bound yet — see the configuration step.
The configuration path
xmonad's config is a Haskell source file, not a plain text settings file. You edit ~/.xmonad/xmonad.hs, then press Mod+q to recompile and restart in place; compile errors appear in a small window rather than killing your session.
A minimal starting point is a main that calls xmonad with your preferred layout and a myKeys list that overrides or adds bindings — the "one-liners" the project advertises for common tasks. Anything you don't override keeps the defaults.
What to expect from the defaults
The project describes xmonad as tiling, minimal, stable, extensible and keyboard-first. In practice that means:
- Windows are arranged automatically, so you spend less time aligning and hunting for them.
- No window decorations, status bar or icon dock out of the box — you add those from
xmonad-contribif you want them. - A mouse is unnecessary; the default modifier is Alt, and every action has a keybinding.
A realistic first hour
Say you're a developer on a laptop with an external monitor. You install the packages, log in, and get a blank screen with one terminal. You add a status bar and a few bindings for your browser and editor, recompile, and you're working. The friction is front-loaded: reading a Haskell config is unfamiliar if you've only edited config files in other window managers, and a typo means a compile error until you fix it. After that, changes are usually one or two lines.
When xmonad is the right trade-off
Choose it if you want automatic tiling, per-screen workspaces and true multi-monitor support, and you're comfortable — or willing to become comfortable — expressing your setup in Haskell. Look elsewhere if you want a graphical settings app, a preconfigured desktop with panels and docks, or a window manager you can configure without ever seeing code.
Next step
Read the official documentation and download pages first, then join the IRC channel #[email protected] or the subreddit when a config snippet won't compile. For a broader comparison before committing, see ArchWiki's window manager pages, which document xmonad alongside alternatives and cover session setup in detail.
What makes xmonad different from other tiling window managers like i3 or dwm?
xmonad's main difference is that its configuration is Haskell code, not a separate config format. You write a Haskell module that describes your keybindings, layouts, and hooks, and xmonad compiles it. i3 uses a plain-text config file with its own syntax, and dwm is configured by editing a C header file and recompiling. So xmonad sits between them: like dwm, changes require a rebuild, but the language you rebuild in is a full, expressive programming language with libraries, types, and a large extension ecosystem.
The practical consequences:
- Extensibility with types. xmonad-contrib is a library of modules you import and compose. Because it's Haskell, you can write your own layouts, hooks, and event handlers with the same tools the core uses. In i3, extending beyond the built-in commands usually means scripting around its IPC interface; in dwm, it means patching C source.
- Minimal by default, featureful when you add it. The site describes the out-of-the-box experience as no decorations, no status bar, no icon dock, with window decorations, status bars, and docks available through the extension library. i3 ships a status bar and a config-driven bar setup; dwm expects you to patch or pipe into an external bar.
- Tiling model. xmonad is dynamically tiling and automates window arrangement; the site highlights per-screen workspaces, true Xinerama support, and managehooks as core features. Per-screen workspaces are a real differentiator for multi-monitor setups, where each physical screen gets its own set of workspaces rather than one global workspace list spread across monitors.
- Keyboard-first. The site states first-class keyboard support and that a mouse is unnecessary. That's a shared trait with i3 and dwm, but xmonad's keybinding layer is just Haskell, so bindings can be computed, conditionally applied, or generated rather than listed one by one.
- Stated stability. The project claims Haskell and "smart programming practices" guarantee a crash-free experience. Treat that as the project's own claim; in practice, a bad config can fail to compile or misbehave, though the type system catches many errors before you ever run it.
Choosing between them
| xmonad | i3 | dwm | |
|---|---|---|---|
| Config language | Haskell (recompile) | i3 config text (reload) | C header (recompile) |
| Extension style | Import Haskell modules | IPC scripts, external tools | Patch source |
| Defaults | Bare: no bar, no decorations | Bar and defaults included | Minimal, patches expected |
| Best fit | You know or want to learn Haskell, and want programmable behavior | You want quick edits and readable config without programming | You want a tiny, hackable C codebase |
The trade-off is the learning curve. If you don't know Haskell, the first config is the hard part; the payoff is that anything you can express in code, you can express in your window manager. If you want to tweak a keybinding in ten seconds without a compiler, i3 is the easier daily driver.
A useful next step: open the documentation on xmonad and read through the default configuration file, since it doubles as a tutorial for the whole model. If the Haskell in it looks approachable, xmonad will reward you; if it looks like an obstacle, i3 or dwm will get you tiling sooner. For comparison shopping, the i3 project documents its config format at i3 and dwm at suckless.org.
How can I extend xmonad with xmonad-contrib to add features like status bars or window decorations?
xmonad-contrib is the standard extension library for xmonad: it adds modules that cover status bars, window decorations, layouts, prompt/launcher behavior and much more, while the core window manager stays small. You use it by importing modules in your Haskell configuration file and wiring them into your config, then recompiling and restarting xmonad.
The basic workflow
- Install xmonad-contrib alongside xmonad, using your distribution's package manager or a Haskell toolchain.
- Open your configuration file (typically
~/.config/xmonad/xmonad.hs, or~/.xmonad/xmonad.hson older setups). - Add
import XMonad.Contrib...lines for the modules you want. - Modify your
mainfunction and/or yourxmonadconfig record to call those modules. - Recompile (for example with
xmonad --recompile) and restart xmonad (often withmod+qby default) to load the changes.
If compilation fails, the error message points at the offending import or expression; this is normal when editing Haskell configs and is the main feedback loop.
Common extension categories
| Goal | Typical contrib area | What it changes |
|---|---|---|
| Status bar | XMonad.Hooks.DynamicLog plus a bar program such as xmobar |
Feeds workspace and window information to an external bar |
| Window decorations | XMonad.Layout.Decoration and related layout modules |
Adds title bars, borders or tabbed decorations to tiled windows |
| Layouts | XMonad.Layout.* |
Adds grid, tabbed, spiral, three-column and other arrangements |
| Prompts and launchers | XMonad.Prompt.* |
Adds keyboard-driven run/launch/search prompts |
| Per-screen and multi-monitor behavior | XMonad.Layout.PerWorkspace, XMonad.Actions.* |
Different layouts or actions per workspace or screen |
A concrete scenario
Suppose you want a status bar showing your current workspace and the focused window title. You would import XMonad.Hooks.DynamicLog, set your logHook to pipe information to xmobar (or another bar), and launch the bar from your startup hook. For decorations, you would instead modify your layoutHook to wrap your layouts in a decoration modifier, which is a different part of the config. These are separate concerns, so you can adopt them one at a time rather than rewriting everything at once.
Trade-offs to expect
- Configuration is code: flexibility comes with a compile step, and a broken config can prevent xmonad from starting until you fix it.
- Contrib modules vary in maturity and in how actively they are maintained; a module that works well for one layout may need adjustment with others.
- Status bars and decorations are usually external programs or layout wrappers, so they add moving parts (and sometimes dependencies) beyond the core window manager.
- The minimal default look is intentional; adding decorations and bars moves you away from that simplicity, which is a deliberate choice rather than an upgrade.
Next step
Start with one module, confirm it compiles and behaves as expected, then add the next. The official documentation at xmonad covers installation, configuration and the contrib module list, and the community channels listed there are the right place to ask when a specific module's usage is unclear.
What are the common configuration tasks in xmonad and how do I write them in Haskell?
xmonad is configured by writing a Haskell file that defines a main function, usually by overriding defaults from the XMonad and XMonad.Config modules. The common tasks are: setting your modifier key, defining key bindings, choosing a layout, and adding hooks or extensions. The site's own framing is that these should often be "one-liners," so the practical approach is to start from the default config and change only what you need.
The core tasks and how they look in Haskell
- Change the modifier key. The default is Alt (
mod1Mask); many people switch to the Super/Windows key (mod4Mask). You set this in thexmonadrecord asmodMask. - Add or rebind keys. You extend
keyswith a list of((modMask, key), action)pairs, using helpers likespawnto launch programs andwindows/focus-style actions to control windows and workspaces. - Pick and order layouts.
layoutHookis where you compose layouts fromXMonad.Layoutmodules, for example tiling plus a fullscreen or tabbed alternative. - Set hooks.
manageHookdecides where new windows go (which workspace, floating or tiled);logHooktypically feeds a status bar;handleEventHookreacts to events. - Change workspace names.
workspacesis just a list of strings, so you can label them "web", "code", "chat" instead of numbers. - Add extensions.
XMonad.Hooks.*,XMonad.Layout.*, andXMonad.Util.*modules cover decorations, status bars, and docks, which are not in the minimal default.
A minimal shape of a config file (illustrative, not copied from the site):
import XMonad
import XMonad.Hooks.ManageHelpers
main = xmonad $ def
{ modMask = mod4Mask
, terminal = "alacritty"
, workspaces = ["web", "code", "chat"]
, keys = \c -> myKeys c `M.union` keys def c
, manageHook = manageHook def <+> isDialog --> doFloat
}
The details of each field and the available helper functions belong in the official documentation rather than in a short answer, because signatures change between releases.
A practical way to start
- Install xmonad and xmonad-contrib from your distribution, or follow the download page on xmonad.
- Copy the default config to
~/.config/xmonad/xmonad.hs(or~/.xmonad/xmonad.hson older setups), change one thing — usuallymodMask— and reload withmod-q. - Add one key binding at a time and test it, rather than pasting a large config you don't understand.
- When something doesn't compile, read the error: Haskell's type checker usually names the exact field or function that is wrong.
Where to get help
The project points to its documentation, mailing list, and IRC channel (#[email protected]) for support. For broader context, the Arch Wiki's xmonad page and the Haskell documentation for the XMonad module are useful references, but the authoritative source for your installed version is the xmonad site itself.
One trade-off worth knowing: because configuration is real Haskell, you get type-checked, composable configs and powerful abstractions, but you also need at least basic familiarity with Haskell syntax and the compile-reload cycle. If you want to change settings by clicking through a GUI, a different window manager will suit you better. If you want tiling behavior you can script precisely, this model is the point.
How can I get help or support for xmonad if I run into issues?
For xmonad support, start with the official documentation and community channels listed on xmonad. The project points users to its documentation, a mailing list, an IRC channel (#[email protected]), and a subreddit, with bug reports handled through its release process. It also mentions a screenshot gallery and videos, which are more useful for examples than troubleshooting.
Practical routes, roughly in order of usefulness:
- Documentation first — configuration and common tasks are covered there, and xmonad's stated goal is making common configuration tasks one-liners.
- IRC — best for quick, interactive questions when you are stuck mid-configuration.
- Mailing list — better for longer questions where you can paste configs and logs.
- Subreddit — useful for browsing how others solved similar problems.
- Bug tracker — for reproducible bugs, not general "how do I" questions.
A concrete scenario: you add an extension from xmonad-contrib, rebuild, and get a compile error. The fastest path is usually to check the documentation for that module, then ask in IRC with your exact error and the relevant part of your xmonad.hs. Because configuration is Haskell, including the error text and your imports matters more than describing the symptom.
Note that the page emphasizes xmonad's minimal default setup — no window decorations, status bar, or icon dock out of the box — so if something appears "missing," it may be an extension you have not added rather than a fault. Support requests are easier to answer when you say which extensions you use.
For broader context, the Haskell community at Haskell can help with language-level errors in your configuration, since xmonad is written and configured in Haskell.
User reviews (0)