Colima: The Lightweight Docker Desktop Alternative

If you’re a macOS developer who’s grown frustrated with Docker Desktop’s resource consumption, licensing restrictions, or forced update cycles, you’re not alone. The official Docker Desktop application has become increasingly controversial since Docker Inc. changed its licensing terms in August 2021, requiring commercial licenses for larger organizations. Beyond licensing concerns, many developers report persistent issues with high CPU usage, memory bloat, slow startup times, and battery drain that make local development feel like a constant battle against their own tools.

Enter Colima—an open-source, lightweight alternative that provides container runtimes on macOS and Linux with minimal setup and zero licensing fees. With over 24,000 GitHub stars and thousands of monthly Homebrew downloads, Colima has quietly become one of the most popular Docker Desktop replacements in the developer community. It’s fast, efficient, free, and surprisingly powerful despite its minimalist approach.

In this comprehensive guide, we’ll explore everything you need to know about Colima: what it is, how to install and use it, practical examples with Docker Compose, and a detailed comparison with both Docker Desktop and OrbStack (the other popular macOS container tool). Whether you’re looking to escape Docker Desktop’s licensing costs or simply want better performance, this guide will help you decide if Colima is the right choice for your workflow.

What is Colima?

Colima (the name combines “Containers on Lima“) is an open-source project that provides container runtimes on macOS and Linux with minimal setup. Under the hood, Colima leverages Lima (Linux on Mac), which creates lightweight Linux virtual machines using QEMU or Apple’s Virtualization Framework (VZ) to provide the Linux environment that Docker requires.

The Origin Story

Colima started as a personal Bash script created by developer Abiola Ibrahim for running Docker and Kubernetes containers without needing Docker Desktop. Initially called “LimaKube” (and renamed to Colima just two days later), it was simply meant to be a personal toolkit. However, after positive community feedback and growing adoption, the project was rewritten in Go to add more capabilities and has since evolved into a mature, production-ready tool.

The project’s popularity exploded when Docker Desktop’s licensing changes took effect. Ibrahim shared a memorable moment when a friend posted in a WhatsApp group: “We’re leaving Docker Desktop at my office to use your work Colima”. Another friend later wrote: “We’ve been told to switch to Colima before end of month”. This organic adoption happened despite Colima having minimal documentation beyond the official README.​

Core Philosophy: Simplicity and Efficiency

Colima’s design philosophy centers on minimal setup with sensible defaults. Unlike Docker Desktop’s feature-rich (and resource-heavy) GUI application, Colima is a command-line tool that focuses on doing one thing exceptionally well: running containers efficiently. This stripped-down approach results in dramatically better performance and resource utilization.

Key Features

Colima offers a surprisingly comprehensive feature set for such a minimal tool:​

Container Runtime Support:

• Docker (default) with full Docker CLI compatibility
• Containerd for lower-level container management
• Incus for LXC-based system containers
• “None” runtime to use Colima purely as a headless VM manager

Platform Support:

• Intel and Apple Silicon macOS
• Linux (though native Docker Engine is typically preferred on Linux)
• Architecture emulation: Run x86_64 containers on ARM Macs and vice versa

Advanced Capabilities:

• Automatic port forwarding from containers to localhost
• Volume mounts with configurable drivers (virtiofs, 9p, sshfs)
• Multiple instances through profile management
• Kubernetes support via built-in K3s server
• CPU architecture emulation (aarch64, x86_64)
• Dynamic configuration through YAML files or command-line flags
• Bridged networking (introduced in v0.8.0)​
• Runtime updates without upgrading Colima itself (v0.7.6+)​

How Colima Compares in Performance

Independent benchmarking has consistently shown Colima outperforming Docker Desktop, especially for I/O operations and CPU-intensive workloads. Testing by developer SchwiftyCold on an M1 Mac revealed:

Write Performance (1024 MB file):

• Docker Desktop: 194-262 seconds
• Colima (QEMU): 293-301 seconds
• Colima (VZ + Rosetta): 198-200 seconds Comparable to Docker Desktop

Read Performance (1,000,000 random reads):

• Docker Desktop: 80-81 seconds (12 reads/ms)
• Colima (QEMU): 729 reads/ms (60x faster!)
• Colima (VZ): 705 reads/ms (58x faster!)

Print Performance:

• Docker Desktop: 4074 chars/ms (best)
• Colima (VZ): 2984 chars/ms
• Colima (QEMU): Lower than VZ

