Kiri deletes the container runtime and starts a container in 2.55 ms

There is a specific irritation in typing docker ps and waiting. The wait is short, but you do it two hundred times a day and your hands learn the pause. So a repository that claims a container starts and exits in 2.55 ms gets attention, followed quickly by suspicion.
Kiri is that repository. It lives at libracoder/kiri, it is written in Rust, it had 5,070 stars on 15 Nov 2026, and it ships under Apache-2.0. The name comes from the Igbo word ntakiri, "small", which is the whole design brief in one syllable count. It runs containers in one small Linux VM, or straight on the kernel when you are already on Linux, and it speaks the Docker Engine API. Your docker CLI, Compose, buildx and docker login keep working. On Apple silicon, amd64 images come through Rosetta.
The headline in the README is that a container starts and exits in about 2.5 ms, around 80 times faster than Docker Desktop. That figure carries a lot of weight, so it deserves a proper look.
The benchmark, as written
The method is one line and I will keep it exact: alpine running true and then removed, median of 30 runs, the same docker CLI for all three tools. Every other figure and the full method sit in bench/results.json, and you can rerun the whole thing with kiri bench.
| Tool | Docker Engine API | `docker` CLI |
|---|---|---|
| Kiri | 2.55 ms | 14.2 ms |
| Docker Desktop | 213 ms | 243 ms |
| OrbStack | 380 ms | 442 ms |
Two columns, and the headline uses the left one. Divide them yourself. 213 by 2.55 is about 84, so "roughly 80x" is fair on the API path. Through the CLI, 243 by 14.2 is about 17. Both are true. The 80x compares Kiri's fastest path against Docker Desktop's fastest path, which is the right comparison, and the one least likely to show up in your terminal. That 14.2 ms on the CLI side is largely the docker binary starting, parsing its own flags before it reaches a socket. It is the floor for any tool that keeps the official CLI, Kiri included.
Now the boundary. This measures the lifecycle of one very small container on one machine, mediated by an API. It does not measure an image pull, a layer extraction, a build against a cold cache, or twenty services coming up at once on a spinning disk. It says nothing about disk I/O under contention or memory pressure. A single figure from a true process is a clean signal about orchestration overhead and a weak signal about almost everything else.
Where the milliseconds went
Requests arrive on the Docker Engine API. A daemon that owns the VM takes them, they cross vsock, and the guest's PID 1 starts the container.
That PID 1 is a Rust agent of roughly 900 KB. The kernel underneath it is a custom 10 MB build. Containers start with a single clone3 into namespaces and a cgroup. There is no runc in the box, no shim, and no dockerd.
Docker Desktop's 213 ms is mostly plumbing: a VM, a shim, dockerd, and API translation. Each of those is a process boundary, a socket, a context switch, a scheduler wake. A request that needs microseconds of real work spends most of its life being handed from one component to the next. Delete the components and the handoffs go with them. What remains is a process calling clone3, which is close to the cheapest thing a Linux kernel does on behalf of a user.
The 2.55 ms is a symptom of an architecture, and the architecture is legible from the repo layout in a way a benchmark row never is.
Two other numbers matter more on a Tuesday afternoon. The daemon sits around 15 MB. The VM sleeps after 60 seconds of idle and wakes in about 0.15 seconds. Compile for two minutes, run a test, and your runtime is asleep. That is the tax, small but not zero.
The migration is one flag, which is the actual product question
First launch sets up a kiri Docker context. After that, every familiar command takes a context flag, and Docker's commands also exist as kiri commands (kiri run, kiri ps, kiri compose up) that always target Kiri.
docker --context kiri run --rm alpine echo hello
docker --context kiri compose up -d
kiri k8s start
kiri import
For a tool in this category, speed has never been the interesting question. The cost of moving is. A developer with forty compose files, two hundred gigabytes of images and a team wiki full of docker incantations will not switch for 200 ms saved per container. They switch when the move costs one command and nothing breaks.
kiri import exists for that. It brings images, volumes and containers over from OrbStack or Docker Desktop. It is the least glamorous line in the README and the one that decides whether anyone gets as far as the benchmark. A faster runtime with no import path is a weekend experiment. A slightly slower one with a clean import path is a product.
There is a second benefit nobody advertises. Because Kiri arrives as a context rather than a replacement binary, you can leave Docker Desktop installed and switch per command or per project, so the trial stays reversible. That is what gets tools through their first week at work.
The rest of the list, judged quickly
Local domains give you http://.kiri.local, with HTTPS from Kiri's own certificate authority. That removes an /etc/hosts edit and a certificate warning from every web project, and it is the feature I would miss most.
kiri k8s start produces a single-node cluster exposed as the kiri kubectl context. Single node means a place to check manifests and Helm charts before they hit a real cluster. kiri machine create dev --distro ubuntu gives you a Linux machine when a container is the wrong shape.
The interface ships in 38 languages, with right-to-left layout for Arabic, Persian and Central Kurdish. There is a native window for containers, images, volumes and networks. Installers come as a .dmg for macOS 14 and later on Apple silicon or Intel, an .msi for Windows 10 and 11 on x86-64 or Arm, and a .deb or .rpm for Linux. Kiri updates itself, checking each release's signature before applying it.
One caveat on Windows: it runs through WSL 2, so the Windows experience inherits a component Kiri does not ship and cannot optimise. The 2.55 ms is a macOS and Linux story until someone publishes a Windows number.
What is missing
The roadmap has one item: a built-in builder. Kiri will serve Docker's own build endpoints so buildx uses its docker driver against Kiri the way it does against Docker Desktop. That brings host-gateway support to BuildKit builds and loads images straight into Kiri instead of through a side channel.
Until that lands, building is the weak part of the story. If your day is mostly docker build, none of this rescues you, and waiting is reasonable. If your day is mostly starting and stopping small services, the case is already made.
Licensing is Apache-2.0, with the guest kernel under GPL-2.0 and its config, patches and source offer kept in guest/kernel. The name and the logo sit outside the licence, and forks are welcome under a different name and logo. That clause is deliberate: it lets people fork the code without letting a fork become the default runtime for everyone while wearing the same shirt.
What I would check before switching
I would not take the table on faith, and the repo does not ask me to. kiri bench is right there, and bench/results.json documents how every figure was produced. The honest test is a week on my own machine with my own compose files and the worst project I own, the one with eleven services, a database and a healthcheck that never passes on the first try.
The metric I would watch is how often the VM is asleep at the moment I need it, how a rebuild behaves with a cold layer cache, and whether kiri import moves my volumes across without making me reseed a database. Those three answers decide whether Kiri replaces Docker Desktop on my laptop. The 2.55 ms is a good reason to open the download page in the meantime.
Related articles
Six Amateurs, 1,113 Episodes, a Thousand Yuan of Compute an Episode: How an AI Drama Got Hand-Built
The first ten seasons of Armed Into Song run to roughly a thousand episodes and have passed ten billion cumulative views, with six core creators and not one of them film-school trained. Compute runs 1,000–2,000 yuan an episode; a normal shot takes three rolls, a battle twenty-plus, and anything that looks flat is graded a sixty and thrown out.
One server, one AI streamer: inside the code that runs a nightly livestream
open-yoki is the production code behind an AI host who streams nightly on Binance Square, with the persona, voice and money features stripped out. Headless Chrome draws the frame, ffmpeg pushes RTMP, a folder of Markdown decides what she feels and what she posts.
Pinky lets an agent drive your phone, and holds the Send button until you click Allow
Pinky connects any MCP agent to a real iPhone or Android phone and enforces approval in its own gateway rather than in a prompt. Banking apps are invisible, password fields are off limits, and on Android 13 the agent gets a hidden second screen.
ByteDance's SeedRealtime takes two frames a second and decides when to speak
Doubao-Seed-Realtime-1.0 folds camera frames, screen frames and speech into one full-duplex session, at no more than two frames per second. The interesting decisions are the frame rate, the proactive speaking, and the audit reply that ships switched on.