文章目录

If you've been hunting for a Wayland compositor that feels genuinely modern — not just a port of an old X11 concept — niri deserves your attention. It's a scrollable-tiling window manager written in Rust that arranges windows on an infinite horizontal strip. Opening a new window never squeezes existing ones. That alone sounds simple, but it changes how you think about window management at a fundamental level.

Niri currently sits at ⭐ 24,643 stars on GitHub with 918 forks and a bustling community that is actively discussing features, bug fixes, and future plans. It was created by Ivan (YaLTeR), a Rust developer who has been building and maintaining niri since August 2023. The project is production-stable — many users are daily-driving it, and the Matrix channel is active with helpful community members.

Most tiling window managers fall into two camps: the i3/sway approach (manual grid tiling) or the BSPWM approach (binary space partitioning). Both require you to manually resize windows or accept that new windows eat into existing ones' space. Niri breaks that pattern entirely.

The key innovation is the scrollable strip — think of it as an infinite desktop going right. Each monitor gets its own separate strip. When you open a new window, it simply slides in to the right without touching any existing window's dimensions. Workspaces are dynamic and arranged vertically, and each monitor maintains its own independent workspace set. This is particularly powerful for multi-monitor setups, where you never have windows "bleeding" across monitors.

What really sold me on niri is the overall polish. We're talking about features like gradient borders with Oklab/Oklch color space support, background blur for windows and panels, custom shader animations, and built-in screenshot UI. And it all works with screen readers for accessibility. The developer clearly cares about aesthetics as much as functionality — a rare combination in the tiling WM space.

The README distills niri's philosophy into a few standout capabilities. First, it was architected from scratch specifically for scrollable tiling — no legacy X11 hacks here. Dynamic workspaces work like GNOME's, automatically creating an empty workspace at the bottom of the strip. The Overview mode lets you zoom out to see all workspaces and windows at once, which is fantastic for navigation.

Input device support is comprehensive: touchpads, tablets, touchscreens, and trackpoints all work. The project maintains multi-monitor support as a core design pillar, not an afterthought, and it handles mixed DPI setups without issues. NVIDIA GPUs are supported too, which remains a pain point with many Wayland compositors.

Since v25.01, niri added floating window support — previously a common limitation in pure-tiling WMs. XWayland applications are supported via xwayland-satellite (v25.08+). The config file uses the KDL format, hot-reloads live, and has a clean syntax that makes it easy to get started. There's even a web-based documentation site at niri-wm.github.io/niri.

Power developers with many windows: If you're constantly working with 6-10 terminal windows, IDE panels, browser tabs, and documentation side by side, niri's scrollable strip lets you keep everything visible without manual resizing. Each new window just appears on the right.

Multi-monitor power users: Niri treats each monitor as completely independent. You can have different workspace sets per monitor, and they remember their layout across hotplug events. Connect a monitor, and its workspaces come back exactly where you left them.

Minimalist Linux desktop builders: Niri isn't a full desktop environment — it's a compositor that works alongside a desktop shell like DankMaterialShell or Noctalia. If you like assembling your own minimal setup (panel bar, notification daemon, etc.) but want a smarter WM than a manual grid, niri is purpose-built for that workflow.

Here's how to get niri running from scratch on a Arch-based system (tested on Arch Linux with wlroots-based dependencies):

# Step 1: Install via AUR (example with yay)
yay -S niri

# Step 2: Add niri to your Wayland session
# In your display manager (SDDM, GDM, etc.), select "niri"
# Or add to ~/.xinitrc:
#   exec niri

# Step 3: Basic config file at ~/.config/niri/default.kdl
output "DP-1" {
    mode "1920x1080@60.000"
    scale 1.0
}

layout {
    center-focused-column "on-overflow"
    gaps 6
    border {
        width 2
        active-color "#ffc87f"
        inactive-color "#505050"
    }
}

# Step 4: Run niri msg to interact at runtime
niri msg toggle-overview
niri msg workspace next

# Step 5: Explore with niri msg (no restart needed for most changes)
# Edit your config and most changes apply live

For NixOS users, niri is available as a package. Gentoo users can use the gui-wm/niri overlay. Check the official Getting Started guide for distro-specific instructions.

  • Rust + Smithay: Built entirely in Rust using the Smithay toolkit, giving it memory safety guarantees and excellent performance. The developer has given talks (RustCon 2024) about how they use randomized property testing and input latency profiling to maintain quality.
  • Oklab/Oklch color science: Rather than using simple RGB for visual customization, niri supports perceptually uniform color spaces. This means gradient borders look correct regardless of how you configure them — a detail that shows deep thinking about the user experience.
  • IPC scripting via niri msg: The CLI tool niri msg exposes a rich IPC interface for controlling the compositor at runtime — switch workspaces, move windows, zoom, and more. This makes it scriptable and automatable without any external tools.

