Tiling Window Managers in 2026: Hyprland, Aerospace, and the End of the Linux Ghetto

For twenty years, tiling window managers were a Linux curiosity — the thing your coworker with the ThinkPad and the dotfiles repo used. i3 and awesome and xmonad were serious tools, but they lived in a world of keyboard-driven workflows, config files in exotic languages, and friends who said “just try it” with an evangelist’s smile while you nodded politely.

That world has changed. In 2026, tiling WMs are no longer niche. Hyprland on Linux has pulled the tiling aesthetic into the Wayland era with animations and eye candy that compete with macOS for visual polish. Aerospace has brought i3-style tiling to macOS in a way that actually works with System Integrity Protection. Windows has tiling through FancyZones and PowerToys. There’s a tiling future in every major OS, and it no longer requires giving up your OS’s native look and feel.

This post covers what’s changed, the current best-in-class on each platform, and why the tiling workflow has finally escaped its Linux-forum origins.

What tiling actually solves

Before getting into the tools, worth being clear about the problem. A traditional floating window manager gives you overlapping windows that you drag, resize, and stack manually. It’s forgiving — you can leave clutter — but it’s manual labor, and the labor scales linearly with the number of windows you’re juggling.

A tiling window manager automates the layout. Windows fill the screen according to rules. New windows split existing ones. Closing a window reshapes the others. You never drag, never resize — you press a key to move or swap, and the WM redraws.

The benefits are concrete:

• Keyboard-first workflow. Hand stays on keyboard; no mouse for layout management. Over a day of coding, that’s hundreds of small context switches saved.
• No wasted screen space. Tiled layouts use every pixel.
• Consistent layouts. You can define “my Go dev layout” or “my writing layout” and snap to it instantly.
• Discoverability of state. No window is ever hidden behind another. What’s on screen is everything that’s running in that workspace.
• Workspace discipline. The per-workspace model encourages one task per workspace — coding here, Slack there, browser elsewhere — which compounds the keyboard-first advantage.

The costs:

• Initial learning curve. Week one is rough. Week two is fine. Month two, you can’t go back.
• Some apps fight it. Modals, floating dialogs, and some Electron apps behave badly in tiled layouts. Good WMs have per-app rules for this.
• Screen sharing gets weird. Presenters expect predictable window layouts; tiled workspaces can surprise audiences.

If you’re a developer who spends all day with 4+ windows open, tiling is probably a productivity win. If you use your computer primarily for browsing and occasional documents, floating is fine.

Linux: Hyprland is the new default

For years, the Linux tiling landscape was i3 on X11, then Sway (an i3 port to Wayland), with xmonad and awesome as the functional-programmer and Lua-curious alternatives respectively. All of these still exist, all of them still work, and all of them are excellent — but the center of gravity has moved.

Hyprland is a dynamic tiling compositor for Wayland written in C++. It’s visually distinctive: smooth animations on every action (window open, close, move, swap), real translucency, blur, rounded corners, and shader-based effects. It looks like macOS if macOS did tiling. The project is young (started 2022) and has accumulated momentum fast.

Why Hyprland won:

• Visual parity with macOS. For a long time, the aesthetic argument for Linux DEs was “it’s fine.” Hyprland’s default look and its ricing community have moved Linux desktops into genuinely-beautiful territory.
• Wayland-native. It doesn’t inherit X11’s baggage. Per-monitor DPI, per-monitor refresh rate, HDR support — all work out of the box.
• Configuration in plain text, sensibly structured. ~/.config/hypr/hyprland.conf uses a simple key/value and block syntax, not Lua or Haskell, and the reload is live.
• Good community and docs. The wiki is thorough, examples are plentiful, and there’s a healthy plugin ecosystem (hyprpaper, hypridle, hyprlock, hyprpicker).

Config example:

monitor=DP-1,3440x1440@144,0x0,1

general {
    gaps_in = 5
    gaps_out = 10
    border_size = 2
    col.active_border = rgb(7aa2f7) rgb(bb9af7) 45deg
    col.inactive_border = rgb(1f2335)
    layout = dwindle
}

decoration {
    rounding = 8
    blur {
        enabled = true
        size = 8
        passes = 2
    }
}

animations {
    enabled = true
    bezier = smooth, 0.25, 0.1, 0.25, 1
    animation = windows, 1, 4, smooth
    animation = fade, 1, 3, smooth
    animation = workspaces, 1, 4, smooth
}

bind = SUPER, Return, exec, ghostty
bind = SUPER, Q, killactive,
bind = SUPER, H, movefocus, l
bind = SUPER, L, movefocus, r
bind = SUPER SHIFT, H, movewindow, l
bind = SUPER SHIFT, L, movewindow, r
bind = SUPER, 1, workspace, 1
bind = SUPER, 2, workspace, 2

