A workspace could show its windows only side by side. Monocle gives one container the whole work area: the focused container is taken out of the workspace's containers, so the layout gives no container a tile, and the next tiling puts its window on the work area less the padding. Turning it off puts the container back at the index it came from, and the tiles come back as they were resized: the container keeps its resize adjustment, and the workspace does not shorten the list of adjustments while a monocle is on. The windows of the other containers are hidden on the parking desktop, as the windows behind the front one of a stack are, and the front window of each is shown again when the monocle is turned off or the window in monocle closes. A stack in monocle stays a stack. `komorebic toggle-monocle` turns it on and off. What focusing in a direction does meanwhile is set with `monocle-focus-behaviour` or switched with `toggle-monocle-focus-behaviour`: with `cycle` the monocle goes to the previous or the next container, with `no-op`, the default, no container is on any side and the focus falls through to the monitor on that side, where the monocle window of its workspace, if it has one, is given the focus, and the command fails where there is no monitor. A container that is moved to a monitor or sent to a workspace in monocle turns that monocle off first. `cycle-focus` always carries the monocle along. Giving the focus to another window gives it back to the monocle window, so that it stays in front. `move` and `cycle-move` are refused and `toggle-float` is ignored while a window is in monocle, since the focused container is not the window in front. The monocle container is in the state, with the index it goes back to, and a window in it that closes takes the monocle with it. komorebi/tests/monocle.rs drives it against the fake desktop, with one monitor and with two. vm-core-e2e checks in a real KWin that the focused window fills the work area, that the state has the monocle container, that toggling back restores the tile, that the cycle behavior gives another window the work area, and that the windows behind a monocle are parked, which a clean stop and the next start after a crash put right; vm-stacks checks a monocle over a stack; the vm-commands sweep runs the new commands.
4.8 KiB
Running komorebi
komorebi is the daemon that tiles your windows, and komorebic is the command line you
control it with. This page covers starting and stopping the daemon, asking it what it is
doing, and reading its log.
Getting the two programs
Installing komorebi covers NixOS, where the flake's module installs both
and starts the daemon with every Plasma session, and building them from source. In a checkout of
the repository, on Linux, nix build leaves them in result/bin, and nix profile install .
puts them on your PATH. Without nix, build them with the Rust toolchain that
rust-toolchain.toml selects:
cargo build --release --locked
export PATH="$PWD/target/release:$PATH"
With the NixOS module, the daemon is the user unit komorebi.service, which starts when you log
in to Plasma. systemctl --user start komorebi starts it again after a komorebic stop, and
journalctl --user -u komorebi shows what it wrote. Everything else on this page applies to it
as it is.
Starting and stopping
komorebic start runs the komorebi on your PATH in the background,
and checks three seconds later that it is running. It tries three times. If komorebi has
not started by then, komorebic start runs it once more in the foreground and prints what
it wrote on its standard error, which explains why it did not start. When a komorebi is
running already, komorebic start does nothing.
komorebi manages the windows of the Plasma Wayland session it is started in: it connects
to KWin on the session bus and loads a script into it, so start it from a terminal in that
session. Outside a Plasma session it exits with an error that says what is missing, which
komorebic start prints.
Everything after a -- is passed to komorebi. --fake-backend runs it against an
in-memory desktop with one monitor and no windows instead of KWin, which is a way to try the
daemon and komorebic without a compositor:
komorebic start
komorebic start -- --log-level debug
komorebic start -- --fake-backend
komorebic stop tells the daemon to stop. It brings back the windows it hid (the
back of a stack, stacking windows, and the windows behind a
monocle), removes the desktop they were hidden on, asks KWin to unload its script,
removes its socket and exits. Stopping the process with SIGINT or SIGTERM does the same.
Asking komorebi what it is doing
The daemon answers questions on its socket, and these commands print the answers:
komorebic state: every monitor, with its workspaces, their containers and the windows in them, as JSON.komorebic monitor-information: the id, the name and the bounds of every monitor, as JSON.komorebic query: one value, the answer to one question: the index of the focused monitor, workspace, container or window, the layout of the focused workspace, whether the focused container is a single window or a stack, or the version of the daemon.
komorebic query focused-workspace-index
komorebic state | jq '.monitors.elements[0].workspaces.elements[0].containers.elements | length'
komorebic retile tiles the windows of every monitor again, which puts
a window that was moved by hand back on its tile.
When the daemon is not running, these commands fail: there is no socket to write to.
A program that wants to know what komorebi does without asking can subscribe to its notifications instead (Subscribing to notifications).
The socket and the data directory
The daemon listens on komorebi.sock in its data directory, $XDG_RUNTIME_DIR/komorebi
(the local data directory, ~/.local/share/komorebi, when there is no runtime directory).
komorebic data-directory prints the directory, if it exists.
The log
The daemon logs to its standard output and to a file a day in ~/.local/share/komorebi
($XDG_DATA_HOME/komorebi when that is set): komorebi.log.YYYY-MM-DD, with colors, and
komorebi_plaintext.log.YYYY-MM-DD, without. The day is the UTC date.
komorebic log follows the file of the current day, with colors, until
you press Ctrl-C. The --log-level of komorebi sets how much is logged: error, warn,
info (the default), debug or trace.
Shell completions
komorebic completions prints a completion script for bash,
elvish, fish, PowerShell or zsh:
komorebic completions fish > ~/.config/fish/completions/komorebic.fish
komorebic completions bash > ~/.local/share/bash-completion/completions/komorebic
Every command
docs/cli has a page for every komorebic command, generated from its
help with just docgen.