⭐ 24,643 stars on GitHub | 📈 +recently trending | License: GPL-3.0

If you're coming from i3wm or sway, the biggest difference is that niri's scrollable tiling eliminates the mental overhead of managing window sizes. In i3, opening a new window in a tiled container resizes everything — you constantly run resize commands. Niri's model means new windows are always full-width in a new column, and you scroll horizontally to access older ones. It's a fundamentally different mental model that scales better with many windows.

Hyprland is probably the closest alternative in terms of polish and features, with excellent animations and visual effects. But Hyprland uses manual tiling by default, whereas niri's scrollable approach is automatic and predictable. Hyprland's community is larger and more active, but niri's codebase is more focused and easier to understand.

river (also written in Zig) shares the dynamic tiling philosophy with niri, but lacks niri's scrollable strip concept and the rich visual customization options like Oklab gradient borders.

Here's a look at what real users and contributors are discussing in the GitHub Issues:

Issue #1071 — "Vertical layout option for portrait monitors" (37 comments) — A contributor notes that for portrait-oriented monitors, it makes sense to flip niri's scrolling layout from horizontal to vertical. The developer responds honestly that this would require a "quite an annoying and complex refactor in the code" but points to an easier alternative (#401) that lets users open windows as maximized by default. The issue has accumulated 162 thumbs-up reactions, showing strong community interest. This kind of honest technical communication from the maintainer builds trust — it's refreshing to see a developer acknowledge complexity rather than over-promising.

Issue #3873 — "popup/overlay/surfaces are not rendered or misaligned (Firefox)" (37 comments) — A NixOS user reports that Firefox tooltips and popups are mispositioned under niri. The issue is tagged "not niri:application," suggesting the root cause lies in Firefox's Wayland popup handling rather than niri itself. The discussion explores using WAYLAND_DEBUG to trace the issue further. This highlights a common pain point in the Wayland ecosystem: application-level popup handling varies, and some apps make assumptions that don't hold across all compositors.

PR #3246 — "Feat/cursor zoom" (140 comments) — A contributor is implementing a cursor zoom action that applies a zoom transform to the entire compositor via IPC. This has massive accessibility implications — think zoom for presentations, low-vision users, or just a different workflow. The 140 comments show deep collaborative design discussion, and 25 hearts indicate strong community approval. This PR exemplifies niri's approach to accessibility: it integrates features into the compositor core rather than requiring external workarounds.

1. Fractional scaling with custom cursor sizes can behave unexpectedly: If you're using fractional scaling (e.g., scale 1.2) and configured a custom xcursor-size in your appearance config, the custom size may be ignored in favor of a default (Issue #3954). A workaround is to test whether your applications use GTK's cursor settings instead of niri's, which is the case for some apps like Discord. Keep this in mind when debugging cursor size issues.

2. Multi-monitor with many outputs can show inconsistent behavior: Users with 3+ external monitors sometimes report that not all monitors are detected consistently between sessions (Issue #1871). This seems to be related to how the compositor enumerates outputs at startup. A useful diagnostic command is niri msg which shows all currently connected outputs with their configuration — compare this with wlr-randr output to identify discrepancies.

3. XWayland requires xwayland-satellite on newer niri versions: Starting from niri 25.08, XWayland is handled via xwayland-satellite instead of the built-in Xwayland. If you depend on X11 applications and upgraded recently, make sure xwayland-satellite is installed and configured, otherwise your X apps won't display.

Niri is one of those rare open-source projects where you can feel the developer's personality in the design choices. The scrollable-tiling model is genuinely novel — not a rehash of X11 tiling — and the implementation quality in Rust is impressive for a project of this scope. With 417 open issues, active development, and a supportive community on Matrix, it's a project that's actively growing.

The visual polish (gradient borders, background blur, shaders, animations) combined with deep technical features (mixed-DPI multi-monitor, screen readers, trackpoint gestures) makes niri stand out in a Wayland ecosystem that is still catching up to X11's maturity. If you're a Linux power user who wants a compositor that thinks differently about window management, niri is absolutely worth an evening to try out.

🔗 More GitHub Trending Open Source Projects: Developer Tools