The results show that Colima with VZ + Rosetta offers the best balanced performance on Apple Silicon, delivering Docker Desktop-level write performance while crushing it on read operations.

Another benchmark by Kumojin comparing file operations showed Colima consistently outperforming Docker Desktop across create, read, copy, and delete operations—often by 2-3x margins.

Installing Colima: Step-by-Step Guide

Getting Colima up and running is refreshingly straightforward. The entire installation process typically takes less than 5 minutes.

Prerequisites

Before installing Colima, ensure you have:

• macOS 13.0 (Ventura) or newer (recommended for VZ support)
• Homebrew installed (visit brew.sh if you don’t have it)
• Basic command-line familiarity
• (Optional) Docker Desktop uninstalled if you want a clean migration

Step 1: Uninstall Docker Desktop (Optional but Recommended)

If you’re migrating from Docker Desktop, it’s recommended to uninstall it first for a clean setup:

Warning: This will delete all your local Docker images, containers, and volumes. Export any important data first!

# Option 1: Uninstall via GUI
# Right-click Docker icon in menu bar → Troubleshooting → Uninstall

# Option 2: Remove Docker Desktop manually
sudo rm -rf /Applications/Docker.app
rm -rf ~/Library/Group\ Containers/group.com.docker
rm -rf ~/Library/Containers/com.docker.docker
rm -rf ~/.docker

Step 2: Install Colima and Docker CLI Tools

Install Colima along with the Docker command-line tools using Homebrew:

# Install Colima, Docker CLI, and related tools
brew install colima docker docker-compose docker-buildx docker-credential-helper

Package breakdown:

• colima: The lightweight VM for running containers
• docker: Docker CLI for interacting with the Docker daemon
• docker-compose: Manage multi-container applications
• docker-buildx: Enhanced build capabilities with BuildKit
• docker-credential-helper: Secure credential storage

Installation time: Typically 2-5 minutes depending on your internet connection.

Step 3: Verify Installation

Check that Colima and Docker are installed correctly:

# Check Colima version
colima version
# Output: colima version 0.8.0

# Check Docker CLI (won't work yet until Colima starts)
docker --version
# Output: Docker version 27.3.1, build ce12735

Step 4: Link the Docker Socket (Important for System-Wide Access)

For seamless integration with IDEs like VS Code, create a symbolic link from Colima’s Docker socket to the standard location:

# Create symbolic link (may require sudo depending on permissions)
sudo ln -sf ~/.colima/default/docker.sock /var/run/docker.sock

This step ensures that tools expecting Docker at /var/run/docker.sock will work correctly with Colima.

Step 5: Start Colima with Optimized Configuration

Now start Colima with a configuration optimized for your Mac:

For Apple Silicon (M1/M2/M3/M4) Macs:

# Start with VZ (Apple's Virtualization Framework) for best performance
colima start \
  --cpu 4 \
  --memory 8 \
  --disk 60 \
  --vm-type vz \
  --mount-type virtiofs \
  --runtime docker

For Intel Macs:

# Start with QEMU (default)
colima start \
  --cpu 4 \
  --memory 8 \
  --disk 60 \
  --vm-type qemu \
  --mount-type sshfs \
  --runtime docker

Configuration options explained:

• --cpu 4: Allocates 4 virtual CPUs (adjust based on your Mac’s specs)
• --memory 8: Allocates 8 GB RAM (use 4-6 GB for 16GB Macs, 8-12 GB for 32GB+ Macs)
• --disk 60: Allocates 60 GB disk space (default, can increase if needed)
• --vm-type vz: Uses Apple’s native virtualization (macOS 13+, faster on M-series)
• --mount-type virtiofs: Fastest file sharing method for VZ VMs
• --runtime docker: Specifies Docker as the container runtime

Startup output:

INFO[0000] starting colima
INFO[0000] runtime: docker
INFO[0000] preparing network ...                         context=vm
INFO[0000] starting ...                                  context=vm
INFO[0022] provisioning ...                              context=docker
INFO[0022] starting ...                                  context=docker
INFO[0027] done

Startup time: Typically 20-30 seconds on first launch.

Step 6: Verify Docker is Working

Test that Docker is functioning correctly through Colima:

# Check Colima status
colima status
# Output: 
# INFO[0000] colima is running using macOS Virtualization.Framework
# INFO[0000] arch: aarch64
# INFO[0000] runtime: docker
# INFO[0000] socket: unix:///Users/yourusername/.colima/default/docker.sock

# Run a test container
docker run --rm hello-world

# Check Docker context
docker context show
# Output: colima

