The 2.5-Millisecond Container Runtime That Got 10,600 Stars in 16 Days — Fact-Checked
The 2.5-Millisecond Container Runtime That Got 10,600 Stars in 16 Days — Fact-Checked
Every few months someone rewrites Docker in a new language and claims victory. This time the claim came with receipts, a benchmark file in the repo, and a GitHub star count that reads like a misprint: 10,652 stars in 16 days, from a repo created on November 2. The project is Kiri (libracoder/kiri), and the hot take forwarded around the internet says a container starts in 2.5 milliseconds, the whole VM kernel is 10 MB, and your docker commands just keep working.
We pulled the live repo, the benchmark data, and the feature docs. Here is what checks out, what is cherry-picked, and whether it belongs on an Ubuntu host like the one this site runs on.
The 3-second version
- Kiri is a pure-Rust Docker Desktop/OrbStack replacement. It speaks the Docker Engine API over a Unix socket, so
docker, Compose, and buildx work against it via a Docker context namedkiri. - The 2.5 ms number is real but narrow. Measured, reproducible, and honest — it is the full lifecycle of
alpine → true → exit → remove, through the raw API, with a warm image. Through the actualdockerCLI it is 14.2 ms. Still 17x faster than Docker Desktop's 243 ms. - The trick is deleting everything Docker does. No dockerd, no containerd, no per-container shim. One 900 KB guest agent calls
clone3once and the container exists. - On Ubuntu hosts it is a
.deb, not a VM.kiri-liteis a 2.7 MB engine-only package; the fullkiriadds the CLI. It co-exists with Docker instead of fighting it — Docker's CLI keeps winning whenever it exists. - The catch is age, not architecture. 16 days old, v0.2.1, one maintainer wrote 106 of the ~140 commits, 194 open issues, no package signing, no apt repo yet. The tech is credible; the project is a newborn.
Proof: the repo, screenshotted
Below is the actual project page today — 10.7k stars and counting, screenshot taken minutes before publishing:

