A small, fast container runtime for macOS, Windows and Linux
Packaging
How Kiri reaches people on each platform, and what each piece of this
directory (and installer/windows) does.
| Platform | Package | Built by | Contents |
|---|---|---|---|
| Linux (Debian, Ubuntu) | kiri_<v>_amd64.deb, _arm64.deb |
packaging/linux/build.sh |
engine + docker CLI, Compose, buildx; the window on x86-64 |
| Linux (Debian, Ubuntu) | kiri-lite_<v>_amd64.deb, _arm64.deb |
packaging/linux/build.sh |
engine only |
| Linux (Fedora, RHEL, openSUSE) | kiri-<v>-1.x86_64.rpm, .aarch64.rpm, kiri-lite-…rpm |
packaging/linux/build.sh |
same two flavours |
| Windows | Kiri-<v>-x86_64.msi |
cargo xtask msi |
engine for WSL2, kiri-win.exe, docker CLI, Compose, buildx |
| Windows on Arm | Kiri-<v>-arm64.msi |
cargo xtask msi --arch arm64 |
the same, arm64 throughout (docker CLI built from source) |
| macOS | Kiri.app in Kiri-<v>-arm64.dmg (-x86_64 for Intel), Kiri Lite |
cargo xtask release |
app + CLI tools; Lite downloads the tools |
Two flavours everywhere, with the same meaning: Kiri brings the docker
CLI, Compose and buildx so docker run works right after installing;
Kiri Lite is the engine alone for people who already have a docker.
The CLI versions and their SHA-256s are pinned once, in
crates/kiri/src/cli_pins.rs, for all three platforms.
Linux
packaging/linux/fetch-cli.sh target/linux-cli # docker, compose, buildx, verified against cli_pins.rs
packaging/linux/build.sh target/linux-x86_64-musl target/packages x86_64 target/linux-cli
A release builds all eight packages (both flavours, .deb and .rpm, x86-64
and arm64) with scripts/ci/linux-build.sh on Ubuntu, zig cross-compiling
the arm64 engine; then installs the x86-64 .debs under systemd and runs
containers through them (packaging/linux/test-host.sh), and the .rpms the
same way on Fedora. Each file goes up with SHA256SUMS-linux.
A v* tag builds Mac, Windows and Linux; each build puts its files on
download.runkiri.com with its feeds staged, and the release moves every
feed and updates the website once all three are up (RELEASES.md). On a Mac, scripts/ci/linux-packages.sh builds
the same packages in a Linux container.
build.sh needs dpkg-deb and rpmbuild (apt install rpm on Debian;
both are in WSL Ubuntu). Without the CLI directory it builds only
kiri-lite. The binaries come from cargo xtask linux or
scripts/windows-engine.sh (static musl, so one package runs on every
distro). What the packages do:
/usr/bin/kiri,/usr/bin/kiri-init,kiri.service(enabled and started on install where systemd runs), thekirigroup that owns/run/kiri/docker.sock. Members of the kiri group can run containers as root on this machine; treat it like the docker group. State in/var/lib/kiri-daemon(0700), images and containers in/var/lib/kiri(0710); removal keeps them,apt purgedeletes them.- The full package adds
/usr/libexec/kiri/bin/dockerwith Compose and buildx in/usr/lib/docker/cli-plugins, and offersdockeron PATH throughupdate-alternativesat priority 10, only when/usr/bin/dockeris absent or already an alternatives link: a docker CLI another package owns keeps winning, as on Windows. Itsdockertalks to Kiri's socket unlessDOCKER_HOST,DOCKER_CONTEXTor a context of your own says otherwise. - The x86-64 full package also has the window:
/usr/lib/kiri/kiri-window(kiri built with--features window, linking GTK 3 and WebKitGTK 4.1, so the package depends on them and on the build machine's glibc, Ubuntu 24.04's in CI), its launcher in the app menu and the icons.kiri uistarts it; where it isn't installed (kiri-lite, the arm64 packages, which zig cross-compiles),kiri uisays so.linux-build.shbuilds the window for its own machine's architecture whenlibwebkit2gtk-4.1-devis there. - Upgrading the package leaves the running engine as it is (stopping it would
end every container); run
systemctl restart kiriafterwards to get the new version.
Tests: packaging/linux/test.sh (package listings, install/remove in
privileged Ubuntu and Fedora containers on any Docker-compatible engine, Kiri
included; nested, so it proves the files and scripts, not container runs) and
packaging/linux/test-host.sh (on a real host or VM with systemd: install,
run containers, publish a port, remove; it stops a kiri daemon already running
there, so it wants KIRI_TEST_KILL=1).
Not yet: an apt/dnf repository (today the packages are release assets;
a repository is what gives apt upgrade), and signing.
Homebrew (planned, not built)
The Mac already has the app and the dmg; Homebrew is the third way in, for people who live in the terminal. Plan:
- A tap, not homebrew-core, to start: a
homebrew-kirirepository (not made yet) withFormula/kiri.rb. Users runbrew install libracoder/kiri/kiri. homebrew-core wants a stable, notable, open project with no vendored binaries, so that comes later, if at all. - Formula = Kiri Lite from source or binary. Simplest and most Homebrew-like:
build from the release tarball with
cargo install --path crates/kiri(depends_on "rust" => :build), installkiritobin, and letbrew services start kirirunkiri daemonas a user LaunchAgent (aservice doblock withrun [opt_bin/"kiri", "daemon"],keep_alive true, log files undervar/log). The CLI tools stay Homebrew's business:depends_on "docker"and"docker-compose","docker-buildx"as recommended deps, which is exactly the Lite split. - A cask for the app:
Casks/kiri.rbpointing at the dmg with its SHA-256,app "Kiri.app",zaplisting~/.kiriand the LaunchAgent, for people who want the window.brew install --cask libracoder/kiri/kiri. - Automate the bump: Kiri CI's release step opens a PR on the tap with
the new version and checksums (formula from the source tarball, cask from
the dmg) whenever it publishes a release;
brew bump-formula-prdoes most of this.
Open questions before building it: whether the formula should build the
guest (cargo xtask guest needs the aarch64 musl target and a kernel image,
which Homebrew will not do) or download Kiri's prebuilt guest image at first
run as Lite does today; and whether the virtualization entitlement survives
a Homebrew-built binary (it needs signing with the entitlement, which the
formula can do with codesign --sign - ad hoc for local use).