Hyprland is a dynamic tiling Wayland compositor written in modern C++. It implements a wide range of Wayland protocols (XDG shell, layer shell, screencopy, input methods, color management, etc.) and provides a full desktop environment with OpenGL rendering, blur effects, animations, and Lua-based configuration. The architecture is a monolithic compositor with modular internal components: a protocol layer, desktop state management, layout algorithms (dwindle, master, scrolling, floating, Lua custom), input handling, rendering pipeline (pass elements, blur providers, window transformers), and IPC via Unix sockets. It includes a plugin system (hyprpm) and a test harness (hyprtester) for integration testing. The codebase demonstrates high craftsmanship with reusable patterns like an event bus, signal/slot system, typed config values, damage ring, and promise-based async IPC. It is actively maintained with frequent commits and a large community.
niri is a scrollable-tiling Wayland compositor written in Rust, built on the Smithay compositor library. It provides a dynamic workspace model with per-monitor vertical workspaces, an always-empty workspace at the bottom, and a tiling layout that supports floating windows, fullscreen, maximized, and tabbed modes. The compositor features a rich animation system (springs, easing curves), custom GLSL shaders for borders, shadows, blur, and window effects, and a comprehensive IPC interface for external tooling. It integrates with GNOME via D-Bus (screencasting, display config, accessibility) and supports PipeWire-based screencasting. Configuration is done via KDL files with live reload, includes, and merging semantics. The codebase is modular with separate crates for config parsing (niri-config), IPC protocol (niri-ipc), and visual tests (niri-visual-tests). It includes extensive unit, integration, snapshot, and property-based tests, as well as a visual test suite using GTK4. The architecture is a monolith compositor with well-defined subsystems for input handling, layout management, rendering, and protocol implementation.
Zellij is a high-craft terminal multiplexer written in Rust, offering a client-server architecture with native and web clients. It manages terminals, panes, tabs, and sessions with full VT emulation, mouse support, and a plugin system based on WebAssembly. The server handles panes (tiled, floating, stacked), PTY I/O, scrollback, search, sixel/Kitty graphics, and session serialization for resurrection. Plugins (built-in: bars, strider, configuration, prompt, session-manager, etc.) extend the UI via a widget framework with serialization through ANSI DCS escapes. The client processes keyboard/mouse input, provides a web client with xterm.js and WebSocket transport, and supports remote attach with token-based auth. The codebase is exceptionally well-tested (unit + integration test suites, snapshot-based), with clean trait abstractions (ClientOsApi, ServerOsApi, ZellijPlugin) and a custom build system (xtask). It is not a data/research repository.
plwm is an X11 dynamic tiling window manager written in Prolog. It features a modular architecture with separate Prolog modules for window management logic, layouts, menus, settings, and utilities, combined with C bindings to X11 libraries via SWI-Prolog's FFI. The system processes X11 events in a main event loop, manages window state through dynamic predicates, and provides multiple interaction methods including keyboard shortcuts, dmenu/rofi menus, and a scriptable command FIFO. Key entry points include the main Prolog file (src/plwm.pl), build system (Makefile), and installation script (tools/install.sh). External dependencies include X11 libraries (libX11, libXft, libXrandr) and SWI-Prolog.
bspwm is a tiling window manager for X11 that represents windows as leaves of a full binary tree. It uses a client-server architecture: the `bspwm` daemon manages windows and desktops, while the `bspc` command-line client communicates with it over a Unix domain socket. The daemon does not handle input directly; instead, an external helper like `sxhkd` invokes `bspc` to perform actions. Configuration is done via shell scripts (`bspwmrc`) that call `bspc` commands, and the state can be dumped to JSON for restoration. The project is written in C99 with XCB (X11 C Bindings) and supports EWMH/ICCCM standards, multi-monitor setups (RandR/Xinerama), a rule system for window matching, and event subscriptions for external tools like panels.
Notion is an X11 window manager with tiling, tabbing, and floating layout capabilities. It features a modular architecture where core functionality resides in ioncore/ and extends via loadable modules (mod_tiling, mod_menu, mod_statusbar, etc.). Configuration and extensibility are driven by Lua scripts, allowing deep customization of key bindings, layouts, and status bar elements. The system handles X11 events, manages window geometry and focus, and provides session saving/restoring. Key components include a reference-counted object system (libtu/obj), Lua-C binding layer (libextl), hook system (libmainloop/hooks), and binding maps for contextual input handling. Despite its age, the codebase shows recent activity and maintains compatibility with modern X11 environments.
React Mosaic is a production-grade React tiling window manager library. It renders an immutable n-ary tree of split, tab, and leaf nodes as a fully interactive layout with drag-to-resize dividers, draggable panel rearrangement, and tab-group management. The library is the single package `react-mosaic-component`, built with TypeScript, using `react-dnd` for drag-and-drop (with HTML5 and touch backends via multi-backend), and `immutability-helper` for immutable tree updates. It supports controlled and uncontrolled usage, Blueprint theming, and React 16–19. The architecture is centered on a `MosaicNode<T>` union type, a recursive renderer (`MosaicRoot`), and a React context system (`MosaicContext`, `MosaicWindowContext`) that exposes tree manipulation actions. The core tree utility layer (`mosaicUtilities.ts`, `mosaicUpdates.ts`) is well-isolated and thoroughly unit-tested. The codebase is actively maintained, with comprehensive CI/CD (GitHub Actions for PR validation, deployment, publishing), conventional commits, and an Nx monorepo build system. Despite some legacy class component patterns in the main components, the library demonstrates strong engineering with clean type guards, immutable state handling, and extensive test coverage for edge cases. It is suitable for embedding in any application needing complex panel layouts (IDEs, dashboards, monitoring tools).
Tiling Shell is a GNOME Shell extension that provides advanced, customizable window tiling and management. It replaces the default window snapping with a flexible layout system where users can define custom tile arrangements (via a built-in editor or JSON files), use snap assist for precise placement, enable edge tiling with multiple modes (default, adaptive, granular), and auto-tile new windows. The extension also adds a panel indicator, keyboard shortcuts, window border customization with dynamic corner radius detection, and a window suggestions feature that proposes layouts after tiling. The architecture follows a manager pattern: per-monitor subsystems (TilingManager, ResizeManager, WindowBorderManager, RaiseTogetherManager) are created and destroyed by the main extension lifecycle. Communication is event-driven via GObject signals, with a central GlobalState singleton and a Settings wrapper around GSettings. The codebase is written in TypeScript, compiled for GJS, and supports GNOME Shell versions 42–50 on both X11 and Wayland. It includes a complex build pipeline that produces separate outputs for modern and legacy GNOME versions, along with full internationalization (10+ languages). While the extension is actively maintained and feature-rich, it relies heavily on private GNOME Shell APIs and contains version-specific workarounds, which introduces maintenance risk as the shell evolves.
Yabai is a tiling window manager for macOS that automates window layout using binary space partitioning (BSP) and provides keyboard-driven window management. It operates as a background daemon, managing spaces, windows, and displays through a combination of public macOS accessibility APIs and private frameworks (notably SkyLight). The application features an event-driven architecture that reacts to system events (window creation, focus changes, space transitions) and applies user-defined rules to control window behavior. The codebase is structured around several managers (display, space, window, view, process) and a central event loop. A scripting addition (OSAX) is injected into the Dock.app to perform privileged operations via private APIs, communicating with the main yabai process over a Unix socket. Configuration and control are exposed through a command-line interface (yabai) and can be integrated with hotkey daemons like skhd. While the core functionality is well-implemented, the project faces significant maintenance challenges due to its reliance on undocumented private macOS APIs, which require frequent updates to remain compatible with new macOS releases. The codebase includes version-specific workarounds and architecture-specific implementations (for x86_64, arm64, and arm64e) to address these challenges. Despite these complexities, yabai remains a popular and actively maintained tool for macOS window management. Reusable components include low-level utilities such as a generic hash table, memory pool, dynamic string buffer, and logging system, which are decoupled from yabai-specific logic and could be extracted for use in other C projects.