# kiri (libracoder/kiri)

> Kiri is a small, fast container runtime for macOS, Windows and Linux. It runs Docker images and works with the docker CLI, Compose and buildx you already use.

- GitHub: https://github.com/libracoder/kiri
- GitHub.Locker page: https://github.locker/libracoder/kiri
- Stars: 827
- Language: Rust
- License: Apache-2.0
- Last push: 2026-11-07

## Questions and answers

Written by GitHub.Locker from the README and the repository; check the README below for details.

**Is it a replacement for Docker Desktop?**

Yes, the README presents it as a lighter replacement for Docker Desktop and OrbStack. It runs containers in one small Linux VM (or directly on the kernel on Linux) and speaks the Docker Engine API.

**How do I get it running?**

Download the .dmg on macOS, the .msi on Windows or the .deb/.rpm on Linux from runkiri.com/releases. On first launch it sets up a kiri Docker context. Docker's commands also work as kiri commands, such as kiri run or kiri compose up.

**Do I need anything extra first, like WSL on Windows?**

On Windows you need WSL 2. On Mac you need macOS 14 or newer. The README mentions no separate Docker install, since the docker CLI, Compose and buildx you already use keep working.

**Is everything from Docker Desktop covered yet?**

Not fully. A built-in builder is still on the roadmap, so buildx builds are not yet served by Kiri's own build endpoints. The Features doc lists what is supported today and the known issues.

**Does it need Apple silicon, or does it work on Intel Macs too?**

Both work: macOS 14+ on Apple silicon or Intel, and Windows 10/11 on x86-64 or Arm. The README says amd64 images run through Rosetta on Apple silicon.

**Are there any license catches?**

The code is Apache-2.0, but the name 'Kiri' and its logo are not covered by the licence, and the guest kernel is GPL-2.0. Forks are welcome under a different name and logo.

**Why is it so fast?**

The VM uses a custom 10 MB kernel, and its PID 1 is a ~900 KB Rust agent. That agent starts containers with a single clone3 into namespaces and a cgroup, with no runc, shim or dockerd.

**What else does it do beyond containers?**

It can run a one-command Kubernetes cluster and Linux machines. It also has a native window for containers, images, volumes and networks, plus a menu bar item.

**Where does the name Kiri come from?**

It comes from the Igbo word 'ntakịrị', meaning 'small'.

**How does it compare on speed?**

In the README's test of running alpine (median of 30 runs, Engine API), Kiri took 2.55 ms versus 213 ms for Docker Desktop and 380 ms for OrbStack.


---

## README (checked against GitHub 2026-11-08)

Source: https://github.com/libracoder/kiri/blob/main/README.md

<p align="center">
  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="brand/logo/kiri-horizontal-dark.svg">
    <img src="brand/logo/kiri-horizontal-light.svg" alt="Kiri" width="220">
  </picture>
</p>

<p align="center">
  <b>A tiny, fast container runtime for macOS, Windows and Linux.</b><br>
  Runs your Docker images and works with the <code>docker</code> CLI, Compose and buildx you already use.
</p>

<p align="center">
  <a href="https://runkiri.com/releases/">Download</a> ·
  <a href="docs/features.md">Features</a> ·
  <a href="docs/development.md">Build from source</a> ·
  <a href="https://github.com/libracoder/kiri/releases">Releases</a>
</p>

<p align="center">
  <a href="https://github.com/libracoder/kiri/releases/latest"><img alt="Latest release" src="https://img.shields.io/github/v/release/libracoder/kiri?label=release&color=2f6feb"></a>
  <a href="LICENSE"><img alt="License: Apache-2.0" src="https://img.shields.io/badge/license-Apache--2.0-555"></a>
</p>

<p align="center">
  <img src="docs/images/kiri-window.png" alt="The Kiri window, showing containers grouped by Compose project with their state, ports, local domains and size" width="900">
</p>

---