Hyprland is opinionated but not dogmatic. You can disable all animations (and people do, for latency-sensitive work). You can turn off blur (lower-end GPUs sometimes want this). You can use a master/stack layout instead of the default dwindle layout. It’s as minimal or as maximal as you want.

Where Hyprland falls short:

• It’s still young. Expect the occasional regression on major releases. The team patches fast but you might trip over an issue first.
• NVIDIA support is better than it used to be but still not ideal. If you’re on NVIDIA proprietary drivers, you’ll want at least the 555+ series for reasonable Wayland support. AMD and Intel users have no issues.
• The developer’s public communication has been controversial at times. The project is fine; some of the Twitter/X discourse around it has been less fine. Separating the software from the drama is a practical matter for anyone adopting.

If you’ve never used tiling, Hyprland is the one to start with. If you’ve used i3 and want a Wayland upgrade, Hyprland or Sway are the natural paths — Sway if you want pure i3 compatibility, Hyprland if you want the visuals.

The other Linux contenders

Not everyone wants Hyprland. The landscape:

• Sway — the i3 compositor for Wayland. Nearly-identical config format to i3. The best choice if you want the i3 workflow on modern Wayland without flashy animations. Stable, boring (in the best way), maintained by someone who explicitly prioritizes stability.
• River — tagged-based dynamic tiling, inspired by dwm. Wayland-native. Good for people who want something deliberately minimal.
• Niri — scrollable tiling, columns instead of stacks. A genuinely different workflow model: instead of managing which windows are visible, you scroll horizontally through a strip of windows. Polarizing but some people swear by it for prose and reading-heavy workflows.
• i3 — still excellent on X11. If you have a working X11 setup and don’t need the Wayland features, it’s fine to keep using.
• awesome, xmonad, bspwm — still available, still good, now niche. Worth considering if you specifically want their programming model (Lua, Haskell, C respectively).

For a 2026 newcomer: start with Hyprland. Fall back to Sway if Hyprland gives you trouble.

macOS: Aerospace has changed the game

macOS has always been hostile to tiling window managers. System Integrity Protection, private frameworks, sandboxing — Apple makes it hard to arrange windows programmatically. For years, the two options were:

• yabai — very capable, but required partially disabling SIP to enable the “scripting addition” that allows space management. Many users balk at SIP disable; many employer-managed Macs forbid it entirely.
• Amethyst / Rectangle — simpler layout tools that don’t need SIP changes but also can’t do true tiling workspaces.

Aerospace, released in 2024 and now very mature in 2026, solved this. It’s an i3-inspired tiling WM for macOS that works entirely within Apple’s public APIs — no SIP disable required. It achieves this by replacing the concept of macOS “Spaces” with its own virtual workspace model, which means it doesn’t fight the OS for window control in ways that need elevated privileges.

Aerospace is now the default recommendation for tiling on macOS. Features:

• i3-style configuration in ~/.aerospace.toml — declarative, simple, well-documented.
• No SIP disable. Works on managed Macs, corporate laptops, and Macs with full security enabled.
• Workspace-based layouts. 10 workspaces by default, each with its own tiling layout.
• Per-app rules. Send Slack to workspace 3, keep Zoom floating, put Terminal on workspace 1 — all declarative.
• Keyboard shortcuts that don’t conflict with macOS defaults. Uses a leader-key model similar to tmux/Zellij.

Config example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

after-startup-command = ['exec-and-forget sketchybar']

default-root-container-layout = 'tiles'
default-root-container-orientation = 'auto'

[gaps]
inner.horizontal = 8
inner.vertical = 8
outer.left = 8
outer.right = 8
outer.top = 8
outer.bottom = 8

[mode.main.binding]
alt-enter = 'exec-and-forget open -n /Applications/Ghostty.app'
alt-q = 'close'

alt-h = 'focus left'
alt-j = 'focus down'
alt-k = 'focus up'
alt-l = 'focus right'

alt-shift-h = 'move left'
alt-shift-j = 'move down'
alt-shift-k = 'move up'
alt-shift-l = 'move right'

alt-1 = 'workspace 1'
alt-2 = 'workspace 2'
alt-3 = 'workspace 3'

[[on-window-detected]]
if.app-id = 'com.tinyspeck.slackmacgap'
run = 'move-node-to-workspace 3'

[[on-window-detected]]
if.app-id = 'us.zoom.xos'
run = 'layout floating'

The catch: Aerospace cannot do some things that yabai can. It can’t do true animated window transitions (it reuses macOS’s built-in space-switching animations). It can’t manipulate every aspect of window geometry as precisely as yabai. It works with macOS’s Mission Control rather than replacing it.