# List running containers
docker ps

If you see “Hello from Docker!” you’re all set! Colima is now running and ready for development.

Alternative: Configuration File Method

For more persistent configuration, you can edit Colima’s YAML config file:

# Open config editor (will start Colima after saving)
colima start --edit

# Or create a template to review first
colima template

This opens your default editor with a comprehensive configuration file where you can set CPU, memory, disk, networking, volume mounts, environment variables, and advanced options.

Getting Started with Colima: Practical Usage Examples

Now that Colima is installed, let’s explore common workflows and practical examples.

Example 1: Basic Docker Commands

All standard Docker commands work seamlessly with Colima:

# Pull an image
docker pull nginx:alpine

# Run a container
docker run -d -p 8080:80 --name my-nginx nginx:alpine

# Access in browser
open http://localhost:8080

# View container logs
docker logs my-nginx

# Stop and remove
docker stop my-nginx
docker rm my-nginx

Example 2: Building and Running a Custom Application

Let’s create a simple Node.js application:

# Create project directory
mkdir my-node-app && cd my-node-app

# Create app.js
cat > app.js << 'EOF'
const http = require('http');
const hostname = '0.0.0.0';
const port = 3000;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'application/json');
  res.end(JSON.stringify({
    message: 'Hello from Colima!',
    timestamp: new Date().toISOString(),
    environment: process.env.NODE_ENV || 'development'
  }));
});

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});
EOF

# Create Dockerfile
cat > Dockerfile << 'EOF'
FROM node:20-alpine
WORKDIR /app
COPY app.js .
EXPOSE 3000
CMD ["node", "app.js"]
EOF

# Build the image
docker build -t my-node-app:latest .

# Run the container
docker run -d -p 3000:3000 --name node-app my-node-app:latest

# Test the application
curl http://localhost:3000
# Output: {"message":"Hello from Colima!","timestamp":"2025-10-22T...","environment":"development"}

Example 3: Docker Compose Multi-Container Application

Docker Compose works perfectly with Colima. Let’s create a full-stack application:

Create docker-compose.yml:

version: '3.8'

services:
  web:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgresql://postgres:secretpassword@db:5432/myapp
      - REDIS_URL=redis://cache:6379
    depends_on:
      - db
      - cache
    restart: unless-stopped

  db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=secretpassword
      - POSTGRES_DB=myapp
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"
    restart: unless-stopped

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

  adminer:
    image: adminer:latest
    ports:
      - "8080:8080"
    depends_on:
      - db
    restart: unless-stopped

volumes:
  postgres_data:
  redis_data:

Launch the full stack:

# Start all services
docker compose up -d

# Check status
docker compose ps

# View logs for all services
docker compose logs -f

# View logs for specific service
docker compose logs -f web

# Access Adminer database GUI
open http://localhost:8080

# Stop all services
docker compose stop

# Remove everything (including volumes)
docker compose down -v

Example 4: Running x86 Containers on Apple Silicon

One of Colima’s most powerful features is architecture emulation:

# Create an x86_64 profile for Intel-specific containers
colima start -p intel --arch x86_64 --cpu 2 --memory 4

# Switch Docker context to the Intel profile
docker context use colima-intel

# Run an x86 container
docker run --rm --platform linux/amd64 alpine uname -m
# Output: x86_64

# Switch back to default ARM profile
docker context use colima

# Run ARM container
docker run --rm --platform linux/arm64 alpine uname -m
# Output: aarch64

This is invaluable when working with legacy images that don’t have ARM versions.

Example 5: Managing Multiple Colima Profiles

Colima supports multiple isolated instances through profiles:

# Create development profile (lightweight)
colima start -p dev --cpu 2 --memory 4 --disk 30

# Create production-testing profile (powerful)
colima start -p prod-test --cpu 8 --memory 16 --disk 100

# Create Intel emulation profile
colima start -p intel --arch x86_64 --cpu 4 --memory 8

# List all profiles
colima list
# Output:
# PROFILE      STATUS    ARCH      CPUS    MEMORY    DISK    RUNTIME
# default      Running   aarch64   4       8GiB      60GiB   docker
# dev          Stopped   aarch64   2       4GiB      30GiB   docker
# prod-test    Running   aarch64   8       16GiB     100GiB  docker
# intel        Stopped   x86_64    4       8GiB      60GiB   docker

# Switch between profiles
colima stop
colima start -p dev

# Stop specific profile
colima stop -p prod-test

# Delete profile (warning: removes all data)
colima delete -p dev