Kiri is a lightweight replacement for Docker Desktop and OrbStack, written in
Rust. It runs containers in one small Linux VM (or straight on the kernel on
Linux) and speaks the Docker Engine API, so your tools just work.

The name comes from the Igbo word *ntakịrị*, "small".

## Why Kiri

- **Fast**: a container starts and exits in about 2.5 ms through the Docker API. That's around 80 times faster than Docker Desktop.
- **Light**: the VM sleeps after 60 s idle, the daemon stays at about 15 MB, and it wakes in about 0.15 s.
- **Compatible**: `docker`, Compose, buildx, `docker login` and amd64 images through Rosetta.
- **Local domains**: `http://<name>.kiri.local`, with HTTPS from Kiri's own certificate authority.
- **More than containers**: a one-command Kubernetes cluster and Linux machines.
- **A native window** for containers, images, volumes and networks, plus a menu bar item.

## Install

| Platform | Get it |
|----------|--------|
| macOS 14+ (Apple silicon or Intel) | `.dmg` from [runkiri.com/releases](https://runkiri.com/releases/) |
| Windows 10 and 11 (x86-64 or Arm, through WSL 2) | `.msi` from [runkiri.com/releases](https://runkiri.com/releases/) |
| Linux (Ubuntu, Fedora and others) | `.deb` or `.rpm` from [runkiri.com/releases](https://runkiri.com/releases/) |

The first time you open Kiri, it sets up a `kiri` Docker context. Kiri updates itself, and checks each new release's signature first.

## Quick start

```sh
docker --context kiri run --rm alpine echo hello
docker --context kiri compose up -d
kiri k8s start                      # single-node Kubernetes as the `kiri` kubectl context
kiri machine create dev --distro ubuntu && kiri machine shell dev
kiri import                         # bring images, volumes and containers over from OrbStack or Docker Desktop
```

Docker's commands also work as `kiri` commands (`kiri run`, `kiri ps`,
`kiri compose up`, and so on), and always target Kiri.

## Numbers

`alpine` running `true` and removed, median of 30 runs, same `docker` CLI for all three:

|                | Docker Engine API | `docker` CLI |
|----------------|------------------:|-------------:|
| **Kiri**       | **2.55 ms**       | **14.2 ms**  |
| Docker Desktop | 213 ms            | 243 ms       |
| OrbStack       | 380 ms            | 442 ms       |

Method and every other figure are in [`bench/results.json`](bench/results.json). Rerun with `kiri bench`.

## How it works

```
docker CLI ─┐
compose ────┼─ Docker Engine API ─► kiri daemon ── vsock ──► guest agent (PID 1)
buildx ─────┤                         owns the VM           clone3 → container
kiri UI ────┘
```

The VM uses a custom 10 MB kernel, and its PID 1 is a ~900 KB Rust agent.
That agent starts containers with a single `clone3` into namespaces and a
cgroup. There's no runc, no shim and no dockerd. More detail is in
[docs/development.md](docs/development.md#architecture).

## Documentation

- [Features](docs/features.md): everything supported today, release files and known issues
- [Development](docs/development.md): building, running from source, architecture and repository layout
- [Release notes](docs/releases)

## Roadmap

Next is a built-in builder. Kiri will serve Docker's own build endpoints, so
buildx uses its docker driver against Kiri as it does against Docker
Desktop. This brings `host-gateway` support to BuildKit builds, and images
load straight into Kiri.

## Contributing

Issues and pull requests are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md)
and the [Code of Conduct](CODE_OF_CONDUCT.md). To report a vulnerability
privately, see [SECURITY.md](SECURITY.md).

## License

[Apache-2.0](LICENSE). Third-party licences are in [NOTICE](NOTICE). The guest
kernel is Linux (GPL-2.0); its config, patches and the source offer are in
[`guest/kernel`](guest/kernel).

The name "Kiri" and the Kiri logo are not covered by the licence. Forks are
welcome, under a different name and logo.