---
title: 'Kiri face à Docker Desktop : architecture, benchmarks et limites du runtime en Rust'
description: "Kiri se présente comme une alternative open source à Docker Desktop, écrite en Rust, jusqu'à 8 fois plus rapide au démarrage. Voici ce que disent son architecture et ses benchmarks, et ce qui reste à sa charge."
pubDate: 2026-11-20
family: 'devops-cloud'
tags: ['Docker']
heroImage: '/images/kiri-alternative-a-docker-desktop-en-rust.webp'
videoUrl: 'https://www.youtube.com/watch?v=pilLUQck6-M'
faq:
  - question: 'Kiri est-il compatible avec mes projets Docker existants ?'
    answer: "Oui, tant que tu t'en tiens à l'API Docker Engine. Kiri implémente cette API et fournit le CLI docker, Compose et buildx : tes images, tes fichiers compose.yaml et tes scripts ne changent pas. Il ajoute un contexte Docker nommé kiri et peut cohabiter avec Docker Desktop. En revanche, les fonctionnalités de dockerd qu'il n'implémente pas répondent par une erreur explicite."
  - question: 'Le « 8× plus rapide » correspond à quoi exactement ?'
    answer: "Le chiffre vient du temps de `docker run --rm alpine true` mesuré par Kiri : 22 ms contre 178 ms pour Docker Desktop, sur une même machine avec chaque moteur limité à 2 CPU et 8 Go. La mesure la plus directe, à travers l'API Docker, donne 2,55 ms contre 213 ms. La plus grande partie des 22 ms est en réalité le démarrage du CLI docker lui-même."
  - question: 'Kiri peut-il remplacer Docker Desktop en production ?'
    answer: "Non, Kiri est un runtime de développement local, encore en bêta (0.2.2). Il ne gère pas les conteneurs Windows, ne remplace pas l'écosystème complet de Docker (Extensions, outils, administration à grande échelle) et vise un usage sur poste de travail, pas un hôte de production. Sur un serveur Linux, tu garderas Docker ou un runtime équivalent."
---

Kiri est un runtime de conteneurs open source, écrit en Rust, qui se pose en alternative à Docker Desktop. Son argument principal tient en un chiffre : un démarrage de conteneur jusqu'à 8 fois plus rapide. Mais derrière le chiffre se cache un choix d'architecture précis — supprimer la chaîne `dockerd` → `containerd` → shim → `runc` au profit d'un seul daemon et d'un agent dans la VM.

