Lima vs Colima vs Podman Desktop — Self-Hosted Local Container Runtimes Guide 2026

Running containers locally on macOS or Linux requires more than just installing Docker. Apple’s move to Apple Silicon, combined with the shift away from Docker Desktop’s paid licensing for enterprises, has created demand for open-source local container runtimes. This guide compares three leading options: Lima, Colima, and Podman Desktop — examining how each handles local container orchestration, performance, and developer experience.

What Are Local Container Runtimes?

Local container runtimes provide the infrastructure needed to run containerized applications on developer machines. On Linux, Docker and Podman run natively using the kernel’s cgroups and namespaces. On macOS and Windows, however, containers require a lightweight Linux virtual machine (VM) to host the container runtime.

Tools like Lima, Colima, and Podman Desktop automate the creation and management of these Linux VMs, giving developers a seamless docker or podman CLI experience without manual VM setup. They bridge the gap between native Linux containerization and macOS/Windows development workflows.

Lima — Linux Virtual Machines Made Simple

Lima (Linux Machines) creates and manages Linux virtual machines with automatic file sharing and port forwarding. Originally designed to run containerd on macOS, Lima has evolved into a general-purpose VM management tool that supports Docker, Podman, nerdctl, and Kubernetes out of the box.

Key characteristics:

• ⭐ 20,921 GitHub stars | Language: Go | Last updated: April 2026
• Architecture-agnostic: supports both x86_64 and ARM64 (Apple Silicon)
• Uses QEMU for virtualization with optional VZ (Virtualization.framework) acceleration on macOS 13+
• Automatic home directory sharing between host and VM
• Declarative YAML configuration for reproducible VM templates
• Supports nested virtualization for running KVM-based workloads
• Rootless mode available for improved security

Lima operates at a lower level than Colima — it manages the full Linux VM lifecycle, not just the container runtime. This makes it more flexible but also more complex to configure.

Lima Installation and Setup

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Install via Homebrew (macOS)
brew install lima

# Start a default Ubuntu VM with Docker
limactl start --name=default

# SSH into the VM
limactl shell default

# Use Docker from the host (via socket forwarding)
docker ps

Lima YAML Configuration

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# default.yaml
vmType: "vz"              # Use macOS Virtualization.framework
arch: "aarch64"           # ARM64 for Apple Silicon
memory: "4GiB"
cpus: 4
disk: "100GiB"

mounts:
  - location: "~"
    writable: true
  - location: "/tmp/lima"
    writable: true

provision:
  - mode: system
    script: |
      #!/bin/bash
      apt-get update
      apt-get install -y docker.io
      systemctl enable --now docker

containerd:
  system: false
  user: false

networks:
  - lima: user-v2

Lima’s YAML configuration is powerful — you can define multiple VMs, customize network settings, provision scripts, and mount points. This makes it suitable for complex development environments that go beyond simple container hosting.

Colima — Container Runtimes with Minimal Setup

Colima (Containers on Lima) builds directly on top of Lima, abstracting away the VM management layer to provide a one-command container runtime experience. Where Lima gives you a Linux VM, Colima gives you Docker or containerd — the VM is an implementation detail.

Key characteristics:

• ⭐ 28,576 GitHub stars | Language: Go | Last updated: April 2026
• Single command setup: colima start
• Built on Lima — inherits Lima’s VM capabilities but hides the complexity
• Supports Docker, containerd, and Podman runtimes
• Automatic architecture detection (Intel vs Apple Silicon)
• Built-in Kubernetes via k3s
• Runtime switching without recreating the VM
• Volume mount optimization for macOS file I/O performance

Colima’s philosophy is “it just works.” You don’t need to understand VMs, QEMU, or Linux internals — you just want docker run to work.

Colima Installation and Setup

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# Install via Homebrew
brew install colima

# Start with Docker runtime (default)
colima start

# Start with specific resources
colima start --cpu 4 --memory 8 --disk 100

# Start with containerd instead of Docker
colima start --runtime containerd

# Start with built-in Kubernetes
colima start --kubernetes

# Check status
colima status

# SSH into the VM (when you need to)
colima ssh

Colima Profile Configuration

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# ~/.colima/default/colima.yaml
runtime: docker
arch: host
cpu: 4
memory: 8
disk: 100
kubernetes:
  enabled: true
  version: v1.30.0+k3s1
vmType: vz
mountType: virtiofs
mounts:
  - location: "~"
    writable: true
  - location: /tmp/colima
    writable: true
dns: []
env:
  DOCKER_HOST: unix:///Users/$USER/.colima/default/docker.sock

Colima profiles let you define multiple configurations — one for lightweight testing, another for heavy development — and switch between them with colima start <profile-name>.

Podman Desktop — Visual Container and Kubernetes Management

Podman Desktop is a graphical desktop application that provides a unified interface for managing containers, pods, and Kubernetes clusters. Unlike Lima and Colima which are CLI-first tools, Podman Desktop offers a full GUI alongside CLI integration.

Key characteristics:

• ⭐ 7,577 GitHub stars | Language: TypeScript | Last updated: April 2026
• Cross-platform: macOS, Windows, and Linux
• Manages Podman, Docker, and Lima engines from a single interface
• Built-in Kubernetes management (kind, minikube, Podman machine)
• Visual container logs, exec terminals, and image management
• Extension ecosystem for CI/CD, Compose, and third-party tool integrations
• No VM management overhead on Linux — uses native Podman/Docker
• Container image building with Buildah integration

