A highly configurable X11 window manager written and extended in Lua. Its dynamic tagging model, per-client rules, layouts, widgets and multi-monitor support let users assemble a desktop from scriptable components rather than a fixed shell. Originally based on dwm code; the project developed its own Lua-driven dynamic window-management model.
Tiling window managers and compositors
Tiling window managers arrange windows in layouts that make use of the available screen space. This collection spans X11 window managers and Wayland compositors with tiling support. Compare their screenshots and configuration approaches, and follow the official project links to investigate their behaviour in more detail.
41 projects
A lightweight X11 window manager controlled through a command-line client and shell scripts. It supports floating windows and manual tiling, with rules and startup behaviour configured as scripts; the project keeps window management separate from hotkeys, panels and other desktop services.
A Haskell and XMonad-based X11 tiler that presents dynamic layouts inside a more conventional desktop session, including panel and task-list integration. Its configuration builds on XMonad’s Haskell model, while the project’s desktop-oriented defaults make it less bare than a typical tiling manager. Bluetile began as a university project and thesis built on XMonad.
An X11 tiling window manager that represents each monitor as a binary tree of split containers, so placement and resizing are explicit and scriptable. The small `bspwm` process manages windows over a socket; a separate hotkey daemon such as `sxhkd` handles keyboard input, and a shell startup script configures the session.
A full-screen X11 window manager written in Common Lisp, organising windows through recursively nested frames rather than conventional desktop panels. Its frame tree can be navigated and reshaped from the keyboard, and Lisp configuration allows users to extend the manager interactively. CLFSWM’s own project documentation identifies TinyWM and StumpWM among its influences; it developed these keyboard and frame-management ideas into a Common Lisp full-screen manager.
An extensible wlroots-based Wayland compositor with dynamic and floating layouts, Lua scripting and C plugins. Its API and interaction model draw on AwesomeWM, letting users script window behaviour and compose the desktop rather than relying on a fixed configuration alone. CWC draws on AwesomeWM’s API and interaction model.
A Wayland compositor with tiling, stacking and scrolling window-management modes, paired with an integrated Flutter-based shell. It targets laptop and touchpad interaction, while the shell supplies desktop controls around the compositor rather than relying on a collection of unrelated desktop utilities. Denial is built around a Flutter-native compositor and integrated shell.
A small Wayland compositor inspired by suckless’s dwm, built on wlroots and configured by editing C source and rebuilding. It provides a compact tiling and floating session with tags and keyboard controls, leaving many desktop services and visual components to separate programs. The project describes itself as dwm for Wayland, aiming to carry dwm’s philosophy and core functionality to Wayland.
A deliberately small, dynamic X11 window manager offering tiled, monocle and floating arrangements plus tag-based workspaces. Users change its C source configuration and rebuild it, so customisation follows suckless’s compile-time patching model instead of a runtime settings panel.
An experimental Wayland compositor derived from dwl and built on wlroots, with a compact C-oriented configuration and tiling workflow. The project is small and its public documentation is limited, so this description sticks to the documented compositor base and design lineage. FjordWM began as a fork of dwl.
A full-screen X11 manager that organises applications into pages and frames controlled mainly from the keyboard. Its focus is a workspace-oriented frame model rather than a conventional desktop with panels and floating title bars.
A keyboard-driven X11 manager combining floating windows, tags and manually controlled placement with a deliberately clean, minimal interface. Its C implementation keeps the manager small, while scripts and key bindings can provide the surrounding desktop workflow.
A manual X11 tiler built around a tree of frames that can be split and assigned windows independently on each monitor. Tags act as workspaces, while `herbstclient` exposes runtime commands and IPC; its startup configuration is a shell script that issues those commands. Project documentation records influence from i3, Musca and wmii alongside its manual frame model.
A Wayland compositor with dynamic tiling and floating windows, per-monitor workspaces, animations and composable visual effects. Current documentation introduces Lua as a configuration interface while retaining support for existing Hyprlang configuration, and its compositor also manages input, outputs and desktop layers. A later milestone added Lua configuration while retaining the established Hyprlang path.
A dynamic X11 window manager whose container tree can be split horizontally or vertically and displayed in tiled, stacked or tabbed modes. A readable text file controls key bindings, workspaces and rules, while IPC lets status bars and other programs inspect or control the running session. Created by Michael Stapelberg as a replacement for wmii, i3 grew into an independently developed tiling window manager with its own configuration format.
A historic keyboard-driven X11 manager built around tiled frames and tabbed windows. Users split the screen into frames, then switch among clients within each frame; its text configuration controls bindings and session behaviour without requiring a mouse-driven desktop. Tuomo Valkonen created Ion as a keyboard-driven tiled and tabbed window manager.
A wlroots-based Wayland tiler with dynamic layouts and configurable workspaces, controlled through a simple configuration file and keyboard bindings. It is a compact compositor for users who want a dwl-like workflow with its own layout and workspace choices. JapokWM describes itself as a compositor based on dwl, adapting that compact wlroots project into its own dynamic tiling Wayland compositor.
A Linux Wayland compositor combining i3-like tiling with support for floating windows and multiple GPUs. Its Rust-based configuration API and rendering backends target users who want a programmable compositor with explicit control over outputs, layouts and session behaviour.
An X11 manager that keeps a tiled primary track for the main window and a floating area for secondary clients. Its automatic arrangement offers a structured alternative to pure manual tiling, while retaining a floating region for windows that do not fit the main layout. LarsWM was derived from 9wm and developed its tiled-primary and floating-secondary model.
A Rust-based X11 tiling window manager that separates core window management from the theme layer used for panels, launchers and other desktop components. Configuration and themes can be changed independently, allowing users to keep the tiler while replacing the surrounding session appearance. LeftWM presents itself as a Rust window manager focused on performance and stability.
A Rust compositor built on Smithay that combines Wayland tiling layouts and tags with a first-party GTK4 desktop shell. Its companion tools provide controls such as settings and application launching, so the project aims to deliver an integrated desktop stack as well as window management. Margo is a Rust and Smithay compositor drawing on dwl and mango’s Wayland tiling lineage.
A tiling Wayland compositor built on Canonical’s Mir, with workspaces, keyboard controls and a plugin interface for extending compositor behaviour. YAML configuration and hot reload support iteration without recompilation, while Mir supplies the underlying display-server framework. Miracle WM was introduced as a tiling Wayland compositor built on Mir.
A manual X11 tiler in which users create, split and arrange frames directly instead of relying on an automatic layout algorithm. Its keyboard commands and text configuration provide a compact session for users who want explicit control over every window’s position. Secondary-source manual documentation lists Ratpoison and dwm among the influences on Musca’s frame-management features.
A Wayland tiling compositor aimed at laptop and touchpad use, with animated transitions and workspace-oriented navigation. Python configuration describes the session and can be evaluated to derive settings, giving users a scriptable way to adapt its layouts and interaction model. Its author describes a starting idea of arranging windows across a large two-dimensional wall for laptop and touchpad use.
A Wayland compositor with scrollable tiling: windows form a horizontal strip that can extend beyond the screen, while each monitor has independent workspaces. KDL configuration controls layouts, input, rules and outputs; the design takes cues from PaperWM without depending on GNOME Shell. Niri’s scrollable tiling design was heavily inspired by PaperWM, while its compositor architecture separates it from the GNOME Shell extension model.
A modular Wayland compositor architecture in which plugins can cooperate to provide compositor and window-management behaviour. Its plugin-oriented approach is intended to make components replaceable, rather than bundling one fixed desktop workflow into the compositor. Orbment was designed around modular plugins that cooperate to supply compositor behaviour.
A hackable window manager whose Python configuration defines layouts, groups, key bindings, rules and widgets. It can run as an X11 window manager or as a Wayland compositor, so the same programmable desktop model is available across both display protocols.
A keyboard-driven X11 tiling manager that replaces overlapping desktop windows, title bars and pointer-centric controls with maximised frames that can be split into panes. Commands and bindings are configured in a text file, and its deliberately minimal interface suits users who want to manage windows without a mouse. Ratpoison is a keyboard-driven X11 manager whose command-oriented interaction is modeled on GNU Screen.
A Sway-derived Wayland compositor that retains i3-style commands and configuration while focusing on a horizontally scrolling tiling layout. Windows extend along a strip that users navigate across, providing a PaperWM-like workflow in a standalone compositor. Scroll forked from Sway, removing its other layouts to focus on a PaperWM-like scrolling layout.
A tiny X11 floating window manager with a compact C configuration header and a deliberately small set of built-in behaviours. Users can add their own key handling and startup tools, making it a minimal base for custom sessions rather than a ready-made desktop environment. The project README cites TinyWM as an inspiration for sowm’s small implementation and minimal X11 window-management scope.
A compact dynamic X11 tiler that arranges clients in a master-and-stack layout and offers workspaces, keyboard controls and a status bar. A plain-text configuration file controls layouts, bindings, rules and appearance, keeping setup accessible without recompiling the window manager. The developers describe spectrwm as inspired by xmonad and dwm.
A keyboard-oriented X11 frame manager written in Common Lisp, where users can interactively evaluate Lisp and extend commands, bindings and window policies. It arranges windows in frames and named groups rather than relying on a conventional desktop panel, and its configuration is Lisp code. StumpWM followed Ratpoison’s keyboard-driven interface goals while replacing its C implementation with Common Lisp.
An i3-compatible Wayland compositor that brings i3’s container tree, split layouts, workspaces and keyboard workflow to Wayland. It accepts familiar i3-style configuration and commands, and includes the compositor and session pieces needed to manage outputs, input and application windows. Started as an i3-compatible window manager for Wayland, allowing users to carry familiar i3 workflows and configuration to a Wayland session.
A community fork of Sway that keeps its i3-compatible Wayland workflow and adds optional visual effects such as blur, shadows, rounded corners and custom borders. It uses Sway-style configuration and commands, with effect settings extending the compositor’s appearance. A community fork of Sway that adds optional visual effects while retaining Sway’s wlroots and i3-compatible foundations.
A dynamic tiling Wayland compositor inspired by xmonad, with tree-based layouts and workspace controls. Configuration can be expressed through TOML and C settings, allowing users to customise layout behaviour while keeping the compositor itself relatively small. The author introduced Vivarium as a personal experimental dynamic Wayland compositor built with wlroots.
An experimental Wayland compositor component designed to pair with AwesomeWM, using Awesome’s Lua-driven policy rather than providing an unrelated desktop shell. The project required a patched Awesome client and its repository is archived, so it is of historical interest rather than a current desktop choice. Way Cooler was designed as the compositor component of AwesomeWM for Wayland; its repository was archived in January 2020.
“Window Manager From Scratch” is a lightweight X11 tiler with tags, client rules, keyboard controls and a configurable status area. It supports both dynamic and manually controlled layouts, while leaving many desktop services to external programs. Its author describes WMFS as a small window manager created from scratch.
A historic keyboard-driven X11 tiler organised around frames that can be split and filled with clients. Its control model emphasises keyboard navigation and configurable frame behaviour, while public documentation is limited compared with maintained contemporary projects. Secondary package documentation traces wmi’s combined feature set to LarsWM, Ion, evilwm and Ratpoison.
A Plan 9-inspired X11 tiler with dynamic, tag-based views and a file-like 9P interface for inspecting and controlling the session. Its frame layout and scripting interface support keyboard-driven workflows, while `wmiirc` supplies the user-level policy and configuration. Its design draws on Plan 9’s rio, Acme and 9P, and exposes session controls through a 9P interface.
A dynamic X11 tiling window manager configured in Haskell, where users can define layouts, key bindings, rules and hooks as code. Layouts can be changed or selected per workspace, and the functional configuration model makes deep customisation a central part of the project. Started in 2007 by Spencer Janssen, Don Stewart and Jason Creighton after they explored alternatives to existing tiling managers.
An Emacs-integrated X11 window manager that exposes window operations and workspace control through Emacs Lisp. Its design lets Emacs users manage X clients and desktop commands from familiar buffers and key bindings, rather than supplying a separate conventional panel. XWEM originated as an XEmacs package for managing X windows through Emacs Lisp.