Cet article reprend ce que montre la vidéo et complète les points techniques avec la documentation officielle de Kiri ([runkiri.com](https://runkiri.com/) et [docs.runkiri.com](https://docs.runkiri.com/)). Aucune commande de cet article n'a été exécutée pour l'article lui-même : les chiffres et les comportements proviennent de ces sources, pas d'un test que j'aurais mené sur ma machine. C'est une limite à garder en tête, notamment pour les benchmarks, qui sont ceux publiés par l'éditeur.

## Ce que propose Kiri

Kiri lance des conteneurs Linux depuis un seul moteur et parle l'API Docker Engine. Concrètement, il se présente comme compatible avec ce que tu utilises déjà :

- le CLI `docker`, `docker compose` et `docker buildx` ;
- l'API Docker Engine ;
- Docker Hub, `ghcr.io` et les images OCI ;
- les Dockerfiles.

La version courante au moment de la vidéo est la **0.2.2**, encore en bêta. Kiri est distribué sous double licence Apache-2.0 ou MIT, et son binaire hôte fait environ 2,2 Mo. Il existe pour macOS (Apple silicon et Intel, macOS 14 ou plus récent), pour Linux, et en bêta pour Windows via WSL2.

## D'où vient le « 8× plus rapide »

### Ce que mesure le chiffre

Le facteur 8 vient d'une mesure simple, `docker run --rm alpine true`, avec chaque moteur limité aux mêmes ressources (2 CPU, 8 Go) et le même CLI Docker :

- **Kiri : 22 ms**
- Docker Desktop : 178 ms
- Colima : 152 ms
- OrbStack : 279 ms

La documentation précise un point important : la majeure partie de ces 22 ms est le temps de démarrage du CLI `docker` lui-même. La mesure plus directe, à travers l'API Docker (création et suppression d'un conteneur), donne **2,55 ms pour Kiri contre 213 ms pour Docker Desktop** — c'est là que l'écart d'architecture se voit vraiment.

### Le tableau complet des benchmarks

Kiri publie l'ensemble de ses mesures, issues de son dépôt (`bench/results.json`) et reprises sur la page [Benchmarks](https://docs.runkiri.com/benchmarks/). Un extrait, mesuré sur un Apple M3 Max avec chaque moteur ramené à 2 CPU et 8 Go :

| Mesure                        | Kiri    | Docker Desktop | OrbStack | Colima  |
| ----------------------------- | ------- | -------------- | -------- | ------- |
| `docker run --rm alpine true` | 22 ms   | 178 ms         | 279 ms   | 152 ms  |
| Cycle de vie via l'API Docker | 3,1 ms  | 163 ms         | 238 ms   | 88 ms   |
| `docker exec` (test trivial)  | 15,7 ms | 47,7 ms        | 32,5 ms  | 36,8 ms |
| Pull, image déjà présente     | 321 ms  | 2798 ms        | 1569 ms  | 2893 ms |
| Démarrages parallèles         | 88,9 /s | 11,4 /s        | 8,2 /s   | 12,9 /s |

Kiri est en tête sur chaque ligne du tableau, mais la documentation signale elle-même deux lignes où il n'est pas le meilleur : Colima lit les _bind mounts_ plus vite (5235 Mo/s contre 1724 Mo/s pour Kiri) et OrbStack accepte plus de nouvelles connexions HTTP sur un port publié (2389 /s contre 1892 /s). Autrement dit, « 8× plus rapide » vaut pour le démarrage de conteneurs, pas pour toutes les opérations.

## Pourquoi Kiri est plus rapide : l'architecture

### Ce que fait Docker Desktop derrière `docker run`

Dans Docker Desktop, une commande `docker run` traverse une chaîne de programmes : `dockerd`, puis `containerd`, puis un `containerd-shim` **par conteneur en cours d'exécution**, puis `runc`. Chaque étape a son propre socket, et le shim reste résident tant que le conteneur tourne.

### Un daemon, une VM, un agent

Kiri remplace toute cette chaîne par trois pièces :

1. **Le daemon** (`kiri daemon`) tourne sur la machine hôte. Il sert l'API Docker Engine sur `~/.kiri/run/docker.sock`, gère les enregistrements de conteneurs, télécharge et publie les images, et pilote la VM.
2. **La VM** est créée avec le framework de virtualisation d'Apple, piloté depuis Rust. Elle démarre un noyau Linux personnalisé d'environ 10 Mo, construit à partir de `allnoconfig` avec seulement le nécessaire. Sur Linux, Kiri s'en passe complètement : le moteur tourne directement sur le noyau de l'hôte, en service systemd.
3. **L'agent** (`kiri-init`) est un petit binaire Rust statique qui sert de PID 1 dans la VM. Il démarre les conteneurs lui-même, **sans `dockerd`, `containerd`, shim ni `runc`**.

Le daemon et l'agent communiquent en vsock avec un petit protocole binaire (un aller-retour médian d'environ 31 µs).

### `docker run`, étape par étape

Toujours d'après la documentation :

1. Le CLI envoie `POST /containers/create` au socket ; le daemon récupère l'image depuis le registre si besoin.
2. Les couches absentes sont transférées une seule fois en vsock et décompressées sur le disque de la VM ; les conteneurs suivants de la même image sautent cette étape.
3. `POST /containers/{id}/start` devient un simple _frame_ `Run` en vsock.
4. L'agent crée le conteneur avec **un seul appel `clone3`** (`CLONE_INTO_CGROUP`), monte l'overlayfs, appelle `pivot_root`, retire les capacités, installe le filtre seccomp et exécute la commande.

Comme chaque processus de conteneur est un enfant direct de l'agent, il ne reste aucun processus résiduel par conteneur, ni sur l'hôte ni dans la VM. C'est ce qui explique aussi l'empreinte mémoire : **9,7 Mo** pour le moteur Kiri contre **216 Mo** pour OrbStack (dockerd + containerd + shims) sur la même machine, et **0 Mo par conteneur** là où OrbStack compte environ 7,9 Mo de shim.

## Installation et premier conteneur

Sur macOS, Kiri s'installe via Homebrew ou l'application signée et notarizée :

```bash
brew install --cask libracoder/kiri/kiri
```

À la première ouverture, Kiri crée un contexte Docker nommé `kiri`, si bien que tes outils pointent vers lui. Le premier conteneur ressemble à n'importe quel usage de Docker :

```bash
docker run -d --name web -p 8080:80 nginx
open http://web.kiri.localhost
```

Le nom `web.kiri.localhost` résout directement le conteneur par son nom, sans mémoriser de port. Avec les noms de domaine activés, les services Compose répondent à `<service>.<projet>.kiri.local`, avec du HTTPS fourni par l'autorité de certification propre à Kiri.

