Open Source
Open Source

kiri Hits 8,878 Stars in Two Weeks: 2.5 ms Docker Rival?

kiri is a Rust container runtime that drew 8,878 stars in two weeks. It claims 2.5 ms startup and direct Docker Engine API compatibility, inviting comparison with Docker Desktop. This piece checks its first-party GitHub data, README self-reported claims and Apache-2.0 license to see if it can really replace Docker Desktop.

Published November 18, 20269 min read
<!-- kiri-rust-container-runtime-opensource | open-source | kiri Hits 8,878 Stars in Two Weeks: 2.5 ms Docker Rival? -->

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

This article is AI-assisted and human-edited. Last updated: 2026-11-18

FAQ

Is kiri's 2.5 ms a third-party benchmark?
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.
How did 8,878 stars arise, and what is +1,744?
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.
Can I keep using my existing docker commands?
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.
What does the licence say, and who owns the copyright?
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.
Can it replace Docker Desktop now?
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

Open Source

Announced GA, Yet Only 71 Stars: What Is Kinference?

Buoyant, the company behind Linkerd, open-sourced Kinference as an inference control plane for Kubernetes and vLLM and announced GA on November 4, 2026; a GitHub API snapshot on November 9, 2026 shows Kinference-AI/kinference (migrated from buoyantio/kinference via 301) at only 71 stars, 6 forks and 57 open issues, in Rust under Apache-2.0, created October 5, last pushed November 8, version v0.1.0-alpha.7. The README confesses verbatim that Kinference is alpha software with no sustained production exposure, lacking Anthropic-style /v1/messages, rate limiting, semantic classifiers and multi-replica support. Mechanically it exposes a gRPC interface that takes OpenAI-format requests, returns the chosen endpoint plus a mutated body, monitors vLLM KV-cache events and engine metrics, reuses NVIDIA's dynamo-kv-router crate and pairs with the Buoyant Gateway. Its vendor-reported median TTFT improvement, 6.88s to 0.31s on shared-prefix traffic, was measured against random routing rather than llm-d or Dynamo, and has no third-party reproduction.

Nov 10, 20269 min read
Open Source

3,003 Stars, No Stable Release Yet: What Is Blocking It?

oxc-project/tsrs is a Rust rewrite of the TypeScript 7 compiler and language server, described in its README as a drop-in replacement. A GitHub API snapshot on November 8, 2026 showed 3,003 stars and Apache-2.0, but still no stable release. The README says the team aims to ship a stable version against TypeScript 7.1 with 100% conformance; aim is a target, not a delivered result. docs/STATUS.md lists GitHub prereleases, a manually assigned npm beta tag and release candidates, but nowhere declares stable. Speedup figures come from three unrelated setups that cannot be merged into one table: the project's own bench/RESULTS.md covers 19 projects on an Apple M3 Max, measured 2026-10-28 with Hyperfine medians against TypeScript 7.1.0-beta, giving 1.71x-6.62x faster; Cloudflare's up to 8x compares against TypeScript 7.0; third-party numbers near 2.7x and 5.3x have their own machines and baselines. This is a deep dive into one repository, not a multi-project ranking.

Nov 9, 20269 min read
Open Source

19,207 stars, still alpha: can this Rust engine rebuild a site?

storytold/craft-anything describes itself as an open-source clean-room engine in pure Rust: see how any website, app or game works, then have AI build your own version. The workflow points at a target, states what is wanted, studies the original with real inspection tools, has a coding agent build a new project, compares results against the original and iterates. A November 7, 2026 GitHub API check showed 19,207 stars, Rust as the language and a repository created on October 31, 2026. The README badges say early alpha and 100% Rust, and the license text is dual-licensed under MIT or Apache-2.0 at your option. ATTRIBUTION.md records bundled font and icon licenses while brand assets must not be modified. macOS, Windows, Linux, FreeBSD and Web are supported through a desktop app, CLI and MCP server, with Anthropic, OpenAI, OpenRouter, xAI and local models plus installed GitHub Copilot, ACP grok and Ghidra. The README admits some capabilities are built but not yet run live.

Nov 7, 20269 min read