# Kiri: A Smaller Runtime Behind Familiar Docker Commands

Starting a container is only one part of a development environment, but it is a part that can happen hundreds of times during tests and local iteration. A small fixed cost becomes noticeable when the workload repeatedly creates a container, runs a short command, and removes it.

[Kiri](https://runkiri.com/) targets that overhead with a compact runtime written in Rust and a Docker-compatible interface. **Its appeal combines a different container startup path with local networking and desktop conveniences.** Evaluating it requires separating those capabilities from the much broader question of whether it can support an existing development workflow.

This guide explains the runtime boundary, interprets its startup benchmarks, and examines the compatibility and resource questions that matter beyond a fast empty container.

<iframe class="aspect-video h-auto" width="100%" height="315" src="https://www.youtube.com/embed/qy4ajsBbOKw" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

## Docker compatibility describes an interface

The Docker command-line client communicates with an engine through an API. That separation allows another implementation to accept familiar commands without running the same internal stack as Docker Desktop.

Kiri implements that interface and supports workflows built around Docker images, Dockerfiles, Compose, and build tooling. On macOS, it runs Linux containers inside a small Linux virtual machine. On Windows, it uses WSL2. On Linux, the runtime can use the host kernel directly.

![Kiri host daemon communicating with a small Linux guest over vsock](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/21bf9dc7-3102-4c7a-c3fe-60a66210e400/lg2x =1920x1080)

*On macOS, the host component communicates with a Linux guest that runs the containers.*

This is why a familiar command does not imply an identical implementation. The client can request a container while a different daemon handles namespaces, filesystems, networking, and process lifecycle underneath.

It is also why compatibility needs testing at the application's boundaries. Accepting a basic `docker run` request is useful evidence, but a larger project may rely on build-cache behavior, volume permissions, network details, or less common API operations. A compatible interface is the beginning of that evaluation.

## A context selects the engine behind the client

Kiri sets up a Docker context named `kiri`. A context tells the client which engine endpoint to use. Existing Docker Desktop or OrbStack installations can remain available through their own contexts while the new environment is evaluated.

![Terminal and Kiri interface showing the runtime selected for Docker commands](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/302e1640-9d4d-4895-7df7-3936ffdad600/orig =1920x1080)

*A context changes the engine that receives client requests.*

For an explicit target, the project documents commands in this form:

```command
docker --context kiri run --rm alpine echo hello
```

The explicit context is useful when comparing environments because it makes the destination visible in the command itself. It also avoids confusion about whether a shell is still using a previously selected engine.

Containers, images, and volumes belong to an engine's storage environment. Switching a context does not automatically make all existing data appear in another engine. A migration feature can help copy resources, but that is a separate operation with its own verification requirements.

For a real project, keep a clear record of which engine holds persistent data and which context a terminal is targeting. Otherwise, an apparently missing database may simply be a different engine's empty volume rather than a failed application.

## What the eight-times-faster figure measures

Kiri's published November 2 benchmark compares a warm-image lifecycle: start an Alpine container, run `true`, exit, and remove the container. The listed median is 22 milliseconds for Kiri and 178 milliseconds for Docker Desktop, using the same Docker CLI with each engine limited to two CPUs and 8 GB of memory.

![Published warm-image container lifecycle comparison across four runtimes](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/129ee74c-7f78-4890-b23e-544b69c52400/md1x =1920x1080)

*A short-lived container emphasizes runtime and client overhead rather than application work.*

That roughly eightfold difference is meaningful for the measured operation. It does not imply that a database query, compilation, or HTTP request inside a long-running container becomes eight times faster. If application work dominates elapsed time, reducing container startup has a smaller effect on the total.

The [benchmark report](https://runkiri.com/benchmarks/) identifies the machine, engine versions, warmups, and samples. Those details belong with the result. Image downloads are excluded by the warm-image setup, and cold VM startup is a separate event from starting another container in a running environment.

The current repository also lists newer figures through the Docker API. Those numbers should not replace the 22-millisecond CLI result without explanation. A direct API lifecycle and a command launched through the Docker CLI measure different paths, and newer versions can change the implementation again.

## Fewer process boundaries reduce fixed overhead

Traditional container stacks divide responsibilities among components such as the daemon, containerd, runtime processes, and per-container shims. Those divisions support mature lifecycle management, but also introduce process and communication overhead.

Kiri uses a more compact path. A host component communicates with its Linux environment, and the guest-side runtime creates container processes using Linux facilities such as `clone3`. Namespaces, mounts, and resource controls still need to be established; removing intermediate programs does not remove the underlying isolation work.

![Comparison of the multi-component container startup path and Kiri's more direct path](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/01505c9b-0fed-40b6-4069-5a9eb1812700/public =1920x1080)

*Reducing intermediate processes can reduce the fixed cost of creating and managing short-lived containers.*

The architecture explains why tiny workloads are an informative test. When the container's command does almost nothing, setup and teardown dominate. In a workload that spends minutes compiling, those same fixed costs become a smaller proportion of the result.

Fewer components also move responsibility. Features handled by separate mature programs still need correct implementations somewhere. Performance is therefore one dimension of the design, alongside lifecycle correctness, API behavior, and recovery from failure.

For evaluation, include repeated starts, command execution in an existing container, process exit, and cleanup. A fast successful start says little about whether a stopped or crashed workload leaves the environment in the expected state.

## A small daemon is not the whole memory footprint

One attractive figure in the demonstration is a daemon using roughly ten megabytes. That describes a component, not the complete active environment. The Linux VM, guest kernel, filesystem cache, and container workloads also consume resources on macOS.

![Kiri's idle timer and virtual-machine state after containers stop](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/79d5e85e-3abe-47e9-578e-7ec55b11df00/lg1x =1920x1080)

*An idle VM can release resources, while a running workload still needs guest memory and CPU time.*

Kiri can return unused memory and suspend or stop its VM after a period with no running containers. The demonstrated idle interval is sixty seconds. Waking the environment again has a cost that should be considered separately from steady-state container startup.

The current project describes somewhat different daemon and wake figures than the earlier demonstration. The useful claim is the mechanism: resources can be reclaimed during inactivity. The exact footprint depends on version, host, active services, and measurement method.

Measure both the component and the host-level effect. A low daemon resident set can coexist with a substantial guest allocation. Conversely, a VM configured with a large maximum need not hold that entire amount as active physical memory at every moment.

Idle behavior also depends on what remains running. A forgotten database, helper container, or local cluster can keep the environment active. Test the actual daily workflow, including what survives after the main application stops.

## Local names simplify service access

Port mappings are a familiar source of friction in multi-service development. Developers need to remember which local port belongs to which application, and parallel projects can compete for the same numbers.

Kiri provides names for containers and Compose services, allowing a browser to reach a service through a local hostname. The demonstration opens Nginx without manually assigning a host port. This is a networking convenience above the application's ordinary container port.

![Container list showing local Kiri hostnames for application services](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/a4bf0d14-5fb7-4109-5f28-2ccd8984e800/lg2x =1920x1080)

*The container list exposes service names alongside their local addresses.*

The project also supports local HTTPS through its own certificate arrangement on macOS. Exact hostname suffixes and setup details should be checked against the installed version: current project pages use both `.kiri.local` and `.kiri.localhost` in different examples.

For a real application, verify redirects, cookies, callbacks, and browser-origin behavior under the chosen hostname. An app written around `localhost` may contain assumptions that do not automatically follow it to another local domain.

Local naming is especially valuable when several services must remain understandable together. It improves navigation, but it does not establish whether an application is ready for exposure outside the development machine.

## Public sharing changes who can reach the app

Kiri's sharing feature gives a local container a public HTTPS address. That can simplify a short demonstration or a webhook test, but the resulting audience is different from a browser on the same Mac.

![Sharing interface indicating the cloud account requirement and public-link behavior](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/126f3d29-502a-4a1f-425e-2cf599716f00/public =1920x1080)

*A public link makes the local service reachable beyond the development machine while sharing is active.*

The demonstrated setup requires a Kiri Cloud account, and possession of the link permits access. Local development services may expose debug routes, seed data, or unauthenticated administration because they were designed for a private machine.

This makes sharing an explicit workflow decision. Choose a suitable service and data set, establish the intended access conditions, and verify that disconnecting the share closes the path when the demonstration ends. The convenience of creating the URL does not change the application's own access controls.

Public sharing and local domains should be evaluated separately. A team may benefit from predictable local names without needing any public route. Likewise, a temporary public preview does not require migrating every local workload to a new runtime.

## Imports and Kubernetes broaden the workflow

Kiri includes a native interface for containers, images, volumes, networks, logs, and Compose projects. It can import resources from other local engines, reducing the effort of setting up an evaluation environment.

![Native container detail view with statistics and access to logs and files](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/1990a907-0c42-4e1e-34de-0d93d98a7e00/lg2x =1920x1080)

*The native interface brings resource details and management views together.*

Persistent data deserves its own validation. Confirm that the destination application can read a copied volume, that permissions are correct, and that the source remains available until the copy is trusted. A successful import message is useful, but application behavior is the stronger check.

Kiri also offers a single-node Kubernetes environment based on k3s. The project describes startup around twenty seconds after the required image is present. That can reduce setup effort for local cluster work, while still leaving Kubernetes compatibility questions specific to each application.

![Kiri's local Kubernetes command and cluster startup result](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/c6e7ba85-ec46-4e33-7b58-3e75f3792e00/orig =1920x1080)

*A bundled local cluster extends the development environment beyond individual containers.*

A local cluster does not reproduce every production cluster feature. Storage classes, ingress behavior, architecture, resource limits, and external services can differ. Treat it as a useful testing environment with a known scope rather than a guarantee of production equivalence.

## The best runtime depends on the workload

The project's own comparison does not show Kiri winning every operation. Colima reads bind mounts faster in the published run, while OrbStack accepts more new HTTP connections per second. That is useful context for applications whose bottlenecks live outside container startup.

An evaluation should reflect where time is spent. A test suite that launches many tiny containers may benefit from lower lifecycle overhead. A file-heavy build may care more about bind-mount performance. A long-running web application may barely notice a difference in startup once its processes are warm.

Compatibility has similar layers. Exercise the project's actual Compose file, Dockerfile stages, caches, registry authentication, volume ownership, networking, and cleanup. Use representative data and compare correctness before relying on a time difference.

Keep versioned measurements. Kiri is evolving quickly, and a result for one release should not silently become a claim about another. The current repository's headline, the benchmark page's dated table, and a local test can all be useful if their paths and versions remain explicit.

## Final thoughts

Kiri offers a compact implementation behind familiar Docker workflows, with attractive conveniences for local names, idle resource reclamation, imports, and temporary sharing. Its warm-image startup result is especially relevant to workloads that repeatedly create short-lived containers.

**The decision to adopt it should follow the application's workload and compatibility needs.** Compare the same operations under explicit contexts, measure the whole active environment, and verify persistent data and networking. A faster container lifecycle is a concrete benefit; the complete development experience is a broader test.