## Les fonctions au-delà des conteneurs

Au fil des versions, Kiri a élargi son périmètre. La documentation liste notamment :

- **Kubernetes** : `kiri k8s start` lance un cluster k3s en une vingtaine de secondes, avec les Pods et Services visibles dans la fenêtre ;
- **Machines Linux** : `kiri machine create dev --distro ubuntu` crée un environnement Linux avec ton utilisateur et tes dossiers macOS aux mêmes chemins ;
- **Kiri Share** : `kiri share web` publie un conteneur sur une adresse publique en HTTPS sur `runkiri.cloud`, jusqu'à déconnexion ;
- **Gestion de la mémoire** : la VM rend la mémoire inutilisée pendant qu'elle tourne, se met en veille après une minute d'inactivité et redémarre en environ 0,15 s ;
- **Migration** : `kiri import desktop-linux` (ou `kiri import orbstack`) récupère images, volumes et conteneurs depuis l'outil concurrent.

## Les limites à connaître

Kiri est encore en bêta, et sa propre documentation est la plus claire sur ce qu'il ne fait pas :

- **Pas de conteneurs Windows** : sur Windows, Kiri ne lance que des conteneurs Linux dans WSL2.
- **Pas l'écosystème Docker complet** : Kiri implémente lui-même l'API Engine ; les fonctionnalités de `dockerd` qu'il ne gère pas répondent par une erreur explicite. Les Extensions, les autres outils Docker et l'administration à grande échelle ne sont pas là.
- **Pas de passthrough USB ni de son** pour les conteneurs et machines.
- **Pas d'accès direct par IP** depuis la machine hôte : on passe par les ports publiés ou les noms.
- **Fichiers de conteneurs en lecture seule** dans Finder, sous `~/Kiri`.
- **Pas de Debug Shell** pour entrer dans un conteneur minimal sans shell (fonction présente chez OrbStack).

## Faut-il remplacer Docker Desktop ?

La réponse dépend de ce que tu cherches. Si ton irritant principal est le temps de démarrage des conteneurs, la mémoire consommée au repos et la présence de processus résiduels, l'architecture de Kiri — un daemon, une VM, un agent, aucun shim — répond directement au problème, et ses benchmarks le montrent sur la majorité des opérations.

Si tu dépends de conteneurs Windows, des Extensions Docker, du passthrough USB ou d'une administration centralisée, Docker Desktop reste devant, et Kiri est encore en bêta. La bonne nouvelle est que les deux peuvent cohabiter : Kiri utilise son propre socket et son propre contexte, et `docker context use` permet de basculer.

Le plus simple est de tester sur un projet existant : tes images et tes `compose.yaml` n'ont pas à changer. Pour creuser, la page [How it works](https://docs.runkiri.com/how-it-works/) détaille l'architecture et les [Benchmarks](https://docs.runkiri.com/benchmarks/) fournissent les chiffres bruts et leur méthode de mesure.

La vidéo ci-dessous propose une plongée en motion design dans les moteurs de conteneurs, avec les démonstrations et les comparaisons de performances.

## Questions fréquentes

**Kiri est-il compatible avec mes projets Docker existants ?**

Oui, tant que tu t'en tiens à l'API Docker Engine. Kiri implémente cette API et fournit le CLI docker, Compose et buildx : tes images, tes fichiers compose.yaml et tes scripts ne changent pas. Il ajoute un contexte Docker nommé kiri et peut cohabiter avec Docker Desktop. En revanche, les fonctionnalités de dockerd qu'il n'implémente pas répondent par une erreur explicite.

**Le « 8× plus rapide » correspond à quoi exactement ?**

Le chiffre vient du temps de `docker run --rm alpine true` mesuré par Kiri : 22 ms contre 178 ms pour Docker Desktop, sur une même machine avec chaque moteur limité à 2 CPU et 8 Go. La mesure la plus directe, à travers l'API Docker, donne 2,55 ms contre 213 ms. La plus grande partie des 22 ms est en réalité le démarrage du CLI docker lui-même.

**Kiri peut-il remplacer Docker Desktop en production ?**

Non, Kiri est un runtime de développement local, encore en bêta (0.2.2). Il ne gère pas les conteneurs Windows, ne remplace pas l'écosystème complet de Docker (Extensions, outils, administration à grande échelle) et vise un usage sur poste de travail, pas un hôte de production. Sur un serveur Linux, tu garderas Docker ou un runtime équivalent.