Podman Desktop is fundamentally different from Lima and Colima. It’s not a VM manager — it’s a container management GUI that can connect to various backends, including Lima and Colima VMs.

Podman Desktop Installation and Setup

1
2
3
4
5
6
7
8
9

# Install via Homebrew (macOS)
brew install --cask podman-desktop

# Initialize Podman machine (creates a Linux VM)
podman machine init
podman machine start

# Podman Desktop will auto-detect the running machine
# Open the GUI to manage containers, images, pods, and volumes

Podman Compose Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# docker-compose.yml compatible with Podman
version: "3"
services:
  web:
    image: nginx:alpine
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html:Z
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    restart: unless-stopped

volumes:
  redis-data:

Run with podman-compose up -d or use the Podman Desktop Compose panel for visual management.

Comparison Table

When to Use Each Tool

Choose Lima when:

• You need fine-grained control over the Linux VM (CPU, memory, disk, network)
• You want to run non-container workloads inside the VM (databases, services)
• You need nested virtualization or KVM support
• You’re comfortable with YAML configuration and CLI management
• You want to create multiple specialized VMs for different projects

Choose Colima when:

• You just want Docker to work on macOS with minimal setup
• You don’t want to manage VMs manually
• You need quick runtime switching (Docker ↔ containerd ↔ Podman)
• You want built-in Kubernetes with k3s
• You prefer a simple CLI over complex configuration

Choose Podman Desktop when:

• You want a visual interface for container management
• You work with both containers and Kubernetes regularly
• You’re on Windows and need cross-platform consistency
• You prefer GUI-based log viewing, exec terminals, and image management
• You want to manage multiple container engines from one place
• You need extension support for CI/CD, Compose previews, or third-party integrations

Why Self-Host Your Local Container Runtime?

Using open-source local container runtimes instead of Docker Desktop offers several advantages for developers and teams:

Cost savings: Docker Desktop requires a paid subscription for companies with more than 250 employees or $10M in revenue. Lima, Colima, and Podman Desktop are completely free and open-source under Apache 2.0 and MIT licenses, eliminating licensing costs entirely.

Transparency and control: Open-source tools let you inspect exactly what’s running on your machine. You can audit the VM configuration, network setup, and volume mounts — critical for security-conscious teams that need to understand their development environment’s attack surface.

Flexibility: Unlike Docker Desktop’s fixed configuration, these tools let you customize CPU, memory, disk, and network settings per-project. You can run multiple isolated environments simultaneously — one VM for a microservices cluster, another for database testing.

No vendor lock-in: Lima and Colima support multiple container runtimes (Docker, containerd, Podman). Podman Desktop connects to multiple engines. If one tool changes its licensing or direction, you can pivot without rebuilding your development workflow.

For teams managing multiple containerized services locally, see our container runtime comparison and container virtualization guide for deeper infrastructure context. If you’re managing container images, our container registry guide covers self-hosted registries.

FAQ

Is Colima just a wrapper around Lima?

Yes, Colima is built on top of Lima. It uses Lima’s VM management under the hood but adds a simplified CLI specifically for container runtimes. Colima handles the Lima YAML configuration automatically, so you don’t need to manage VM templates manually. If Colima’s defaults work for you, use it. If you need custom VM setups, use Lima directly.

Can I use Podman Desktop with Docker?

Yes. Podman Desktop can connect to Docker as a backend engine. It detects running Docker installations (including Docker Desktop, Colima’s Docker runtime, or Lima’s Docker) and manages them through its GUI. You can also manage Podman and Docker engines simultaneously, comparing container states across both runtimes.

Does Lima work on Apple Silicon Macs?

Yes. Lima fully supports ARM64 architecture on Apple Silicon (M1/M2/M3) Macs. It uses QEMU with Apple’s Virtualization.framework (VZ) for near-native performance. The VM runs a native ARM64 Linux distribution, so container images must have ARM64 variants (most popular images do).

Can I run Kubernetes locally with these tools?

All three support Kubernetes. Colima has built-in k3s support via colima start --kubernetes. Podman Desktop supports kind, minikube, and Podman machine-based Kubernetes clusters. Lima can run any Kubernetes distribution manually — you’d install k3s, kind, or k3d inside the Lima VM yourself.

How do these tools compare to Docker Desktop?

Docker Desktop bundles a Linux VM, Docker Engine, Kubernetes, a GUI, and Docker Compose into one package. Lima provides the VM layer, Colima adds the Docker runtime, and Podman Desktop provides the GUI — together they replicate Docker Desktop’s functionality with open-source alternatives. Podman Desktop alone comes closest to Docker Desktop’s feature set with its multi-engine GUI and Kubernetes support.

Which tool has the best file I/O performance on macOS?

Colima supports virtiofs for volume mounts, which provides significantly better performance than the older 9p protocol. Lima also supports virtiofs when using the VZ virtualization type. Podman Desktop uses the underlying Podman machine’s mount type. For database workloads with heavy disk I/O, consider using named volumes instead of bind mounts regardless of which tool you choose.