Example 6: Kubernetes with Colima

Colima includes K3s for Kubernetes development:

# Start Colima with Kubernetes enabled
colima start --kubernetes

# Check Kubernetes is running
kubectl cluster-info

# Deploy a sample application
kubectl create deployment nginx --image=nginx:alpine
kubectl expose deployment nginx --port=80 --type=NodePort

# Get the NodePort
kubectl get svc nginx

# Access the application
# Note: You'll need to use the VM IP and NodePort

Common Colima Commands

Managing Colima:

colima start                    # Start default profile
colima stop                     # Stop default profile
colima restart                  # Restart default profile
colima delete                   # Delete profile and all data
colima status                   # Show current status
colima list                     # List all profiles
colima version                  # Show Colima version

Configuration:

colima start --edit             # Edit config before starting
colima template                 # Show default config template
colima ssh                      # SSH into the VM
colima nerdctl install          # Install nerdctl (for containerd)

Docker context management:

docker context ls               # List available contexts
docker context use colima       # Switch to Colima
docker context use default      # Switch to default

Comparison: Colima vs. Docker Desktop vs. OrbStack

Let’s compare these three popular container solutions across key dimensions:

Feature Comparison Table

Performance Verdict

Winner: OrbStack for raw performance, with Colima close behind for I/O operations.

• OrbStack leads in startup speed (2 seconds vs 20-30 seconds), idle efficiency (<0.1% CPU), and dynamic memory management
• Colima crushes Docker Desktop in read operations (60x faster) and matches or beats it in write performance
• Docker Desktop trails significantly in efficiency but has improved with recent optimizations

Cost and Licensing Verdict

Winner: Colima for maximum flexibility and freedom.

• Colima: Completely free for all use cases, MIT licensed, no restrictions​
• OrbStack: Free for personal use, $8/user/month for commercial​
• Docker Desktop: Free for small businesses only, requires $5-21/user/month for larger organizations

For a 50-person team:

• Colima: $0
• OrbStack: $400/month ($4,800/year)
• Docker Desktop Team: $450/month ($5,400/year)

Ease of Use Verdict

Winner: OrbStack for beginners, Docker Desktop for familiarity.

• OrbStack offers the smoothest experience with a native macOS app, automatic domains, and minimal configurationyoutube​​
• Docker Desktop provides a familiar GUI with extensive documentation and tutorials
• Colima requires comfort with the command line but offers maximum control for power users​

Feature Completeness Verdict

Winner: Docker Desktop for enterprise features, OrbStack for developer productivity.

• Docker Desktop includes extensions marketplace, Docker Scout security scanning, and enterprise management features
• OrbStack provides unique productivity features like Linux VMs, automatic HTTPS, and volume file access
• Colima focuses on core container functionality with excellent architecture emulation support​

Who Should Choose Which?

Choose Colima if you:

• Want a 100% free, open-source solution with no licensing concerns
• Are comfortable with CLI-focused workflows
• Need architecture emulation (x86 on ARM, ARM on x86)
• Prioritize data sovereignty and avoid proprietary tools
• Want multiple isolated container environments via profiles
• Need containerd or alternative runtimes beyond Docker
• Have stable workflows that don’t require frequent GUI interactions

Choose Docker Desktop if you:

• Work in cross-platform teams (Windows + macOS + Linux)
• Need Docker extensions for cloud integrations or specialized tools
• Require enterprise features (SSO, centralized management, compliance)
• Want Docker Scout security scanning built-in
• Prefer GUI-based management for containers and images
• Have established Docker Desktop workflows and don’t want to change
• Work in regulated industries requiring vendor support

Choose OrbStack if you:

• Develop exclusively on macOS and want the best native experience
• Prioritize performance and battery life above all
• Want full Linux VMs alongside containers
• Value automatic domains and HTTPS for local development
• Need quick startup times and near-zero idle resource usage
• Prefer native macOS apps with menu bar integration
• Don’t mind paying $8/month for commercial use

Troubleshooting Common Colima Issues

Despite Colima’s simplicity, you may encounter some common issues:

Issue 1: “Waiting for the essential requirement 1 of 5: ssh”

Solution:

# Delete and restart with explicit architecture
colima delete
colima start --arch x86_64  # or aarch64 for M-series

This usually resolves SSH connection issues during startup.

Issue 2: Docker Command Not Found After Colima Start

Solution:

# Check Docker context
docker context ls

# Switch to Colima context
docker context use colima

