Two weeks, 8,878 stars, and a claim that a container starts in 2.5 ms. That is the calling card of kiri, a lightweight container runtime written in Rust. The repository is kiri, spelled out as https://github.com/libracoder/kiri. The title asks whether it can replace Docker Desktop, but answering that honestly means putting one boundary first: who measured those 2.5 ms, under what conditions, and whether anyone independent has reproduced them. This article is not a README walkthrough; its main line is the boundary between self-reported claims and independent verification.
Two Weeks, 8,878 Stars, and One Snapshot
As of November 17, 2026, reading the GitHub API cumulative totals, stargazers_count is 8,878, forks_count is 392, the primary language is Rust, and license.spdx_id is Apache-2.0. The created_at field sits at 2026-11-02, pushed_at at 2026-11-16, the default branch is main, and the homepage points to runkiri.com. The two weeks in the title describe the repository's age at this check, not a growth window. Stars are a cumulative total and should be read with their fetch time, never confused with a single-day increment.
The star figure needs one more split. 8,878 is a cumulative snapshot; a separate +1,744 refers to star events inside a single trending-day window, an increment. The two are not the same metric and must be neither added nor subtracted. At this check kiri was no longer on GitHub's daily Rust trending page, so claims of sustained dominance have no basis. A careful account never packages a one-window increment as lasting heat.
Where the 2.5 ms Figure Comes From
The 2.5 ms in the title carries a precise qualifier. The README says "about 2.5 ms" in its Why Kiri section and states the conditions: an alpine container running true and then removed, the median of 30 runs, the same docker CLI throughout, split into two columns, one through the Docker Engine API and one through the docker CLI. The Engine API column reads 2.55 ms, the CLI column 14.2 ms; Docker Desktop is 213 ms and 243 ms, OrbStack 380 ms and 442 ms. The famed 80 times figure is 2.55 against 213. So 2.5 ms is self-reported by the project, not an independent benchmark, and that qualifier belongs in every sentence touching performance.
Spreading out those conditions makes the boundary clear. The claimant is the project itself; the data lives in bench/results.json and anyone can rerun it with kiri bench, yet it remains the project's own result on its own machine. The test object is alpine running true, a container doing almost no real work, so what is measured is orchestration overhead, not the cold start of a real application. The 80 times comparison comes from the same self-test with the comparison group fixed at Docker Desktop's 213 ms; change the machine or image and the ratio changes.
Is there independent verification? This check found no reproducible third-party benchmark. On the contrary, one third-party article notes that the figures on the runkiri.com home page, docker run at 22 ms against Docker Desktop at 178 ms, were vendor-measured on a single Apple Silicon Mac and amount to "a claim rather than an independently verified result," with the comparison charts still placeholders. The same source notes the product gives inconsistent numbers in two places: the README says 2.55 ms through the Engine API, the home page 22 ms for docker run. That does not make the numbers false; it means different methods and environments, so method must be cited alongside each figure. Keeping the word self-reported next to every performance claim is the basic discipline here.
A 10MB Kernel and One clone3 Call
The architecture is the hardest and most checkable part. The README says the VM uses a custom 10MB kernel, and its PID 1 is a roughly 900 KB Rust agent. That agent starts containers with a single clone3 into namespaces and a cgroup, with no runc, no shim, and no dockerd. kiri compresses the traditional daemon plus shim plus runc chain into one resident agent, so container creation becomes a single system call. The 10MB refers to the kernel image, not a distribution, and that volume backs the claim of being small.
Lightness shows up in resource use too. The README says the VM sleeps after 60 seconds idle, the daemon stays around 15 MB, and it wakes in about 0.15 seconds. On macOS and Windows containers run inside one Linux VM with vsock between host and guest; on Linux the agent runs directly on the host kernel, with no VM, ballooning, or sleeping. Entry points are specific: macOS 14 and later on Apple silicon or Intel uses a .dmg; Windows 10 and 11 on x86-64 or Arm must go through WSL 2 with an .msi; Linux uses .deb or .rpm. The name comes from the Igbo word ntakirị, "small," and these numbers are how the project cashes that in.
Speaking Docker Engine API
Compatibility is the crux of whether kiri can replace Docker Desktop. Its selling point is speaking the Docker Engine API, so the docker CLI, Compose, and buildx you already use keep working. It creates a kiri Docker context and you point commands at it with docker --context kiri; docker CLI commands also work as kiri run, kiri ps, and kiri compose up, always targeting Kiri. The compatibility list covers run, exec, logs, attach, stop, cp, commit, and stats. Migration cost is concentrated in switching contexts rather than rewriting scripts. That is where replacement acquires an operational meaning.
Two more practical features sit underneath. A single kiri k8s start brings up a single-node k3s cluster inside a container, ready in about 20 seconds after the first pull as the kiri kubectl context. The other is a local HTTPS domain per container: <name>.kiri.local needs enabling, while <name>.kiri.localhost works with no setup. HTTPS is issued by Kiri's own CA under ~/.kiri/tls, with name constraints allowing only those two domains, and enabling it asks macOS to trust the certificate. Local development gets a proper domain and a trusted certificate, constrained to dedicated domains.
The Ngrok Claim Deserves Its Own Section
One detail needs its own qualifier. The GitHub description contains the phrase free Ngrok alternative, but the README body does not, and never mentions ngrok, tunnel, or runkiri.cloud. What the README does describe is local domains with a self-signed CA, which is not an ngrok-style public tunnel. The real sharing capability is in the Kiri Share documentation: Kiri opens one encrypted connection to the relay at edge.runkiri.com on port 443, and visitors reach a local port, container, or Kubernetes service at an HTTPS address on runkiri.cloud, with no router port opened. This rests on a third-party directory's retelling of the official docs, weaker evidence than the README or API. Sharing also requires a Kiri Cloud account created by signing in with GitHub, with plan limits on concurrent links, speed, and monthly transfer. Reading one description line as a README promise of a free public tunnel crosses the factual boundary.
A Placeholder in the License
The license has its own trap. The API reports license.spdx_id as Apache-2.0 and Cargo.toml states license = "Apache-2.0"; these are the basis for judgment. The LICENSE file, though, is a standard Apache-2.0 template in full, with the copyright line still reading [yyyy] [name of copyright owner], no owner or year filled in. You cannot invent a copyright line from it or infer who owns Kiri's copyright. The README adds that the Kiri name and logo are not covered by the licence, and what is allowed is a fork under a different name and logo. The guest kernel is Linux under GPL-2.0. Apache-2.0 names the licence type; the copyright line is left blank in the official file.
v0.2.1 and the Beta Reality
The release cadence overturns another misconception. This is not a project with no release: the latest stable version is v0.2.1, published 2026-11-15, with draft and prerelease both false and arm64 and x86_64 .dmg, .msi, and .tar.gz assets plus a kernel source package. From creation on 11-02 to a release on 11-15 is a fast pace. Yet having a stable version is not the same as being settled. The official features document frames the context as beta from its opening lines, the Roadmap admits a built-in builder is unfinished, and using host-gateway in BuildKit builds still needs a workaround. The README does not literally say "not for production," but these limits are real and writing them down is more responsible than hiding them.
Open issues tell a similar story. The API's open_issues_count is 156, but that includes pull requests; searching issues alone returns 110, the difference being open PRs. High-frequency topics by comment count cluster in three groups: networking and Docker Engine API consistency, such as a bridge name option reported but ignored and docker inspect dropping port bindings; cross-platform details, such as the engine not restarting after a macOS update, no inotify on bind mounts, no default seccomp, and path conflicts with Docker Desktop for Linux; and build gaps, such as docker build failing over an unpacked buildkit layer. Developers use labels like status: partially fixed, so problems are claimed but not cleared.
So is kiri a credible Docker Rival today? Two weeks and 8,878 stars, a self-reported 2.5 ms, a 10MB kernel, Docker Engine API compatibility, and one-command k3s make it a lightweight alternative worth watching. But calling the replacement of Docker Desktop an accomplished fact still lacks three pieces: an independent reproduction of the benchmarks, convergence of cross-platform compatibility issues, and a finished built-in builder. For local development and CI container runs it already handles much of the work; for production environments that put stability first, the project does not claim to be finished. Star heat and performance claims are separate things, and that is the line this article holds.
Stacking identity, performance, architecture, compatibility, licence, releases, and limitations gives a complete picture: a Rust-written lightweight runtime that sells itself on being small and fast and speaks the Docker Engine API, with a 2.5 ms narrative propped up by self-reported testing behind 8,878 cumulative stars and the independent verification link still missing. This article covers the runtime repository itself, a different angle from the Rust-ecosystem view in Rust and TypeScript open-source resources and the self-test-sensitive llama.cpp and ggml 1.0.0. Chrome's official MCP server covered a browser tool and is outside this article's scope.
FAQ
Q1: Is kiri's 2.5 ms a third-party benchmark? A1: No. It is self-reported: an alpine container running true and removed, median of 30 runs, 2.55 ms through the Docker Engine API; the 80 times figure against Docker Desktop's 213 ms comes from the same self-test. The data lives in bench/results.json and can be rerun with kiri bench, but it remains the project's own method, and this check found no independent reproduction.
Q2: How did 8,878 stars arise, and what is +1,744? A2: 8,878 is the GitHub API cumulative snapshot as of November 17, 2026; +1,744 is the star-event increment inside a single trending-day window. They are not the same metric and cannot be added or subtracted. At the time of this check kiri was no longer on the daily Rust trending page, so sustained dominance is not supported.
Q3: Can I keep using my existing docker commands? A3: Yes. kiri speaks the Docker Engine API: create a kiri Docker context and point commands at it with docker --context kiri, and the docker CLI, Compose, and buildx keep working; commands also run as kiri run, kiri ps, and kiri compose up. The migration cost is mainly switching contexts rather than rewriting scripts.
Q4: What does the licence say, and who owns the copyright? A4: Cargo.toml states license = "Apache-2.0" and the API spdx_id is Apache-2.0. The LICENSE file, however, is a standard template with the copyright line still reading [yyyy] [name of copyright owner], so no owner or year is filled in and no copyright line should be invented. The Kiri name and logo are outside the licence; the guest kernel is GPL-2.0.
Q5: Can it replace Docker Desktop now? A5: It depends on the scenario. For local development and CI container runs, its lightness and compatibility already cover a lot of ground; but the three things production needs, an independent benchmark reproduction, converged cross-platform compatibility, and a built-in builder, are still missing. The official features document frames everything as beta and the Roadmap admits the built-in builder is unfinished, so replacement should not be treated as an established fact.
Related reading
- tsrs-rust-typescript-opensource-resource: open-source resources viewed through the Rust ecosystem.
- llama-cpp-ggml-1-0-0-opensource-resource: a lightweight runtime project where self-test claims also need care.
- chrome-devtools-mcp-coding-agent-opensource-resource: an open-source tool repository maintained by Chrome's team.
- univer-office-sdk-agent-editing-opensource-resource: another project opened up in SDK form.