What the forwarded claim got right (and slightly wrong)
The original write-up Steve forwarded says "one day, two thousand stars." Close, but the meter has moved: the repo hit 10,652 stars in 16 days — roughly 665 stars a day sustained, which is honestly more impressive than the one-day spike. Verified via the GitHub API at time of writing: 481 forks, 194 open issues, Apache-2.0 license, last push today.
| Claim in the forwarded post | Verdict |
|---|---|
| "Starts containers in ~2.5 ms" | True, with an asterisk — 2.55 ms via Engine API, 14.1 ms via the docker CLI (their own bench/results.json, Apple Silicon, p50 of 30) |
| "10 MB mini kernel + tiny guest agent" | True — guest kernel image is 10,264 KB measured; PID 1 agent is ~900 KB (650 KB measured) |
| "docker / Compose / buildx all keep working" | True — Docker Engine API over a Unix socket; context name kiri; builds run BuildKit in a Kiri container |
| "One command brings up single-node Kubernetes" | True — kiri k8s start, a k3s cluster in one container, ~20 s ready |
| "Every container gets a local HTTPS domain" | True — https://<name>.kiri.local with Kiri's own certificate authority |
| "2,000+ stars in a day" | Understated — 10,652 stars in 16 days and climbing |
The 2.5 ms, dissected
Kiri's bench/results.json is unusually honest for a hype-era project — it even lists "design budget" targets separately from measured numbers, and documents its own caveats. The test: pull nothing, image is warm, run alpine true, exit, remove. Median of 30 runs, same docker CLI for all three engines:
| Engine | Engine API | docker CLI |
|---|---|---|
| Kiri | 2.55 ms | 14.2 ms |
| Docker Desktop | 213 ms | 243 ms |
| OrbStack | 380 ms | 442 ms |
So the headline ratio is ~84x through the API, ~17x through the CLI. The CLI floor across all three is ~14–19 ms — most of that is the docker client binary starting up, which is why Kiri's CLI number sits at the floor. Their own caveats, credited: OrbStack had 86 containers and a Kubernetes cluster running during the test (widening its numbers), and Kiri's 2.55 ms stops just before final file deletion (~3 ms with it included).
Why is it this fast? The kernel-primitive table in the same file is the best part of the whole project. Inside a Linux VM, Kiri measured the building blocks: fork+exec 0.54 ms, namespaces 0.78 ms, network namespace 1.15 ms, cgroup v2 1.23 ms, overlay mount 0.36 ms, veth create 2.2 ms. And then the kicker: veth delete takes 18.9 ms — and Docker does that before --rm returns. Modern containers are not slow to start; they are slow to tear down the network. Kiri deletes its network files just after the API returns, which is exactly the kind of trade a startup benchmark loves and a production system should think about twice. (To their credit, the benchmark says so in plain language.)
What about memory? The "15 MB daemon" is real for the daemon (9.7 MB measured) plus a 0.69 MB guest agent — but the per-engine comparison table from Better Stack's November 16 guide is the honest footnote: on macOS there is also a 69 MB VM helper process. The mechanism — VM sleeps 60 s after idle, wakes in ~0.15 s — is the real win. A small daemon is not the whole footprint; a sleeping footprint is.
And the earlier November 2 benchmark (via the Better Stack guide) measured 22 ms through the CLI vs Docker Desktop's 178 ms — 8x. The newer 14.2 ms in the repo is ahead of that. Two honest numbers, two different dates; the repo's is the one to quote.
Where Kiri does not win: Better Stack's summary notes Colima reads bind mounts faster and OrbStack accepts more HTTP connections per second. If your bottleneck is filesystem or HTTP throughput in a long-running container, 2.5 ms of startup is invisible. The win is for churn: test suites, CI build steps, devcontainer spawns, anything that creates thousands of short-lived containers a day.
What Kiri actually is (architecture in 30 seconds)
docker CLI ─┐
compose ────┼─ Docker Engine API ─► kiri daemon ── vsock ──► guest agent (PID 1)
buildx ─────┤ owns the VM clone3 → container
kiri UI ────┘
On macOS it runs inside one small Linux VM (Apple's Virtualization.framework, driven from Rust). On Windows, WSL2. On Linux — and this matters for our host question — there is no VM at all: the agent runs on the host kernel directly. No runc, no shim, no dockerd: the guest agent is PID 1, serves the host over vsock, reaps children, relays ports, answers DNS, and starts each container with a single clone3 into fresh namespaces plus a cgroup. The 10 MB kernel exists only for the VM guests; on Ubuntu you use your own kernel.
Feature-wise the compatibility story is surprisingly deep for a 16-day-old project: run/exec/logs/stats/cp/commit, memory/CPU/pids limits, seccomp defaults, --privileged, named volumes, bind mounts over virtiofs, --tmpfs, amd64 images via Rosetta, --platform, user networks with DNS, IPv6, host.docker.internal, local domains with HTTPS from its own CA, a native window, 38 languages, USB passthrough (beta), and free ngrok-style public sharing. Known gaps, stated in their own docs: docker build --add-host host-gateway fails with the docker-container build driver until its built-in builder lands, no apt/dnf repository yet (packages are release assets), no package signing yet, Homebrew planned.
Ubuntu on the NX host: worth integrating?
This is the question that actually matters for production machines, so we read the .deb packaging and the systemd unit. Short answer: worth a side-by-side trial, not worth a migration — and "docker management via HTTPS" needs a clarifying footnote.
How it installs on Ubuntu. Two packages: kiri (engine + docker CLI, Compose, buildx) and kiri-lite (~2.7 MB, engine only — the right choice if you already have a docker client). The systemd unit is clean and boring in the best way: /usr/bin/kiri daemon, socket at /run/kiri/docker.sock (0660, root:kiri), Delegate=yes for cgroups, state in /var/lib/kiri-daemon (0700). Installing alone starts nothing; sudo kiri host-access $USER enables it and puts you in the kiri group — which the docs honestly call "root-equivalent, exactly like the docker group."
The coexistence design is the best part for a host. Kiri's docker CLI only joins PATH through update-alternatives at priority 10 if /usr/bin/docker is free — Docker's CLI keeps winning whenever it exists. Compose and buildx plugins follow the same rule, and if Docker owns /var/run/docker.sock, Kiri leaves it alone. While no Docker engine claims the socket path, Kiri links it to its own, so Testcontainers, docker-py, and Go's client.FromEnv work untouched. It is engineered to be adoptable without displacement, which is exactly what a production host wants.
Now the HTTPS question. Kiri manages containers through a Unix socket only — no TCP listener. There is no built-in TLS endpoint to expose; that is the same posture as dockerd by default, and it is the correct default (the socket is group-guarded). If you want HTTPS management of the engine, you put a TLS-terminating proxy in front of the socket — Caddy or nginx with basic auth and client certificates — exactly the pattern used with Docker's socket today. The .kiri.local HTTPS that Kiri advertises is for your apps inside containers, not for managing the engine. And a warning worth repeating: the kiri group is root-equivalent, so any HTTPS proxy in front of this socket is, functionally, a root shell behind a login page. Treat it accordingly.
The honest verdict for a host. On a quiet production box running a handful of long-lived services, Docker's overhead is a rounding error and Kiri's 2.5 ms buys you nothing — while its age (v0.2.1, 194 open issues, one maintainer, CLA in the repo, upgrades that restart a running engine) costs you real risk. Where it genuinely earns a trial:
- Dev/CI hosts with churn. Build agents and test farms that spawn thousands of short-lived containers a day will feel the 17x CLI lifecycle win immediately.
- Heterogeneous dev boxes. One Ubuntu host serving many projects gets
.kiri.localnaming and the 60-second idle sleep for free. - Evaluation is cheap. Because Docker keeps its socket and CLI whenever present, you can run both engines on the same host and switch per command with
docker --context kiri— zero migration before you have measurements.
If we integrated it here, the plan would be: install kiri-lite, leave Docker untouched, point one CI/test workload at the kiri context, measure lifecycle and bind-mount performance on our own images for two weeks, and only then decide. Do not replace a working dockerd on a production host with a two-week-old v0.2.1 on the strength of someone else's benchmark — even an unusually honest one.
Scoreboard
| Score | Why | |
|---|---|---|
| Architecture & engineering honesty | 9/10 | Benchmark file with caveats, kernel-primitive table, socket-only security posture, coexistence-first packaging |
| Raw speed (measured) | 9.5/10 | 2.55 ms API / 14.2 ms CLI, p50 of 30, rerunnable with kiri bench |
| Compatibility depth | 8/10 | Real Docker API surface, Compose, buildx, Rosetta, k3s — but host-gateway build bug and beta USB |
| Project health | 5/10 | 10.6k stars and 481 forks, but 16 days old, v0.2.1, single blast-radius maintainer, CLA, unsigned packages |
| Production readiness (Ubuntu host) | 6/10 | Coexistence design is excellent; age and upgrade-restarts-a-running-engine behavior are not |
Verdict
Kiri is not hype — it is a genuinely clever deletion of everything between you and clone3, with benchmark discipline rare at this age and a packaging story that respects existing Docker installs. The "2.5 milliseconds" is true the way a sprinter's 100-meter split is true: real, measured, and not the whole race. For the NX host: trial it beside Docker, keep Docker in charge, and let churn-sized workloads make the case. The 2.5 ms matters when you start containers thousands of times a day. For the rest of us, it matters mostly as proof that the daemon stack still has slack worth removing.
Research checkpoint: blogs/kiri-runtime/research/notes.md. Numbers pulled live from the GitHub API and bench/results.json on 2026-11-18; the repo is moving fast, so re-check the star count and release before quoting.