# Kiri container runtime: 22 ms starts, one shared kernel, no sandbox

> Kiri 0.2.1 replaces Docker Desktop's shim chain with one daemon and one VM. That makes container starts fast, but it adds no isolation boundary beyond namespaces and cgroups.

- Published: 2026-11-15
- By: Samir Sengupta (https://www.samcodeman.com/about)
- Canonical: https://www.samcodeman.com/writing/kiri-container-runtime-22-ms-isolation-like-runc
- How this was made: Drafted with Claude, Anthropic's model from 1 cited source, then checked against it in a second editing pass. Editorial policy: https://www.samcodeman.com/editorial-policy

## The short version

- The 8x figure is docker run start time on one Apple Silicon Mac: 22 ms on Kiri against 178 ms on Docker Desktop, both limited to 2 CPUs and 8 GB. It does not measure how fast workloads run.
- One daemon creates namespaces, cgroups and mounts itself and keeps no per-container shim, but every container shares one kernel.
- The sources name no licence, no CRI endpoint and no gVisor-style or per-container VM isolation.
- As of 0.2.1, Kiri is a fast Docker Desktop alternative for developer machines. It is not a sandbox for untrusted AI agent code.

The Kiri container runtime, version 0.2.1, is a free beta Docker Desktop alternative. It answers the Docker API from a single daemon. Its headline claim is that docker run takes 22 ms on Kiri against 178 ms on Docker Desktop, which is where the 8x figure comes from. Isolation is ordinary Linux namespaces and cgroups on one shared kernel, so it is not a gVisor-style sandbox. The sources describe no CRI endpoint and name no licence, which rules it out as a sandbox for untrusted AI agent code for now.

Kiri ships for Mac, Windows and Linux and is in beta on all three. The Mac build is 0.2.1 for Apple silicon on macOS 14 and later. It brings its own docker CLI, Compose and buildx and sets up a kiri docker context. It also imports images, volumes and containers from OrbStack or Docker Desktop.

## How the Kiri container runtime isolates workloads

On the Mac, Kiri runs one minimal Linux VM through Virtualization.framework, and that VM serves every container. On Windows it runs inside WSL2 and exposes the Docker API on a named pipe, which is also in beta. On Linux there is no VM: the daemon calls clone3 directly on the host kernel.

The site says one daemon creates namespaces, cgroups and mounts itself, and that nothing per container is left running. That is the structural change from the containerd and shim path. Kiri describes OrbStack as five hops with one shim process resident for every running container, and Docker Desktop as the same five hops with a shim per container. Requests to Kiri cross one vsock channel into the VM instead of a chain of Unix sockets. One commenter on Hacker News said the documentation is wrong to suggest a (micro)VM per container. The front page agrees with that reading, since it says one VM serves every container.

Another commenter asked whether Kiri implements its own runtime or uses containerd or another runtime as its backend. The front page says the daemon builds namespaces, cgroups and mounts itself. That suggests nothing like containerd or runc underneath, but the page does not say so outright. Nothing in the sources mentions gVisor, a user-space kernel, seccomp profiles, user namespaces or any hardening beyond standard container primitives.

## What 8x faster than Docker actually measures

The benchmark command is docker run --rm alpine true. It ran on one Apple Silicon Mac, with each engine limited to 2 CPUs and 8 GB. All engines went through the same docker CLI with Docker's default bridge networking. The figures are medians from one full run, and the site says Windows has its own race. For Kiri, the site says most of the 22 ms is the docker CLI starting up.

- docker run: 22 ms on Kiri, 178 ms on Docker Desktop, 152 ms on Colima, 279 ms on OrbStack
- Full container lifecycle through the Docker API: 3.1 ms
- VM cold boot to ready: 112 ms, down from 810 ms on a stock kernel
- Guest vsock round trip p50: 31 µs
- Daemon footprint: around 15 MB. The VM sleeps after a minute idle, and waking takes 0.15 s
- OrbStack shims: 143 running containers held 1.13 GB in shims on the test Mac

Commenters on Hacker News raised several objections. One asked whether 8x means containers run faster or the tooling around them does. Another replied that the figure is container start time, and that 200 ms on a start done every few days is not noticeable. That commenter also noted the memory savings only apply past 100 containers. A third argued the test almost certainly compares a warm start with a cached image, and that cold start is what users notice; the sources do not report a cold-pull figure. One commenter who values OrbStack for fast bind mounting said the site does not discuss bind mount performance.

The site's CPU and memory chart for ten running containers is labelled as a sample from one Apple-silicon Mac, one runtime at a time. That sits awkwardly with the download section's line that every number on the page was measured. The chart's caption says:

> Measured numbers replace these soon.
>
> - Kiri front page, runkiri.com

One commenter said Kiri's full benchmarks show it running faster on macOS than Colima with vz. Others wanted comparisons against Podman, systemd-nspawn, incus and Apple containers instead of Docker. The sources include none of those, and they do not compare Kiri against gVisor or any other sandboxed runtime.

## Docker API and OCI images, no CRI endpoint

Compatibility is pitched at the Docker layer. The site lists docker, docker compose, docker buildx, the Docker Engine API, Docker Hub, OCI images, ghcr.io and Dockerfiles. Builds go through BuildKit, and amd64 images run through Rosetta on the Mac. Because Kiri answers the Docker API, docker ps shows the same containers that kiri ps does.

Kubernetes support means running a cluster inside Kiri. kiri k8s start brings up a k3s cluster in about 20 seconds, and kind also runs. The sources never mention CRI, containerd or CRI-O. Nothing indicates that a kubelet can use Kiri as its container runtime the way it uses containerd or a gVisor runsc handler.

One commenter read Kiri as running behind the real dockerd, in the slot containerd normally fills. The front page instead says Kiri runs Docker containers with one daemon. Another commenter pointed out that Docker and Podman already let users swap the low-level runtime with --runtime, for example to a security-hardened one instead of crun. The sources do not say whether Kiri accepts a pluggable OCI runtime or replaces that layer entirely.

## No licence named for a 0.2.1 beta

The front page says Kiri is free and in beta. It does not name a licence. A commenter linked a GitHub repository at libracoder/kiri, but the sources state no licence for it. Teams cannot yet tell from the sources whether they may fork, vendor or redistribute it.

One commenter who looked at the code described Kiri as a desktop container runtime written in Rust that uses nftables for networking on Linux. The same commenter said the code did not look majorly AI-generated. Another commenter, who maintains a VM that uses crun as its container runtime, flagged a design choice: by default the daemon defers cleanup before responding with the exit notification. They called it a tradeoff and warned that cleanup failures could pile up silently. The sources contain no response from the developers on that point.

## Kiri is not a sandbox for AI agents

An agent sandbox has to contain code that may be hostile. Kiri's boundary is namespaces and cgroups on a kernel shared by every container. On Linux that kernel is the host's own, because the daemon calls clone3 directly. The sources offer nothing like gVisor's user-space kernel or a VM per workload. The single Mac VM separates containers from macOS, but not from each other.

Several features also widen the attack surface for agents with shell access:

- Kiri Share puts any container on a public HTTPS address on runkiri.cloud until someone presses Disconnect. It can be started from the window or with kiri share web. The safeguard the site describes is a warning page on the first visit, so a link cannot pass itself off as a bank.
- Kiri runs its own certificate authority for local HTTPS names. The site calls it narrow, but the front page does not describe its scope.
- Linux machines created with kiri machine create get the user's account, sudo and the user's Mac folders at the same paths.

These are conveniences for a developer. They are risky to hand to an autonomous agent.

- No security model, threat model or hardening is described in the sources
- No seccomp, AppArmor, user-namespace or rootless configuration is mentioned
- No per-container VM or gVisor-style option is offered
- No CRI integration is described for scheduling sandboxed agent pods under Kubernetes
- No licence is named, which matters for anyone embedding it in an agent platform

Kiri's case is speed and footprint on a developer laptop. It offers 22 ms docker run starts, a daemon of around 15 MB and no per-container shims. Teams running untrusted agent workloads should keep using a runtime with a stronger boundary. Kiri is worth another look if it publishes an isolation model, a licence and measured resource numbers.

## Questions this raises

### Is Kiri safe to use as a sandbox for untrusted AI agent code?

No. Kiri isolates containers only with Linux namespaces and cgroups on a kernel shared by every container, and on Linux that is the host kernel itself. The sources describe nothing like gVisor's user-space kernel or a VM per workload.

### What does Kiri's 8x faster than Docker claim actually measure?

It measures container start time for docker run --rm alpine true: 22 ms on Kiri against 178 ms on Docker Desktop. The figures are medians from one run on one Apple Silicon Mac, likely with a cached image, and the site says most of Kiri's 22 ms is the docker CLI starting up.

### Can Kubernetes use Kiri as its container runtime?

The sources give no sign of that, because they never mention a CRI endpoint, containerd or CRI-O. Kiri's Kubernetes support means running a k3s cluster inside Kiri with kiri k8s start, which takes about 20 seconds, or running kind.

## Key facts

- Kiri 0.2.1 is a free beta for Mac (Apple silicon, macOS 14+), Windows (WSL2) and Linux.
- docker run --rm alpine true: 22 ms on Kiri, 178 ms on Docker Desktop, 152 ms on Colima, 279 ms on OrbStack.
- Benchmarks are medians from one run on one Apple Silicon Mac with each engine capped at 2 CPUs and 8 GB, and no cold-pull figure is reported.
- VM cold boot to ready takes 112 ms, down from 810 ms on a stock kernel, and the daemon footprint is around 15 MB.
- Isolation is namespaces and cgroups on one shared kernel, with no gVisor-style sandbox, no CRI endpoint and no named licence.

## Sources

1. [Kiri – The Modern Container Runtime](https://runkiri.com/) - runkiri.com

Discussion read (practitioners' reactions, not a source): https://news.ycombinator.com/item?id=50504077
