Docker changed how developers build, package, and deploy applications.

But container development continues to evolve. Developers are now exploring alternative runtimes that promise a different local development experience.

One interesting project is Kiri.

What makes it different from Docker Desktop? Can it work with familiar Docker commands? Is it worth trying for AWS developers?

Let's explore the differences.

Why Are Developers Looking Beyond Docker Desktop?

Imagine running a local development environment with:

  • A frontend application
  • A backend API
  • PostgreSQL
  • Redis
  • Multiple supporting services

Everything works, but your laptop starts consuming more resources than expected.

You begin wondering whether your local container environment could be faster or lighter.

This is where alternative container runtimes become interesting.

Before comparing them, let's understand one important distinction:

Docker is an ecosystem. Docker Desktop is one way to run that ecosystem locally.

Docker provides tools and workflows for building, distributing, and running containers. Docker Desktop packages a local development experience around those capabilities.

Kiri offers another approach to the local runtime experience.

What Is Kiri?

Kiri is an emerging Docker-compatible container runtime.

It aims to let developers continue using familiar tools and workflows, including Docker-compatible CLI commands, Dockerfiles, container images, and Compose.

Instead of simply being another Docker Desktop interface, Kiri uses its own runtime architecture.

Its documentation describes a Kiri daemon and guest agent architecture, with communication between components.

The goal is to provide a different way to run containers locally without requiring developers to completely change their existing workflows.

Kiri is still an evolving project, so compatibility and feature maturity should be verified before adopting it for a team's daily development environment.

Understanding the Architecture

With Docker Desktop on macOS, the typical workflow involves the Docker CLI communicating with the Docker Engine API. Docker Desktop provides a Linux environment for running Linux containers, with components such as Docker Engine, containerd, and the lower-level container runtime.

Kiri takes a different architectural approach.

Its workflow uses the Kiri daemon and guest agent, with communication between the components through its own architecture.

The important question is not simply how many components each runtime uses.

What matters is how the architecture affects startup time, memory consumption, networking, storage, compatibility, and the developer experience.

A different architecture does not automatically mean better performance for every application.

Performance: What Do the Benchmarks Say?

Kiri publishes benchmark results showing lower latency for selected operations compared with Docker Desktop.

Its documentation reports figures including:

Container lifecycle API operation

  • Kiri: approximately 2.55 ms
  • Docker Desktop: approximately 213 ms

CLI operation

  • Kiri: approximately 14 ms
  • Docker Desktop: approximately 243 ms

These figures are interesting, but context matters.

They are project-reported results from a particular test environment, including an Apple Silicon Mac. They are not independent benchmarks or universal performance guarantees.

Actual performance depends on hardware, operating system, container images, storage, networking, and workload.

For a meaningful comparison, test both runtimes using the same application and configuration.

Measure container startup time, idle memory usage, CPU consumption, image build duration, volume performance, and Docker Compose startup time.

The best benchmark is the workload your team actually runs.

Docker Compatibility: Do You Need to Change Your Workflow?

One of Kiri's interesting aspects is its focus on Docker-compatible workflows.

Developers can experiment with another runtime while continuing to use familiar container tools.

For example, Docker contexts can be inspected with:

docker context ls 

Switch to a Kiri context:

docker context use kiri 

Switch back to Docker Desktop:

docker context use desktop-linux 

The exact context names depend on your installation and configuration.

This makes side-by-side testing easier.

However, Docker compatibility does not guarantee that every Docker Desktop feature is available. Kubernetes integration, extensions, enterprise administration, networking, volumes, and specialized workflows should be checked individually.

What Does This Mean for AWS Developers?

This is where the comparison becomes especially relevant.

Many AWS developers use Docker locally before deploying applications to cloud infrastructure.

A common workflow looks like this:

Application code → Dockerfile → Container image → Amazon ECR → Amazon ECS or Amazon EKS

The distinction is important:

Docker and Kiri are local container runtime choices. AWS container services provide the infrastructure for running applications in the cloud.

Kiri does not replace Amazon ECS, Amazon EKS, Amazon ECR, or AWS Fargate.

You can still use a compatible Docker CLI workflow to build an image and push it to Amazon ECR.

For example:

Build your image:

docker build -t my-app . 

Tag it for Amazon ECR:

docker tag my-app:latest \ ACCOUNT_ID.dkr.ecr.REGION.amazonaws.com/my-app:latest 

Authenticate:

aws ecr get-login-password --region REGION | \ docker login \ --username AWS \ --password-stdin \ ACCOUNT_ID.dkr.ecr.REGION.amazonaws.com 

Push the image:

docker push \ ACCOUNT_ID.dkr.ecr.REGION.amazonaws.com/my-app:latest 

This is the general workflow when using a compatible Docker CLI and image-building setup.

The resulting image must still be compatible with the target AWS runtime environment.

When Should You Choose Docker?

Docker remains a strong default when you need ecosystem maturity, broad compatibility, established documentation, and a familiar development experience.

It is particularly suitable when your team depends on Docker Desktop features, enterprise management, extensions, or existing integrations.

If your current environment works reliably, there may be no reason to change it.

When Should You Try Kiri?

Kiri is worth exploring if you want to experiment with an alternative local container runtime.

It may be interesting for developers who want to evaluate different runtime architectures, investigate resource usage, or benchmark container lifecycle operations.

But don't migrate your entire development workflow based on a benchmark result.

Test it against your actual project first.

A Practical Experiment: Test Both Runtimes

Here is an experiment I would recommend.

Create one application containing a frontend, backend API, PostgreSQL database, and Redis.

Use the same Dockerfiles, Compose configuration, container images, and application data for both runtimes.

Then compare:

  1. Cold and warm container startup times.
  2. Memory usage while containers are idle.
  3. CPU consumption under load.
  4. Image build duration.
  5. Database query performance.
  6. Container-to-container networking.
  7. Volume read and write performance.
  8. Docker Compose startup behavior.

For an AWS-focused test, build the application image locally, push it to Amazon ECR, and deploy it to a test ECS or EKS environment.

This helps identify whether your local runtime choice introduces any unexpected issues in your cloud delivery workflow.

Final Thoughts

Docker and Kiri should not be viewed as identical products competing feature for feature.

Docker represents a mature container ecosystem with broad adoption.

Kiri is an emerging alternative runtime that brings an interesting architecture and performance claims worth investigating.

For AWS developers, the important lesson is to separate local container tooling from cloud deployment infrastructure.

You can experiment with different local runtimes while continuing to use Amazon ECR, ECS, EKS, and Fargate for cloud workloads.

Don't choose a tool just because it is newer. Choose it because it improves your development workflow.

Let's Discuss

Would you continue using Docker Desktop, or would you try Kiri as an alternative local container runtime?

Have you tested Kiri with a real Docker Compose project? Share your experience in the comments.

References