KWin has no protocol that lets another process read or set the geometry of a window, but its scripting API has both, and a signal for every change the window manager follows. So the KWin backend is in two parts: bridge.js, a script the daemon loads into KWin, which reports what KWin sees and holds no window manager logic, and a D-Bus service in the daemon, org.komorebi.Bridge, which the script calls with every event as a JSON string. Every decision about what an event means is made by the table in kwin::state, which is pure and is unit-tested with the JSON the script sends: which windows may be managed, the ids komorebi gives KWin's windows, and the Show, Destroy, FocusChange, Minimize and Restore events of the window manager. Events reach the window manager in the order KWin raised them: the Event interface handles its calls inline (zbus reordered them otherwise), and one channel and one thread, window_manager_event_listener and listen_for_events, carry them on. Commands go to the script as the answer to a Poll call that the script always has open and the daemon holds until it has something to send: in the spikes this was as fast as any other channel, and it makes one call every 10 seconds when nothing happens. Here the only command is the cursor query. Every command of the Backend trait is refused with "the KWin backend only reads the desktop", so the daemon follows KWin and moves nothing. The bridge is JavaScript that KWin runs as it is, and it gets types and tests without a JavaScript build chain. tsc checks it as strict TypeScript through JSDoc types of every message, against kwin-api.d.ts, a declaration of the part of KWin's scripting API it uses, in which every property is read-only and callDBus takes one string. bridge.test.js runs it under node --test against a fake KWin in a node:vm context. The messages of a session are JSON fixtures that both sides' tests read: the bridge's tests check that it sends those events, and the table's and the backend's tests read the same events and commands, so a message cannot change on one side alone. just check-js and the flake's komorebi-bridge-js check run both, with nodejs and typescript from nixpkgs; there is no package.json. The daemon now connects to KWin by default, and --fake-backend is hidden. The VM suite vm-kwin-events starts it against a headless KWin and checks, from its debug log, that the script loads and reports what was open, that KWin's signals arrive as events and in order, and that stopping the daemon unloads the script. docs/dev/PLATFORM.md starts with what komorebi needs from Plasma. zbus 5's zvariant, zbus_names and zvariant_derive are flagged unmaintained, since their code moved into zbus 6; deny.toml ignores the three advisories.
8.5 KiB
VM tests
The unit tests run against a fake desktop. They cannot say whether KWin does what the daemon asks of it, so a second kind of test boots a NixOS virtual machine with Plasma in it, starts a real KWin, and drives it. This page says how they are laid out, how to run them, and how to add one.
What runs where
| Where | How | Accelerator |
|---|---|---|
CI, x86_64-linux |
nix build -L .#checks.x86_64-linux.vm-NAME |
KVM |
| A Linux machine with KVM | just vm NAME |
KVM |
| A Mac | just vm NAME, which runs scripts/vm-mac |
HVF |
| A Linux machine with no KVM | nix build -L .#legacyPackages.SYSTEM.vmTcg.NAME |
TCG |
CI runs the fast tier on every pull request and the slow tier on master,
every week, and on pull requests labeled ci:vm-slow
(ci.yaml). The slow jobs run the driver
by hand instead of building the check, so that the screenshots and journals of a
failed run can be uploaded as an artifact. KVM on GitHub-hosted runners is
documented for public repositories; the first step of each VM job checks that
/dev/kvm is writable and fails there if it is not.
TCG is software emulation. It is slow enough that only short suites are worth
running that way, and the library's scale argument (below) is 8 for it.
Each suite is a directory under
nix/tests/vm/suites. The generator in
nix/tests/vm/default.nix lists that
directory, so a new suite is a new directory and nothing else: it appears as
checks.<system>.vm-NAME on Linux and as legacyPackages.<system>.vm.NAME
everywhere. legacyPackages.<system>.vmTiers lists the names of each tier as
JSON, which is what CI reads.
A suite has two files:
default.nixsetstier("fast"or"slow"),kind(the node it runs on) andtimeoutMinutes.test.pyis the test, a Python script for the NixOS test driver. It is prefixed withSCALE = <number>, how many times slower than KVM the machine is.
Nodes
kind picks a file under
nix/tests/vm/nodes.
headless is a machine with Plasma installed and no login. Each KWin a test
starts is a pair of user units of the test user, session-bus@NAME (a private
D-Bus session bus) and kwin-virtual@NAME (kwin_wayland --virtual with its
own Wayland socket), so a test can run several sessions side by side and none
touches another. A virtual KWin has no real output, so it cannot draw: it can
place windows and answer questions about them, but it cannot take a screenshot.
A third unit, komorebi@NAME, runs the daemon in a session, built from the
commit under test and installed on the node; it is not bound to KWin's unit, so
a test can restart KWin under a running daemon.
KWin wants a DRM render node, which needs a GPU. The test driver gives every aarch64 guest one
virtio-gpu-pci; on x86_64 the node adds it, unless komorebi.vm.renderNode is false.
session is the headless node plus a login: plasma-login-manager logs the test
user in by itself, as in nixpkgs' own plasma6 test, and Plasma draws on the
machine's display device. It is the node for anything that needs pixels. The
choice of login manager is made in
nodes/session.nix and nowhere else;
the file says how to switch to sddm, the other one that has been seen to work.
Its display is 1280x800, because screenshots are taken of the machine's one
display device: the virtio-gpu-pci that the test driver adds to every aarch64
guest, and the default VGA of an x86_64 one. The node sets
komorebi.vm.renderNode to false, so that an x86_64 guest does not get a second
device: KWin would draw on it, and the screenshot would show the other one.
On aarch64 under HVF, at time of writing (2026-10-27), the session has the Wayland socket after 11 to 19 seconds and a painted desktop after 35 seconds.
The library
Suites import from komorebi_vm, in
nix/tests/vm/lib. It does not depend on the test
driver. It depends on the small Machine protocol, and its unit tests pass a
fake machine, so the vm-lib check tests it without booting anything. The
check also runs ruff and ty over it. The driver type checks every
test.py with ty and ruff too, so a typo in a suite fails the build, not
the run.
Checkscounts checks and fails once, at the end, so that one failure does not hide the ones after it.finish()printspassed: N failed: M.Kdeis one KWin session.Kde.headless(machine, name, size=, outputs=, scale=)starts the units and waits for KWin to own its name on the private bus.wid,rect,titleandactiveread windows throughkdotool,outputscounts the enabled outputs throughkscreen-doctor,spawnstarts a client, andwait_for(predicate, timeout)polls, with the timeout multiplied byscale.Kde.session(machine, scale=)attaches to the session node's own Plasma session once its desktop is up, andshot(name)returns a screenshot as a Pillow image, keepingNAME.pngin the output directory.activate,minimizeandcloseact on a window throughkdotool, as the user would.start_komorebi(*args)starts the daemon in the session,stop_komorebi()stops it withSIGTERM,komorebi_log()returns its log since it was last started, andscript_loaded()asks KWin whether it runs the bridge.daemonreads the daemon's view of the desktop from that log, started with--log-level debug:daemon.events(log)lists the window events it handled, in order, anddaemon.window_ids(log)maps a window's title to the daemon's id for it.
Poll for what the test needs with wait_for. A fixed sleep is too long on
KVM and too short on TCG.
Two traps are worth knowing about before writing a screenshot test:
- A splash screen is not a blank screen. KSplash has more than a thousand colors
on it, so "the screenshot is not blank" passes while Plasma is still
starting.
Kde.sessionwaits for the splash process to exit, and a test should check a pixel it knows, such as the middle of a terminal. - NixOS wraps programs, so a process's name is the wrapper's (
.plasmashell-wrapped), andpgrep -x plasmashellnever matches. Match the command line instead, with a bracket in the pattern (pgrep -f '[p]lasmashell') so that the shell runningpgrepdoes not match itself.
Running a test on a Mac
QEMU has to run on the Mac to use HVF, and the guest is Linux, so the guest's
closure is built on a Linux builder and the driver runs on the Mac. The nix
sandbox on macOS cannot give QEMU the hypervisor, so scripts/vm-mac runs the
driver directly instead of building the check.
export KOMOREBI_BUILDER=ssh-ng://builder@localhost
export NIX_SSHOPTS="-p 31022 -i $HOME/.ssh/builder_ed25519 -o IdentitiesOnly=yes"
just vm kwin
KOMOREBI_BUILDER is the store URL of an aarch64-linux builder you can
reach. nix run nixpkgs#darwin.linux-builder starts one, with one core and 3 GB
of memory by default; a Plasma guest needs more than that (6 cores and 10 GB
worked, at time of writing, 2026-10-27), and the builder's 20 GB disk holds one
Plasma system closure of about 10 GB, so run nix-collect-garbage on it
between builds of different guests.
The script prints where the artifacts (screenshots, logs) are, under
.vm/out/NAME.
Writing a test
- Create
nix/tests/vm/suites/NAME/default.nixandtest.py. Start fromsuites/kwin, or fromsuites/kwin-eventsfor a test that runs the daemon. - Pick the tier.
fastsuites are the pull request gate and should take minutes.slowsuites run onmasterand every night. - Run it:
just vm NAME. - If the test covers behavior the daemon has, write the Rust test that covers the same behavior against the fake desktop in the same commit, and say in the VM test's first comment what only a real KWin can tell.
Add git add -N for new files first: a flake only sees files git knows about.
Looking inside a failed run
nix build -L prints the guest's console, and a session test keeps its screenshots. Run the driver by hand, as
scripts/vm-mac does, to keep the screenshots. For an interactive session
build driverInteractive instead of driver, run it, and call start_all()
and machine.shell_interact() at its prompt. In the guest, KWin's own log is
journalctl --user -u kwin-virtual@NAME as the test user, and a KWin script's
print() goes to the same journal. The daemon's log is
/run/user/1000/komorebi-NAME.log.