For 95% of users, these limitations don’t matter. For the 5% who’ve built a custom workflow around yabai’s Spaces hack, yabai is still there. For everyone else, Aerospace is the pragmatic default.

Menu bar integration

Tiling WMs on macOS get more interesting when paired with sketchybar, a customizable replacement for the macOS menu bar. Sketchybar plus Aerospace gives you Linux-style workspace indicators, system info widgets, and a fully scripted menu bar — on a stock, unmodified macOS with SIP intact.

This combination — Aerospace + sketchybar + Ghostty + neovim or Helix — is the 2026 macOS power-user stack. It genuinely rivals a Hyprland Linux setup for keyboard-driven workflow, without giving up macOS’s app ecosystem, reliability, or battery life.

Windows: the quiet tiler

Windows gets less attention in this space but has options:

• FancyZones (part of PowerToys) — user-defined layout grids. Windows snap to zones when dragged with Shift held. Not a true tiling WM, but it gets you 70% of the productivity benefit for 10% of the setup.
• GlazeWM — i3-inspired tiling for Windows 10/11, actively maintained. If you want full keyboard-driven tiling on Windows, this is the one.
• komorebi — a more ambitious tiling WM for Windows written in Rust by a committed author. More powerful than GlazeWM but more config overhead.
• Windows 11 Snap Layouts — built-in, works out of the box, actually pretty good for casual tiling.

Honest take: if you’re on Windows and curious about tiling, try Snap Layouts and FancyZones first. If you need more, GlazeWM or komorebi both work well. The Windows tiling community is smaller than Linux or macOS, but it exists and is healthy.

The stack that works

If you’re considering tiling for the first time in 2026, here’s a concrete stack to adopt. You don’t have to adopt the whole thing at once, but knowing the endpoint helps.

Shared across platforms:

• Terminal: Ghostty or WezTerm (keyboard-native, fast, good defaults)
• Multiplexer: Zellij (easier learning curve than tmux)
• Editor: Helix or Neovim (keyboard-driven, fits the workflow)
• Shell: Fish or Zsh + starship
• Launcher: Raycast (macOS) or Rofi/Wofi (Linux) or PowerToys Run (Windows)

Linux:

• WM: Hyprland (or Sway if you want stability-first)
• Bar: Waybar
• Notification daemon: mako or dunst
• Screen lock: hyprlock

macOS:

• WM: Aerospace
• Menu bar: sketchybar (optional but worth it)

Windows:

• WM: GlazeWM or FancyZones for a gentler start
• Bar: Yasb (a cross-platform alternative menu bar)

Week one with a tiling WM

If you’re starting from nothing, the realistic adoption curve:

• Day 1. Install. Run through the default config. Memorize: open terminal, close window, switch workspace, move window. Get used to it. You’ll be slow.
• Day 2-3. Customize keybindings to match what your fingers already know. If you’re a Vim user, hjkl for navigation is natural. If you’re not, pick directional keys that match your instinct.
• Day 4-7. Build per-workspace habits. Workspace 1 for coding, 2 for the browser, 3 for Slack, 4 for music. Stop thinking about “where’s my Slack window” and start thinking “I open Slack on workspace 3.”
• Week 2. Start using layouts intentionally — horizontal splits for wide code, vertical splits for short terminals, a big main + small side for focused work. This is where the productivity kicks in.
• Week 3-4. Tweak per-app rules (float the modal dialogs, pin the password manager). Lock in your dotfiles.
• Month 2. Tiling feels native. Using a floating WM on someone else’s machine feels slow.

Don’t expect productivity gains in week 1. You’ll be slower while your muscle memory rewires. That’s normal and temporary.

Why tiling has finally escaped the ghetto

For a long time, tiling WMs were held back by three things: ugly defaults, intimidating configuration, and platform lock-in to Linux. In 2026, all three are solved:

• Hyprland made tiling beautiful by default. It’s not a compromise on aesthetics; it looks better than most stock desktop environments.
• Aerospace and GlazeWM brought tiling to macOS and Windows with sensible defaults and public-API compliance. You don’t have to switch OS to get the workflow.
• Configuration formats have matured. TOML (Aerospace), the Hyprland format, GlazeWM’s YAML — all readable by anyone who’s edited a config file, without requiring Haskell or Lua literacy.

The old tiling-WM rite of passage — wrestling with xmonad.hs, debugging DPI issues across monitors, giving up on battery life — is mostly gone. What’s left is the actual workflow, on whatever platform you’re already on, with a visual polish that’s competitive with anything.

If you’ve been tiling-curious but put off by the learning curve, 2026 is the best year it’s ever been to try. The tools work. The docs exist. The aesthetic isn’t a compromise. And if you stick with it past the first awkward week, you’ll probably never go back.