Freeze view when pointer or touch is grabbed

Deny toplevel move from DnD grabs
Work around https://gitlab.gnome.org/GNOME/gtk/-/issues/7113
2026-06-21 02:01:55 +07:00 · 2024-10-28 21:18:26 +03:00 · 2024-10-28 21:12:58 +03:00 · 2024-10-28 21:12:58 +03:00 · 2024-10-27 23:07:39 -07:00 · 2024-10-27 23:07:39 -07:00
184 changed files with 40278 additions and 8327 deletions
@@ -0,0 +1 @@
+*.png filter=lfs diff=lfs merge=lfs -text
@@ -14,6 +14,9 @@ assignees: ''
 <!-- Paste the output of `niri -V`, e.g. niri 0.1.0-beta.1 (v0.1.0-beta.1) -->
 * niri version: 

+<!-- Write your distribution, e.g. Fedora 40 Silverblue -->
+* Distro: 
+
 <!-- Write your GPU vendor and model, e.g. AMD RX 6700M -->
 * GPU: 

@@ -34,7 +34,7 @@ jobs:
      - name: Install dependencies
        run: |
          apt-get update -y
-          apt-get install -y curl gcc clang libudev-dev libgbm-dev libxkbcommon-dev libegl1-mesa-dev libwayland-dev libinput-dev libdbus-1-dev libsystemd-dev libseat-dev libpipewire-0.3-dev libpango1.0-dev
+          apt-get install -y curl gcc clang libudev-dev libgbm-dev libxkbcommon-dev libegl1-mesa-dev libwayland-dev libinput-dev libdbus-1-dev libsystemd-dev libseat-dev libpipewire-0.3-dev libpango1.0-dev libdisplay-info-dev

      - uses: dtolnay/rust-toolchain@stable

@@ -42,11 +42,23 @@ jobs:
        with:
          key: ${{ matrix.configuration }}

-      - name: Build (no default features)
-        run: cargo build ${{ matrix.release-flag }} --no-default-features
+      - name: Check (no default features)
+        run: cargo check ${{ matrix.release-flag }} --no-default-features

-      - name: Build
-        run: cargo build ${{ matrix.release-flag }}
+      - name: Check (just dbus)
+        run: cargo check ${{ matrix.release-flag }} --no-default-features --features dbus
+
+      - name: Check (just systemd)
+        run: cargo check ${{ matrix.release-flag }} --no-default-features --features systemd
+
+      - name: Check (just dinit)
+        run: cargo check ${{ matrix.release-flag }} --no-default-features --features dinit
+
+      - name: Check (just xdp-gnome-screencast)
+        run: cargo check ${{ matrix.release-flag }} --no-default-features --features xdp-gnome-screencast
+
+      - name: Check
+        run: cargo check ${{ matrix.release-flag }}

      - name: Build (with profiling)
        run: cargo build ${{ matrix.release-flag }} --features profile-with-tracy
@@ -73,7 +85,7 @@ jobs:
      - name: Install dependencies
        run: |
          apt-get update -y
-          apt-get install -y curl gcc clang libudev-dev libgbm-dev libxkbcommon-dev libegl1-mesa-dev libwayland-dev libinput-dev libdbus-1-dev libsystemd-dev libseat-dev libpipewire-0.3-dev libpango1.0-dev libadwaita-1-dev
+          apt-get install -y curl gcc clang libudev-dev libgbm-dev libxkbcommon-dev libegl1-mesa-dev libwayland-dev libinput-dev libdbus-1-dev libsystemd-dev libseat-dev libpipewire-0.3-dev libpango1.0-dev libadwaita-1-dev libdisplay-info-dev

      - uses: dtolnay/rust-toolchain@stable

@@ -86,7 +98,7 @@ jobs:
    strategy:
      fail-fast: false

-    name: 'msrv - 1.72.0'
+    name: 'msrv - 1.77.0'
    runs-on: ubuntu-22.04
    container: ubuntu:23.10

@@ -98,9 +110,9 @@ jobs:
      - name: Install dependencies
        run: |
          apt-get update -y
-          apt-get install -y curl gcc clang libudev-dev libgbm-dev libxkbcommon-dev libegl1-mesa-dev libwayland-dev libinput-dev libdbus-1-dev libsystemd-dev libseat-dev libpipewire-0.3-dev libpango1.0-dev libadwaita-1-dev
+          apt-get install -y curl gcc clang libudev-dev libgbm-dev libxkbcommon-dev libegl1-mesa-dev libwayland-dev libinput-dev libdbus-1-dev libsystemd-dev libseat-dev libpipewire-0.3-dev libpango1.0-dev libadwaita-1-dev libdisplay-info-dev

-      - uses: dtolnay/rust-toolchain@1.72.0
+      - uses: dtolnay/rust-toolchain@1.77.0

      - uses: Swatinem/rust-cache@v2

@@ -122,7 +134,7 @@ jobs:
      - name: Install dependencies
        run: |
          apt-get update -y
-          apt-get install -y curl gcc clang libudev-dev libgbm-dev libxkbcommon-dev libegl1-mesa-dev libwayland-dev libinput-dev libdbus-1-dev libsystemd-dev libseat-dev libpipewire-0.3-dev libpango1.0-dev libadwaita-1-dev
+          apt-get install -y curl gcc clang libudev-dev libgbm-dev libxkbcommon-dev libegl1-mesa-dev libwayland-dev libinput-dev libdbus-1-dev libsystemd-dev libseat-dev libpipewire-0.3-dev libpango1.0-dev libadwaita-1-dev libdisplay-info-dev

      - uses: dtolnay/rust-toolchain@stable
        with:
@@ -141,11 +153,9 @@ jobs:
        with:
          show-progress: false

-      - name: Install Rust
-        run: |
-          rustup set auto-self-update check-only
-          rustup toolchain install nightly --profile minimal --component rustfmt
-          rustup override set nightly
+      - uses: dtolnay/rust-toolchain@nightly
+        with:
+          components: rustfmt

      - name: Run rustfmt
        run: cargo fmt --all -- --check
@@ -162,7 +172,7 @@ jobs:
      - name: Install dependencies
        run: |
          sudo dnf update -y
-          sudo dnf install -y cargo gcc libudev-devel libgbm-devel libxkbcommon-devel wayland-devel libinput-devel dbus-devel systemd-devel libseat-devel pipewire-devel pango-devel cairo-gobject-devel clang libadwaita-devel
+          sudo dnf install -y cargo gcc libudev-devel libgbm-devel libxkbcommon-devel wayland-devel libinput-devel dbus-devel systemd-devel libseat-devel pipewire-devel pango-devel cairo-gobject-devel clang libadwaita-devel libdisplay-info-devel

      - uses: Swatinem/rust-cache@v2
      - run: cargo build --all
@@ -171,6 +181,8 @@ jobs:
    runs-on: ubuntu-22.04
    steps:
      - uses: actions/checkout@v4
+        with:
+          show-progress: false

      - name: Check flake inputs
        uses: DeterminateSystems/flake-checker-action@v4
@@ -180,5 +192,43 @@ jobs:
        uses: DeterminateSystems/nix-installer-action@v3
        continue-on-error: true

-      - run: nix build
+      - run: nix flake check
        continue-on-error: true
+
+  publish-wiki:
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    needs: build
+    permissions:
+      contents: write
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          lfs: true
+          show-progress: false
+      - uses: Andrew-Chen-Wang/github-wiki-action@86138cbd6328b21d759e89ab6e6dd6a139b22270
+
+  rustdoc:
+    needs: build
+    permissions:
+      contents: write
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
+
+      - uses: dtolnay/rust-toolchain@stable
+
+      - name: Generate documentation
+        run: cargo doc --no-deps -p niri-ipc
+
+      - run: cp ./resources/rustdoc-index.html ./target/doc/index.html
+
+      - name: Deploy documentation
+        if: github.ref == 'refs/heads/main'
+        uses: peaceiris/actions-gh-pages@v4
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./target/doc
+          force_orphan: true
@@ -2,21 +2,24 @@
 members = ["niri-visual-tests"]

 [workspace.package]
-version = "0.1.2"
+version = "0.1.9"
 description = "A scrollable-tiling Wayland compositor"
 authors = ["Ivan Molodetskikh <yalterz@gmail.com>"]
 license = "GPL-3.0-or-later"
 edition = "2021"
 repository = "https://github.com/YaLTeR/niri"
+rust-version = "1.77"

 [workspace.dependencies]
-anyhow = "1.0.79"
-bitflags = "2.4.2"
-clap = { version = "4.4.18", features = ["derive"] }
-serde = { version = "1.0.196", features = ["derive"] }
+anyhow = "1.0.90"
+bitflags = "2.6.0"
+clap = { version = "4.5.20", features = ["derive"] }
+k9 = "0.12.0"
+serde = { version = "1.0.210", features = ["derive"] }
+serde_json = "1.0.132"
 tracing = { version = "0.1.40", features = ["max_level_trace", "release_max_level_debug"] }
 tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
-tracy-client = { version = "0.16.5", default-features = false }
+tracy-client = { version = "0.17.4", default-features = false }

 [workspace.dependencies.smithay]
 git = "https://github.com/Smithay/smithay.git"
@@ -35,43 +38,54 @@ authors.workspace = true
 license.workspace = true
 edition.workspace = true
 repository.workspace = true
+rust-version.workspace = true

 readme = "README.md"
 keywords = ["wayland", "compositor", "tiling", "smithay", "wm"]

 [dependencies]
 anyhow.workspace = true
-arrayvec = "0.7.4"
-async-channel = { version = "2.2.0", optional = true }
+arrayvec = "0.7.6"
+async-channel = "2.3.1"
 async-io = { version = "1.13.0", optional = true }
-bitflags = "2.4.2"
-calloop = { version = "0.12.4", features = ["executor", "futures-io"] }
+atomic = "0.6.0"
+bitflags.workspace = true
+bytemuck = { version = "1.19.0", features = ["derive"] }
+calloop = { version = "0.14.1", features = ["executor", "futures-io"] }
 clap = { workspace = true, features = ["string"] }
 directories = "5.0.1"
-futures-util = { version = "0.3.30", default-features = false, features = ["std", "io"] }
+drm-ffi = "0.9.0"
+fastrand = "2.1.1"
+futures-util = { version = "0.3.31", default-features = false, features = ["std", "io"] }
 git-version = "0.3.9"
-input = { version = "0.9.0", features = ["libinput_1_21"] }
+glam = "0.29.0"
+input = { version = "0.9.1", features = ["libinput_1_21"] }
 keyframe = { version = "1.1.1", default-features = false }
-libc = "0.2.153"
-log = { version = "0.4.20", features = ["max_level_trace", "release_max_level_debug"] }
-niri-config = { version = "0.1.2", path = "niri-config" }
-niri-ipc = { version = "0.1.2", path = "niri-ipc", features = ["clap"] }
-notify-rust = { version = "4.10.0", optional = true }
-pangocairo = "0.19.1"
-pipewire = { version = "0.8.0", optional = true }
-png = "0.17.11"
-portable-atomic = { version = "1.6.0", default-features = false, features = ["float"] }
-profiling = "1.0.14"
-sd-notify = "0.4.1"
+libc = "0.2.161"
+libdisplay-info = "0.1.0"
+log = { version = "0.4.22", features = ["max_level_trace", "release_max_level_debug"] }
+niri-config = { version = "0.1.9", path = "niri-config" }
+niri-ipc = { version = "0.1.9", path = "niri-ipc", features = ["clap"] }
+notify-rust = { version = "~4.10.0", optional = true }
+ordered-float = "4.4.0"
+pango = { version = "0.20.4", features = ["v1_44"] }
+pangocairo = "0.20.4"
+pipewire = { git = "https://gitlab.freedesktop.org/pipewire/pipewire-rs.git", optional = true, features = ["v0_3_33"] }
+png = "0.17.14"
+portable-atomic = { version = "1.9.0", default-features = false, features = ["float"] }
+profiling = "1.0.16"
+sd-notify = "0.4.3"
 serde.workspace = true
-serde_json = "1.0.113"
+serde_json.workspace = true
 smithay-drm-extras.workspace = true
 tracing-subscriber.workspace = true
 tracing.workspace = true
 tracy-client.workspace = true
-url = { version = "2.5.0", optional = true }
-xcursor = "0.3.5"
-zbus = { version = "3.15.0", optional = true }
+url = { version = "2.5.2", optional = true }
+wayland-backend = "0.3.7"
+wayland-scanner = "0.31.5"
+xcursor = "0.3.8"
+zbus = { version = "~3.15.2", optional = true }

 [dependencies.smithay]
 workspace = true
@@ -92,18 +106,26 @@ features = [
 ]

 [dev-dependencies]
-proptest = "1.4.0"
-proptest-derive = "0.4.0"
-xshell = "0.2.5"
+approx = "0.5.1"
+k9.workspace = true
+proptest = "1.5.0"
+proptest-derive = { version = "0.5.0", features = ["boxed_union"] }
+xshell = "0.2.6"

 [features]
-default = ["dbus", "xdp-gnome-screencast"]
-# Enables DBus support (required for xdp-gnome and power button inhibiting).
-dbus = ["zbus", "async-channel", "async-io", "notify-rust", "url"]
+default = ["dbus", "systemd", "xdp-gnome-screencast"]
+# Enables D-Bus support (serve various freedesktop and GNOME interfaces, power button handling).
+dbus = ["zbus", "async-io", "notify-rust", "url"]
+# Enables systemd integration (global environment, apps in transient scopes).
+systemd = ["dbus"]
 # Enables screencasting support through xdg-desktop-portal-gnome.
 xdp-gnome-screencast = ["dbus", "pipewire"]
 # Enables the Tracy profiler instrumentation.
 profile-with-tracy = ["profiling/profile-with-tracy", "tracy-client/default"]
+# Enables the on-demand Tracy profiler instrumentation.
+profile-with-tracy-ondemand = ["profile-with-tracy", "tracy-client/ondemand", "tracy-client/manual-lifetime"]
+# Enables dinit integration (global environment).
+dinit = []

 [profile.release]
 debug = "line-tables-only"
@@ -115,7 +137,7 @@ lto = "thin"
 debug = false

 [package.metadata.generate-rpm]
-version = "0.1.2"
+version = "0.1.9"
 assets = [
    { source = "target/release/niri", dest = "/usr/bin/", mode = "755" },
    { source = "resources/niri-session", dest = "/usr/bin/", mode = "755" },
@@ -126,3 +148,15 @@ assets = [
 ]
 [package.metadata.generate-rpm.requires]
 alacritty = "*"
+fuzzel = "*"
+
+[package.metadata.deb]
+depends = "alacritty, fuzzel"
+assets = [
+    ["target/release/niri", "usr/bin/", "755"],
+    ["resources/niri-session", "usr/bin/", "755"],
+    ["resources/niri.desktop", "/usr/share/wayland-sessions/", "644"],
+    ["resources/niri-portals.conf", "/usr/share/xdg-desktop-portal/", "644"],
+    ["resources/niri.service", "/usr/lib/systemd/user/", "644"],
+    ["resources/niri-shutdown.target", "/usr/lib/systemd/user/", "644"],
+]
@@ -6,7 +6,11 @@
    <a href="https://github.com/YaLTeR/niri/releases"><img alt="GitHub Release" src="https://img.shields.io/github/v/release/YaLTeR/niri?logo=github"></a>
 </p>

-![](https://github.com/YaLTeR/niri/assets/1794388/16f87a4a-afac-49aa-b3e6-5e6f16c943a9)
+<p align="center">
+    <a href="https://github.com/YaLTeR/niri/wiki/Getting-Started">Getting Started</a> | <a href="https://github.com/YaLTeR/niri/wiki/Configuration:-Overview">Configuration</a> | <a href="https://github.com/YaLTeR/niri/discussions/325">Setup&nbsp;Showcase</a>
+</p>
+
+![](https://github.com/YaLTeR/niri/assets/1794388/52c799a1-77ec-455f-b4aa-f3236a144964)

 ## About

@@ -27,23 +31,24 @@ When a monitor disconnects, its workspaces will move to another monitor, but upo
 - Scrollable tiling
 - Dynamic workspaces like in GNOME
 - Built-in screenshot UI
- Monitor screencasting through xdg-desktop-portal-gnome
- Touchpad gesture to switch workspaces
+- Monitor and window screencasting through xdg-desktop-portal-gnome
+    - You can [block out](https://github.com/YaLTeR/niri/wiki/Configuration:-Window-Rules#block-out-from) sensitive windows from screencasts
+- [Touchpad](https://github.com/YaLTeR/niri/assets/1794388/946a910e-9bec-4cd1-a923-4a9421707515) and [mouse](https://github.com/YaLTeR/niri/assets/1794388/8464e65d-4bf2-44fa-8c8e-5883355bd000) gestures
 - Configurable layout: gaps, borders, struts, window sizes
+- [Gradient borders](https://github.com/YaLTeR/niri/wiki/Configuration:-Layout#gradients) with Oklab and Oklch support
+- [Animations](https://github.com/YaLTeR/niri/assets/1794388/ce178da2-af9e-4c51-876f-8709c241d95e) with support for [custom shaders](https://github.com/YaLTeR/niri/assets/1794388/27a238d6-0a22-4692-b794-30dc7a626fad)
 - Live-reloading config

 ## Video Demo

-https://github.com/YaLTeR/niri/assets/1794388/5d355694-7b06-4f00-8920-8dce54a8721c
+https://github.com/YaLTeR/niri/assets/1794388/bce834b0-f205-434e-a027-b373495f9729

 ## Status

 A lot of the essential functionality is implemented, plus some goodies on top.
-Feel free to give niri a try.
+Feel free to give niri a try: follow the instructions on the [Getting Started](https://github.com/YaLTeR/niri/wiki/Getting-Started) wiki page.
 Have your [waybar]s and [fuzzel]s ready: niri is not a complete desktop environment.

-Note that NVIDIA GPUs might have rendering issues.
-
 ## Inspiration

 Niri is heavily inspired by [PaperWM] which implements scrollable tiling on top of GNOME Shell.
@@ -51,162 +56,25 @@ Niri is heavily inspired by [PaperWM] which implements scrollable tiling on top
 One of the reasons that prompted me to try writing my own compositor is being able to properly separate the monitors.
 Being a GNOME Shell extension, PaperWM has to work against Shell's global window coordinate space to prevent windows from overflowing.

-## Building
+## Tile Scrollably Elsewhere

-> [!TIP]
-> For Fedora users, there's a COPR with built and packaged niri: https://copr.fedorainfracloud.org/coprs/yalter/niri/
->
-> NixOS users, check out https://github.com/sodiboo/niri-flake
->
-> For Arch users, there's an AUR package: https://aur.archlinux.org/packages/niri
+Here are some other projects which implement a similar workflow:

-First, install the dependencies for your distribution.
-
- Ubuntu 23.10:
-
-    ```sh
-    sudo apt-get install -y gcc clang libudev-dev libgbm-dev libxkbcommon-dev libegl1-mesa-dev libwayland-dev libinput-dev libdbus-1-dev libsystemd-dev libseat-dev libpipewire-0.3-dev libpango1.0-dev
-    ```
-
- Fedora:
-
-    ```sh
-    sudo dnf install gcc libudev-devel libgbm-devel libxkbcommon-devel wayland-devel libinput-devel dbus-devel systemd-devel libseat-devel pipewire-devel pango-devel cairo-gobject-devel clang
-    ```
-
-Next, get latest stable Rust: https://rustup.rs/
-
-Then, build niri with `cargo build --release`.
-
-### NixOS/Nix
-
-We have a community-maintained flake which provides a devshell with required dependencies. Use `nix build` to build niri, and then run `./results/bin/niri`.
-    
-If you're not on NixOS, you may need [NixGL](https://github.com/nix-community/nixGL) to run the resulting binary:
-
-```
-nix run --impure github:guibou/nixGL -- ./results/bin/niri
-```
-
-## Installation
-
-The recommended way to install and run niri is as a standalone desktop session.
-To do that, put files into the correct directories according to this table.
-
-| File | Destination |
-| ---- | ----------- |
-| `target/release/niri` | `/usr/bin/` |
-| `resources/niri-session` | `/usr/bin/` |
-| `resources/niri.desktop` | `/usr/share/wayland-sessions/` |
-| `resources/niri-portals.conf` | `/usr/share/xdg-desktop-portal/` |
-| `resources/niri.service` | `/usr/lib/systemd/user/` |
-| `resources/niri-shutdown.target` | `/usr/lib/systemd/user/` |
-
-Doing this will make niri appear in GDM and, presumably, other display managers.
-
-## Running
-
-`cargo run --release`
-
-Inside an existing desktop session, it will run in a window.
-On a TTY, it will run natively.
-
-To exit when running on a TTY, press <kbd>Super</kbd><kbd>Shift</kbd><kbd>E</kbd>.
-
-### Session
-
-If you followed the recommended installation steps above, niri should appear in your display manager.
-Starting it from there will run niri as a desktop session.
-
-The niri session will autostart apps through the systemd xdg-autostart target.
-You can also autostart systemd services like [mako] by symlinking them into `$HOME/.config/systemd/user/niri.service.wants/`.
-A step-by-step process for this is explained [on the wiki](https://github.com/YaLTeR/niri/wiki/Example-systemd-Setup).
-
-Niri also works with some parts of xdg-desktop-portal-gnome.
-In particular, it supports file choosers and monitor screencasting (e.g. to [OBS]).
-
-[This wiki page](https://github.com/YaLTeR/niri/wiki/Important-Software) explains how to run important software required for normal desktop use, including portals.
-
-### Xwayland
-
-See [the wiki page](https://github.com/YaLTeR/niri/wiki/Xwayland) to learn how to use Xwayland with niri.
-
-### IPC
-
-You can communicate with the running niri instance over an IPC socket.
-Check `niri msg --help` for available commands.
-
-The `--json` flag prints the response in JSON, rather than formatted.
-For example, `niri msg --json outputs`.
-
-For programmatic access, check the [niri-ipc sub-crate](./niri-ipc/) which defines the types.
-The communication over the IPC socket happens in JSON.
-
-## Default Hotkeys
-
-When running on a TTY, the Mod key is <kbd>Super</kbd>.
-When running in a window, the Mod key is <kbd>Alt</kbd>.
-
-The general system is: if a hotkey switches somewhere, then adding <kbd>Ctrl</kbd> will move the focused window or column there.
-
-| Hotkey | Description |
-| ------ | ----------- |
-| <kbd>Mod</kbd><kbd>Shift</kbd><kbd>/</kbd> | Show a list of important niri hotkeys |
-| <kbd>Mod</kbd><kbd>T</kbd> | Spawn `alacritty` (terminal) |
-| <kbd>Mod</kbd><kbd>D</kbd> | Spawn `fuzzel` (application launcher) |
-| <kbd>Mod</kbd><kbd>Alt</kbd><kbd>L</kbd> | Spawn `swaylock` (screen locker) |
-| <kbd>Mod</kbd><kbd>Q</kbd> | Close the focused window |
-| <kbd>Mod</kbd><kbd>H</kbd> or <kbd>Mod</kbd><kbd>←</kbd> | Focus the column to the left |
-| <kbd>Mod</kbd><kbd>L</kbd> or <kbd>Mod</kbd><kbd>→</kbd> | Focus the column to the right |
-| <kbd>Mod</kbd><kbd>J</kbd> or <kbd>Mod</kbd><kbd>↓</kbd> | Focus the window below in a column |
-| <kbd>Mod</kbd><kbd>K</kbd> or <kbd>Mod</kbd><kbd>↑</kbd> | Focus the window above in a column |
-| <kbd>Mod</kbd><kbd>Ctrl</kbd><kbd>H</kbd> or <kbd>Mod</kbd><kbd>Ctrl</kbd><kbd>←</kbd> | Move the focused column to the left |
-| <kbd>Mod</kbd><kbd>Ctrl</kbd><kbd>L</kbd> or <kbd>Mod</kbd><kbd>Ctrl</kbd><kbd>→</kbd> | Move the focused column to the right |
-| <kbd>Mod</kbd><kbd>Ctrl</kbd><kbd>J</kbd> or <kbd>Mod</kbd><kbd>Ctrl</kbd><kbd>↓</kbd> | Move the focused window below in a column |
-| <kbd>Mod</kbd><kbd>Ctrl</kbd><kbd>K</kbd> or <kbd>Mod</kbd><kbd>Ctrl</kbd><kbd>↑</kbd> | Move the focused window above in a column |
-| <kbd>Mod</kbd><kbd>Home</kbd> and <kbd>Mod</kbd><kbd>End</kbd> | Focus the first or the last column |
-| <kbd>Mod</kbd><kbd>Ctrl</kbd><kbd>Home</kbd> and <kbd>Mod</kbd><kbd>Ctrl</kbd><kbd>End</kbd> | Move the focused column to the very start or to the very end |
-| <kbd>Mod</kbd><kbd>Shift</kbd><kbd>H</kbd><kbd>J</kbd><kbd>K</kbd><kbd>L</kbd> or <kbd>Mod</kbd><kbd>Shift</kbd><kbd>←</kbd><kbd>↓</kbd><kbd>↑</kbd><kbd>→</kbd> | Focus the monitor to the side |
-| <kbd>Mod</kbd><kbd>Ctrl</kbd><kbd>Shift</kbd><kbd>H</kbd><kbd>J</kbd><kbd>K</kbd><kbd>L</kbd> or <kbd>Mod</kbd><kbd>Ctrl</kbd><kbd>Shift</kbd><kbd>←</kbd><kbd>↓</kbd><kbd>↑</kbd><kbd>→</kbd> | Move the focused column to the monitor to the side |
-| <kbd>Mod</kbd><kbd>U</kbd> or <kbd>Mod</kbd><kbd>PageDown</kbd> | Switch to the workspace below |
-| <kbd>Mod</kbd><kbd>I</kbd> or <kbd>Mod</kbd><kbd>PageUp</kbd> | Switch to the workspace above |
-| <kbd>Mod</kbd><kbd>Ctrl</kbd><kbd>U</kbd> or <kbd>Mod</kbd><kbd>Ctrl</kbd><kbd>PageDown</kbd> | Move the focused column to the workspace below |
-| <kbd>Mod</kbd><kbd>Ctrl</kbd><kbd>I</kbd> or <kbd>Mod</kbd><kbd>Ctrl</kbd><kbd>PageUp</kbd> | Move the focused column to the workspace above |
-| <kbd>Mod</kbd><kbd>1</kbd>–<kbd>9</kbd> | Switch to a workspace by index |
-| <kbd>Mod</kbd><kbd>Ctrl</kbd><kbd>1</kbd>–<kbd>9</kbd> | Move the focused column to a workspace by index |
-| <kbd>Mod</kbd><kbd>Shift</kbd><kbd>U</kbd> or <kbd>Mod</kbd><kbd>Shift</kbd><kbd>PageDown</kbd> | Move the focused workspace down |
-| <kbd>Mod</kbd><kbd>Shift</kbd><kbd>I</kbd> or <kbd>Mod</kbd><kbd>Shift</kbd><kbd>PageUp</kbd> | Move the focused workspace up |
-| <kbd>Mod</kbd><kbd>,</kbd> | Consume the window to the right into the focused column |
-| <kbd>Mod</kbd><kbd>.</kbd> | Expel the focused window into its own column |
-| <kbd>Mod</kbd><kbd>R</kbd> | Toggle between preset column widths |
-| <kbd>Mod</kbd><kbd>F</kbd> | Maximize column |
-| <kbd>Mod</kbd><kbd>C</kbd> | Center column within view |
-| <kbd>Mod</kbd><kbd>-</kbd> | Decrease column width by 10% |
-| <kbd>Mod</kbd><kbd>=</kbd> | Increase column width by 10% |
-| <kbd>Mod</kbd><kbd>Shift</kbd><kbd>-</kbd> | Decrease window height by 10% |
-| <kbd>Mod</kbd><kbd>Shift</kbd><kbd>=</kbd> | Increase window height by 10% |
-| <kbd>Mod</kbd><kbd>Shift</kbd><kbd>F</kbd> | Toggle full-screen on the focused window |
-| <kbd>PrtSc</kbd> | Take an area screenshot. Select the area to screenshot with mouse, then press Space to save the screenshot, or Escape to cancel |
-| <kbd>Alt</kbd><kbd>PrtSc</kbd> | Take a screenshot of the focused window to clipboard and to `~/Pictures/Screenshots/` |
-| <kbd>Ctrl</kbd><kbd>PrtSc</kbd> | Take a screenshot of the focused monitor to clipboard and to `~/Pictures/Screenshots/` |
-| <kbd>Mod</kbd><kbd>Ctrl</kbd><kbd>Shift</kbd><kbd>T</kbd> | Toggle debug tinting of rendered elements |
-| <kbd>Mod</kbd><kbd>Shift</kbd><kbd>E</kbd> | Exit niri |
-
-## Configuration
-
-Niri will load configuration from `$XDG_CONFIG_HOME/.config/niri/config.kdl` or `~/.config/niri/config.kdl`.
-If this fails, it will load [the default configuration file](resources/default-config.kdl).
-Please use the default configuration file as the starting point for your custom configuration.
-
-Niri will live-reload most of the configuration settings, like key binds or gaps or output modes, as you change the config file.
+- [PaperWM]: scrollable tiling on top of GNOME Shell.
+- [karousel]: scrollable tiling on top of KDE.
+- [papersway]: scrollable tiling on top of sway/i3.
+- [hyprscroller] and [hyprslidr]: scrollable tiling on top of Hyprland.
+- [PaperWM.spoon]: scrollable tiling on top of macOS.

 ## Contact

 We have a Matrix chat, feel free to join and ask a question: https://matrix.to/#/#niri:matrix.org

 [PaperWM]: https://github.com/paperwm/PaperWM
-[mako]: https://github.com/emersion/mako
-[OBS]: https://flathub.org/apps/com.obsproject.Studio
 [waybar]: https://github.com/Alexays/Waybar
 [fuzzel]: https://codeberg.org/dnkl/fuzzel
-
+[karousel]: https://github.com/peterfajdiga/karousel
+[papersway]: https://spwhitton.name/tech/code/papersway/
+[hyprscroller]: https://github.com/dawsers/hyprscroller
+[hyprslidr]: https://gitlab.com/magus/hyprslidr
+[PaperWM.spoon]: https://github.com/mogenson/PaperWM.spoon
@@ -0,0 +1,5 @@
+ignore-interior-mutability = [
+    "smithay::desktop::Window",
+    "smithay::output::Output",
+    "wayland_server::backend::ClientId",
+]
@@ -1,72 +1,12 @@
 {
  "nodes": {
-    "crane": {
-      "inputs": {
-        "nixpkgs": [
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1707685877,
-        "narHash": "sha256-XoXRS+5whotelr1rHiZle5t5hDg9kpguS5yk8c8qzOc=",
-        "owner": "ipetkov",
-        "repo": "crane",
-        "rev": "2c653e4478476a52c6aa3ac0495e4dea7449ea0e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "ipetkov",
-        "repo": "crane",
-        "type": "github"
-      }
-    },
-    "fenix": {
-      "inputs": {
-        "nixpkgs": [
-          "nixpkgs"
-        ],
-        "rust-analyzer-src": "rust-analyzer-src"
-      },
-      "locked": {
-        "lastModified": 1706768574,
-        "narHash": "sha256-4o6TMpzBHO659EiJTzd/EGQGUDdbgwKwhqf3u6b23U8=",
-        "owner": "nix-community",
-        "repo": "fenix",
-        "rev": "668102037129923cd0fc239d864fce71eabdc6a3",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-community",
-        "ref": "monthly",
-        "repo": "fenix",
-        "type": "github"
-      }
-    },
-    "flake-utils": {
-      "inputs": {
-        "systems": "systems"
-      },
-      "locked": {
-        "lastModified": 1705309234,
-        "narHash": "sha256-uNRRNRKmJyCRC/8y1RqBkqWBLM034y4qN7EprSdmgyA=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "1ef2e671c3b0c19053962c07dbda38332dcebf26",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
    "nix-filter": {
      "locked": {
-        "lastModified": 1705332318,
-        "narHash": "sha256-kcw1yFeJe9N4PjQji9ZeX47jg0p9A0DuU4djKvg1a7I=",
+        "lastModified": 1710156097,
+        "narHash": "sha256-1Wvk8UP7PXdf8bCCaEoMnOT1qe5/Duqgj+rL8sRQsSM=",
        "owner": "numtide",
        "repo": "nix-filter",
-        "rev": "3449dc925982ad46246cfc36469baf66e1b64f17",
+        "rev": "3342559a24e85fc164b295c3444e8a139924675b",
        "type": "github"
      },
      "original": {
@@ -77,11 +17,11 @@
    },
    "nixpkgs": {
      "locked": {
-        "lastModified": 1707619277,
-        "narHash": "sha256-vKnYD5GMQbNQyyQm4wRlqi+5n0/F1hnvqSQgaBy4BqY=",
+        "lastModified": 1726365531,
+        "narHash": "sha256-luAKNxWZ+ZN0kaHchx1OdLQ71n81Y31ryNPWP1YRDZc=",
        "owner": "NixOS",
        "repo": "nixpkgs",
-        "rev": "f3a93440fbfff8a74350f4791332a19282cc6dc8",
+        "rev": "9299cdf978e15f448cf82667b0ffdd480b44ee48",
        "type": "github"
      },
      "original": {
@@ -93,42 +33,28 @@
    },
    "root": {
      "inputs": {
-        "crane": "crane",
-        "fenix": "fenix",
-        "flake-utils": "flake-utils",
        "nix-filter": "nix-filter",
-        "nixpkgs": "nixpkgs"
+        "nixpkgs": "nixpkgs",
+        "rust-overlay": "rust-overlay"
      }
    },
-    "rust-analyzer-src": {
-      "flake": false,
+    "rust-overlay": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
      "locked": {
-        "lastModified": 1706735270,
-        "narHash": "sha256-IJk+UitcJsxzMQWm9pa1ZbJBriQ4ginXOlPyVq+Cu40=",
-        "owner": "rust-lang",
-        "repo": "rust-analyzer",
-        "rev": "42cb1a2bd79af321b0cc503d2960b73f34e2f92b",
+        "lastModified": 1727663505,
+        "narHash": "sha256-83j/GrHsx8GFUcQofKh+PRPz6pz8sxAsZyT/HCNdey8=",
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "rev": "c2099c6c7599ea1980151b8b6247a8f93e1806ee",
        "type": "github"
      },
      "original": {
-        "owner": "rust-lang",
-        "ref": "nightly",
-        "repo": "rust-analyzer",
-        "type": "github"
-      }
-    },
-    "systems": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
+        "owner": "oxalica",
+        "repo": "rust-overlay",
        "type": "github"
      }
    }
@@ -1,102 +1,251 @@
 # This flake file is community maintained
-# Maintainers:
-#   Bill Sun (github/billksun)
 {
  description = "Niri: A scrollable-tiling Wayland compositor.";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
-    crane = {
-      url = "github:ipetkov/crane";
-      inputs.nixpkgs.follows = "nixpkgs";
-    };
-    flake-utils.url = "github:numtide/flake-utils";
    nix-filter.url = "github:numtide/nix-filter";
-    fenix = {
-      url = "github:nix-community/fenix/monthly";
+
+    # NOTE: This is not necessary for end users
+    # You can omit it with `inputs.rust-overlay.follows = ""`
+    rust-overlay = {
+      url = "github:oxalica/rust-overlay";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };

-  outputs = {
-    self,
-    nixpkgs,
-    crane,
-    nix-filter,
-    flake-utils,
-    fenix,
-    ...
-  }: let
-    systems = ["aarch64-linux" "x86_64-linux"];
-  in
-    flake-utils.lib.eachSystem systems (
-      system: let
-        pkgs = nixpkgs.legacyPackages.${system};
-        toolchain = fenix.packages.${system}.complete.toolchain;
-        craneLib = crane.lib.${system}.overrideToolchain toolchain;
+  outputs =
+    {
+      self,
+      nixpkgs,
+      nix-filter,
+      rust-overlay,
+    }:
+    let
+      niri-package =
+        {
+          lib,
+          cairo,
+          clang,
+          dbus,
+          libGL,
+          libclang,
+          libdisplay-info,
+          libinput,
+          libseat,
+          libxkbcommon,
+          mesa,
+          pango,
+          pipewire,
+          pkg-config,
+          rustPlatform,
+          systemd,
+          wayland,
+          withDbus ? true,
+          withSystemd ? true,
+          withScreencastSupport ? true,
+          withDinit ? false,
+        }:

-        craneArgs = {
+        rustPlatform.buildRustPackage {
          pname = "niri";
-          version = self.rev or "dirty";
+          version = self.shortRev or self.dirtyShortRev or "unknown";

-          src = nixpkgs.lib.cleanSourceWith {
-            src = craneLib.path ./.;
-            filter = path: type:
-              (builtins.match "resources" path == null) ||
-              ((craneLib.filterCargoSources path type) &&
-              (builtins.match "niri-visual-tests" path == null));
+          src = nix-filter.lib.filter {
+            root = self;
+            include = [
+              "niri-config"
+              "niri-ipc"
+              "niri-visual-tests"
+              "resources"
+              "src"
+              ./Cargo.lock
+              ./Cargo.toml
+            ];
          };

-          nativeBuildInputs = with pkgs; [
-            pkg-config
-            autoPatchelfHook
+          postPatch = ''
+            patchShebangs resources/niri-session
+            substituteInPlace resources/niri.service \
+              --replace-fail '/usr/bin' "$out/bin"
+          '';
+
+          cargoLock = {
+            # NOTE: This is only used for Git dependencies
+            allowBuiltinFetchGit = true;
+            lockFile = ./Cargo.lock;
+          };
+
+          strictDeps = true;
+
+          nativeBuildInputs = [
            clang
+            pkg-config
          ];

-          buildInputs = with pkgs; [
-            wayland
-            systemd # For libudev
-            seatd # For libseat
-            libxkbcommon
-            libinput
-            mesa # For libgbm
-            fontconfig
-            stdenv.cc.cc.lib
-            pipewire
-            pango
-          ];
+          buildInputs =
+            [
+              cairo
+              dbus
+              libGL
+              libdisplay-info
+              libinput
+              libseat
+              libxkbcommon
+              mesa # libgbm
+              pango
+              wayland
+            ]
+            ++ lib.optional (withDbus || withScreencastSupport || withSystemd) dbus
+            ++ lib.optional withScreencastSupport pipewire
+            # Also includes libudev
+            ++ lib.optional withSystemd systemd;

-          runtimeDependencies = with pkgs; [
-            wayland
-            mesa
-            libglvnd # For libEGL
-          ];
+          buildFeatures =
+            lib.optional withDbus "dbus"
+            ++ lib.optional withDinit "dinit"
+            ++ lib.optional withScreencastSupport "xdp-gnome-screencast"
+            ++ lib.optional withSystemd "systemd";
+          buildNoDefaultFeatures = true;

-          LIBCLANG_PATH = "${pkgs.libclang.lib}/lib";
+          postInstall =
+            ''
+              install -Dm644 resources/niri.desktop -t $out/share/wayland-sessions
+              install -Dm644 resources/niri-portals.conf -t $out/share/xdg-desktop-portal
+            ''
+            + lib.optionalString withSystemd ''
+              install -Dm755 resources/niri-session $out/bin/niri-session
+              install -Dm644 resources/niri{.service,-shutdown.target} -t $out/share/systemd/user
+            '';
+
+          env = {
+            LIBCLANG_PATH = lib.getLib libclang + "/lib";
+
+            # Force linking with libEGL and libwayland-client
+            # so they can be discovered by `dlopen()`
+            CARGO_BUILD_RUSTFLAGS = toString (
+              map (arg: "-C link-arg=" + arg) [
+                "-Wl,--push-state,--no-as-needed"
+                "-lEGL"
+                "-lwayland-client"
+                "-Wl,--pop-state"
+              ]
+            );
+          };
+
+          passthru = {
+            providedSessions = [ "niri" ];
+          };
+
+          meta = {
+            description = "Scrollable-tiling Wayland compositor";
+            homepage = "https://github.com/YaLTeR/niri";
+            license = lib.licenses.gpl3Only;
+            mainProgram = "niri";
+            platforms = lib.platforms.linux;
+          };
        };

-        cargoArtifacts = craneLib.buildDepsOnly craneArgs;
-        niri = craneLib.buildPackage (craneArgs // {inherit cargoArtifacts;});
-      in {
-        formatter = pkgs.alejandra;
+      inherit (nixpkgs) lib;
+      # Support all Linux systems that the nixpkgs flake exposes
+      systems = lib.intersectLists lib.systems.flakeExposed lib.platforms.linux;

-        checks.niri = niri;
-        packages.default = niri;
+      forAllSystems = lib.genAttrs systems;
+      nixpkgsFor = forAllSystems (system: nixpkgs.legacyPackages.${system});
+    in
+    {
+      checks = forAllSystems (system: {
+        # We use the debug build here to save a bit of time
+        inherit (self.packages.${system}) niri-debug;
+      });

-        devShells.default = pkgs.mkShell.override {stdenv = pkgs.clangStdenv;} {
-          inherit (niri) nativeBuildInputs buildInputs LIBCLANG_PATH;
-          packages = niri.runtimeDependencies;
+      devShells = forAllSystems (
+        system:
+        let
+          pkgs = nixpkgsFor.${system};
+          rust-bin = rust-overlay.lib.mkRustBin { } pkgs;
+          inherit (self.packages.${system}) niri;
+        in
+        {
+          default = pkgs.mkShell {
+            packages = [
+              # We don't use the toolchain from nixpkgs
+              # because we prefer a nightly toolchain
+              # and we *require* a nightly rustfmt
+              (rust-bin.selectLatestNightlyWith (
+                toolchain:
+                toolchain.default.override {
+                  extensions = [
+                    # includes already:
+                    # rustc
+                    # cargo
+                    # rust-std
+                    # rust-docs
+                    # rustfmt-preview
+                    # clippy-preview
+                    "rust-analyzer"
+                    "rust-src"
+                  ];
+                }
+              ))
+            ];

-          # Force linking to libEGL, which is always dlopen()ed, and to
-          # libwayland-client, which is always dlopen()ed except by the
-          # obscure winit backend.
-          RUSTFLAGS = map (a: "-C link-arg=${a}") [
-            "-Wl,--push-state,--no-as-needed"
-            "-lEGL"
-            "-lwayland-client"
-            "-Wl,--pop-state"
-          ];
-        };
-      }
-    );
+            nativeBuildInputs = [
+              pkgs.clang
+              pkgs.pkg-config
+              pkgs.wrapGAppsHook4 # For `niri-visual-tests`
+            ];
+
+            buildInputs = niri.buildInputs ++ [
+              pkgs.libadwaita # For `niri-visual-tests`
+            ];
+
+            env = {
+              inherit (niri) LIBCLANG_PATH;
+
+              # WARN: Do not overwrite this variable in your shell!
+              # It is required for `dlopen()` to work on some libraries; see the comment
+              # in the package expression
+              #
+              # This should only be set with `CARGO_BUILD_RUSTFLAGS="$CARGO_BUILD_RUSTFLAGS -C your-flags"`
+              inherit (niri) CARGO_BUILD_RUSTFLAGS;
+            };
+          };
+        }
+      );
+
+      formatter = forAllSystems (system: nixpkgsFor.${system}.nixfmt-rfc-style);
+
+      packages = forAllSystems (
+        system:
+        let
+          niri = nixpkgsFor.${system}.callPackage niri-package { };
+        in
+        {
+          inherit niri;
+
+          # NOTE: This is for development purposes only
+          #
+          # It is primarily to help with quickly iterating on
+          # changes made to the above expression - though it is
+          # also not stripped in order to better debug niri itself
+          niri-debug = niri.overrideAttrs (
+            newAttrs: oldAttrs: {
+              pname = oldAttrs.pname + "-debug";
+
+              cargoBuildType = "debug";
+              cargoCheckType = newAttrs.cargoBuildType;
+
+              dontStrip = true;
+            }
+          );
+
+          default = niri;
+        }
+      );
+
+      overlays.default = final: _: {
+        niri = final.callPackage niri-package { };
+      };
+    };
 }
@@ -9,10 +9,16 @@ repository.workspace = true

 [dependencies]
 bitflags.workspace = true
+csscolorparser = "0.7.0"
 knuffel = "3.2.0"
 miette = "5.10.0"
-niri-ipc = { version = "0.1.2", path = "../niri-ipc" }
-regex = "1.10.3"
+niri-ipc = { version = "0.1.9", path = "../niri-ipc" }
+regex = "1.11.0"
 smithay = { workspace = true, features = ["backend_libinput"] }
 tracing.workspace = true
 tracy-client.workspace = true
+
+[dev-dependencies]
+k9.workspace = true
+miette = { version = "5.10.0", features = ["fancy"] }
+pretty_assertions = "1.4.1"
@@ -0,0 +1,111 @@
+use std::fs;
+use std::path::PathBuf;
+
+struct KdlCodeBlock {
+    filename: String,
+    code: String,
+    line_number: usize,
+    must_fail: bool,
+}
+
+fn extract_kdl_from_file(file_contents: &str, filename: &str) -> Vec<KdlCodeBlock> {
+    let mut lines = file_contents
+        .lines()
+        .map(|line| {
+            // Removes the > from callouts that might contain ```kdl```
+            let line = line.trim();
+            if line.starts_with('>') {
+                if line.len() == 1 {
+                    ""
+                } else {
+                    &line[2..]
+                }
+            } else {
+                line
+            }
+        })
+        .enumerate();
+
+    let mut kdl_code_blocks = vec![];
+
+    while let Some((line_number, line)) = lines.next() {
+        if !line.starts_with("```kdl") {
+            continue;
+        }
+
+        let mut snippet = String::new();
+
+        for (_, line) in lines
+            .by_ref()
+            .take_while(|(_, line)| !line.starts_with("```"))
+        {
+            snippet.push_str(line);
+            snippet.push('\n');
+        }
+
+        kdl_code_blocks.push(KdlCodeBlock {
+            code: snippet,
+            line_number,
+            filename: filename.to_string(),
+            must_fail: line.contains("must-fail"),
+        });
+    }
+
+    kdl_code_blocks
+}
+
+#[test]
+fn wiki_docs_parses() {
+    let wiki_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../wiki");
+
+    let code_blocks = fs::read_dir(wiki_dir)
+        .unwrap()
+        .filter_map(|entry| entry.ok())
+        .filter(|entry| entry.file_type().is_ok_and(|ft| ft.is_file()))
+        .filter(|file| {
+            file.path()
+                .extension()
+                .map(|ext| ext == "md")
+                .unwrap_or(false)
+        })
+        .flat_map(|file| {
+            let file_contents = fs::read_to_string(file.path()).unwrap();
+            let file_path = file.path();
+            let filename = file_path.to_str().unwrap();
+            extract_kdl_from_file(&file_contents, filename)
+        });
+
+    let mut errors = vec![];
+
+    for KdlCodeBlock {
+        code,
+        line_number,
+        filename,
+        must_fail,
+    } in code_blocks
+    {
+        if let Err(error) = niri_config::Config::parse(&filename, &code) {
+            if !must_fail {
+                errors.push(format!(
+                    "Error parsing wiki KDL code block at {}:{}: {:?}",
+                    filename,
+                    line_number,
+                    miette::Report::new(error)
+                ));
+            }
+        } else if must_fail {
+            errors.push(format!(
+                "Expected error parsing wiki KDL code block at {}:{}",
+                filename, line_number
+            ));
+        }
+    }
+
+    if !errors.is_empty() {
+        panic!(
+            "Errors parsing {} wiki KDL code blocks:\n{}",
+            errors.len(),
+            errors.join("\n")
+        );
+    }
+}
@@ -9,7 +9,10 @@ repository.workspace = true

 [dependencies]
 clap = { workspace = true, optional = true }
+schemars = { version = "0.8.21", optional = true }
 serde.workspace = true
+serde_json.workspace = true

 [features]
 clap = ["dep:clap"]
+json-schema = ["dep:schemars"]
@@ -1,4 +1,24 @@
 //! Types for communicating with niri via IPC.
+//!
+//! After connecting to the niri socket, you can send a single [`Request`] and receive a single
+//! [`Reply`], which is a `Result` wrapping a [`Response`]. If you requested an event stream, you
+//! can keep reading [`Event`]s from the socket after the response.
+//!
+//! You can use the [`socket::Socket`] helper if you're fine with blocking communication. However,
+//! it is a fairly simple helper, so if you need async, or if you're using a different language,
+//! you are encouraged to communicate with the socket manually.
+//!
+//! 1. Read the socket filesystem path from [`socket::SOCKET_PATH_ENV`] (`$NIRI_SOCKET`).
+//! 2. Connect to the socket and write a JSON-formatted [`Request`] on a single line. You can follow
+//!    up with a line break and a flush, or just flush and shutdown the write end of the socket.
+//! 3. Niri will respond with a single line JSON-formatted [`Reply`].
+//! 4. If you requested an event stream, niri will keep responding with JSON-formatted [`Event`]s,
+//!    on a single line each.
+//!
+//! ## Backwards compatibility
+//!
+//! This crate follows the niri version. It is **not** API-stable in terms of the Rust semver. In
+//! particular, expect new struct fields and enum variants to be added in patch version bumps.
 #![warn(missing_docs)]

 use std::collections::HashMap;
@@ -6,16 +26,57 @@ use std::str::FromStr;

 use serde::{Deserialize, Serialize};

-/// Name of the environment variable containing the niri IPC socket path.
-pub const SOCKET_PATH_ENV: &str = "NIRI_SOCKET";
+pub mod socket;
+pub mod state;

 /// Request from client to niri.
 #[derive(Debug, Serialize, Deserialize, Clone)]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
 pub enum Request {
+    /// Request the version string for the running niri instance.
+    Version,
    /// Request information about connected outputs.
    Outputs,
+    /// Request information about workspaces.
+    Workspaces,
+    /// Request information about open windows.
+    Windows,
+    /// Request information about the configured keyboard layouts.
+    KeyboardLayouts,
+    /// Request information about the focused output.
+    FocusedOutput,
+    /// Request information about the focused window.
+    FocusedWindow,
    /// Perform an action.
    Action(Action),
+    /// Change output configuration temporarily.
+    ///
+    /// The configuration is changed temporarily and not saved into the config file. If the output
+    /// configuration subsequently changes in the config file, these temporary changes will be
+    /// forgotten.
+    Output {
+        /// Output name.
+        output: String,
+        /// Configuration to apply.
+        action: OutputAction,
+    },
+    /// Start continuously receiving events from the compositor.
+    ///
+    /// The compositor should reply with `Reply::Ok(Response::Handled)`, then continuously send
+    /// [`Event`]s, one per line.
+    ///
+    /// The event stream will always give you the full current state up-front. For example, the
+    /// first workspace-related event you will receive will be [`Event::WorkspacesChanged`]
+    /// containing the full current workspaces state. You *do not* need to separately send
+    /// [`Request::Workspaces`] when using the event stream.
+    ///
+    /// Where reasonable, event stream state updates are atomic, though this is not always the
+    /// case. For example, a window may end up with a workspace id for a workspace that had already
+    /// been removed. This can happen if the corresponding [`Event::WorkspacesChanged`] arrives
+    /// before the corresponding [`Event::WindowOpenedOrChanged`].
+    EventStream,
+    /// Respond with an error (for testing error handling).
+    ReturnError,
 }

 /// Reply from niri to client.
@@ -30,13 +91,28 @@ pub type Reply = Result<Response, String>;

 /// Successful response from niri to client.
 #[derive(Debug, Serialize, Deserialize, Clone)]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
 pub enum Response {
    /// A request that does not need a response was handled successfully.
    Handled,
+    /// The version string for the running niri instance.
+    Version(String),
    /// Information about connected outputs.
    ///
-    /// Map from connector name to output info.
+    /// Map from output name to output info.
    Outputs(HashMap<String, Output>),
+    /// Information about workspaces.
+    Workspaces(Vec<Workspace>),
+    /// Information about open windows.
+    Windows(Vec<Window>),
+    /// Information about the keyboard layout.
+    KeyboardLayouts(KeyboardLayouts),
+    /// Information about the focused output.
+    FocusedOutput(Option<Output>),
+    /// Information about the focused window.
+    FocusedWindow(Option<Window>),
+    /// Output configuration change result.
+    OutputConfigChanged(OutputConfigChanged),
 }

 /// Actions that niri can perform.
@@ -46,6 +122,7 @@ pub enum Response {
 #[cfg_attr(feature = "clap", derive(clap::Parser))]
 #[cfg_attr(feature = "clap", command(subcommand_value_name = "ACTION"))]
 #[cfg_attr(feature = "clap", command(subcommand_help_heading = "Actions"))]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
 pub enum Action {
    /// Exit niri.
    Quit {
@@ -54,133 +131,257 @@ pub enum Action {
        skip_confirmation: bool,
    },
    /// Power off all monitors via DPMS.
-    PowerOffMonitors,
+    PowerOffMonitors {},
+    /// Power on all monitors via DPMS.
+    PowerOnMonitors {},
    /// Spawn a command.
    Spawn {
        /// Command to spawn.
        #[cfg_attr(feature = "clap", arg(last = true, required = true))]
        command: Vec<String>,
    },
-    /// Open the screenshot UI.
-    Screenshot,
-    /// Screenshot the focused screen.
-    ScreenshotScreen,
-    /// Screenshot the focused window.
-    ScreenshotWindow,
-    /// Close the focused window.
-    CloseWindow,
-    /// Toggle fullscreen on the focused window.
-    FullscreenWindow,
-    /// Focus the column to the left.
-    FocusColumnLeft,
-    /// Focus the column to the right.
-    FocusColumnRight,
-    /// Focus the first column.
-    FocusColumnFirst,
-    /// Focus the last column.
-    FocusColumnLast,
-    /// Focus the window below.
-    FocusWindowDown,
-    /// Focus the window above.
-    FocusWindowUp,
-    /// Focus the window or the workspace above.
-    FocusWindowOrWorkspaceDown,
-    /// Focus the window or the workspace above.
-    FocusWindowOrWorkspaceUp,
-    /// Move the focused column to the left.
-    MoveColumnLeft,
-    /// Move the focused column to the right.
-    MoveColumnRight,
-    /// Move the focused column to the start of the workspace.
-    MoveColumnToFirst,
-    /// Move the focused column to the end of the workspace.
-    MoveColumnToLast,
-    /// Move the focused window down in a column.
-    MoveWindowDown,
-    /// Move the focused window up in a column.
-    MoveWindowUp,
-    /// Move the focused window down in a column or to the workspace below.
-    MoveWindowDownOrToWorkspaceDown,
-    /// Move the focused window up in a column or to the workspace above.
-    MoveWindowUpOrToWorkspaceUp,
-    /// Consume or expel the focused window left.
-    ConsumeOrExpelWindowLeft,
-    /// Consume or expel the focused window right.
-    ConsumeOrExpelWindowRight,
-    /// Consume the window to the right into the focused column.
-    ConsumeWindowIntoColumn,
-    /// Expel the focused window from the column.
-    ExpelWindowFromColumn,
-    /// Center the focused column on the screen.
-    CenterColumn,
-    /// Focus the workspace below.
-    FocusWorkspaceDown,
-    /// Focus the workspace above.
-    FocusWorkspaceUp,
-    /// Focus a workspace by index.
-    FocusWorkspace {
-        /// Index of the workspace to focus.
-        #[cfg_attr(feature = "clap", arg())]
-        index: u8,
+    /// Do a screen transition.
+    DoScreenTransition {
+        /// Delay in milliseconds for the screen to freeze before starting the transition.
+        #[cfg_attr(feature = "clap", arg(short, long))]
+        delay_ms: Option<u16>,
    },
-    /// Move the focused window to the workspace below.
-    MoveWindowToWorkspaceDown,
-    /// Move the focused window to the workspace above.
-    MoveWindowToWorkspaceUp,
-    /// Move the focused window to a workspace by index.
-    MoveWindowToWorkspace {
-        /// Index of the target workspace.
+    /// Open the screenshot UI.
+    Screenshot {},
+    /// Screenshot the focused screen.
+    ScreenshotScreen {},
+    /// Screenshot a window.
+    #[cfg_attr(feature = "clap", clap(about = "Screenshot the focused window"))]
+    ScreenshotWindow {
+        /// Id of the window to screenshot.
+        ///
+        /// If `None`, uses the focused window.
+        #[cfg_attr(feature = "clap", arg(long))]
+        id: Option<u64>,
+    },
+    /// Close a window.
+    #[cfg_attr(feature = "clap", clap(about = "Close the focused window"))]
+    CloseWindow {
+        /// Id of the window to close.
+        ///
+        /// If `None`, uses the focused window.
+        #[cfg_attr(feature = "clap", arg(long))]
+        id: Option<u64>,
+    },
+    /// Toggle fullscreen on a window.
+    #[cfg_attr(
+        feature = "clap",
+        clap(about = "Toggle fullscreen on the focused window")
+    )]
+    FullscreenWindow {
+        /// Id of the window to toggle fullscreen of.
+        ///
+        /// If `None`, uses the focused window.
+        #[cfg_attr(feature = "clap", arg(long))]
+        id: Option<u64>,
+    },
+    /// Focus a window by id.
+    FocusWindow {
+        /// Id of the window to focus.
+        #[cfg_attr(feature = "clap", arg(long))]
+        id: u64,
+    },
+    /// Focus the column to the left.
+    FocusColumnLeft {},
+    /// Focus the column to the right.
+    FocusColumnRight {},
+    /// Focus the first column.
+    FocusColumnFirst {},
+    /// Focus the last column.
+    FocusColumnLast {},
+    /// Focus the next column to the right, looping if at end.
+    FocusColumnRightOrFirst {},
+    /// Focus the next column to the left, looping if at start.
+    FocusColumnLeftOrLast {},
+    /// Focus the window or the monitor above.
+    FocusWindowOrMonitorUp {},
+    /// Focus the window or the monitor below.
+    FocusWindowOrMonitorDown {},
+    /// Focus the column or the monitor to the left.
+    FocusColumnOrMonitorLeft {},
+    /// Focus the column or the monitor to the right.
+    FocusColumnOrMonitorRight {},
+    /// Focus the window below.
+    FocusWindowDown {},
+    /// Focus the window above.
+    FocusWindowUp {},
+    /// Focus the window below or the column to the left.
+    FocusWindowDownOrColumnLeft {},
+    /// Focus the window below or the column to the right.
+    FocusWindowDownOrColumnRight {},
+    /// Focus the window above or the column to the left.
+    FocusWindowUpOrColumnLeft {},
+    /// Focus the window above or the column to the right.
+    FocusWindowUpOrColumnRight {},
+    /// Focus the window or the workspace above.
+    FocusWindowOrWorkspaceDown {},
+    /// Focus the window or the workspace above.
+    FocusWindowOrWorkspaceUp {},
+    /// Move the focused column to the left.
+    MoveColumnLeft {},
+    /// Move the focused column to the right.
+    MoveColumnRight {},
+    /// Move the focused column to the start of the workspace.
+    MoveColumnToFirst {},
+    /// Move the focused column to the end of the workspace.
+    MoveColumnToLast {},
+    /// Move the focused column to the left or to the monitor to the left.
+    MoveColumnLeftOrToMonitorLeft {},
+    /// Move the focused column to the right or to the monitor to the right.
+    MoveColumnRightOrToMonitorRight {},
+    /// Move the focused window down in a column.
+    MoveWindowDown {},
+    /// Move the focused window up in a column.
+    MoveWindowUp {},
+    /// Move the focused window down in a column or to the workspace below.
+    MoveWindowDownOrToWorkspaceDown {},
+    /// Move the focused window up in a column or to the workspace above.
+    MoveWindowUpOrToWorkspaceUp {},
+    /// Consume or expel a window left.
+    #[cfg_attr(
+        feature = "clap",
+        clap(about = "Consume or expel the focused window left")
+    )]
+    ConsumeOrExpelWindowLeft {
+        /// Id of the window to consume or expel.
+        ///
+        /// If `None`, uses the focused window.
+        #[cfg_attr(feature = "clap", arg(long))]
+        id: Option<u64>,
+    },
+    /// Consume or expel a window right.
+    #[cfg_attr(
+        feature = "clap",
+        clap(about = "Consume or expel the focused window right")
+    )]
+    ConsumeOrExpelWindowRight {
+        /// Id of the window to consume or expel.
+        ///
+        /// If `None`, uses the focused window.
+        #[cfg_attr(feature = "clap", arg(long))]
+        id: Option<u64>,
+    },
+    /// Consume the window to the right into the focused column.
+    ConsumeWindowIntoColumn {},
+    /// Expel the focused window from the column.
+    ExpelWindowFromColumn {},
+    /// Center the focused column on the screen.
+    CenterColumn {},
+    /// Focus the workspace below.
+    FocusWorkspaceDown {},
+    /// Focus the workspace above.
+    FocusWorkspaceUp {},
+    /// Focus a workspace by reference (index or name).
+    FocusWorkspace {
+        /// Reference (index or name) of the workspace to focus.
        #[cfg_attr(feature = "clap", arg())]
-        index: u8,
+        reference: WorkspaceReferenceArg,
+    },
+    /// Focus the previous workspace.
+    FocusWorkspacePrevious {},
+    /// Move the focused window to the workspace below.
+    MoveWindowToWorkspaceDown {},
+    /// Move the focused window to the workspace above.
+    MoveWindowToWorkspaceUp {},
+    /// Move a window to a workspace.
+    #[cfg_attr(
+        feature = "clap",
+        clap(about = "Move the focused window to a workspace by reference (index or name)")
+    )]
+    MoveWindowToWorkspace {
+        /// Id of the window to move.
+        ///
+        /// If `None`, uses the focused window.
+        #[cfg_attr(feature = "clap", arg(long))]
+        window_id: Option<u64>,
+
+        /// Reference (index or name) of the workspace to move the window to.
+        #[cfg_attr(feature = "clap", arg())]
+        reference: WorkspaceReferenceArg,
    },
    /// Move the focused column to the workspace below.
-    MoveColumnToWorkspaceDown,
+    MoveColumnToWorkspaceDown {},
    /// Move the focused column to the workspace above.
-    MoveColumnToWorkspaceUp,
-    /// Move the focused column to a workspace by index.
+    MoveColumnToWorkspaceUp {},
+    /// Move the focused column to a workspace by reference (index or name).
    MoveColumnToWorkspace {
-        /// Index of the target workspace.
+        /// Reference (index or name) of the workspace to move the column to.
        #[cfg_attr(feature = "clap", arg())]
-        index: u8,
+        reference: WorkspaceReferenceArg,
    },
    /// Move the focused workspace down.
-    MoveWorkspaceDown,
+    MoveWorkspaceDown {},
    /// Move the focused workspace up.
-    MoveWorkspaceUp,
+    MoveWorkspaceUp {},
    /// Focus the monitor to the left.
-    FocusMonitorLeft,
+    FocusMonitorLeft {},
    /// Focus the monitor to the right.
-    FocusMonitorRight,
+    FocusMonitorRight {},
    /// Focus the monitor below.
-    FocusMonitorDown,
+    FocusMonitorDown {},
    /// Focus the monitor above.
-    FocusMonitorUp,
+    FocusMonitorUp {},
    /// Move the focused window to the monitor to the left.
-    MoveWindowToMonitorLeft,
+    MoveWindowToMonitorLeft {},
    /// Move the focused window to the monitor to the right.
-    MoveWindowToMonitorRight,
+    MoveWindowToMonitorRight {},
    /// Move the focused window to the monitor below.
-    MoveWindowToMonitorDown,
+    MoveWindowToMonitorDown {},
    /// Move the focused window to the monitor above.
-    MoveWindowToMonitorUp,
+    MoveWindowToMonitorUp {},
    /// Move the focused column to the monitor to the left.
-    MoveColumnToMonitorLeft,
+    MoveColumnToMonitorLeft {},
    /// Move the focused column to the monitor to the right.
-    MoveColumnToMonitorRight,
+    MoveColumnToMonitorRight {},
    /// Move the focused column to the monitor below.
-    MoveColumnToMonitorDown,
+    MoveColumnToMonitorDown {},
    /// Move the focused column to the monitor above.
-    MoveColumnToMonitorUp,
-    /// Change the height of the focused window.
+    MoveColumnToMonitorUp {},
+    /// Change the height of a window.
+    #[cfg_attr(
+        feature = "clap",
+        clap(about = "Change the height of the focused window")
+    )]
    SetWindowHeight {
+        /// Id of the window whose height to set.
+        ///
+        /// If `None`, uses the focused window.
+        #[cfg_attr(feature = "clap", arg(long))]
+        id: Option<u64>,
+
        /// How to change the height.
        #[cfg_attr(feature = "clap", arg())]
        change: SizeChange,
    },
+    /// Reset the height of a window back to automatic.
+    #[cfg_attr(
+        feature = "clap",
+        clap(about = "Reset the height of the focused window back to automatic")
+    )]
+    ResetWindowHeight {
+        /// Id of the window whose height to reset.
+        ///
+        /// If `None`, uses the focused window.
+        #[cfg_attr(feature = "clap", arg(long))]
+        id: Option<u64>,
+    },
    /// Switch between preset column widths.
-    SwitchPresetColumnWidth,
+    SwitchPresetColumnWidth {},
+    /// Switch between preset window heights.
+    SwitchPresetWindowHeight {
+        /// Id of the window whose height to switch.
+        ///
+        /// If `None`, uses the focused window.
+        #[cfg_attr(feature = "clap", arg(long))]
+        id: Option<u64>,
+    },
    /// Toggle the maximized state of the focused column.
-    MaximizeColumn,
+    MaximizeColumn {},
    /// Change the width of the focused column.
    SetColumnWidth {
        /// How to change the width.
@@ -194,21 +395,26 @@ pub enum Action {
        layout: LayoutSwitchTarget,
    },
    /// Show the hotkey overlay.
-    ShowHotkeyOverlay,
+    ShowHotkeyOverlay {},
    /// Move the focused workspace to the monitor to the left.
-    MoveWorkspaceToMonitorLeft,
+    MoveWorkspaceToMonitorLeft {},
    /// Move the focused workspace to the monitor to the right.
-    MoveWorkspaceToMonitorRight,
+    MoveWorkspaceToMonitorRight {},
    /// Move the focused workspace to the monitor below.
-    MoveWorkspaceToMonitorDown,
+    MoveWorkspaceToMonitorDown {},
    /// Move the focused workspace to the monitor above.
-    MoveWorkspaceToMonitorUp,
+    MoveWorkspaceToMonitorUp {},
    /// Toggle a debug tint on windows.
-    ToggleDebugTint,
+    ToggleDebugTint {},
+    /// Toggle visualization of render element opaque regions.
+    DebugToggleOpaqueRegions {},
+    /// Toggle visualization of output damage.
+    DebugToggleDamage {},
 }

 /// Change in window or column size.
 #[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
 pub enum SizeChange {
    /// Set the size in logical pixels.
    SetFixed(i32),
@@ -220,8 +426,21 @@ pub enum SizeChange {
    AdjustProportion(f64),
 }

+/// Workspace reference (id, index or name) to operate on.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
+pub enum WorkspaceReferenceArg {
+    /// Id of the workspace.
+    Id(u64),
+    /// Index of the workspace.
+    Index(u8),
+    /// Name of the workspace.
+    Name(String),
+}
+
 /// Layout to switch to.
 #[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
 pub enum LayoutSwitchTarget {
    /// The next configured layout.
    Next,
@@ -229,8 +448,135 @@ pub enum LayoutSwitchTarget {
    Prev,
 }

+/// Output actions that niri can perform.
+// Variants in this enum should match the spelling of the ones in niri-config. Most thigs from
+// niri-config should be present here.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[cfg_attr(feature = "clap", derive(clap::Parser))]
+#[cfg_attr(feature = "clap", command(subcommand_value_name = "ACTION"))]
+#[cfg_attr(feature = "clap", command(subcommand_help_heading = "Actions"))]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
+pub enum OutputAction {
+    /// Turn off the output.
+    Off,
+    /// Turn on the output.
+    On,
+    /// Set the output mode.
+    Mode {
+        /// Mode to set, or "auto" for automatic selection.
+        ///
+        /// Run `niri msg outputs` to see the available modes.
+        #[cfg_attr(feature = "clap", arg())]
+        mode: ModeToSet,
+    },
+    /// Set the output scale.
+    Scale {
+        /// Scale factor to set, or "auto" for automatic selection.
+        #[cfg_attr(feature = "clap", arg())]
+        scale: ScaleToSet,
+    },
+    /// Set the output transform.
+    Transform {
+        /// Transform to set, counter-clockwise.
+        #[cfg_attr(feature = "clap", arg())]
+        transform: Transform,
+    },
+    /// Set the output position.
+    Position {
+        /// Position to set, or "auto" for automatic selection.
+        #[cfg_attr(feature = "clap", command(subcommand))]
+        position: PositionToSet,
+    },
+    /// Set the variable refresh rate mode.
+    Vrr {
+        /// Variable refresh rate mode to set.
+        #[cfg_attr(feature = "clap", command(flatten))]
+        vrr: VrrToSet,
+    },
+}
+
+/// Output mode to set.
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
+pub enum ModeToSet {
+    /// Niri will pick the mode automatically.
+    Automatic,
+    /// Specific mode.
+    Specific(ConfiguredMode),
+}
+
+/// Output mode as set in the config file.
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
+pub struct ConfiguredMode {
+    /// Width in physical pixels.
+    pub width: u16,
+    /// Height in physical pixels.
+    pub height: u16,
+    /// Refresh rate.
+    pub refresh: Option<f64>,
+}
+
+/// Output scale to set.
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
+pub enum ScaleToSet {
+    /// Niri will pick the scale automatically.
+    Automatic,
+    /// Specific scale.
+    Specific(f64),
+}
+
+/// Output position to set.
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "clap", derive(clap::Subcommand))]
+#[cfg_attr(feature = "clap", command(subcommand_value_name = "POSITION"))]
+#[cfg_attr(feature = "clap", command(subcommand_help_heading = "Position Values"))]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
+pub enum PositionToSet {
+    /// Position the output automatically.
+    #[cfg_attr(feature = "clap", command(name = "auto"))]
+    Automatic,
+    /// Set a specific position.
+    #[cfg_attr(feature = "clap", command(name = "set"))]
+    Specific(ConfiguredPosition),
+}
+
+/// Output position as set in the config file.
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "clap", derive(clap::Args))]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
+pub struct ConfiguredPosition {
+    /// Logical X position.
+    pub x: i32,
+    /// Logical Y position.
+    pub y: i32,
+}
+
+/// Output VRR to set.
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "clap", derive(clap::Args))]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
+pub struct VrrToSet {
+    /// Whether to enable variable refresh rate.
+    #[cfg_attr(
+        feature = "clap",
+        arg(
+            value_name = "ON|OFF",
+            action = clap::ArgAction::Set,
+            value_parser = clap::builder::BoolishValueParser::new(),
+            hide_possible_values = true,
+        ),
+    )]
+    pub vrr: bool,
+    /// Only enable when the output shows a window matching the variable-refresh-rate window rule.
+    #[cfg_attr(feature = "clap", arg(long))]
+    pub on_demand: bool,
+}
+
 /// Connected output.
 #[derive(Debug, Serialize, Deserialize, Clone)]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
 pub struct Output {
    /// Name of the output.
    pub name: String,
@@ -238,6 +584,8 @@ pub struct Output {
    pub make: String,
    /// Textual description of the model.
    pub model: String,
+    /// Serial of the output, if known.
+    pub serial: Option<String>,
    /// Physical width and height of the output in millimeters, if known.
    pub physical_size: Option<(u32, u32)>,
    /// Available modes for the output.
@@ -246,10 +594,19 @@ pub struct Output {
    ///
    /// `None` if the output is disabled.
    pub current_mode: Option<usize>,
+    /// Whether the output supports variable refresh rate.
+    pub vrr_supported: bool,
+    /// Whether variable refresh rate is enabled on the output.
+    pub vrr_enabled: bool,
+    /// Logical output information.
+    ///
+    /// `None` if the output is not mapped to any logical output (for example, if it is disabled).
+    pub logical: Option<LogicalOutput>,
 }

 /// Output mode.
-#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
+#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
 pub struct Mode {
    /// Width in physical pixels.
    pub width: u16,
@@ -257,6 +614,227 @@ pub struct Mode {
    pub height: u16,
    /// Refresh rate in millihertz.
    pub refresh_rate: u32,
+    /// Whether this mode is preferred by the monitor.
+    pub is_preferred: bool,
+}
+
+/// Logical output in the compositor's coordinate space.
+#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
+pub struct LogicalOutput {
+    /// Logical X position.
+    pub x: i32,
+    /// Logical Y position.
+    pub y: i32,
+    /// Width in logical pixels.
+    pub width: u32,
+    /// Height in logical pixels.
+    pub height: u32,
+    /// Scale factor.
+    pub scale: f64,
+    /// Transform.
+    pub transform: Transform,
+}
+
+/// Output transform, which goes counter-clockwise.
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "clap", derive(clap::ValueEnum))]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
+pub enum Transform {
+    /// Untransformed.
+    Normal,
+    /// Rotated by 90°.
+    #[serde(rename = "90")]
+    _90,
+    /// Rotated by 180°.
+    #[serde(rename = "180")]
+    _180,
+    /// Rotated by 270°.
+    #[serde(rename = "270")]
+    _270,
+    /// Flipped horizontally.
+    Flipped,
+    /// Rotated by 90° and flipped horizontally.
+    #[cfg_attr(feature = "clap", value(name("flipped-90")))]
+    Flipped90,
+    /// Flipped vertically.
+    #[cfg_attr(feature = "clap", value(name("flipped-180")))]
+    Flipped180,
+    /// Rotated by 270° and flipped horizontally.
+    #[cfg_attr(feature = "clap", value(name("flipped-270")))]
+    Flipped270,
+}
+
+/// Toplevel window.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
+pub struct Window {
+    /// Unique id of this window.
+    ///
+    /// This id remains constant while this window is open.
+    ///
+    /// Do not assume that window ids will always increase without wrapping, or start at 1. That is
+    /// an implementation detail subject to change. For example, ids may change to be randomly
+    /// generated for each new window.
+    pub id: u64,
+    /// Title, if set.
+    pub title: Option<String>,
+    /// Application ID, if set.
+    pub app_id: Option<String>,
+    /// Id of the workspace this window is on, if any.
+    pub workspace_id: Option<u64>,
+    /// Whether this window is currently focused.
+    ///
+    /// There can be either one focused window or zero (e.g. when a layer-shell surface has focus).
+    pub is_focused: bool,
+}
+
+/// Output configuration change result.
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
+pub enum OutputConfigChanged {
+    /// The target output was connected and the change was applied.
+    Applied,
+    /// The target output was not found, the change will be applied when it is connected.
+    OutputWasMissing,
+}
+
+/// A workspace.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
+pub struct Workspace {
+    /// Unique id of this workspace.
+    ///
+    /// This id remains constant regardless of the workspace moving around and across monitors.
+    ///
+    /// Do not assume that workspace ids will always increase without wrapping, or start at 1. That
+    /// is an implementation detail subject to change. For example, ids may change to be randomly
+    /// generated for each new workspace.
+    pub id: u64,
+    /// Index of the workspace on its monitor.
+    ///
+    /// This is the same index you can use for requests like `niri msg action focus-workspace`.
+    ///
+    /// This index *will change* as you move and re-order workspace. It is merely the workspace's
+    /// current position on its monitor. Workspaces on different monitors can have the same index.
+    ///
+    /// If you need a unique workspace id that doesn't change, see [`Self::id`].
+    pub idx: u8,
+    /// Optional name of the workspace.
+    pub name: Option<String>,
+    /// Name of the output that the workspace is on.
+    ///
+    /// Can be `None` if no outputs are currently connected.
+    pub output: Option<String>,
+    /// Whether the workspace is currently active on its output.
+    ///
+    /// Every output has one active workspace, the one that is currently visible on that output.
+    pub is_active: bool,
+    /// Whether the workspace is currently focused.
+    ///
+    /// There's only one focused workspace across all outputs.
+    pub is_focused: bool,
+    /// Id of the active window on this workspace, if any.
+    pub active_window_id: Option<u64>,
+}
+
+/// Configured keyboard layouts.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
+pub struct KeyboardLayouts {
+    /// XKB names of the configured layouts.
+    pub names: Vec<String>,
+    /// Index of the currently active layout in `names`.
+    pub current_idx: u8,
+}
+
+/// A compositor event.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
+pub enum Event {
+    /// The workspace configuration has changed.
+    WorkspacesChanged {
+        /// The new workspace configuration.
+        ///
+        /// This configuration completely replaces the previous configuration. I.e. if any
+        /// workspaces are missing from here, then they were deleted.
+        workspaces: Vec<Workspace>,
+    },
+    /// A workspace was activated on an output.
+    ///
+    /// This doesn't always mean the workspace became focused, just that it's now the active
+    /// workspace on its output. All other workspaces on the same output become inactive.
+    WorkspaceActivated {
+        /// Id of the newly active workspace.
+        id: u64,
+        /// Whether this workspace also became focused.
+        ///
+        /// If `true`, this is now the single focused workspace. All other workspaces are no longer
+        /// focused, but they may remain active on their respective outputs.
+        focused: bool,
+    },
+    /// An active window changed on a workspace.
+    WorkspaceActiveWindowChanged {
+        /// Id of the workspace on which the active window changed.
+        workspace_id: u64,
+        /// Id of the new active window, if any.
+        active_window_id: Option<u64>,
+    },
+    /// The window configuration has changed.
+    WindowsChanged {
+        /// The new window configuration.
+        ///
+        /// This configuration completely replaces the previous configuration. I.e. if any windows
+        /// are missing from here, then they were closed.
+        windows: Vec<Window>,
+    },
+    /// A new toplevel window was opened, or an existing toplevel window changed.
+    WindowOpenedOrChanged {
+        /// The new or updated window.
+        ///
+        /// If the window is focused, all other windows are no longer focused.
+        window: Window,
+    },
+    /// A toplevel window was closed.
+    WindowClosed {
+        /// Id of the removed window.
+        id: u64,
+    },
+    /// Window focus changed.
+    ///
+    /// All other windows are no longer focused.
+    WindowFocusChanged {
+        /// Id of the newly focused window, or `None` if no window is now focused.
+        id: Option<u64>,
+    },
+    /// The configured keyboard layouts have changed.
+    KeyboardLayoutsChanged {
+        /// The new keyboard layout configuration.
+        keyboard_layouts: KeyboardLayouts,
+    },
+    /// The keyboard layout switched.
+    KeyboardLayoutSwitched {
+        /// Index of the newly active layout.
+        idx: u8,
+    },
+}
+
+impl FromStr for WorkspaceReferenceArg {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let reference = if let Ok(index) = s.parse::<i32>() {
+            if let Ok(idx) = u8::try_from(index) {
+                Self::Index(idx)
+            } else {
+                return Err("workspace index must be between 0 and 255");
+            }
+        } else {
+            Self::Name(s.to_string())
+        };
+
+        Ok(reference)
+    }
 }

 impl FromStr for SizeChange {
@@ -310,3 +888,78 @@ impl FromStr for LayoutSwitchTarget {
        }
    }
 }
+
+impl FromStr for Transform {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "normal" => Ok(Self::Normal),
+            "90" => Ok(Self::_90),
+            "180" => Ok(Self::_180),
+            "270" => Ok(Self::_270),
+            "flipped" => Ok(Self::Flipped),
+            "flipped-90" => Ok(Self::Flipped90),
+            "flipped-180" => Ok(Self::Flipped180),
+            "flipped-270" => Ok(Self::Flipped270),
+            _ => Err(concat!(
+                r#"invalid transform, can be "90", "180", "270", "#,
+                r#""flipped", "flipped-90", "flipped-180" or "flipped-270""#
+            )),
+        }
+    }
+}
+
+impl FromStr for ModeToSet {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if s.eq_ignore_ascii_case("auto") {
+            return Ok(Self::Automatic);
+        }
+
+        let mode = s.parse()?;
+        Ok(Self::Specific(mode))
+    }
+}
+
+impl FromStr for ConfiguredMode {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let Some((width, rest)) = s.split_once('x') else {
+            return Err("no 'x' separator found");
+        };
+
+        let (height, refresh) = match rest.split_once('@') {
+            Some((height, refresh)) => (height, Some(refresh)),
+            None => (rest, None),
+        };
+
+        let width = width.parse().map_err(|_| "error parsing width")?;
+        let height = height.parse().map_err(|_| "error parsing height")?;
+        let refresh = refresh
+            .map(str::parse)
+            .transpose()
+            .map_err(|_| "error parsing refresh rate")?;
+
+        Ok(Self {
+            width,
+            height,
+            refresh,
+        })
+    }
+}
+
+impl FromStr for ScaleToSet {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if s.eq_ignore_ascii_case("auto") {
+            return Ok(Self::Automatic);
+        }
+
+        let scale = s.parse().map_err(|_| "error parsing scale")?;
+        Ok(Self::Specific(scale))
+    }
+}
@@ -0,0 +1,77 @@
+//! Helper for blocking communication over the niri socket.
+
+use std::env;
+use std::io::{self, BufRead, BufReader, Write};
+use std::net::Shutdown;
+use std::os::unix::net::UnixStream;
+use std::path::Path;
+
+use crate::{Event, Reply, Request};
+
+/// Name of the environment variable containing the niri IPC socket path.
+pub const SOCKET_PATH_ENV: &str = "NIRI_SOCKET";
+
+/// Helper for blocking communication over the niri socket.
+///
+/// This struct is used to communicate with the niri IPC server. It handles the socket connection
+/// and serialization/deserialization of messages.
+pub struct Socket {
+    stream: UnixStream,
+}
+
+impl Socket {
+    /// Connects to the default niri IPC socket.
+    ///
+    /// This is equivalent to calling [`Self::connect_to`] with the path taken from the
+    /// [`SOCKET_PATH_ENV`] environment variable.
+    pub fn connect() -> io::Result<Self> {
+        let socket_path = env::var_os(SOCKET_PATH_ENV).ok_or_else(|| {
+            io::Error::new(
+                io::ErrorKind::NotFound,
+                format!("{SOCKET_PATH_ENV} is not set, are you running this within niri?"),
+            )
+        })?;
+        Self::connect_to(socket_path)
+    }
+
+    /// Connects to the niri IPC socket at the given path.
+    pub fn connect_to(path: impl AsRef<Path>) -> io::Result<Self> {
+        let stream = UnixStream::connect(path.as_ref())?;
+        Ok(Self { stream })
+    }
+
+    /// Sends a request to niri and returns the response.
+    ///
+    /// Return values:
+    ///
+    /// * `Ok(Ok(response))`: successful [`Response`](crate::Response) from niri
+    /// * `Ok(Err(message))`: error message from niri
+    /// * `Err(error)`: error communicating with niri
+    ///
+    /// This method also returns a blocking function that you can call to keep reading [`Event`]s
+    /// after requesting an [`EventStream`][Request::EventStream]. This function is not useful
+    /// otherwise.
+    pub fn send(self, request: Request) -> io::Result<(Reply, impl FnMut() -> io::Result<Event>)> {
+        let Self { mut stream } = self;
+
+        let mut buf = serde_json::to_string(&request).unwrap();
+        stream.write_all(buf.as_bytes())?;
+        stream.shutdown(Shutdown::Write)?;
+
+        let mut reader = BufReader::new(stream);
+
+        buf.clear();
+        reader.read_line(&mut buf)?;
+
+        let reply = serde_json::from_str(&buf)?;
+
+        let events = move || {
+            buf.clear();
+            reader.read_line(&mut buf)?;
+            let event = serde_json::from_str(&buf)?;
+            Ok(event)
+        };
+
+        Ok((reply, events))
+    }
+}
@@ -0,0 +1,194 @@
+//! Helpers for keeping track of the event stream state.
+//!
+//! 1. Create an [`EventStreamState`] using `Default::default()`, or any individual state part if
+//!    you only care about part of the state.
+//! 2. Connect to the niri socket and request an event stream.
+//! 3. Pass every [`Event`] to [`EventStreamStatePart::apply`] on your state.
+//! 4. Read the fields of the state as needed.
+
+use std::collections::hash_map::Entry;
+use std::collections::HashMap;
+
+use crate::{Event, KeyboardLayouts, Window, Workspace};
+
+/// Part of the state communicated via the event stream.
+pub trait EventStreamStatePart {
+    /// Returns a sequence of events that replicates this state from default initialization.
+    fn replicate(&self) -> Vec<Event>;
+
+    /// Applies the event to this state.
+    ///
+    /// Returns `None` after applying the event, and `Some(event)` if the event is ignored by this
+    /// part of the state.
+    fn apply(&mut self, event: Event) -> Option<Event>;
+}
+
+/// The full state communicated over the event stream.
+///
+/// Different parts of the state are not guaranteed to be consistent across every single event
+/// sent by niri. For example, you may receive the first [`Event::WindowOpenedOrChanged`] for a
+/// just-opened window *after* an [`Event::WorkspaceActiveWindowChanged`] for that window. Between
+/// these two events, the workspace active window id refers to a window that does not yet exist in
+/// the windows state part.
+#[derive(Debug, Default)]
+pub struct EventStreamState {
+    /// State of workspaces.
+    pub workspaces: WorkspacesState,
+
+    /// State of workspaces.
+    pub windows: WindowsState,
+
+    /// State of the keyboard layouts.
+    pub keyboard_layouts: KeyboardLayoutsState,
+}
+
+/// The workspaces state communicated over the event stream.
+#[derive(Debug, Default)]
+pub struct WorkspacesState {
+    /// Map from a workspace id to the workspace.
+    pub workspaces: HashMap<u64, Workspace>,
+}
+
+/// The windows state communicated over the event stream.
+#[derive(Debug, Default)]
+pub struct WindowsState {
+    /// Map from a window id to the window.
+    pub windows: HashMap<u64, Window>,
+}
+
+/// The keyboard layout state communicated over the event stream.
+#[derive(Debug, Default)]
+pub struct KeyboardLayoutsState {
+    /// Configured keyboard layouts.
+    pub keyboard_layouts: Option<KeyboardLayouts>,
+}
+
+impl EventStreamStatePart for EventStreamState {
+    fn replicate(&self) -> Vec<Event> {
+        let mut events = Vec::new();
+        events.extend(self.workspaces.replicate());
+        events.extend(self.windows.replicate());
+        events.extend(self.keyboard_layouts.replicate());
+        events
+    }
+
+    fn apply(&mut self, event: Event) -> Option<Event> {
+        let event = self.workspaces.apply(event)?;
+        let event = self.windows.apply(event)?;
+        let event = self.keyboard_layouts.apply(event)?;
+        Some(event)
+    }
+}
+
+impl EventStreamStatePart for WorkspacesState {
+    fn replicate(&self) -> Vec<Event> {
+        let workspaces = self.workspaces.values().cloned().collect();
+        vec![Event::WorkspacesChanged { workspaces }]
+    }
+
+    fn apply(&mut self, event: Event) -> Option<Event> {
+        match event {
+            Event::WorkspacesChanged { workspaces } => {
+                self.workspaces = workspaces.into_iter().map(|ws| (ws.id, ws)).collect();
+            }
+            Event::WorkspaceActivated { id, focused } => {
+                let ws = self.workspaces.get(&id);
+                let ws = ws.expect("activated workspace was missing from the map");
+                let output = ws.output.clone();
+
+                for ws in self.workspaces.values_mut() {
+                    let got_activated = ws.id == id;
+                    if ws.output == output {
+                        ws.is_active = got_activated;
+                    }
+
+                    if focused {
+                        ws.is_focused = got_activated;
+                    }
+                }
+            }
+            Event::WorkspaceActiveWindowChanged {
+                workspace_id,
+                active_window_id,
+            } => {
+                let ws = self.workspaces.get_mut(&workspace_id);
+                let ws = ws.expect("changed workspace was missing from the map");
+                ws.active_window_id = active_window_id;
+            }
+            event => return Some(event),
+        }
+        None
+    }
+}
+
+impl EventStreamStatePart for WindowsState {
+    fn replicate(&self) -> Vec<Event> {
+        let windows = self.windows.values().cloned().collect();
+        vec![Event::WindowsChanged { windows }]
+    }
+
+    fn apply(&mut self, event: Event) -> Option<Event> {
+        match event {
+            Event::WindowsChanged { windows } => {
+                self.windows = windows.into_iter().map(|win| (win.id, win)).collect();
+            }
+            Event::WindowOpenedOrChanged { window } => {
+                let (id, is_focused) = match self.windows.entry(window.id) {
+                    Entry::Occupied(mut entry) => {
+                        let entry = entry.get_mut();
+                        *entry = window;
+                        (entry.id, entry.is_focused)
+                    }
+                    Entry::Vacant(entry) => {
+                        let entry = entry.insert(window);
+                        (entry.id, entry.is_focused)
+                    }
+                };
+
+                if is_focused {
+                    for win in self.windows.values_mut() {
+                        if win.id != id {
+                            win.is_focused = false;
+                        }
+                    }
+                }
+            }
+            Event::WindowClosed { id } => {
+                let win = self.windows.remove(&id);
+                win.expect("closed window was missing from the map");
+            }
+            Event::WindowFocusChanged { id } => {
+                for win in self.windows.values_mut() {
+                    win.is_focused = Some(win.id) == id;
+                }
+            }
+            event => return Some(event),
+        }
+        None
+    }
+}
+
+impl EventStreamStatePart for KeyboardLayoutsState {
+    fn replicate(&self) -> Vec<Event> {
+        if let Some(keyboard_layouts) = self.keyboard_layouts.clone() {
+            vec![Event::KeyboardLayoutsChanged { keyboard_layouts }]
+        } else {
+            vec![]
+        }
+    }
+
+    fn apply(&mut self, event: Event) -> Option<Event> {
+        match event {
+            Event::KeyboardLayoutsChanged { keyboard_layouts } => {
+                self.keyboard_layouts = Some(keyboard_layouts);
+            }
+            Event::KeyboardLayoutSwitched { idx } => {
+                let kb = self.keyboard_layouts.as_mut();
+                let kb = kb.expect("keyboard layouts must be set before a layout can be switched");
+                kb.current_idx = idx;
+            }
+            event => return Some(event),
+        }
+        None
+    }
+}
@@ -8,11 +8,11 @@ edition.workspace = true
 repository.workspace = true

 [dependencies]
-adw = { version = "0.6.0", package = "libadwaita", features = ["v1_4"] }
+adw = { version = "0.7.0", package = "libadwaita", features = ["v1_4"] }
 anyhow.workspace = true
-gtk = { version = "0.8.0", package = "gtk4", features = ["v4_12"] }
-niri = { version = "0.1.2", path = ".." }
-niri-config = { version = "0.1.2", path = "../niri-config" }
+gtk = { version = "0.9.2", package = "gtk4", features = ["v4_12"] }
+niri = { version = "0.1.9", path = ".." }
+niri-config = { version = "0.1.9", path = "../niri-config" }
 smithay.workspace = true
 tracing.workspace = true
 tracing-subscriber.workspace = true
@@ -0,0 +1,81 @@
+use std::f32::consts::{FRAC_PI_2, PI};
+use std::sync::atomic::Ordering;
+use std::time::Duration;
+
+use niri::animation::ANIMATION_SLOWDOWN;
+use niri::render_helpers::border::BorderRenderElement;
+use niri_config::{Color, CornerRadius, GradientInterpolation};
+use smithay::backend::renderer::element::RenderElement;
+use smithay::backend::renderer::gles::GlesRenderer;
+use smithay::utils::{Logical, Physical, Rectangle, Size};
+
+use super::TestCase;
+
+pub struct GradientAngle {
+    angle: f32,
+    prev_time: Duration,
+}
+
+impl GradientAngle {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
+        Self {
+            angle: 0.,
+            prev_time: Duration::ZERO,
+        }
+    }
+}
+
+impl TestCase for GradientAngle {
+    fn are_animations_ongoing(&self) -> bool {
+        true
+    }
+
+    fn advance_animations(&mut self, current_time: Duration) {
+        let mut delta = if self.prev_time.is_zero() {
+            Duration::ZERO
+        } else {
+            current_time.saturating_sub(self.prev_time)
+        };
+        self.prev_time = current_time;
+
+        let slowdown = ANIMATION_SLOWDOWN.load(Ordering::SeqCst);
+        if slowdown == 0. {
+            delta = Duration::ZERO
+        } else {
+            delta = delta.div_f64(slowdown);
+        }
+
+        self.angle += delta.as_secs_f32() * PI;
+
+        if self.angle >= PI * 2. {
+            self.angle -= PI * 2.
+        }
+    }
+
+    fn render(
+        &mut self,
+        _renderer: &mut GlesRenderer,
+        size: Size<i32, Physical>,
+    ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
+        let (a, b) = (size.w / 4, size.h / 4);
+        let size = (size.w - a * 2, size.h - b * 2);
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
+
+        [BorderRenderElement::new(
+            area.size,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            GradientInterpolation::default(),
+            Color::new_unpremul(1., 0., 0., 1.),
+            Color::new_unpremul(0., 1., 0., 1.),
+            self.angle - FRAC_PI_2,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            0.,
+            CornerRadius::default(),
+            1.,
+        )
+        .with_location(area.loc)]
+        .into_iter()
+        .map(|elem| Box::new(elem) as _)
+        .collect()
+    }
+}
@@ -0,0 +1,123 @@
+use std::f32::consts::{FRAC_PI_4, PI};
+use std::sync::atomic::Ordering;
+use std::time::Duration;
+
+use niri::animation::ANIMATION_SLOWDOWN;
+use niri::layout::focus_ring::FocusRing;
+use niri::render_helpers::border::BorderRenderElement;
+use niri_config::{Color, CornerRadius, FloatOrInt, GradientInterpolation};
+use smithay::backend::renderer::element::RenderElement;
+use smithay::backend::renderer::gles::GlesRenderer;
+use smithay::utils::{Logical, Physical, Point, Rectangle, Size};
+
+use super::TestCase;
+
+pub struct GradientArea {
+    progress: f32,
+    border: FocusRing,
+    prev_time: Duration,
+}
+
+impl GradientArea {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
+        let border = FocusRing::new(niri_config::FocusRing {
+            off: false,
+            width: FloatOrInt(1.),
+            active_color: Color::from_rgba8_unpremul(255, 255, 255, 128),
+            inactive_color: Color::default(),
+            active_gradient: None,
+            inactive_gradient: None,
+        });
+
+        Self {
+            progress: 0.,
+            border,
+            prev_time: Duration::ZERO,
+        }
+    }
+}
+
+impl TestCase for GradientArea {
+    fn are_animations_ongoing(&self) -> bool {
+        true
+    }
+
+    fn advance_animations(&mut self, current_time: Duration) {
+        let mut delta = if self.prev_time.is_zero() {
+            Duration::ZERO
+        } else {
+            current_time.saturating_sub(self.prev_time)
+        };
+        self.prev_time = current_time;
+
+        let slowdown = ANIMATION_SLOWDOWN.load(Ordering::SeqCst);
+        if slowdown == 0. {
+            delta = Duration::ZERO
+        } else {
+            delta = delta.div_f64(slowdown);
+        }
+
+        self.progress += delta.as_secs_f32() * PI;
+
+        if self.progress >= PI * 2. {
+            self.progress -= PI * 2.
+        }
+    }
+
+    fn render(
+        &mut self,
+        renderer: &mut GlesRenderer,
+        size: Size<i32, Physical>,
+    ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
+        let mut rv = Vec::new();
+
+        let f = (self.progress.sin() + 1.) / 2.;
+
+        let (a, b) = (size.w / 4, size.h / 4);
+        let rect_size = (size.w - a * 2, size.h - b * 2);
+        let area = Rectangle::from_loc_and_size((a, b), rect_size).to_f64();
+
+        let g_size = Size::from((
+            (size.w as f32 / 8. + size.w as f32 / 8. * 7. * f).round() as i32,
+            (size.h as f32 / 8. + size.h as f32 / 8. * 7. * f).round() as i32,
+        ));
+        let g_loc = Point::from(((size.w - g_size.w) / 2, (size.h - g_size.h) / 2)).to_f64();
+        let g_size = g_size.to_f64();
+        let mut g_area = Rectangle::from_loc_and_size(g_loc, g_size);
+        g_area.loc -= area.loc;
+
+        self.border.update_render_elements(
+            g_size,
+            true,
+            true,
+            Rectangle::default(),
+            CornerRadius::default(),
+            1.,
+        );
+        rv.extend(
+            self.border
+                .render(renderer, g_loc)
+                .map(|elem| Box::new(elem) as _),
+        );
+
+        rv.extend(
+            [BorderRenderElement::new(
+                area.size,
+                g_area,
+                GradientInterpolation::default(),
+                Color::new_unpremul(1., 0., 0., 1.),
+                Color::new_unpremul(0., 1., 0., 1.),
+                FRAC_PI_4,
+                Rectangle::from_loc_and_size((0, 0), rect_size).to_f64(),
+                0.,
+                CornerRadius::default(),
+                1.,
+            )
+            .with_location(area.loc)]
+            .into_iter()
+            .map(|elem| Box::new(elem) as _),
+        );
+
+        rv
+    }
+}
@@ -0,0 +1,53 @@
+use niri::render_helpers::border::BorderRenderElement;
+use niri_config::{
+    Color, CornerRadius, GradientColorSpace, GradientInterpolation, HueInterpolation,
+};
+use smithay::backend::renderer::element::RenderElement;
+use smithay::backend::renderer::gles::GlesRenderer;
+use smithay::utils::{Logical, Physical, Rectangle, Size};
+
+use super::TestCase;
+
+pub struct GradientOklab {
+    gradient_format: GradientInterpolation,
+}
+
+impl GradientOklab {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
+        Self {
+            gradient_format: GradientInterpolation {
+                color_space: GradientColorSpace::Oklab,
+                hue_interpolation: HueInterpolation::Shorter,
+            },
+        }
+    }
+}
+
+impl TestCase for GradientOklab {
+    fn render(
+        &mut self,
+        _renderer: &mut GlesRenderer,
+        size: Size<i32, Physical>,
+    ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
+        let (a, b) = (size.w / 6, size.h / 3);
+        let size = (size.w - a * 2, size.h - b * 2);
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
+
+        [BorderRenderElement::new(
+            area.size,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            self.gradient_format,
+            Color::new_unpremul(1., 0., 0., 1.),
+            Color::new_unpremul(0., 1., 0., 1.),
+            0.,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            0.,
+            CornerRadius::default(),
+            1.,
+        )
+        .with_location(area.loc)]
+        .into_iter()
+        .map(|elem| Box::new(elem) as _)
+        .collect()
+    }
+}
@@ -0,0 +1,51 @@
+use niri::render_helpers::border::BorderRenderElement;
+use niri_config::{Color, CornerRadius, GradientColorSpace, GradientInterpolation};
+use smithay::backend::renderer::element::RenderElement;
+use smithay::backend::renderer::gles::GlesRenderer;
+use smithay::utils::{Logical, Physical, Rectangle, Size};
+
+use super::TestCase;
+
+pub struct GradientOklabAlpha {
+    gradient_format: GradientInterpolation,
+}
+
+impl GradientOklabAlpha {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
+        Self {
+            gradient_format: GradientInterpolation {
+                color_space: GradientColorSpace::Oklab,
+                hue_interpolation: Default::default(),
+            },
+        }
+    }
+}
+
+impl TestCase for GradientOklabAlpha {
+    fn render(
+        &mut self,
+        _renderer: &mut GlesRenderer,
+        size: Size<i32, Physical>,
+    ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
+        let (a, b) = (size.w / 6, size.h / 3);
+        let size = (size.w - a * 2, size.h - b * 2);
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
+
+        [BorderRenderElement::new(
+            area.size,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            self.gradient_format,
+            Color::new_unpremul(1., 0., 0., 1.),
+            Color::new_unpremul(0., 1., 0., 0.),
+            0.,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            0.,
+            CornerRadius::default(),
+            1.,
+        )
+        .with_location(area.loc)]
+        .into_iter()
+        .map(|elem| Box::new(elem) as _)
+        .collect()
+    }
+}
@@ -0,0 +1,53 @@
+use niri::render_helpers::border::BorderRenderElement;
+use niri_config::{
+    Color, CornerRadius, GradientColorSpace, GradientInterpolation, HueInterpolation,
+};
+use smithay::backend::renderer::element::RenderElement;
+use smithay::backend::renderer::gles::GlesRenderer;
+use smithay::utils::{Logical, Physical, Rectangle, Size};
+
+use super::TestCase;
+
+pub struct GradientOklchAlpha {
+    gradient_format: GradientInterpolation,
+}
+
+impl GradientOklchAlpha {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
+        Self {
+            gradient_format: GradientInterpolation {
+                color_space: GradientColorSpace::Oklch,
+                hue_interpolation: HueInterpolation::Longer,
+            },
+        }
+    }
+}
+
+impl TestCase for GradientOklchAlpha {
+    fn render(
+        &mut self,
+        _renderer: &mut GlesRenderer,
+        size: Size<i32, Physical>,
+    ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
+        let (a, b) = (size.w / 6, size.h / 3);
+        let size = (size.w - a * 2, size.h - b * 2);
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
+
+        [BorderRenderElement::new(
+            area.size,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            self.gradient_format,
+            Color::new_unpremul(1., 0., 0., 1.),
+            Color::new_unpremul(0., 1., 0., 0.),
+            0.,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            0.,
+            CornerRadius::default(),
+            1.,
+        )
+        .with_location(area.loc)]
+        .into_iter()
+        .map(|elem| Box::new(elem) as _)
+        .collect()
+    }
+}
@@ -0,0 +1,53 @@
+use niri::render_helpers::border::BorderRenderElement;
+use niri_config::{
+    Color, CornerRadius, GradientColorSpace, GradientInterpolation, HueInterpolation,
+};
+use smithay::backend::renderer::element::RenderElement;
+use smithay::backend::renderer::gles::GlesRenderer;
+use smithay::utils::{Logical, Physical, Rectangle, Size};
+
+use super::TestCase;
+
+pub struct GradientOklchDecreasing {
+    gradient_format: GradientInterpolation,
+}
+
+impl GradientOklchDecreasing {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
+        Self {
+            gradient_format: GradientInterpolation {
+                color_space: GradientColorSpace::Oklch,
+                hue_interpolation: HueInterpolation::Decreasing,
+            },
+        }
+    }
+}
+
+impl TestCase for GradientOklchDecreasing {
+    fn render(
+        &mut self,
+        _renderer: &mut GlesRenderer,
+        size: Size<i32, Physical>,
+    ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
+        let (a, b) = (size.w / 6, size.h / 3);
+        let size = (size.w - a * 2, size.h - b * 2);
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
+
+        [BorderRenderElement::new(
+            area.size,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            self.gradient_format,
+            Color::new_unpremul(1., 0., 0., 1.),
+            Color::new_unpremul(0., 1., 0., 1.),
+            0.,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            0.,
+            CornerRadius::default(),
+            1.,
+        )
+        .with_location(area.loc)]
+        .into_iter()
+        .map(|elem| Box::new(elem) as _)
+        .collect()
+    }
+}
@@ -0,0 +1,53 @@
+use niri::render_helpers::border::BorderRenderElement;
+use niri_config::{
+    Color, CornerRadius, GradientColorSpace, GradientInterpolation, HueInterpolation,
+};
+use smithay::backend::renderer::element::RenderElement;
+use smithay::backend::renderer::gles::GlesRenderer;
+use smithay::utils::{Logical, Physical, Rectangle, Size};
+
+use super::TestCase;
+
+pub struct GradientOklchIncreasing {
+    gradient_format: GradientInterpolation,
+}
+
+impl GradientOklchIncreasing {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
+        Self {
+            gradient_format: GradientInterpolation {
+                color_space: GradientColorSpace::Oklch,
+                hue_interpolation: HueInterpolation::Increasing,
+            },
+        }
+    }
+}
+
+impl TestCase for GradientOklchIncreasing {
+    fn render(
+        &mut self,
+        _renderer: &mut GlesRenderer,
+        size: Size<i32, Physical>,
+    ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
+        let (a, b) = (size.w / 6, size.h / 3);
+        let size = (size.w - a * 2, size.h - b * 2);
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
+
+        [BorderRenderElement::new(
+            area.size,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            self.gradient_format,
+            Color::new_unpremul(1., 0., 0., 1.),
+            Color::new_unpremul(0., 1., 0., 1.),
+            0.,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            0.,
+            CornerRadius::default(),
+            1.,
+        )
+        .with_location(area.loc)]
+        .into_iter()
+        .map(|elem| Box::new(elem) as _)
+        .collect()
+    }
+}
@@ -0,0 +1,53 @@
+use niri::render_helpers::border::BorderRenderElement;
+use niri_config::{
+    Color, CornerRadius, GradientColorSpace, GradientInterpolation, HueInterpolation,
+};
+use smithay::backend::renderer::element::RenderElement;
+use smithay::backend::renderer::gles::GlesRenderer;
+use smithay::utils::{Logical, Physical, Rectangle, Size};
+
+use super::TestCase;
+
+pub struct GradientOklchLonger {
+    gradient_format: GradientInterpolation,
+}
+
+impl GradientOklchLonger {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
+        Self {
+            gradient_format: GradientInterpolation {
+                color_space: GradientColorSpace::Oklch,
+                hue_interpolation: HueInterpolation::Longer,
+            },
+        }
+    }
+}
+
+impl TestCase for GradientOklchLonger {
+    fn render(
+        &mut self,
+        _renderer: &mut GlesRenderer,
+        size: Size<i32, Physical>,
+    ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
+        let (a, b) = (size.w / 6, size.h / 3);
+        let size = (size.w - a * 2, size.h - b * 2);
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
+
+        [BorderRenderElement::new(
+            area.size,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            self.gradient_format,
+            Color::new_unpremul(1., 0., 0., 1.),
+            Color::new_unpremul(0., 1., 0., 1.),
+            0.,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            0.,
+            CornerRadius::default(),
+            1.,
+        )
+        .with_location(area.loc)]
+        .into_iter()
+        .map(|elem| Box::new(elem) as _)
+        .collect()
+    }
+}
@@ -0,0 +1,53 @@
+use niri::render_helpers::border::BorderRenderElement;
+use niri_config::{
+    Color, CornerRadius, GradientColorSpace, GradientInterpolation, HueInterpolation,
+};
+use smithay::backend::renderer::element::RenderElement;
+use smithay::backend::renderer::gles::GlesRenderer;
+use smithay::utils::{Logical, Physical, Rectangle, Size};
+
+use super::TestCase;
+
+pub struct GradientOklchShorter {
+    gradient_format: GradientInterpolation,
+}
+
+impl GradientOklchShorter {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
+        Self {
+            gradient_format: GradientInterpolation {
+                color_space: GradientColorSpace::Oklch,
+                hue_interpolation: HueInterpolation::Shorter,
+            },
+        }
+    }
+}
+
+impl TestCase for GradientOklchShorter {
+    fn render(
+        &mut self,
+        _renderer: &mut GlesRenderer,
+        size: Size<i32, Physical>,
+    ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
+        let (a, b) = (size.w / 6, size.h / 3);
+        let size = (size.w - a * 2, size.h - b * 2);
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
+
+        [BorderRenderElement::new(
+            area.size,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            self.gradient_format,
+            Color::new_unpremul(1., 0., 0., 1.),
+            Color::new_unpremul(0., 1., 0., 1.),
+            0.,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            0.,
+            CornerRadius::default(),
+            1.,
+        )
+        .with_location(area.loc)]
+        .into_iter()
+        .map(|elem| Box::new(elem) as _)
+        .collect()
+    }
+}
@@ -0,0 +1,53 @@
+use niri::render_helpers::border::BorderRenderElement;
+use niri_config::{
+    Color, CornerRadius, GradientColorSpace, GradientInterpolation, HueInterpolation,
+};
+use smithay::backend::renderer::element::RenderElement;
+use smithay::backend::renderer::gles::GlesRenderer;
+use smithay::utils::{Logical, Physical, Rectangle, Size};
+
+use super::TestCase;
+
+pub struct GradientSrgb {
+    gradient_format: GradientInterpolation,
+}
+
+impl GradientSrgb {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
+        Self {
+            gradient_format: GradientInterpolation {
+                color_space: GradientColorSpace::Srgb,
+                hue_interpolation: HueInterpolation::Shorter,
+            },
+        }
+    }
+}
+
+impl TestCase for GradientSrgb {
+    fn render(
+        &mut self,
+        _renderer: &mut GlesRenderer,
+        size: Size<i32, Physical>,
+    ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
+        let (a, b) = (size.w / 6, size.h / 3);
+        let size = (size.w - a * 2, size.h - b * 2);
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
+
+        [BorderRenderElement::new(
+            area.size,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            self.gradient_format,
+            Color::new_unpremul(1., 0., 0., 1.),
+            Color::new_unpremul(0., 1., 0., 1.),
+            0.,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            0.,
+            CornerRadius::default(),
+            1.,
+        )
+        .with_location(area.loc)]
+        .into_iter()
+        .map(|elem| Box::new(elem) as _)
+        .collect()
+    }
+}
@@ -0,0 +1,51 @@
+use niri::render_helpers::border::BorderRenderElement;
+use niri_config::{Color, CornerRadius, GradientColorSpace, GradientInterpolation};
+use smithay::backend::renderer::element::RenderElement;
+use smithay::backend::renderer::gles::GlesRenderer;
+use smithay::utils::{Logical, Physical, Rectangle, Size};
+
+use super::TestCase;
+
+pub struct GradientSrgbAlpha {
+    gradient_format: GradientInterpolation,
+}
+
+impl GradientSrgbAlpha {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
+        Self {
+            gradient_format: GradientInterpolation {
+                color_space: GradientColorSpace::Srgb,
+                hue_interpolation: Default::default(),
+            },
+        }
+    }
+}
+
+impl TestCase for GradientSrgbAlpha {
+    fn render(
+        &mut self,
+        _renderer: &mut GlesRenderer,
+        size: Size<i32, Physical>,
+    ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
+        let (a, b) = (size.w / 6, size.h / 3);
+        let size = (size.w - a * 2, size.h - b * 2);
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
+
+        [BorderRenderElement::new(
+            area.size,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            self.gradient_format,
+            Color::new_unpremul(1., 0., 0., 1.),
+            Color::new_unpremul(0., 1., 0., 0.),
+            0.,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            0.,
+            CornerRadius::default(),
+            1.,
+        )
+        .with_location(area.loc)]
+        .into_iter()
+        .map(|elem| Box::new(elem) as _)
+        .collect()
+    }
+}
@@ -0,0 +1,53 @@
+use niri::render_helpers::border::BorderRenderElement;
+use niri_config::{
+    Color, CornerRadius, GradientColorSpace, GradientInterpolation, HueInterpolation,
+};
+use smithay::backend::renderer::element::RenderElement;
+use smithay::backend::renderer::gles::GlesRenderer;
+use smithay::utils::{Logical, Physical, Rectangle, Size};
+
+use super::TestCase;
+
+pub struct GradientSrgbLinear {
+    gradient_format: GradientInterpolation,
+}
+
+impl GradientSrgbLinear {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
+        Self {
+            gradient_format: GradientInterpolation {
+                color_space: GradientColorSpace::SrgbLinear,
+                hue_interpolation: HueInterpolation::Shorter,
+            },
+        }
+    }
+}
+
+impl TestCase for GradientSrgbLinear {
+    fn render(
+        &mut self,
+        _renderer: &mut GlesRenderer,
+        size: Size<i32, Physical>,
+    ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
+        let (a, b) = (size.w / 6, size.h / 3);
+        let size = (size.w - a * 2, size.h - b * 2);
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
+
+        [BorderRenderElement::new(
+            area.size,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            self.gradient_format,
+            Color::new_unpremul(1., 0., 0., 1.),
+            Color::new_unpremul(0., 1., 0., 1.),
+            0.,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            0.,
+            CornerRadius::default(),
+            1.,
+        )
+        .with_location(area.loc)]
+        .into_iter()
+        .map(|elem| Box::new(elem) as _)
+        .collect()
+    }
+}
@@ -0,0 +1,51 @@
+use niri::render_helpers::border::BorderRenderElement;
+use niri_config::{Color, CornerRadius, GradientColorSpace, GradientInterpolation};
+use smithay::backend::renderer::element::RenderElement;
+use smithay::backend::renderer::gles::GlesRenderer;
+use smithay::utils::{Logical, Physical, Rectangle, Size};
+
+use super::TestCase;
+
+pub struct GradientSrgbLinearAlpha {
+    gradient_format: GradientInterpolation,
+}
+
+impl GradientSrgbLinearAlpha {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
+        Self {
+            gradient_format: GradientInterpolation {
+                color_space: GradientColorSpace::SrgbLinear,
+                hue_interpolation: Default::default(),
+            },
+        }
+    }
+}
+
+impl TestCase for GradientSrgbLinearAlpha {
+    fn render(
+        &mut self,
+        _renderer: &mut GlesRenderer,
+        size: Size<i32, Physical>,
+    ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
+        let (a, b) = (size.w / 6, size.h / 3);
+        let size = (size.w - a * 2, size.h - b * 2);
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
+
+        [BorderRenderElement::new(
+            area.size,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            self.gradient_format,
+            Color::new_unpremul(1., 0., 0., 1.),
+            Color::new_unpremul(0., 1., 0., 0.),
+            0.,
+            Rectangle::from_loc_and_size((0., 0.), area.size),
+            0.,
+            CornerRadius::default(),
+            1.,
+        )
+        .with_location(area.loc)]
+        .into_iter()
+        .map(|elem| Box::new(elem) as _)
+        .collect()
+    }
+}
@@ -2,9 +2,10 @@ use std::collections::HashMap;
 use std::time::Duration;

 use niri::layout::workspace::ColumnWidth;
-use niri::layout::Options;
+use niri::layout::{LayoutElement as _, Options};
+use niri::render_helpers::RenderTarget;
 use niri::utils::get_monotonic_time;
-use niri_config::Color;
+use niri_config::{Color, FloatOrInt, OutputName};
 use smithay::backend::renderer::element::RenderElement;
 use smithay::backend::renderer::gles::GlesRenderer;
 use smithay::desktop::layer_map_for_output;
@@ -40,6 +41,12 @@ impl Layout {
            refresh: 60000,
        });
        output.change_current_state(mode, None, None, None);
+        output.user_data().insert_if_missing(|| OutputName {
+            connector: String::new(),
+            make: None,
+            model: None,
+            serial: None,
+        });

        let options = Options {
            focus_ring: niri_config::FocusRing {
@@ -48,9 +55,11 @@ impl Layout {
            },
            border: niri_config::Border {
                off: false,
-                width: 4,
-                active_color: Color::new(255, 163, 72, 255),
-                inactive_color: Color::new(50, 50, 50, 255),
+                width: FloatOrInt(4.),
+                active_color: Color::from_rgba8_unpremul(255, 163, 72, 255),
+                inactive_color: Color::from_rgba8_unpremul(50, 50, 50, 255),
+                active_gradient: None,
+                inactive_gradient: None,
            },
            ..Default::default()
        };
@@ -71,12 +80,12 @@ impl Layout {

        rv.add_window(TestWindow::freeform(0), Some(ColumnWidth::Proportion(0.3)));
        rv.add_window(TestWindow::freeform(1), Some(ColumnWidth::Proportion(0.3)));
-        rv.layout.activate_window(&rv.windows[0]);
+        rv.layout.activate_window(&0);

        rv.add_step(500, |l| {
            let win = TestWindow::freeform(2);
            l.add_window(win.clone(), Some(ColumnWidth::Proportion(0.3)));
-            l.layout.start_open_animation_for_window(&win);
+            l.layout.start_open_animation_for_window(win.id());
        });

        rv
@@ -89,7 +98,7 @@ impl Layout {
            rv.add_step(delay, move |l| {
                let win = TestWindow::freeform(delay as usize);
                l.add_window(win.clone(), Some(ColumnWidth::Proportion(0.3)));
-                l.layout.start_open_animation_for_window(&win);
+                l.layout.start_open_animation_for_window(win.id());
            });
        }

@@ -103,7 +112,7 @@ impl Layout {
            rv.add_step(delay, move |l| {
                let win = TestWindow::freeform(delay as usize);
                l.add_window(win.clone(), Some(ColumnWidth::Proportion(0.5)));
-                l.layout.start_open_animation_for_window(&win);
+                l.layout.start_open_animation_for_window(win.id());
            });
        }

@@ -120,7 +129,7 @@ impl Layout {
            let win = TestWindow::freeform(2);
            let right_of = l.windows[0].clone();
            l.add_window_right_of(&right_of, win.clone(), Some(ColumnWidth::Proportion(0.3)));
-            l.layout.start_open_animation_for_window(&win);
+            l.layout.start_open_animation_for_window(win.id());
        });

        rv
@@ -136,32 +145,33 @@ impl Layout {
            let win = TestWindow::freeform(2);
            let right_of = l.windows[0].clone();
            l.add_window_right_of(&right_of, win.clone(), Some(ColumnWidth::Proportion(0.5)));
-            l.layout.start_open_animation_for_window(&win);
+            l.layout.start_open_animation_for_window(win.id());
        });

        rv
    }

-    fn add_window(&mut self, window: TestWindow, width: Option<ColumnWidth>) {
-        self.layout
-            .add_window(window.clone(), width.map(Some), false);
-        if window.communicate() {
-            self.layout.update_window(&window);
-        }
+    fn add_window(&mut self, mut window: TestWindow, width: Option<ColumnWidth>) {
+        let ws = self.layout.active_workspace().unwrap();
+        window.request_size(ws.new_window_size(width, window.rules()), false, None);
+        window.communicate();
+
+        self.layout.add_window(window.clone(), width, false);
        self.windows.push(window);
    }

    fn add_window_right_of(
        &mut self,
        right_of: &TestWindow,
-        window: TestWindow,
+        mut window: TestWindow,
        width: Option<ColumnWidth>,
    ) {
+        let ws = self.layout.active_workspace().unwrap();
+        window.request_size(ws.new_window_size(width, window.rules()), false, None);
+        window.communicate();
+
        self.layout
-            .add_window_right_of(right_of, window.clone(), width.map(Some), false);
-        if window.communicate() {
-            self.layout.update_window(&window);
-        }
+            .add_window_right_of(right_of.id(), window.clone(), width, false);
        self.windows.push(window);
    }

@@ -182,17 +192,13 @@ impl TestCase for Layout {
        self.layout.update_output_size(&self.output);
        for win in &self.windows {
            if win.communicate() {
-                self.layout.update_window(win);
+                self.layout.update_window(win.id(), None);
            }
        }
    }

    fn are_animations_ongoing(&self) -> bool {
-        self.layout
-            .monitor_for_output(&self.output)
-            .unwrap()
-            .are_animations_ongoing()
-            || !self.steps.is_empty()
+        self.layout.are_animations_ongoing(Some(&self.output)) || !self.steps.is_empty()
    }

    fn advance_animations(&mut self, mut current_time: Duration) {
@@ -218,11 +224,11 @@ impl TestCase for Layout {
        renderer: &mut GlesRenderer,
        _size: Size<i32, Physical>,
    ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
+        self.layout.update_render_elements(Some(&self.output));
        self.layout
            .monitor_for_output(&self.output)
            .unwrap()
-            .render_elements(renderer)
-            .into_iter()
+            .render_elements(renderer, RenderTarget::Output)
            .map(|elem| Box::new(elem) as _)
            .collect()
    }
@@ -4,12 +4,25 @@ use smithay::backend::renderer::element::RenderElement;
 use smithay::backend::renderer::gles::GlesRenderer;
 use smithay::utils::{Physical, Size};

+pub mod gradient_angle;
+pub mod gradient_area;
+pub mod gradient_oklab;
+pub mod gradient_oklab_alpha;
+pub mod gradient_oklch_alpha;
+pub mod gradient_oklch_decreasing;
+pub mod gradient_oklch_increasing;
+pub mod gradient_oklch_longer;
+pub mod gradient_oklch_shorter;
+pub mod gradient_srgb;
+pub mod gradient_srgb_alpha;
+pub mod gradient_srgblinear;
+pub mod gradient_srgblinear_alpha;
 pub mod layout;
 pub mod tile;
 pub mod window;

 pub trait TestCase {
-    fn resize(&mut self, width: i32, height: i32);
+    fn resize(&mut self, _width: i32, _height: i32) {}
    fn are_animations_ongoing(&self) -> bool {
        false
    }
@@ -2,10 +2,11 @@ use std::rc::Rc;
 use std::time::Duration;

 use niri::layout::Options;
-use niri_config::Color;
+use niri::render_helpers::RenderTarget;
+use niri_config::{Color, FloatOrInt};
 use smithay::backend::renderer::element::RenderElement;
 use smithay::backend::renderer::gles::GlesRenderer;
-use smithay::utils::{Logical, Physical, Point, Scale, Size};
+use smithay::utils::{Logical, Physical, Point, Rectangle, Scale, Size};

 use super::TestCase;
 use crate::test_window::TestWindow;
@@ -19,7 +20,7 @@ impl Tile {
    pub fn freeform(size: Size<i32, Logical>) -> Self {
        let window = TestWindow::freeform(0);
        let mut rv = Self::with_window(window);
-        rv.tile.request_tile_size(size);
+        rv.tile.request_tile_size(size.to_f64(), false, None);
        rv.window.communicate();
        rv
    }
@@ -27,7 +28,7 @@ impl Tile {
    pub fn fixed_size(size: Size<i32, Logical>) -> Self {
        let window = TestWindow::fixed_size(0);
        let mut rv = Self::with_window(window);
-        rv.tile.request_tile_size(size);
+        rv.tile.request_tile_size(size.to_f64(), false, None);
        rv.window.communicate();
        rv
    }
@@ -36,7 +37,7 @@ impl Tile {
        let window = TestWindow::fixed_size(0);
        window.set_csd_shadow_width(64);
        let mut rv = Self::with_window(window);
-        rv.tile.request_tile_size(size);
+        rv.tile.request_tile_size(size.to_f64(), false, None);
        rv.window.communicate();
        rv
    }
@@ -70,20 +71,21 @@ impl Tile {
            },
            border: niri_config::Border {
                off: false,
-                width: 32,
-                active_color: Color::new(255, 163, 72, 255),
+                width: FloatOrInt(32.),
+                active_color: Color::from_rgba8_unpremul(255, 163, 72, 255),
                ..Default::default()
            },
            ..Default::default()
        };
-        let tile = niri::layout::tile::Tile::new(window.clone(), Rc::new(options));
+        let tile = niri::layout::tile::Tile::new(window.clone(), 1., Rc::new(options));
        Self { window, tile }
    }
 }

 impl TestCase for Tile {
    fn resize(&mut self, width: i32, height: i32) {
-        self.tile.request_tile_size(Size::from((width, height)));
+        self.tile
+            .request_tile_size(Size::from((width, height)).to_f64(), false, None);
        self.window.communicate();
    }

@@ -92,7 +94,7 @@ impl TestCase for Tile {
    }

    fn advance_animations(&mut self, current_time: Duration) {
-        self.tile.advance_animations(current_time, true);
+        self.tile.advance_animations(current_time);
    }

    fn render(
@@ -100,11 +102,22 @@ impl TestCase for Tile {
        renderer: &mut GlesRenderer,
        size: Size<i32, Physical>,
    ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
-        let tile_size = self.tile.tile_size().to_physical(1);
-        let location = Point::from(((size.w - tile_size.w) / 2, (size.h - tile_size.h) / 2));
+        let size = size.to_f64();
+        let tile_size = self.tile.tile_size().to_physical(1.);
+        let location = Point::from((size.w - tile_size.w, size.h - tile_size.h)).downscale(2.);

+        self.tile.update(
+            true,
+            Rectangle::from_loc_and_size((-location.x, -location.y), size.to_logical(1.)),
+        );
        self.tile
-            .render(renderer, location, Scale::from(1.), true)
+            .render(
+                renderer,
+                location,
+                Scale::from(1.),
+                true,
+                RenderTarget::Output,
+            )
            .map(|elem| Box::new(elem) as _)
            .collect()
    }
@@ -1,4 +1,5 @@
 use niri::layout::LayoutElement;
+use niri::render_helpers::RenderTarget;
 use smithay::backend::renderer::element::RenderElement;
 use smithay::backend::renderer::gles::GlesRenderer;
 use smithay::utils::{Logical, Physical, Point, Scale, Size};
@@ -12,23 +13,23 @@ pub struct Window {

 impl Window {
    pub fn freeform(size: Size<i32, Logical>) -> Self {
-        let window = TestWindow::freeform(0);
-        window.request_size(size);
+        let mut window = TestWindow::freeform(0);
+        window.request_size(size, false, None);
        window.communicate();
        Self { window }
    }

    pub fn fixed_size(size: Size<i32, Logical>) -> Self {
-        let window = TestWindow::fixed_size(0);
-        window.request_size(size);
+        let mut window = TestWindow::fixed_size(0);
+        window.request_size(size, false, None);
        window.communicate();
        Self { window }
    }

    pub fn fixed_size_with_csd_shadow(size: Size<i32, Logical>) -> Self {
-        let window = TestWindow::fixed_size(0);
+        let mut window = TestWindow::fixed_size(0);
        window.set_csd_shadow_width(64);
-        window.request_size(size);
+        window.request_size(size, false, None);
        window.communicate();
        Self { window }
    }
@@ -36,7 +37,8 @@ impl Window {

 impl TestCase for Window {
    fn resize(&mut self, width: i32, height: i32) {
-        self.window.request_size(Size::from((width, height)));
+        self.window
+            .request_size(Size::from((width, height)), false, None);
        self.window.communicate();
    }

@@ -46,10 +48,18 @@ impl TestCase for Window {
        size: Size<i32, Physical>,
    ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
        let win_size = self.window.size().to_physical(1);
-        let location = Point::from(((size.w - win_size.w) / 2, (size.h - win_size.h) / 2));
+        let location = Point::from((size.w - win_size.w, size.h - win_size.h))
+            .to_f64()
+            .downscale(2.);

        self.window
-            .render(renderer, location, Scale::from(1.))
+            .render(
+                renderer,
+                location,
+                Scale::from(1.),
+                1.,
+                RenderTarget::Output,
+            )
            .into_iter()
            .map(|elem| Box::new(elem) as _)
            .collect()
@@ -5,8 +5,6 @@ use std::env;
 use std::sync::atomic::Ordering;

 use adw::prelude::{AdwApplicationWindowExt, NavigationPageExt};
-use cases::tile::Tile;
-use cases::window::Window;
 use gtk::prelude::{
    AdjustmentExt, ApplicationExt, ApplicationExtManual, BoxExt, GtkWindowExt, WidgetExt,
 };
@@ -16,7 +14,22 @@ use smithay::utils::{Logical, Size};
 use smithay_view::SmithayView;
 use tracing_subscriber::EnvFilter;

+use crate::cases::gradient_angle::GradientAngle;
+use crate::cases::gradient_area::GradientArea;
+use crate::cases::gradient_oklab::GradientOklab;
+use crate::cases::gradient_oklab_alpha::GradientOklabAlpha;
+use crate::cases::gradient_oklch_alpha::GradientOklchAlpha;
+use crate::cases::gradient_oklch_decreasing::GradientOklchDecreasing;
+use crate::cases::gradient_oklch_increasing::GradientOklchIncreasing;
+use crate::cases::gradient_oklch_longer::GradientOklchLonger;
+use crate::cases::gradient_oklch_shorter::GradientOklchShorter;
+use crate::cases::gradient_srgb::GradientSrgb;
+use crate::cases::gradient_srgb_alpha::GradientSrgbAlpha;
+use crate::cases::gradient_srgblinear::GradientSrgbLinear;
+use crate::cases::gradient_srgblinear_alpha::GradientSrgbLinearAlpha;
 use crate::cases::layout::Layout;
+use crate::cases::tile::Tile;
+use crate::cases::window::Window;
 use crate::cases::TestCase;

 mod cases;
@@ -108,6 +121,20 @@ fn build_ui(app: &adw::Application) {
        "Layout - Open To The Left - Big",
    );

+    s.add(GradientAngle::new, "Gradient - Angle");
+    s.add(GradientArea::new, "Gradient - Area");
+    s.add(GradientSrgb::new, "Gradient - Srgb");
+    s.add(GradientSrgbLinear::new, "Gradient - SrgbLinear");
+    s.add(GradientOklab::new, "Gradient - Oklab");
+    s.add(GradientOklchShorter::new, "Gradient - Oklch Shorter");
+    s.add(GradientOklchLonger::new, "Gradient - Oklch Longer");
+    s.add(GradientOklchIncreasing::new, "Gradient - Oklch Increasing");
+    s.add(GradientOklchDecreasing::new, "Gradient - Oklch Decreasing");
+    s.add(GradientSrgbAlpha::new, "Gradient - Srgb Alpha");
+    s.add(GradientSrgbLinearAlpha::new, "Gradient - SrgbLinear Alpha");
+    s.add(GradientOklabAlpha::new, "Gradient - Oklab Alpha");
+    s.add(GradientOklchAlpha::new, "Gradient - Oklch Alpha");
+
    let content_headerbar = adw::HeaderBar::new();

    let anim_adjustment = gtk::Adjustment::new(1., 0., 10., 0.1, 0.5, 0.);
@@ -11,11 +11,12 @@ mod imp {
    use anyhow::{ensure, Context};
    use gtk::gdk;
    use gtk::prelude::*;
+    use niri::render_helpers::{resources, shaders};
    use niri::utils::get_monotonic_time;
    use smithay::backend::egl::ffi::egl;
    use smithay::backend::egl::EGLContext;
-    use smithay::backend::renderer::gles::{Capability, GlesRenderer};
-    use smithay::backend::renderer::{Frame, Renderer, Unbind};
+    use smithay::backend::renderer::gles::GlesRenderer;
+    use smithay::backend::renderer::{Color32F, Frame, Renderer, Unbind};
    use smithay::utils::{Physical, Rectangle, Scale, Transform};

    use super::*;
@@ -146,7 +147,7 @@ mod imp {
                .context("error creating frame")?;

            frame
-                .clear([0.3, 0.3, 0.3, 1.], &[rect])
+                .clear(Color32F::from([0.3, 0.3, 0.3, 1.]), &[rect])
                .context("error clearing")?;

            for element in elements.iter().rev() {
@@ -156,7 +157,7 @@ mod imp {
                if let Some(mut damage) = rect.intersection(dst) {
                    damage.loc -= dst.loc;
                    element
-                        .draw(&mut frame, src, dst, &[damage])
+                        .draw(&mut frame, src, dst, &[damage], &[])
                        .context("error drawing element")?;
                }
            }
@@ -185,13 +186,13 @@ mod imp {

        let egl_context = EGLContext::from_raw(egl_display, egl_config_id as *const _, egl_context)
            .context("error creating EGL context")?;
-        let capabilities = GlesRenderer::supported_capabilities(&egl_context)
-            .context("error getting supported renderer capabilities")?
-            .into_iter()
-            .filter(|c| *c != Capability::ColorTransformations);

-        GlesRenderer::with_capabilities(egl_context, capabilities)
-            .context("error creating GlesRenderer")
+        let mut renderer = GlesRenderer::new(egl_context).context("error creating GlesRenderer")?;
+
+        resources::init(&mut renderer);
+        shaders::init(&mut renderer);
+
+        Ok(renderer)
    }

    unsafe fn with_framebuffer_save_restore<T>(
@@ -2,17 +2,22 @@ use std::cell::RefCell;
 use std::cmp::{max, min};
 use std::rc::Rc;

-use niri::layout::{LayoutElement, LayoutElementRenderElement};
+use niri::layout::{
+    ConfigureIntent, InteractiveResizeData, LayoutElement, LayoutElementRenderElement,
+    LayoutElementRenderSnapshot,
+};
 use niri::render_helpers::renderer::NiriRenderer;
-use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};
+use niri::render_helpers::solid_color::{SolidColorBuffer, SolidColorRenderElement};
+use niri::render_helpers::{RenderTarget, SplitElements};
+use niri::utils::transaction::Transaction;
+use niri::window::ResolvedWindowRules;
 use smithay::backend::renderer::element::{Id, Kind};
-use smithay::output::Output;
+use smithay::output::{self, Output};
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
-use smithay::utils::{Logical, Point, Scale, Size, Transform};
+use smithay::utils::{Logical, Point, Scale, Serial, Size, Transform};

 #[derive(Debug)]
 struct TestWindowInner {
-    id: usize,
    size: Size<i32, Logical>,
    requested_size: Option<Size<i32, Logical>>,
    min_size: Size<i32, Logical>,
@@ -24,26 +29,31 @@ struct TestWindowInner {
 }

 #[derive(Debug, Clone)]
-pub struct TestWindow(Rc<RefCell<TestWindowInner>>);
+pub struct TestWindow {
+    id: usize,
+    inner: Rc<RefCell<TestWindowInner>>,
+}

 impl TestWindow {
    pub fn freeform(id: usize) -> Self {
        let size = Size::from((100, 200));
        let min_size = Size::from((0, 0));
        let max_size = Size::from((0, 0));
-        let buffer = SolidColorBuffer::new(size, [0.15, 0.64, 0.41, 1.]);
+        let buffer = SolidColorBuffer::new(size.to_f64(), [0.15, 0.64, 0.41, 1.]);

-        Self(Rc::new(RefCell::new(TestWindowInner {
+        Self {
            id,
-            size,
-            requested_size: None,
-            min_size,
-            max_size,
-            buffer,
-            pending_fullscreen: false,
-            csd_shadow_width: 0,
-            csd_shadow_buffer: SolidColorBuffer::new((0, 0), [0., 0., 0., 0.3]),
-        })))
+            inner: Rc::new(RefCell::new(TestWindowInner {
+                size,
+                requested_size: None,
+                min_size,
+                max_size,
+                buffer,
+                pending_fullscreen: false,
+                csd_shadow_width: 0,
+                csd_shadow_buffer: SolidColorBuffer::new((0., 0.), [0., 0., 0., 0.3]),
+            })),
+        }
    }

    pub fn fixed_size(id: usize) -> Self {
@@ -56,28 +66,28 @@ impl TestWindow {
    }

    pub fn set_min_size(&self, size: Size<i32, Logical>) {
-        self.0.borrow_mut().min_size = size;
+        self.inner.borrow_mut().min_size = size;
    }

    pub fn set_max_size(&self, size: Size<i32, Logical>) {
-        self.0.borrow_mut().max_size = size;
+        self.inner.borrow_mut().max_size = size;
    }

    pub fn set_color(&self, color: [f32; 4]) {
-        self.0.borrow_mut().buffer.set_color(color);
+        self.inner.borrow_mut().buffer.set_color(color);
    }

    pub fn set_csd_shadow_width(&self, width: i32) {
-        self.0.borrow_mut().csd_shadow_width = width;
+        self.inner.borrow_mut().csd_shadow_width = width;
    }

    pub fn communicate(&self) -> bool {
        let mut rv = false;
-        let mut inner = self.0.borrow_mut();
+        let mut inner = self.inner.borrow_mut();

        let mut new_size = inner.size;

-        if let Some(size) = inner.requested_size.take() {
+        if let Some(size) = inner.requested_size {
            assert!(size.w >= 0);
            assert!(size.h >= 0);

@@ -104,28 +114,28 @@ impl TestWindow {

        if inner.size != new_size {
            inner.size = new_size;
-            inner.buffer.resize(new_size);
+            inner.buffer.resize(new_size.to_f64());
            rv = true;
        }

        let mut csd_shadow_size = new_size;
        csd_shadow_size.w += inner.csd_shadow_width * 2;
        csd_shadow_size.h += inner.csd_shadow_width * 2;
-        inner.csd_shadow_buffer.resize(csd_shadow_size);
+        inner.csd_shadow_buffer.resize(csd_shadow_size.to_f64());

        rv
    }
 }

-impl PartialEq for TestWindow {
-    fn eq(&self, other: &Self) -> bool {
-        self.0.borrow().id == other.0.borrow().id
-    }
-}
-
 impl LayoutElement for TestWindow {
+    type Id = usize;
+
+    fn id(&self) -> &Self::Id {
+        &self.id
+    }
+
    fn size(&self) -> Size<i32, Logical> {
-        self.0.borrow().size
+        self.inner.borrow().size
    }

    fn buf_loc(&self) -> Point<i32, Logical> {
@@ -139,54 +149,62 @@ impl LayoutElement for TestWindow {
    fn render<R: NiriRenderer>(
        &self,
        _renderer: &mut R,
-        location: Point<i32, Logical>,
-        scale: Scale<f64>,
-    ) -> Vec<LayoutElementRenderElement<R>> {
-        let inner = self.0.borrow();
+        location: Point<f64, Logical>,
+        _scale: Scale<f64>,
+        alpha: f32,
+        _target: RenderTarget,
+    ) -> SplitElements<LayoutElementRenderElement<R>> {
+        let inner = self.inner.borrow();

-        vec![
-            SolidColorRenderElement::from_buffer(
-                &inner.buffer,
-                location.to_physical_precise_round(scale),
-                scale,
-                1.,
-                Kind::Unspecified,
-            )
-            .into(),
-            SolidColorRenderElement::from_buffer(
-                &inner.csd_shadow_buffer,
-                (location - Point::from((inner.csd_shadow_width, inner.csd_shadow_width)))
-                    .to_physical_precise_round(scale),
-                scale,
-                1.,
-                Kind::Unspecified,
-            )
-            .into(),
-        ]
+        SplitElements {
+            normal: vec![
+                SolidColorRenderElement::from_buffer(
+                    &inner.buffer,
+                    location,
+                    alpha,
+                    Kind::Unspecified,
+                )
+                .into(),
+                SolidColorRenderElement::from_buffer(
+                    &inner.csd_shadow_buffer,
+                    location
+                        - Point::from((inner.csd_shadow_width, inner.csd_shadow_width)).to_f64(),
+                    alpha,
+                    Kind::Unspecified,
+                )
+                .into(),
+            ],
+            popups: vec![],
+        }
    }

-    fn request_size(&self, size: Size<i32, Logical>) {
-        self.0.borrow_mut().requested_size = Some(size);
-        self.0.borrow_mut().pending_fullscreen = false;
+    fn request_size(
+        &mut self,
+        size: Size<i32, Logical>,
+        _animate: bool,
+        _transaction: Option<Transaction>,
+    ) {
+        self.inner.borrow_mut().requested_size = Some(size);
+        self.inner.borrow_mut().pending_fullscreen = false;
    }

    fn request_fullscreen(&self, _size: Size<i32, Logical>) {
-        self.0.borrow_mut().pending_fullscreen = true;
+        self.inner.borrow_mut().pending_fullscreen = true;
    }

    fn min_size(&self) -> Size<i32, Logical> {
-        self.0.borrow().min_size
+        self.inner.borrow().min_size
    }

    fn max_size(&self) -> Size<i32, Logical> {
-        self.0.borrow().max_size
+        self.inner.borrow().max_size
    }

    fn is_wl_surface(&self, _wl_surface: &WlSurface) -> bool {
        false
    }

-    fn set_preferred_scale_transform(&self, _scale: i32, _transform: Transform) {}
+    fn set_preferred_scale_transform(&self, _scale: output::Scale, _transform: Transform) {}

    fn has_ssd(&self) -> bool {
        false
@@ -198,11 +216,52 @@ impl LayoutElement for TestWindow {

    fn set_offscreen_element_id(&self, _id: Option<Id>) {}

+    fn set_activated(&mut self, _active: bool) {}
+
+    fn set_active_in_column(&mut self, _active: bool) {}
+
+    fn set_bounds(&self, _bounds: Size<i32, Logical>) {}
+
+    fn configure_intent(&self) -> ConfigureIntent {
+        ConfigureIntent::CanSend
+    }
+
+    fn send_pending_configure(&mut self) {}
+
    fn is_fullscreen(&self) -> bool {
        false
    }

    fn is_pending_fullscreen(&self) -> bool {
-        self.0.borrow().pending_fullscreen
+        self.inner.borrow().pending_fullscreen
+    }
+
+    fn requested_size(&self) -> Option<Size<i32, Logical>> {
+        self.inner.borrow().requested_size
+    }
+
+    fn refresh(&self) {}
+
+    fn rules(&self) -> &ResolvedWindowRules {
+        static EMPTY: ResolvedWindowRules = ResolvedWindowRules::empty();
+        &EMPTY
+    }
+
+    fn animation_snapshot(&self) -> Option<&LayoutElementRenderSnapshot> {
+        None
+    }
+
+    fn take_animation_snapshot(&mut self) -> Option<LayoutElementRenderSnapshot> {
+        None
+    }
+
+    fn set_interactive_resize(&mut self, _data: Option<InteractiveResizeData>) {}
+
+    fn cancel_interactive_resize(&mut self) {}
+
+    fn update_interactive_resize(&mut self, _serial: Serial) {}
+
+    fn interactive_resize_data(&self) -> Option<InteractiveResizeData> {
+        None
    }
 }
@@ -0,0 +1,148 @@
+%bcond_without check
+
+%global cargo_install_lib 0
+
+# We want panic backtraces to work without installing the debuginfo package,
+# so we leave the debuginfo in the main binary.
+%global debug_package %{nil}
+%global __strip /bin/true
+
+# To reduce the file size, do some convincing of rust-srpm-macros
+# to leave alone the chosen debug settings from Cargo.toml.
+%global rustflags_debuginfo please-remove-me
+%global build_rustflags %{shrink:
+  -Copt-level=%rustflags_opt_level
+  -Ccodegen-units=%rustflags_codegen_units
+  -Cstrip=none
+  %{expr:0%{?_include_frame_pointers} && ("%{_arch}" != "ppc64le" && "%{_arch}" != "s390x" && "%{_arch}" != "i386") ? "-Cforce-frame-pointers=yes" : ""}
+  -Clink-arg=-Wl,-z,relro
+  -Clink-arg=-Wl,-z,now
+  %[0%{?_package_note_status} ? "-Clink-arg=%_package_note_flags" : ""]
+  --cap-lints=warn
+}
+
+# Convince rust-srpm-macros to use Cargo.lock with the Smithay commit.
+%global __cargo_common_opts %{?_smp_mflags} -Z avoid-dev-deps --locked
+
+%global version {{{ git_dir_version }}}
+
+Name:           niri
+Version:        %{version}
+Release:        1%{?dist}
+Summary:        Scrollable-tiling Wayland compositor
+
+SourceLicense:  GPL-3.0-or-later
+
+# (MIT OR Apache-2.0) AND BSD-3-Clause
+# 0BSD OR MIT OR Apache-2.0
+# Apache-2.0
+# Apache-2.0 OR BSL-1.0
+# Apache-2.0 OR MIT
+# Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT
+# BSD-2-Clause
+# BSD-2-Clause OR Apache-2.0 OR MIT
+# BSD-3-Clause
+# BSD-3-Clause OR MIT OR Apache-2.0
+# GPL-3.0-or-later
+# ISC
+# MIT
+# MIT OR Apache-2.0
+# MIT OR Apache-2.0 OR Zlib
+# MIT OR Zlib OR Apache-2.0
+# MPL-2.0
+# Unlicense OR MIT
+# Zlib OR Apache-2.0 OR MIT
+License:        ((MIT OR Apache-2.0) AND BSD-3-Clause) AND (0BSD OR MIT OR Apache-2.0) AND (Apache-2.0) AND (Apache-2.0 OR BSL-1.0) AND (Apache-2.0 OR MIT) AND (Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT) AND (BSD-2-Clause) AND (BSD-2-Clause OR Apache-2.0 OR MIT) AND (BSD-3-Clause) AND (BSD-3-Clause OR MIT OR Apache-2.0) AND (GPL-3.0-or-later) AND (ISC) AND (MIT) AND (MIT OR Apache-2.0) AND (MIT OR Apache-2.0 OR Zlib) AND (MIT OR Zlib OR Apache-2.0) AND (MPL-2.0) AND (Unlicense OR MIT) AND (Zlib OR Apache-2.0 OR MIT)
+# LICENSE.dependencies contains a full license breakdown
+
+URL:            https://github.com/YaLTeR/niri
+VCS:            {{{ git_dir_vcs }}}
+Source:         {{{ git_dir_pack }}}
+
+BuildRequires:  cargo-rpm-macros >= 26
+BuildRequires:  pkgconfig(udev)
+BuildRequires:  pkgconfig(gbm)
+BuildRequires:  pkgconfig(xkbcommon)
+BuildRequires:  wayland-devel
+BuildRequires:  pkgconfig(libinput)
+BuildRequires:  pkgconfig(dbus-1)
+BuildRequires:  pkgconfig(systemd)
+BuildRequires:  pkgconfig(libseat)
+BuildRequires:  pkgconfig(libdisplay-info)
+BuildRequires:  pipewire-devel
+BuildRequires:  pango-devel
+BuildRequires:  cairo-gobject-devel
+# Needed for pipewire-rs
+BuildRequires:  clang
+
+Requires:       mesa-dri-drivers
+Requires:       mesa-libEGL
+
+# Portal implementations used by niri
+Recommends:     xdg-desktop-portal-gtk
+Recommends:     xdg-desktop-portal-gnome
+Recommends:     gnome-keyring
+
+# Suggested utilities, bound in the default config
+Recommends:     alacritty
+Recommends:     fuzzel
+Recommends:     swaylock
+# Suggested utilities
+Recommends:     swaybg
+Recommends:     mako
+Recommends:     swayidle
+
+%description
+A scrollable-tiling Wayland compositor.
+
+Windows are arranged in columns on an infinite strip going to the right.
+Opening a new window never causes existing windows to resize.
+
+%prep
+{{{ git_dir_setup_macro }}}
+
+# Make the version log message look nicer: since we're building not from niri's git repository,
+# the git version macro will show its fallback string.
+sed -i 's/"unknown commit"/"%{version}"/' src/utils/mod.rs
+
+%cargo_prep -N
+
+# We're doing an online build.
+sed -i 's/^offline = true$//' .cargo/config.toml
+
+# Final step in leaving alone our debug settings.
+sed -i 's/.*please-remove-me$//' .cargo/config.toml
+
+%build
+%cargo_build
+
+%install
+%cargo_install
+
+install -Dm755 -t %{buildroot}%{_bindir} ./resources/niri-session
+install -Dm644 -t %{buildroot}%{_datadir}/wayland-sessions ./resources/niri.desktop
+install -Dm644 -t %{buildroot}%{_datadir}/xdg-desktop-portal ./resources/niri-portals.conf
+install -Dm644 -t %{buildroot}%{_userunitdir} ./resources/niri.service
+install -Dm644 -t %{buildroot}%{_userunitdir} ./resources/niri-shutdown.target
+
+%if %{with check}
+%check
+%cargo_test -- --workspace --exclude niri-visual-tests
+%endif
+
+%files
+%license LICENSE
+%doc README.md
+%doc resources/default-config.kdl
+%doc wiki
+%{_bindir}/niri
+%{_bindir}/niri-session
+%{_datadir}/wayland-sessions/niri.desktop
+%dir %{_datadir}/xdg-desktop-portal
+%{_datadir}/xdg-desktop-portal/niri-portals.conf
+%{_userunitdir}/niri.service
+%{_userunitdir}/niri-shutdown.target
+
+%changelog
+{{{ git_dir_changelog }}}
+
@@ -1,6 +1,11 @@
 // This config is in the KDL format: https://kdl.dev
 // "/-" comments out the following node.
+// Check the wiki for a full description of the configuration:
+// https://github.com/YaLTeR/niri/wiki/Configuration:-Overview

+// Input device configuration.
+// Find the full list of options on the wiki:
+// https://github.com/YaLTeR/niri/wiki/Configuration:-Input
 input {
    keyboard {
        xkb {
@@ -11,71 +16,58 @@ input {
            // layout "us,ru"
            // options "grp:win_space_toggle,compose:ralt,ctrl:nocaps"
        }
-
-        // You can set the keyboard repeat parameters. The defaults match wlroots and sway.
-        // Delay is in milliseconds before the repeat starts. Rate is in characters per second.
-        // repeat-delay 600
-        // repeat-rate 25
-
-        // Niri can remember the keyboard layout globally (the default) or per-window.
-        // - "global" - layout change is global for all windows.
-        // - "window" - layout is tracked for each window individually.
-        // track-layout "global"
    }

    // Next sections include libinput settings.
    // Omitting settings disables them, or leaves them at their default values.
    touchpad {
+        // off
        tap
        // dwt
        // dwtp
        natural-scroll
        // accel-speed 0.2
        // accel-profile "flat"
-        // tap-button-map "left-middle-right"
+        // scroll-method "two-finger"
+        // disabled-on-external-mouse
    }

    mouse {
+        // off
        // natural-scroll
        // accel-speed 0.2
        // accel-profile "flat"
+        // scroll-method "no-scroll"
    }

    trackpoint {
+        // off
        // natural-scroll
        // accel-speed 0.2
        // accel-profile "flat"
+        // scroll-method "on-button-down"
+        // scroll-button 273
+        // middle-emulation
    }

-    tablet {
-        // Set the name of the output (see below) which the tablet will map to.
-        // If this is unset or the output doesn't exist, the tablet maps to one of the
-        // existing outputs.
-        map-to-output "eDP-1"
-    }
+    // Uncomment this to make the mouse warp to the center of newly focused windows.
+    // warp-mouse-to-focus

-    // By default, niri will take over the power button to make it sleep
-    // instead of power off.
-    // Uncomment this if you would like to configure the power button elsewhere
-    // (i.e. logind.conf).
-    // disable-power-key-handling
+    // Focus windows and outputs automatically when moving the mouse into them.
+    // Setting max-scroll-amount="0%" makes it work only on windows already fully on screen.
+    // focus-follows-mouse max-scroll-amount="0%"
 }

 // You can configure outputs by their name, which you can find
 // by running `niri msg outputs` while inside a niri instance.
 // The built-in laptop monitor is usually called "eDP-1".
+// Find more information on the wiki:
+// https://github.com/YaLTeR/niri/wiki/Configuration:-Outputs
 // Remember to uncomment the node by removing "/-"!
 /-output "eDP-1" {
    // Uncomment this line to disable this output.
    // off

-    // Scale is a floating-point number, but at the moment only integer values work.
-    scale 2.0
-
-    // Transform allows to rotate the output counter-clockwise, valid values are:
-    // normal, 90, 180, 270, flipped, flipped-90, flipped-180 and flipped-270.
-    transform "normal"
-
    // Resolution and, optionally, refresh rate of the output.
    // The format is "<width>x<height>" or "<width>x<height>@<refresh rate>".
    // If the refresh rate is omitted, niri will pick the highest refresh rate
@@ -84,52 +76,39 @@ input {
    // Run `niri msg outputs` while inside a niri instance to list all outputs and their modes.
    mode "1920x1080@120.030"

+    // You can use integer or fractional scale, for example use 1.5 for 150% scale.
+    scale 2
+
+    // Transform allows to rotate the output counter-clockwise, valid values are:
+    // normal, 90, 180, 270, flipped, flipped-90, flipped-180 and flipped-270.
+    transform "normal"
+
    // Position of the output in the global coordinate space.
    // This affects directional monitor actions like "focus-monitor-left", and cursor movement.
    // The cursor can only move between directly adjacent outputs.
-    // Output scale has to be taken into account for positioning:
+    // Output scale and rotation has to be taken into account for positioning:
    // outputs are sized in logical, or scaled, pixels.
    // For example, a 3840×2160 output with scale 2.0 will have a logical size of 1920×1080,
    // so to put another output directly adjacent to it on the right, set its x to 1920.
-    // It the position is unset or results in an overlap, the output is instead placed
+    // If the position is unset or results in an overlap, the output is instead placed
    // automatically.
    position x=1280 y=0
 }

+// Settings that influence how windows are positioned and sized.
+// Find more information on the wiki:
+// https://github.com/YaLTeR/niri/wiki/Configuration:-Layout
 layout {
-    // By default focus ring and border are rendered as a solid background rectangle
-    // behind windows. That is, they will show up through semitransparent windows.
-    // This is because windows using client-side decorations can have an arbitrary shape.
-    //
-    // If you don't like that, you should uncomment `prefer-no-csd` below.
-    // Niri will draw focus ring and border *around* windows that agree to omit their
-    // client-side decorations.
+    // Set gaps around windows in logical pixels.
+    gaps 16

-    // You can change how the focus ring looks.
-    focus-ring {
-        // Uncomment this line to disable the focus ring.
-        // off
-
-        // How many logical pixels the ring extends out from the windows.
-        width 4
-
-        // Color of the ring on the active monitor: red, green, blue, alpha.
-        active-color 127 200 255 255
-
-        // Color of the ring on inactive monitors: red, green, blue, alpha.
-        inactive-color 80 80 80 255
-    }
-
-    // You can also add a border. It's similar to the focus ring, but always visible.
-    border {
-        // The settings are the same as for the focus ring.
-        // If you enable the border, you probably want to disable the focus ring.
-        off
-
-        width 4
-        active-color 255 200 127 255
-        inactive-color 80 80 80 255
-    }
+    // When to center a column when changing focus, options are:
+    // - "never", default behavior, focusing an off-screen column will keep at the left
+    //   or right edge of the screen.
+    // - "always", the focused column will always be centered.
+    // - "on-overflow", focusing a column will center it if it doesn't fit
+    //   together with the previously focused column.
+    center-focused-column "never"

    // You can customize the widths that "switch-preset-column-width" (Mod+R) toggles between.
    preset-column-widths {
@@ -144,13 +123,73 @@ layout {
        // fixed 1920
    }

+    // You can also customize the heights that "switch-preset-window-height" (Mod+Shift+R) toggles between.
+    // preset-window-heights { }
+
    // You can change the default width of the new windows.
    default-column-width { proportion 0.5; }
    // If you leave the brackets empty, the windows themselves will decide their initial width.
    // default-column-width {}

-    // Set gaps around windows in logical pixels.
-    gaps 16
+    // By default focus ring and border are rendered as a solid background rectangle
+    // behind windows. That is, they will show up through semitransparent windows.
+    // This is because windows using client-side decorations can have an arbitrary shape.
+    //
+    // If you don't like that, you should uncomment `prefer-no-csd` below.
+    // Niri will draw focus ring and border *around* windows that agree to omit their
+    // client-side decorations.
+    //
+    // Alternatively, you can override it with a window rule called
+    // `draw-border-with-background`.
+
+    // You can change how the focus ring looks.
+    focus-ring {
+        // Uncomment this line to disable the focus ring.
+        // off
+
+        // How many logical pixels the ring extends out from the windows.
+        width 4
+
+        // Colors can be set in a variety of ways:
+        // - CSS named colors: "red"
+        // - RGB hex: "#rgb", "#rgba", "#rrggbb", "#rrggbbaa"
+        // - CSS-like notation: "rgb(255, 127, 0)", rgba(), hsl() and a few others.
+
+        // Color of the ring on the active monitor.
+        active-color "#7fc8ff"
+
+        // Color of the ring on inactive monitors.
+        inactive-color "#505050"
+
+        // You can also use gradients. They take precedence over solid colors.
+        // Gradients are rendered the same as CSS linear-gradient(angle, from, to).
+        // The angle is the same as in linear-gradient, and is optional,
+        // defaulting to 180 (top-to-bottom gradient).
+        // You can use any CSS linear-gradient tool on the web to set these up.
+        // Changing the color space is also supported, check the wiki for more info.
+        //
+        // active-gradient from="#80c8ff" to="#bbddff" angle=45
+
+        // You can also color the gradient relative to the entire view
+        // of the workspace, rather than relative to just the window itself.
+        // To do that, set relative-to="workspace-view".
+        //
+        // inactive-gradient from="#505050" to="#808080" angle=45 relative-to="workspace-view"
+    }
+
+    // You can also add a border. It's similar to the focus ring, but always visible.
+    border {
+        // The settings are the same as for the focus ring.
+        // If you enable the border, you probably want to disable the focus ring.
+        off
+
+        width 4
+        active-color "#ffc87f"
+        inactive-color "#505050"
+
+        // active-gradient from="#ffbb66" to="#ffc880" angle=45 relative-to="workspace-view"
+        // inactive-gradient from="#505050" to="#808080" angle=45 relative-to="workspace-view"
+    }

    // Struts shrink the area occupied by windows, similarly to layer-shell panels.
    // You can think of them as a kind of outer gaps. They are set in logical pixels.
@@ -163,31 +202,19 @@ layout {
        // top 64
        // bottom 64
    }
-
-    // When to center a column when changing focus, options are:
-    // - "never", default behavior, focusing an off-screen column will keep at the left
-    //   or right edge of the screen.
-    // - "on-overflow", focusing a column will center it if it doesn't fit
-    //   together with the previously focused column.
-    // - "always", the focused column will always be centered.
-    center-focused-column "never"
 }

 // Add lines like this to spawn processes at startup.
 // Note that running niri as a session supports xdg-desktop-autostart,
 // which may be more convenient to use.
+// See the binds section below for more spawn examples.
 // spawn-at-startup "alacritty" "-e" "fish"

-cursor {
-    // Change the theme and size of the cursor as well as set the
-    // `XCURSOR_THEME` and `XCURSOR_SIZE` env variables.
-    // xcursor-theme "default"
-    // xcursor-size 24
-}
-
 // Uncomment this line to ask the clients to omit their client-side decorations if possible.
 // If the client will specifically ask for CSD, the request will be honored.
-// Additionally, clients will be informed that they are tiled, removing some rounded corners.
+// Additionally, clients will be informed that they are tiled, removing some client-side rounded corners.
+// This option will also fix border/focus ring drawing behind some semitransparent windows.
+// After enabling or disabling this, you need to restart the apps for this to take effect.
 // prefer-no-csd

 // You can change the path where screenshots are saved.
@@ -198,105 +225,50 @@ screenshot-path "~/Pictures/Screenshots/Screenshot from %Y-%m-%d %H-%M-%S.png"
 // You can also set this to null to disable saving screenshots to disk.
 // screenshot-path null

-// Settings for the "Important Hotkeys" overlay.
-hotkey-overlay {
-    // Uncomment this line if you don't want to see the hotkey help at niri startup.
-    // skip-at-startup
-}
-
 // Animation settings.
+// The wiki explains how to configure individual animations:
+// https://github.com/YaLTeR/niri/wiki/Configuration:-Animations
 animations {
    // Uncomment to turn off all animations.
    // off

    // Slow down all animations by this factor. Values below 1 speed them up instead.
    // slowdown 3.0
-
-    // You can configure all individual animations.
-    // Available settings are the same for all of them:
-    // - off disables the animation.
-    // - duration-ms sets the duration of the animation in milliseconds.
-    // - curve sets the easing curve. Currently, available curves
-    //   are "ease-out-cubic" and "ease-out-expo".
-
-    // Animation when switching workspaces up and down,
-    // including after the touchpad gesture.
-    workspace-switch {
-        // off
-        // duration-ms 250
-        // curve "ease-out-cubic"
-    }
-
-    // All horizontal camera view movement:
-    // - When a window off-screen is focused and the camera scrolls to it.
-    // - When a new window appears off-screen and the camera scrolls to it.
-    // - When a window resizes bigger and the camera scrolls to show it in full.
-    // - And so on.
-    horizontal-view-movement {
-        // off
-        // duration-ms 250
-        // curve "ease-out-cubic"
-    }
-
-    // Window opening animation. Note that this one has different defaults.
-    window-open {
-        // off
-        // duration-ms 150
-        // curve "ease-out-expo"
-    }
-
-    // Config parse error and new default config creation notification
-    // open/close animation.
-    config-notification-open-close {
-        // off
-        // duration-ms 250
-        // curve "ease-out-cubic"
-    }
 }

 // Window rules let you adjust behavior for individual windows.
-// They are processed in order of appearance in this file.
-// (This example rule is commented out with a "/-" in front.)
-/-window-rule {
-    // Match directives control which windows this rule will apply to.
-    // You can match by app-id and by title.
-    // The window must match all properties of the match directive.
-    match app-id="org.myapp.MyApp" title="My Cool App"
+// Find more information on the wiki:
+// https://github.com/YaLTeR/niri/wiki/Configuration:-Window-Rules

-    // There can be multiple match directives. A window must match any one
-    // of the rule's match directives.
-    //
-    // If there are no match directives, any window will match the rule.
-    match title="Second App"
-
-    // You can also add exclude directives which have the same properties.
-    // If a window matches any exclude directive, it won't match this rule.
-    //
-    // Both app-id and title are regular expressions.
-    // Raw KDL strings are helpful here.
-    exclude app-id=r#"\.unwanted\."#
-
-    // Here are the properties that you can set on a window rule.
-    // You can override the default column width.
-    default-column-width { proportion 0.75; }
-
-    // You can set the output that this window will initially open on.
-    // If such an output does not exist, it will open on the currently
-    // focused output as usual.
-    open-on-output "eDP-1"
-}
-
-// Here's a useful example. Work around WezTerm's initial configure bug
+// Work around WezTerm's initial configure bug
 // by setting an empty default-column-width.
 window-rule {
    // This regular expression is intentionally made as specific as possible,
    // since this is the default config, and we want no false positives.
    // You can get away with just app-id="wezterm" if you want.
-    // The regular expression can match anywhere in the string.
    match app-id=r#"^org\.wezfurlong\.wezterm$"#
    default-column-width {}
 }

+// Example: block out two password managers from screen capture.
+// (This example rule is commented out with a "/-" in front.)
+/-window-rule {
+    match app-id=r#"^org\.keepassxc\.KeePassXC$"#
+    match app-id=r#"^org\.gnome\.World\.Secrets$"#
+
+    block-out-from "screen-capture"
+
+    // Use this instead if you want them visible on third-party screenshot tools.
+    // block-out-from "screencast"
+}
+
+// Example: enable rounded corners for all windows.
+// (This example rule is commented out with a "/-" in front.)
+/-window-rule {
+    geometry-corner-radius 12
+    clip-to-geometry true
+}
+
 binds {
    // Keys consist of modifiers separated by + signs, followed by an XKB key name
    // in the end. To find an XKB name for a particular key, you may use a program
@@ -317,12 +289,16 @@ binds {
    Mod+D { spawn "fuzzel"; }
    Super+Alt+L { spawn "swaylock"; }

-    // You can also use a shell:
+    // You can also use a shell. Do this if you need pipes, multiple commands, etc.
+    // Note: the entire command goes as a single argument in the end.
    // Mod+T { spawn "bash" "-c" "notify-send hello && exec alacritty"; }

    // Example volume keys mappings for PipeWire & WirePlumber.
-    XF86AudioRaiseVolume { spawn "wpctl" "set-volume" "@DEFAULT_AUDIO_SINK@" "0.1+"; }
-    XF86AudioLowerVolume { spawn "wpctl" "set-volume" "@DEFAULT_AUDIO_SINK@" "0.1-"; }
+    // The allow-when-locked=true property makes them work even when the session is locked.
+    XF86AudioRaiseVolume allow-when-locked=true { spawn "wpctl" "set-volume" "@DEFAULT_AUDIO_SINK@" "0.1+"; }
+    XF86AudioLowerVolume allow-when-locked=true { spawn "wpctl" "set-volume" "@DEFAULT_AUDIO_SINK@" "0.1-"; }
+    XF86AudioMute        allow-when-locked=true { spawn "wpctl" "set-mute" "@DEFAULT_AUDIO_SINK@" "toggle"; }
+    XF86AudioMicMute     allow-when-locked=true { spawn "wpctl" "set-mute" "@DEFAULT_AUDIO_SOURCE@" "toggle"; }

    Mod+Q { close-window; }

@@ -400,6 +376,46 @@ binds {
    Mod+Shift+U         { move-workspace-down; }
    Mod+Shift+I         { move-workspace-up; }

+    // You can bind mouse wheel scroll ticks using the following syntax.
+    // These binds will change direction based on the natural-scroll setting.
+    //
+    // To avoid scrolling through workspaces really fast, you can use
+    // the cooldown-ms property. The bind will be rate-limited to this value.
+    // You can set a cooldown on any bind, but it's most useful for the wheel.
+    Mod+WheelScrollDown      cooldown-ms=150 { focus-workspace-down; }
+    Mod+WheelScrollUp        cooldown-ms=150 { focus-workspace-up; }
+    Mod+Ctrl+WheelScrollDown cooldown-ms=150 { move-column-to-workspace-down; }
+    Mod+Ctrl+WheelScrollUp   cooldown-ms=150 { move-column-to-workspace-up; }
+
+    Mod+WheelScrollRight      { focus-column-right; }
+    Mod+WheelScrollLeft       { focus-column-left; }
+    Mod+Ctrl+WheelScrollRight { move-column-right; }
+    Mod+Ctrl+WheelScrollLeft  { move-column-left; }
+
+    // Usually scrolling up and down with Shift in applications results in
+    // horizontal scrolling; these binds replicate that.
+    Mod+Shift+WheelScrollDown      { focus-column-right; }
+    Mod+Shift+WheelScrollUp        { focus-column-left; }
+    Mod+Ctrl+Shift+WheelScrollDown { move-column-right; }
+    Mod+Ctrl+Shift+WheelScrollUp   { move-column-left; }
+
+    // Similarly, you can bind touchpad scroll "ticks".
+    // Touchpad scrolling is continuous, so for these binds it is split into
+    // discrete intervals.
+    // These binds are also affected by touchpad's natural-scroll, so these
+    // example binds are "inverted", since we have natural-scroll enabled for
+    // touchpads by default.
+    // Mod+TouchpadScrollDown { spawn "wpctl" "set-volume" "@DEFAULT_AUDIO_SINK@" "0.02+"; }
+    // Mod+TouchpadScrollUp   { spawn "wpctl" "set-volume" "@DEFAULT_AUDIO_SINK@" "0.02-"; }
+
+    // You can refer to workspaces by index. However, keep in mind that
+    // niri is a dynamic workspace system, so these commands are kind of
+    // "best effort". Trying to refer to a workspace index bigger than
+    // the current workspace count will instead refer to the bottommost
+    // (empty) workspace.
+    //
+    // For example, with 2 workspaces + 1 empty, indices 3, 4, 5 and so on
+    // will all refer to the 3rd workspace.
    Mod+1 { focus-workspace 1; }
    Mod+2 { focus-workspace 2; }
    Mod+3 { focus-workspace 3; }
@@ -422,14 +438,21 @@ binds {
    // Alternatively, there are commands to move just a single window:
    // Mod+Ctrl+1 { move-window-to-workspace 1; }

+    // Switches focus between the current and the previous workspace.
+    // Mod+Tab { focus-workspace-previous; }
+
+    // Consume one window from the right into the focused column.
    Mod+Comma  { consume-window-into-column; }
+    // Expel one window from the focused column to the right.
    Mod+Period { expel-window-from-column; }

    // There are also commands that consume or expel a single window to the side.
-    // Mod+BracketLeft  { consume-or-expel-window-left; }
-    // Mod+BracketRight { consume-or-expel-window-right; }
+    Mod+BracketLeft  { consume-or-expel-window-left; }
+    Mod+BracketRight { consume-or-expel-window-right; }

    Mod+R { switch-preset-column-width; }
+    Mod+Shift+R { switch-preset-window-height; }
+    Mod+Ctrl+R { reset-window-height; }
    Mod+F { maximize-column; }
    Mod+Shift+F { fullscreen-window; }
    Mod+C { center-column; }
@@ -462,39 +485,9 @@ binds {
    Alt+Print { screenshot-window; }

    // The quit action will show a confirmation dialog to avoid accidental exits.
-    // If you want to skip the confirmation dialog, set the flag like so:
-    // Mod+Shift+E { quit skip-confirmation=true; }
    Mod+Shift+E { quit; }

+    // Powers off the monitors. To turn them back on, do any input like
+    // moving the mouse or pressing any other key.
    Mod+Shift+P { power-off-monitors; }
-
-    Mod+Shift+Ctrl+T { toggle-debug-tint; }
-}
-
-// Settings for debugging. Not meant for normal use.
-// These can change or stop working at any point with little notice.
-debug {
-    // Make niri take over its DBus services even if it's not running as a session.
-    // Useful for testing screen recording changes without having to relogin.
-    // The main niri instance will *not* currently take back the services; so you will
-    // need to relogin in the end.
-    // dbus-interfaces-in-non-session-instances
-
-    // Wait until every frame is done rendering before handing it over to DRM.
-    // wait-for-frame-completion-before-queueing
-
-    // Enable direct scanout into overlay planes.
-    // May cause frame drops during some animations on some hardware.
-    // enable-overlay-planes
-
-    // Disable the use of the cursor plane.
-    // The cursor will be rendered together with the rest of the frame.
-    // disable-cursor-plane
-
-    // Override the DRM device that niri will use for all rendering.
-    // render-drm-device "/dev/dri/renderD129"
-
-    // Enable the color-transformations capability of the Smithay renderer.
-    // May cause a slight decrease in rendering performance.
-    // enable-color-transformations-capability
 }
@@ -0,0 +1,8 @@
+type              = process
+command           = niri --session
+restart           = false
+working-dir       = $HOME
+depends-on        = dbus
+after             = niri-shutdown
+chain-to          = niri-shutdown
+options:          always-chain
@@ -0,0 +1,3 @@
+type               = scripted
+command            = dinitctl -u setenv WAYLAND_DISPLAY= XDG_SESSION_TYPE= XDG_CURRENT_DESKTOP= NIRI_SOCKET=
+restart            = false
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="mutter_x11_interop">
+  <description summary="X11 interoperability helper">
+    This protocol is intended to be used by the portal backend to map Wayland
+    dialogs as modal dialogs on top of X11 windows.
+  </description>
+
+  <interface name="mutter_x11_interop" version="1">
+    <description summary="X11 interoperability helper"/>
+
+    <request name="destroy" type="destructor"/>
+
+    <request name="set_x11_parent">
+      <arg name="surface" type="object" interface="wl_surface"/>
+      <arg name="xwindow" type="uint"/>
+    </request>
+  </interface>
+</protocol>
@@ -11,37 +11,51 @@ if [ -n "$SHELL" ] &&
  fi
 fi

-# Make sure there's no already running session.
-if systemctl --user -q is-active niri.service; then
-  echo 'A niri session is already running.'
-  exit 1
+# Try to detect the service manager that is being used
+if hash systemctl &> /dev/null; then
+    # Make sure there's no already running session.
+    if systemctl --user -q is-active niri.service; then
+      echo 'A niri session is already running.'
+      exit 1
+    fi
+
+    # Reset failed state of all user units.
+    systemctl --user reset-failed
+
+    # Import the login manager environment.
+    systemctl --user import-environment
+
+    # DBus activation environment is independent from systemd. While most of
+    # dbus-activated services are already using `SystemdService` directive, some
+    # still don't and thus we should set the dbus environment with a separate
+    # command.
+    if hash dbus-update-activation-environment 2>/dev/null; then
+        dbus-update-activation-environment --all
+    fi
+
+    # Start niri and wait for it to terminate.
+    systemctl --user --wait start niri.service
+
+    # Force stop of graphical-session.target.
+    systemctl --user start --job-mode=replace-irreversibly niri-shutdown.target
+
+    # Unset environment that we've set.
+    systemctl --user unset-environment WAYLAND_DISPLAY XDG_SESSION_TYPE XDG_CURRENT_DESKTOP NIRI_SOCKET
+elif hash dinitctl &> /dev/null; then
+    # Check that the user dinit daemon is running
+    if ! pgrep -u $(id -u) dinit &> /dev/null; then
+      echo "dinit user daemon is not running."
+      exit 1
+    fi
+
+    # Make sure there's no already running session.
+    if dinitctl --user is-started niri &> /dev/null; then
+      echo 'A niri session is already running.'
+      exit 1
+    fi
+
+    # Start niri
+    dinitctl --user start niri
+else
+    echo "No systemd or dinit detected, please use niri --session instead."
 fi
-
-# Reset failed state of all user units.
-systemctl --user reset-failed
-
-# Set the current desktop for xdg-desktop-portal.
-export XDG_CURRENT_DESKTOP=niri
-
-# Ensure the session type is set to Wayland for xdg-autostart apps.
-export XDG_SESSION_TYPE=wayland
-
-# Import the login manager environment.
-systemctl --user import-environment
-
-# DBus activation environment is independent from systemd. While most of
-# dbus-activated services are already using `SystemdService` directive, some
-# still don't and thus we should set the dbus environment with a separate
-# command.
-if hash dbus-update-activation-environment 2>/dev/null; then
-    dbus-update-activation-environment --all
-fi
-
-# Start niri and wait for it to terminate.
-systemctl --user --wait start niri.service
-
-# Force stop of grahical-session.target.
-systemctl --user start --job-mode=replace-irreversibly niri-shutdown.target
-
-# Unset environment that we've set.
-systemctl --user unset-environment WAYLAND_DISPLAY XDG_SESSION_TYPE XDG_CURRENT_DESKTOP NIRI_SOCKET
@@ -9,5 +9,6 @@ Wants=xdg-desktop-autostart.target
 Before=xdg-desktop-autostart.target

 [Service]
+Slice=session.slice
 Type=notify
-ExecStart=/usr/bin/niri
+ExecStart=/usr/bin/niri --session
@@ -0,0 +1,6 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta http-equiv=refresh content=0;url=niri_ipc/index.html />
+    </head>
+</html>
@@ -1,99 +0,0 @@
-use std::time::Duration;
-
-use keyframe::functions::EaseOutCubic;
-use keyframe::EasingFunction;
-use portable_atomic::{AtomicF64, Ordering};
-
-use crate::utils::get_monotonic_time;
-
-pub static ANIMATION_SLOWDOWN: AtomicF64 = AtomicF64::new(1.);
-
-#[derive(Debug)]
-pub struct Animation {
-    from: f64,
-    to: f64,
-    duration: Duration,
-    start_time: Duration,
-    current_time: Duration,
-    curve: Curve,
-}
-
-#[derive(Debug, Clone, Copy)]
-pub enum Curve {
-    EaseOutCubic,
-    EaseOutExpo,
-}
-
-impl Animation {
-    pub fn new(
-        from: f64,
-        to: f64,
-        config: niri_config::Animation,
-        default: niri_config::Animation,
-    ) -> Self {
-        // FIXME: ideally we shouldn't use current time here because animations started within the
-        // same frame cycle should have the same start time to be synchronized.
-        let now = get_monotonic_time();
-
-        let duration_ms = if config.off {
-            0
-        } else {
-            config.duration_ms.unwrap_or(default.duration_ms.unwrap())
-        };
-        let duration = Duration::from_millis(u64::from(duration_ms))
-            .mul_f64(ANIMATION_SLOWDOWN.load(Ordering::Relaxed));
-
-        let curve = Curve::from(config.curve.unwrap_or(default.curve.unwrap()));
-
-        Self {
-            from,
-            to,
-            duration,
-            start_time: now,
-            current_time: now,
-            curve,
-        }
-    }
-
-    pub fn set_current_time(&mut self, time: Duration) {
-        self.current_time = time;
-    }
-
-    pub fn is_done(&self) -> bool {
-        self.current_time >= self.start_time + self.duration
-    }
-
-    pub fn value(&self) -> f64 {
-        let passed = (self.current_time - self.start_time).as_secs_f64();
-        let total = self.duration.as_secs_f64();
-        let x = (passed / total).clamp(0., 1.);
-        self.curve.y(x) * (self.to - self.from) + self.from
-    }
-
-    pub fn to(&self) -> f64 {
-        self.to
-    }
-
-    #[cfg(test)]
-    pub fn from(&self) -> f64 {
-        self.from
-    }
-}
-
-impl Curve {
-    pub fn y(self, x: f64) -> f64 {
-        match self {
-            Curve::EaseOutCubic => EaseOutCubic.y(x),
-            Curve::EaseOutExpo => 1. - 2f64.powf(-10. * x),
-        }
-    }
-}
-
-impl From<niri_config::AnimationCurve> for Curve {
-    fn from(value: niri_config::AnimationCurve) -> Self {
-        match value {
-            niri_config::AnimationCurve::EaseOutCubic => Curve::EaseOutCubic,
-            niri_config::AnimationCurve::EaseOutExpo => Curve::EaseOutExpo,
-        }
-    }
-}
@@ -0,0 +1,379 @@
+use std::time::Duration;
+
+use keyframe::functions::{EaseOutCubic, EaseOutQuad};
+use keyframe::EasingFunction;
+use portable_atomic::{AtomicF64, Ordering};
+
+use crate::utils::get_monotonic_time;
+
+mod spring;
+pub use spring::{Spring, SpringParams};
+
+pub static ANIMATION_SLOWDOWN: AtomicF64 = AtomicF64::new(1.);
+
+#[derive(Debug, Clone)]
+pub struct Animation {
+    from: f64,
+    to: f64,
+    initial_velocity: f64,
+    is_off: bool,
+    duration: Duration,
+    /// Time until the animation first reaches `to`.
+    ///
+    /// Best effort; not always exactly precise.
+    clamped_duration: Duration,
+    start_time: Duration,
+    current_time: Duration,
+    kind: Kind,
+}
+
+#[derive(Debug, Clone, Copy)]
+enum Kind {
+    Easing {
+        curve: Curve,
+    },
+    Spring(Spring),
+    Deceleration {
+        initial_velocity: f64,
+        deceleration_rate: f64,
+    },
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum Curve {
+    Linear,
+    EaseOutQuad,
+    EaseOutCubic,
+    EaseOutExpo,
+}
+
+impl Animation {
+    pub fn new(from: f64, to: f64, initial_velocity: f64, config: niri_config::Animation) -> Self {
+        // Scale the velocity by slowdown to keep the touchpad gestures feeling right.
+        let initial_velocity = initial_velocity * ANIMATION_SLOWDOWN.load(Ordering::Relaxed);
+
+        let mut rv = Self::ease(from, to, initial_velocity, 0, Curve::EaseOutCubic);
+        if config.off {
+            rv.is_off = true;
+            return rv;
+        }
+
+        rv.replace_config(config);
+        rv
+    }
+
+    pub fn replace_config(&mut self, config: niri_config::Animation) {
+        self.is_off = config.off;
+        if config.off {
+            self.duration = Duration::ZERO;
+            self.clamped_duration = Duration::ZERO;
+            return;
+        }
+
+        let start_time = self.start_time;
+        let current_time = self.current_time;
+
+        match config.kind {
+            niri_config::AnimationKind::Spring(p) => {
+                let params = SpringParams::new(p.damping_ratio, f64::from(p.stiffness), p.epsilon);
+
+                let spring = Spring {
+                    from: self.from,
+                    to: self.to,
+                    initial_velocity: self.initial_velocity,
+                    params,
+                };
+                *self = Self::spring(spring);
+            }
+            niri_config::AnimationKind::Easing(p) => {
+                *self = Self::ease(
+                    self.from,
+                    self.to,
+                    self.initial_velocity,
+                    u64::from(p.duration_ms),
+                    Curve::from(p.curve),
+                );
+            }
+        }
+
+        self.start_time = start_time;
+        self.current_time = current_time;
+    }
+
+    /// Restarts the animation using the previous config.
+    pub fn restarted(&self, from: f64, to: f64, initial_velocity: f64) -> Self {
+        if self.is_off {
+            return self.clone();
+        }
+
+        // Scale the velocity by slowdown to keep the touchpad gestures feeling right.
+        let initial_velocity = initial_velocity * ANIMATION_SLOWDOWN.load(Ordering::Relaxed);
+
+        match self.kind {
+            Kind::Easing { curve } => Self::ease(
+                from,
+                to,
+                initial_velocity,
+                self.duration.as_millis() as u64,
+                curve,
+            ),
+            Kind::Spring(spring) => {
+                let spring = Spring {
+                    from: self.from,
+                    to: self.to,
+                    initial_velocity: self.initial_velocity,
+                    params: spring.params,
+                };
+                Self::spring(spring)
+            }
+            Kind::Deceleration {
+                initial_velocity,
+                deceleration_rate,
+            } => {
+                let threshold = 0.001; // FIXME
+                Self::decelerate(from, initial_velocity, deceleration_rate, threshold)
+            }
+        }
+    }
+
+    pub fn ease(from: f64, to: f64, initial_velocity: f64, duration_ms: u64, curve: Curve) -> Self {
+        // FIXME: ideally we shouldn't use current time here because animations started within the
+        // same frame cycle should have the same start time to be synchronized.
+        let now = get_monotonic_time();
+
+        let duration = Duration::from_millis(duration_ms);
+        let kind = Kind::Easing { curve };
+
+        Self {
+            from,
+            to,
+            initial_velocity,
+            is_off: false,
+            duration,
+            // Our current curves never overshoot.
+            clamped_duration: duration,
+            start_time: now,
+            current_time: now,
+            kind,
+        }
+    }
+
+    pub fn spring(spring: Spring) -> Self {
+        let _span = tracy_client::span!("Animation::spring");
+
+        // FIXME: ideally we shouldn't use current time here because animations started within the
+        // same frame cycle should have the same start time to be synchronized.
+        let now = get_monotonic_time();
+
+        let duration = spring.duration();
+        let clamped_duration = spring.clamped_duration().unwrap_or(duration);
+        let kind = Kind::Spring(spring);
+
+        Self {
+            from: spring.from,
+            to: spring.to,
+            initial_velocity: spring.initial_velocity,
+            is_off: false,
+            duration,
+            clamped_duration,
+            start_time: now,
+            current_time: now,
+            kind,
+        }
+    }
+
+    pub fn decelerate(
+        from: f64,
+        initial_velocity: f64,
+        deceleration_rate: f64,
+        threshold: f64,
+    ) -> Self {
+        // FIXME: ideally we shouldn't use current time here because animations started within the
+        // same frame cycle should have the same start time to be synchronized.
+        let now = get_monotonic_time();
+
+        let duration_s = if initial_velocity == 0. {
+            0.
+        } else {
+            let coeff = 1000. * deceleration_rate.ln();
+            (-coeff * threshold / initial_velocity.abs()).ln() / coeff
+        };
+        let duration = Duration::from_secs_f64(duration_s);
+
+        let to = from - initial_velocity / (1000. * deceleration_rate.ln());
+
+        let kind = Kind::Deceleration {
+            initial_velocity,
+            deceleration_rate,
+        };
+
+        Self {
+            from,
+            to,
+            initial_velocity,
+            is_off: false,
+            duration,
+            clamped_duration: duration,
+            start_time: now,
+            current_time: now,
+            kind,
+        }
+    }
+
+    pub fn set_current_time(&mut self, time: Duration) {
+        if self.duration.is_zero() {
+            self.current_time = time;
+            return;
+        }
+
+        let end_time = self.start_time + self.duration;
+        if end_time <= self.current_time {
+            return;
+        }
+
+        let slowdown = ANIMATION_SLOWDOWN.load(Ordering::Relaxed);
+        if slowdown <= f64::EPSILON {
+            // Zero slowdown will cause the animation to end right away.
+            self.current_time = end_time;
+            return;
+        }
+
+        // We can't change current_time (since the incoming time values are always real-time), so
+        // apply the slowdown by shifting the start time to compensate.
+        if self.current_time <= time {
+            let delta = time - self.current_time;
+
+            let max_delta = end_time - self.current_time;
+            let min_slowdown = delta.as_secs_f64() / max_delta.as_secs_f64();
+            if slowdown <= min_slowdown {
+                // Our slowdown value will cause the animation to end right away.
+                self.current_time = end_time;
+                return;
+            }
+
+            let adjusted_delta = delta.div_f64(slowdown);
+            if adjusted_delta >= delta {
+                self.start_time -= adjusted_delta - delta;
+            } else {
+                self.start_time += delta - adjusted_delta;
+            }
+        } else {
+            let delta = self.current_time - time;
+
+            let min_slowdown = delta.as_secs_f64() / self.current_time.as_secs_f64();
+            if slowdown <= min_slowdown {
+                // Current time was about to jump to before the animation had started; let's just
+                // cancel the animation in this case.
+                self.current_time = end_time;
+                return;
+            }
+
+            let adjusted_delta = delta.div_f64(slowdown);
+            if adjusted_delta >= delta {
+                self.start_time += adjusted_delta - delta;
+            } else {
+                self.start_time -= delta - adjusted_delta;
+            }
+        }
+
+        self.current_time = time;
+    }
+
+    pub fn is_done(&self) -> bool {
+        self.current_time >= self.start_time + self.duration
+    }
+
+    pub fn is_clamped_done(&self) -> bool {
+        self.current_time >= self.start_time + self.clamped_duration
+    }
+
+    pub fn value(&self) -> f64 {
+        if self.is_done() {
+            return self.to;
+        }
+
+        let passed = self.current_time.saturating_sub(self.start_time);
+
+        match self.kind {
+            Kind::Easing { curve } => {
+                let passed = passed.as_secs_f64();
+                let total = self.duration.as_secs_f64();
+                let x = (passed / total).clamp(0., 1.);
+                curve.y(x) * (self.to - self.from) + self.from
+            }
+            Kind::Spring(spring) => {
+                let value = spring.value_at(passed);
+
+                // Protect against numerical instability.
+                let range = (self.to - self.from) * 10.;
+                let a = self.from - range;
+                let b = self.to + range;
+                if self.from <= self.to {
+                    value.clamp(a, b)
+                } else {
+                    value.clamp(b, a)
+                }
+            }
+            Kind::Deceleration {
+                initial_velocity,
+                deceleration_rate,
+            } => {
+                let passed = passed.as_secs_f64();
+                let coeff = 1000. * deceleration_rate.ln();
+                self.from + (deceleration_rate.powf(1000. * passed) - 1.) / coeff * initial_velocity
+            }
+        }
+    }
+
+    /// Returns a value that stops at the target value after first reaching it.
+    ///
+    /// Best effort; not always exactly precise.
+    pub fn clamped_value(&self) -> f64 {
+        if self.is_clamped_done() {
+            return self.to;
+        }
+
+        self.value()
+    }
+
+    pub fn to(&self) -> f64 {
+        self.to
+    }
+
+    #[cfg(test)]
+    pub fn from(&self) -> f64 {
+        self.from
+    }
+
+    pub fn offset(&mut self, offset: f64) {
+        self.from += offset;
+        self.to += offset;
+
+        if let Kind::Spring(spring) = &mut self.kind {
+            spring.from += offset;
+            spring.to += offset;
+        }
+    }
+}
+
+impl Curve {
+    pub fn y(self, x: f64) -> f64 {
+        match self {
+            Curve::Linear => x,
+            Curve::EaseOutQuad => EaseOutQuad.y(x),
+            Curve::EaseOutCubic => EaseOutCubic.y(x),
+            Curve::EaseOutExpo => 1. - 2f64.powf(-10. * x),
+        }
+    }
+}
+
+impl From<niri_config::AnimationCurve> for Curve {
+    fn from(value: niri_config::AnimationCurve) -> Self {
+        match value {
+            niri_config::AnimationCurve::Linear => Curve::Linear,
+            niri_config::AnimationCurve::EaseOutQuad => Curve::EaseOutQuad,
+            niri_config::AnimationCurve::EaseOutCubic => Curve::EaseOutCubic,
+            niri_config::AnimationCurve::EaseOutExpo => Curve::EaseOutExpo,
+        }
+    }
+}
@@ -0,0 +1,168 @@
+use std::time::Duration;
+
+#[derive(Debug, Clone, Copy)]
+pub struct SpringParams {
+    pub damping: f64,
+    pub mass: f64,
+    pub stiffness: f64,
+    pub epsilon: f64,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Spring {
+    pub from: f64,
+    pub to: f64,
+    pub initial_velocity: f64,
+    pub params: SpringParams,
+}
+
+impl SpringParams {
+    pub fn new(damping_ratio: f64, stiffness: f64, epsilon: f64) -> Self {
+        let damping_ratio = damping_ratio.max(0.);
+        let stiffness = stiffness.max(0.);
+        let epsilon = epsilon.max(0.);
+
+        let mass = 1.;
+        let critical_damping = 2. * (mass * stiffness).sqrt();
+        let damping = damping_ratio * critical_damping;
+
+        Self {
+            damping,
+            mass,
+            stiffness,
+            epsilon,
+        }
+    }
+}
+
+impl Spring {
+    pub fn value_at(&self, t: Duration) -> f64 {
+        self.oscillate(t.as_secs_f64())
+    }
+
+    // Based on libadwaita (LGPL-2.1-or-later):
+    // https://gitlab.gnome.org/GNOME/libadwaita/-/blob/1.4.4/src/adw-spring-animation.c,
+    // which itself is based on (MIT):
+    // https://github.com/robb/RBBAnimation/blob/master/RBBAnimation/RBBSpringAnimation.m
+    /// Computes and returns the duration until the spring is at rest.
+    pub fn duration(&self) -> Duration {
+        const DELTA: f64 = 0.001;
+
+        let beta = self.params.damping / (2. * self.params.mass);
+
+        if beta.abs() <= f64::EPSILON || beta < 0. {
+            return Duration::MAX;
+        }
+
+        let omega0 = (self.params.stiffness / self.params.mass).sqrt();
+
+        // As first ansatz for the overdamped solution,
+        // and general estimation for the oscillating ones
+        // we take the value of the envelope when it's < epsilon.
+        let mut x0 = -self.params.epsilon.ln() / beta;
+
+        // f64::EPSILON is too small for this specific comparison, so we use
+        // f32::EPSILON even though it's doubles.
+        if (beta - omega0).abs() <= f64::from(f32::EPSILON) || beta < omega0 {
+            return Duration::from_secs_f64(x0);
+        }
+
+        // Since the overdamped solution decays way slower than the envelope
+        // we need to use the value of the oscillation itself.
+        // Newton's root finding method is a good candidate in this particular case:
+        // https://en.wikipedia.org/wiki/Newton%27s_method
+        let mut y0 = self.oscillate(x0);
+        let m = (self.oscillate(x0 + DELTA) - y0) / DELTA;
+
+        let mut x1 = (self.to - y0 + m * x0) / m;
+        let mut y1 = self.oscillate(x1);
+
+        let mut i = 0;
+        while (self.to - y1).abs() > self.params.epsilon {
+            if i > 1000 {
+                return Duration::ZERO;
+            }
+
+            x0 = x1;
+            y0 = y1;
+
+            let m = (self.oscillate(x0 + DELTA) - y0) / DELTA;
+
+            x1 = (self.to - y0 + m * x0) / m;
+            y1 = self.oscillate(x1);
+            i += 1;
+        }
+
+        Duration::from_secs_f64(x1)
+    }
+
+    /// Computes and returns the duration until the spring reaches its target position.
+    pub fn clamped_duration(&self) -> Option<Duration> {
+        let beta = self.params.damping / (2. * self.params.mass);
+
+        if beta.abs() <= f64::EPSILON || beta < 0. {
+            return Some(Duration::MAX);
+        }
+
+        if (self.to - self.from).abs() <= f64::EPSILON {
+            return Some(Duration::ZERO);
+        }
+
+        // The first frame is not that important and we avoid finding the trivial 0 for in-place
+        // animations.
+        let mut i = 1u16;
+        let mut y = self.oscillate(f64::from(i) / 1000.);
+
+        while (self.to - self.from > f64::EPSILON && self.to - y > self.params.epsilon)
+            || (self.from - self.to > f64::EPSILON && y - self.to > self.params.epsilon)
+        {
+            if i > 3000 {
+                return None;
+            }
+
+            i += 1;
+            y = self.oscillate(f64::from(i) / 1000.);
+        }
+
+        Some(Duration::from_millis(u64::from(i)))
+    }
+
+    /// Returns the spring position at a given time in seconds.
+    fn oscillate(&self, t: f64) -> f64 {
+        let b = self.params.damping;
+        let m = self.params.mass;
+        let k = self.params.stiffness;
+        let v0 = self.initial_velocity;
+
+        let beta = b / (2. * m);
+        let omega0 = (k / m).sqrt();
+
+        let x0 = self.from - self.to;
+
+        let envelope = (-beta * t).exp();
+
+        // Solutions of the form C1*e^(lambda1*x) + C2*e^(lambda2*x)
+        // for the differential equation m*ẍ+b*ẋ+kx = 0
+
+        // f64::EPSILON is too small for this specific comparison, so we use
+        // f32::EPSILON even though it's doubles.
+        if (beta - omega0).abs() <= f64::from(f32::EPSILON) {
+            // Critically damped.
+            self.to + envelope * (x0 + (beta * x0 + v0) * t)
+        } else if beta < omega0 {
+            // Underdamped.
+            let omega1 = ((omega0 * omega0) - (beta * beta)).sqrt();
+
+            self.to
+                + envelope
+                    * (x0 * (omega1 * t).cos() + ((beta * x0 + v0) / omega1) * (omega1 * t).sin())
+        } else {
+            // Overdamped.
+            let omega2 = ((beta * beta) - (omega0 * omega0)).sqrt();
+
+            self.to
+                + envelope
+                    * (x0 * (omega2 * t).cosh() + ((beta * x0 + v0) / omega2) * (omega2 * t).sinh())
+        }
+    }
+}
@@ -1,6 +1,4 @@
-use std::cell::RefCell;
 use std::collections::HashMap;
-use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;

@@ -11,6 +9,7 @@ use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;

 use crate::input::CompositorMod;
 use crate::niri::Niri;
+use crate::utils::id::IdCounter;

 pub mod tty;
 pub use tty::Tty;
@@ -33,6 +32,23 @@ pub enum RenderResult {
    Skipped,
 }

+pub type IpcOutputMap = HashMap<OutputId, niri_ipc::Output>;
+
+static OUTPUT_ID_COUNTER: IdCounter = IdCounter::new();
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct OutputId(u64);
+
+impl OutputId {
+    fn next() -> OutputId {
+        OutputId(OUTPUT_ID_COUNTER.next())
+    }
+
+    pub fn get(self) -> u64 {
+        self.0
+    }
+}
+
 impl Backend {
    pub fn init(&mut self, niri: &mut Niri) {
        match self {
@@ -112,21 +128,13 @@ impl Backend {
        }
    }

-    pub fn ipc_outputs(&self) -> Rc<RefCell<HashMap<String, niri_ipc::Output>>> {
+    pub fn ipc_outputs(&self) -> Arc<Mutex<IpcOutputMap>> {
        match self {
            Backend::Tty(tty) => tty.ipc_outputs(),
            Backend::Winit(winit) => winit.ipc_outputs(),
        }
    }

-    #[cfg_attr(not(feature = "dbus"), allow(unused))]
-    pub fn enabled_outputs(&self) -> Arc<Mutex<HashMap<String, Output>>> {
-        match self {
-            Backend::Tty(tty) => tty.enabled_outputs(),
-            Backend::Winit(winit) => winit.enabled_outputs(),
-        }
-    }
-
    #[cfg(feature = "xdp-gnome-screencast")]
    pub fn gbm_device(
        &self,
@@ -145,6 +153,13 @@ impl Backend {
        }
    }

+    pub fn set_output_on_demand_vrr(&mut self, niri: &mut Niri, output: &Output, enable_vrr: bool) {
+        match self {
+            Backend::Tty(tty) => tty.set_output_on_demand_vrr(niri, output, enable_vrr),
+            Backend::Winit(_) => (),
+        }
+    }
+
    pub fn on_output_config_changed(&mut self, niri: &mut Niri) {
        match self {
            Backend::Tty(tty) => tty.on_output_config_changed(niri),
@@ -152,6 +167,21 @@ impl Backend {
        }
    }

+    pub fn on_debug_config_changed(&mut self) {
+        match self {
+            Backend::Tty(tty) => tty.on_debug_config_changed(),
+            Backend::Winit(_) => (),
+        }
+    }
+
+    pub fn tty_checked(&mut self) -> Option<&mut Tty> {
+        if let Self::Tty(v) = self {
+            Some(v)
+        } else {
+            None
+        }
+    }
+
    pub fn tty(&mut self) -> &mut Tty {
        if let Self::Tty(v) = self {
            v
@@ -5,7 +5,7 @@ use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;

-use niri_config::Config;
+use niri_config::{Config, OutputName};
 use smithay::backend::allocator::dmabuf::Dmabuf;
 use smithay::backend::renderer::damage::OutputDamageTracker;
 use smithay::backend::renderer::gles::GlesRenderer;
@@ -15,19 +15,20 @@ use smithay::output::{Mode, Output, PhysicalProperties, Subpixel};
 use smithay::reexports::calloop::LoopHandle;
 use smithay::reexports::wayland_protocols::wp::presentation_time::server::wp_presentation_feedback;
 use smithay::reexports::winit::dpi::LogicalSize;
-use smithay::reexports::winit::window::WindowBuilder;
+use smithay::reexports::winit::window::Window;

-use super::RenderResult;
+use super::{IpcOutputMap, OutputId, RenderResult};
 use crate::niri::{Niri, RedrawState, State};
-use crate::utils::get_monotonic_time;
+use crate::render_helpers::debug::draw_damage;
+use crate::render_helpers::{resources, shaders, RenderTarget};
+use crate::utils::{get_monotonic_time, logical_output};

 pub struct Winit {
    config: Rc<RefCell<Config>>,
    output: Output,
    backend: WinitGraphicsBackend<GlesRenderer>,
    damage_tracker: OutputDamageTracker,
-    ipc_outputs: Rc<RefCell<HashMap<String, niri_ipc::Output>>>,
-    enabled_outputs: Arc<Mutex<HashMap<String, Output>>>,
+    ipc_outputs: Arc<Mutex<IpcOutputMap>>,
 }

 impl Winit {
@@ -35,11 +36,11 @@ impl Winit {
        config: Rc<RefCell<Config>>,
        event_loop: LoopHandle<State>,
    ) -> Result<Self, winit::Error> {
-        let builder = WindowBuilder::new()
+        let builder = Window::default_attributes()
            .with_inner_size(LogicalSize::new(1280.0, 800.0))
            // .with_resizable(false)
            .with_title("niri");
-        let (backend, winit) = winit::init_from_builder(builder)?;
+        let (backend, winit) = winit::init_from_attributes(builder)?;

        let output = Output::new(
            "winit".to_string(),
@@ -58,28 +59,35 @@ impl Winit {
        output.change_current_state(Some(mode), None, None, None);
        output.set_preferred(mode);

+        output.user_data().insert_if_missing(|| OutputName {
+            connector: "winit".to_string(),
+            make: Some("Smithay".to_string()),
+            model: Some("Winit".to_string()),
+            serial: None,
+        });
+
        let physical_properties = output.physical_properties();
-        let ipc_outputs = Rc::new(RefCell::new(HashMap::from([(
-            "winit".to_owned(),
+        let ipc_outputs = Arc::new(Mutex::new(HashMap::from([(
+            OutputId::next(),
            niri_ipc::Output {
                name: output.name(),
                make: physical_properties.make,
                model: physical_properties.model,
+                serial: None,
                physical_size: None,
                modes: vec![niri_ipc::Mode {
                    width: backend.window_size().w.clamp(0, u16::MAX as i32) as u16,
                    height: backend.window_size().h.clamp(0, u16::MAX as i32) as u16,
                    refresh_rate: 60_000,
+                    is_preferred: true,
                }],
                current_mode: Some(0),
+                vrr_supported: false,
+                vrr_enabled: false,
+                logical: Some(logical_output(&output)),
            },
        )])));

-        let enabled_outputs = Arc::new(Mutex::new(HashMap::from([(
-            "winit".to_owned(),
-            output.clone(),
-        )])));
-
        let damage_tracker = OutputDamageTracker::from_output(&output);

        event_loop
@@ -96,18 +104,24 @@ impl Winit {
                        None,
                    );

-                    let mut ipc_outputs = winit.ipc_outputs.borrow_mut();
-                    let mode = &mut ipc_outputs.get_mut("winit").unwrap().modes[0];
-                    mode.width = size.w.clamp(0, u16::MAX as i32) as u16;
-                    mode.height = size.h.clamp(0, u16::MAX as i32) as u16;
+                    {
+                        let mut ipc_outputs = winit.ipc_outputs.lock().unwrap();
+                        let output = ipc_outputs.values_mut().next().unwrap();
+                        let mode = &mut output.modes[0];
+                        mode.width = size.w.clamp(0, u16::MAX as i32) as u16;
+                        mode.height = size.h.clamp(0, u16::MAX as i32) as u16;
+                        if let Some(logical) = output.logical.as_mut() {
+                            logical.width = size.w as u32;
+                            logical.height = size.h as u32;
+                        }
+                        state.niri.ipc_outputs_changed = true;
+                    }

-                    state.niri.output_resized(winit.output.clone());
+                    state.niri.output_resized(&winit.output);
                }
                WinitEvent::Input(event) => state.process_input_event(event),
                WinitEvent::Focus(_) => (),
-                WinitEvent::Redraw => state
-                    .niri
-                    .queue_redraw(state.backend.winit().output.clone()),
+                WinitEvent::Redraw => state.niri.queue_redraw(&state.backend.winit().output),
                WinitEvent::CloseRequested => state.niri.stop_signal.stop(),
            })
            .unwrap();
@@ -118,20 +132,33 @@ impl Winit {
            backend,
            damage_tracker,
            ipc_outputs,
-            enabled_outputs,
        })
    }

    pub fn init(&mut self, niri: &mut Niri) {
-        if let Err(err) = self
-            .backend
-            .renderer()
-            .bind_wl_display(&niri.display_handle)
-        {
+        let renderer = self.backend.renderer();
+        if let Err(err) = renderer.bind_wl_display(&niri.display_handle) {
            warn!("error binding renderer wl_display: {err}");
        }

-        niri.add_output(self.output.clone(), None);
+        resources::init(renderer);
+        shaders::init(renderer);
+
+        let config = self.config.borrow();
+        if let Some(src) = config.animations.window_resize.custom_shader.as_deref() {
+            shaders::set_custom_resize_program(renderer, Some(src));
+        }
+        if let Some(src) = config.animations.window_close.custom_shader.as_deref() {
+            shaders::set_custom_close_program(renderer, Some(src));
+        }
+        if let Some(src) = config.animations.window_open.custom_shader.as_deref() {
+            shaders::set_custom_open_program(renderer, Some(src));
+        }
+        drop(config);
+
+        niri.layout.update_shaders();
+
+        niri.add_output(self.output.clone(), None, false);
    }

    pub fn seat_name(&self) -> String {
@@ -149,7 +176,18 @@ impl Winit {
        let _span = tracy_client::span!("Winit::render");

        // Render the elements.
-        let elements = niri.render::<GlesRenderer>(self.backend.renderer(), output, true);
+        let mut elements = niri.render::<GlesRenderer>(
+            self.backend.renderer(),
+            output,
+            true,
+            RenderTarget::Output,
+        );
+
+        // Visualize the damage, if enabled.
+        if niri.debug_draw_damage {
+            let output_state = niri.output_state.get_mut(output).unwrap();
+            draw_damage(&mut output_state.debug_damage_tracker, &mut elements);
+        }

        // Hand them over to winit.
        self.backend.bind().unwrap();
@@ -170,10 +208,12 @@ impl Winit {
                .wait_for_frame_completion_before_queueing
            {
                let _span = tracy_client::span!("wait for completion");
-                res.sync.wait();
+                if let Err(err) = res.sync.wait() {
+                    warn!("error waiting for frame completion: {err:?}");
+                }
            }

-            self.backend.submit(Some(&damage)).unwrap();
+            self.backend.submit(Some(damage)).unwrap();

            let mut presentation_feedbacks = niri.take_presentation_feedbacks(output, &res.states);
            let mode = output.current_mode().unwrap();
@@ -193,12 +233,16 @@ impl Winit {
        let output_state = niri.output_state.get_mut(output).unwrap();
        match mem::replace(&mut output_state.redraw_state, RedrawState::Idle) {
            RedrawState::Idle => unreachable!(),
-            RedrawState::Queued(_) => (),
+            RedrawState::Queued => (),
            RedrawState::WaitingForVBlank { .. } => unreachable!(),
            RedrawState::WaitingForEstimatedVBlank(_) => unreachable!(),
            RedrawState::WaitingForEstimatedVBlankAndQueued(_) => unreachable!(),
        }

+        output_state.frame_callback_sequence = output_state.frame_callback_sequence.wrapping_add(1);
+
+        // FIXME: this should wait until a frame callback from the host compositor, but it redraws
+        // right away instead.
        if output_state.unfinished_animations_remain {
            self.backend.window().request_redraw();
        }
@@ -221,11 +265,7 @@ impl Winit {
        }
    }

-    pub fn ipc_outputs(&self) -> Rc<RefCell<HashMap<String, niri_ipc::Output>>> {
+    pub fn ipc_outputs(&self) -> Arc<Mutex<IpcOutputMap>> {
        self.ipc_outputs.clone()
    }
-
-    pub fn enabled_outputs(&self) -> Arc<Mutex<HashMap<String, Output>>> {
-        self.enabled_outputs.clone()
-    }
 }
@@ -2,7 +2,7 @@ use std::ffi::OsString;
 use std::path::PathBuf;

 use clap::{Parser, Subcommand};
-use niri_ipc::Action;
+use niri_ipc::{Action, OutputAction};

 use crate::utils::version;

@@ -13,8 +13,18 @@ use crate::utils::version;
 #[command(subcommand_help_heading = "Subcommands")]
 pub struct Cli {
    /// Path to config file (default: `$XDG_CONFIG_HOME/niri/config.kdl`).
+    ///
+    /// This can also be set with the `NIRI_CONFIG` environment variable. If both are set, the
+    /// command line argument takes precedence.
    #[arg(short, long)]
    pub config: Option<PathBuf>,
+    /// Import environment globally to systemd and D-Bus, run D-Bus services.
+    ///
+    /// Set this flag in a systemd service started by your display manager, or when running
+    /// manually as your main compositor instance. Do not set when running as a nested window, or
+    /// on a TTY as your non-main compositor instance, to avoid messing up the global environment.
+    #[arg(long)]
+    pub session: bool,
    /// Command to run upon compositor startup.
    #[arg(last = true)]
    pub command: Vec<OsString>,
@@ -25,12 +35,6 @@ pub struct Cli {

 #[derive(Subcommand)]
 pub enum Sub {
-    /// Validate the config file.
-    Validate {
-        /// Path to config file (default: `$XDG_CONFIG_HOME/niri/config.kdl`).
-        #[arg(short, long)]
-        config: Option<PathBuf>,
-    },
    /// Communicate with the running niri instance.
    Msg {
        #[command(subcommand)]
@@ -39,6 +43,15 @@ pub enum Sub {
        #[arg(short, long)]
        json: bool,
    },
+    /// Validate the config file.
+    Validate {
+        /// Path to config file (default: `$XDG_CONFIG_HOME/niri/config.kdl`).
+        ///
+        /// This can also be set with the `NIRI_CONFIG` environment variable. If both are set, the
+        /// command line argument takes precedence.
+        #[arg(short, long)]
+        config: Option<PathBuf>,
+    },
    /// Cause a panic to check if the backtraces are good.
    Panic,
 }
@@ -47,9 +60,40 @@ pub enum Sub {
 pub enum Msg {
    /// List connected outputs.
    Outputs,
+    /// List workspaces.
+    Workspaces,
+    /// List open windows.
+    Windows,
+    /// Get the configured keyboard layouts.
+    KeyboardLayouts,
+    /// Print information about the focused output.
+    FocusedOutput,
+    /// Print information about the focused window.
+    FocusedWindow,
    /// Perform an action.
    Action {
        #[command(subcommand)]
        action: Action,
    },
+    /// Change output configuration temporarily.
+    ///
+    /// The configuration is changed temporarily and not saved into the config file. If the output
+    /// configuration subsequently changes in the config file, these temporary changes will be
+    /// forgotten.
+    Output {
+        /// Output name.
+        ///
+        /// Run `niri msg outputs` to see the output names.
+        #[arg()]
+        output: String,
+        /// Configuration to apply.
+        #[command(subcommand)]
+        action: OutputAction,
+    },
+    /// Start continuously receiving events from the compositor.
+    EventStream,
+    /// Print the version of the running niri instance.
+    Version,
+    /// Request an error from the running niri instance.
+    RequestError,
 }
@@ -142,7 +142,7 @@ impl CursorManager {
            .unwrap()
    }

-    /// Currenly used cursor_image as a cursor provider.
+    /// Currently used cursor_image as a cursor provider.
    pub fn cursor_image(&self) -> &CursorImageStatus {
        &self.current_cursor
    }
@@ -0,0 +1,81 @@
+use std::collections::HashMap;
+
+use zbus::fdo::{self, RequestNameFlags};
+use zbus::zvariant::{SerializeDict, Type, Value};
+use zbus::{dbus_interface, SignalContext};
+
+use super::Start;
+
+pub struct Introspect {
+    to_niri: calloop::channel::Sender<IntrospectToNiri>,
+    from_niri: async_channel::Receiver<NiriToIntrospect>,
+}
+
+pub enum IntrospectToNiri {
+    GetWindows,
+}
+
+pub enum NiriToIntrospect {
+    Windows(HashMap<u64, WindowProperties>),
+}
+
+#[derive(Debug, SerializeDict, Type, Value)]
+#[zvariant(signature = "dict")]
+pub struct WindowProperties {
+    /// Window title.
+    pub title: String,
+    /// Window app ID.
+    ///
+    /// This is actually the name of the .desktop file, and Shell does internal tracking to match
+    /// Wayland app IDs to desktop files. We don't do that yet, which is the reason why
+    /// xdg-desktop-portal-gnome's window list is missing icons.
+    #[zvariant(rename = "app-id")]
+    pub app_id: String,
+}
+
+#[dbus_interface(name = "org.gnome.Shell.Introspect")]
+impl Introspect {
+    async fn get_windows(&self) -> fdo::Result<HashMap<u64, WindowProperties>> {
+        if let Err(err) = self.to_niri.send(IntrospectToNiri::GetWindows) {
+            warn!("error sending message to niri: {err:?}");
+            return Err(fdo::Error::Failed("internal error".to_owned()));
+        }
+
+        match self.from_niri.recv().await {
+            Ok(NiriToIntrospect::Windows(windows)) => Ok(windows),
+            Err(err) => {
+                warn!("error receiving message from niri: {err:?}");
+                Err(fdo::Error::Failed("internal error".to_owned()))
+            }
+        }
+    }
+
+    // FIXME: call this upon window changes, once more of the infrastructure is there (will be
+    // needed for the event stream IPC anyway).
+    #[dbus_interface(signal)]
+    pub async fn windows_changed(ctxt: &SignalContext<'_>) -> zbus::Result<()>;
+}
+
+impl Introspect {
+    pub fn new(
+        to_niri: calloop::channel::Sender<IntrospectToNiri>,
+        from_niri: async_channel::Receiver<NiriToIntrospect>,
+    ) -> Self {
+        Self { to_niri, from_niri }
+    }
+}
+
+impl Start for Introspect {
+    fn start(self) -> anyhow::Result<zbus::blocking::Connection> {
+        let conn = zbus::blocking::Connection::session()?;
+        let flags = RequestNameFlags::AllowReplacement
+            | RequestNameFlags::ReplaceExisting
+            | RequestNameFlags::DoNotQueue;
+
+        conn.object_server()
+            .at("/org/gnome/Shell/Introspect", self)?;
+        conn.request_name_with_flags("org.gnome.Shell.Introspect", flags)?;
+
+        Ok(conn)
+    }
+}
@@ -1,6 +1,5 @@
 use std::path::PathBuf;

-use smithay::reexports::calloop;
 use zbus::dbus_interface;
 use zbus::fdo::{self, RequestNameFlags};

@@ -1,10 +1,10 @@
-use smithay::reexports::calloop;
 use zbus::blocking::Connection;
 use zbus::Interface;

 use crate::niri::State;

 pub mod freedesktop_screensaver;
+pub mod gnome_shell_introspect;
 pub mod gnome_shell_screenshot;
 pub mod mutter_display_config;
 pub mod mutter_service_channel;
@@ -15,6 +15,7 @@ pub mod mutter_screen_cast;
 use mutter_screen_cast::ScreenCast;

 use self::freedesktop_screensaver::ScreenSaver;
+use self::gnome_shell_introspect::Introspect;
 use self::mutter_display_config::DisplayConfig;
 use self::mutter_service_channel::ServiceChannel;

@@ -28,6 +29,7 @@ pub struct DBusServers {
    pub conn_display_config: Option<Connection>,
    pub conn_screen_saver: Option<Connection>,
    pub conn_screen_shot: Option<Connection>,
+    pub conn_introspect: Option<Connection>,
    #[cfg(feature = "xdp-gnome-screencast")]
    pub conn_screen_cast: Option<Connection>,
 }
@@ -48,7 +50,7 @@ impl DBusServers {
        }

        if is_session_instance || config.debug.dbus_interfaces_in_non_session_instances {
-            let display_config = DisplayConfig::new(backend.enabled_outputs());
+            let display_config = DisplayConfig::new(backend.ipc_outputs());
            dbus.conn_display_config = try_start(display_config);

            let screen_saver = ScreenSaver::new(niri.is_fdo_idle_inhibited.clone());
@@ -67,22 +69,34 @@ impl DBusServers {
            let screenshot = gnome_shell_screenshot::Screenshot::new(to_niri, from_niri);
            dbus.conn_screen_shot = try_start(screenshot);

+            let (to_niri, from_introspect) = calloop::channel::channel();
+            let (to_introspect, from_niri) = async_channel::unbounded();
+            niri.event_loop
+                .insert_source(from_introspect, move |event, _, state| match event {
+                    calloop::channel::Event::Msg(msg) => {
+                        state.on_introspect_msg(&to_introspect, msg)
+                    }
+                    calloop::channel::Event::Closed => (),
+                })
+                .unwrap();
+            let introspect = Introspect::new(to_niri, from_niri);
+            dbus.conn_introspect = try_start(introspect);
+
            #[cfg(feature = "xdp-gnome-screencast")]
-            {
+            if niri.pipewire.is_some() {
                let (to_niri, from_screen_cast) = calloop::channel::channel();
                niri.event_loop
                    .insert_source(from_screen_cast, {
-                        let to_niri = to_niri.clone();
                        move |event, _, state| match event {
-                            calloop::channel::Event::Msg(msg) => {
-                                state.on_screen_cast_msg(&to_niri, msg)
-                            }
+                            calloop::channel::Event::Msg(msg) => state.on_screen_cast_msg(msg),
                            calloop::channel::Event::Closed => (),
                        }
                    })
                    .unwrap();
-                let screen_cast = ScreenCast::new(backend.enabled_outputs(), to_niri);
+                let screen_cast = ScreenCast::new(backend.ipc_outputs(), to_niri);
                dbus.conn_screen_cast = try_start(screen_cast);
+            } else {
+                warn!("disabling screencast support because we couldn't start PipeWire");
            }
        }

@@ -2,15 +2,15 @@ use std::collections::HashMap;
 use std::sync::{Arc, Mutex};

 use serde::Serialize;
-use smithay::output::Output;
 use zbus::fdo::RequestNameFlags;
 use zbus::zvariant::{self, OwnedValue, Type};
 use zbus::{dbus_interface, fdo, SignalContext};

 use super::Start;
+use crate::backend::IpcOutputMap;

 pub struct DisplayConfig {
-    enabled_outputs: Arc<Mutex<HashMap<String, Output>>>,
+    ipc_outputs: Arc<Mutex<IpcOutputMap>>,
 }

 #[derive(Serialize, Type)]
@@ -53,63 +53,106 @@ impl DisplayConfig {
        HashMap<String, OwnedValue>,
    )> {
        // Construct the DBus response.
-        let mut monitors: Vec<Monitor> = self
-            .enabled_outputs
+        let mut monitors: Vec<(Monitor, LogicalMonitor)> = self
+            .ipc_outputs
            .lock()
            .unwrap()
-            .keys()
-            .map(|c| {
+            .values()
+            // Take only enabled outputs.
+            .filter(|output| output.current_mode.is_some() && output.logical.is_some())
+            .map(|output| {
                // Loosely matches the check in Mutter.
+                let c = &output.name;
                let is_laptop_panel = matches!(c.get(..4), Some("eDP-" | "LVDS" | "DSI-"));
-
-                // FIXME: use proper serial when we have libdisplay-info.
-                // A serial is required for correct session restore by xdp-gnome.
-                let serial = c.clone();
+                let display_name = make_display_name(output, is_laptop_panel);

                let mut properties = HashMap::new();
-                if is_laptop_panel {
-                    properties.insert(
-                        String::from("display-name"),
-                        OwnedValue::from(zvariant::Str::from_static("Built-in display")),
-                    );
-                }
+                properties.insert(
+                    String::from("display-name"),
+                    OwnedValue::from(zvariant::Str::from(display_name)),
+                );
                properties.insert(
                    String::from("is-builtin"),
                    OwnedValue::from(is_laptop_panel),
                );

-                Monitor {
-                    names: (c.clone(), String::new(), String::new(), serial),
-                    modes: vec![],
+                let mut modes: Vec<Mode> = output
+                    .modes
+                    .iter()
+                    .map(|m| {
+                        let niri_ipc::Mode {
+                            width,
+                            height,
+                            refresh_rate,
+                            is_preferred,
+                        } = *m;
+                        let refresh = refresh_rate as f64 / 1000.;
+
+                        Mode {
+                            id: format!("{width}x{height}@{refresh:.3}"),
+                            width: i32::from(width),
+                            height: i32::from(height),
+                            refresh_rate: refresh,
+                            preferred_scale: 1.,
+                            supported_scales: vec![1., 2., 3.],
+                            properties: HashMap::from([(
+                                String::from("is-preferred"),
+                                OwnedValue::from(is_preferred),
+                            )]),
+                        }
+                    })
+                    .collect();
+                modes[output.current_mode.unwrap()]
+                    .properties
+                    .insert(String::from("is-current"), OwnedValue::from(true));
+
+                let connector = c.clone();
+                let model = output.model.clone();
+                let make = output.make.clone();
+
+                // Serial is used for session restore, so fall back to the connector name if it's
+                // not available.
+                let serial = output.serial.as_ref().unwrap_or(&connector).clone();
+
+                let monitor = Monitor {
+                    names: (connector, make, model, serial),
+                    modes,
                    properties,
-                }
+                };
+
+                let logical = output.logical.as_ref().unwrap();
+
+                let transform = match logical.transform {
+                    niri_ipc::Transform::Normal => 0,
+                    niri_ipc::Transform::_90 => 1,
+                    niri_ipc::Transform::_180 => 2,
+                    niri_ipc::Transform::_270 => 3,
+                    niri_ipc::Transform::Flipped => 4,
+                    niri_ipc::Transform::Flipped90 => 5,
+                    niri_ipc::Transform::Flipped180 => 6,
+                    niri_ipc::Transform::Flipped270 => 7,
+                };
+
+                let logical_monitor = LogicalMonitor {
+                    x: logical.x,
+                    y: logical.y,
+                    scale: logical.scale,
+                    transform,
+                    is_primary: false,
+                    monitors: vec![monitor.names.clone()],
+                    properties: HashMap::new(),
+                };
+
+                (monitor, logical_monitor)
            })
            .collect();

-        // Sort the built-in monitor first, then by connector name.
-        monitors.sort_unstable_by(|a, b| {
-            let a_is_builtin = a.properties.contains_key("display-name");
-            let b_is_builtin = b.properties.contains_key("display-name");
-            a_is_builtin
-                .cmp(&b_is_builtin)
-                .reverse()
-                .then_with(|| a.names.0.cmp(&b.names.0))
-        });
+        // Sort by connector.
+        monitors.sort_unstable_by(|a, b| a.0.names.0.cmp(&b.0.names.0));

-        let logical_monitors = monitors
-            .iter()
-            .map(|m| LogicalMonitor {
-                x: 0,
-                y: 0,
-                scale: 1.,
-                transform: 0,
-                is_primary: false,
-                monitors: vec![m.names.clone()],
-                properties: HashMap::new(),
-            })
-            .collect();
-
-        Ok((0, monitors, logical_monitors, HashMap::new()))
+        let (monitors, logical_monitors) = monitors.into_iter().unzip();
+        let properties = HashMap::from([(String::from("layout-mode"), OwnedValue::from(1u32))]);
+        Ok((0, monitors, logical_monitors, properties))
    }

    #[dbus_interface(signal)]
@@ -117,8 +160,8 @@ impl DisplayConfig {
 }

 impl DisplayConfig {
-    pub fn new(enabled_outputs: Arc<Mutex<HashMap<String, Output>>>) -> Self {
-        Self { enabled_outputs }
+    pub fn new(ipc_outputs: Arc<Mutex<IpcOutputMap>>) -> Self {
+        Self { ipc_outputs }
    }
 }

@@ -136,3 +179,48 @@ impl Start for DisplayConfig {
        Ok(conn)
    }
 }
+
+// Adapted from Mutter.
+fn make_display_name(output: &niri_ipc::Output, is_laptop_panel: bool) -> String {
+    if is_laptop_panel {
+        return String::from("Built-in display");
+    }
+
+    let make = &output.make;
+    let model = &output.model;
+    if let Some(diagonal) = output.physical_size.map(|(width_mm, height_mm)| {
+        let diagonal = f64::hypot(f64::from(width_mm), f64::from(height_mm)) / 25.4;
+        format_diagonal(diagonal)
+    }) {
+        format!("{make} {diagonal}")
+    } else if model != "Unknown" {
+        format!("{make} {model}")
+    } else {
+        make.clone()
+    }
+}
+
+fn format_diagonal(diagonal_inches: f64) -> String {
+    let known = [12.1, 13.3, 15.6];
+    if let Some(d) = known.iter().find(|d| (*d - diagonal_inches).abs() < 0.1) {
+        format!("{d:.1}″")
+    } else {
+        format!("{}″", diagonal_inches.round() as u32)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use k9::snapshot;
+
+    use super::*;
+
+    #[test]
+    fn test_format_diagonal() {
+        snapshot!(format_diagonal(12.11), "12.1″");
+        snapshot!(format_diagonal(13.28), "13.3″");
+        snapshot!(format_diagonal(15.6), "15.6″");
+        snapshot!(format_diagonal(23.2), "23″");
+        snapshot!(format_diagonal(24.8), "25″");
+    }
+}
@@ -4,18 +4,16 @@ use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::{Arc, Mutex};

 use serde::Deserialize;
-use smithay::output::Output;
-use smithay::reexports::calloop;
 use zbus::fdo::RequestNameFlags;
 use zbus::zvariant::{DeserializeDict, OwnedObjectPath, SerializeDict, Type, Value};
 use zbus::{dbus_interface, fdo, InterfaceRef, ObjectServer, SignalContext};

 use super::Start;
-use crate::utils::output_size;
+use crate::backend::IpcOutputMap;

 #[derive(Clone)]
 pub struct ScreenCast {
-    enabled_outputs: Arc<Mutex<HashMap<String, Output>>>,
+    ipc_outputs: Arc<Mutex<IpcOutputMap>>,
    to_niri: calloop::channel::Sender<ScreenCastToNiri>,
    #[allow(clippy::type_complexity)]
    sessions: Arc<Mutex<Vec<(Session, InterfaceRef<Session>)>>>,
@@ -24,10 +22,11 @@ pub struct ScreenCast {
 #[derive(Clone)]
 pub struct Session {
    id: usize,
-    enabled_outputs: Arc<Mutex<HashMap<String, Output>>>,
+    ipc_outputs: Arc<Mutex<IpcOutputMap>>,
    to_niri: calloop::channel::Sender<ScreenCastToNiri>,
    #[allow(clippy::type_complexity)]
    streams: Arc<Mutex<Vec<(Stream, InterfaceRef<Stream>)>>>,
+    stopped: Arc<AtomicBool>,
 }

 #[derive(Debug, Default, Deserialize, Type, Clone, Copy)]
@@ -47,17 +46,45 @@ struct RecordMonitorProperties {
    _is_recording: Option<bool>,
 }

+#[derive(Debug, DeserializeDict, Type)]
+#[zvariant(signature = "dict")]
+struct RecordWindowProperties {
+    #[zvariant(rename = "window-id")]
+    window_id: u64,
+    #[zvariant(rename = "cursor-mode")]
+    cursor_mode: Option<CursorMode>,
+    #[zvariant(rename = "is-recording")]
+    _is_recording: Option<bool>,
+}
+
+static STREAM_ID: AtomicUsize = AtomicUsize::new(0);
+
 #[derive(Clone)]
 pub struct Stream {
-    output: Output,
+    target: StreamTarget,
    cursor_mode: CursorMode,
    was_started: Arc<AtomicBool>,
    to_niri: calloop::channel::Sender<ScreenCastToNiri>,
 }

+#[derive(Clone)]
+enum StreamTarget {
+    // FIXME: update on scale changes and whatnot.
+    Output(niri_ipc::Output),
+    Window { id: u64 },
+}
+
+#[derive(Debug, Clone)]
+pub enum StreamTargetId {
+    Output { name: String },
+    Window { id: u64 },
+}
+
 #[derive(Debug, SerializeDict, Type, Value)]
 #[zvariant(signature = "dict")]
 struct StreamParameters {
+    /// Position of the stream in logical coordinates.
+    position: (i32, i32),
    /// Size of the stream in logical coordinates.
    size: (i32, i32),
 }
@@ -65,14 +92,13 @@ struct StreamParameters {
 pub enum ScreenCastToNiri {
    StartCast {
        session_id: usize,
-        output: Output,
+        target: StreamTargetId,
        cursor_mode: CursorMode,
        signal_ctx: SignalContext<'static>,
    },
    StopCast {
        session_id: usize,
    },
-    Redraw(Output),
 }

 #[dbus_interface(name = "org.gnome.Mutter.ScreenCast")]
@@ -93,11 +119,7 @@ impl ScreenCast {
        let path = format!("/org/gnome/Mutter/ScreenCast/Session/u{}", session_id);
        let path = OwnedObjectPath::try_from(path).unwrap();

-        let session = Session::new(
-            session_id,
-            self.enabled_outputs.clone(),
-            self.to_niri.clone(),
-        );
+        let session = Session::new(session_id, self.ipc_outputs.clone(), self.to_niri.clone());
        match server.at(&path, session.clone()).await {
            Ok(true) => {
                let iface = server.interface(&path).await.unwrap();
@@ -137,6 +159,11 @@ impl Session {
    ) {
        debug!("stop");

+        if self.stopped.swap(true, Ordering::SeqCst) {
+            // Already stopped.
+            return;
+        }
+
        Session::closed(&ctxt).await.unwrap();

        if let Err(err) = self.to_niri.send(ScreenCastToNiri::StopCast {
@@ -164,20 +191,63 @@ impl Session {
    ) -> fdo::Result<OwnedObjectPath> {
        debug!(connector, ?properties, "record_monitor");

-        let Some(output) = self.enabled_outputs.lock().unwrap().get(connector).cloned() else {
+        let output = {
+            let ipc_outputs = self.ipc_outputs.lock().unwrap();
+            ipc_outputs.values().find(|o| o.name == connector).cloned()
+        };
+        let Some(output) = output else {
            return Err(fdo::Error::Failed("no such monitor".to_owned()));
        };

-        static NUMBER: AtomicUsize = AtomicUsize::new(0);
+        if output.logical.is_none() {
+            return Err(fdo::Error::Failed("monitor is disabled".to_owned()));
+        }
+
        let path = format!(
            "/org/gnome/Mutter/ScreenCast/Stream/u{}",
-            NUMBER.fetch_add(1, Ordering::SeqCst)
+            STREAM_ID.fetch_add(1, Ordering::SeqCst)
        );
        let path = OwnedObjectPath::try_from(path).unwrap();

        let cursor_mode = properties.cursor_mode.unwrap_or_default();

-        let stream = Stream::new(output, cursor_mode, self.to_niri.clone());
+        let target = StreamTarget::Output(output);
+        let stream = Stream::new(target, cursor_mode, self.to_niri.clone());
+        match server.at(&path, stream.clone()).await {
+            Ok(true) => {
+                let iface = server.interface(&path).await.unwrap();
+                self.streams.lock().unwrap().push((stream, iface));
+            }
+            Ok(false) => return Err(fdo::Error::Failed("stream path already exists".to_owned())),
+            Err(err) => {
+                return Err(fdo::Error::Failed(format!(
+                    "error creating stream object: {err:?}"
+                )))
+            }
+        }
+
+        Ok(path)
+    }
+
+    async fn record_window(
+        &mut self,
+        #[zbus(object_server)] server: &ObjectServer,
+        properties: RecordWindowProperties,
+    ) -> fdo::Result<OwnedObjectPath> {
+        debug!(?properties, "record_window");
+
+        let path = format!(
+            "/org/gnome/Mutter/ScreenCast/Stream/u{}",
+            STREAM_ID.fetch_add(1, Ordering::SeqCst)
+        );
+        let path = OwnedObjectPath::try_from(path).unwrap();
+
+        let cursor_mode = properties.cursor_mode.unwrap_or_default();
+
+        let target = StreamTarget::Window {
+            id: properties.window_id,
+        };
+        let stream = Stream::new(target, cursor_mode, self.to_niri.clone());
        match server.at(&path, stream.clone()).await {
            Ok(true) => {
                let iface = server.interface(&path).await.unwrap();
@@ -206,18 +276,32 @@ impl Stream {

    #[dbus_interface(property)]
    async fn parameters(&self) -> StreamParameters {
-        let size = output_size(&self.output).into();
-        StreamParameters { size }
+        match &self.target {
+            StreamTarget::Output(output) => {
+                let logical = output.logical.as_ref().unwrap();
+                StreamParameters {
+                    position: (logical.x, logical.y),
+                    size: (logical.width as i32, logical.height as i32),
+                }
+            }
+            StreamTarget::Window { .. } => {
+                // Does any consumer need this?
+                StreamParameters {
+                    position: (0, 0),
+                    size: (1, 1),
+                }
+            }
+        }
    }
 }

 impl ScreenCast {
    pub fn new(
-        enabled_outputs: Arc<Mutex<HashMap<String, Output>>>,
+        ipc_outputs: Arc<Mutex<IpcOutputMap>>,
        to_niri: calloop::channel::Sender<ScreenCastToNiri>,
    ) -> Self {
        Self {
-            enabled_outputs,
+            ipc_outputs,
            to_niri,
            sessions: Arc::new(Mutex::new(vec![])),
        }
@@ -242,14 +326,15 @@ impl Start for ScreenCast {
 impl Session {
    pub fn new(
        id: usize,
-        enabled_outputs: Arc<Mutex<HashMap<String, Output>>>,
+        ipc_outputs: Arc<Mutex<IpcOutputMap>>,
        to_niri: calloop::channel::Sender<ScreenCastToNiri>,
    ) -> Self {
        Self {
            id,
-            enabled_outputs,
+            ipc_outputs,
            streams: Arc::new(Mutex::new(vec![])),
            to_niri,
+            stopped: Arc::new(AtomicBool::new(false)),
        }
    }
 }
@@ -263,13 +348,13 @@ impl Drop for Session {
 }

 impl Stream {
-    pub fn new(
-        output: Output,
+    fn new(
+        target: StreamTarget,
        cursor_mode: CursorMode,
        to_niri: calloop::channel::Sender<ScreenCastToNiri>,
    ) -> Self {
        Self {
-            output,
+            target,
            cursor_mode,
            was_started: Arc::new(AtomicBool::new(false)),
            to_niri,
@@ -283,7 +368,7 @@ impl Stream {

        let msg = ScreenCastToNiri::StartCast {
            session_id,
-            output: self.output.clone(),
+            target: self.target.make_id(),
            cursor_mode: self.cursor_mode,
            signal_ctx: ctxt,
        };
@@ -293,3 +378,14 @@ impl Stream {
        }
    }
 }
+
+impl StreamTarget {
+    fn make_id(&self) -> StreamTargetId {
+        match self {
+            StreamTarget::Output(output) => StreamTargetId::Output {
+                name: output.name.clone(),
+            },
+            StreamTarget::Window { id } => StreamTargetId::Window { id: *id },
+        }
+    }
+}
@@ -7,10 +7,11 @@ use crate::utils::get_monotonic_time;
 pub struct FrameClock {
    last_presentation_time: Option<Duration>,
    refresh_interval_ns: Option<NonZeroU64>,
+    vrr: bool,
 }

 impl FrameClock {
-    pub fn new(refresh_interval: Option<Duration>) -> Self {
+    pub fn new(refresh_interval: Option<Duration>, vrr: bool) -> Self {
        let refresh_interval_ns = if let Some(interval) = &refresh_interval {
            assert_eq!(interval.as_secs(), 0);
            Some(NonZeroU64::new(interval.subsec_nanos().into()).unwrap())
@@ -21,6 +22,7 @@ impl FrameClock {
        Self {
            last_presentation_time: None,
            refresh_interval_ns,
+            vrr,
        }
    }

@@ -29,6 +31,19 @@ impl FrameClock {
            .map(|r| Duration::from_nanos(r.get()))
    }

+    pub fn set_vrr(&mut self, vrr: bool) {
+        if self.vrr == vrr {
+            return;
+        }
+
+        self.vrr = vrr;
+        self.last_presentation_time = None;
+    }
+
+    pub fn vrr(&self) -> bool {
+        self.vrr
+    }
+
    pub fn presented(&mut self, presentation_time: Duration) {
        if presentation_time.is_zero() {
            // Not interested in these.
@@ -71,6 +86,13 @@ impl FrameClock {
        let since_last_ns =
            since_last.as_secs() * 1_000_000_000 + u64::from(since_last.subsec_nanos());
        let to_next_ns = (since_last_ns / refresh_interval_ns + 1) * refresh_interval_ns;
-        last_presentation_time + Duration::from_nanos(to_next_ns)
+
+        // If VRR is enabled and more than one frame passed since last presentation, assume that we
+        // can present immediately.
+        if self.vrr && to_next_ns > refresh_interval_ns {
+            now
+        } else {
+            last_presentation_time + Duration::from_nanos(to_next_ns)
+        }
    }
 }
@@ -1,24 +1,27 @@
 use std::collections::hash_map::Entry;

 use smithay::backend::renderer::utils::{on_commit_buffer_handler, with_renderer_surface_state};
-use smithay::input::pointer::CursorImageStatus;
+use smithay::input::pointer::{CursorImageStatus, CursorImageSurfaceData};
 use smithay::reexports::calloop::Interest;
 use smithay::reexports::wayland_server::protocol::wl_buffer;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 use smithay::reexports::wayland_server::{Client, Resource};
 use smithay::wayland::buffer::BufferHandler;
 use smithay::wayland::compositor::{
-    add_blocker, add_pre_commit_hook, get_parent, is_sync_subsurface, send_surface_state,
+    add_blocker, add_pre_commit_hook, get_parent, is_sync_subsurface, remove_pre_commit_hook,
    with_states, BufferAssignment, CompositorClientState, CompositorHandler, CompositorState,
    SurfaceAttributes,
 };
 use smithay::wayland::dmabuf::get_dmabuf;
+use smithay::wayland::shell::xdg::XdgToplevelSurfaceData;
 use smithay::wayland::shm::{ShmHandler, ShmState};
 use smithay::{delegate_compositor, delegate_shm};

-use super::xdg_shell::{initial_configure_sent, resolve_window_rules};
+use super::xdg_shell::add_mapped_toplevel_pre_commit_hook;
 use crate::niri::{ClientState, State};
-use crate::utils::clone2;
+use crate::utils::send_scale_transform;
+use crate::utils::transaction::Transaction;
+use crate::window::{InitialConfigureState, Mapped, ResolvedWindowRules, Unmapped};

 impl CompositorHandler for State {
    fn compositor_state(&mut self) -> &mut CompositorState {
@@ -36,50 +39,21 @@ impl CompositorHandler for State {
        }

        if let Some(output) = self.niri.output_for_root(&root) {
-            let scale = output.current_scale().integer_scale();
+            let scale = output.current_scale();
            let transform = output.current_transform();
            with_states(surface, |data| {
-                send_surface_state(surface, data, scale, transform);
+                send_scale_transform(surface, data, scale, transform);
            });
        }
    }

    fn new_surface(&mut self, surface: &WlSurface) {
-        add_pre_commit_hook::<Self, _>(surface, move |state, _dh, surface| {
-            let maybe_dmabuf = with_states(surface, |surface_data| {
-                surface_data
-                    .cached_state
-                    .pending::<SurfaceAttributes>()
-                    .buffer
-                    .as_ref()
-                    .and_then(|assignment| match assignment {
-                        BufferAssignment::NewBuffer(buffer) => get_dmabuf(buffer).ok(),
-                        _ => None,
-                    })
-            });
-            if let Some(dmabuf) = maybe_dmabuf {
-                if let Ok((blocker, source)) = dmabuf.generate_blocker(Interest::READ) {
-                    let client = surface.client().unwrap();
-                    let res = state
-                        .niri
-                        .event_loop
-                        .insert_source(source, move |_, _, state| {
-                            let display_handle = state.niri.display_handle.clone();
-                            state
-                                .client_compositor_state(&client)
-                                .blocker_cleared(state, &display_handle);
-                            Ok(())
-                        });
-                    if res.is_ok() {
-                        add_blocker(surface, blocker);
-                    }
-                }
-            }
-        })
+        self.add_default_dmabuf_pre_commit_hook(surface);
    }

    fn commit(&mut self, surface: &WlSurface) {
        let _span = tracy_client::span!("CompositorHandler::commit");
+        trace!(surface = ?surface.id(), "commit");

        on_commit_buffer_handler::<Self>(surface);
        self.backend.early_import(surface);
@@ -93,6 +67,11 @@ impl CompositorHandler for State {
            root_surface = parent;
        }

+        // Update the cached root surface.
+        self.niri
+            .root_surface
+            .insert(surface.clone(), root_surface.clone());
+
        if surface == &root_surface {
            // This is a root surface commit. It might have mapped a previously-unmapped toplevel.
            if let Entry::Occupied(entry) = self.niri.unmapped_windows.entry(surface.clone()) {
@@ -105,67 +84,106 @@ impl CompositorHandler for State {

                if is_mapped {
                    // The toplevel got mapped.
-                    let window = entry.remove();
+                    let Unmapped { window, state } = entry.remove();
+
                    window.on_commit();

-                    let parent = window
-                        .toplevel()
+                    let toplevel = window.toplevel().expect("no X11 support");
+
+                    let (rules, width, is_full_width, output, workspace_name) =
+                        if let InitialConfigureState::Configured {
+                            rules,
+                            width,
+                            is_full_width,
+                            output,
+                            workspace_name,
+                        } = state
+                        {
+                            // Check that the output is still connected.
+                            let output =
+                                output.filter(|o| self.niri.layout.monitor_for_output(o).is_some());
+
+                            // Check that the workspace still exists.
+                            let workspace_name = workspace_name
+                                .filter(|n| self.niri.layout.find_workspace_by_name(n).is_some());
+
+                            (rules, width, is_full_width, output, workspace_name)
+                        } else {
+                            error!("window map must happen after initial configure");
+                            (ResolvedWindowRules::empty(), None, false, None, None)
+                        };
+
+                    let parent = toplevel
                        .parent()
                        .and_then(|parent| self.niri.layout.find_window_and_output(&parent))
-                        .map(|(win, _)| win.clone());
+                        // Only consider the parent if we configured the window for the same
+                        // output.
+                        //
+                        // Normally when we're following the parent, the configured output will be
+                        // None. If the configured output is set, that means it was set explicitly
+                        // by a window rule or a fullscreen request.
+                        .filter(|(_, parent_output)| {
+                            output.is_none() || output.as_ref() == Some(*parent_output)
+                        })
+                        .map(|(mapped, _)| mapped.window.clone());

-                    let (width, output) = {
-                        let config = self.niri.config.borrow();
-                        let rules = resolve_window_rules(&config.window_rules, window.toplevel());
-                        let output = rules
-                            .open_on_output
-                            .and_then(|name| self.niri.output_by_name.get(name))
-                            .cloned();
-                        (rules.default_width, output)
-                    };
+                    // The mapped pre-commit hook deals with dma-bufs on its own.
+                    self.remove_default_dmabuf_pre_commit_hook(toplevel.wl_surface());
+                    let hook = add_mapped_toplevel_pre_commit_hook(toplevel);
+                    let mapped = Mapped::new(window, rules, hook);
+                    let window = mapped.window.clone();

-                    let win = window.clone();
-
-                    // Open dialogs immediately to the right of their parent window.
                    let output = if let Some(p) = parent {
-                        self.niri.layout.add_window_right_of(&p, win, width, false)
+                        // Open dialogs immediately to the right of their parent window.
+                        self.niri
+                            .layout
+                            .add_window_right_of(&p, mapped, width, is_full_width)
+                    } else if let Some(workspace_name) = &workspace_name {
+                        self.niri.layout.add_window_to_named_workspace(
+                            workspace_name,
+                            mapped,
+                            width,
+                            is_full_width,
+                        )
                    } else if let Some(output) = &output {
                        self.niri
                            .layout
-                            .add_window_on_output(output, win, width, false);
+                            .add_window_on_output(output, mapped, width, is_full_width);
                        Some(output)
                    } else {
-                        self.niri.layout.add_window(win, width, false)
+                        self.niri.layout.add_window(mapped, width, is_full_width)
                    };

                    if let Some(output) = output.cloned() {
                        self.niri.layout.start_open_animation_for_window(&window);
-                        self.niri.queue_redraw(output);
+
+                        let new_active_window =
+                            self.niri.layout.active_window().map(|(m, _)| &m.window);
+                        if new_active_window == Some(&window) {
+                            self.maybe_warp_cursor_to_focus();
+                        }
+
+                        self.niri.queue_redraw(&output);
                    }
                    return;
                }

                // The toplevel remains unmapped.
-                let window = entry.get().clone();
-
-                // Send the initial configure in an idle, in case the client sent some more info
-                // after the initial commit.
-                if !initial_configure_sent(window.toplevel()) {
-                    self.niri.event_loop.insert_idle(move |state| {
-                        if !window.toplevel().alive() {
-                            return;
-                        }
-                        state.send_initial_configure_if_needed(&window);
-                    });
+                let unmapped = entry.get();
+                if unmapped.needs_initial_configure() {
+                    let toplevel = unmapped.window.toplevel().expect("no x11 support").clone();
+                    self.queue_initial_configure(toplevel);
                }
                return;
            }

            // This is a commit of a previously-mapped root or a non-toplevel root.
-            if let Some(win_out) = self.niri.layout.find_window_and_output(surface) {
-                let (window, output) = clone2(win_out);
+            if let Some((mapped, output)) = self.niri.layout.find_window_and_output(surface) {
+                let window = mapped.window.clone();
+                let output = output.clone();

-                window.on_commit();
+                #[cfg(feature = "xdp-gnome-screencast")]
+                let id = mapped.id();

                // This is a commit of a previously-mapped toplevel.
                let is_mapped =
@@ -175,21 +193,74 @@ impl CompositorHandler for State {
                            false
                        });

+                // Must start the close animation before window.on_commit().
+                let transaction = Transaction::new();
+                if !is_mapped {
+                    let blocker = transaction.blocker();
+                    self.backend.with_primary_renderer(|renderer| {
+                        self.niri
+                            .layout
+                            .start_close_animation_for_window(renderer, &window, blocker);
+                    });
+                }
+
+                window.on_commit();
+
                if !is_mapped {
                    // The toplevel got unmapped.
-                    self.niri.layout.remove_window(&window);
-                    self.niri.unmapped_windows.insert(surface.clone(), window);
-                    self.niri.queue_redraw(output);
+                    //
+                    // Test client: wleird-unmap.
+                    let active_window = self.niri.layout.active_window().map(|(m, _)| &m.window);
+                    let was_active = active_window == Some(&window);
+
+                    #[cfg(feature = "xdp-gnome-screencast")]
+                    self.niri
+                        .stop_casts_for_target(crate::pw_utils::CastTarget::Window {
+                            id: id.get(),
+                        });
+
+                    self.niri.layout.remove_window(&window, transaction.clone());
+                    self.add_default_dmabuf_pre_commit_hook(surface);
+
+                    // If this is the only instance, then this transaction will complete
+                    // immediately, so no need to set the timer.
+                    if !transaction.is_last() {
+                        transaction.register_deadline_timer(&self.niri.event_loop);
+                    }
+
+                    if was_active {
+                        self.maybe_warp_cursor_to_focus();
+                    }
+
+                    // Newly-unmapped toplevels must perform the initial commit-configure sequence
+                    // afresh.
+                    let unmapped = Unmapped::new(window);
+                    self.niri.unmapped_windows.insert(surface.clone(), unmapped);
+
+                    self.niri.queue_redraw(&output);
                    return;
                }

+                let serial = with_states(surface, |states| {
+                    let role = states
+                        .data_map
+                        .get::<XdgToplevelSurfaceData>()
+                        .unwrap()
+                        .lock()
+                        .unwrap();
+                    role.configure_serial
+                });
+                if serial.is_none() {
+                    error!("commit on a mapped surface without a configured serial");
+                }
+
                // The toplevel remains mapped.
-                self.niri.layout.update_window(&window);
+                self.niri.layout.update_window(&window, serial);

                // Popup placement depends on window size which might have changed.
                self.update_reactive_popups(&window, &output);

-                self.niri.queue_redraw(output);
+                self.niri.queue_redraw(&output);
                return;
            }

@@ -198,10 +269,12 @@ impl CompositorHandler for State {

        // This is a commit of a non-root or a non-toplevel root.
        let root_window_output = self.niri.layout.find_window_and_output(&root_surface);
-        if let Some((window, output)) = root_window_output.map(clone2) {
+        if let Some((mapped, output)) = root_window_output {
+            let window = mapped.window.clone();
+            let output = output.clone();
            window.on_commit();
-            self.niri.layout.update_window(&window);
-            self.niri.queue_redraw(output);
+            self.niri.layout.update_window(&window, None);
+            self.niri.queue_redraw(&output);
            return;
        }

@@ -209,38 +282,110 @@ impl CompositorHandler for State {
        self.popups_handle_commit(surface);
        if let Some(popup) = self.niri.popups.find_popup(surface) {
            if let Some(output) = self.output_for_popup(&popup) {
-                self.niri.queue_redraw(output.clone());
+                self.niri.queue_redraw(&output.clone());
            }
+            return;
        }

        // This might be a layer-shell surface.
-        self.layer_shell_handle_commit(surface);
+        if self.layer_shell_handle_commit(surface) {
+            return;
+        }

        // This might be a cursor surface.
-        if matches!(&self.niri.cursor_manager.cursor_image(), CursorImageStatus::Surface(s) if s == surface)
-        {
+        if matches!(
+            &self.niri.cursor_manager.cursor_image(),
+            CursorImageStatus::Surface(s) if s == &root_surface
+        ) {
+            // In case the cursor surface has been committed handle the role specific
+            // buffer offset by applying the offset on the cursor image hotspot
+            if surface == &root_surface {
+                with_states(surface, |states| {
+                    let cursor_image_attributes = states.data_map.get::<CursorImageSurfaceData>();
+
+                    if let Some(mut cursor_image_attributes) =
+                        cursor_image_attributes.map(|attrs| attrs.lock().unwrap())
+                    {
+                        let buffer_delta = states
+                            .cached_state
+                            .get::<SurfaceAttributes>()
+                            .current()
+                            .buffer_delta
+                            .take();
+                        if let Some(buffer_delta) = buffer_delta {
+                            cursor_image_attributes.hotspot -= buffer_delta;
+                        }
+                    }
+                });
+            }
+
            // FIXME: granular redraws for cursors.
            self.niri.queue_redraw_all();
+            return;
        }

        // This might be a DnD icon surface.
-        if self.niri.dnd_icon.as_ref() == Some(surface) {
+        if matches!(&self.niri.dnd_icon, Some(icon) if icon.surface == root_surface) {
+            let dnd_icon = self.niri.dnd_icon.as_mut().unwrap();
+
+            // In case the dnd surface has been committed handle the role specific
+            // buffer offset by applying the offset on the dnd icon offset
+            if surface == &dnd_icon.surface {
+                with_states(&dnd_icon.surface, |states| {
+                    let buffer_delta = states
+                        .cached_state
+                        .get::<SurfaceAttributes>()
+                        .current()
+                        .buffer_delta
+                        .take()
+                        .unwrap_or_default();
+                    dnd_icon.offset += buffer_delta;
+                });
+            }
+
            // FIXME: granular redraws for cursors.
            self.niri.queue_redraw_all();
+            return;
        }

        // This might be a lock surface.
        if self.niri.is_locked() {
            for (output, state) in &self.niri.output_state {
                if let Some(lock_surface) = &state.lock_surface {
-                    if lock_surface.wl_surface() == surface {
-                        self.niri.queue_redraw(output.clone());
-                        break;
+                    if lock_surface.wl_surface() == &root_surface {
+                        self.niri.queue_redraw(&output.clone());
+                        return;
                    }
                }
            }
        }
    }
+
+    fn destroyed(&mut self, surface: &WlSurface) {
+        // Clients may destroy their subsurfaces before the main surface. Ensure we have a snapshot
+        // when that happens, so that the closing animation includes all these subsurfaces.
+        //
+        // Test client: alacritty with CSD <= 0.13 (it was fixed in winit afterwards:
+        // https://github.com/rust-windowing/winit/pull/3625).
+        //
+        // This is still not perfect, as this function is called already after the (first)
+        // subsurface is destroyed; in the case of alacritty, this is the top CSD shadow. But, it
+        // gets most of the job done.
+        if let Some(root) = self.niri.root_surface.get(surface) {
+            if let Some((mapped, _)) = self.niri.layout.find_window_and_output(root) {
+                let window = mapped.window.clone();
+                self.backend.with_primary_renderer(|renderer| {
+                    self.niri.layout.store_unmap_snapshot(renderer, &window);
+                });
+            }
+        }
+
+        self.niri
+            .root_surface
+            .retain(|k, v| k != surface && v != surface);
+
+        self.niri.dmabuf_pre_commit_hook.remove(surface);
+    }
 }

 impl BufferHandler for State {
@@ -255,3 +400,57 @@ impl ShmHandler for State {

 delegate_compositor!(State);
 delegate_shm!(State);
+
+impl State {
+    pub fn add_default_dmabuf_pre_commit_hook(&mut self, surface: &WlSurface) {
+        let hook = add_pre_commit_hook::<Self, _>(surface, move |state, _dh, surface| {
+            let maybe_dmabuf = with_states(surface, |surface_data| {
+                surface_data
+                    .cached_state
+                    .get::<SurfaceAttributes>()
+                    .pending()
+                    .buffer
+                    .as_ref()
+                    .and_then(|assignment| match assignment {
+                        BufferAssignment::NewBuffer(buffer) => get_dmabuf(buffer).cloned().ok(),
+                        _ => None,
+                    })
+            });
+            if let Some(dmabuf) = maybe_dmabuf {
+                if let Ok((blocker, source)) = dmabuf.generate_blocker(Interest::READ) {
+                    if let Some(client) = surface.client() {
+                        let res =
+                            state
+                                .niri
+                                .event_loop
+                                .insert_source(source, move |_, _, state| {
+                                    let display_handle = state.niri.display_handle.clone();
+                                    state
+                                        .client_compositor_state(&client)
+                                        .blocker_cleared(state, &display_handle);
+                                    Ok(())
+                                });
+                        if res.is_ok() {
+                            add_blocker(surface, blocker);
+                            trace!("added default dmabuf blocker");
+                        }
+                    }
+                }
+            }
+        });
+
+        let s = surface.clone();
+        if let Some(prev) = self.niri.dmabuf_pre_commit_hook.insert(s, hook) {
+            error!("tried to add dmabuf pre-commit hook when there was already one");
+            remove_pre_commit_hook(surface, prev);
+        }
+    }
+
+    pub fn remove_default_dmabuf_pre_commit_hook(&mut self, surface: &WlSurface) {
+        if let Some(hook) = self.niri.dmabuf_pre_commit_hook.remove(surface) {
+            remove_pre_commit_hook(surface, hook);
+        } else {
+            error!("tried to remove dmabuf pre-commit hook but there was none");
+        }
+    }
+}
@@ -1,16 +1,18 @@
+use smithay::backend::renderer::utils::with_renderer_surface_state;
 use smithay::delegate_layer_shell;
-use smithay::desktop::{layer_map_for_output, LayerSurface, WindowSurfaceType};
+use smithay::desktop::{layer_map_for_output, LayerSurface, PopupKind, WindowSurfaceType};
 use smithay::output::Output;
 use smithay::reexports::wayland_server::protocol::wl_output::WlOutput;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
-use smithay::wayland::compositor::{send_surface_state, with_states};
+use smithay::wayland::compositor::{get_parent, with_states};
 use smithay::wayland::shell::wlr_layer::{
-    Layer, LayerSurface as WlrLayerSurface, LayerSurfaceData, WlrLayerShellHandler,
+    self, Layer, LayerSurface as WlrLayerSurface, LayerSurfaceData, WlrLayerShellHandler,
    WlrLayerShellState,
 };
 use smithay::wayland::shell::xdg::PopupSurface;

 use crate::niri::State;
+use crate::utils::send_scale_transform;

 impl WlrLayerShellHandler for State {
    fn shell_state(&mut self) -> &mut WlrLayerShellState {
@@ -24,17 +26,30 @@ impl WlrLayerShellHandler for State {
        _layer: Layer,
        namespace: String,
    ) {
-        let output = wl_output
-            .as_ref()
-            .and_then(Output::from_resource)
-            .or_else(|| self.niri.layout.active_output().cloned())
-            .unwrap();
+        let output = if let Some(wl_output) = &wl_output {
+            Output::from_resource(wl_output)
+        } else {
+            self.niri.layout.active_output().cloned()
+        };
+        let Some(output) = output else {
+            warn!("no output for new layer surface, closing");
+            surface.send_close();
+            return;
+        };
+
+        let wl_surface = surface.wl_surface().clone();
+        let is_new = self.niri.unmapped_layer_surfaces.insert(wl_surface);
+        assert!(is_new);
+
        let mut map = layer_map_for_output(&output);
        map.map_layer(&LayerSurface::new(surface, namespace))
            .unwrap();
    }

    fn layer_destroyed(&mut self, surface: WlrLayerSurface) {
+        let wl_surface = surface.wl_surface();
+        self.niri.unmapped_layer_surfaces.remove(wl_surface);
+
        let output = if let Some((output, mut map, layer)) =
            self.niri.layout.outputs().find_map(|o| {
                let map = layer_map_for_output(o);
@@ -50,63 +65,112 @@ impl WlrLayerShellHandler for State {
            None
        };
        if let Some(output) = output {
-            self.niri.output_resized(output);
+            self.niri.output_resized(&output);
        }
    }

    fn new_popup(&mut self, _parent: WlrLayerSurface, popup: PopupSurface) {
-        self.unconstrain_popup(&popup);
+        self.unconstrain_popup(&PopupKind::Xdg(popup));
    }
 }
 delegate_layer_shell!(State);

 impl State {
-    pub fn layer_shell_handle_commit(&mut self, surface: &WlSurface) {
-        let Some(output) = self
+    pub fn layer_shell_handle_commit(&mut self, surface: &WlSurface) -> bool {
+        let mut root_surface = surface.clone();
+        while let Some(parent) = get_parent(&root_surface) {
+            root_surface = parent;
+        }
+
+        let output = self
            .niri
            .layout
            .outputs()
            .find(|o| {
                let map = layer_map_for_output(o);
-                map.layer_for_surface(surface, WindowSurfaceType::TOPLEVEL)
+                map.layer_for_surface(&root_surface, WindowSurfaceType::TOPLEVEL)
                    .is_some()
            })
-            .cloned()
-        else {
-            return;
+            .cloned();
+        let Some(output) = output else {
+            return false;
        };

-        let initial_configure_sent = with_states(surface, |states| {
-            states
-                .data_map
-                .get::<LayerSurfaceData>()
-                .unwrap()
-                .lock()
-                .unwrap()
-                .initial_configure_sent
-        });
+        if surface == &root_surface {
+            let initial_configure_sent = with_states(surface, |states| {
+                states
+                    .data_map
+                    .get::<LayerSurfaceData>()
+                    .unwrap()
+                    .lock()
+                    .unwrap()
+                    .initial_configure_sent
+            });

-        let mut map = layer_map_for_output(&output);
+            let mut map = layer_map_for_output(&output);
+
+            // Arrange the layers before sending the initial configure to respect any size the
+            // client may have sent.
+            map.arrange();

-        // arrange the layers before sending the initial configure
-        // to respect any size the client may have sent
-        map.arrange();
-        // send the initial configure if relevant
-        if !initial_configure_sent {
            let layer = map
                .layer_for_surface(surface, WindowSurfaceType::TOPLEVEL)
                .unwrap();

-            let scale = output.current_scale().integer_scale();
-            let transform = output.current_transform();
-            with_states(surface, |data| {
-                send_surface_state(surface, data, scale, transform);
-            });
+            if initial_configure_sent {
+                let is_mapped =
+                    with_renderer_surface_state(surface, |state| state.buffer().is_some())
+                        .unwrap_or_else(|| {
+                            error!("no renderer surface state even though we use commit handler");
+                            false
+                        });

-            layer.layer_surface().send_configure();
+                if is_mapped {
+                    let was_unmapped = self.niri.unmapped_layer_surfaces.remove(surface);
+
+                    // Give focus to newly mapped on-demand surfaces. Some launchers like
+                    // lxqt-runner rely on this behavior. While this behavior doesn't make much
+                    // sense for other clients like panels, the consensus seems to be that it's not
+                    // a big deal since panels generally only open once at the start of the
+                    // session.
+                    //
+                    // Note that:
+                    // 1) Exclusive layer surfaces already get focus automatically in
+                    //    update_keyboard_focus().
+                    // 2) Same-layer exclusive layer surfaces are already preferred to on-demand
+                    //    surfaces in update_keyboard_focus(), so we don't need to check for that
+                    //    here.
+                    //
+                    // https://github.com/YaLTeR/niri/issues/641
+                    let on_demand = layer.cached_state().keyboard_interactivity
+                        == wlr_layer::KeyboardInteractivity::OnDemand;
+                    if was_unmapped && on_demand {
+                        // I guess it'd make sense to check that no higher-layer on-demand surface
+                        // has focus, but Smithay's Layer doesn't implement Ord so this would be a
+                        // little annoying.
+                        self.niri.layer_shell_on_demand_focus = Some(layer.clone());
+                    }
+                } else {
+                    self.niri.unmapped_layer_surfaces.insert(surface.clone());
+                }
+            } else {
+                let scale = output.current_scale();
+                let transform = output.current_transform();
+                with_states(surface, |data| {
+                    send_scale_transform(surface, data, scale, transform);
+                });
+
+                layer.layer_surface().send_configure();
+            }
+            drop(map);
+
+            // This will call queue_redraw() inside.
+            self.niri.output_resized(&output);
+        } else {
+            // This is an unsync layer-shell subsurface.
+            self.niri.queue_redraw(&output);
        }
-        drop(map);

-        self.niri.output_resized(output);
+        true
    }
 }
@@ -10,27 +10,32 @@ use std::thread;

 use smithay::backend::allocator::dmabuf::Dmabuf;
 use smithay::backend::drm::DrmNode;
+use smithay::backend::input::TabletToolDescriptor;
 use smithay::desktop::{PopupKind, PopupManager};
-use smithay::input::pointer::{CursorIcon, CursorImageStatus, PointerHandle};
+use smithay::input::pointer::{
+    CursorIcon, CursorImageStatus, CursorImageSurfaceData, PointerHandle,
+};
 use smithay::input::{keyboard, Seat, SeatHandler, SeatState};
 use smithay::output::Output;
-use smithay::reexports::input;
+use smithay::reexports::rustix::fs::{fcntl_setfl, OFlags};
 use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel;
+use smithay::reexports::wayland_protocols_wlr::screencopy::v1::server::zwlr_screencopy_manager_v1::ZwlrScreencopyManagerV1;
 use smithay::reexports::wayland_server::protocol::wl_data_source::WlDataSource;
 use smithay::reexports::wayland_server::protocol::wl_output::WlOutput;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 use smithay::reexports::wayland_server::Resource;
-use smithay::utils::{Logical, Rectangle, Size};
-use smithay::wayland::compositor::{send_surface_state, with_states};
+use smithay::utils::{Logical, Point, Rectangle, Size};
+use smithay::wayland::compositor::{get_parent, with_states};
 use smithay::wayland::dmabuf::{DmabufGlobal, DmabufHandler, DmabufState, ImportNotifier};
 use smithay::wayland::drm_lease::{
    DrmLease, DrmLeaseBuilder, DrmLeaseHandler, DrmLeaseRequest, DrmLeaseState, LeaseRejected,
 };
+use smithay::wayland::fractional_scale::FractionalScaleHandler;
 use smithay::wayland::idle_inhibit::IdleInhibitHandler;
 use smithay::wayland::idle_notify::{IdleNotifierHandler, IdleNotifierState};
 use smithay::wayland::input_method::{InputMethodHandler, PopupSurface};
 use smithay::wayland::output::OutputHandler;
-use smithay::wayland::pointer_constraints::PointerConstraintsHandler;
+use smithay::wayland::pointer_constraints::{with_pointer_constraint, PointerConstraintsHandler};
 use smithay::wayland::security_context::{
    SecurityContext, SecurityContextHandler, SecurityContextListenerSource,
 };
@@ -46,25 +51,39 @@ use smithay::wayland::selection::{SelectionHandler, SelectionTarget};
 use smithay::wayland::session_lock::{
    LockSurface, SessionLockHandler, SessionLockManagerState, SessionLocker,
 };
+use smithay::wayland::tablet_manager::TabletSeatHandler;
+use smithay::wayland::xdg_activation::{
+    XdgActivationHandler, XdgActivationState, XdgActivationToken, XdgActivationTokenData,
+};
 use smithay::{
    delegate_cursor_shape, delegate_data_control, delegate_data_device, delegate_dmabuf,
-    delegate_drm_lease, delegate_idle_inhibit, delegate_idle_notify, delegate_input_method_manager,
-    delegate_output, delegate_pointer_constraints, delegate_pointer_gestures,
-    delegate_presentation, delegate_primary_selection, delegate_relative_pointer, delegate_seat,
-    delegate_security_context, delegate_session_lock, delegate_tablet_manager,
-    delegate_text_input_manager, delegate_virtual_keyboard_manager,
+    delegate_drm_lease, delegate_fractional_scale, delegate_idle_inhibit, delegate_idle_notify,
+    delegate_input_method_manager, delegate_output, delegate_pointer_constraints,
+    delegate_pointer_gestures, delegate_presentation, delegate_primary_selection,
+    delegate_relative_pointer, delegate_seat, delegate_security_context, delegate_session_lock,
+    delegate_tablet_manager, delegate_text_input_manager, delegate_viewporter,
+    delegate_virtual_keyboard_manager, delegate_xdg_activation,
 };

-use crate::delegate_foreign_toplevel;
-use crate::niri::{ClientState, State};
+pub use crate::handlers::xdg_shell::KdeDecorationsModeState;
+use crate::niri::{ClientState, DndIcon, State};
 use crate::protocols::foreign_toplevel::{
    self, ForeignToplevelHandler, ForeignToplevelManagerState,
 };
-use crate::utils::output_size;
+use crate::protocols::gamma_control::{GammaControlHandler, GammaControlManagerState};
+use crate::protocols::mutter_x11_interop::MutterX11InteropHandler;
+use crate::protocols::output_management::{OutputManagementHandler, OutputManagementManagerState};
+use crate::protocols::screencopy::{Screencopy, ScreencopyHandler, ScreencopyManagerState};
+use crate::utils::{output_size, send_scale_transform};
+use crate::{
+    delegate_foreign_toplevel, delegate_gamma_control, delegate_mutter_x11_interop,
+    delegate_output_management, delegate_screencopy,
+};

 impl SeatHandler for State {
    type KeyboardFocus = WlSurface;
    type PointerFocus = WlSurface;
+    type TouchFocus = WlSurface;

    fn seat_state(&mut self) -> &mut SeatState<State> {
        &mut self.niri.seat_state
@@ -103,11 +122,20 @@ impl SeatHandler for State {
 }
 delegate_seat!(State);
 delegate_cursor_shape!(State);
-delegate_tablet_manager!(State);
 delegate_pointer_gestures!(State);
 delegate_relative_pointer!(State);
 delegate_text_input_manager!(State);

+impl TabletSeatHandler for State {
+    fn tablet_tool_image(&mut self, _tool: &TabletToolDescriptor, image: CursorImageStatus) {
+        // FIXME: tablet tools should have their own cursors.
+        self.niri.cursor_manager.set_cursor_image(image);
+        // FIXME: granular.
+        self.niri.queue_redraw_all();
+    }
+}
+delegate_tablet_manager!(State);
+
 impl PointerConstraintsHandler for State {
    fn new_constraint(&mut self, _surface: &WlSurface, pointer: &PointerHandle<Self>) {
        self.niri.maybe_activate_pointer_constraint(
@@ -115,34 +143,97 @@ impl PointerConstraintsHandler for State {
            &self.niri.pointer_focus,
        );
    }
+
+    fn cursor_position_hint(
+        &mut self,
+        surface: &WlSurface,
+        pointer: &PointerHandle<Self>,
+        location: Point<f64, Logical>,
+    ) {
+        let is_constraint_active = with_pointer_constraint(surface, pointer, |constraint| {
+            constraint.map_or(false, |c| c.is_active())
+        });
+
+        if !is_constraint_active {
+            return;
+        }
+
+        // Logically the following two checks should always succeed (so, they should print
+        // error!()s if they fail). However, currently both can fail because niri's pointer focus
+        // doesn't take pointer grabs into account. So if you start, say, a middle-drag in Blender,
+        // then touchpad-swipe the window away, the niri pointer focus will change, even though the
+        // real pointer focus remains on the Blender surface due to the click grab.
+        //
+        // FIXME: add error!()s when niri pointer focus takes grabs into account. Alternatively,
+        // recompute the surface origin here (but that is a bit clunky).
+        let Some((ref focused_surface, origin)) = self.niri.pointer_focus.surface else {
+            return;
+        };
+
+        if focused_surface != surface {
+            return;
+        }
+
+        let mut root = surface.clone();
+        while let Some(parent) = get_parent(&root) {
+            root = parent;
+        }
+
+        let target = self
+            .niri
+            .output_for_root(&root)
+            .and_then(|output| self.niri.global_space.output_geometry(output))
+            .map_or(origin + location, |mut output_geometry| {
+                // i32 sizes are exclusive, but f64 sizes are inclusive.
+                output_geometry.size -= (1, 1).into();
+                (origin + location).constrain(output_geometry.to_f64())
+            });
+        pointer.set_location(target);
+
+        // Redraw to update the cursor position if it's visible.
+        if !self.niri.pointer_hidden {
+            // FIXME: redraw only outputs overlapping the cursor.
+            self.niri.queue_redraw_all();
+        }
+    }
 }
 delegate_pointer_constraints!(State);

 impl InputMethodHandler for State {
    fn new_popup(&mut self, surface: PopupSurface) {
-        let popup = PopupKind::from(surface.clone());
+        let popup = PopupKind::InputMethod(surface);
        if let Some(output) = self.output_for_popup(&popup) {
-            let scale = output.current_scale().integer_scale();
+            let scale = output.current_scale();
            let transform = output.current_transform();
-            let wl_surface = surface.wl_surface();
+            let wl_surface = popup.wl_surface();
            with_states(wl_surface, |data| {
-                send_surface_state(wl_surface, data, scale, transform);
+                send_scale_transform(wl_surface, data, scale, transform);
            });
        }
+
+        self.unconstrain_popup(&popup);
+
        if let Err(err) = self.niri.popups.track_popup(popup) {
            warn!("error tracking ime popup {err:?}");
        }
    }
+
+    fn popup_repositioned(&mut self, surface: PopupSurface) {
+        let popup = PopupKind::InputMethod(surface);
+        self.unconstrain_popup(&popup);
+    }
+
    fn dismiss_popup(&mut self, surface: PopupSurface) {
        if let Some(parent) = surface.get_parent().map(|parent| parent.surface.clone()) {
            let _ = PopupManager::dismiss_popup(&parent, &PopupKind::from(surface));
        }
    }
+
    fn parent_geometry(&self, parent: &WlSurface) -> Rectangle<i32, Logical> {
        self.niri
            .layout
            .find_window_and_output(parent)
-            .map(|(window, _)| window.geometry())
+            .map(|(mapped, _)| mapped.window.geometry())
            .unwrap_or_default()
    }
 }
@@ -165,6 +256,10 @@ impl SelectionHandler for State {

        let buf = user_data.clone();
        thread::spawn(move || {
+            // Clear O_NONBLOCK, otherwise File::write_all() will stop halfway.
+            if let Err(err) = fcntl_setfl(&fd, OFlags::empty()) {
+                warn!("error clearing flags on selection target fd: {err:?}");
+            }
            if let Err(err) = File::from(fd).write_all(&buf) {
                warn!("error writing selection: {err:?}");
            }
@@ -185,7 +280,23 @@ impl ClientDndGrabHandler for State {
        icon: Option<WlSurface>,
        _seat: Seat<Self>,
    ) {
-        self.niri.dnd_icon = icon;
+        let offset = if let CursorImageStatus::Surface(ref surface) =
+            self.niri.cursor_manager.cursor_image()
+        {
+            with_states(surface, |states| {
+                let hotspot = states
+                    .data_map
+                    .get::<CursorImageSurfaceData>()
+                    .unwrap()
+                    .lock()
+                    .unwrap()
+                    .hotspot;
+                Point::from((-hotspot.x, -hotspot.y))
+            })
+        } else {
+            (0, 0).into()
+        };
+        self.niri.dnd_icon = icon.map(|surface| DndIcon { surface, offset });
        // FIXME: more granular
        self.niri.queue_redraw_all();
    }
@@ -260,7 +371,7 @@ impl SessionLockHandler for State {

    fn new_surface(&mut self, surface: LockSurface, output: WlOutput) {
        let Some(output) = Output::from_resource(&output) else {
-            error!("no Output matching WlOutput");
+            warn!("no Output matching WlOutput");
            return;
        };

@@ -275,11 +386,11 @@ pub fn configure_lock_surface(surface: &LockSurface, output: &Output) {
        let size = output_size(output);
        states.size = Some(Size::from((size.w as u32, size.h as u32)));
    });
-    let scale = output.current_scale().integer_scale();
+    let scale = output.current_scale();
    let transform = output.current_transform();
    let wl_surface = surface.wl_surface();
    with_states(wl_surface, |data| {
-        send_surface_state(wl_surface, data, scale, transform);
+        send_scale_transform(wl_surface, data, scale, transform);
    });
    surface.send_configure();
 }
@@ -297,7 +408,7 @@ impl SecurityContextHandler for State {
                });

                if let Err(err) = state.niri.display_handle.insert_client(client, data) {
-                    error!("error inserting client: {err}");
+                    warn!("error inserting client: {err}");
                } else {
                    trace!("inserted a new restricted client, context={context:?}");
                }
@@ -331,23 +442,24 @@ impl ForeignToplevelHandler for State {
    }

    fn activate(&mut self, wl_surface: WlSurface) {
-        if let Some((window, _)) = self.niri.layout.find_window_and_output(&wl_surface) {
-            let window = window.clone();
+        if let Some((mapped, _)) = self.niri.layout.find_window_and_output(&wl_surface) {
+            let window = mapped.window.clone();
            self.niri.layout.activate_window(&window);
+            self.niri.layer_shell_on_demand_focus = None;
            self.niri.queue_redraw_all();
        }
    }

    fn close(&mut self, wl_surface: WlSurface) {
-        if let Some((window, _)) = self.niri.layout.find_window_and_output(&wl_surface) {
-            window.toplevel().send_close();
+        if let Some((mapped, _)) = self.niri.layout.find_window_and_output(&wl_surface) {
+            mapped.toplevel().send_close();
        }
    }

    fn set_fullscreen(&mut self, wl_surface: WlSurface, wl_output: Option<WlOutput>) {
-        if let Some((window, current_output)) = self.niri.layout.find_window_and_output(&wl_surface)
+        if let Some((mapped, current_output)) = self.niri.layout.find_window_and_output(&wl_surface)
        {
-            if !window
+            if !mapped
                .toplevel()
                .current_state()
                .capabilities
@@ -356,13 +468,13 @@ impl ForeignToplevelHandler for State {
                return;
            }

-            let window = window.clone();
+            let window = mapped.window.clone();

            if let Some(requested_output) = wl_output.as_ref().and_then(Output::from_resource) {
                if &requested_output != current_output {
                    self.niri
                        .layout
-                        .move_window_to_output(window.clone(), &requested_output);
+                        .move_to_output(Some(&window), &requested_output, None);
                }
            }

@@ -371,22 +483,51 @@ impl ForeignToplevelHandler for State {
    }

    fn unset_fullscreen(&mut self, wl_surface: WlSurface) {
-        if let Some((window, _)) = self.niri.layout.find_window_and_output(&wl_surface) {
-            let window = window.clone();
+        if let Some((mapped, _)) = self.niri.layout.find_window_and_output(&wl_surface) {
+            let window = mapped.window.clone();
            self.niri.layout.set_fullscreen(&window, false);
        }
    }
 }
 delegate_foreign_toplevel!(State);

+impl ScreencopyHandler for State {
+    fn frame(&mut self, manager: &ZwlrScreencopyManagerV1, screencopy: Screencopy) {
+        // If with_damage then push it onto the queue for redraw of the output,
+        // otherwise render it immediately.
+        if screencopy.with_damage() {
+            let Some(queue) = self.niri.screencopy_state.get_queue_mut(manager) else {
+                trace!("screencopy manager destroyed already");
+                return;
+            };
+            queue.push(screencopy);
+        } else {
+            self.backend.with_primary_renderer(|renderer| {
+                if let Err(err) = self
+                    .niri
+                    .render_for_screencopy_without_damage(renderer, manager, screencopy)
+                {
+                    warn!("error rendering for screencopy: {err:?}");
+                }
+            });
+        }
+    }
+
+    fn screencopy_state(&mut self) -> &mut ScreencopyManagerState {
+        &mut self.niri.screencopy_state
+    }
+}
+delegate_screencopy!(State);
+
 impl DrmLeaseHandler for State {
    fn drm_lease_state(&mut self, node: DrmNode) -> &mut DrmLeaseState {
-        &mut self
-            .backend
+        self.backend
            .tty()
            .get_device_from_node(node)
            .unwrap()
            .drm_lease_state
+            .as_mut()
+            .unwrap()
    }

    fn lease_request(
@@ -424,3 +565,93 @@ impl DrmLeaseHandler for State {
    }
 }
 delegate_drm_lease!(State);
+
+delegate_viewporter!(State);
+
+impl GammaControlHandler for State {
+    fn gamma_control_manager_state(&mut self) -> &mut GammaControlManagerState {
+        &mut self.niri.gamma_control_manager_state
+    }
+
+    fn get_gamma_size(&mut self, output: &Output) -> Option<u32> {
+        match self.backend.tty().get_gamma_size(output) {
+            Ok(0) => None, // Setting gamma is not supported.
+            Ok(size) => Some(size),
+            Err(err) => {
+                warn!(
+                    "error getting gamma size for output {}: {err:?}",
+                    output.name()
+                );
+                None
+            }
+        }
+    }
+
+    fn set_gamma(&mut self, output: &Output, ramp: Option<Vec<u16>>) -> Option<()> {
+        match self.backend.tty().set_gamma(output, ramp) {
+            Ok(()) => Some(()),
+            Err(err) => {
+                warn!("error setting gamma for output {}: {err:?}", output.name());
+                None
+            }
+        }
+    }
+}
+delegate_gamma_control!(State);
+
+impl XdgActivationHandler for State {
+    fn activation_state(&mut self) -> &mut XdgActivationState {
+        &mut self.niri.activation_state
+    }
+
+    fn token_created(&mut self, _token: XdgActivationToken, data: XdgActivationTokenData) -> bool {
+        // Only tokens that were created while the application has keyboard focus are valid.
+        let Some((serial, seat)) = data.serial else {
+            return false;
+        };
+        let Some(seat) = Seat::<State>::from_resource(&seat) else {
+            return false;
+        };
+
+        let keyboard = seat.get_keyboard().unwrap();
+        keyboard
+            .last_enter()
+            .map(|last_enter| serial.is_no_older_than(&last_enter))
+            .unwrap_or(false)
+    }
+
+    fn request_activation(
+        &mut self,
+        _token: XdgActivationToken,
+        token_data: XdgActivationTokenData,
+        surface: WlSurface,
+    ) {
+        if token_data.timestamp.elapsed().as_secs() < 10 {
+            if let Some((mapped, _)) = self.niri.layout.find_window_and_output(&surface) {
+                let window = mapped.window.clone();
+                self.niri.layout.activate_window(&window);
+                self.niri.layer_shell_on_demand_focus = None;
+                self.niri.queue_redraw_all();
+            }
+        }
+    }
+}
+delegate_xdg_activation!(State);
+
+impl FractionalScaleHandler for State {}
+delegate_fractional_scale!(State);
+
+impl OutputManagementHandler for State {
+    fn output_management_state(&mut self) -> &mut OutputManagementManagerState {
+        &mut self.niri.output_management_state
+    }
+
+    fn apply_output_config(&mut self, config: niri_config::Outputs) {
+        self.niri.config.borrow_mut().outputs = config;
+        self.reload_output_config();
+    }
+}
+delegate_output_management!(State);
+
+impl MutterX11InteropHandler for State {}
+delegate_mutter_x11_interop!(State);
@@ -0,0 +1,225 @@
+use std::time::Duration;
+
+use smithay::backend::input::ButtonState;
+use smithay::desktop::Window;
+use smithay::input::pointer::{
+    AxisFrame, ButtonEvent, CursorImageStatus, GestureHoldBeginEvent, GestureHoldEndEvent,
+    GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent, GestureSwipeBeginEvent,
+    GestureSwipeEndEvent, GestureSwipeUpdateEvent, GrabStartData as PointerGrabStartData,
+    MotionEvent, PointerGrab, PointerInnerHandle, RelativeMotionEvent,
+};
+use smithay::input::SeatHandler;
+use smithay::utils::{IsAlive, Logical, Point};
+
+use crate::niri::State;
+
+pub struct MoveGrab {
+    start_data: PointerGrabStartData<State>,
+    last_location: Point<f64, Logical>,
+    window: Window,
+    is_moving: bool,
+}
+
+impl MoveGrab {
+    pub fn new(start_data: PointerGrabStartData<State>, window: Window) -> Self {
+        Self {
+            last_location: start_data.location,
+            start_data,
+            window,
+            is_moving: false,
+        }
+    }
+
+    fn on_ungrab(&mut self, state: &mut State) {
+        state.niri.layout.interactive_move_end(&self.window);
+        // FIXME: only redraw the window output.
+        state.niri.queue_redraw_all();
+        state.niri.pointer_grab_ongoing = false;
+        state
+            .niri
+            .cursor_manager
+            .set_cursor_image(CursorImageStatus::default_named());
+    }
+}
+
+impl PointerGrab<State> for MoveGrab {
+    fn motion(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        _focus: Option<(<State as SeatHandler>::PointerFocus, Point<f64, Logical>)>,
+        event: &MotionEvent,
+    ) {
+        // While the grab is active, no client has pointer focus.
+        handle.motion(data, None, event);
+
+        if self.window.alive() {
+            if let Some((output, pos_within_output)) = data.niri.output_under(event.location) {
+                let output = output.clone();
+                let event_delta = event.location - self.last_location;
+                self.last_location = event.location;
+                let ongoing = data.niri.layout.interactive_move_update(
+                    &self.window,
+                    event_delta,
+                    output,
+                    pos_within_output,
+                );
+                if ongoing {
+                    let timestamp = Duration::from_millis(u64::from(event.time));
+                    if self.is_moving {
+                        data.niri.layout.view_offset_gesture_update(
+                            -event_delta.x,
+                            timestamp,
+                            false,
+                        );
+                    }
+                    // FIXME: only redraw the previous and the new output.
+                    data.niri.queue_redraw_all();
+                    return;
+                }
+            } else {
+                return;
+            }
+        }
+
+        // The move is no longer ongoing.
+        handle.unset_grab(self, data, event.serial, event.time, true);
+    }
+
+    fn relative_motion(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        _focus: Option<(<State as SeatHandler>::PointerFocus, Point<f64, Logical>)>,
+        event: &RelativeMotionEvent,
+    ) {
+        // While the grab is active, no client has pointer focus.
+        handle.relative_motion(data, None, event);
+    }
+
+    fn button(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &ButtonEvent,
+    ) {
+        handle.button(data, event);
+
+        // MouseButton::Middle
+        if event.button == 0x112 {
+            if event.state == ButtonState::Pressed {
+                let output = data
+                    .niri
+                    .output_under(handle.current_location())
+                    .map(|(output, _)| output)
+                    .cloned();
+                // TODO: workspace switch gesture.
+                if let Some(output) = output {
+                    self.is_moving = true;
+                    data.niri.layout.view_offset_gesture_begin(&output, false);
+                }
+            } else if event.state == ButtonState::Released {
+                self.is_moving = false;
+                data.niri.layout.view_offset_gesture_end(false, None);
+            }
+        }
+
+        if handle.current_pressed().is_empty() {
+            // No more buttons are pressed, release the grab.
+            handle.unset_grab(self, data, event.serial, event.time, true);
+        }
+    }
+
+    fn axis(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        details: AxisFrame,
+    ) {
+        handle.axis(data, details);
+    }
+
+    fn frame(&mut self, data: &mut State, handle: &mut PointerInnerHandle<'_, State>) {
+        handle.frame(data);
+    }
+
+    fn gesture_swipe_begin(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureSwipeBeginEvent,
+    ) {
+        handle.gesture_swipe_begin(data, event);
+    }
+
+    fn gesture_swipe_update(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureSwipeUpdateEvent,
+    ) {
+        handle.gesture_swipe_update(data, event);
+    }
+
+    fn gesture_swipe_end(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureSwipeEndEvent,
+    ) {
+        handle.gesture_swipe_end(data, event);
+    }
+
+    fn gesture_pinch_begin(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GesturePinchBeginEvent,
+    ) {
+        handle.gesture_pinch_begin(data, event);
+    }
+
+    fn gesture_pinch_update(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GesturePinchUpdateEvent,
+    ) {
+        handle.gesture_pinch_update(data, event);
+    }
+
+    fn gesture_pinch_end(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GesturePinchEndEvent,
+    ) {
+        handle.gesture_pinch_end(data, event);
+    }
+
+    fn gesture_hold_begin(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureHoldBeginEvent,
+    ) {
+        handle.gesture_hold_begin(data, event);
+    }
+
+    fn gesture_hold_end(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureHoldEndEvent,
+    ) {
+        handle.gesture_hold_end(data, event);
+    }
+
+    fn start_data(&self) -> &PointerGrabStartData<State> {
+        &self.start_data
+    }
+
+    fn unset(&mut self, data: &mut State) {
+        self.on_ungrab(data);
+    }
+}
@@ -0,0 +1,176 @@
+use smithay::desktop::Window;
+use smithay::input::pointer::{
+    AxisFrame, ButtonEvent, CursorImageStatus, GestureHoldBeginEvent, GestureHoldEndEvent,
+    GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent, GestureSwipeBeginEvent,
+    GestureSwipeEndEvent, GestureSwipeUpdateEvent, GrabStartData as PointerGrabStartData,
+    MotionEvent, PointerGrab, PointerInnerHandle, RelativeMotionEvent,
+};
+use smithay::input::SeatHandler;
+use smithay::utils::{IsAlive, Logical, Point};
+
+use crate::niri::State;
+
+pub struct ResizeGrab {
+    start_data: PointerGrabStartData<State>,
+    window: Window,
+}
+
+impl ResizeGrab {
+    pub fn new(start_data: PointerGrabStartData<State>, window: Window) -> Self {
+        Self { start_data, window }
+    }
+
+    fn on_ungrab(&mut self, state: &mut State) {
+        state.niri.layout.interactive_resize_end(&self.window);
+        state.niri.pointer_grab_ongoing = false;
+        state
+            .niri
+            .cursor_manager
+            .set_cursor_image(CursorImageStatus::default_named());
+    }
+}
+
+impl PointerGrab<State> for ResizeGrab {
+    fn motion(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        _focus: Option<(<State as SeatHandler>::PointerFocus, Point<f64, Logical>)>,
+        event: &MotionEvent,
+    ) {
+        // While the grab is active, no client has pointer focus.
+        handle.motion(data, None, event);
+
+        if self.window.alive() {
+            let delta = event.location - self.start_data.location;
+            let ongoing = data
+                .niri
+                .layout
+                .interactive_resize_update(&self.window, delta);
+            if ongoing {
+                return;
+            }
+        }
+
+        // The resize is no longer ongoing.
+        handle.unset_grab(self, data, event.serial, event.time, true);
+    }
+
+    fn relative_motion(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        _focus: Option<(<State as SeatHandler>::PointerFocus, Point<f64, Logical>)>,
+        event: &RelativeMotionEvent,
+    ) {
+        // While the grab is active, no client has pointer focus.
+        handle.relative_motion(data, None, event);
+    }
+
+    fn button(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &ButtonEvent,
+    ) {
+        handle.button(data, event);
+
+        if handle.current_pressed().is_empty() {
+            // No more buttons are pressed, release the grab.
+            handle.unset_grab(self, data, event.serial, event.time, true);
+        }
+    }
+
+    fn axis(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        details: AxisFrame,
+    ) {
+        handle.axis(data, details);
+    }
+
+    fn frame(&mut self, data: &mut State, handle: &mut PointerInnerHandle<'_, State>) {
+        handle.frame(data);
+    }
+
+    fn gesture_swipe_begin(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureSwipeBeginEvent,
+    ) {
+        handle.gesture_swipe_begin(data, event);
+    }
+
+    fn gesture_swipe_update(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureSwipeUpdateEvent,
+    ) {
+        handle.gesture_swipe_update(data, event);
+    }
+
+    fn gesture_swipe_end(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureSwipeEndEvent,
+    ) {
+        handle.gesture_swipe_end(data, event);
+    }
+
+    fn gesture_pinch_begin(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GesturePinchBeginEvent,
+    ) {
+        handle.gesture_pinch_begin(data, event);
+    }
+
+    fn gesture_pinch_update(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GesturePinchUpdateEvent,
+    ) {
+        handle.gesture_pinch_update(data, event);
+    }
+
+    fn gesture_pinch_end(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GesturePinchEndEvent,
+    ) {
+        handle.gesture_pinch_end(data, event);
+    }
+
+    fn gesture_hold_begin(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureHoldBeginEvent,
+    ) {
+        handle.gesture_hold_begin(data, event);
+    }
+
+    fn gesture_hold_end(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureHoldEndEvent,
+    ) {
+        handle.gesture_hold_end(data, event);
+    }
+
+    fn start_data(&self) -> &PointerGrabStartData<State> {
+        &self.start_data
+    }
+
+    fn unset(&mut self, data: &mut State) {
+        self.on_ungrab(data);
+    }
+}
@@ -0,0 +1,40 @@
+pub struct ScrollTracker {
+    tick: f64,
+    last: f64,
+    acc: f64,
+}
+
+impl ScrollTracker {
+    #[allow(clippy::new_without_default)]
+    pub fn new(tick: i8) -> Self {
+        Self {
+            tick: f64::from(tick),
+            last: 0.,
+            acc: 0.,
+        }
+    }
+
+    pub fn accumulate(&mut self, amount: f64) -> i8 {
+        let changed_direction = (self.last > 0. && amount < 0.) || (self.last < 0. && amount > 0.);
+        if changed_direction {
+            self.acc = 0.
+        }
+
+        self.last = amount;
+        self.acc += amount;
+
+        let mut ticks = 0;
+        if self.acc.abs() >= self.tick {
+            let clamped = self.acc.clamp(-127. * self.tick, 127. * self.tick);
+            ticks = (clamped as i16 / self.tick as i16) as i8;
+            self.acc %= self.tick;
+        }
+
+        ticks
+    }
+
+    pub fn reset(&mut self) {
+        self.last = 0.;
+        self.acc = 0.;
+    }
+}
@@ -0,0 +1,231 @@
+use std::time::Duration;
+
+use smithay::input::pointer::{
+    AxisFrame, ButtonEvent, CursorImageStatus, GestureHoldBeginEvent, GestureHoldEndEvent,
+    GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent, GestureSwipeBeginEvent,
+    GestureSwipeEndEvent, GestureSwipeUpdateEvent, GrabStartData as PointerGrabStartData,
+    MotionEvent, PointerGrab, PointerInnerHandle, RelativeMotionEvent,
+};
+use smithay::input::SeatHandler;
+use smithay::output::Output;
+use smithay::utils::{Logical, Point};
+
+use crate::niri::State;
+
+pub struct SpatialMovementGrab {
+    start_data: PointerGrabStartData<State>,
+    last_location: Point<f64, Logical>,
+    output: Output,
+    gesture: GestureState,
+}
+
+#[derive(Debug, Clone, Copy)]
+enum GestureState {
+    Recognizing,
+    ViewOffset,
+    WorkspaceSwitch,
+}
+
+impl SpatialMovementGrab {
+    pub fn new(start_data: PointerGrabStartData<State>, output: Output) -> Self {
+        Self {
+            last_location: start_data.location,
+            start_data,
+            output,
+            gesture: GestureState::Recognizing,
+        }
+    }
+
+    fn on_ungrab(&mut self, state: &mut State) {
+        let layout = &mut state.niri.layout;
+        let res = match self.gesture {
+            GestureState::Recognizing => None,
+            GestureState::ViewOffset => layout.view_offset_gesture_end(false, Some(false)),
+            GestureState::WorkspaceSwitch => {
+                layout.workspace_switch_gesture_end(false, Some(false))
+            }
+        };
+
+        if let Some(output) = res {
+            state.niri.queue_redraw(&output);
+        }
+
+        state.niri.pointer_grab_ongoing = false;
+        state
+            .niri
+            .cursor_manager
+            .set_cursor_image(CursorImageStatus::default_named());
+    }
+}
+
+impl PointerGrab<State> for SpatialMovementGrab {
+    fn motion(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        _focus: Option<(<State as SeatHandler>::PointerFocus, Point<f64, Logical>)>,
+        event: &MotionEvent,
+    ) {
+        // While the grab is active, no client has pointer focus.
+        handle.motion(data, None, event);
+
+        let timestamp = Duration::from_millis(u64::from(event.time));
+        let delta = event.location - self.last_location;
+        self.last_location = event.location;
+
+        let layout = &mut data.niri.layout;
+        let res = match self.gesture {
+            GestureState::Recognizing => {
+                let c = event.location - self.start_data.location;
+
+                // Check if the gesture moved far enough to decide. Threshold copied from GTK 4.
+                if c.x * c.x + c.y * c.y >= 8. * 8. {
+                    if c.x.abs() > c.y.abs() {
+                        self.gesture = GestureState::ViewOffset;
+                        layout.view_offset_gesture_begin(&self.output, false);
+                        layout.view_offset_gesture_update(-c.x, timestamp, false)
+                    } else {
+                        self.gesture = GestureState::WorkspaceSwitch;
+                        layout.workspace_switch_gesture_begin(&self.output, false);
+                        layout.workspace_switch_gesture_update(-c.y, timestamp, false)
+                    }
+                } else {
+                    Some(None)
+                }
+            }
+            GestureState::ViewOffset => {
+                layout.view_offset_gesture_update(-delta.x, timestamp, false)
+            }
+            GestureState::WorkspaceSwitch => {
+                layout.workspace_switch_gesture_update(-delta.y, timestamp, false)
+            }
+        };
+
+        if let Some(output) = res {
+            if let Some(output) = output {
+                data.niri.queue_redraw(&output);
+            }
+        } else {
+            // The resize is no longer ongoing.
+            handle.unset_grab(self, data, event.serial, event.time, true);
+        }
+    }
+
+    fn relative_motion(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        _focus: Option<(<State as SeatHandler>::PointerFocus, Point<f64, Logical>)>,
+        event: &RelativeMotionEvent,
+    ) {
+        // While the grab is active, no client has pointer focus.
+        handle.relative_motion(data, None, event);
+    }
+
+    fn button(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &ButtonEvent,
+    ) {
+        handle.button(data, event);
+
+        if handle.current_pressed().is_empty() {
+            // No more buttons are pressed, release the grab.
+            handle.unset_grab(self, data, event.serial, event.time, true);
+        }
+    }
+
+    fn axis(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        details: AxisFrame,
+    ) {
+        handle.axis(data, details);
+    }
+
+    fn frame(&mut self, data: &mut State, handle: &mut PointerInnerHandle<'_, State>) {
+        handle.frame(data);
+    }
+
+    fn gesture_swipe_begin(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureSwipeBeginEvent,
+    ) {
+        handle.gesture_swipe_begin(data, event);
+    }
+
+    fn gesture_swipe_update(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureSwipeUpdateEvent,
+    ) {
+        handle.gesture_swipe_update(data, event);
+    }
+
+    fn gesture_swipe_end(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureSwipeEndEvent,
+    ) {
+        handle.gesture_swipe_end(data, event);
+    }
+
+    fn gesture_pinch_begin(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GesturePinchBeginEvent,
+    ) {
+        handle.gesture_pinch_begin(data, event);
+    }
+
+    fn gesture_pinch_update(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GesturePinchUpdateEvent,
+    ) {
+        handle.gesture_pinch_update(data, event);
+    }
+
+    fn gesture_pinch_end(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GesturePinchEndEvent,
+    ) {
+        handle.gesture_pinch_end(data, event);
+    }
+
+    fn gesture_hold_begin(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureHoldBeginEvent,
+    ) {
+        handle.gesture_hold_begin(data, event);
+    }
+
+    fn gesture_hold_end(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureHoldEndEvent,
+    ) {
+        handle.gesture_hold_end(data, event);
+    }
+
+    fn start_data(&self) -> &PointerGrabStartData<State> {
+        &self.start_data
+    }
+
+    fn unset(&mut self, data: &mut State) {
+        self.on_ungrab(data);
+    }
+}
@@ -0,0 +1,87 @@
+use std::collections::VecDeque;
+use std::time::Duration;
+
+const HISTORY_LIMIT: Duration = Duration::from_millis(150);
+const DECELERATION_TOUCHPAD: f64 = 0.997;
+
+#[derive(Debug)]
+pub struct SwipeTracker {
+    history: VecDeque<Event>,
+    pos: f64,
+}
+
+#[derive(Debug, Clone, Copy)]
+struct Event {
+    delta: f64,
+    timestamp: Duration,
+}
+
+impl SwipeTracker {
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Self {
+        Self {
+            history: VecDeque::new(),
+            pos: 0.,
+        }
+    }
+
+    /// Pushes a new reading into the tracker.
+    pub fn push(&mut self, delta: f64, timestamp: Duration) {
+        // For the events that we care about, timestamps should always increase
+        // monotonically.
+        if let Some(last) = self.history.back() {
+            if timestamp < last.timestamp {
+                trace!(
+                    "ignoring event with timestamp {timestamp:?} earlier than last {:?}",
+                    last.timestamp
+                );
+                return;
+            }
+        }
+
+        self.history.push_back(Event { delta, timestamp });
+        self.pos += delta;
+
+        self.trim_history();
+    }
+
+    /// Returns the current gesture position.
+    pub fn pos(&self) -> f64 {
+        self.pos
+    }
+
+    /// Computes the current gesture velocity.
+    pub fn velocity(&self) -> f64 {
+        let (Some(first), Some(last)) = (self.history.front(), self.history.back()) else {
+            return 0.;
+        };
+
+        let total_time = (last.timestamp - first.timestamp).as_secs_f64();
+        if total_time == 0. {
+            return 0.;
+        }
+
+        let total_delta = self.history.iter().map(|event| event.delta).sum::<f64>();
+        total_delta / total_time
+    }
+
+    /// Computes the gesture end position after decelerating to a halt.
+    pub fn projected_end_pos(&self) -> f64 {
+        let vel = self.velocity();
+        self.pos - vel / (1000. * DECELERATION_TOUCHPAD.ln())
+    }
+
+    fn trim_history(&mut self) {
+        let Some(&Event { timestamp, .. }) = self.history.back() else {
+            return;
+        };
+
+        while let Some(first) = self.history.front() {
+            if timestamp <= first.timestamp + HISTORY_LIMIT {
+                break;
+            }
+
+            let _ = self.history.pop_front();
+        }
+    }
+}
@@ -0,0 +1,136 @@
+use smithay::desktop::Window;
+use smithay::input::touch::{
+    DownEvent, GrabStartData as TouchGrabStartData, MotionEvent, OrientationEvent, ShapeEvent,
+    TouchGrab, TouchInnerHandle, UpEvent,
+};
+use smithay::input::SeatHandler;
+use smithay::utils::{IsAlive, Logical, Point, Serial};
+
+use crate::niri::State;
+
+pub struct TouchMoveGrab {
+    start_data: TouchGrabStartData<State>,
+    last_location: Point<f64, Logical>,
+    window: Window,
+}
+
+impl TouchMoveGrab {
+    pub fn new(start_data: TouchGrabStartData<State>, window: Window) -> Self {
+        Self {
+            last_location: start_data.location,
+            start_data,
+            window,
+        }
+    }
+
+    fn on_ungrab(&mut self, state: &mut State) {
+        state.niri.layout.interactive_move_end(&self.window);
+        // FIXME: only redraw the window output.
+        state.niri.queue_redraw_all();
+    }
+}
+
+impl TouchGrab<State> for TouchMoveGrab {
+    fn down(
+        &mut self,
+        data: &mut State,
+        handle: &mut TouchInnerHandle<'_, State>,
+        _focus: Option<(<State as SeatHandler>::TouchFocus, Point<f64, Logical>)>,
+        event: &DownEvent,
+        seq: Serial,
+    ) {
+        handle.down(data, None, event, seq);
+    }
+
+    fn up(
+        &mut self,
+        data: &mut State,
+        handle: &mut TouchInnerHandle<'_, State>,
+        event: &UpEvent,
+        seq: Serial,
+    ) {
+        handle.up(data, event, seq);
+
+        if event.slot != self.start_data.slot {
+            return;
+        }
+
+        handle.unset_grab(self, data);
+    }
+
+    fn motion(
+        &mut self,
+        data: &mut State,
+        handle: &mut TouchInnerHandle<'_, State>,
+        _focus: Option<(<State as SeatHandler>::TouchFocus, Point<f64, Logical>)>,
+        event: &MotionEvent,
+        seq: Serial,
+    ) {
+        handle.motion(data, None, event, seq);
+
+        if event.slot != self.start_data.slot {
+            return;
+        }
+
+        if self.window.alive() {
+            if let Some((output, pos_within_output)) = data.niri.output_under(event.location) {
+                let output = output.clone();
+                let event_delta = event.location - self.last_location;
+                self.last_location = event.location;
+                let ongoing = data.niri.layout.interactive_move_update(
+                    &self.window,
+                    event_delta,
+                    output,
+                    pos_within_output,
+                );
+                if ongoing {
+                    // FIXME: only redraw the previous and the new output.
+                    data.niri.queue_redraw_all();
+                    return;
+                }
+            } else {
+                return;
+            }
+        }
+
+        // The move is no longer ongoing.
+        handle.unset_grab(self, data);
+    }
+
+    fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
+        handle.frame(data, seq);
+    }
+
+    fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
+        handle.cancel(data, seq);
+        handle.unset_grab(self, data);
+    }
+
+    fn shape(
+        &mut self,
+        data: &mut State,
+        handle: &mut TouchInnerHandle<'_, State>,
+        event: &ShapeEvent,
+        seq: Serial,
+    ) {
+        handle.shape(data, event, seq);
+    }
+
+    fn orientation(
+        &mut self,
+        data: &mut State,
+        handle: &mut TouchInnerHandle<'_, State>,
+        event: &OrientationEvent,
+        seq: Serial,
+    ) {
+        handle.orientation(data, event, seq);
+    }
+
+    fn start_data(&self) -> &TouchGrabStartData<State> {
+        &self.start_data
+    }
+
+    fn unset(&mut self, data: &mut State) {
+        self.on_ungrab(data);
+    }
+}
@@ -0,0 +1,119 @@
+use smithay::desktop::Window;
+use smithay::input::touch::{
+    DownEvent, GrabStartData as TouchGrabStartData, MotionEvent, OrientationEvent, ShapeEvent,
+    TouchGrab, TouchInnerHandle, UpEvent,
+};
+use smithay::input::SeatHandler;
+use smithay::utils::{IsAlive, Logical, Point, Serial};
+
+use crate::niri::State;
+
+pub struct TouchResizeGrab {
+    start_data: TouchGrabStartData<State>,
+    window: Window,
+}
+
+impl TouchResizeGrab {
+    pub fn new(start_data: TouchGrabStartData<State>, window: Window) -> Self {
+        Self { start_data, window }
+    }
+
+    fn on_ungrab(&mut self, state: &mut State) {
+        state.niri.layout.interactive_resize_end(&self.window);
+    }
+}
+
+impl TouchGrab<State> for TouchResizeGrab {
+    fn down(
+        &mut self,
+        data: &mut State,
+        handle: &mut TouchInnerHandle<'_, State>,
+        _focus: Option<(<State as SeatHandler>::TouchFocus, Point<f64, Logical>)>,
+        event: &DownEvent,
+        seq: Serial,
+    ) {
+        handle.down(data, None, event, seq);
+    }
+
+    fn up(
+        &mut self,
+        data: &mut State,
+        handle: &mut TouchInnerHandle<'_, State>,
+        event: &UpEvent,
+        seq: Serial,
+    ) {
+        handle.up(data, event, seq);
+
+        if event.slot != self.start_data.slot {
+            return;
+        }
+
+        handle.unset_grab(self, data);
+    }
+
+    fn motion(
+        &mut self,
+        data: &mut State,
+        handle: &mut TouchInnerHandle<'_, State>,
+        _focus: Option<(<State as SeatHandler>::TouchFocus, Point<f64, Logical>)>,
+        event: &MotionEvent,
+        seq: Serial,
+    ) {
+        handle.motion(data, None, event, seq);
+
+        if event.slot != self.start_data.slot {
+            return;
+        }
+
+        if self.window.alive() {
+            let delta = event.location - self.start_data.location;
+            let ongoing = data
+                .niri
+                .layout
+                .interactive_resize_update(&self.window, delta);
+            if ongoing {
+                return;
+            }
+        }
+
+        // The resize is no longer ongoing.
+        handle.unset_grab(self, data);
+    }
+
+    fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
+        handle.frame(data, seq);
+    }
+
+    fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
+        handle.cancel(data, seq);
+        handle.unset_grab(self, data);
+    }
+
+    fn shape(
+        &mut self,
+        data: &mut State,
+        handle: &mut TouchInnerHandle<'_, State>,
+        event: &ShapeEvent,
+        seq: Serial,
+    ) {
+        handle.shape(data, event, seq);
+    }
+
+    fn orientation(
+        &mut self,
+        data: &mut State,
+        handle: &mut TouchInnerHandle<'_, State>,
+        event: &OrientationEvent,
+        seq: Serial,
+    ) {
+        handle.orientation(data, event, seq);
+    }
+
+    fn start_data(&self) -> &TouchGrabStartData<State> {
+        &self.start_data
+    }
+
+    fn unset(&mut self, data: &mut State) {
+        self.on_ungrab(data);
+    }
+}
@@ -1,48 +1,114 @@
-use std::env;
-use std::io::{Read, Write};
-use std::net::Shutdown;
-use std::os::unix::net::UnixStream;
-
 use anyhow::{anyhow, bail, Context};
-use niri_ipc::{Mode, Output, Reply, Request, Response};
+use niri_config::OutputName;
+use niri_ipc::socket::Socket;
+use niri_ipc::{
+    Event, KeyboardLayouts, LogicalOutput, Mode, Output, OutputConfigChanged, Request, Response,
+    Transform, Window,
+};
+use serde_json::json;

 use crate::cli::Msg;
+use crate::utils::version;

 pub fn handle_msg(msg: Msg, json: bool) -> anyhow::Result<()> {
-    let socket_path = env::var_os(niri_ipc::SOCKET_PATH_ENV).with_context(|| {
-        format!(
-            "{} is not set, are you running this within niri?",
-            niri_ipc::SOCKET_PATH_ENV
-        )
+    let request = match &msg {
+        Msg::Version => Request::Version,
+        Msg::Outputs => Request::Outputs,
+        Msg::FocusedWindow => Request::FocusedWindow,
+        Msg::FocusedOutput => Request::FocusedOutput,
+        Msg::Action { action } => Request::Action(action.clone()),
+        Msg::Output { output, action } => Request::Output {
+            output: output.clone(),
+            action: action.clone(),
+        },
+        Msg::Workspaces => Request::Workspaces,
+        Msg::Windows => Request::Windows,
+        Msg::KeyboardLayouts => Request::KeyboardLayouts,
+        Msg::EventStream => Request::EventStream,
+        Msg::RequestError => Request::ReturnError,
+    };
+
+    let socket = Socket::connect().context("error connecting to the niri socket")?;
+
+    let (reply, mut read_event) = socket
+        .send(request)
+        .context("error communicating with niri")?;
+
+    let compositor_version = match reply {
+        Err(_) if !matches!(msg, Msg::Version) => {
+            // If we got an error, it might be that the CLI is a different version from the running
+            // niri instance. Request the running instance version to compare and print a message.
+            Socket::connect()
+                .and_then(|socket| socket.send(Request::Version))
+                .ok()
+                .map(|(reply, _read_event)| reply)
+        }
+        _ => None,
+    };
+
+    // Default SIGPIPE so that our prints don't panic on stdout closing.
+    unsafe {
+        libc::signal(libc::SIGPIPE, libc::SIG_DFL);
+    }
+
+    let response = reply.map_err(|err_msg| {
+        // Check for CLI-server version mismatch to add helpful context.
+        match compositor_version {
+            Some(Ok(Response::Version(compositor_version))) => {
+                let cli_version = version();
+                if cli_version != compositor_version {
+                    eprintln!("Running niri compositor has a different version from the niri CLI:");
+                    eprintln!("Compositor version: {compositor_version}");
+                    eprintln!("CLI version:        {cli_version}");
+                    eprintln!("Did you forget to restart niri after an update?");
+                    eprintln!();
+                }
+            }
+            Some(_) => {
+                eprintln!("Unable to get the running niri compositor version.");
+                eprintln!("Did you forget to restart niri after an update?");
+                eprintln!();
+            }
+            None => {
+                // Communication error, or the original request was already a version request.
+                // Don't add irrelevant context.
+            }
+        }
+
+        anyhow!(err_msg).context("niri returned an error")
    })?;

-    let mut stream =
-        UnixStream::connect(socket_path).context("error connecting to {socket_path}")?;
-
-    let request = match &msg {
-        Msg::Outputs => Request::Outputs,
-        Msg::Action { action } => Request::Action(action.clone()),
-    };
-    let mut buf = serde_json::to_vec(&request).unwrap();
-    stream
-        .write_all(&buf)
-        .context("error writing IPC request")?;
-    stream
-        .shutdown(Shutdown::Write)
-        .context("error closing IPC stream for writing")?;
-
-    buf.clear();
-    stream
-        .read_to_end(&mut buf)
-        .context("error reading IPC response")?;
-
-    let reply: Reply = serde_json::from_slice(&buf).context("error parsing IPC reply")?;
-
-    let response = reply
-        .map_err(|msg| anyhow!(msg))
-        .context("niri could not handle the request")?;
-
    match msg {
+        Msg::RequestError => {
+            bail!("unexpected response: expected an error, got {response:?}");
+        }
+        Msg::Version => {
+            let Response::Version(compositor_version) = response else {
+                bail!("unexpected response: expected Version, got {response:?}");
+            };
+
+            let cli_version = version();
+
+            if json {
+                println!(
+                    "{}",
+                    json!({
+                        "compositor": compositor_version,
+                        "cli": cli_version,
+                    })
+                );
+                return Ok(());
+            }
+
+            if cli_version != compositor_version {
+                eprintln!("Running niri compositor has a different version from the niri CLI.");
+                eprintln!("Did you forget to restart niri after an update?");
+                eprintln!();
+            }
+
+            println!("Compositor version: {compositor_version}");
+            println!("CLI version:        {cli_version}");
+        }
        Msg::Outputs => {
            let Response::Outputs(outputs) = response else {
                bail!("unexpected response: expected Outputs, got {response:?}");
@@ -55,61 +121,337 @@ pub fn handle_msg(msg: Msg, json: bool) -> anyhow::Result<()> {
                return Ok(());
            }

-            let mut outputs = outputs.into_iter().collect::<Vec<_>>();
-            outputs.sort_unstable_by(|a, b| a.0.cmp(&b.0));
+            let mut outputs = outputs
+                .into_values()
+                .map(|out| (OutputName::from_ipc_output(&out), out))
+                .collect::<Vec<_>>();
+            outputs.sort_unstable_by(|a, b| a.0.compare(&b.0));

-            for (connector, output) in outputs.into_iter() {
-                let Output {
-                    name,
-                    make,
-                    model,
-                    physical_size,
-                    modes,
-                    current_mode,
-                } = output;
-
-                println!(r#"Output "{connector}" ({make} - {model} - {name})"#);
-
-                if let Some(current) = current_mode {
-                    let mode = *modes
-                        .get(current)
-                        .context("invalid response: current mode does not exist")?;
-                    let Mode {
-                        width,
-                        height,
-                        refresh_rate,
-                    } = mode;
-                    let refresh = refresh_rate as f64 / 1000.;
-                    println!("  Current mode: {width}x{height} @ {refresh:.3} Hz");
-                } else {
-                    println!("  Disabled");
-                }
-
-                if let Some((width, height)) = physical_size {
-                    println!("  Physical size: {width}x{height} mm");
-                } else {
-                    println!("  Physical size: unknown");
-                }
-
-                println!("  Available modes:");
-                for mode in modes {
-                    let Mode {
-                        width,
-                        height,
-                        refresh_rate,
-                    } = mode;
-                    let refresh = refresh_rate as f64 / 1000.;
-                    println!("    {width}x{height}@{refresh:.3}");
-                }
+            for (_name, output) in outputs.into_iter() {
+                print_output(output)?;
                println!();
            }
        }
+        Msg::FocusedWindow => {
+            let Response::FocusedWindow(window) = response else {
+                bail!("unexpected response: expected FocusedWindow, got {response:?}");
+            };
+
+            if json {
+                let window = serde_json::to_string(&window).context("error formatting response")?;
+                println!("{window}");
+                return Ok(());
+            }
+
+            if let Some(window) = window {
+                print_window(&window);
+            } else {
+                println!("No window is focused.");
+            }
+        }
+        Msg::Windows => {
+            let Response::Windows(mut windows) = response else {
+                bail!("unexpected response: expected Windows, got {response:?}");
+            };
+
+            if json {
+                let windows =
+                    serde_json::to_string(&windows).context("error formatting response")?;
+                println!("{windows}");
+                return Ok(());
+            }
+
+            windows.sort_unstable_by(|a, b| a.id.cmp(&b.id));
+
+            for window in windows {
+                print_window(&window);
+                println!();
+            }
+        }
+        Msg::FocusedOutput => {
+            let Response::FocusedOutput(output) = response else {
+                bail!("unexpected response: expected FocusedOutput, got {response:?}");
+            };
+
+            if json {
+                let output = serde_json::to_string(&output).context("error formatting response")?;
+                println!("{output}");
+                return Ok(());
+            }
+
+            if let Some(output) = output {
+                print_output(output)?;
+            } else {
+                println!("No output is focused.");
+            }
+        }
        Msg::Action { .. } => {
            let Response::Handled = response else {
                bail!("unexpected response: expected Handled, got {response:?}");
            };
        }
+        Msg::Output { output, .. } => {
+            let Response::OutputConfigChanged(response) = response else {
+                bail!("unexpected response: expected OutputConfigChanged, got {response:?}");
+            };
+
+            if json {
+                let response =
+                    serde_json::to_string(&response).context("error formatting response")?;
+                println!("{response}");
+                return Ok(());
+            }
+
+            if response == OutputConfigChanged::OutputWasMissing {
+                println!("Output \"{output}\" is not connected.");
+                println!("The change will apply when it is connected.");
+            }
+        }
+        Msg::Workspaces => {
+            let Response::Workspaces(mut response) = response else {
+                bail!("unexpected response: expected Workspaces, got {response:?}");
+            };
+
+            if json {
+                let response =
+                    serde_json::to_string(&response).context("error formatting response")?;
+                println!("{response}");
+                return Ok(());
+            }
+
+            if response.is_empty() {
+                println!("No workspaces.");
+                return Ok(());
+            }
+
+            response.sort_by_key(|ws| ws.idx);
+            response.sort_by(|a, b| a.output.cmp(&b.output));
+
+            let mut current_output = if let Some(output) = response[0].output.as_deref() {
+                println!("Output \"{output}\":");
+                Some(output)
+            } else {
+                println!("No output:");
+                None
+            };
+
+            for ws in &response {
+                if ws.output.as_deref() != current_output {
+                    let output = ws.output.as_deref().context(
+                        "invalid response: workspace with no output \
+                         following a workspace with an output",
+                    )?;
+                    current_output = Some(output);
+                    println!("\nOutput \"{output}\":");
+                }
+
+                let is_active = if ws.is_active { " * " } else { "   " };
+                let idx = ws.idx;
+                let name = if let Some(name) = ws.name.as_deref() {
+                    format!(" \"{name}\"")
+                } else {
+                    String::new()
+                };
+                println!("{is_active}{idx}{name}");
+            }
+        }
+        Msg::KeyboardLayouts => {
+            let Response::KeyboardLayouts(response) = response else {
+                bail!("unexpected response: expected KeyboardLayouts, got {response:?}");
+            };
+
+            if json {
+                let response =
+                    serde_json::to_string(&response).context("error formatting response")?;
+                println!("{response}");
+                return Ok(());
+            }
+
+            let KeyboardLayouts { names, current_idx } = response;
+            let current_idx = usize::from(current_idx);
+
+            println!("Keyboard layouts:");
+            for (idx, name) in names.iter().enumerate() {
+                let is_active = if idx == current_idx { " * " } else { "   " };
+                println!("{is_active}{idx} {name}");
+            }
+        }
+        Msg::EventStream => {
+            let Response::Handled = response else {
+                bail!("unexpected response: expected Handled, got {response:?}");
+            };
+
+            if !json {
+                println!("Started reading events.");
+            }
+
+            loop {
+                let event = read_event().context("error reading event from niri")?;
+
+                if json {
+                    let event = serde_json::to_string(&event).context("error formatting event")?;
+                    println!("{event}");
+                    continue;
+                }
+
+                match event {
+                    Event::WorkspacesChanged { workspaces } => {
+                        println!("Workspaces changed: {workspaces:?}");
+                    }
+                    Event::WorkspaceActivated { id, focused } => {
+                        let word = if focused { "focused" } else { "activated" };
+                        println!("Workspace {word}: {id}");
+                    }
+                    Event::WorkspaceActiveWindowChanged {
+                        workspace_id,
+                        active_window_id,
+                    } => {
+                        println!(
+                            "Workspace {workspace_id}: \
+                             active window changed to {active_window_id:?}"
+                        );
+                    }
+                    Event::WindowsChanged { windows } => {
+                        println!("Windows changed: {windows:?}");
+                    }
+                    Event::WindowOpenedOrChanged { window } => {
+                        println!("Window opened or changed: {window:?}");
+                    }
+                    Event::WindowClosed { id } => {
+                        println!("Window closed: {id}");
+                    }
+                    Event::WindowFocusChanged { id } => {
+                        println!("Window focus changed: {id:?}");
+                    }
+                    Event::KeyboardLayoutsChanged { keyboard_layouts } => {
+                        println!("Keyboard layouts changed: {keyboard_layouts:?}");
+                    }
+                    Event::KeyboardLayoutSwitched { idx } => {
+                        println!("Keyboard layout switched: {idx}");
+                    }
+                }
+            }
+        }
    }

    Ok(())
 }
+
+fn print_output(output: Output) -> anyhow::Result<()> {
+    let Output {
+        name,
+        make,
+        model,
+        serial,
+        physical_size,
+        modes,
+        current_mode,
+        vrr_supported,
+        vrr_enabled,
+        logical,
+    } = output;
+
+    let serial = serial.as_deref().unwrap_or("Unknown");
+    println!(r#"Output "{make} {model} {serial}" ({name})"#);
+
+    if let Some(current) = current_mode {
+        let mode = *modes
+            .get(current)
+            .context("invalid response: current mode does not exist")?;
+        let Mode {
+            width,
+            height,
+            refresh_rate,
+            is_preferred,
+        } = mode;
+        let refresh = refresh_rate as f64 / 1000.;
+        let preferred = if is_preferred { " (preferred)" } else { "" };
+        println!("  Current mode: {width}x{height} @ {refresh:.3} Hz{preferred}");
+    } else {
+        println!("  Disabled");
+    }
+
+    if vrr_supported {
+        let enabled = if vrr_enabled { "enabled" } else { "disabled" };
+        println!("  Variable refresh rate: supported, {enabled}");
+    } else {
+        println!("  Variable refresh rate: not supported");
+    }
+
+    if let Some((width, height)) = physical_size {
+        println!("  Physical size: {width}x{height} mm");
+    } else {
+        println!("  Physical size: unknown");
+    }
+
+    if let Some(logical) = logical {
+        let LogicalOutput {
+            x,
+            y,
+            width,
+            height,
+            scale,
+            transform,
+        } = logical;
+        println!("  Logical position: {x}, {y}");
+        println!("  Logical size: {width}x{height}");
+        println!("  Scale: {scale}");
+
+        let transform = match transform {
+            Transform::Normal => "normal",
+            Transform::_90 => "90° counter-clockwise",
+            Transform::_180 => "180°",
+            Transform::_270 => "270° counter-clockwise",
+            Transform::Flipped => "flipped horizontally",
+            Transform::Flipped90 => "90° counter-clockwise, flipped horizontally",
+            Transform::Flipped180 => "flipped vertically",
+            Transform::Flipped270 => "270° counter-clockwise, flipped horizontally",
+        };
+        println!("  Transform: {transform}");
+    }
+
+    println!("  Available modes:");
+    for (idx, mode) in modes.into_iter().enumerate() {
+        let Mode {
+            width,
+            height,
+            refresh_rate,
+            is_preferred,
+        } = mode;
+        let refresh = refresh_rate as f64 / 1000.;
+
+        let is_current = Some(idx) == current_mode;
+        let qualifier = match (is_current, is_preferred) {
+            (true, true) => " (current, preferred)",
+            (true, false) => " (current)",
+            (false, true) => " (preferred)",
+            (false, false) => "",
+        };
+
+        println!("    {width}x{height}@{refresh:.3}{qualifier}");
+    }
+    Ok(())
+}
+
+fn print_window(window: &Window) {
+    let focused = if window.is_focused { " (focused)" } else { "" };
+    println!("Window ID {}:{focused}", window.id);
+
+    if let Some(title) = &window.title {
+        println!("  Title: \"{title}\"");
+    } else {
+        println!("  Title: (unset)");
+    }
+
+    if let Some(app_id) = &window.app_id {
+        println!("  App ID: \"{app_id}\"");
+    } else {
+        println!("  App ID: (unset)");
+    }
+
+    if let Some(workspace_id) = window.workspace_id {
+        println!("  Workspace ID: {workspace_id}");
+    } else {
+        println!("  Workspace ID: (none)");
+    }
+}
@@ -1,29 +1,60 @@
 use std::cell::RefCell;
-use std::collections::HashMap;
+use std::collections::HashSet;
 use std::os::unix::net::{UnixListener, UnixStream};
 use std::path::PathBuf;
 use std::rc::Rc;
+use std::sync::{Arc, Mutex};
 use std::{env, io, process};

 use anyhow::Context;
+use async_channel::{Receiver, Sender, TrySendError};
+use calloop::futures::Scheduler;
 use calloop::io::Async;
 use directories::BaseDirs;
 use futures_util::io::{AsyncReadExt, BufReader};
-use futures_util::{AsyncBufReadExt, AsyncWriteExt};
-use niri_ipc::{Request, Response};
+use futures_util::{select_biased, AsyncBufReadExt, AsyncWrite, AsyncWriteExt, FutureExt as _};
+use niri_config::OutputName;
+use niri_ipc::state::{EventStreamState, EventStreamStatePart as _};
+use niri_ipc::{Event, KeyboardLayouts, OutputConfigChanged, Reply, Request, Response, Workspace};
 use smithay::reexports::calloop::generic::Generic;
 use smithay::reexports::calloop::{Interest, LoopHandle, Mode, PostAction};
 use smithay::reexports::rustix::fs::unlink;
+use smithay::wayland::compositor::with_states;
+use smithay::wayland::shell::xdg::XdgToplevelSurfaceData;

+use crate::backend::IpcOutputMap;
+use crate::layout::workspace::WorkspaceId;
 use crate::niri::State;
+use crate::utils::version;
+use crate::window::Mapped;
+
+// If an event stream client fails to read events fast enough that we accumulate more than this
+// number in our buffer, we drop that event stream client.
+const EVENT_STREAM_BUFFER_SIZE: usize = 64;

 pub struct IpcServer {
    pub socket_path: PathBuf,
+    event_streams: Rc<RefCell<Vec<EventStreamSender>>>,
+    event_stream_state: Rc<RefCell<EventStreamState>>,
 }

 struct ClientCtx {
    event_loop: LoopHandle<'static, State>,
-    ipc_outputs: Rc<RefCell<HashMap<String, niri_ipc::Output>>>,
+    scheduler: Scheduler<()>,
+    ipc_outputs: Arc<Mutex<IpcOutputMap>>,
+    event_streams: Rc<RefCell<Vec<EventStreamSender>>>,
+    event_stream_state: Rc<RefCell<EventStreamState>>,
+}
+
+struct EventStreamClient {
+    events: Receiver<Event>,
+    disconnect: Receiver<()>,
+    write: Box<dyn AsyncWrite + Unpin>,
+}
+
+struct EventStreamSender {
+    events: Sender<Event>,
+    disconnect: Sender<()>,
 }

 impl IpcServer {
@@ -55,7 +86,34 @@ impl IpcServer {
            })
            .unwrap();

-        Ok(Self { socket_path })
+        Ok(Self {
+            socket_path,
+            event_streams: Rc::new(RefCell::new(Vec::new())),
+            event_stream_state: Rc::new(RefCell::new(EventStreamState::default())),
+        })
+    }
+
+    fn send_event(&self, event: Event) {
+        let mut streams = self.event_streams.borrow_mut();
+        let mut to_remove = Vec::new();
+        for (idx, stream) in streams.iter_mut().enumerate() {
+            match stream.events.try_send(event.clone()) {
+                Ok(()) => (),
+                Err(TrySendError::Closed(_)) => to_remove.push(idx),
+                Err(TrySendError::Full(_)) => {
+                    warn!(
+                        "disconnecting IPC event stream client \
+                         because it is reading events too slowly"
+                    );
+                    to_remove.push(idx);
+                }
+            }
+        }
+
+        for idx in to_remove.into_iter().rev() {
+            let stream = streams.swap_remove(idx);
+            let _ = stream.disconnect.send_blocking(());
+        }
    }
 }

@@ -85,9 +143,14 @@ fn on_new_ipc_client(state: &mut State, stream: UnixStream) {
        }
    };

+    let ipc_server = state.niri.ipc_server.as_ref().unwrap();
+
    let ctx = ClientCtx {
        event_loop: state.niri.event_loop.clone(),
+        scheduler: state.niri.scheduler.clone(),
        ipc_outputs: state.backend.ipc_outputs(),
+        event_streams: ipc_server.event_streams.clone(),
+        event_stream_state: ipc_server.event_stream_state.clone(),
    };

    let future = async move {
@@ -100,7 +163,7 @@ fn on_new_ipc_client(state: &mut State, stream: UnixStream) {
    }
 }

-async fn handle_client(ctx: ClientCtx, stream: Async<'_, UnixStream>) -> anyhow::Result<()> {
+async fn handle_client(ctx: ClientCtx, stream: Async<'static, UnixStream>) -> anyhow::Result<()> {
    let (read, mut write) = stream.split();
    let mut buf = String::new();

@@ -110,33 +173,436 @@ async fn handle_client(ctx: ClientCtx, stream: Async<'_, UnixStream>) -> anyhow:
        .await
        .context("error reading request")?;

-    let reply = process(&ctx, &buf).map_err(|err| {
-        warn!("error processing IPC request: {err:?}");
-        err.to_string()
-    });
+    let request = serde_json::from_str(&buf)
+        .context("error parsing request")
+        .map_err(|err| err.to_string());
+    let requested_error = matches!(request, Ok(Request::ReturnError));
+    let requested_event_stream = matches!(request, Ok(Request::EventStream));

-    let buf = serde_json::to_vec(&reply).context("error formatting reply")?;
+    let reply = match request {
+        Ok(request) => process(&ctx, request).await,
+        Err(err) => Err(err),
+    };
+
+    if let Err(err) = &reply {
+        if !requested_error {
+            warn!("error processing IPC request: {err:?}");
+        }
+    }
+
+    let mut buf = serde_json::to_vec(&reply).context("error formatting reply")?;
+    buf.push(b'\n');
    write.write_all(&buf).await.context("error writing reply")?;

+    if requested_event_stream {
+        let (events_tx, events_rx) = async_channel::bounded(EVENT_STREAM_BUFFER_SIZE);
+        let (disconnect_tx, disconnect_rx) = async_channel::bounded(1);
+
+        // Spawn a task for the client.
+        let client = EventStreamClient {
+            events: events_rx,
+            disconnect: disconnect_rx,
+            write: Box::new(write) as _,
+        };
+        let future = async move {
+            if let Err(err) = handle_event_stream_client(client).await {
+                warn!("error handling IPC event stream client: {err:?}");
+            }
+        };
+        if let Err(err) = ctx.scheduler.schedule(future) {
+            warn!("error scheduling IPC event stream future: {err:?}");
+        }
+
+        // Send the initial state.
+        {
+            let state = ctx.event_stream_state.borrow();
+            for event in state.replicate() {
+                events_tx
+                    .try_send(event)
+                    .expect("initial event burst had more events than buffer size");
+            }
+        }
+
+        // Add it to the list.
+        {
+            let mut streams = ctx.event_streams.borrow_mut();
+            let sender = EventStreamSender {
+                events: events_tx,
+                disconnect: disconnect_tx,
+            };
+            streams.push(sender);
+        }
+    }
+
    Ok(())
 }

-fn process(ctx: &ClientCtx, buf: &str) -> anyhow::Result<Response> {
-    let request: Request = serde_json::from_str(buf).context("error parsing request")?;
-
+async fn process(ctx: &ClientCtx, request: Request) -> Reply {
    let response = match request {
+        Request::ReturnError => return Err(String::from("example compositor error")),
+        Request::Version => Response::Version(version()),
        Request::Outputs => {
-            let ipc_outputs = ctx.ipc_outputs.borrow().clone();
-            Response::Outputs(ipc_outputs)
+            let ipc_outputs = ctx.ipc_outputs.lock().unwrap().clone();
+            let outputs = ipc_outputs.values().cloned().map(|o| (o.name.clone(), o));
+            Response::Outputs(outputs.collect())
+        }
+        Request::Workspaces => {
+            let state = ctx.event_stream_state.borrow();
+            let workspaces = state.workspaces.workspaces.values().cloned().collect();
+            Response::Workspaces(workspaces)
+        }
+        Request::Windows => {
+            let state = ctx.event_stream_state.borrow();
+            let windows = state.windows.windows.values().cloned().collect();
+            Response::Windows(windows)
+        }
+        Request::KeyboardLayouts => {
+            let state = ctx.event_stream_state.borrow();
+            let layout = state.keyboard_layouts.keyboard_layouts.clone();
+            let layout = layout.expect("keyboard layouts should be set at startup");
+            Response::KeyboardLayouts(layout)
+        }
+        Request::FocusedWindow => {
+            let state = ctx.event_stream_state.borrow();
+            let windows = &state.windows.windows;
+            let window = windows.values().find(|win| win.is_focused).cloned();
+            Response::FocusedWindow(window)
        }
        Request::Action(action) => {
+            let (tx, rx) = async_channel::bounded(1);
+
            let action = niri_config::Action::from(action);
            ctx.event_loop.insert_idle(move |state| {
-                state.do_action(action);
+                state.do_action(action, false);
+                let _ = tx.send_blocking(());
            });
+
+            // Wait until the action has been processed before returning. This is important for a
+            // few actions, for instance for DoScreenTransition this wait ensures that the screen
+            // contents were sampled into the texture.
+            let _ = rx.recv().await;
            Response::Handled
        }
+        Request::Output { output, action } => {
+            let ipc_outputs = ctx.ipc_outputs.lock().unwrap();
+            let found = ipc_outputs
+                .values()
+                .any(|o| OutputName::from_ipc_output(o).matches(&output));
+            let response = if found {
+                OutputConfigChanged::Applied
+            } else {
+                OutputConfigChanged::OutputWasMissing
+            };
+            drop(ipc_outputs);
+
+            ctx.event_loop.insert_idle(move |state| {
+                state.apply_transient_output_config(&output, action);
+            });
+
+            Response::OutputConfigChanged(response)
+        }
+        Request::FocusedOutput => {
+            let (tx, rx) = async_channel::bounded(1);
+            ctx.event_loop.insert_idle(move |state| {
+                let active_output = state
+                    .niri
+                    .layout
+                    .active_output()
+                    .map(|output| output.name());
+
+                let output = active_output.and_then(|active_output| {
+                    state
+                        .backend
+                        .ipc_outputs()
+                        .lock()
+                        .unwrap()
+                        .values()
+                        .find(|o| o.name == active_output)
+                        .cloned()
+                });
+
+                let _ = tx.send_blocking(output);
+            });
+            let result = rx.recv().await;
+            let output = result.map_err(|_| String::from("error getting active output info"))?;
+            Response::FocusedOutput(output)
+        }
+        Request::EventStream => Response::Handled,
    };

    Ok(response)
 }
+
+async fn handle_event_stream_client(client: EventStreamClient) -> anyhow::Result<()> {
+    let EventStreamClient {
+        events,
+        disconnect,
+        mut write,
+    } = client;
+
+    while let Ok(event) = events.recv().await {
+        let mut buf = serde_json::to_vec(&event).context("error formatting event")?;
+        buf.push(b'\n');
+
+        let res = select_biased! {
+            _ = disconnect.recv().fuse() => return Ok(()),
+            res = write.write_all(&buf).fuse() => res,
+        };
+
+        match res {
+            Ok(()) => (),
+            // Normal client disconnection.
+            Err(err) if err.kind() == io::ErrorKind::BrokenPipe => return Ok(()),
+            res @ Err(_) => res.context("error writing event")?,
+        }
+    }
+
+    Ok(())
+}
+
+fn make_ipc_window(mapped: &Mapped, workspace_id: Option<WorkspaceId>) -> niri_ipc::Window {
+    let wl_surface = mapped.toplevel().wl_surface();
+    with_states(wl_surface, |states| {
+        let role = states
+            .data_map
+            .get::<XdgToplevelSurfaceData>()
+            .unwrap()
+            .lock()
+            .unwrap();
+
+        niri_ipc::Window {
+            id: mapped.id().get(),
+            title: role.title.clone(),
+            app_id: role.app_id.clone(),
+            workspace_id: workspace_id.map(|id| id.get()),
+            is_focused: mapped.is_focused(),
+        }
+    })
+}
+
+impl State {
+    pub fn ipc_keyboard_layouts_changed(&mut self) {
+        let keyboard = self.niri.seat.get_keyboard().unwrap();
+        let keyboard_layouts = keyboard.with_xkb_state(self, |context| {
+            let xkb = context.xkb().lock().unwrap();
+            let layouts = xkb.layouts();
+            KeyboardLayouts {
+                names: layouts
+                    .map(|layout| xkb.layout_name(layout).to_owned())
+                    .collect(),
+                current_idx: xkb.active_layout().0 as u8,
+            }
+        });
+
+        let Some(server) = &self.niri.ipc_server else {
+            return;
+        };
+
+        let mut state = server.event_stream_state.borrow_mut();
+        let state = &mut state.keyboard_layouts;
+
+        let event = Event::KeyboardLayoutsChanged { keyboard_layouts };
+        state.apply(event.clone());
+        server.send_event(event);
+    }
+
+    pub fn ipc_refresh_keyboard_layout_index(&mut self) {
+        let keyboard = self.niri.seat.get_keyboard().unwrap();
+        let idx = keyboard.with_xkb_state(self, |context| {
+            let xkb = context.xkb().lock().unwrap();
+            xkb.active_layout().0 as u8
+        });
+
+        let Some(server) = &self.niri.ipc_server else {
+            return;
+        };
+
+        let mut state = server.event_stream_state.borrow_mut();
+        let state = &mut state.keyboard_layouts;
+
+        if state.keyboard_layouts.as_ref().unwrap().current_idx == idx {
+            return;
+        }
+
+        let event = Event::KeyboardLayoutSwitched { idx };
+        state.apply(event.clone());
+        server.send_event(event);
+    }
+
+    pub fn ipc_refresh_layout(&mut self) {
+        self.ipc_refresh_workspaces();
+        self.ipc_refresh_windows();
+    }
+
+    fn ipc_refresh_workspaces(&mut self) {
+        let Some(server) = &self.niri.ipc_server else {
+            return;
+        };
+
+        let _span = tracy_client::span!("State::ipc_refresh_workspaces");
+
+        let mut state = server.event_stream_state.borrow_mut();
+        let state = &mut state.workspaces;
+
+        let mut events = Vec::new();
+        let layout = &self.niri.layout;
+        let focused_ws_id = layout.active_workspace().map(|ws| ws.id().get());
+
+        // Check for workspace changes.
+        let mut seen = HashSet::new();
+        let mut need_workspaces_changed = false;
+        for (mon, ws_idx, ws) in layout.workspaces() {
+            let id = ws.id().get();
+            seen.insert(id);
+
+            let Some(ipc_ws) = state.workspaces.get(&id) else {
+                // A new workspace was added.
+                need_workspaces_changed = true;
+                break;
+            };
+
+            // Check for any changes that we can't signal as individual events.
+            let output_name = mon.map(|mon| mon.output_name());
+            if ipc_ws.idx != u8::try_from(ws_idx + 1).unwrap_or(u8::MAX)
+                || ipc_ws.name.as_ref() != ws.name()
+                || ipc_ws.output.as_ref() != output_name
+            {
+                need_workspaces_changed = true;
+                break;
+            }
+
+            let active_window_id = ws.active_window().map(|win| win.id().get());
+            if ipc_ws.active_window_id != active_window_id {
+                events.push(Event::WorkspaceActiveWindowChanged {
+                    workspace_id: id,
+                    active_window_id,
+                });
+            }
+
+            // Check if this workspace became focused.
+            let is_focused = Some(id) == focused_ws_id;
+            if is_focused && !ipc_ws.is_focused {
+                events.push(Event::WorkspaceActivated { id, focused: true });
+                continue;
+            }
+
+            // Check if this workspace became active.
+            let is_active = mon.map_or(false, |mon| mon.active_workspace_idx() == ws_idx);
+            if is_active && !ipc_ws.is_active {
+                events.push(Event::WorkspaceActivated { id, focused: false });
+            }
+        }
+
+        // Check if any workspaces were removed.
+        if !need_workspaces_changed && state.workspaces.keys().any(|id| !seen.contains(id)) {
+            need_workspaces_changed = true;
+        }
+
+        if need_workspaces_changed {
+            events.clear();
+
+            let workspaces = layout
+                .workspaces()
+                .map(|(mon, ws_idx, ws)| {
+                    let id = ws.id().get();
+                    Workspace {
+                        id,
+                        idx: u8::try_from(ws_idx + 1).unwrap_or(u8::MAX),
+                        name: ws.name().cloned(),
+                        output: mon.map(|mon| mon.output_name().clone()),
+                        is_active: mon.map_or(false, |mon| mon.active_workspace_idx() == ws_idx),
+                        is_focused: Some(id) == focused_ws_id,
+                        active_window_id: ws.active_window().map(|win| win.id().get()),
+                    }
+                })
+                .collect();
+
+            events.push(Event::WorkspacesChanged { workspaces });
+        }
+
+        for event in events {
+            state.apply(event.clone());
+            server.send_event(event);
+        }
+    }
+
+    fn ipc_refresh_windows(&mut self) {
+        let Some(server) = &self.niri.ipc_server else {
+            return;
+        };
+
+        let _span = tracy_client::span!("State::ipc_refresh_windows");
+
+        let mut state = server.event_stream_state.borrow_mut();
+        let state = &mut state.windows;
+
+        let mut events = Vec::new();
+        let layout = &self.niri.layout;
+
+        // Check for window changes.
+        let mut seen = HashSet::new();
+        let mut focused_id = None;
+        layout.with_windows(|mapped, _, ws_id| {
+            let id = mapped.id().get();
+            seen.insert(id);
+
+            if mapped.is_focused() {
+                focused_id = Some(id);
+            }
+
+            let Some(ipc_win) = state.windows.get(&id) else {
+                let window = make_ipc_window(mapped, ws_id);
+                events.push(Event::WindowOpenedOrChanged { window });
+                return;
+            };
+
+            let workspace_id = ws_id.map(|id| id.get());
+            let mut changed = ipc_win.workspace_id != workspace_id;
+
+            let wl_surface = mapped.toplevel().wl_surface();
+            changed |= with_states(wl_surface, |states| {
+                let role = states
+                    .data_map
+                    .get::<XdgToplevelSurfaceData>()
+                    .unwrap()
+                    .lock()
+                    .unwrap();
+
+                ipc_win.title != role.title || ipc_win.app_id != role.app_id
+            });
+
+            if changed {
+                let window = make_ipc_window(mapped, ws_id);
+                events.push(Event::WindowOpenedOrChanged { window });
+                return;
+            }
+
+            if mapped.is_focused() && !ipc_win.is_focused {
+                events.push(Event::WindowFocusChanged { id: Some(id) });
+            }
+        });
+
+        // Check for closed windows.
+        let mut ipc_focused_id = None;
+        for (id, ipc_win) in &state.windows {
+            if !seen.contains(id) {
+                events.push(Event::WindowClosed { id: *id });
+            }
+
+            if ipc_win.is_focused {
+                ipc_focused_id = Some(id);
+            }
+        }
+
+        // Extra check for focus becoming None, since the checks above only work for focus becoming
+        // a different window.
+        if focused_id.is_none() && ipc_focused_id.is_some() {
+            events.push(Event::WindowFocusChanged { id: None });
+        }
+
+        for event in events {
+            state.apply(event.clone());
+            server.send_event(event);
+        }
+    }
+}
@@ -0,0 +1,277 @@
+use std::collections::HashMap;
+use std::time::Duration;
+
+use anyhow::Context as _;
+use glam::{Mat3, Vec2};
+use niri_config::BlockOutFrom;
+use smithay::backend::allocator::Fourcc;
+use smithay::backend::renderer::element::utils::{
+    Relocate, RelocateRenderElement, RescaleRenderElement,
+};
+use smithay::backend::renderer::element::{Kind, RenderElement};
+use smithay::backend::renderer::gles::{GlesRenderer, GlesTexture, Uniform};
+use smithay::backend::renderer::Texture;
+use smithay::utils::{Logical, Point, Rectangle, Scale, Size, Transform};
+use smithay::wayland::compositor::{Blocker, BlockerState};
+
+use crate::animation::Animation;
+use crate::niri_render_elements;
+use crate::render_helpers::primary_gpu_texture::PrimaryGpuTextureRenderElement;
+use crate::render_helpers::shader_element::ShaderRenderElement;
+use crate::render_helpers::shaders::{mat3_uniform, ProgramType, Shaders};
+use crate::render_helpers::snapshot::RenderSnapshot;
+use crate::render_helpers::texture::{TextureBuffer, TextureRenderElement};
+use crate::render_helpers::{render_to_encompassing_texture, RenderTarget};
+use crate::utils::transaction::TransactionBlocker;
+
+#[derive(Debug)]
+pub struct ClosingWindow {
+    /// Contents of the window.
+    buffer: TextureBuffer<GlesTexture>,
+
+    /// Blocked-out contents of the window.
+    blocked_out_buffer: TextureBuffer<GlesTexture>,
+
+    /// Where the window should be blocked out from.
+    block_out_from: Option<BlockOutFrom>,
+
+    /// Size of the window geometry.
+    geo_size: Size<f64, Logical>,
+
+    /// Position in the workspace.
+    pos: Point<f64, Logical>,
+
+    /// How much the texture should be offset.
+    buffer_offset: Point<f64, Logical>,
+
+    /// How much the blocked-out texture should be offset.
+    blocked_out_buffer_offset: Point<f64, Logical>,
+
+    /// The closing animation.
+    anim_state: AnimationState,
+
+    /// Random seed for the shader.
+    random_seed: f32,
+}
+
+niri_render_elements! {
+    ClosingWindowRenderElement => {
+        Texture = RelocateRenderElement<RescaleRenderElement<PrimaryGpuTextureRenderElement>>,
+        Shader = ShaderRenderElement,
+    }
+}
+
+#[derive(Debug)]
+enum AnimationState {
+    Waiting {
+        /// Blocker for a transaction before starting the animation.
+        blocker: TransactionBlocker,
+        anim: Animation,
+    },
+    Animating(Animation),
+}
+
+impl AnimationState {
+    pub fn new(blocker: TransactionBlocker, anim: Animation) -> Self {
+        if blocker.state() == BlockerState::Pending {
+            Self::Waiting { blocker, anim }
+        } else {
+            // This actually doesn't normally happen because the window is removed only after the
+            // closing animation is created. Though, it does happen with disable-transactions debug
+            // flag.
+            Self::Animating(anim)
+        }
+    }
+}
+
+impl ClosingWindow {
+    pub fn new<E: RenderElement<GlesRenderer>>(
+        renderer: &mut GlesRenderer,
+        snapshot: RenderSnapshot<E, E>,
+        scale: Scale<f64>,
+        geo_size: Size<f64, Logical>,
+        pos: Point<f64, Logical>,
+        blocker: TransactionBlocker,
+        anim: Animation,
+    ) -> anyhow::Result<Self> {
+        let _span = tracy_client::span!("ClosingWindow::new");
+
+        let mut render_to_texture = |elements: Vec<E>| -> anyhow::Result<_> {
+            let (texture, _sync_point, geo) = render_to_encompassing_texture(
+                renderer,
+                scale,
+                Transform::Normal,
+                Fourcc::Abgr8888,
+                &elements,
+            )
+            .context("error rendering to texture")?;
+
+            let buffer = TextureBuffer::from_texture(
+                renderer,
+                texture,
+                scale,
+                Transform::Normal,
+                Vec::new(),
+            );
+
+            let offset = geo.loc.to_f64().to_logical(scale);
+
+            Ok((buffer, offset))
+        };
+
+        let (buffer, buffer_offset) =
+            render_to_texture(snapshot.contents).context("error rendering contents")?;
+        let (blocked_out_buffer, blocked_out_buffer_offset) =
+            render_to_texture(snapshot.blocked_out_contents)
+                .context("error rendering blocked-out contents")?;
+
+        Ok(Self {
+            buffer,
+            blocked_out_buffer,
+            block_out_from: snapshot.block_out_from,
+            geo_size,
+            pos,
+            buffer_offset,
+            blocked_out_buffer_offset,
+            anim_state: AnimationState::new(blocker, anim),
+            random_seed: fastrand::f32(),
+        })
+    }
+
+    pub fn advance_animations(&mut self, current_time: Duration) {
+        match &mut self.anim_state {
+            AnimationState::Waiting { blocker, anim } => {
+                if blocker.state() != BlockerState::Pending {
+                    let mut anim = anim.restarted(0., 1., 0.);
+                    anim.set_current_time(current_time);
+                    self.anim_state = AnimationState::Animating(anim);
+                }
+            }
+            AnimationState::Animating(anim) => anim.set_current_time(current_time),
+        }
+    }
+
+    pub fn are_animations_ongoing(&self) -> bool {
+        match &self.anim_state {
+            AnimationState::Waiting { .. } => true,
+            AnimationState::Animating(anim) => !anim.is_done(),
+        }
+    }
+
+    pub fn render(
+        &self,
+        renderer: &mut GlesRenderer,
+        view_rect: Rectangle<f64, Logical>,
+        scale: Scale<f64>,
+        target: RenderTarget,
+    ) -> ClosingWindowRenderElement {
+        let (buffer, offset) = if target.should_block_out(self.block_out_from) {
+            (&self.blocked_out_buffer, self.blocked_out_buffer_offset)
+        } else {
+            (&self.buffer, self.buffer_offset)
+        };
+
+        let anim = match &self.anim_state {
+            AnimationState::Waiting { .. } => {
+                let elem = TextureRenderElement::from_texture_buffer(
+                    buffer.clone(),
+                    Point::from((0., 0.)),
+                    1.,
+                    None,
+                    None,
+                    Kind::Unspecified,
+                );
+
+                let elem = PrimaryGpuTextureRenderElement(elem);
+                let elem = RescaleRenderElement::from_element(elem, Point::from((0, 0)), 1.);
+
+                let mut location = self.pos + offset;
+                location.x -= view_rect.loc.x;
+                let elem = RelocateRenderElement::from_element(
+                    elem,
+                    location.to_physical_precise_round(scale),
+                    Relocate::Relative,
+                );
+
+                return elem.into();
+            }
+            AnimationState::Animating(anim) => anim,
+        };
+
+        let progress = anim.value();
+        let clamped_progress = anim.clamped_value().clamp(0., 1.);
+
+        if Shaders::get(renderer).program(ProgramType::Close).is_some() {
+            let area_loc = Vec2::new(view_rect.loc.x as f32, view_rect.loc.y as f32);
+            let area_size = Vec2::new(view_rect.size.w as f32, view_rect.size.h as f32);
+
+            // Round to physical pixels relative to the view position. This is similar to what
+            // happens when rendering normal windows.
+            let relative = self.pos - view_rect.loc;
+            let pos = view_rect.loc + relative.to_physical_precise_round(scale).to_logical(scale);
+
+            let geo_loc = Vec2::new(pos.x as f32, pos.y as f32);
+            let geo_size = Vec2::new(self.geo_size.w as f32, self.geo_size.h as f32);
+
+            let input_to_geo = Mat3::from_scale(area_size / geo_size)
+                * Mat3::from_translation((area_loc - geo_loc) / area_size);
+
+            let tex_scale = self.buffer.texture_scale();
+            let tex_scale = Vec2::new(tex_scale.x as f32, tex_scale.y as f32);
+            let tex_loc = Vec2::new(offset.x as f32, offset.y as f32);
+            let tex_size = self.buffer.texture().size();
+            let tex_size = Vec2::new(tex_size.w as f32, tex_size.h as f32) / tex_scale;
+
+            let geo_to_tex =
+                Mat3::from_translation(-tex_loc / tex_size) * Mat3::from_scale(geo_size / tex_size);
+
+            return ShaderRenderElement::new(
+                ProgramType::Close,
+                view_rect.size,
+                None,
+                scale.x as f32,
+                1.,
+                vec![
+                    mat3_uniform("niri_input_to_geo", input_to_geo),
+                    Uniform::new("niri_geo_size", geo_size.to_array()),
+                    mat3_uniform("niri_geo_to_tex", geo_to_tex),
+                    Uniform::new("niri_progress", progress as f32),
+                    Uniform::new("niri_clamped_progress", clamped_progress as f32),
+                    Uniform::new("niri_random_seed", self.random_seed),
+                ],
+                HashMap::from([(String::from("niri_tex"), buffer.texture().clone())]),
+                Kind::Unspecified,
+            )
+            .with_location(Point::from((0., 0.)))
+            .into();
+        }
+
+        let elem = TextureRenderElement::from_texture_buffer(
+            buffer.clone(),
+            Point::from((0., 0.)),
+            1. - clamped_progress as f32,
+            None,
+            None,
+            Kind::Unspecified,
+        );
+
+        let elem = PrimaryGpuTextureRenderElement(elem);
+
+        let center = self.geo_size.to_point().downscale(2.);
+        let elem = RescaleRenderElement::from_element(
+            elem,
+            (center - offset).to_physical_precise_round(scale),
+            ((1. - clamped_progress) / 5. + 0.8).max(0.),
+        );
+
+        let mut location = self.pos + offset;
+        location.x -= view_rect.loc.x;
+        let elem = RelocateRenderElement::from_element(
+            elem,
+            location.to_physical_precise_round(scale),
+            Relocate::Relative,
+        );
+
+        elem.into()
+    }
+}
@@ -1,115 +1,268 @@
 use std::iter::zip;

 use arrayvec::ArrayVec;
-use niri_config::{self, Color};
-use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};
+use niri_config::{CornerRadius, Gradient, GradientInterpolation, GradientRelativeTo};
 use smithay::backend::renderer::element::Kind;
-use smithay::utils::{Logical, Point, Scale, Size};
+use smithay::utils::{Logical, Point, Rectangle, Size};
+
+use crate::niri_render_elements;
+use crate::render_helpers::border::BorderRenderElement;
+use crate::render_helpers::renderer::NiriRenderer;
+use crate::render_helpers::solid_color::{SolidColorBuffer, SolidColorRenderElement};

 #[derive(Debug)]
 pub struct FocusRing {
-    buffers: [SolidColorBuffer; 4],
-    locations: [Point<i32, Logical>; 4],
-    is_off: bool,
+    buffers: [SolidColorBuffer; 8],
+    locations: [Point<f64, Logical>; 8],
+    sizes: [Size<f64, Logical>; 8],
+    borders: [BorderRenderElement; 8],
+    full_size: Size<f64, Logical>,
    is_border: bool,
-    width: i32,
-    active_color: Color,
-    inactive_color: Color,
+    use_border_shader: bool,
+    config: niri_config::FocusRing,
 }

-pub type FocusRingRenderElement = SolidColorRenderElement;
+niri_render_elements! {
+    FocusRingRenderElement => {
+        SolidColor = SolidColorRenderElement,
+        Gradient = BorderRenderElement,
+    }
+}

 impl FocusRing {
    pub fn new(config: niri_config::FocusRing) -> Self {
        Self {
            buffers: Default::default(),
            locations: Default::default(),
-            is_off: config.off,
+            sizes: Default::default(),
+            borders: Default::default(),
+            full_size: Default::default(),
            is_border: false,
-            width: config.width.into(),
-            active_color: config.active_color,
-            inactive_color: config.inactive_color,
+            use_border_shader: false,
+            config,
        }
    }

    pub fn update_config(&mut self, config: niri_config::FocusRing) {
-        self.is_off = config.off;
-        self.width = config.width.into();
-        self.active_color = config.active_color;
-        self.inactive_color = config.inactive_color;
+        self.config = config;
    }

-    pub fn update(
-        &mut self,
-        win_pos: Point<i32, Logical>,
-        win_size: Size<i32, Logical>,
-        is_border: bool,
-    ) {
-        if is_border {
-            self.buffers[0].resize((win_size.w + self.width * 2, self.width));
-            self.buffers[1].resize((win_size.w + self.width * 2, self.width));
-            self.buffers[2].resize((self.width, win_size.h));
-            self.buffers[3].resize((self.width, win_size.h));
+    pub fn update_shaders(&mut self) {
+        for elem in &mut self.borders {
+            elem.damage_all();
+        }
+    }

-            self.locations[0] = win_pos + Point::from((-self.width, -self.width));
-            self.locations[1] = win_pos + Point::from((-self.width, win_size.h));
-            self.locations[2] = win_pos + Point::from((-self.width, 0));
-            self.locations[3] = win_pos + Point::from((win_size.w, 0));
+    pub fn update_render_elements(
+        &mut self,
+        win_size: Size<f64, Logical>,
+        is_active: bool,
+        is_border: bool,
+        view_rect: Rectangle<f64, Logical>,
+        radius: CornerRadius,
+        scale: f64,
+    ) {
+        let width = self.config.width.0;
+        self.full_size = win_size + Size::from((width, width)).upscale(2.);
+
+        let color = if is_active {
+            self.config.active_color
        } else {
-            let size = win_size + Size::from((self.width * 2, self.width * 2));
-            self.buffers[0].resize(size);
-            self.locations[0] = win_pos - Point::from((self.width, self.width));
+            self.config.inactive_color
+        };
+
+        for buf in &mut self.buffers {
+            buf.set_color(color.to_array_premul());
+        }
+
+        let radius = radius.fit_to(self.full_size.w as f32, self.full_size.h as f32);
+
+        let gradient = if is_active {
+            self.config.active_gradient
+        } else {
+            self.config.inactive_gradient
+        };
+
+        self.use_border_shader = radius != CornerRadius::default() || gradient.is_some();
+
+        // Set the defaults for solid color + rounded corners.
+        let gradient = gradient.unwrap_or(Gradient {
+            from: color,
+            to: color,
+            angle: 0,
+            relative_to: GradientRelativeTo::Window,
+            in_: GradientInterpolation::default(),
+        });
+
+        let full_rect = Rectangle::from_loc_and_size((-width, -width), self.full_size);
+        let gradient_area = match gradient.relative_to {
+            GradientRelativeTo::Window => full_rect,
+            GradientRelativeTo::WorkspaceView => view_rect,
+        };
+
+        let rounded_corner_border_width = if self.is_border {
+            // HACK: increase the border width used for the inner rounded corners a tiny bit to
+            // reduce background bleed.
+            width as f32 + 0.5
+        } else {
+            0.
+        };
+
+        let ceil = |logical: f64| (logical * scale).ceil() / scale;
+
+        // All of this stuff should end up aligned to physical pixels because:
+        // * Window size and border width are rounded to physical pixels before being passed to this
+        //   function.
+        // * We will ceil the corner radii below.
+        // * We do not divide anything, only add, subtract and multiply by integers.
+        // * At rendering time, tile positions are rounded to physical pixels.
+
+        if is_border {
+            let top_left = f64::max(width, ceil(f64::from(radius.top_left)));
+            let top_right = f64::min(
+                self.full_size.w - top_left,
+                f64::max(width, ceil(f64::from(radius.top_right))),
+            );
+            let bottom_left = f64::min(
+                self.full_size.h - top_left,
+                f64::max(width, ceil(f64::from(radius.bottom_left))),
+            );
+            let bottom_right = f64::min(
+                self.full_size.h - top_right,
+                f64::min(
+                    self.full_size.w - bottom_left,
+                    f64::max(width, ceil(f64::from(radius.bottom_right))),
+                ),
+            );
+
+            // Top edge.
+            self.sizes[0] = Size::from((win_size.w + width * 2. - top_left - top_right, width));
+            self.locations[0] = Point::from((-width + top_left, -width));
+
+            // Bottom edge.
+            self.sizes[1] =
+                Size::from((win_size.w + width * 2. - bottom_left - bottom_right, width));
+            self.locations[1] = Point::from((-width + bottom_left, win_size.h));
+
+            // Left edge.
+            self.sizes[2] = Size::from((width, win_size.h + width * 2. - top_left - bottom_left));
+            self.locations[2] = Point::from((-width, -width + top_left));
+
+            // Right edge.
+            self.sizes[3] = Size::from((width, win_size.h + width * 2. - top_right - bottom_right));
+            self.locations[3] = Point::from((win_size.w, -width + top_right));
+
+            // Top-left corner.
+            self.sizes[4] = Size::from((top_left, top_left));
+            self.locations[4] = Point::from((-width, -width));
+
+            // Top-right corner.
+            self.sizes[5] = Size::from((top_right, top_right));
+            self.locations[5] = Point::from((win_size.w + width - top_right, -width));
+
+            // Bottom-right corner.
+            self.sizes[6] = Size::from((bottom_right, bottom_right));
+            self.locations[6] = Point::from((
+                win_size.w + width - bottom_right,
+                win_size.h + width - bottom_right,
+            ));
+
+            // Bottom-left corner.
+            self.sizes[7] = Size::from((bottom_left, bottom_left));
+            self.locations[7] = Point::from((-width, win_size.h + width - bottom_left));
+
+            for (buf, size) in zip(&mut self.buffers, self.sizes) {
+                buf.resize(size);
+            }
+
+            for (border, (loc, size)) in zip(&mut self.borders, zip(self.locations, self.sizes)) {
+                border.update(
+                    size,
+                    Rectangle::from_loc_and_size(gradient_area.loc - loc, gradient_area.size),
+                    gradient.in_,
+                    gradient.from,
+                    gradient.to,
+                    ((gradient.angle as f32) - 90.).to_radians(),
+                    Rectangle::from_loc_and_size(full_rect.loc - loc, full_rect.size),
+                    rounded_corner_border_width,
+                    radius,
+                    scale as f32,
+                );
+            }
+        } else {
+            self.sizes[0] = self.full_size;
+            self.buffers[0].resize(self.sizes[0]);
+            self.locations[0] = Point::from((-width, -width));
+
+            self.borders[0].update(
+                self.sizes[0],
+                Rectangle::from_loc_and_size(
+                    gradient_area.loc - self.locations[0],
+                    gradient_area.size,
+                ),
+                gradient.in_,
+                gradient.from,
+                gradient.to,
+                ((gradient.angle as f32) - 90.).to_radians(),
+                Rectangle::from_loc_and_size(full_rect.loc - self.locations[0], full_rect.size),
+                rounded_corner_border_width,
+                radius,
+                scale as f32,
+            );
        }

        self.is_border = is_border;
    }

-    pub fn set_active(&mut self, is_active: bool) {
-        let color = if is_active {
-            self.active_color.into()
-        } else {
-            self.inactive_color.into()
-        };
+    pub fn render(
+        &self,
+        renderer: &mut impl NiriRenderer,
+        location: Point<f64, Logical>,
+    ) -> impl Iterator<Item = FocusRingRenderElement> {
+        let mut rv = ArrayVec::<_, 8>::new();

-        for buf in &mut self.buffers {
-            buf.set_color(color);
-        }
-    }
-
-    pub fn render(&self, scale: Scale<f64>) -> impl Iterator<Item = FocusRingRenderElement> {
-        let mut rv = ArrayVec::<_, 4>::new();
-
-        if self.is_off {
+        if self.config.off {
            return rv.into_iter();
        }

-        let mut push = |buffer, location: Point<i32, Logical>| {
-            let elem = SolidColorRenderElement::from_buffer(
-                buffer,
-                location.to_physical_precise_round(scale),
-                scale,
-                1.,
-                Kind::Unspecified,
-            );
+        let border_width = -self.locations[0].y;
+
+        // If drawing as a border with width = 0, then there's nothing to draw.
+        if self.is_border && border_width == 0. {
+            return rv.into_iter();
+        }
+
+        let has_border_shader = BorderRenderElement::has_shader(renderer);
+
+        let mut push = |buffer, border: &BorderRenderElement, location: Point<f64, Logical>| {
+            let elem = if self.use_border_shader && has_border_shader {
+                border.clone().with_location(location).into()
+            } else {
+                SolidColorRenderElement::from_buffer(buffer, location, 1., Kind::Unspecified).into()
+            };
            rv.push(elem);
        };

        if self.is_border {
-            for (buf, loc) in zip(&self.buffers, self.locations) {
-                push(buf, loc);
+            for ((buf, border), loc) in zip(zip(&self.buffers, &self.borders), self.locations) {
+                push(buf, border, location + loc);
            }
        } else {
-            push(&self.buffers[0], self.locations[0]);
+            push(
+                &self.buffers[0],
+                &self.borders[0],
+                location + self.locations[0],
+            );
        }

        rv.into_iter()
    }

-    pub fn width(&self) -> i32 {
-        self.width
+    pub fn width(&self) -> f64 {
+        self.config.width.0
    }

    pub fn is_off(&self) -> bool {
-        self.is_off
+        self.config.off
    }
 }
@@ -7,28 +7,46 @@ use smithay::backend::renderer::element::utils::{
    CropRenderElement, Relocate, RelocateRenderElement,
 };
 use smithay::output::Output;
-use smithay::utils::{Logical, Point, Rectangle, Scale};
+use smithay::utils::{Logical, Point, Rectangle};

+use super::tile::Tile;
 use super::workspace::{
-    compute_working_area, Column, ColumnWidth, OutputId, Workspace, WorkspaceRenderElement,
+    compute_working_area, Column, ColumnWidth, OutputId, Workspace, WorkspaceId,
+    WorkspaceRenderElement,
 };
 use super::{LayoutElement, Options};
 use crate::animation::Animation;
+use crate::input::swipe_tracker::SwipeTracker;
 use crate::render_helpers::renderer::NiriRenderer;
-use crate::utils::output_size;
+use crate::render_helpers::RenderTarget;
+use crate::rubber_band::RubberBand;
+use crate::utils::transaction::Transaction;
+use crate::utils::{output_size, round_logical_in_physical, ResizeEdge};
+
+/// Amount of touchpad movement to scroll the height of one workspace.
+const WORKSPACE_GESTURE_MOVEMENT: f64 = 300.;
+
+const WORKSPACE_GESTURE_RUBBER_BAND: RubberBand = RubberBand {
+    stiffness: 0.5,
+    limit: 0.05,
+};

 #[derive(Debug)]
 pub struct Monitor<W: LayoutElement> {
    /// Output for this monitor.
-    pub output: Output,
+    pub(super) output: Output,
+    /// Cached name of the output.
+    output_name: String,
    // Must always contain at least one.
-    pub workspaces: Vec<Workspace<W>>,
+    pub(super) workspaces: Vec<Workspace<W>>,
    /// Index of the currently active workspace.
-    pub active_workspace_idx: usize,
+    pub(super) active_workspace_idx: usize,
+    /// ID of the previously active workspace.
+    pub(super) previous_workspace_id: Option<WorkspaceId>,
    /// In-progress switch between workspaces.
-    pub workspace_switch: Option<WorkspaceSwitch>,
+    pub(super) workspace_switch: Option<WorkspaceSwitch>,
    /// Configurable properties of the layout.
-    pub options: Rc<Options>,
+    pub(super) options: Rc<Options>,
 }

 #[derive(Debug)]
@@ -40,9 +58,12 @@ pub enum WorkspaceSwitch {
 #[derive(Debug)]
 pub struct WorkspaceSwitchGesture {
    /// Index of the workspace where the gesture was started.
-    pub center_idx: usize,
+    center_idx: usize,
    /// Current, fractional workspace index.
-    pub current_idx: f64,
+    pub(super) current_idx: f64,
+    tracker: SwipeTracker,
+    /// Whether the gesture is controlled by the touchpad.
+    is_touchpad: bool,
 }

 pub type MonitorRenderElement<R> =
@@ -56,6 +77,13 @@ impl WorkspaceSwitch {
        }
    }

+    pub fn target_idx(&self) -> f64 {
+        match self {
+            WorkspaceSwitch::Animation(anim) => anim.to(),
+            WorkspaceSwitch::Gesture(gesture) => gesture.current_idx,
+        }
+    }
+
    /// Returns `true` if the workspace switch is [`Animation`].
    ///
    /// [`Animation`]: WorkspaceSwitch::Animation
@@ -68,40 +96,81 @@ impl WorkspaceSwitch {
 impl<W: LayoutElement> Monitor<W> {
    pub fn new(output: Output, workspaces: Vec<Workspace<W>>, options: Rc<Options>) -> Self {
        Self {
+            output_name: output.name(),
            output,
            workspaces,
            active_workspace_idx: 0,
+            previous_workspace_id: None,
            workspace_switch: None,
            options,
        }
    }

+    pub fn output(&self) -> &Output {
+        &self.output
+    }
+
+    pub fn output_name(&self) -> &String {
+        &self.output_name
+    }
+
+    pub fn active_workspace_idx(&self) -> usize {
+        self.active_workspace_idx
+    }
+
    pub fn active_workspace_ref(&self) -> &Workspace<W> {
        &self.workspaces[self.active_workspace_idx]
    }

+    pub fn find_named_workspace(&self, workspace_name: &str) -> Option<&Workspace<W>> {
+        self.workspaces.iter().find(|ws| {
+            ws.name
+                .as_ref()
+                .map_or(false, |name| name.eq_ignore_ascii_case(workspace_name))
+        })
+    }
+
+    pub fn find_named_workspace_index(&self, workspace_name: &str) -> Option<usize> {
+        self.workspaces.iter().position(|ws| {
+            ws.name
+                .as_ref()
+                .map_or(false, |name| name.eq_ignore_ascii_case(workspace_name))
+        })
+    }
+
    pub fn active_workspace(&mut self) -> &mut Workspace<W> {
        &mut self.workspaces[self.active_workspace_idx]
    }

+    pub fn windows(&self) -> impl Iterator<Item = &W> {
+        self.workspaces.iter().flat_map(|ws| ws.windows())
+    }
+
+    pub fn has_window(&self, window: &W::Id) -> bool {
+        self.windows().any(|win| win.id() == window)
+    }
+
    fn activate_workspace(&mut self, idx: usize) {
        if self.active_workspace_idx == idx {
            return;
        }

+        // FIXME: also compute and use current velocity.
        let current_idx = self
            .workspace_switch
            .as_ref()
            .map(|s| s.current_idx())
            .unwrap_or(self.active_workspace_idx as f64);

+        self.previous_workspace_id = Some(self.workspaces[self.active_workspace_idx].id());
+
        self.active_workspace_idx = idx;

        self.workspace_switch = Some(WorkspaceSwitch::Animation(Animation::new(
            current_idx,
            idx as f64,
-            self.options.animations.workspace_switch,
-            niri_config::Animation::default_workspace_switch(),
+            0.,
+            self.options.animations.workspace_switch.0,
        )));
    }

@@ -115,7 +184,7 @@ impl<W: LayoutElement> Monitor<W> {
    ) {
        let workspace = &mut self.workspaces[workspace_idx];

-        workspace.add_window(window, activate, width, is_full_width);
+        workspace.add_window(None, window, activate, width, is_full_width);

        // After adding a new window, workspace becomes this output's own.
        workspace.original_output = OutputId::new(&self.output);
@@ -133,7 +202,7 @@ impl<W: LayoutElement> Monitor<W> {

    pub fn add_window_right_of(
        &mut self,
-        right_of: &W,
+        right_of: &W::Id,
        window: W,
        width: ColumnWidth,
        is_full_width: bool,
@@ -149,12 +218,15 @@ impl<W: LayoutElement> Monitor<W> {

        // After adding a new window, workspace becomes this output's own.
        workspace.original_output = OutputId::new(&self.output);
+
+        // Since we're adding window right of something, the workspace isn't empty, and therefore
+        // cannot be the last one, so we never need to insert a new empty workspace.
    }

    pub fn add_column(&mut self, workspace_idx: usize, column: Column<W>, activate: bool) {
        let workspace = &mut self.workspaces[workspace_idx];

-        workspace.add_column(column, activate);
+        workspace.add_column(None, column, activate, None);

        // After adding a new window, workspace becomes this output's own.
        workspace.original_output = OutputId::new(&self.output);
@@ -170,6 +242,56 @@ impl<W: LayoutElement> Monitor<W> {
        }
    }

+    pub fn add_tile(
+        &mut self,
+        workspace_idx: usize,
+        column_idx: Option<usize>,
+        tile: Tile<W>,
+        activate: bool,
+        width: ColumnWidth,
+        is_full_width: bool,
+    ) {
+        let workspace = &mut self.workspaces[workspace_idx];
+
+        workspace.add_tile(column_idx, tile, activate, width, is_full_width, None);
+
+        // After adding a new window, workspace becomes this output's own.
+        workspace.original_output = OutputId::new(&self.output);
+
+        if workspace_idx == self.workspaces.len() - 1 {
+            // Insert a new empty workspace.
+            let ws = Workspace::new(self.output.clone(), self.options.clone());
+            self.workspaces.push(ws);
+        }
+
+        if activate {
+            self.activate_workspace(workspace_idx);
+        }
+    }
+
+    pub fn add_tile_to_column(
+        &mut self,
+        workspace_idx: usize,
+        column_idx: usize,
+        tile_idx: Option<usize>,
+        tile: Tile<W>,
+        activate: bool,
+    ) {
+        let workspace = &mut self.workspaces[workspace_idx];
+
+        workspace.add_tile_to_column(column_idx, tile_idx, tile, activate);
+
+        // After adding a new window, workspace becomes this output's own.
+        workspace.original_output = OutputId::new(&self.output);
+
+        // Since we're adding window to an existing column, the workspace isn't empty, and
+        // therefore cannot be the last one, so we never need to insert a new empty workspace.
+
+        if activate {
+            self.activate_workspace(workspace_idx);
+        }
+    }
+
    pub fn clean_up_workspaces(&mut self) {
        assert!(self.workspace_switch.is_none());

@@ -178,7 +300,7 @@ impl<W: LayoutElement> Monitor<W> {
                continue;
            }

-            if !self.workspaces[idx].has_windows() {
+            if !self.workspaces[idx].has_windows() && self.workspaces[idx].name.is_none() {
                self.workspaces.remove(idx);
                if self.active_workspace_idx > idx {
                    self.active_workspace_idx -= 1;
@@ -187,6 +309,20 @@ impl<W: LayoutElement> Monitor<W> {
        }
    }

+    pub fn unname_workspace(&mut self, workspace_name: &str) -> bool {
+        for ws in &mut self.workspaces {
+            if ws
+                .name
+                .as_ref()
+                .map_or(false, |name| name.eq_ignore_ascii_case(workspace_name))
+            {
+                ws.unname();
+                return true;
+            }
+        }
+        false
+    }
+
    pub fn move_left(&mut self) {
        self.active_workspace().move_left();
    }
@@ -240,14 +376,6 @@ impl<W: LayoutElement> Monitor<W> {
        }
    }

-    pub fn consume_or_expel_window_left(&mut self) {
-        self.active_workspace().consume_or_expel_window_left();
-    }
-
-    pub fn consume_or_expel_window_right(&mut self) {
-        self.active_workspace().consume_or_expel_window_right();
-    }
-
    pub fn focus_left(&mut self) {
        self.active_workspace().focus_left();
    }
@@ -264,6 +392,14 @@ impl<W: LayoutElement> Monitor<W> {
        self.active_workspace().focus_column_last();
    }

+    pub fn focus_column_right_or_first(&mut self) {
+        self.active_workspace().focus_column_right_or_first();
+    }
+
+    pub fn focus_column_left_or_last(&mut self) {
+        self.active_workspace().focus_column_left_or_last();
+    }
+
    pub fn focus_down(&mut self) {
        self.active_workspace().focus_down();
    }
@@ -272,6 +408,62 @@ impl<W: LayoutElement> Monitor<W> {
        self.active_workspace().focus_up();
    }

+    pub fn focus_down_or_left(&mut self) {
+        let workspace = self.active_workspace();
+        if !workspace.columns.is_empty() {
+            let column = &workspace.columns[workspace.active_column_idx];
+            let curr_idx = column.active_tile_idx;
+            let new_idx = min(column.active_tile_idx + 1, column.tiles.len() - 1);
+            if curr_idx == new_idx {
+                self.focus_left();
+            } else {
+                workspace.focus_down();
+            }
+        }
+    }
+
+    pub fn focus_down_or_right(&mut self) {
+        let workspace = self.active_workspace();
+        if !workspace.columns.is_empty() {
+            let column = &workspace.columns[workspace.active_column_idx];
+            let curr_idx = column.active_tile_idx;
+            let new_idx = min(column.active_tile_idx + 1, column.tiles.len() - 1);
+            if curr_idx == new_idx {
+                self.focus_right();
+            } else {
+                workspace.focus_down();
+            }
+        }
+    }
+
+    pub fn focus_up_or_left(&mut self) {
+        let workspace = self.active_workspace();
+        if !workspace.columns.is_empty() {
+            let curr_idx = workspace.columns[workspace.active_column_idx].active_tile_idx;
+            let new_idx = curr_idx.saturating_sub(1);
+            if curr_idx == new_idx {
+                self.focus_left();
+            } else {
+                workspace.focus_up();
+            }
+        }
+    }
+
+    pub fn focus_up_or_right(&mut self) {
+        let workspace = self.active_workspace();
+        if workspace.columns.is_empty() {
+            self.switch_workspace_up();
+        } else {
+            let curr_idx = workspace.columns[workspace.active_column_idx].active_tile_idx;
+            let new_idx = curr_idx.saturating_sub(1);
+            if curr_idx == new_idx {
+                self.focus_right();
+            } else {
+                workspace.focus_up();
+            }
+        }
+    }
+
    pub fn focus_window_or_workspace_down(&mut self) {
        let workspace = self.active_workspace();
        if workspace.columns.is_empty() {
@@ -317,12 +509,20 @@ impl<W: LayoutElement> Monitor<W> {
        }

        let column = &workspace.columns[workspace.active_column_idx];
-        let width = column.width;
-        let is_full_width = column.is_full_width;
-        let window =
-            workspace.remove_window_by_idx(workspace.active_column_idx, column.active_tile_idx);
+        let removed = workspace.remove_tile_by_idx(
+            workspace.active_column_idx,
+            column.active_tile_idx,
+            Transaction::new(),
+            None,
+        );

-        self.add_window(new_idx, window, true, width, is_full_width);
+        self.add_window(
+            new_idx,
+            removed.tile.into_window(),
+            true,
+            removed.width,
+            removed.is_full_width,
+        );
    }

    pub fn move_to_workspace_down(&mut self) {
@@ -339,16 +539,48 @@ impl<W: LayoutElement> Monitor<W> {
        }

        let column = &workspace.columns[workspace.active_column_idx];
-        let width = column.width;
-        let is_full_width = column.is_full_width;
-        let window =
-            workspace.remove_window_by_idx(workspace.active_column_idx, column.active_tile_idx);
+        let removed = workspace.remove_tile_by_idx(
+            workspace.active_column_idx,
+            column.active_tile_idx,
+            Transaction::new(),
+            None,
+        );

-        self.add_window(new_idx, window, true, width, is_full_width);
+        self.add_window(
+            new_idx,
+            removed.tile.into_window(),
+            true,
+            removed.width,
+            removed.is_full_width,
+        );
    }

-    pub fn move_to_workspace(&mut self, idx: usize) {
-        let source_workspace_idx = self.active_workspace_idx;
+    pub fn move_to_workspace(&mut self, window: Option<&W::Id>, idx: usize) {
+        let (source_workspace_idx, col_idx, tile_idx) = if let Some(window) = window {
+            self.workspaces
+                .iter()
+                .enumerate()
+                .find_map(|(ws_idx, ws)| {
+                    ws.columns.iter().enumerate().find_map(|(col_idx, col)| {
+                        col.tiles
+                            .iter()
+                            .position(|tile| tile.window().id() == window)
+                            .map(|tile_idx| (ws_idx, col_idx, tile_idx))
+                    })
+                })
+                .unwrap()
+        } else {
+            let ws_idx = self.active_workspace_idx;
+
+            let ws = &self.workspaces[ws_idx];
+            if ws.columns.is_empty() {
+                return;
+            }
+
+            let col_idx = ws.active_column_idx;
+            let tile_idx = ws.columns[col_idx].active_tile_idx;
+            (ws_idx, col_idx, tile_idx)
+        };

        let new_idx = min(idx, self.workspaces.len() - 1);
        if new_idx == source_workspace_idx {
@@ -356,22 +588,24 @@ impl<W: LayoutElement> Monitor<W> {
        }

        let workspace = &mut self.workspaces[source_workspace_idx];
-        if workspace.columns.is_empty() {
-            return;
+        let column = &workspace.columns[col_idx];
+        let activate = source_workspace_idx == self.active_workspace_idx
+            && col_idx == workspace.active_column_idx
+            && tile_idx == column.active_tile_idx;
+
+        let removed = workspace.remove_tile_by_idx(col_idx, tile_idx, Transaction::new(), None);
+
+        self.add_window(
+            new_idx,
+            removed.tile.into_window(),
+            activate,
+            removed.width,
+            removed.is_full_width,
+        );
+
+        if self.workspace_switch.is_none() {
+            self.clean_up_workspaces();
        }
-
-        let column = &workspace.columns[workspace.active_column_idx];
-        let width = column.width;
-        let is_full_width = column.is_full_width;
-        let window =
-            workspace.remove_window_by_idx(workspace.active_column_idx, column.active_tile_idx);
-
-        self.add_window(new_idx, window, true, width, is_full_width);
-
-        // Don't animate this action.
-        self.workspace_switch = None;
-
-        self.clean_up_workspaces();
    }

    pub fn move_column_to_workspace_up(&mut self) {
@@ -387,7 +621,7 @@ impl<W: LayoutElement> Monitor<W> {
            return;
        }

-        let column = workspace.remove_column_by_idx(workspace.active_column_idx);
+        let column = workspace.remove_column_by_idx(workspace.active_column_idx, None);
        self.add_column(new_idx, column, true);
    }

@@ -404,7 +638,7 @@ impl<W: LayoutElement> Monitor<W> {
            return;
        }

-        let column = workspace.remove_column_by_idx(workspace.active_column_idx);
+        let column = workspace.remove_column_by_idx(workspace.active_column_idx, None);
        self.add_column(new_idx, column, true);
    }

@@ -421,13 +655,8 @@ impl<W: LayoutElement> Monitor<W> {
            return;
        }

-        let column = workspace.remove_column_by_idx(workspace.active_column_idx);
+        let column = workspace.remove_column_by_idx(workspace.active_column_idx, None);
        self.add_column(new_idx, column, true);
-
-        // Don't animate this action.
-        self.workspace_switch = None;
-
-        self.clean_up_workspaces();
    }

    pub fn switch_workspace_up(&mut self) {
@@ -441,12 +670,31 @@ impl<W: LayoutElement> Monitor<W> {
        ));
    }

+    fn previous_workspace_idx(&self) -> Option<usize> {
+        let id = self.previous_workspace_id?;
+        self.workspaces.iter().position(|w| w.id() == id)
+    }
+
    pub fn switch_workspace(&mut self, idx: usize) {
        self.activate_workspace(min(idx, self.workspaces.len() - 1));
-        // Don't animate this action.
-        self.workspace_switch = None;
+    }

-        self.clean_up_workspaces();
+    pub fn switch_workspace_auto_back_and_forth(&mut self, idx: usize) {
+        let idx = min(idx, self.workspaces.len() - 1);
+
+        if idx == self.active_workspace_idx {
+            if let Some(prev_idx) = self.previous_workspace_idx() {
+                self.switch_workspace(prev_idx);
+            }
+        } else {
+            self.switch_workspace(idx);
+        }
+    }
+
+    pub fn switch_workspace_previous(&mut self) {
+        if let Some(idx) = self.previous_workspace_idx() {
+            self.switch_workspace(idx);
+        }
    }

    pub fn consume_into_column(&mut self) {
@@ -471,7 +719,7 @@ impl<W: LayoutElement> Monitor<W> {
        Some(column.tiles[column.active_tile_idx].window())
    }

-    pub fn advance_animations(&mut self, current_time: Duration, is_active: bool) {
+    pub fn advance_animations(&mut self, current_time: Duration) {
        if let Some(WorkspaceSwitch::Animation(anim)) = &mut self.workspace_switch {
            anim.set_current_time(current_time);
            if anim.is_done() {
@@ -481,11 +729,11 @@ impl<W: LayoutElement> Monitor<W> {
        }

        for ws in &mut self.workspaces {
-            ws.advance_animations(current_time, is_active);
+            ws.advance_animations(current_time);
        }
    }

-    pub fn are_animations_ongoing(&self) -> bool {
+    pub(super) fn are_animations_ongoing(&self) -> bool {
        self.workspace_switch
            .as_ref()
            .is_some_and(|s| s.is_animation())
@@ -494,7 +742,39 @@ impl<W: LayoutElement> Monitor<W> {

    pub fn are_transitions_ongoing(&self) -> bool {
        self.workspace_switch.is_some()
-            || self.workspaces.iter().any(|ws| ws.are_animations_ongoing())
+            || self
+                .workspaces
+                .iter()
+                .any(|ws| ws.are_transitions_ongoing())
+    }
+
+    pub fn update_render_elements(&mut self, is_active: bool) {
+        match &self.workspace_switch {
+            Some(switch) => {
+                let render_idx = switch.current_idx();
+                let before_idx = render_idx.floor();
+                let after_idx = render_idx.ceil();
+
+                if after_idx < 0. || before_idx as usize >= self.workspaces.len() {
+                    return;
+                }
+
+                let after_idx = after_idx as usize;
+                if after_idx < self.workspaces.len() {
+                    self.workspaces[after_idx].update_render_elements(is_active);
+
+                    if before_idx < 0. {
+                        return;
+                    }
+                }
+
+                let before_idx = before_idx as usize;
+                self.workspaces[before_idx].update_render_elements(is_active);
+            }
+            None => {
+                self.workspaces[self.active_workspace_idx].update_render_elements(is_active);
+            }
+        }
    }

    pub fn update_config(&mut self, options: Rc<Options>) {
@@ -503,11 +783,13 @@ impl<W: LayoutElement> Monitor<W> {
        }

        if self.options.struts != options.struts {
+            let scale = self.output.current_scale();
+            let transform = self.output.current_transform();
            let view_size = output_size(&self.output);
            let working_area = compute_working_area(&self.output, options.struts);

            for ws in &mut self.workspaces {
-                ws.set_view_size(view_size, working_area);
+                ws.set_view_size(scale, transform, view_size, working_area);
            }
        }

@@ -526,10 +808,6 @@ impl<W: LayoutElement> Monitor<W> {
        self.active_workspace().set_column_width(change);
    }

-    pub fn set_window_height(&mut self, change: SizeChange) {
-        self.active_workspace().set_window_height(change);
-    }
-
    pub fn move_workspace_down(&mut self) {
        let new_idx = min(self.active_workspace_idx + 1, self.workspaces.len() - 1);
        if new_idx == self.active_workspace_idx {
@@ -544,8 +822,10 @@ impl<W: LayoutElement> Monitor<W> {
            self.workspaces.push(ws);
        }

+        let previous_workspace_id = self.previous_workspace_id;
        self.activate_workspace(new_idx);
        self.workspace_switch = None;
+        self.previous_workspace_id = previous_workspace_id;

        self.clean_up_workspaces();
    }
@@ -564,41 +844,102 @@ impl<W: LayoutElement> Monitor<W> {
            self.workspaces.push(ws);
        }

+        let previous_workspace_id = self.previous_workspace_id;
        self.activate_workspace(new_idx);
        self.workspace_switch = None;
+        self.previous_workspace_id = previous_workspace_id;

        self.clean_up_workspaces();
    }

+    /// Returns the geometry of the active tile relative to and clamped to the output.
+    ///
+    /// During animations, assumes the final view position.
+    pub fn active_tile_visual_rectangle(&self) -> Option<Rectangle<f64, Logical>> {
+        let mut rect = self.active_workspace_ref().active_tile_visual_rectangle()?;
+
+        if let Some(switch) = &self.workspace_switch {
+            let size = output_size(&self.output).to_f64();
+
+            let offset = switch.target_idx() - self.active_workspace_idx as f64;
+            let offset = offset * size.h;
+
+            let clip_rect = Rectangle::from_loc_and_size((0., -offset), size);
+            rect = rect.intersection(clip_rect)?;
+        }
+
+        Some(rect)
+    }
+
+    pub fn workspaces_with_render_positions(
+        &self,
+    ) -> impl Iterator<Item = (&Workspace<W>, Point<f64, Logical>)> {
+        let mut first = None;
+        let mut second = None;
+
+        match &self.workspace_switch {
+            Some(switch) => {
+                let render_idx = switch.current_idx();
+                let before_idx = render_idx.floor();
+                let after_idx = render_idx.ceil();
+
+                if after_idx >= 0. && before_idx < self.workspaces.len() as f64 {
+                    let scale = self.output.current_scale().fractional_scale();
+                    let size = output_size(&self.output);
+                    let offset =
+                        round_logical_in_physical(scale, (render_idx - before_idx) * size.h);
+
+                    // Ceil the height in physical pixels.
+                    let height = (size.h * scale).ceil() / scale;
+
+                    if before_idx >= 0. {
+                        let before_idx = before_idx as usize;
+                        let before_offset = Point::from((0., -offset));
+                        first = Some((&self.workspaces[before_idx], before_offset));
+                    }
+
+                    let after_idx = after_idx as usize;
+                    if after_idx < self.workspaces.len() {
+                        let after_offset = Point::from((0., -offset + height));
+                        second = Some((&self.workspaces[after_idx], after_offset));
+                    }
+                }
+            }
+            None => {
+                first = Some((
+                    &self.workspaces[self.active_workspace_idx],
+                    Point::from((0., 0.)),
+                ));
+            }
+        }
+
+        first.into_iter().chain(second)
+    }
+
+    pub fn workspace_under(
+        &self,
+        pos_within_output: Point<f64, Logical>,
+    ) -> Option<(&Workspace<W>, Point<f64, Logical>)> {
+        let size = output_size(&self.output);
+        let (ws, bounds) = self
+            .workspaces_with_render_positions()
+            .map(|(ws, offset)| (ws, Rectangle::from_loc_and_size(offset, size)))
+            .find(|(_, bounds)| bounds.contains(pos_within_output))?;
+        Some((ws, bounds.loc))
+    }
+
    pub fn window_under(
        &self,
        pos_within_output: Point<f64, Logical>,
-    ) -> Option<(&W, Option<Point<i32, Logical>>)> {
-        match &self.workspace_switch {
-            Some(switch) => {
-                let size = output_size(&self.output);
+    ) -> Option<(&W, Option<Point<f64, Logical>>)> {
+        let (ws, offset) = self.workspace_under(pos_within_output)?;
+        let (win, win_pos) = ws.window_under(pos_within_output - offset)?;
+        Some((win, win_pos.map(|p| p + offset)))
+    }

-                let render_idx = switch.current_idx();
-                let before_idx = render_idx.floor() as usize;
-                let after_idx = render_idx.ceil() as usize;
-
-                let offset = ((render_idx - before_idx as f64) * size.h as f64).round() as i32;
-
-                let (idx, ws_offset) = if pos_within_output.y < (size.h - offset) as f64 {
-                    (before_idx, Point::from((0, offset)))
-                } else {
-                    (after_idx, Point::from((0, -size.h + offset)))
-                };
-
-                let ws = &self.workspaces[idx];
-                let (win, win_pos) = ws.window_under(pos_within_output + ws_offset.to_f64())?;
-                Some((win, win_pos.map(|p| p - ws_offset)))
-            }
-            None => {
-                let ws = &self.workspaces[self.active_workspace_idx];
-                ws.window_under(pos_within_output)
-            }
-        }
+    pub fn resize_edges_under(&self, pos_within_output: Point<f64, Logical>) -> Option<ResizeEdge> {
+        let (ws, offset) = self.workspace_under(pos_within_output)?;
+        ws.resize_edges_under(pos_within_output - offset)
    }

    pub fn render_above_top_layer(&self) -> bool {
@@ -611,76 +952,159 @@ impl<W: LayoutElement> Monitor<W> {
        ws.render_above_top_layer()
    }

-    pub fn render_elements<R: NiriRenderer>(
-        &self,
-        renderer: &mut R,
-    ) -> Vec<MonitorRenderElement<R>> {
+    pub fn render_elements<'a, R: NiriRenderer>(
+        &'a self,
+        renderer: &'a mut R,
+        target: RenderTarget,
+    ) -> impl Iterator<Item = MonitorRenderElement<R>> + '_ {
        let _span = tracy_client::span!("Monitor::render_elements");

-        let output_scale = Scale::from(self.output.current_scale().fractional_scale());
-        let output_transform = self.output.current_transform();
-        let output_mode = self.output.current_mode().unwrap();
-        let size = output_transform.transform_size(output_mode.size);
+        let scale = self.output.current_scale().fractional_scale();
+        let size = output_size(&self.output);
+        // Ceil the height in physical pixels.
+        let height = (size.h * scale).ceil() as i32;

-        match &self.workspace_switch {
-            Some(switch) => {
-                let render_idx = switch.current_idx();
-                let before_idx = render_idx.floor() as usize;
-                let after_idx = render_idx.ceil() as usize;
+        // Crop the elements to prevent them overflowing, currently visible during a workspace
+        // switch.
+        //
+        // HACK: crop to infinite bounds at least horizontally where we
+        // know there's no workspace joining or monitor bounds, otherwise
+        // it will cut pixel shaders and mess up the coordinate space.
+        // There's also a damage tracking bug which causes glitched
+        // rendering for maximized GTK windows.
+        //
+        // FIXME: use proper bounds after fixing the Crop element.
+        let crop_bounds = if self.workspace_switch.is_some() {
+            Rectangle::from_loc_and_size((-i32::MAX / 2, 0), (i32::MAX, height))
+        } else {
+            Rectangle::from_loc_and_size((-i32::MAX / 2, -i32::MAX / 2), (i32::MAX, i32::MAX))
+        };

-                let offset = ((render_idx - before_idx as f64) * size.h as f64).round() as i32;
-
-                let before = self.workspaces[before_idx].render_elements(renderer);
-                let after = self.workspaces[after_idx].render_elements(renderer);
-
-                let before = before.into_iter().filter_map(|elem| {
-                    Some(RelocateRenderElement::from_element(
-                        CropRenderElement::from_element(
-                            elem,
-                            output_scale,
-                            Rectangle::from_extemities((0, offset), (size.w, size.h)),
-                        )?,
-                        (0, -offset),
-                        Relocate::Relative,
-                    ))
-                });
-                let after = after.into_iter().filter_map(|elem| {
-                    Some(RelocateRenderElement::from_element(
-                        CropRenderElement::from_element(
-                            elem,
-                            output_scale,
-                            Rectangle::from_extemities((0, 0), (size.w, offset)),
-                        )?,
-                        (0, -offset + size.h),
-                        Relocate::Relative,
-                    ))
-                });
-                before.chain(after).collect()
-            }
-            None => {
-                let elements = self.workspaces[self.active_workspace_idx].render_elements(renderer);
-                elements
+        self.workspaces_with_render_positions()
+            .flat_map(move |(ws, offset)| {
+                ws.render_elements(renderer, target)
                    .into_iter()
-                    .filter_map(|elem| {
-                        Some(RelocateRenderElement::from_element(
-                            CropRenderElement::from_element(
-                                elem,
-                                output_scale,
-                                // HACK: set infinite crop bounds due to a damage tracking bug
-                                // which causes glitched rendering for maximized GTK windows.
-                                // FIXME: use proper bounds after fixing the Crop element.
-                                Rectangle::from_loc_and_size(
-                                    (-i32::MAX / 2, -i32::MAX / 2),
-                                    (i32::MAX, i32::MAX),
-                                ),
-                                // Rectangle::from_loc_and_size((0, 0), size),
-                            )?,
-                            (0, 0),
-                            Relocate::Relative,
-                        ))
+                    .filter_map(move |elem| {
+                        CropRenderElement::from_element(elem, scale, crop_bounds)
                    })
-                    .collect()
-            }
+                    .map(move |elem| {
+                        RelocateRenderElement::from_element(
+                            elem,
+                            // The offset we get from workspaces_with_render_positions() is already
+                            // rounded to physical pixels, but it's in the logical coordinate
+                            // space, so we need to convert it to physical.
+                            offset.to_physical_precise_round(scale),
+                            Relocate::Relative,
+                        )
+                    })
+            })
+    }
+
+    pub fn workspace_switch_gesture_begin(&mut self, is_touchpad: bool) {
+        let center_idx = self.active_workspace_idx;
+        let current_idx = self
+            .workspace_switch
+            .as_ref()
+            .map(|s| s.current_idx())
+            .unwrap_or(center_idx as f64);
+
+        let gesture = WorkspaceSwitchGesture {
+            center_idx,
+            current_idx,
+            tracker: SwipeTracker::new(),
+            is_touchpad,
+        };
+        self.workspace_switch = Some(WorkspaceSwitch::Gesture(gesture));
+    }
+
+    pub fn workspace_switch_gesture_update(
+        &mut self,
+        delta_y: f64,
+        timestamp: Duration,
+        is_touchpad: bool,
+    ) -> Option<bool> {
+        let Some(WorkspaceSwitch::Gesture(gesture)) = &mut self.workspace_switch else {
+            return None;
+        };
+
+        if gesture.is_touchpad != is_touchpad {
+            return None;
        }
+
+        gesture.tracker.push(delta_y, timestamp);
+
+        let total_height = if gesture.is_touchpad {
+            WORKSPACE_GESTURE_MOVEMENT
+        } else {
+            self.workspaces[0].view_size().h
+        };
+        let pos = gesture.tracker.pos() / total_height;
+
+        let min = gesture.center_idx.saturating_sub(1) as f64;
+        let max = (gesture.center_idx + 1).min(self.workspaces.len() - 1) as f64;
+        let new_idx = gesture.center_idx as f64 + pos;
+        let new_idx = WORKSPACE_GESTURE_RUBBER_BAND.clamp(min, max, new_idx);
+
+        if gesture.current_idx == new_idx {
+            return Some(false);
+        }
+
+        gesture.current_idx = new_idx;
+        Some(true)
+    }
+
+    pub fn workspace_switch_gesture_end(
+        &mut self,
+        cancelled: bool,
+        is_touchpad: Option<bool>,
+    ) -> bool {
+        let Some(WorkspaceSwitch::Gesture(gesture)) = &mut self.workspace_switch else {
+            return false;
+        };
+
+        if is_touchpad.map_or(false, |x| gesture.is_touchpad != x) {
+            return false;
+        }
+
+        if cancelled {
+            self.workspace_switch = None;
+            self.clean_up_workspaces();
+            return true;
+        }
+
+        let total_height = if gesture.is_touchpad {
+            WORKSPACE_GESTURE_MOVEMENT
+        } else {
+            self.workspaces[0].view_size().h
+        };
+
+        let mut velocity = gesture.tracker.velocity() / total_height;
+        let current_pos = gesture.tracker.pos() / total_height;
+        let pos = gesture.tracker.projected_end_pos() / total_height;
+
+        let min = gesture.center_idx.saturating_sub(1) as f64;
+        let max = (gesture.center_idx + 1).min(self.workspaces.len() - 1) as f64;
+        let new_idx = gesture.center_idx as f64 + pos;
+
+        let new_idx = WORKSPACE_GESTURE_RUBBER_BAND.clamp(min, max, new_idx);
+        let new_idx = new_idx.round() as usize;
+
+        velocity *= WORKSPACE_GESTURE_RUBBER_BAND.clamp_derivative(
+            min,
+            max,
+            gesture.center_idx as f64 + current_pos,
+        );
+
+        self.previous_workspace_id = Some(self.workspaces[self.active_workspace_idx].id());
+
+        self.active_workspace_idx = new_idx;
+        self.workspace_switch = Some(WorkspaceSwitch::Animation(Animation::new(
+            gesture.current_idx,
+            new_idx as f64,
+            velocity,
+            self.options.animations.workspace_switch.0,
+        )));
+
+        true
    }
 }
@@ -0,0 +1,154 @@
+use std::collections::HashMap;
+use std::time::Duration;
+
+use anyhow::Context as _;
+use glam::{Mat3, Vec2};
+use smithay::backend::allocator::Fourcc;
+use smithay::backend::renderer::element::utils::{
+    Relocate, RelocateRenderElement, RescaleRenderElement,
+};
+use smithay::backend::renderer::element::{Kind, RenderElement};
+use smithay::backend::renderer::gles::{GlesRenderer, Uniform};
+use smithay::backend::renderer::Texture;
+use smithay::utils::{Logical, Point, Rectangle, Scale, Size, Transform};
+
+use crate::animation::Animation;
+use crate::niri_render_elements;
+use crate::render_helpers::primary_gpu_texture::PrimaryGpuTextureRenderElement;
+use crate::render_helpers::render_to_encompassing_texture;
+use crate::render_helpers::shader_element::ShaderRenderElement;
+use crate::render_helpers::shaders::{mat3_uniform, ProgramType, Shaders};
+use crate::render_helpers::texture::{TextureBuffer, TextureRenderElement};
+
+#[derive(Debug)]
+pub struct OpenAnimation {
+    anim: Animation,
+    random_seed: f32,
+}
+
+niri_render_elements! {
+    OpeningWindowRenderElement => {
+        Texture = RelocateRenderElement<RescaleRenderElement<PrimaryGpuTextureRenderElement>>,
+        Shader = ShaderRenderElement,
+    }
+}
+
+impl OpenAnimation {
+    pub fn new(anim: Animation) -> Self {
+        Self {
+            anim,
+            random_seed: fastrand::f32(),
+        }
+    }
+
+    pub fn advance_animations(&mut self, current_time: Duration) {
+        self.anim.set_current_time(current_time);
+    }
+
+    pub fn is_done(&self) -> bool {
+        self.anim.is_done()
+    }
+
+    // We can't depend on view_rect here, because the result of window opening can be snapshot and
+    // then rendered elsewhere.
+    pub fn render(
+        &self,
+        renderer: &mut GlesRenderer,
+        elements: &[impl RenderElement<GlesRenderer>],
+        geo_size: Size<f64, Logical>,
+        location: Point<f64, Logical>,
+        scale: Scale<f64>,
+    ) -> anyhow::Result<OpeningWindowRenderElement> {
+        let progress = self.anim.value();
+        let clamped_progress = self.anim.clamped_value().clamp(0., 1.);
+
+        let (texture, _sync_point, geo) = render_to_encompassing_texture(
+            renderer,
+            scale,
+            Transform::Normal,
+            Fourcc::Abgr8888,
+            elements,
+        )
+        .context("error rendering to texture")?;
+
+        let offset = geo.loc.to_f64().to_logical(scale);
+        let texture_size = geo.size.to_f64().to_logical(scale);
+
+        if Shaders::get(renderer).program(ProgramType::Open).is_some() {
+            let mut area = Rectangle::from_loc_and_size(location + offset, texture_size);
+
+            // Expand the area a bit to allow for more varied effects.
+            let mut target_size = area.size.upscale(1.5);
+            target_size.w = f64::max(area.size.w + 1000., target_size.w);
+            target_size.h = f64::max(area.size.h + 1000., target_size.h);
+            let diff = (target_size.to_point() - area.size.to_point()).downscale(2.);
+            let diff = diff.to_physical_precise_round(scale).to_logical(scale);
+            area.loc -= diff;
+            area.size += diff.upscale(2.).to_size();
+
+            let area_loc = Vec2::new(area.loc.x as f32, area.loc.y as f32);
+            let area_size = Vec2::new(area.size.w as f32, area.size.h as f32);
+
+            let geo_loc = Vec2::new(location.x as f32, location.y as f32);
+            let geo_size = Vec2::new(geo_size.w as f32, geo_size.h as f32);
+
+            let input_to_geo = Mat3::from_scale(area_size / geo_size)
+                * Mat3::from_translation((area_loc - geo_loc) / area_size);
+
+            let tex_scale = Vec2::new(scale.x as f32, scale.y as f32);
+            let tex_loc = Vec2::new(offset.x as f32, offset.y as f32);
+            let tex_size = Vec2::new(texture.width() as f32, texture.height() as f32) / tex_scale;
+
+            let geo_to_tex =
+                Mat3::from_translation(-tex_loc / tex_size) * Mat3::from_scale(geo_size / tex_size);
+
+            return Ok(ShaderRenderElement::new(
+                ProgramType::Open,
+                area.size,
+                None,
+                scale.x as f32,
+                1.,
+                vec![
+                    mat3_uniform("niri_input_to_geo", input_to_geo),
+                    Uniform::new("niri_geo_size", geo_size.to_array()),
+                    mat3_uniform("niri_geo_to_tex", geo_to_tex),
+                    Uniform::new("niri_progress", progress as f32),
+                    Uniform::new("niri_clamped_progress", clamped_progress as f32),
+                    Uniform::new("niri_random_seed", self.random_seed),
+                ],
+                HashMap::from([(String::from("niri_tex"), texture.clone())]),
+                Kind::Unspecified,
+            )
+            .with_location(area.loc)
+            .into());
+        }
+
+        let buffer =
+            TextureBuffer::from_texture(renderer, texture, scale, Transform::Normal, Vec::new());
+        let elem = TextureRenderElement::from_texture_buffer(
+            buffer,
+            Point::from((0., 0.)),
+            clamped_progress as f32,
+            None,
+            None,
+            Kind::Unspecified,
+        );
+
+        let elem = PrimaryGpuTextureRenderElement(elem);
+
+        let center = geo_size.to_point().downscale(2.);
+        let elem = RescaleRenderElement::from_element(
+            elem,
+            (center - offset).to_physical_precise_round(scale),
+            (progress / 2. + 0.5).max(0.),
+        );
+
+        let elem = RelocateRenderElement::from_element(
+            elem,
+            (location + offset).to_physical_precise_round(scale),
+            Relocate::Relative,
+        );
+
+        Ok(elem.into())
+    }
+}
@@ -4,23 +4,21 @@ extern crate tracing;
 pub mod animation;
 pub mod backend;
 pub mod cli;
-pub mod config_error_notification;
 pub mod cursor;
 #[cfg(feature = "dbus")]
 pub mod dbus;
-pub mod exit_confirm_dialog;
 pub mod frame_clock;
 pub mod handlers;
-pub mod hotkey_overlay;
 pub mod input;
 pub mod ipc;
 pub mod layout;
 pub mod niri;
 pub mod protocols;
 pub mod render_helpers;
-pub mod screenshot_ui;
+pub mod rubber_band;
+pub mod ui;
 pub mod utils;
-pub mod watcher;
+pub mod window;

 #[cfg(not(feature = "xdp-gnome-screencast"))]
 pub mod dummy_pw_utils;
@@ -1,8 +1,10 @@
 #[macro_use]
 extern crate tracing;

+use std::fmt::Write as _;
 use std::fs::{self, File};
 use std::io::{self, Write};
+use std::os::fd::FromRawFd;
 use std::path::PathBuf;
 use std::process::Command;
 use std::{env, mem};
@@ -15,17 +17,22 @@ use niri::cli::{Cli, Sub};
 use niri::dbus;
 use niri::ipc::client::handle_msg;
 use niri::niri::State;
-use niri::utils::{
-    cause_panic, spawn, version, REMOVE_ENV_RUST_BACKTRACE, REMOVE_ENV_RUST_LIB_BACKTRACE,
+use niri::utils::spawning::{
+    spawn, store_and_increase_nofile_rlimit, CHILD_ENV, REMOVE_ENV_RUST_BACKTRACE,
+    REMOVE_ENV_RUST_LIB_BACKTRACE,
 };
-use niri::watcher::Watcher;
+use niri::utils::watcher::Watcher;
+use niri::utils::{cause_panic, version, IS_SYSTEMD_SERVICE};
 use niri_config::Config;
+use niri_ipc::socket::SOCKET_PATH_ENV;
 use portable_atomic::Ordering;
 use sd_notify::NotifyState;
-use smithay::reexports::calloop::{self, EventLoop};
+use smithay::reexports::calloop::EventLoop;
 use smithay::reexports::wayland_server::Display;
 use tracing_subscriber::EnvFilter;

+const DEFAULT_LOG_FILTER: &str = "niri=debug,smithay::backend::renderer::gles=error";
+
 fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Set backtrace defaults if not set.
    if env::var_os("RUST_BACKTRACE").is_none() {
@@ -37,33 +44,44 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
        REMOVE_ENV_RUST_LIB_BACKTRACE.store(true, Ordering::Relaxed);
    }

-    let is_systemd_service = env::var_os("NOTIFY_SOCKET").is_some();
+    if env::var_os("NOTIFY_SOCKET").is_some() {
+        IS_SYSTEMD_SERVICE.store(true, Ordering::Relaxed);

-    let directives = env::var("RUST_LOG").unwrap_or_else(|_| "niri=debug".to_owned());
+        #[cfg(not(feature = "systemd"))]
+        warn!(
+            "running as a systemd service, but systemd support is compiled out. \
+             Are you sure you did not forget to set `--features systemd`?"
+        );
+    }
+
+    let directives = env::var("RUST_LOG").unwrap_or_else(|_| DEFAULT_LOG_FILTER.to_owned());
    let env_filter = EnvFilter::builder().parse_lossy(directives);
    tracing_subscriber::fmt()
        .compact()
        .with_env_filter(env_filter)
        .init();

-    if is_systemd_service {
-        // If we're starting as a systemd service, assume that the intention is to start on a TTY.
-        // Remove DISPLAY or WAYLAND_DISPLAY from our environment if they are set, since they will
-        // cause the winit backend to be selected instead.
+    let cli = Cli::parse();
+
+    if cli.session {
+        // If we're starting as a session, assume that the intention is to start on a TTY. Remove
+        // DISPLAY or WAYLAND_DISPLAY from our environment if they are set, since they will cause
+        // the winit backend to be selected instead.
        if env::var_os("DISPLAY").is_some() {
-            debug!("we're running as a systemd service but DISPLAY is set, removing it");
+            warn!("running as a session but DISPLAY is set, removing it");
            env::remove_var("DISPLAY");
        }
        if env::var_os("WAYLAND_DISPLAY").is_some() {
-            debug!("we're running as a systemd service but WAYLAND_DISPLAY is set, removing it");
+            warn!("running as a session but WAYLAND_DISPLAY is set, removing it");
            env::remove_var("WAYLAND_DISPLAY");
        }
+
+        // Set the current desktop for xdg-desktop-portal.
+        env::set_var("XDG_CURRENT_DESKTOP", "niri");
+        // Ensure the session type is set to Wayland for xdg-autostart and Qt apps.
+        env::set_var("XDG_SESSION_TYPE", "wayland");
    }

-    let cli = Cli::parse();
-
-    let _client = tracy_client::Client::start();
-
    // Set a better error printer for config loading.
    niri_config::set_miette_hook().unwrap();

@@ -71,9 +89,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    if let Some(subcommand) = cli.subcommand {
        match subcommand {
            Sub::Validate { config } => {
-                let path = config
-                    .or_else(default_config_path)
-                    .expect("error getting config path");
+                tracy_client::Client::start();
+
+                let (path, _, _) = config_path(config);
                Config::load(&path)?;
                info!("config is valid");
                return Ok(());
@@ -86,58 +104,58 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
        }
    }

+    // Avoid starting Tracy for the `niri msg` code path since starting/stopping Tracy is a bit
+    // slow.
+    tracy_client::Client::start();
+
    info!("starting version {}", &version());

    // Load the config.
    let mut config_created = false;
-    let path = cli.config.or_else(|| {
-        let default_path = default_config_path()?;
-        let default_parent = default_path.parent().unwrap();
+    let (path, watch_path, create_default) = config_path(cli.config);
+    env::remove_var("NIRI_CONFIG");
+    if create_default {
+        let default_parent = path.parent().unwrap();

-        if let Err(err) = fs::create_dir_all(default_parent) {
-            warn!(
-                "error creating config directories {:?}: {err:?}",
-                default_parent
-            );
-            return Some(default_path);
-        }
-
-        // Create the config and fill it with the default config if it doesn't exist.
-        let new_file = File::options()
-            .read(true)
-            .write(true)
-            .create_new(true)
-            .open(&default_path);
-        match new_file {
-            Ok(mut new_file) => {
-                let default = include_bytes!("../resources/default-config.kdl");
-                match new_file.write_all(default) {
-                    Ok(()) => {
-                        config_created = true;
-                        info!("wrote default config to {:?}", &default_path);
-                    }
-                    Err(err) => {
-                        warn!("error writing config file at {:?}: {err:?}", &default_path)
+        match fs::create_dir_all(default_parent) {
+            Ok(()) => {
+                // Create the config and fill it with the default config if it doesn't exist.
+                let new_file = File::options()
+                    .read(true)
+                    .write(true)
+                    .create_new(true)
+                    .open(&path);
+                match new_file {
+                    Ok(mut new_file) => {
+                        let default = include_bytes!("../resources/default-config.kdl");
+                        match new_file.write_all(default) {
+                            Ok(()) => {
+                                config_created = true;
+                                info!("wrote default config to {:?}", &path);
+                            }
+                            Err(err) => {
+                                warn!("error writing config file at {:?}: {err:?}", &path)
+                            }
+                        }
                    }
+                    Err(err) if err.kind() == io::ErrorKind::AlreadyExists => {}
+                    Err(err) => warn!("error creating config file at {:?}: {err:?}", &path),
                }
            }
-            Err(err) if err.kind() == io::ErrorKind::AlreadyExists => {}
-            Err(err) => warn!("error creating config file at {:?}: {err:?}", &default_path),
+            Err(err) => {
+                warn!(
+                    "error creating config directories {:?}: {err:?}",
+                    default_parent
+                );
+            }
        }
-
-        Some(default_path)
-    });
+    }

    let mut config_errored = false;
-    let mut config = path
-        .as_deref()
-        .and_then(|path| match Config::load(path) {
-            Ok(config) => Some(config),
-            Err(err) => {
-                warn!("{err:?}");
-                config_errored = true;
-                None
-            }
+    let mut config = Config::load(&path)
+        .map_err(|err| {
+            warn!("{err:?}");
+            config_errored = true;
        })
        .unwrap_or_default();

@@ -149,6 +167,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    animation::ANIMATION_SLOWDOWN.store(slowdown, Ordering::Relaxed);

    let spawn_at_startup = mem::take(&mut config.spawn_at_startup);
+    *CHILD_ENV.write().unwrap() = mem::take(&mut config.environment);
+
+    store_and_increase_nofile_rlimit();

    // Create the compositor.
    let mut event_loop = EventLoop::try_new().unwrap();
@@ -171,13 +192,13 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {

    // Set NIRI_SOCKET for children.
    if let Some(ipc) = &state.niri.ipc_server {
-        env::set_var(niri_ipc::SOCKET_PATH_ENV, &ipc.socket_path);
+        env::set_var(SOCKET_PATH_ENV, &ipc.socket_path);
        info!("IPC listening on: {}", ipc.socket_path.to_string_lossy());
    }

-    if is_systemd_service {
-        // We're starting as a systemd service. Export our variables.
-        import_env_to_systemd();
+    if cli.session {
+        // We're starting as a session. Import our variables.
+        import_environment();

        // Inhibit power key handling so we can suspend on it.
        #[cfg(feature = "dbus")]
@@ -189,27 +210,32 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    }

    #[cfg(feature = "dbus")]
-    dbus::DBusServers::start(&mut state, is_systemd_service);
+    dbus::DBusServers::start(&mut state, cli.session);

-    // Notify systemd we're ready.
-    if let Err(err) = sd_notify::notify(true, &[NotifyState::Ready]) {
-        warn!("error notifying systemd: {err:?}");
-    };
+    if env::var_os("NIRI_DISABLE_SYSTEM_MANAGER_NOTIFY").map_or(true, |x| x != "1") {
+        // Notify systemd we're ready.
+        if let Err(err) = sd_notify::notify(true, &[NotifyState::Ready]) {
+            warn!("error notifying systemd: {err:?}");
+        };
+
+        // Send ready notification to the NOTIFY_FD file descriptor.
+        if let Err(err) = notify_fd() {
+            warn!("error notifying fd: {err:?}");
+        }
+    }

    // Set up config file watcher.
-    let _watcher = if let Some(path) = path.clone() {
+    let _watcher = {
        let (tx, rx) = calloop::channel::sync_channel(1);
-        let watcher = Watcher::new(path.clone(), tx);
+        let watcher = Watcher::new(watch_path.clone(), tx);
        event_loop
            .handle()
            .insert_source(rx, move |event, _, state| match event {
-                calloop::channel::Event::Msg(()) => state.reload_config(path.clone()),
+                calloop::channel::Event::Msg(()) => state.reload_config(watch_path.clone()),
                calloop::channel::Event::Closed => (),
            })
            .unwrap();
-        Some(watcher)
-    } else {
-        None
+        watcher
    };

    // Spawn commands from cli and auto-start.
@@ -234,14 +260,32 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    Ok(())
 }

-fn import_env_to_systemd() {
-    let variables = ["WAYLAND_DISPLAY", niri_ipc::SOCKET_PATH_ENV].join(" ");
+fn import_environment() {
+    let variables = [
+        "WAYLAND_DISPLAY",
+        "XDG_CURRENT_DESKTOP",
+        "XDG_SESSION_TYPE",
+        SOCKET_PATH_ENV,
+    ]
+    .join(" ");
+
+    let mut init_system_import = String::new();
+    if cfg!(feature = "systemd") {
+        write!(
+            init_system_import,
+            "systemctl --user import-environment {variables};"
+        )
+        .unwrap();
+    }
+    if cfg!(feature = "dinit") {
+        write!(init_system_import, "dinitctl setenv {variables};").unwrap();
+    }

    let rv = Command::new("/bin/sh")
        .args([
            "-c",
            &format!(
-                "systemctl --user import-environment {variables} && \
+                "{init_system_import}\
                 hash dbus-update-activation-environment 2>/dev/null && \
                 dbus-update-activation-environment {variables}"
            ),
@@ -261,11 +305,17 @@ fn import_env_to_systemd() {
            }
        },
        Err(err) => {
-            warn!("error spawning shell to import environment into systemd: {err:?}");
+            warn!("error spawning shell to import environment: {err:?}");
        }
    }
 }

+fn env_config_path() -> Option<PathBuf> {
+    env::var_os("NIRI_CONFIG")
+        .filter(|x| !x.is_empty())
+        .map(PathBuf::from)
+}
+
 fn default_config_path() -> Option<PathBuf> {
    let Some(dirs) = ProjectDirs::from("", "", "niri") else {
        warn!("error retrieving home directory");
@@ -276,3 +326,42 @@ fn default_config_path() -> Option<PathBuf> {
    path.push("config.kdl");
    Some(path)
 }
+
+fn system_config_path() -> PathBuf {
+    PathBuf::from("/etc/niri/config.kdl")
+}
+
+/// Resolves and returns the config path to load, the config path to watch, and whether to create
+/// the default config at the path to load.
+fn config_path(cli_path: Option<PathBuf>) -> (PathBuf, PathBuf, bool) {
+    if let Some(explicit) = cli_path.or_else(env_config_path) {
+        return (explicit.clone(), explicit, false);
+    }
+
+    let system_path = system_config_path();
+    if let Some(path) = default_config_path() {
+        if path.exists() {
+            return (path.clone(), path, true);
+        }
+
+        if system_path.exists() {
+            (system_path, path, false)
+        } else {
+            (path.clone(), path, true)
+        }
+    } else {
+        (system_path.clone(), system_path, false)
+    }
+}
+
+fn notify_fd() -> anyhow::Result<()> {
+    let fd = match env::var("NOTIFY_FD") {
+        Ok(notify_fd) => notify_fd.parse()?,
+        Err(env::VarError::NotPresent) => return Ok(()),
+        Err(err) => return Err(err.into()),
+    };
+    env::remove_var("NOTIFY_FD");
+    let mut notif = unsafe { File::from_raw_fd(fd) };
+    notif.write_all(b"READY=1\n")?;
+    Ok(())
+}
@@ -95,8 +95,8 @@ pub fn refresh(state: &mut State) {
    // Save the focused window for last, this way when the focus changes, we will first deactivate
    // the previous window and only then activate the newly focused window.
    let mut focused = None;
-    state.niri.layout.with_windows(|window, output| {
-        let wl_surface = window.toplevel().wl_surface();
+    state.niri.layout.with_windows(|mapped, output, _| {
+        let wl_surface = mapped.toplevel().wl_surface();

        with_states(wl_surface, |states| {
            let role = states
@@ -106,8 +106,8 @@ pub fn refresh(state: &mut State) {
                .lock()
                .unwrap();

-            if state.niri.keyboard_focus.as_ref() == Some(wl_surface) {
-                focused = Some((window.clone(), output.cloned()));
+            if state.niri.keyboard_focus.surface() == Some(wl_surface) {
+                focused = Some((mapped.window.clone(), output.cloned()));
            } else {
                refresh_toplevel(protocol_state, wl_surface, &role, output, false);
            }
@@ -116,7 +116,7 @@ pub fn refresh(state: &mut State) {

    // Finally, refresh the focused window.
    if let Some((window, output)) = focused {
-        let wl_surface = window.toplevel().wl_surface();
+        let wl_surface = window.toplevel().expect("no x11 support").wl_surface();

        with_states(wl_surface, |states| {
            let role = states
@@ -172,7 +172,7 @@ fn refresh_toplevel(

            let mut new_title = None;
            if data.title != role.title {
-                data.title = role.title.clone();
+                data.title.clone_from(&role.title);
                new_title = role.title.as_deref();

                if new_title.is_none() {
@@ -182,7 +182,7 @@ fn refresh_toplevel(

            let mut new_app_id = None;
            if data.app_id != role.app_id {
-                data.app_id = role.app_id.clone();
+                data.app_id.clone_from(&role.app_id);
                new_app_id = role.app_id.as_deref();

                if new_app_id.is_none() {
@@ -0,0 +1,246 @@
+use std::collections::HashMap;
+use std::fs::File;
+use std::io::Read;
+
+use smithay::output::Output;
+use smithay::reexports::wayland_protocols_wlr;
+use smithay::reexports::wayland_server::backend::ClientId;
+use smithay::reexports::wayland_server::{
+    Client, DataInit, Dispatch, DisplayHandle, GlobalDispatch, New, Resource,
+};
+use wayland_protocols_wlr::gamma_control::v1::server::{
+    zwlr_gamma_control_manager_v1, zwlr_gamma_control_v1,
+};
+use zwlr_gamma_control_manager_v1::ZwlrGammaControlManagerV1;
+use zwlr_gamma_control_v1::ZwlrGammaControlV1;
+
+const VERSION: u32 = 1;
+
+pub struct GammaControlManagerState {
+    // Active gamma controls only. Failed ones are removed.
+    gamma_controls: HashMap<Output, ZwlrGammaControlV1>,
+}
+
+pub struct GammaControlManagerGlobalData {
+    filter: Box<dyn for<'c> Fn(&'c Client) -> bool + Send + Sync>,
+}
+
+pub trait GammaControlHandler {
+    fn gamma_control_manager_state(&mut self) -> &mut GammaControlManagerState;
+    fn get_gamma_size(&mut self, output: &Output) -> Option<u32>;
+    fn set_gamma(&mut self, output: &Output, ramp: Option<Vec<u16>>) -> Option<()>;
+}
+
+pub struct GammaControlState {
+    gamma_size: u32,
+}
+
+impl GammaControlManagerState {
+    pub fn new<D, F>(display: &DisplayHandle, filter: F) -> Self
+    where
+        D: GlobalDispatch<ZwlrGammaControlManagerV1, GammaControlManagerGlobalData>,
+        D: Dispatch<ZwlrGammaControlManagerV1, ()>,
+        D: Dispatch<ZwlrGammaControlV1, GammaControlState>,
+        D: GammaControlHandler,
+        D: 'static,
+        F: for<'c> Fn(&'c Client) -> bool + Send + Sync + 'static,
+    {
+        let global_data = GammaControlManagerGlobalData {
+            filter: Box::new(filter),
+        };
+        display.create_global::<D, ZwlrGammaControlManagerV1, _>(VERSION, global_data);
+
+        Self {
+            gamma_controls: HashMap::new(),
+        }
+    }
+
+    pub fn output_removed(&mut self, output: &Output) {
+        if let Some(gamma_control) = self.gamma_controls.remove(output) {
+            gamma_control.failed();
+        }
+    }
+}
+
+impl<D> GlobalDispatch<ZwlrGammaControlManagerV1, GammaControlManagerGlobalData, D>
+    for GammaControlManagerState
+where
+    D: GlobalDispatch<ZwlrGammaControlManagerV1, GammaControlManagerGlobalData>,
+    D: Dispatch<ZwlrGammaControlManagerV1, ()>,
+    D: Dispatch<ZwlrGammaControlV1, GammaControlState>,
+    D: GammaControlHandler,
+    D: 'static,
+{
+    fn bind(
+        _state: &mut D,
+        _handle: &DisplayHandle,
+        _client: &Client,
+        manager: New<ZwlrGammaControlManagerV1>,
+        _manager_state: &GammaControlManagerGlobalData,
+        data_init: &mut DataInit<'_, D>,
+    ) {
+        data_init.init(manager, ());
+    }
+
+    fn can_view(client: Client, global_data: &GammaControlManagerGlobalData) -> bool {
+        (global_data.filter)(&client)
+    }
+}
+
+impl<D> Dispatch<ZwlrGammaControlManagerV1, (), D> for GammaControlManagerState
+where
+    D: Dispatch<ZwlrGammaControlManagerV1, ()>,
+    D: Dispatch<ZwlrGammaControlV1, GammaControlState>,
+    D: GammaControlHandler,
+    D: 'static,
+{
+    fn request(
+        state: &mut D,
+        _client: &Client,
+        _resource: &ZwlrGammaControlManagerV1,
+        request: <ZwlrGammaControlManagerV1 as Resource>::Request,
+        _data: &(),
+        _dhandle: &DisplayHandle,
+        data_init: &mut DataInit<'_, D>,
+    ) {
+        match request {
+            zwlr_gamma_control_manager_v1::Request::GetGammaControl { id, output } => {
+                if let Some(output) = Output::from_resource(&output) {
+                    // We borrow state in the middle.
+                    #[allow(clippy::map_entry)]
+                    if !state
+                        .gamma_control_manager_state()
+                        .gamma_controls
+                        .contains_key(&output)
+                    {
+                        if let Some(gamma_size) = state.get_gamma_size(&output) {
+                            let zwlr_gamma_control =
+                                data_init.init(id, GammaControlState { gamma_size });
+                            zwlr_gamma_control.gamma_size(gamma_size);
+                            state
+                                .gamma_control_manager_state()
+                                .gamma_controls
+                                .insert(output, zwlr_gamma_control);
+                            return;
+                        }
+                    }
+                }
+
+                data_init
+                    .init(id, GammaControlState { gamma_size: 0 })
+                    .failed();
+            }
+            zwlr_gamma_control_manager_v1::Request::Destroy => (),
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl<D> Dispatch<ZwlrGammaControlV1, GammaControlState, D> for GammaControlManagerState
+where
+    D: Dispatch<ZwlrGammaControlV1, GammaControlState>,
+    D: GammaControlHandler,
+    D: 'static,
+{
+    fn request(
+        state: &mut D,
+        _client: &Client,
+        resource: &ZwlrGammaControlV1,
+        request: <ZwlrGammaControlV1 as Resource>::Request,
+        data: &GammaControlState,
+        _dhandle: &DisplayHandle,
+        _data_init: &mut DataInit<'_, D>,
+    ) {
+        match request {
+            zwlr_gamma_control_v1::Request::SetGamma { fd } => {
+                let gamma_controls = &mut state.gamma_control_manager_state().gamma_controls;
+                let Some((output, _)) = gamma_controls.iter().find(|(_, x)| *x == resource) else {
+                    return;
+                };
+                let output = output.clone();
+
+                trace!("setting gamma for output {}", output.name());
+
+                // Start with a u16 slice so it's aligned correctly.
+                let mut gamma = vec![0u16; data.gamma_size as usize * 3];
+                let buf = bytemuck::cast_slice_mut(&mut gamma);
+                let mut file = File::from(fd);
+                {
+                    let _span = tracy_client::span!("read gamma from fd");
+
+                    if let Err(err) = file.read_exact(buf) {
+                        warn!("failed to read gamma data: {err:?}");
+                        resource.failed();
+                        gamma_controls.remove(&output);
+                        let _ = state.set_gamma(&output, None);
+                        return;
+                    }
+
+                    // Verify that there's no more data.
+                    #[allow(clippy::unused_io_amount)] // False positive on 1.77.0
+                    {
+                        match file.read(&mut [0]) {
+                            Ok(0) => (),
+                            Ok(_) => {
+                                warn!("gamma data is too large");
+                                resource.failed();
+                                gamma_controls.remove(&output);
+                                let _ = state.set_gamma(&output, None);
+                                return;
+                            }
+                            Err(err) => {
+                                warn!("error reading gamma data: {err:?}");
+                                resource.failed();
+                                gamma_controls.remove(&output);
+                                let _ = state.set_gamma(&output, None);
+                                return;
+                            }
+                        }
+                    }
+                }
+
+                if state.set_gamma(&output, Some(gamma)).is_none() {
+                    resource.failed();
+                    let gamma_controls = &mut state.gamma_control_manager_state().gamma_controls;
+                    gamma_controls.remove(&output);
+                    let _ = state.set_gamma(&output, None);
+                }
+            }
+            zwlr_gamma_control_v1::Request::Destroy => (),
+            _ => unreachable!(),
+        }
+    }
+
+    fn destroyed(
+        state: &mut D,
+        _client: ClientId,
+        resource: &ZwlrGammaControlV1,
+        _data: &GammaControlState,
+    ) {
+        let gamma_controls = &mut state.gamma_control_manager_state().gamma_controls;
+        let Some((output, _)) = gamma_controls.iter().find(|(_, x)| *x == resource) else {
+            return;
+        };
+        let output = output.clone();
+        gamma_controls.remove(&output);
+
+        let _ = state.set_gamma(&output, None);
+    }
+}
+
+#[macro_export]
+macro_rules! delegate_gamma_control {
+    ($(@<$( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+>)? $ty: ty) => {
+        smithay::reexports::wayland_server::delegate_global_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            smithay::reexports::wayland_protocols_wlr::gamma_control::v1::server::zwlr_gamma_control_manager_v1::ZwlrGammaControlManagerV1: $crate::protocols::gamma_control::GammaControlManagerGlobalData
+        ] => $crate::protocols::gamma_control::GammaControlManagerState);
+
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            smithay::reexports::wayland_protocols_wlr::gamma_control::v1::server::zwlr_gamma_control_manager_v1::ZwlrGammaControlManagerV1: ()
+        ] => $crate::protocols::gamma_control::GammaControlManagerState);
+
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            smithay::reexports::wayland_protocols_wlr::gamma_control::v1::server::zwlr_gamma_control_v1::ZwlrGammaControlV1:  $crate::protocols::gamma_control::GammaControlState
+        ] => $crate::protocols::gamma_control::GammaControlManagerState);
+    };
+}
@@ -1 +1,7 @@
 pub mod foreign_toplevel;
+pub mod gamma_control;
+pub mod mutter_x11_interop;
+pub mod output_management;
+pub mod screencopy;
+
+pub mod raw;
@@ -0,0 +1,93 @@
+use mutter_x11_interop::MutterX11Interop;
+use smithay::reexports::wayland_server::{
+    Client, DataInit, Dispatch, DisplayHandle, GlobalDispatch, New, Resource,
+};
+
+use super::raw::mutter_x11_interop::v1::server::mutter_x11_interop;
+
+const VERSION: u32 = 1;
+
+pub struct MutterX11InteropManagerState {}
+
+pub struct MutterX11InteropManagerGlobalData {
+    filter: Box<dyn for<'c> Fn(&'c Client) -> bool + Send + Sync>,
+}
+
+pub trait MutterX11InteropHandler {}
+
+impl MutterX11InteropManagerState {
+    pub fn new<D, F>(display: &DisplayHandle, filter: F) -> Self
+    where
+        D: GlobalDispatch<MutterX11Interop, MutterX11InteropManagerGlobalData>,
+        D: Dispatch<MutterX11Interop, ()>,
+        D: MutterX11InteropHandler,
+        D: 'static,
+        F: for<'c> Fn(&'c Client) -> bool + Send + Sync + 'static,
+    {
+        let global_data = MutterX11InteropManagerGlobalData {
+            filter: Box::new(filter),
+        };
+        display.create_global::<D, MutterX11Interop, _>(VERSION, global_data);
+
+        Self {}
+    }
+}
+
+impl<D> GlobalDispatch<MutterX11Interop, MutterX11InteropManagerGlobalData, D>
+    for MutterX11InteropManagerState
+where
+    D: GlobalDispatch<MutterX11Interop, MutterX11InteropManagerGlobalData>,
+    D: Dispatch<MutterX11Interop, ()>,
+    D: MutterX11InteropHandler,
+    D: 'static,
+{
+    fn bind(
+        _state: &mut D,
+        _handle: &DisplayHandle,
+        _client: &Client,
+        manager: New<MutterX11Interop>,
+        _manager_state: &MutterX11InteropManagerGlobalData,
+        data_init: &mut DataInit<'_, D>,
+    ) {
+        data_init.init(manager, ());
+    }
+
+    fn can_view(client: Client, global_data: &MutterX11InteropManagerGlobalData) -> bool {
+        (global_data.filter)(&client)
+    }
+}
+
+impl<D> Dispatch<MutterX11Interop, (), D> for MutterX11InteropManagerState
+where
+    D: Dispatch<MutterX11Interop, ()>,
+    D: MutterX11InteropHandler,
+    D: 'static,
+{
+    fn request(
+        _state: &mut D,
+        _client: &Client,
+        _resource: &MutterX11Interop,
+        request: <MutterX11Interop as Resource>::Request,
+        _data: &(),
+        _dhandle: &DisplayHandle,
+        _data_init: &mut DataInit<'_, D>,
+    ) {
+        match request {
+            mutter_x11_interop::Request::Destroy => (),
+            mutter_x11_interop::Request::SetX11Parent { .. } => (),
+        }
+    }
+}
+
+#[macro_export]
+macro_rules! delegate_mutter_x11_interop {
+    ($(@<$( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+>)? $ty: ty) => {
+        smithay::reexports::wayland_server::delegate_global_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            $crate::protocols::raw::mutter_x11_interop::v1::server::mutter_x11_interop::MutterX11Interop: $crate::protocols::mutter_x11_interop::MutterX11InteropManagerGlobalData
+        ] => $crate::protocols::mutter_x11_interop::MutterX11InteropManagerState);
+
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            $crate::protocols::raw::mutter_x11_interop::v1::server::mutter_x11_interop::MutterX11Interop: ()
+        ] => $crate::protocols::mutter_x11_interop::MutterX11InteropManagerState);
+    };
+}
@@ -0,0 +1,897 @@
+use std::collections::hash_map::Entry;
+use std::collections::HashMap;
+use std::iter::zip;
+use std::mem;
+
+use niri_config::{FloatOrInt, OutputName, Vrr};
+use niri_ipc::Transform;
+use smithay::reexports::wayland_protocols_wlr::output_management::v1::server::{
+    zwlr_output_configuration_head_v1, zwlr_output_configuration_v1, zwlr_output_head_v1,
+    zwlr_output_manager_v1, zwlr_output_mode_v1,
+};
+use smithay::reexports::wayland_server::backend::ClientId;
+use smithay::reexports::wayland_server::protocol::wl_output::Transform as WlTransform;
+use smithay::reexports::wayland_server::{
+    Client, DataInit, Dispatch, DisplayHandle, GlobalDispatch, New, Resource, WEnum,
+};
+use zwlr_output_configuration_head_v1::ZwlrOutputConfigurationHeadV1;
+use zwlr_output_configuration_v1::ZwlrOutputConfigurationV1;
+use zwlr_output_head_v1::{AdaptiveSyncState, ZwlrOutputHeadV1};
+use zwlr_output_manager_v1::ZwlrOutputManagerV1;
+use zwlr_output_mode_v1::ZwlrOutputModeV1;
+
+use crate::backend::OutputId;
+use crate::niri::State;
+use crate::utils::ipc_transform_to_smithay;
+
+const VERSION: u32 = 4;
+
+#[derive(Debug)]
+struct ClientData {
+    heads: HashMap<OutputId, (ZwlrOutputHeadV1, Vec<ZwlrOutputModeV1>)>,
+    confs: HashMap<ZwlrOutputConfigurationV1, OutputConfigurationState>,
+    manager: ZwlrOutputManagerV1,
+}
+
+pub struct OutputManagementManagerState {
+    display: DisplayHandle,
+    serial: u32,
+    clients: HashMap<ClientId, ClientData>,
+    current_state: HashMap<OutputId, niri_ipc::Output>,
+    current_config: niri_config::Outputs,
+}
+
+pub struct OutputManagementManagerGlobalData {
+    filter: Box<dyn for<'c> Fn(&'c Client) -> bool + Send + Sync>,
+}
+
+pub trait OutputManagementHandler {
+    fn output_management_state(&mut self) -> &mut OutputManagementManagerState;
+    fn apply_output_config(&mut self, config: niri_config::Outputs);
+}
+
+#[derive(Debug)]
+enum OutputConfigurationState {
+    Ongoing(HashMap<OutputId, niri_config::Output>),
+    Finished,
+}
+
+pub enum OutputConfigurationHeadState {
+    Cancelled,
+    Ok(OutputId, ZwlrOutputConfigurationV1),
+}
+
+impl OutputManagementManagerState {
+    pub fn new<D, F>(display: &DisplayHandle, filter: F) -> Self
+    where
+        D: GlobalDispatch<ZwlrOutputManagerV1, OutputManagementManagerGlobalData>,
+        D: Dispatch<ZwlrOutputManagerV1, ()>,
+        D: Dispatch<ZwlrOutputHeadV1, OutputId>,
+        D: Dispatch<ZwlrOutputConfigurationV1, u32>,
+        D: Dispatch<ZwlrOutputConfigurationHeadV1, OutputConfigurationHeadState>,
+        D: Dispatch<ZwlrOutputModeV1, ()>,
+        D: OutputManagementHandler,
+        D: 'static,
+        F: for<'c> Fn(&'c Client) -> bool + Send + Sync + 'static,
+    {
+        let global_data = OutputManagementManagerGlobalData {
+            filter: Box::new(filter),
+        };
+        display.create_global::<D, ZwlrOutputManagerV1, _>(VERSION, global_data);
+
+        Self {
+            display: display.clone(),
+            clients: HashMap::new(),
+            serial: 0,
+            current_state: HashMap::new(),
+            current_config: Default::default(),
+        }
+    }
+
+    pub fn on_config_changed(&mut self, new_config: niri_config::Outputs) {
+        self.current_config = new_config;
+    }
+
+    pub fn notify_changes(&mut self, new_state: HashMap<OutputId, niri_ipc::Output>) {
+        let mut changed = false; /* most likely to end up true */
+        for (output, conf) in new_state.iter() {
+            if let Some(old) = self.current_state.get(output) {
+                if old.vrr_enabled != conf.vrr_enabled {
+                    changed = true;
+                    for client in self.clients.values() {
+                        if let Some((head, _)) = client.heads.get(output) {
+                            if head.version() >= zwlr_output_head_v1::EVT_ADAPTIVE_SYNC_SINCE {
+                                head.adaptive_sync(match conf.vrr_enabled {
+                                    true => AdaptiveSyncState::Enabled,
+                                    false => AdaptiveSyncState::Disabled,
+                                });
+                            }
+                        }
+                    }
+                }
+
+                // TTY outputs can't change modes I think, however, winit and virtual outputs can.
+                let modes_changed = old.modes != conf.modes;
+                if modes_changed {
+                    changed = true;
+                    if old.modes.len() != conf.modes.len() {
+                        error!("output's old mode count doesn't match new modes");
+                    } else {
+                        for client in self.clients.values() {
+                            if let Some((_, modes)) = client.heads.get(output) {
+                                for (wl_mode, mode) in zip(modes, &conf.modes) {
+                                    wl_mode.size(i32::from(mode.width), i32::from(mode.height));
+                                    if let Ok(refresh_rate) = mode.refresh_rate.try_into() {
+                                        wl_mode.refresh(refresh_rate);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                match (old.current_mode, conf.current_mode) {
+                    (Some(old_index), Some(new_index)) => {
+                        if old.modes.len() == conf.modes.len()
+                            && (modes_changed || old_index != new_index)
+                        {
+                            changed = true;
+                            for client in self.clients.values() {
+                                if let Some((head, modes)) = client.heads.get(output) {
+                                    if let Some(new_mode) = modes.get(new_index) {
+                                        head.current_mode(new_mode);
+                                    } else {
+                                        error!(
+                                            "output new mode doesnt exist for the client's output"
+                                        );
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    (Some(_), None) => {
+                        changed = true;
+                        for client in self.clients.values() {
+                            if let Some((head, _)) = client.heads.get(output) {
+                                head.enabled(0);
+                            }
+                        }
+                    }
+                    (None, Some(new_index)) => {
+                        if old.modes.len() == conf.modes.len() {
+                            changed = true;
+                            for client in self.clients.values() {
+                                if let Some((head, modes)) = client.heads.get(output) {
+                                    head.enabled(1);
+                                    if let Some(mode) = modes.get(new_index) {
+                                        head.current_mode(mode);
+                                    } else {
+                                        error!(
+                                            "output new mode doesnt exist for the client's output"
+                                        );
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    (None, None) => {}
+                }
+                match (old.logical, conf.logical) {
+                    (Some(old_logical), Some(new_logical)) => {
+                        if old_logical != new_logical {
+                            changed = true;
+                            for client in self.clients.values() {
+                                if let Some((head, _)) = client.heads.get(output) {
+                                    if old_logical.x != new_logical.x
+                                        || old_logical.y != new_logical.y
+                                    {
+                                        head.position(new_logical.x, new_logical.y);
+                                    }
+                                    if old_logical.scale != new_logical.scale {
+                                        head.scale(new_logical.scale);
+                                    }
+                                    if old_logical.transform != new_logical.transform {
+                                        head.transform(
+                                            ipc_transform_to_smithay(new_logical.transform).into(),
+                                        );
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    (None, Some(new_logical)) => {
+                        changed = true;
+                        for client in self.clients.values() {
+                            if let Some((head, _)) = client.heads.get(output) {
+                                // head enable in the mode diff check
+                                head.position(new_logical.x, new_logical.y);
+                                head.transform(
+                                    ipc_transform_to_smithay(new_logical.transform).into(),
+                                );
+                                head.scale(new_logical.scale);
+                            }
+                        }
+                    }
+                    (Some(_), None) => {
+                        // heads disabled in the mode diff check
+                    }
+                    (None, None) => {}
+                }
+            } else {
+                changed = true;
+                notify_new_head(self, output, conf);
+            }
+        }
+        for (old, _) in self.current_state.iter() {
+            if !new_state.contains_key(old) {
+                changed = true;
+                notify_removed_head(&mut self.clients, old);
+            }
+        }
+        if changed {
+            self.current_state = new_state;
+            self.serial += 1;
+            for data in self.clients.values() {
+                data.manager.done(self.serial);
+                for conf in data.confs.keys() {
+                    conf.cancelled();
+                }
+            }
+        }
+    }
+}
+
+impl<D> GlobalDispatch<ZwlrOutputManagerV1, OutputManagementManagerGlobalData, D>
+    for OutputManagementManagerState
+where
+    D: GlobalDispatch<ZwlrOutputManagerV1, OutputManagementManagerGlobalData>,
+    D: Dispatch<ZwlrOutputManagerV1, ()>,
+    D: Dispatch<ZwlrOutputHeadV1, OutputId>,
+    D: Dispatch<ZwlrOutputConfigurationV1, u32>,
+    D: Dispatch<ZwlrOutputConfigurationHeadV1, OutputConfigurationHeadState>,
+    D: Dispatch<ZwlrOutputModeV1, ()>,
+    D: OutputManagementHandler,
+    D: 'static,
+{
+    fn bind(
+        state: &mut D,
+        display: &DisplayHandle,
+        client: &Client,
+        manager: New<ZwlrOutputManagerV1>,
+        _manager_state: &OutputManagementManagerGlobalData,
+        data_init: &mut DataInit<'_, D>,
+    ) {
+        let manager = data_init.init(manager, ());
+        let g_state = state.output_management_state();
+        let mut client_data = ClientData {
+            heads: HashMap::new(),
+            confs: HashMap::new(),
+            manager: manager.clone(),
+        };
+        for (output, conf) in &g_state.current_state {
+            send_new_head::<D>(display, client, &mut client_data, *output, conf);
+        }
+        g_state.clients.insert(client.id(), client_data);
+        manager.done(g_state.serial);
+    }
+
+    fn can_view(client: Client, global_data: &OutputManagementManagerGlobalData) -> bool {
+        (global_data.filter)(&client)
+    }
+}
+
+impl<D> Dispatch<ZwlrOutputManagerV1, (), D> for OutputManagementManagerState
+where
+    D: GlobalDispatch<ZwlrOutputManagerV1, OutputManagementManagerGlobalData>,
+    D: Dispatch<ZwlrOutputManagerV1, ()>,
+    D: Dispatch<ZwlrOutputHeadV1, OutputId>,
+    D: Dispatch<ZwlrOutputConfigurationV1, u32>,
+    D: Dispatch<ZwlrOutputConfigurationHeadV1, OutputConfigurationHeadState>,
+    D: Dispatch<ZwlrOutputModeV1, ()>,
+    D: OutputManagementHandler,
+    D: 'static,
+{
+    fn request(
+        state: &mut D,
+        client: &Client,
+        _manager: &ZwlrOutputManagerV1,
+        request: zwlr_output_manager_v1::Request,
+        _data: &(),
+        _display: &DisplayHandle,
+        data_init: &mut DataInit<'_, D>,
+    ) {
+        match request {
+            zwlr_output_manager_v1::Request::CreateConfiguration { id, serial } => {
+                let g_state = state.output_management_state();
+                let conf = data_init.init(id, serial);
+                if let Some(client_data) = g_state.clients.get_mut(&client.id()) {
+                    if serial != g_state.serial {
+                        conf.cancelled();
+                    }
+                    let state = OutputConfigurationState::Ongoing(HashMap::new());
+                    client_data.confs.insert(conf, state);
+                } else {
+                    error!("CreateConfiguration: missing client data");
+                }
+            }
+            zwlr_output_manager_v1::Request::Stop => {
+                if let Some(c) = state.output_management_state().clients.remove(&client.id()) {
+                    c.manager.finished()
+                }
+            }
+            _ => unreachable!(),
+        }
+    }
+    fn destroyed(state: &mut D, client: ClientId, _resource: &ZwlrOutputManagerV1, _data: &()) {
+        state.output_management_state().clients.remove(&client);
+    }
+}
+
+impl<D> Dispatch<ZwlrOutputConfigurationV1, u32, D> for OutputManagementManagerState
+where
+    D: GlobalDispatch<ZwlrOutputManagerV1, OutputManagementManagerGlobalData>,
+    D: Dispatch<ZwlrOutputManagerV1, ()>,
+    D: Dispatch<ZwlrOutputHeadV1, OutputId>,
+    D: Dispatch<ZwlrOutputConfigurationV1, u32>,
+    D: Dispatch<ZwlrOutputConfigurationHeadV1, OutputConfigurationHeadState>,
+    D: Dispatch<ZwlrOutputModeV1, ()>,
+    D: OutputManagementHandler,
+    D: 'static,
+{
+    fn request(
+        state: &mut D,
+        client: &Client,
+        conf: &ZwlrOutputConfigurationV1,
+        request: zwlr_output_configuration_v1::Request,
+        serial: &u32,
+        _display: &DisplayHandle,
+        data_init: &mut DataInit<'_, D>,
+    ) {
+        let g_state = state.output_management_state();
+        let outdated = *serial != g_state.serial;
+        if outdated {
+            debug!("OutputConfiguration: request from an outdated configuration");
+        }
+
+        let new_config = g_state
+            .clients
+            .get_mut(&client.id())
+            .and_then(|data| data.confs.get_mut(conf));
+        if new_config.is_none() {
+            error!("OutputConfiguration: request from unknown configuration object");
+        }
+
+        match request {
+            zwlr_output_configuration_v1::Request::EnableHead { id, head } => {
+                let Some(output) = head.data::<OutputId>() else {
+                    error!("EnableHead: Missing attached output");
+                    let _fail = data_init.init(id, OutputConfigurationHeadState::Cancelled);
+                    return;
+                };
+                if outdated {
+                    let _fail = data_init.init(id, OutputConfigurationHeadState::Cancelled);
+                    return;
+                }
+
+                let Some(new_config) = new_config else {
+                    let _fail = data_init.init(id, OutputConfigurationHeadState::Cancelled);
+                    return;
+                };
+
+                let OutputConfigurationState::Ongoing(new_config) = new_config else {
+                    let _fail = data_init.init(id, OutputConfigurationHeadState::Cancelled);
+                    conf.post_error(
+                        zwlr_output_configuration_v1::Error::AlreadyUsed,
+                        "configuration had already been used",
+                    );
+                    return;
+                };
+
+                let Some(current_config) = g_state.current_state.get(output) else {
+                    error!("EnableHead: output missing from current config");
+                    let _fail = data_init.init(id, OutputConfigurationHeadState::Cancelled);
+                    return;
+                };
+
+                match new_config.entry(*output) {
+                    Entry::Occupied(_) => {
+                        let _fail = data_init.init(id, OutputConfigurationHeadState::Cancelled);
+                        conf.post_error(
+                            zwlr_output_configuration_v1::Error::AlreadyConfiguredHead,
+                            "head has been already configured",
+                        );
+                        return;
+                    }
+                    Entry::Vacant(entry) => {
+                        let name = OutputName::from_ipc_output(current_config);
+                        let mut config = g_state
+                            .current_config
+                            .find(&name)
+                            .cloned()
+                            .unwrap_or_else(|| niri_config::Output {
+                                name: name.format_make_model_serial_or_connector(),
+                                ..Default::default()
+                            });
+                        config.off = false;
+                        entry.insert(config);
+                    }
+                };
+
+                data_init.init(id, OutputConfigurationHeadState::Ok(*output, conf.clone()));
+            }
+            zwlr_output_configuration_v1::Request::DisableHead { head } => {
+                if outdated {
+                    return;
+                }
+                let Some(output) = head.data::<OutputId>() else {
+                    error!("DisableHead: missing attached output head name");
+                    return;
+                };
+
+                let Some(new_config) = new_config else {
+                    return;
+                };
+
+                let OutputConfigurationState::Ongoing(new_config) = new_config else {
+                    conf.post_error(
+                        zwlr_output_configuration_v1::Error::AlreadyUsed,
+                        "configuration had already been used",
+                    );
+                    return;
+                };
+
+                let Some(current_config) = g_state.current_state.get(output) else {
+                    error!("EnableHead: output missing from current config");
+                    return;
+                };
+
+                match new_config.entry(*output) {
+                    Entry::Occupied(_) => {
+                        conf.post_error(
+                            zwlr_output_configuration_v1::Error::AlreadyConfiguredHead,
+                            "head has been already configured",
+                        );
+                    }
+                    Entry::Vacant(entry) => {
+                        let name = OutputName::from_ipc_output(current_config);
+                        let mut config = g_state
+                            .current_config
+                            .find(&name)
+                            .cloned()
+                            .unwrap_or_else(|| niri_config::Output {
+                                name: name.format_make_model_serial_or_connector(),
+                                ..Default::default()
+                            });
+                        config.off = true;
+                        entry.insert(config);
+                    }
+                };
+            }
+            zwlr_output_configuration_v1::Request::Apply => {
+                if outdated {
+                    conf.cancelled();
+                    return;
+                }
+
+                let Some(new_config) = new_config else {
+                    return;
+                };
+
+                let OutputConfigurationState::Ongoing(new_config) =
+                    mem::replace(new_config, OutputConfigurationState::Finished)
+                else {
+                    conf.post_error(
+                        zwlr_output_configuration_v1::Error::AlreadyUsed,
+                        "configuration had already been used",
+                    );
+                    return;
+                };
+
+                let any_enabled = new_config.values().any(|c| !c.off);
+                if !any_enabled {
+                    conf.failed();
+                    return;
+                }
+
+                state.apply_output_config(new_config.into_values().collect());
+                // FIXME: verify that it had been applied successfully (which may be difficult).
+                conf.succeeded();
+            }
+            zwlr_output_configuration_v1::Request::Test => {
+                if outdated {
+                    conf.cancelled();
+                    return;
+                }
+
+                let Some(new_config) = new_config else {
+                    return;
+                };
+
+                let OutputConfigurationState::Ongoing(new_config) =
+                    mem::replace(new_config, OutputConfigurationState::Finished)
+                else {
+                    conf.post_error(
+                        zwlr_output_configuration_v1::Error::AlreadyUsed,
+                        "configuration had already been used",
+                    );
+                    return;
+                };
+
+                let any_enabled = new_config.values().any(|c| !c.off);
+                if !any_enabled {
+                    conf.failed();
+                    return;
+                }
+
+                // FIXME: actually test the configuration with TTY.
+                conf.succeeded()
+            }
+            zwlr_output_configuration_v1::Request::Destroy => {
+                g_state
+                    .clients
+                    .get_mut(&client.id())
+                    .map(|d| d.confs.remove(conf));
+            }
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl<D> Dispatch<ZwlrOutputConfigurationHeadV1, OutputConfigurationHeadState, D>
+    for OutputManagementManagerState
+where
+    D: GlobalDispatch<ZwlrOutputManagerV1, OutputManagementManagerGlobalData>,
+    D: Dispatch<ZwlrOutputManagerV1, ()>,
+    D: Dispatch<ZwlrOutputHeadV1, OutputId>,
+    D: Dispatch<ZwlrOutputConfigurationV1, u32>,
+    D: Dispatch<ZwlrOutputConfigurationHeadV1, OutputConfigurationHeadState>,
+    D: Dispatch<ZwlrOutputModeV1, ()>,
+    D: OutputManagementHandler,
+    D: 'static,
+{
+    fn request(
+        state: &mut D,
+        client: &Client,
+        conf_head: &ZwlrOutputConfigurationHeadV1,
+        request: zwlr_output_configuration_head_v1::Request,
+        data: &OutputConfigurationHeadState,
+        _display: &DisplayHandle,
+        _data_init: &mut DataInit<'_, D>,
+    ) {
+        let g_state = state.output_management_state();
+        let Some(client_data) = g_state.clients.get_mut(&client.id()) else {
+            error!("ConfigurationHead: missing client data");
+            return;
+        };
+        let OutputConfigurationHeadState::Ok(output_id, conf) = data else {
+            warn!("ConfigurationHead: request sent to a cancelled head");
+            return;
+        };
+        let Some(serial) = conf.data::<u32>() else {
+            error!("ConfigurationHead: missing serial");
+            return;
+        };
+        if *serial != g_state.serial {
+            warn!("ConfigurationHead: request sent to an outdated");
+            return;
+        }
+        let Some(new_config) = client_data.confs.get_mut(conf) else {
+            error!("ConfigurationHead: unknown configuration");
+            return;
+        };
+        let OutputConfigurationState::Ongoing(new_config) = new_config else {
+            conf.post_error(
+                zwlr_output_configuration_v1::Error::AlreadyUsed,
+                "configuration had already been used",
+            );
+            return;
+        };
+        let Some(new_config) = new_config.get_mut(output_id) else {
+            error!("ConfigurationHead: config missing from enabled heads");
+            return;
+        };
+
+        match request {
+            zwlr_output_configuration_head_v1::Request::SetMode { mode } => {
+                let index = match client_data
+                    .heads
+                    .get(output_id)
+                    .map(|(_, mods)| mods.iter().position(|m| m.id() == mode.id()))
+                {
+                    Some(Some(index)) => index,
+                    _ => {
+                        warn!("SetMode: failed to find requested mode");
+                        conf_head.post_error(
+                            zwlr_output_configuration_head_v1::Error::InvalidMode,
+                            "failed to find requested mode",
+                        );
+                        return;
+                    }
+                };
+
+                let Some(current_config) = g_state.current_state.get(output_id) else {
+                    warn!("SetMode: output missing from the current config");
+                    return;
+                };
+
+                let Some(mode) = current_config.modes.get(index) else {
+                    error!("SetMode: requested mode is out of range");
+                    return;
+                };
+
+                new_config.mode = Some(niri_ipc::ConfiguredMode {
+                    width: mode.width,
+                    height: mode.height,
+                    refresh: Some(mode.refresh_rate as f64 / 1000.),
+                });
+            }
+            zwlr_output_configuration_head_v1::Request::SetCustomMode {
+                width,
+                height,
+                refresh,
+            } => {
+                // FIXME: Support custom mode
+                let (width, height, refresh): (u16, u16, u32) =
+                    match (width.try_into(), height.try_into(), refresh.try_into()) {
+                        (Ok(width), Ok(height), Ok(refresh)) => (width, height, refresh),
+                        _ => {
+                            warn!("SetCustomMode: invalid input data");
+                            return;
+                        }
+                    };
+
+                let Some(current_config) = g_state.current_state.get(output_id) else {
+                    warn!("SetMode: output missing from the current config");
+                    return;
+                };
+
+                let Some(mode) = current_config.modes.iter().find(|m| {
+                    m.width == width
+                        && m.height == height
+                        && (refresh == 0 || m.refresh_rate == refresh)
+                }) else {
+                    warn!("SetCustomMode: no matching mode");
+                    return;
+                };
+
+                new_config.mode = Some(niri_ipc::ConfiguredMode {
+                    width: mode.width,
+                    height: mode.height,
+                    refresh: Some(mode.refresh_rate as f64 / 1000.),
+                });
+            }
+            zwlr_output_configuration_head_v1::Request::SetPosition { x, y } => {
+                new_config.position = Some(niri_config::Position { x, y });
+            }
+            zwlr_output_configuration_head_v1::Request::SetTransform { transform } => {
+                let transform = match transform {
+                    WEnum::Value(WlTransform::Normal) => Transform::Normal,
+                    WEnum::Value(WlTransform::_90) => Transform::_90,
+                    WEnum::Value(WlTransform::_180) => Transform::_180,
+                    WEnum::Value(WlTransform::_270) => Transform::_270,
+                    WEnum::Value(WlTransform::Flipped) => Transform::Flipped,
+                    WEnum::Value(WlTransform::Flipped90) => Transform::Flipped90,
+                    WEnum::Value(WlTransform::Flipped180) => Transform::Flipped180,
+                    WEnum::Value(WlTransform::Flipped270) => Transform::Flipped270,
+                    _ => {
+                        warn!("SetTransform: unknown requested transform");
+                        conf_head.post_error(
+                            zwlr_output_configuration_head_v1::Error::InvalidTransform,
+                            "unknown transform value",
+                        );
+                        return;
+                    }
+                };
+                new_config.transform = transform;
+            }
+            zwlr_output_configuration_head_v1::Request::SetScale { scale } => {
+                if scale <= 0. {
+                    conf_head.post_error(
+                        zwlr_output_configuration_head_v1::Error::InvalidScale,
+                        "scale is negative or zero",
+                    );
+                    return;
+                }
+                new_config.scale = Some(FloatOrInt(scale));
+            }
+            zwlr_output_configuration_head_v1::Request::SetAdaptiveSync { state } => {
+                let vrr = match state {
+                    WEnum::Value(AdaptiveSyncState::Enabled) => Some(Vrr { on_demand: false }),
+                    WEnum::Value(AdaptiveSyncState::Disabled) => None,
+                    _ => {
+                        warn!("SetAdaptativeSync: unknown requested adaptative sync");
+                        conf_head.post_error(
+                            zwlr_output_configuration_head_v1::Error::InvalidAdaptiveSyncState,
+                            "unknown adaptive sync value",
+                        );
+                        return;
+                    }
+                };
+                new_config.variable_refresh_rate = vrr;
+            }
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl<D> Dispatch<ZwlrOutputHeadV1, OutputId, D> for OutputManagementManagerState
+where
+    D: GlobalDispatch<ZwlrOutputManagerV1, OutputManagementManagerGlobalData>,
+    D: Dispatch<ZwlrOutputManagerV1, ()>,
+    D: Dispatch<ZwlrOutputHeadV1, OutputId>,
+    D: Dispatch<ZwlrOutputConfigurationV1, u32>,
+    D: Dispatch<ZwlrOutputConfigurationHeadV1, OutputConfigurationHeadState>,
+    D: Dispatch<ZwlrOutputModeV1, ()>,
+    D: OutputManagementHandler,
+    D: 'static,
+{
+    fn request(
+        _state: &mut D,
+        _client: &Client,
+        _output_head: &ZwlrOutputHeadV1,
+        request: zwlr_output_head_v1::Request,
+        _data: &OutputId,
+        _display: &DisplayHandle,
+        _data_init: &mut DataInit<'_, D>,
+    ) {
+        match request {
+            zwlr_output_head_v1::Request::Release => {}
+            _ => unreachable!(),
+        }
+    }
+    fn destroyed(state: &mut D, client: ClientId, _resource: &ZwlrOutputHeadV1, data: &OutputId) {
+        if let Some(c) = state.output_management_state().clients.get_mut(&client) {
+            c.heads.remove(data);
+        }
+    }
+}
+
+impl<D> Dispatch<ZwlrOutputModeV1, (), D> for OutputManagementManagerState
+where
+    D: GlobalDispatch<ZwlrOutputManagerV1, OutputManagementManagerGlobalData>,
+    D: Dispatch<ZwlrOutputManagerV1, ()>,
+    D: Dispatch<ZwlrOutputHeadV1, OutputId>,
+    D: Dispatch<ZwlrOutputConfigurationV1, u32>,
+    D: Dispatch<ZwlrOutputConfigurationHeadV1, OutputConfigurationHeadState>,
+    D: Dispatch<ZwlrOutputModeV1, ()>,
+    D: OutputManagementHandler,
+    D: 'static,
+{
+    fn request(
+        _state: &mut D,
+        _client: &Client,
+        _mode: &ZwlrOutputModeV1,
+        request: zwlr_output_mode_v1::Request,
+        _data: &(),
+        _display: &DisplayHandle,
+        _data_init: &mut DataInit<'_, D>,
+    ) {
+        match request {
+            zwlr_output_mode_v1::Request::Release => {}
+            _ => unreachable!(),
+        }
+    }
+}
+
+#[macro_export]
+macro_rules! delegate_output_management{
+    ($(@<$( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+>)? $ty: ty) => {
+        smithay::reexports::wayland_server::delegate_global_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            smithay::reexports::wayland_protocols_wlr::output_management::v1::server::zwlr_output_manager_v1::ZwlrOutputManagerV1: $crate::protocols::output_management::OutputManagementManagerGlobalData
+        ] => $crate::protocols::output_management::OutputManagementManagerState);
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            smithay::reexports::wayland_protocols_wlr::output_management::v1::server::zwlr_output_manager_v1::ZwlrOutputManagerV1: ()
+        ] => $crate::protocols::output_management::OutputManagementManagerState);
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            smithay::reexports::wayland_protocols_wlr::output_management::v1::server::zwlr_output_configuration_v1::ZwlrOutputConfigurationV1: u32
+        ] => $crate::protocols::output_management::OutputManagementManagerState);
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            smithay::reexports::wayland_protocols_wlr::output_management::v1::server::zwlr_output_head_v1::ZwlrOutputHeadV1: $crate::backend::OutputId
+        ] => $crate::protocols::output_management::OutputManagementManagerState);
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            smithay::reexports::wayland_protocols_wlr::output_management::v1::server::zwlr_output_mode_v1::ZwlrOutputModeV1: ()
+        ] => $crate::protocols::output_management::OutputManagementManagerState);
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            smithay::reexports::wayland_protocols_wlr::output_management::v1::server::zwlr_output_configuration_head_v1::ZwlrOutputConfigurationHeadV1: $crate::protocols::output_management::OutputConfigurationHeadState
+        ] => $crate::protocols::output_management::OutputManagementManagerState);
+    };
+}
+
+fn notify_removed_head(clients: &mut HashMap<ClientId, ClientData>, head: &OutputId) {
+    for data in clients.values_mut() {
+        if let Some((head, mods)) = data.heads.remove(head) {
+            mods.iter().for_each(|m| m.finished());
+            head.finished();
+        }
+    }
+}
+
+fn notify_new_head(
+    state: &mut OutputManagementManagerState,
+    output: &OutputId,
+    conf: &niri_ipc::Output,
+) {
+    let display = &state.display;
+    let clients = &mut state.clients;
+    for data in clients.values_mut() {
+        if let Some(client) = data.manager.client() {
+            send_new_head::<State>(display, &client, data, *output, conf);
+        }
+    }
+}
+
+fn send_new_head<D>(
+    display: &DisplayHandle,
+    client: &Client,
+    client_data: &mut ClientData,
+    output: OutputId,
+    conf: &niri_ipc::Output,
+) where
+    D: GlobalDispatch<ZwlrOutputManagerV1, OutputManagementManagerGlobalData>,
+    D: Dispatch<ZwlrOutputManagerV1, ()>,
+    D: Dispatch<ZwlrOutputConfigurationV1, u32>,
+    D: Dispatch<ZwlrOutputConfigurationHeadV1, OutputConfigurationHeadState>,
+    D: Dispatch<ZwlrOutputModeV1, ()>,
+    D: OutputManagementHandler,
+    D: 'static,
+    D: Dispatch<ZwlrOutputHeadV1, OutputId>,
+    D: Dispatch<ZwlrOutputModeV1, ()>,
+    D: 'static,
+{
+    let new_head = client
+        .create_resource::<ZwlrOutputHeadV1, _, D>(display, client_data.manager.version(), output)
+        .unwrap();
+    client_data.manager.head(&new_head);
+    new_head.name(conf.name.clone());
+    // Format matches what Output::new() does internally.
+    new_head.description(format!("{} - {} - {}", conf.make, conf.model, conf.name));
+    if let Some((width, height)) = conf.physical_size {
+        if let (Ok(a), Ok(b)) = (width.try_into(), height.try_into()) {
+            new_head.physical_size(a, b);
+        }
+    }
+    let mut new_modes = Vec::with_capacity(conf.modes.len());
+    for (index, mode) in conf.modes.iter().enumerate() {
+        let new_mode = client
+            .create_resource::<ZwlrOutputModeV1, _, D>(display, new_head.version(), ())
+            .unwrap();
+        new_head.mode(&new_mode);
+        new_mode.size(i32::from(mode.width), i32::from(mode.height));
+        if mode.is_preferred {
+            new_mode.preferred();
+        }
+        if let Ok(refresh_rate) = mode.refresh_rate.try_into() {
+            new_mode.refresh(refresh_rate);
+        }
+        if Some(index) == conf.current_mode {
+            new_head.current_mode(&new_mode);
+        }
+        new_modes.push(new_mode);
+    }
+    if let Some(logical) = conf.logical {
+        new_head.position(logical.x, logical.y);
+        new_head.transform(ipc_transform_to_smithay(logical.transform).into());
+        new_head.scale(logical.scale);
+    }
+    new_head.enabled(conf.current_mode.is_some() as i32);
+    if new_head.version() >= zwlr_output_head_v1::EVT_MAKE_SINCE {
+        new_head.make(conf.make.clone());
+    }
+    if new_head.version() >= zwlr_output_head_v1::EVT_MODEL_SINCE {
+        new_head.model(conf.model.clone());
+    }
+    if new_head.version() >= zwlr_output_head_v1::EVT_SERIAL_NUMBER_SINCE {
+        if let Some(serial) = &conf.serial {
+            new_head.serial_number(serial.clone());
+        }
+    }
+
+    if new_head.version() >= zwlr_output_head_v1::EVT_ADAPTIVE_SYNC_SINCE {
+        new_head.adaptive_sync(match conf.vrr_enabled {
+            true => AdaptiveSyncState::Enabled,
+            false => AdaptiveSyncState::Disabled,
+        });
+    }
+    // new_head.serial_number(output.serial);
+    client_data.heads.insert(output, (new_head, new_modes));
+}
@@ -0,0 +1,25 @@
+pub mod mutter_x11_interop {
+    pub mod v1 {
+        pub use self::generated::server;
+
+        mod generated {
+            pub mod server {
+                #![allow(dead_code, non_camel_case_types, unused_unsafe, unused_variables)]
+                #![allow(non_upper_case_globals, non_snake_case, unused_imports)]
+                #![allow(missing_docs, clippy::all)]
+
+                use smithay::reexports::wayland_server;
+                use wayland_server::protocol::*;
+
+                pub mod __interfaces {
+                    use smithay::reexports::wayland_server;
+                    use wayland_server::protocol::__interfaces::*;
+                    wayland_scanner::generate_interfaces!("resources/mutter-x11-interop.xml");
+                }
+                use self::__interfaces::*;
+
+                wayland_scanner::generate_server_code!("resources/mutter-x11-interop.xml");
+            }
+        }
+    }
+}
@@ -0,0 +1,508 @@
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use std::time::Duration;
+
+use calloop::generic::Generic;
+use calloop::{Interest, LoopHandle, Mode, PostAction};
+use smithay::backend::allocator::dmabuf::Dmabuf;
+use smithay::backend::allocator::{Buffer, Fourcc};
+use smithay::backend::renderer::damage::OutputDamageTracker;
+use smithay::backend::renderer::sync::SyncPoint;
+use smithay::output::Output;
+use smithay::reexports::wayland_protocols_wlr::screencopy::v1::server::zwlr_screencopy_frame_v1::{
+    Flags, ZwlrScreencopyFrameV1,
+};
+use smithay::reexports::wayland_protocols_wlr::screencopy::v1::server::zwlr_screencopy_manager_v1::ZwlrScreencopyManagerV1;
+use smithay::reexports::wayland_protocols_wlr::screencopy::v1::server::{
+    zwlr_screencopy_frame_v1, zwlr_screencopy_manager_v1,
+};
+use smithay::reexports::wayland_server::protocol::wl_buffer::WlBuffer;
+use smithay::reexports::wayland_server::protocol::wl_shm::Format;
+use smithay::reexports::wayland_server::{
+    Client, DataInit, Dispatch, DisplayHandle, GlobalDispatch, New, Resource,
+};
+use smithay::utils::{Physical, Point, Rectangle, Size, Transform};
+use smithay::wayland::{dmabuf, shm};
+
+use crate::utils::get_monotonic_time;
+
+const VERSION: u32 = 3;
+
+pub struct ScreencopyQueue {
+    damage_tracker: OutputDamageTracker,
+    screencopies: Vec<Screencopy>,
+}
+
+impl Default for ScreencopyQueue {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ScreencopyQueue {
+    pub fn new() -> Self {
+        Self {
+            damage_tracker: OutputDamageTracker::new((0, 0), 1.0, Transform::Normal),
+            screencopies: Vec::new(),
+        }
+    }
+
+    pub fn split(&mut self) -> (&mut OutputDamageTracker, Option<&Screencopy>) {
+        let ScreencopyQueue {
+            damage_tracker,
+            screencopies,
+        } = self;
+        (damage_tracker, screencopies.first())
+    }
+
+    pub fn push(&mut self, screencopy: Screencopy) {
+        self.screencopies.push(screencopy);
+    }
+
+    pub fn pop(&mut self) -> Screencopy {
+        self.screencopies.pop().unwrap()
+    }
+
+    pub fn remove_output(&mut self, output: &Output) {
+        self.screencopies
+            .retain(|screencopy| screencopy.output() != output);
+    }
+}
+
+#[derive(Default)]
+pub struct ScreencopyManagerState {
+    queues: HashMap<ZwlrScreencopyManagerV1, ScreencopyQueue>,
+}
+
+pub struct ScreencopyManagerGlobalData {
+    filter: Box<dyn for<'c> Fn(&'c Client) -> bool + Send + Sync>,
+}
+
+impl ScreencopyManagerState {
+    pub fn new<D, F>(display: &DisplayHandle, filter: F) -> Self
+    where
+        D: GlobalDispatch<ZwlrScreencopyManagerV1, ScreencopyManagerGlobalData>,
+        D: Dispatch<ZwlrScreencopyManagerV1, ()>,
+        D: Dispatch<ZwlrScreencopyFrameV1, ScreencopyFrameState>,
+        D: ScreencopyHandler,
+        D: 'static,
+        F: for<'c> Fn(&'c Client) -> bool + Send + Sync + 'static,
+    {
+        let global_data = ScreencopyManagerGlobalData {
+            filter: Box::new(filter),
+        };
+        display.create_global::<D, ZwlrScreencopyManagerV1, _>(VERSION, global_data);
+
+        Self {
+            queues: HashMap::new(),
+        }
+    }
+
+    pub fn bind(&mut self, manager: &ZwlrScreencopyManagerV1) {
+        // Clean up all entries if its manager is dead and its queue is empty.
+        self.queues
+            .retain(|k, v| k.is_alive() || !v.screencopies.is_empty());
+
+        self.queues.insert(manager.clone(), ScreencopyQueue::new());
+    }
+
+    pub fn get_queue_mut(
+        &mut self,
+        manager: &ZwlrScreencopyManagerV1,
+    ) -> Option<&mut ScreencopyQueue> {
+        self.queues.get_mut(manager)
+    }
+
+    pub fn queues_mut(&mut self) -> impl Iterator<Item = &mut ScreencopyQueue> {
+        self.queues.values_mut()
+    }
+}
+
+impl<D> GlobalDispatch<ZwlrScreencopyManagerV1, ScreencopyManagerGlobalData, D>
+    for ScreencopyManagerState
+where
+    D: GlobalDispatch<ZwlrScreencopyManagerV1, ScreencopyManagerGlobalData>,
+    D: Dispatch<ZwlrScreencopyManagerV1, ()>,
+    D: Dispatch<ZwlrScreencopyFrameV1, ScreencopyFrameState>,
+    D: ScreencopyHandler,
+    D: 'static,
+{
+    fn bind(
+        state: &mut D,
+        _display: &DisplayHandle,
+        _client: &Client,
+        manager: New<ZwlrScreencopyManagerV1>,
+        _manager_state: &ScreencopyManagerGlobalData,
+        data_init: &mut DataInit<'_, D>,
+    ) {
+        let manager = data_init.init(manager, ());
+        state.screencopy_state().bind(&manager);
+    }
+
+    fn can_view(client: Client, global_data: &ScreencopyManagerGlobalData) -> bool {
+        (global_data.filter)(&client)
+    }
+}
+
+impl<D> Dispatch<ZwlrScreencopyManagerV1, (), D> for ScreencopyManagerState
+where
+    D: GlobalDispatch<ZwlrScreencopyManagerV1, ScreencopyManagerGlobalData>,
+    D: Dispatch<ZwlrScreencopyManagerV1, ()>,
+    D: Dispatch<ZwlrScreencopyFrameV1, ScreencopyFrameState>,
+    D: ScreencopyHandler,
+    D: 'static,
+{
+    fn request(
+        _state: &mut D,
+        _client: &Client,
+        manager: &ZwlrScreencopyManagerV1,
+        request: zwlr_screencopy_manager_v1::Request,
+        _data: &(),
+        _display: &DisplayHandle,
+        data_init: &mut DataInit<'_, D>,
+    ) {
+        let (frame, overlay_cursor, buffer_size, region_loc, output) = match request {
+            zwlr_screencopy_manager_v1::Request::CaptureOutput {
+                frame,
+                overlay_cursor,
+                output,
+            } => {
+                let Some(output) = Output::from_resource(&output) else {
+                    trace!("screencopy client requested non-existent output");
+                    let frame = data_init.init(frame, ScreencopyFrameState::Failed);
+                    frame.failed();
+                    return;
+                };
+
+                let buffer_size = output.current_mode().unwrap().size;
+                let region_loc = Point::from((0, 0));
+
+                (frame, overlay_cursor, buffer_size, region_loc, output)
+            }
+            zwlr_screencopy_manager_v1::Request::CaptureOutputRegion {
+                frame,
+                overlay_cursor,
+                x,
+                y,
+                width,
+                height,
+                output,
+            } => {
+                if width <= 0 || height <= 0 {
+                    trace!("screencopy client requested invalid sized region");
+                    let frame = data_init.init(frame, ScreencopyFrameState::Failed);
+                    frame.failed();
+                    return;
+                }
+
+                let Some(output) = Output::from_resource(&output) else {
+                    trace!("screencopy client requested non-existent output");
+                    let frame = data_init.init(frame, ScreencopyFrameState::Failed);
+                    frame.failed();
+                    return;
+                };
+
+                let output_transform = output.current_transform();
+                let output_physical_size =
+                    output_transform.transform_size(output.current_mode().unwrap().size);
+                let output_rect = Rectangle::from_loc_and_size((0, 0), output_physical_size);
+
+                let rect = Rectangle::from_loc_and_size((x, y), (width, height));
+
+                let output_scale = output.current_scale().fractional_scale();
+                let physical_rect = rect.to_physical_precise_round(output_scale);
+
+                // Clamp captured region to the output.
+                let Some(clamped_rect) = physical_rect.intersection(output_rect) else {
+                    trace!("screencopy client requested region outside of output");
+                    let frame = data_init.init(frame, ScreencopyFrameState::Failed);
+                    frame.failed();
+                    return;
+                };
+
+                let untransformed_rect = output_transform
+                    .invert()
+                    .transform_rect_in(clamped_rect, &output_physical_size);
+
+                (
+                    frame,
+                    overlay_cursor,
+                    untransformed_rect.size,
+                    clamped_rect.loc,
+                    output,
+                )
+            }
+            zwlr_screencopy_manager_v1::Request::Destroy => return,
+            _ => unreachable!(),
+        };
+
+        // Create the frame.
+        let overlay_cursor = overlay_cursor != 0;
+        let info = ScreencopyFrameInfo {
+            output,
+            overlay_cursor,
+            buffer_size,
+            region_loc,
+        };
+        let frame = data_init.init(
+            frame,
+            ScreencopyFrameState::Pending {
+                manager: manager.clone(),
+                info,
+                copied: Arc::new(AtomicBool::new(false)),
+            },
+        );
+
+        // Send desired SHM buffer parameters.
+        frame.buffer(
+            Format::Xrgb8888,
+            buffer_size.w as u32,
+            buffer_size.h as u32,
+            buffer_size.w as u32 * 4,
+        );
+
+        if frame.version() >= 3 {
+            // Send desired DMA buffer parameters.
+            frame.linux_dmabuf(
+                Fourcc::Xrgb8888 as u32,
+                buffer_size.w as u32,
+                buffer_size.h as u32,
+            );
+
+            // Notify client that all supported buffers were enumerated.
+            frame.buffer_done();
+        }
+    }
+}
+
+/// Handler trait for wlr-screencopy.
+pub trait ScreencopyHandler {
+    /// Handle new screencopy request.
+    fn frame(&mut self, manager: &ZwlrScreencopyManagerV1, screencopy: Screencopy);
+    fn screencopy_state(&mut self) -> &mut ScreencopyManagerState;
+}
+
+#[allow(missing_docs)]
+#[macro_export]
+macro_rules! delegate_screencopy {
+    ($(@<$( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+>)? $ty: ty) => {
+        smithay::reexports::wayland_server::delegate_global_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            smithay::reexports::wayland_protocols_wlr::screencopy::v1::server::zwlr_screencopy_manager_v1::ZwlrScreencopyManagerV1: $crate::protocols::screencopy::ScreencopyManagerGlobalData
+        ] => $crate::protocols::screencopy::ScreencopyManagerState);
+
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            smithay::reexports::wayland_protocols_wlr::screencopy::v1::server::zwlr_screencopy_manager_v1::ZwlrScreencopyManagerV1: ()
+        ] => $crate::protocols::screencopy::ScreencopyManagerState);
+
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            smithay::reexports::wayland_protocols_wlr::screencopy::v1::server::zwlr_screencopy_frame_v1::ZwlrScreencopyFrameV1: $crate::protocols::screencopy::ScreencopyFrameState
+        ] => $crate::protocols::screencopy::ScreencopyManagerState);
+    };
+}
+
+#[derive(Clone)]
+pub struct ScreencopyFrameInfo {
+    output: Output,
+    buffer_size: Size<i32, Physical>,
+    region_loc: Point<i32, Physical>,
+    overlay_cursor: bool,
+}
+
+pub enum ScreencopyFrameState {
+    Failed,
+    Pending {
+        manager: ZwlrScreencopyManagerV1,
+        info: ScreencopyFrameInfo,
+        copied: Arc<AtomicBool>,
+    },
+}
+
+impl<D> Dispatch<ZwlrScreencopyFrameV1, ScreencopyFrameState, D> for ScreencopyManagerState
+where
+    D: Dispatch<ZwlrScreencopyFrameV1, ScreencopyFrameState>,
+    D: ScreencopyHandler,
+    D: 'static,
+{
+    fn request(
+        state: &mut D,
+        _client: &Client,
+        frame: &ZwlrScreencopyFrameV1,
+        request: zwlr_screencopy_frame_v1::Request,
+        data: &ScreencopyFrameState,
+        _display: &DisplayHandle,
+        _data_init: &mut DataInit<'_, D>,
+    ) {
+        if matches!(request, zwlr_screencopy_frame_v1::Request::Destroy) {
+            return;
+        }
+
+        let ScreencopyFrameState::Pending {
+            manager,
+            info,
+            copied,
+        } = data
+        else {
+            return;
+        };
+
+        if copied.load(Ordering::SeqCst) {
+            frame.post_error(
+                zwlr_screencopy_frame_v1::Error::AlreadyUsed,
+                "copy was already requested",
+            );
+            return;
+        }
+
+        let (buffer, with_damage) = match request {
+            zwlr_screencopy_frame_v1::Request::Copy { buffer } => (buffer, false),
+            zwlr_screencopy_frame_v1::Request::CopyWithDamage { buffer } => (buffer, true),
+            _ => unreachable!(),
+        };
+
+        let size = info.buffer_size;
+
+        let buffer = if let Ok(dmabuf) = dmabuf::get_dmabuf(&buffer) {
+            if dmabuf.format().code == Fourcc::Xrgb8888
+                && dmabuf.width() == size.w as u32
+                && dmabuf.height() == size.h as u32
+            {
+                ScreencopyBuffer::Dmabuf(dmabuf.clone())
+            } else {
+                frame.post_error(
+                    zwlr_screencopy_frame_v1::Error::InvalidBuffer,
+                    "invalid dmabuf parameters",
+                );
+                return;
+            }
+        } else if shm::with_buffer_contents(&buffer, |_, shm_len, buffer_data| {
+            buffer_data.format == Format::Xrgb8888
+                && buffer_data.width == size.w
+                && buffer_data.height == size.h
+                && buffer_data.stride == size.w * 4
+                && shm_len == buffer_data.stride as usize * buffer_data.height as usize
+        })
+        .unwrap_or(false)
+        {
+            ScreencopyBuffer::Shm(buffer)
+        } else {
+            frame.post_error(
+                zwlr_screencopy_frame_v1::Error::InvalidBuffer,
+                "invalid buffer",
+            );
+            return;
+        };
+
+        copied.store(true, Ordering::SeqCst);
+
+        state.frame(
+            manager,
+            Screencopy {
+                buffer,
+                frame: frame.clone(),
+                info: info.clone(),
+                with_damage,
+                submitted: false,
+            },
+        );
+    }
+}
+
+/// Screencopy buffer.
+#[derive(Clone)]
+pub enum ScreencopyBuffer {
+    Dmabuf(Dmabuf),
+    Shm(WlBuffer),
+}
+
+/// Screencopy frame.
+pub struct Screencopy {
+    info: ScreencopyFrameInfo,
+    frame: ZwlrScreencopyFrameV1,
+    buffer: ScreencopyBuffer,
+    with_damage: bool,
+    submitted: bool,
+}
+
+impl Drop for Screencopy {
+    fn drop(&mut self) {
+        if !self.submitted {
+            self.frame.failed();
+        }
+    }
+}
+
+impl Screencopy {
+    /// Get the target buffer to copy to.
+    pub fn buffer(&self) -> &ScreencopyBuffer {
+        &self.buffer
+    }
+
+    pub fn region_loc(&self) -> Point<i32, Physical> {
+        self.info.region_loc
+    }
+
+    pub fn buffer_size(&self) -> Size<i32, Physical> {
+        self.info.buffer_size
+    }
+
+    pub fn output(&self) -> &Output {
+        &self.info.output
+    }
+
+    pub fn overlay_cursor(&self) -> bool {
+        self.info.overlay_cursor
+    }
+
+    pub fn with_damage(&self) -> bool {
+        self.with_damage
+    }
+
+    pub fn damage(&self, damages: impl Iterator<Item = Rectangle<i32, smithay::utils::Buffer>>) {
+        for Rectangle { loc, size } in damages {
+            self.frame
+                .damage(loc.x as u32, loc.y as u32, size.w as u32, size.h as u32);
+        }
+    }
+
+    /// Submit the copied content.
+    fn submit(mut self, y_invert: bool, timestamp: Duration) {
+        // Notify client that buffer is ordinary.
+        self.frame.flags(if y_invert {
+            Flags::YInvert
+        } else {
+            Flags::empty()
+        });
+
+        // Notify client about successful copy.
+        let tv_sec_hi = (timestamp.as_secs() >> 32) as u32;
+        let tv_sec_lo = (timestamp.as_secs() & 0xFFFFFFFF) as u32;
+        let tv_nsec = timestamp.subsec_nanos();
+        self.frame.ready(tv_sec_hi, tv_sec_lo, tv_nsec);
+
+        // Mark frame as submitted to ensure destructor isn't run.
+        self.submitted = true;
+    }
+
+    pub fn submit_after_sync<T>(
+        self,
+        y_invert: bool,
+        sync_point: Option<SyncPoint>,
+        event_loop: &LoopHandle<'_, T>,
+    ) {
+        let timestamp = get_monotonic_time();
+        match sync_point.and_then(|s| s.export()) {
+            None => self.submit(y_invert, timestamp),
+            Some(sync_fd) => {
+                let source = Generic::new(sync_fd, Interest::READ, Mode::OneShot);
+                let mut screencopy = Some(self);
+                event_loop
+                    .insert_source(source, move |_, _, _| {
+                        screencopy.take().unwrap().submit(y_invert, timestamp);
+                        Ok(PostAction::Remove)
+                    })
+                    .unwrap();
+            }
+        }
+    }
+}
@@ -0,0 +1,301 @@
+use std::collections::HashMap;
+
+use glam::{Mat3, Vec2};
+use niri_config::{
+    Color, CornerRadius, GradientColorSpace, GradientInterpolation, HueInterpolation,
+};
+use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, UnderlyingStorage};
+use smithay::backend::renderer::gles::{GlesError, GlesFrame, GlesRenderer, Uniform};
+use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions};
+use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size, Transform};
+
+use super::renderer::NiriRenderer;
+use super::shader_element::ShaderRenderElement;
+use super::shaders::{mat3_uniform, ProgramType, Shaders};
+use crate::backend::tty::{TtyFrame, TtyRenderer, TtyRendererError};
+
+/// Renders a wide variety of borders and border parts.
+///
+/// This includes:
+/// * sub- or super-rect of an angled linear gradient like CSS linear-gradient(angle, a, b).
+/// * corner rounding.
+/// * as a background rectangle and as parts of a border line.
+#[derive(Debug, Clone)]
+pub struct BorderRenderElement {
+    inner: ShaderRenderElement,
+    params: Parameters,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+struct Parameters {
+    size: Size<f64, Logical>,
+    gradient_area: Rectangle<f64, Logical>,
+    gradient_format: GradientInterpolation,
+    color_from: Color,
+    color_to: Color,
+    angle: f32,
+    geometry: Rectangle<f64, Logical>,
+    border_width: f32,
+    corner_radius: CornerRadius,
+    // Should only be used for visual improvements, i.e. corner radius anti-aliasing.
+    scale: f32,
+}
+
+impl BorderRenderElement {
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        size: Size<f64, Logical>,
+        gradient_area: Rectangle<f64, Logical>,
+        gradient_format: GradientInterpolation,
+        color_from: Color,
+        color_to: Color,
+        angle: f32,
+        geometry: Rectangle<f64, Logical>,
+        border_width: f32,
+        corner_radius: CornerRadius,
+        scale: f32,
+    ) -> Self {
+        let inner = ShaderRenderElement::empty(ProgramType::Border, Kind::Unspecified);
+        let mut rv = Self {
+            inner,
+            params: Parameters {
+                size,
+                gradient_area,
+                gradient_format,
+                color_from,
+                color_to,
+                angle,
+                geometry,
+                border_width,
+                corner_radius,
+                scale,
+            },
+        };
+        rv.update_inner();
+        rv
+    }
+
+    pub fn empty() -> Self {
+        let inner = ShaderRenderElement::empty(ProgramType::Border, Kind::Unspecified);
+        Self {
+            inner,
+            params: Parameters {
+                size: Default::default(),
+                gradient_area: Default::default(),
+                gradient_format: GradientInterpolation::default(),
+                color_from: Default::default(),
+                color_to: Default::default(),
+                angle: 0.,
+                geometry: Default::default(),
+                border_width: 0.,
+                corner_radius: Default::default(),
+                scale: 1.,
+            },
+        }
+    }
+
+    pub fn damage_all(&mut self) {
+        self.inner.damage_all();
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn update(
+        &mut self,
+        size: Size<f64, Logical>,
+        gradient_area: Rectangle<f64, Logical>,
+        gradient_format: GradientInterpolation,
+        color_from: Color,
+        color_to: Color,
+        angle: f32,
+        geometry: Rectangle<f64, Logical>,
+        border_width: f32,
+        corner_radius: CornerRadius,
+        scale: f32,
+    ) {
+        let params = Parameters {
+            size,
+            gradient_area,
+            gradient_format,
+            color_from,
+            color_to,
+            angle,
+            geometry,
+            border_width,
+            corner_radius,
+            scale,
+        };
+        if self.params == params {
+            return;
+        }
+
+        self.params = params;
+        self.update_inner();
+    }
+
+    fn update_inner(&mut self) {
+        let Parameters {
+            size,
+            gradient_area,
+            gradient_format,
+            color_from,
+            color_to,
+            angle,
+            geometry,
+            border_width,
+            corner_radius,
+            scale,
+        } = self.params;
+
+        let grad_offset = geometry.loc - gradient_area.loc;
+        let grad_offset = Vec2::new(grad_offset.x as f32, grad_offset.y as f32);
+
+        let grad_dir = Vec2::from_angle(angle);
+
+        let (w, h) = (gradient_area.size.w as f32, gradient_area.size.h as f32);
+
+        let mut grad_area_diag = Vec2::new(w, h);
+        if (grad_dir.x < 0. && 0. <= grad_dir.y) || (0. <= grad_dir.x && grad_dir.y < 0.) {
+            grad_area_diag.x = -w;
+        }
+
+        let mut grad_vec = grad_area_diag.project_onto(grad_dir);
+        if grad_dir.y < 0. {
+            grad_vec = -grad_vec;
+        }
+
+        let area_size = Vec2::new(size.w as f32, size.h as f32);
+
+        let geo_loc = Vec2::new(geometry.loc.x as f32, geometry.loc.y as f32);
+        let geo_size = Vec2::new(geometry.size.w as f32, geometry.size.h as f32);
+
+        let input_to_geo =
+            Mat3::from_scale(area_size) * Mat3::from_translation(-geo_loc / area_size);
+
+        let colorspace = match gradient_format.color_space {
+            GradientColorSpace::Srgb => 0.,
+            GradientColorSpace::SrgbLinear => 1.,
+            GradientColorSpace::Oklab => 2.,
+            GradientColorSpace::Oklch => 3.,
+        };
+
+        let hue_interpolation = match gradient_format.hue_interpolation {
+            HueInterpolation::Shorter => 0.,
+            HueInterpolation::Longer => 1.,
+            HueInterpolation::Increasing => 2.,
+            HueInterpolation::Decreasing => 3.,
+        };
+
+        self.inner.update(
+            size,
+            None,
+            scale,
+            vec![
+                Uniform::new("colorspace", colorspace),
+                Uniform::new("hue_interpolation", hue_interpolation),
+                Uniform::new("color_from", color_from.to_array_unpremul()),
+                Uniform::new("color_to", color_to.to_array_unpremul()),
+                Uniform::new("grad_offset", grad_offset.to_array()),
+                Uniform::new("grad_width", w),
+                Uniform::new("grad_vec", grad_vec.to_array()),
+                mat3_uniform("input_to_geo", input_to_geo),
+                Uniform::new("geo_size", geo_size.to_array()),
+                Uniform::new("outer_radius", <[f32; 4]>::from(corner_radius)),
+                Uniform::new("border_width", border_width),
+            ],
+            HashMap::new(),
+        );
+    }
+
+    pub fn with_location(mut self, location: Point<f64, Logical>) -> Self {
+        self.inner = self.inner.with_location(location);
+        self
+    }
+
+    pub fn has_shader(renderer: &mut impl NiriRenderer) -> bool {
+        Shaders::get(renderer)
+            .program(ProgramType::Border)
+            .is_some()
+    }
+}
+
+impl Default for BorderRenderElement {
+    fn default() -> Self {
+        Self::empty()
+    }
+}
+
+impl Element for BorderRenderElement {
+    fn id(&self) -> &Id {
+        self.inner.id()
+    }
+
+    fn current_commit(&self) -> CommitCounter {
+        self.inner.current_commit()
+    }
+
+    fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
+        self.inner.geometry(scale)
+    }
+
+    fn transform(&self) -> Transform {
+        self.inner.transform()
+    }
+
+    fn src(&self) -> Rectangle<f64, Buffer> {
+        self.inner.src()
+    }
+
+    fn damage_since(
+        &self,
+        scale: Scale<f64>,
+        commit: Option<CommitCounter>,
+    ) -> DamageSet<i32, Physical> {
+        self.inner.damage_since(scale, commit)
+    }
+
+    fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, Physical> {
+        self.inner.opaque_regions(scale)
+    }
+
+    fn alpha(&self) -> f32 {
+        self.inner.alpha()
+    }
+
+    fn kind(&self) -> Kind {
+        self.inner.kind()
+    }
+}
+
+impl RenderElement<GlesRenderer> for BorderRenderElement {
+    fn draw(
+        &self,
+        frame: &mut GlesFrame<'_>,
+        src: Rectangle<f64, Buffer>,
+        dst: Rectangle<i32, Physical>,
+        damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
+    ) -> Result<(), GlesError> {
+        RenderElement::<GlesRenderer>::draw(&self.inner, frame, src, dst, damage, opaque_regions)
+    }
+
+    fn underlying_storage(&self, renderer: &mut GlesRenderer) -> Option<UnderlyingStorage> {
+        self.inner.underlying_storage(renderer)
+    }
+}
+
+impl<'render> RenderElement<TtyRenderer<'render>> for BorderRenderElement {
+    fn draw(
+        &self,
+        frame: &mut TtyFrame<'_, '_>,
+        src: Rectangle<f64, Buffer>,
+        dst: Rectangle<i32, Physical>,
+        damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
+    ) -> Result<(), TtyRendererError<'render>> {
+        RenderElement::<TtyRenderer<'_>>::draw(&self.inner, frame, src, dst, damage, opaque_regions)
+    }
+
+    fn underlying_storage(&self, renderer: &mut TtyRenderer<'render>) -> Option<UnderlyingStorage> {
+        self.inner.underlying_storage(renderer)
+    }
+}
@@ -0,0 +1,302 @@
+use glam::{Mat3, Vec2};
+use niri_config::CornerRadius;
+use smithay::backend::renderer::element::surface::WaylandSurfaceRenderElement;
+use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, UnderlyingStorage};
+use smithay::backend::renderer::gles::{
+    GlesError, GlesFrame, GlesRenderer, GlesTexProgram, Uniform,
+};
+use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions};
+use smithay::utils::{Buffer, Logical, Physical, Rectangle, Scale, Size, Transform};
+
+use super::damage::ExtraDamage;
+use super::renderer::{AsGlesFrame as _, NiriRenderer};
+use super::shaders::{mat3_uniform, Shaders};
+use crate::backend::tty::{TtyFrame, TtyRenderer, TtyRendererError};
+
+#[derive(Debug)]
+pub struct ClippedSurfaceRenderElement<R: NiriRenderer> {
+    inner: WaylandSurfaceRenderElement<R>,
+    program: GlesTexProgram,
+    corner_radius: CornerRadius,
+    geometry: Rectangle<f64, Logical>,
+    input_to_geo: Mat3,
+    // Should only be used for visual improvements, i.e. corner radius anti-aliasing.
+    scale: f32,
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct RoundedCornerDamage {
+    damage: ExtraDamage,
+    corner_radius: CornerRadius,
+}
+
+impl<R: NiriRenderer> ClippedSurfaceRenderElement<R> {
+    pub fn new(
+        elem: WaylandSurfaceRenderElement<R>,
+        scale: Scale<f64>,
+        geometry: Rectangle<f64, Logical>,
+        program: GlesTexProgram,
+        corner_radius: CornerRadius,
+    ) -> Self {
+        let elem_geo = elem.geometry(scale);
+
+        let elem_geo_loc = Vec2::new(elem_geo.loc.x as f32, elem_geo.loc.y as f32);
+        let elem_geo_size = Vec2::new(elem_geo.size.w as f32, elem_geo.size.h as f32);
+
+        let geo = geometry.to_physical_precise_round(scale);
+        let geo_loc = Vec2::new(geo.loc.x, geo.loc.y);
+        let geo_size = Vec2::new(geo.size.w, geo.size.h);
+
+        let buf_size = elem.buffer_size();
+        let buf_size = Vec2::new(buf_size.w as f32, buf_size.h as f32);
+
+        let view = elem.view();
+        let src_loc = Vec2::new(view.src.loc.x as f32, view.src.loc.y as f32);
+        let src_size = Vec2::new(view.src.size.w as f32, view.src.size.h as f32);
+
+        let transform = elem.transform();
+        // HACK: ??? for some reason flipped ones are fine.
+        let transform = match transform {
+            Transform::_90 => Transform::_270,
+            Transform::_270 => Transform::_90,
+            x => x,
+        };
+        let transform_matrix = Mat3::from_translation(Vec2::new(0.5, 0.5))
+            * Mat3::from_cols_array(transform.matrix().as_ref())
+            * Mat3::from_translation(-Vec2::new(0.5, 0.5));
+
+        // FIXME: y_inverted
+        let input_to_geo = transform_matrix * Mat3::from_scale(elem_geo_size / geo_size)
+            * Mat3::from_translation((elem_geo_loc - geo_loc) / elem_geo_size)
+            // Apply viewporter src.
+            * Mat3::from_scale(buf_size / src_size)
+            * Mat3::from_translation(-src_loc / buf_size);
+
+        Self {
+            inner: elem,
+            program,
+            corner_radius,
+            geometry,
+            input_to_geo,
+            scale: scale.x as f32,
+        }
+    }
+
+    pub fn shader(renderer: &mut R) -> Option<&GlesTexProgram> {
+        Shaders::get(renderer).clipped_surface.as_ref()
+    }
+
+    pub fn will_clip(
+        elem: &WaylandSurfaceRenderElement<R>,
+        scale: Scale<f64>,
+        geometry: Rectangle<f64, Logical>,
+        corner_radius: CornerRadius,
+    ) -> bool {
+        let elem_geo = elem.geometry(scale);
+        let geo = geometry.to_physical_precise_round(scale);
+
+        if corner_radius == CornerRadius::default() {
+            !geo.contains_rect(elem_geo)
+        } else {
+            let corners = Self::rounded_corners(geometry, corner_radius);
+            let corners = corners
+                .into_iter()
+                .map(|rect| rect.to_physical_precise_up(scale));
+            let geo = Rectangle::subtract_rects_many([geo], corners);
+            !Rectangle::subtract_rects_many([elem_geo], geo).is_empty()
+        }
+    }
+
+    fn rounded_corners(
+        geo: Rectangle<f64, Logical>,
+        corner_radius: CornerRadius,
+    ) -> [Rectangle<f64, Logical>; 4] {
+        let top_left = corner_radius.top_left as f64;
+        let top_right = corner_radius.top_right as f64;
+        let bottom_right = corner_radius.bottom_right as f64;
+        let bottom_left = corner_radius.bottom_left as f64;
+
+        [
+            Rectangle::from_loc_and_size(geo.loc, (top_left, top_left)),
+            Rectangle::from_loc_and_size(
+                (geo.loc.x + geo.size.w - top_right, geo.loc.y),
+                (top_right, top_right),
+            ),
+            Rectangle::from_loc_and_size(
+                (
+                    geo.loc.x + geo.size.w - bottom_right,
+                    geo.loc.y + geo.size.h - bottom_right,
+                ),
+                (bottom_right, bottom_right),
+            ),
+            Rectangle::from_loc_and_size(
+                (geo.loc.x, geo.loc.y + geo.size.h - bottom_left),
+                (bottom_left, bottom_left),
+            ),
+        ]
+    }
+}
+
+impl<R: NiriRenderer> Element for ClippedSurfaceRenderElement<R> {
+    fn id(&self) -> &Id {
+        self.inner.id()
+    }
+
+    fn current_commit(&self) -> CommitCounter {
+        self.inner.current_commit()
+    }
+
+    fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
+        self.inner.geometry(scale)
+    }
+
+    fn src(&self) -> Rectangle<f64, Buffer> {
+        self.inner.src()
+    }
+
+    fn transform(&self) -> Transform {
+        self.inner.transform()
+    }
+
+    fn damage_since(
+        &self,
+        scale: Scale<f64>,
+        commit: Option<CommitCounter>,
+    ) -> DamageSet<i32, Physical> {
+        // FIXME: radius changes need to cause damage.
+        let damage = self.inner.damage_since(scale, commit);
+
+        // Intersect with geometry, since we're clipping by it.
+        let mut geo = self.geometry.to_physical_precise_round(scale);
+        geo.loc -= self.geometry(scale).loc;
+        damage
+            .into_iter()
+            .filter_map(|rect| rect.intersection(geo))
+            .collect()
+    }
+
+    fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, Physical> {
+        let regions = self.inner.opaque_regions(scale);
+
+        // Intersect with geometry, since we're clipping by it.
+        let mut geo = self.geometry.to_physical_precise_round(scale);
+        geo.loc -= self.geometry(scale).loc;
+        let regions = regions
+            .into_iter()
+            .filter_map(|rect| rect.intersection(geo));
+
+        // Subtract the rounded corners.
+        if self.corner_radius == CornerRadius::default() {
+            regions.collect()
+        } else {
+            let corners = Self::rounded_corners(self.geometry, self.corner_radius);
+
+            let elem_loc = self.geometry(scale).loc;
+            let corners = corners.into_iter().map(|rect| {
+                let mut rect = rect.to_physical_precise_up(scale);
+                rect.loc -= elem_loc;
+                rect
+            });
+
+            OpaqueRegions::from_slice(&Rectangle::subtract_rects_many(regions, corners))
+        }
+    }
+
+    fn alpha(&self) -> f32 {
+        self.inner.alpha()
+    }
+
+    fn kind(&self) -> Kind {
+        self.inner.kind()
+    }
+}
+
+impl RenderElement<GlesRenderer> for ClippedSurfaceRenderElement<GlesRenderer> {
+    fn draw(
+        &self,
+        frame: &mut GlesFrame<'_>,
+        src: Rectangle<f64, Buffer>,
+        dst: Rectangle<i32, Physical>,
+        damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
+    ) -> Result<(), GlesError> {
+        frame.override_default_tex_program(
+            self.program.clone(),
+            vec![
+                Uniform::new("niri_scale", self.scale),
+                Uniform::new(
+                    "geo_size",
+                    (self.geometry.size.w as f32, self.geometry.size.h as f32),
+                ),
+                Uniform::new("corner_radius", <[f32; 4]>::from(self.corner_radius)),
+                mat3_uniform("input_to_geo", self.input_to_geo),
+            ],
+        );
+        RenderElement::<GlesRenderer>::draw(&self.inner, frame, src, dst, damage, opaque_regions)?;
+        frame.clear_tex_program_override();
+        Ok(())
+    }
+
+    fn underlying_storage(&self, _renderer: &mut GlesRenderer) -> Option<UnderlyingStorage> {
+        // If scanout for things other than Wayland buffers is implemented, this will need to take
+        // the target GPU into account.
+        None
+    }
+}
+
+impl<'render> RenderElement<TtyRenderer<'render>>
+    for ClippedSurfaceRenderElement<TtyRenderer<'render>>
+{
+    fn draw(
+        &self,
+        frame: &mut TtyFrame<'render, '_>,
+        src: Rectangle<f64, Buffer>,
+        dst: Rectangle<i32, Physical>,
+        damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
+    ) -> Result<(), TtyRendererError<'render>> {
+        frame.as_gles_frame().override_default_tex_program(
+            self.program.clone(),
+            vec![
+                Uniform::new(
+                    "geo_size",
+                    (self.geometry.size.w as f32, self.geometry.size.h as f32),
+                ),
+                Uniform::new("corner_radius", <[f32; 4]>::from(self.corner_radius)),
+                mat3_uniform("input_to_geo", self.input_to_geo),
+            ],
+        );
+        RenderElement::draw(&self.inner, frame, src, dst, damage, opaque_regions)?;
+        frame.as_gles_frame().clear_tex_program_override();
+        Ok(())
+    }
+
+    fn underlying_storage(
+        &self,
+        _renderer: &mut TtyRenderer<'render>,
+    ) -> Option<UnderlyingStorage> {
+        // If scanout for things other than Wayland buffers is implemented, this will need to take
+        // the target GPU into account.
+        None
+    }
+}
+
+impl RoundedCornerDamage {
+    pub fn set_size(&mut self, size: Size<f64, Logical>) {
+        self.damage.set_size(size);
+    }
+
+    pub fn set_corner_radius(&mut self, corner_radius: CornerRadius) {
+        if self.corner_radius == corner_radius {
+            return;
+        }
+
+        // FIXME: make the damage granular.
+        self.corner_radius = corner_radius;
+        self.damage.damage_all();
+    }
+
+    pub fn element(&self) -> ExtraDamage {
+        self.damage.clone()
+    }
+}
@@ -0,0 +1,76 @@
+use smithay::backend::renderer::element::{Element, Id, RenderElement};
+use smithay::backend::renderer::utils::CommitCounter;
+use smithay::backend::renderer::Renderer;
+use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size};
+
+#[derive(Debug, Clone)]
+pub struct ExtraDamage {
+    id: Id,
+    commit: CommitCounter,
+    geometry: Rectangle<f64, Logical>,
+}
+
+impl ExtraDamage {
+    pub fn new() -> Self {
+        Self {
+            id: Id::new(),
+            commit: Default::default(),
+            geometry: Default::default(),
+        }
+    }
+
+    pub fn set_size(&mut self, size: Size<f64, Logical>) {
+        if self.geometry.size == size {
+            return;
+        }
+
+        self.geometry.size = size;
+        self.commit.increment();
+    }
+
+    pub fn damage_all(&mut self) {
+        self.commit.increment();
+    }
+
+    pub fn with_location(mut self, location: Point<f64, Logical>) -> Self {
+        self.geometry.loc = location;
+        self
+    }
+}
+
+impl Default for ExtraDamage {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Element for ExtraDamage {
+    fn id(&self) -> &Id {
+        &self.id
+    }
+
+    fn current_commit(&self) -> CommitCounter {
+        self.commit
+    }
+
+    fn src(&self) -> Rectangle<f64, Buffer> {
+        Rectangle::from_loc_and_size((0., 0.), (1., 1.))
+    }
+
+    fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
+        self.geometry.to_physical_precise_up(scale)
+    }
+}
+
+impl<R: Renderer> RenderElement<R> for ExtraDamage {
+    fn draw(
+        &self,
+        _frame: &mut <R as Renderer>::Frame<'_>,
+        _src: Rectangle<f64, Buffer>,
+        _dst: Rectangle<i32, Physical>,
+        _damage: &[Rectangle<i32, Physical>],
+        _opaque_regions: &[Rectangle<i32, Physical>],
+    ) -> Result<(), R::Error> {
+        Ok(())
+    }
+}
@@ -0,0 +1,81 @@
+use smithay::backend::renderer::damage::OutputDamageTracker;
+use smithay::backend::renderer::element::solid::SolidColorRenderElement;
+use smithay::backend::renderer::element::{Element, Id, Kind};
+use smithay::backend::renderer::utils::CommitCounter;
+use smithay::utils::Scale;
+
+use super::renderer::NiriRenderer;
+use crate::niri::OutputRenderElements;
+
+pub fn draw_opaque_regions<R: NiriRenderer>(
+    elements: &mut Vec<OutputRenderElements<R>>,
+    scale: Scale<f64>,
+) {
+    let _span = tracy_client::span!("draw_opaque_regions");
+
+    let mut i = 0;
+    while i < elements.len() {
+        let elem = &elements[i];
+        i += 1;
+
+        // HACK
+        if format!("{elem:?}").contains("ExtraDamage") {
+            continue;
+        }
+
+        let geo = elem.geometry(scale);
+        let mut opaque = elem.opaque_regions(scale).to_vec();
+
+        for rect in &mut opaque {
+            rect.loc += geo.loc;
+        }
+
+        let semitransparent = geo.subtract_rects(opaque.iter().copied());
+
+        for rect in opaque {
+            let color = SolidColorRenderElement::new(
+                Id::new(),
+                rect,
+                CommitCounter::default(),
+                [0., 0., 0.2, 0.2],
+                Kind::Unspecified,
+            );
+            elements.insert(i - 1, OutputRenderElements::SolidColor(color));
+            i += 1;
+        }
+
+        for rect in semitransparent {
+            let color = SolidColorRenderElement::new(
+                Id::new(),
+                rect,
+                CommitCounter::default(),
+                [0.3, 0., 0., 0.3],
+                Kind::Unspecified,
+            );
+            elements.insert(i - 1, OutputRenderElements::SolidColor(color));
+            i += 1;
+        }
+    }
+}
+
+pub fn draw_damage<R: NiriRenderer>(
+    damage_tracker: &mut OutputDamageTracker,
+    elements: &mut Vec<OutputRenderElements<R>>,
+) {
+    let _span = tracy_client::span!("draw_damage");
+
+    let Ok((Some(damage), _)) = damage_tracker.damage_output(1, elements) else {
+        return;
+    };
+
+    for rect in damage {
+        let color = SolidColorRenderElement::new(
+            Id::new(),
+            *rect,
+            CommitCounter::default(),
+            [0.3, 0., 0., 0.3],
+            Kind::Unspecified,
+        );
+        elements.insert(0, OutputRenderElements::SolidColor(color));
+    }
+}
@@ -0,0 +1,63 @@
+use std::sync::Arc;
+
+use smithay::backend::allocator::format::get_bpp;
+use smithay::backend::allocator::Fourcc;
+use smithay::utils::{Buffer, Logical, Scale, Size, Transform};
+
+#[derive(Clone)]
+pub struct MemoryBuffer {
+    data: Arc<[u8]>,
+    format: Fourcc,
+    size: Size<i32, Buffer>,
+    scale: Scale<f64>,
+    transform: Transform,
+}
+
+impl MemoryBuffer {
+    pub fn new(
+        data: impl Into<Arc<[u8]>>,
+        format: Fourcc,
+        size: impl Into<Size<i32, Buffer>>,
+        scale: impl Into<Scale<f64>>,
+        transform: Transform,
+    ) -> Self {
+        let data = data.into();
+
+        let size = size.into();
+        let stride =
+            size.w * (get_bpp(format).expect("Format with unknown bits per pixel") / 8) as i32;
+        assert!(data.len() >= (stride * size.h) as usize);
+
+        Self {
+            data,
+            format,
+            size,
+            scale: scale.into(),
+            transform,
+        }
+    }
+
+    pub fn data(&self) -> &[u8] {
+        &self.data
+    }
+
+    pub fn format(&self) -> Fourcc {
+        self.format
+    }
+
+    pub fn size(&self) -> Size<i32, Buffer> {
+        self.size
+    }
+
+    pub fn scale(&self) -> Scale<f64> {
+        self.scale
+    }
+
+    pub fn transform(&self) -> Transform {
+        self.transform
+    }
+
+    pub fn logical_size(&self) -> Size<f64, Logical> {
+        self.size.to_f64().to_logical(self.scale, self.transform)
+    }
+}
@@ -1,26 +1,188 @@
-use anyhow::Context;
-use smithay::backend::allocator::Fourcc;
-use smithay::backend::renderer::element::RenderElement;
+use std::ptr;
+
+use anyhow::{ensure, Context};
+use niri_config::BlockOutFrom;
+use smithay::backend::allocator::dmabuf::Dmabuf;
+use smithay::backend::allocator::{Buffer, Fourcc};
+use smithay::backend::renderer::element::utils::{Relocate, RelocateRenderElement};
+use smithay::backend::renderer::element::{Kind, RenderElement};
 use smithay::backend::renderer::gles::{GlesMapping, GlesRenderer, GlesTexture};
 use smithay::backend::renderer::sync::SyncPoint;
-use smithay::backend::renderer::{Bind, ExportMem, Frame, Offscreen, Renderer};
-use smithay::utils::{Physical, Rectangle, Scale, Size, Transform};
+use smithay::backend::renderer::{Bind, Color32F, ExportMem, Frame, Offscreen, Renderer};
+use smithay::reexports::wayland_server::protocol::wl_buffer::WlBuffer;
+use smithay::reexports::wayland_server::protocol::wl_shm;
+use smithay::utils::{Logical, Physical, Point, Rectangle, Scale, Size, Transform};
+use smithay::wayland::shm;
+use solid_color::{SolidColorBuffer, SolidColorRenderElement};

+use self::primary_gpu_texture::PrimaryGpuTextureRenderElement;
+use self::texture::{TextureBuffer, TextureRenderElement};
+
+pub mod border;
+pub mod clipped_surface;
+pub mod damage;
+pub mod debug;
+pub mod memory;
 pub mod offscreen;
 pub mod primary_gpu_texture;
 pub mod render_elements;
 pub mod renderer;
+pub mod resize;
+pub mod resources;
+pub mod shader_element;
+pub mod shaders;
+pub mod snapshot;
+pub mod solid_color;
+pub mod surface;
+pub mod texture;
+
+/// What we're rendering for.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RenderTarget {
+    /// Rendering to display on screen.
+    Output,
+    /// Rendering for a screencast.
+    Screencast,
+    /// Rendering for any other screen capture.
+    ScreenCapture,
+}
+
+/// Buffer with location, src and dst.
+#[derive(Debug)]
+pub struct BakedBuffer<B> {
+    pub buffer: B,
+    pub location: Point<f64, Logical>,
+    pub src: Option<Rectangle<f64, Logical>>,
+    pub dst: Option<Size<i32, Logical>>,
+}
+
+/// Render elements split into normal and popup.
+#[derive(Debug)]
+pub struct SplitElements<E> {
+    pub normal: Vec<E>,
+    pub popups: Vec<E>,
+}
+
+pub trait ToRenderElement {
+    type RenderElement;
+
+    fn to_render_element(
+        &self,
+        location: Point<f64, Logical>,
+        scale: Scale<f64>,
+        alpha: f32,
+        kind: Kind,
+    ) -> Self::RenderElement;
+}
+
+impl RenderTarget {
+    pub fn should_block_out(self, block_out_from: Option<BlockOutFrom>) -> bool {
+        match block_out_from {
+            None => false,
+            Some(BlockOutFrom::Screencast) => self == RenderTarget::Screencast,
+            Some(BlockOutFrom::ScreenCapture) => self != RenderTarget::Output,
+        }
+    }
+}
+
+impl<E> Default for SplitElements<E> {
+    fn default() -> Self {
+        Self {
+            normal: Vec::new(),
+            popups: Vec::new(),
+        }
+    }
+}
+
+impl<E> IntoIterator for SplitElements<E> {
+    type Item = E;
+    type IntoIter = std::iter::Chain<std::vec::IntoIter<E>, std::vec::IntoIter<E>>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.popups.into_iter().chain(self.normal)
+    }
+}
+
+impl<E> SplitElements<E> {
+    pub fn iter(&self) -> std::iter::Chain<std::slice::Iter<E>, std::slice::Iter<E>> {
+        self.popups.iter().chain(&self.normal)
+    }
+
+    pub fn into_vec(self) -> Vec<E> {
+        let Self { normal, mut popups } = self;
+        popups.extend(normal);
+        popups
+    }
+}
+
+impl ToRenderElement for BakedBuffer<TextureBuffer<GlesTexture>> {
+    type RenderElement = PrimaryGpuTextureRenderElement;
+
+    fn to_render_element(
+        &self,
+        location: Point<f64, Logical>,
+        _scale: Scale<f64>,
+        alpha: f32,
+        kind: Kind,
+    ) -> Self::RenderElement {
+        let elem = TextureRenderElement::from_texture_buffer(
+            self.buffer.clone(),
+            location + self.location,
+            alpha,
+            self.src,
+            self.dst.map(|dst| dst.to_f64()),
+            kind,
+        );
+        PrimaryGpuTextureRenderElement(elem)
+    }
+}
+
+impl ToRenderElement for BakedBuffer<SolidColorBuffer> {
+    type RenderElement = SolidColorRenderElement;
+
+    fn to_render_element(
+        &self,
+        location: Point<f64, Logical>,
+        _scale: Scale<f64>,
+        alpha: f32,
+        kind: Kind,
+    ) -> Self::RenderElement {
+        SolidColorRenderElement::from_buffer(&self.buffer, location + self.location, alpha, kind)
+    }
+}
+
+pub fn render_to_encompassing_texture(
+    renderer: &mut GlesRenderer,
+    scale: Scale<f64>,
+    transform: Transform,
+    fourcc: Fourcc,
+    elements: &[impl RenderElement<GlesRenderer>],
+) -> anyhow::Result<(GlesTexture, SyncPoint, Rectangle<i32, Physical>)> {
+    let geo = elements
+        .iter()
+        .map(|ele| ele.geometry(scale))
+        .reduce(|a, b| a.merge(b))
+        .unwrap_or_default();
+    let elements = elements.iter().rev().map(|ele| {
+        RelocateRenderElement::from_element(ele, (-geo.loc.x, -geo.loc.y), Relocate::Relative)
+    });
+
+    let (texture, sync_point) =
+        render_to_texture(renderer, geo.size, scale, transform, fourcc, elements)?;
+
+    Ok((texture, sync_point, geo))
+}

 pub fn render_to_texture(
    renderer: &mut GlesRenderer,
    size: Size<i32, Physical>,
    scale: Scale<f64>,
+    transform: Transform,
    fourcc: Fourcc,
    elements: impl Iterator<Item = impl RenderElement<GlesRenderer>>,
 ) -> anyhow::Result<(GlesTexture, SyncPoint)> {
    let _span = tracy_client::span!();

-    let output_rect = Rectangle::from_loc_and_size((0, 0), size);
    let buffer_size = size.to_logical(1).to_buffer(1, Transform::Normal);

    let texture: GlesTexture = renderer
@@ -31,27 +193,7 @@ pub fn render_to_texture(
        .bind(texture.clone())
        .context("error binding texture")?;

-    let mut frame = renderer
-        .render(size, Transform::Normal)
-        .context("error starting frame")?;
-
-    frame
-        .clear([0., 0., 0., 0.], &[output_rect])
-        .context("error clearing")?;
-
-    for element in elements {
-        let src = element.src();
-        let dst = element.geometry(scale);
-
-        if let Some(mut damage) = output_rect.intersection(dst) {
-            damage.loc -= dst.loc;
-            element
-                .draw(&mut frame, src, dst, &[damage])
-                .context("error drawing element")?;
-        }
-    }
-
-    let sync_point = frame.finish().context("error finishing frame")?;
+    let sync_point = render_elements(renderer, size, scale, transform, elements)?;
    Ok((texture, sync_point))
 }

@@ -59,13 +201,13 @@ pub fn render_and_download(
    renderer: &mut GlesRenderer,
    size: Size<i32, Physical>,
    scale: Scale<f64>,
+    transform: Transform,
    fourcc: Fourcc,
    elements: impl Iterator<Item = impl RenderElement<GlesRenderer>>,
 ) -> anyhow::Result<GlesMapping> {
    let _span = tracy_client::span!();

-    let (_, sync_point) = render_to_texture(renderer, size, scale, fourcc, elements)?;
-    sync_point.wait();
+    let (_, _) = render_to_texture(renderer, size, scale, transform, fourcc, elements)?;

    let buffer_size = size.to_logical(1).to_buffer(1, Transform::Normal);
    let mapping = renderer
@@ -78,38 +220,89 @@ pub fn render_to_vec(
    renderer: &mut GlesRenderer,
    size: Size<i32, Physical>,
    scale: Scale<f64>,
+    transform: Transform,
    fourcc: Fourcc,
    elements: impl Iterator<Item = impl RenderElement<GlesRenderer>>,
 ) -> anyhow::Result<Vec<u8>> {
    let _span = tracy_client::span!();

-    let mapping =
-        render_and_download(renderer, size, scale, fourcc, elements).context("error rendering")?;
+    let mapping = render_and_download(renderer, size, scale, transform, fourcc, elements)
+        .context("error rendering")?;
    let copy = renderer
        .map_texture(&mapping)
        .context("error mapping texture")?;
    Ok(copy.to_vec())
 }

-#[cfg(feature = "xdp-gnome-screencast")]
 pub fn render_to_dmabuf(
    renderer: &mut GlesRenderer,
-    dmabuf: smithay::backend::allocator::dmabuf::Dmabuf,
+    dmabuf: Dmabuf,
    size: Size<i32, Physical>,
    scale: Scale<f64>,
+    transform: Transform,
+    elements: impl Iterator<Item = impl RenderElement<GlesRenderer>>,
+) -> anyhow::Result<SyncPoint> {
+    let _span = tracy_client::span!();
+    ensure!(
+        dmabuf.width() == size.w as u32 && dmabuf.height() == size.h as u32,
+        "invalid buffer size"
+    );
+    renderer.bind(dmabuf).context("error binding texture")?;
+    render_elements(renderer, size, scale, transform, elements)
+}
+
+pub fn render_to_shm(
+    renderer: &mut GlesRenderer,
+    buffer: &WlBuffer,
+    size: Size<i32, Physical>,
+    scale: Scale<f64>,
+    transform: Transform,
    elements: impl Iterator<Item = impl RenderElement<GlesRenderer>>,
 ) -> anyhow::Result<()> {
    let _span = tracy_client::span!();
+    shm::with_buffer_contents_mut(buffer, |shm_buffer, shm_len, buffer_data| {
+        ensure!(
+            // The buffer prefers pixels in little endian ...
+            buffer_data.format == wl_shm::Format::Xrgb8888
+                && buffer_data.width == size.w
+                && buffer_data.height == size.h
+                && buffer_data.stride == size.w * 4
+                && shm_len == buffer_data.stride as usize * buffer_data.height as usize,
+            "invalid buffer format or size"
+        );
+        let mapping =
+            render_and_download(renderer, size, scale, transform, Fourcc::Xrgb8888, elements)?;

-    let output_rect = Rectangle::from_loc_and_size((0, 0), size);
+        let bytes = renderer
+            .map_texture(&mapping)
+            .context("error mapping texture")?;
+
+        unsafe {
+            let _span = tracy_client::span!("copy_nonoverlapping");
+            ptr::copy_nonoverlapping(bytes.as_ptr(), shm_buffer.cast(), shm_len);
+        }
+
+        Ok(())
+    })
+    .context("expected shm buffer, but didn't get one")?
+}
+
+fn render_elements(
+    renderer: &mut GlesRenderer,
+    size: Size<i32, Physical>,
+    scale: Scale<f64>,
+    transform: Transform,
+    elements: impl Iterator<Item = impl RenderElement<GlesRenderer>>,
+) -> anyhow::Result<SyncPoint> {
+    let transform = transform.invert();
+    let output_rect = Rectangle::from_loc_and_size((0, 0), transform.transform_size(size));

-    renderer.bind(dmabuf).context("error binding texture")?;
    let mut frame = renderer
-        .render(size, Transform::Normal)
+        .render(size, transform)
        .context("error starting frame")?;

    frame
-        .clear([0., 0., 0., 0.], &[output_rect])
+        .clear(Color32F::TRANSPARENT, &[output_rect])
        .context("error clearing")?;

    for element in elements {
@@ -119,12 +312,10 @@ pub fn render_to_dmabuf(
        if let Some(mut damage) = output_rect.intersection(dst) {
            damage.loc -= dst.loc;
            element
-                .draw(&mut frame, src, dst, &[damage])
+                .draw(&mut frame, src, dst, &[damage], &[])
                .context("error drawing element")?;
        }
    }

-    let _sync_point = frame.finish().context("error finishing frame")?;
-
-    Ok(())
+    frame.finish().context("error finishing frame")
 }
@@ -1,15 +1,15 @@
 use smithay::backend::allocator::Fourcc;
 use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};
-use smithay::backend::renderer::element::texture::{TextureBuffer, TextureRenderElement};
 use smithay::backend::renderer::element::utils::{Relocate, RelocateRenderElement};
 use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, UnderlyingStorage};
 use smithay::backend::renderer::gles::{GlesError, GlesFrame, GlesRenderer};
-use smithay::backend::renderer::utils::CommitCounter;
+use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions};
 use smithay::utils::{Buffer, Physical, Rectangle, Scale, Transform};

 use super::primary_gpu_texture::PrimaryGpuTextureRenderElement;
 use super::render_to_texture;
 use super::renderer::AsGlesFrame;
+use super::texture::{TextureBuffer, TextureRenderElement};
 use crate::backend::tty::{TtyFrame, TtyRenderer, TtyRendererError};

 /// Renders elements into an off-screen buffer.
@@ -54,16 +54,22 @@ impl OffscreenRenderElement {
            renderer,
            geo.size,
            Scale::from(scale as f64),
+            Transform::Normal,
            Fourcc::Abgr8888,
            elements,
        ) {
            Ok((texture, _sync_point)) => {
-                let buffer =
-                    TextureBuffer::from_texture(renderer, texture, scale, Transform::Normal, None);
+                let buffer = TextureBuffer::from_texture(
+                    renderer,
+                    texture,
+                    scale as f64,
+                    Transform::Normal,
+                    Vec::new(),
+                );
                let element = TextureRenderElement::from_texture_buffer(
-                    geo.loc.to_f64(),
-                    &buffer,
-                    Some(result_alpha),
+                    buffer,
+                    geo.loc.to_f64().to_logical(scale as f64),
+                    result_alpha,
                    None,
                    None,
                    Kind::Unspecified,
@@ -129,7 +135,7 @@ impl Element for OffscreenRenderElement {
        &self,
        scale: Scale<f64>,
        commit: Option<CommitCounter>,
-    ) -> Vec<Rectangle<i32, Physical>> {
+    ) -> DamageSet<i32, Physical> {
        if let Some(texture) = &self.texture {
            texture.damage_since(scale, commit)
        } else {
@@ -137,7 +143,7 @@ impl Element for OffscreenRenderElement {
        }
    }

-    fn opaque_regions(&self, scale: Scale<f64>) -> Vec<Rectangle<i32, Physical>> {
+    fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, Physical> {
        if let Some(texture) = &self.texture {
            texture.opaque_regions(scale)
        } else {
@@ -169,12 +175,27 @@ impl RenderElement<GlesRenderer> for OffscreenRenderElement {
        src: Rectangle<f64, Buffer>,
        dst: Rectangle<i32, Physical>,
        damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
    ) -> Result<(), GlesError> {
        let gles_frame = frame.as_gles_frame();
        if let Some(texture) = &self.texture {
-            RenderElement::<GlesRenderer>::draw(texture, gles_frame, src, dst, damage)?;
+            RenderElement::<GlesRenderer>::draw(
+                texture,
+                gles_frame,
+                src,
+                dst,
+                damage,
+                opaque_regions,
+            )?;
        } else {
-            RenderElement::<GlesRenderer>::draw(&self.fallback, gles_frame, src, dst, damage)?;
+            RenderElement::<GlesRenderer>::draw(
+                &self.fallback,
+                gles_frame,
+                src,
+                dst,
+                damage,
+                opaque_regions,
+            )?;
        }
        Ok(())
    }
@@ -188,27 +209,39 @@ impl RenderElement<GlesRenderer> for OffscreenRenderElement {
    }
 }

-impl<'render, 'alloc> RenderElement<TtyRenderer<'render, 'alloc>> for OffscreenRenderElement {
+impl<'render> RenderElement<TtyRenderer<'render>> for OffscreenRenderElement {
    fn draw(
        &self,
-        frame: &mut TtyFrame<'_, '_, '_>,
+        frame: &mut TtyFrame<'_, '_>,
        src: Rectangle<f64, Buffer>,
        dst: Rectangle<i32, Physical>,
        damage: &[Rectangle<i32, Physical>],
-    ) -> Result<(), TtyRendererError<'render, 'alloc>> {
+        opaque_regions: &[Rectangle<i32, Physical>],
+    ) -> Result<(), TtyRendererError<'render>> {
        let gles_frame = frame.as_gles_frame();
        if let Some(texture) = &self.texture {
-            RenderElement::<GlesRenderer>::draw(texture, gles_frame, src, dst, damage)?;
+            RenderElement::<GlesRenderer>::draw(
+                texture,
+                gles_frame,
+                src,
+                dst,
+                damage,
+                opaque_regions,
+            )?;
        } else {
-            RenderElement::<GlesRenderer>::draw(&self.fallback, gles_frame, src, dst, damage)?;
+            RenderElement::<GlesRenderer>::draw(
+                &self.fallback,
+                gles_frame,
+                src,
+                dst,
+                damage,
+                opaque_regions,
+            )?;
        }
        Ok(())
    }

-    fn underlying_storage(
-        &self,
-        renderer: &mut TtyRenderer<'render, 'alloc>,
-    ) -> Option<UnderlyingStorage> {
+    fn underlying_storage(&self, renderer: &mut TtyRenderer<'render>) -> Option<UnderlyingStorage> {
        if let Some(texture) = &self.texture {
            texture.underlying_storage(renderer)
        } else {
@@ -1,14 +1,14 @@
-use smithay::backend::renderer::element::texture::TextureRenderElement;
 use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, UnderlyingStorage};
 use smithay::backend::renderer::gles::{GlesError, GlesFrame, GlesRenderer, GlesTexture};
-use smithay::backend::renderer::utils::CommitCounter;
+use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions};
 use smithay::utils::{Buffer, Physical, Rectangle, Scale, Transform};

 use super::renderer::AsGlesFrame;
+use super::texture::TextureRenderElement;
 use crate::backend::tty::{TtyFrame, TtyRenderer, TtyRendererError};

 /// Wrapper for a texture from the primary GPU for rendering with the primary GPU.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct PrimaryGpuTextureRenderElement(pub TextureRenderElement<GlesTexture>);

 impl Element for PrimaryGpuTextureRenderElement {
@@ -36,11 +36,11 @@ impl Element for PrimaryGpuTextureRenderElement {
        &self,
        scale: Scale<f64>,
        commit: Option<CommitCounter>,
-    ) -> Vec<Rectangle<i32, Physical>> {
+    ) -> DamageSet<i32, Physical> {
        self.0.damage_since(scale, commit)
    }

-    fn opaque_regions(&self, scale: Scale<f64>) -> Vec<Rectangle<i32, Physical>> {
+    fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, Physical> {
        self.0.opaque_regions(scale)
    }

@@ -60,9 +60,10 @@ impl RenderElement<GlesRenderer> for PrimaryGpuTextureRenderElement {
        src: Rectangle<f64, Buffer>,
        dst: Rectangle<i32, Physical>,
        damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
    ) -> Result<(), GlesError> {
        let gles_frame = frame.as_gles_frame();
-        RenderElement::<GlesRenderer>::draw(&self.0, gles_frame, src, dst, damage)?;
+        RenderElement::<GlesRenderer>::draw(&self.0, gles_frame, src, dst, damage, opaque_regions)?;
        Ok(())
    }

@@ -73,24 +74,23 @@ impl RenderElement<GlesRenderer> for PrimaryGpuTextureRenderElement {
    }
 }

-impl<'render, 'alloc> RenderElement<TtyRenderer<'render, 'alloc>>
-    for PrimaryGpuTextureRenderElement
-{
+impl<'render> RenderElement<TtyRenderer<'render>> for PrimaryGpuTextureRenderElement {
    fn draw(
        &self,
-        frame: &mut TtyFrame<'_, '_, '_>,
+        frame: &mut TtyFrame<'_, '_>,
        src: Rectangle<f64, Buffer>,
        dst: Rectangle<i32, Physical>,
        damage: &[Rectangle<i32, Physical>],
-    ) -> Result<(), TtyRendererError<'render, 'alloc>> {
+        opaque_regions: &[Rectangle<i32, Physical>],
+    ) -> Result<(), TtyRendererError<'render>> {
        let gles_frame = frame.as_gles_frame();
-        RenderElement::<GlesRenderer>::draw(&self.0, gles_frame, src, dst, damage)?;
+        RenderElement::<GlesRenderer>::draw(&self.0, gles_frame, src, dst, damage, opaque_regions)?;
        Ok(())
    }

    fn underlying_storage(
        &self,
-        _renderer: &mut TtyRenderer<'render, 'alloc>,
+        _renderer: &mut TtyRenderer<'render>,
    ) -> Option<UnderlyingStorage> {
        // If scanout for things other than Wayland buffers is implemented, this will need to take
        // the target GPU into account.
--- a/Show More
+++ b/Show More