# Or set DOCKER_HOST manually
export DOCKER_HOST="unix://$HOME/.colima/default/docker.sock"

Colima creates its own Docker context which should be automatically selected.

Issue 3: Colima Randomly Freezing or Becoming Unresponsive

This is a known issue that some users experience:

Workarounds:

# Update to latest Colima version (many stability fixes)
brew upgrade colima

# Restart Colima
colima restart

# If that doesn't work, delete and recreate
colima delete
colima start --vm-type vz  # VZ tends to be more stable on M-series

NOTE:
If using Lima 1.0.0+, ensure you're on Colima v0.8.0+ which fixes critical stability issues.

Issue 4: Poor File I/O Performance

Solution:

# For Apple Silicon Macs, use VZ with virtiofs
colima start --vm-type vz --mount-type virtiofs

# For Intel Macs, try 9p instead of sshfs
colima start --vm-type qemu --mount-type 9p

VirtioFS is the fastest mount type but only works with VZ on Apple Silicon.

Issue 5: VS Code Dev Containers Not Working

Solution:

# Ensure symbolic link exists
sudo ln -sf ~/.colima/default/docker.sock /var/run/docker.sock

# Set Docker context
docker context use colima

# Restart VS Code

VS Code Dev Containers extension needs the socket at the standard location.

Migrating from Docker Desktop to Colima

If you’re ready to make the switch, here’s a migration checklist:

Pre-Migration

1. Export important data:

# Export Docker images you want to keep
docker save -o my-images.tar image1:tag image2:tag

# Backup volumes if needed
docker run --rm -v volume_name:/data -v $(pwd):/backup alpine tar czf /backup/volume_name.tar.gz /data

2. Document your configuration:
   • Note CPU, memory, and disk allocations in Docker Desktop
   • Document any custom daemon.json settings
   • List any Docker Desktop extensions you use

Migration Steps

1. Uninstall Docker Desktop (see Step 1 in Installation section)
2. Install Colima and tools (see Steps 2-3)
3. Configure Colima to match your previous resource allocation
4. Import images if needed:

docker load -i my-images.tar

5. Test your workflows with docker and docker compose commands
6. Update IDE integrations (VS Code, IntelliJ, etc.)

Post-Migration

• Monitor resource usage with colima status and Activity Monitor
• Adjust CPU/memory if needed: colima stop && colima start --cpu X --memory Y
• Report any issues to the Colima GitHub repository

Conclusion: The Right Tool for Your Workflow

The container runtime landscape on macOS has evolved dramatically since Docker Desktop’s licensing changes. While Docker Desktop remains a solid choice for certain use cases, Colima has emerged as a compelling free, open-source alternative that delivers excellent performance with a minimalist approach.

Colima shines in several key areas:

• Zero cost for all use cases, personal and commercial
• Excellent I/O performance, especially for read operations (60x faster than Docker Desktop)
• Architecture emulation for running x86 containers on ARM Macs
• Multiple profiles for isolated development environments
• Open-source transparency and active community development

However, Colima has trade-offs:

• CLI-only interface (no GUI for visual learners)
• macOS/Linux only (not suitable for cross-platform teams with Windows users)
• Steeper learning curve for developers accustomed to GUI tools
• Occasional stability issues (though much improved in recent versions)

For solo developers, small teams, open-source enthusiasts, and anyone seeking maximum performance without licensing costs, Colima is an excellent choice. For enterprise teams needing GUI tools, cross-platform consistency, or Docker Inc.’s ecosystem integrations, Docker Desktop remains the safer bet. And for macOS developers wanting the absolute best native experience with all the bells and whistles, OrbStack represents the premium option.

The beauty of the current ecosystem is that you have genuine choices. All three tools use the standard Docker API, so switching between them is relatively painless if your needs change.

Take Action: Try Colima Today

Ready to experience container development without the overhead? Getting started takes less than 10 minutes:

# Install Colima and Docker tools
brew install colima docker docker-compose

# Start with optimized settings for M-series Macs
colima start --cpu 4 --memory 8 --vm-type vz --mount-type virtiofs

# Or for Intel Macs
colima start --cpu 4 --memory 8 --vm-type qemu --mount-type 9p

# Test it works
docker run --rm hello-world

If Colima doesn’t meet your needs, you can easily switch back to Docker Desktop or try OrbStack—all three use the same Docker commands and configuration files.

Have you tried Colima? Share your experience in the comments below. How does it compare to Docker Desktop in your workflow? Have you encountered any issues or discovered any hidden features? Your feedback helps the community make better tool choices.