Lima vs Multipass

Your Mac Is Lying to You

Docker Desktop works fine — right up until you check your Activity Monitor and notice it’s eating 4 GB of RAM on idle and spinning your fans like a leaf blower. Then you check the pricing page. Then you start Googling.

Welcome to the search for a better way.

The actual problem: running Linux containers on macOS means you need a Linux VM underneath. Docker Desktop hides that VM from you, which is convenient until it isn’t. Lima and Multipass don’t hide anything — they give you the VM directly, let you poke at it, and get out of the way.

Both are free. Both are open source. Both support Apple Silicon and x86. The difference is in philosophy and use case, and picking the wrong one will cost you time you didn’t have.

What You’re Actually Installing

Before the comparison, a quick mental model reset.

Lima (Linux Machines) is a CNCF project. It’s a VM manager that leans hard into the container-native world. Under the hood it uses QEMU with Apple’s Virtualization Framework on Apple Silicon, handles port forwarding, mounts your home directory read-only by default (writable paths are explicit), and ships with ready-made templates for Ubuntu, Debian, Fedora, Alpine, and more. Rancher Desktop and Colima both use Lima as their VM engine. It’s the engine room.

Multipass is Canonical’s answer. Ubuntu-first, deliberately simple, built for the “I need a Ubuntu box right now” workflow. It uses Apple’s Virtualization Framework on M-series Macs and Hyper-V/KVM on Linux/Windows. It’s opinionated and fast. The tradeoff is that it’s Ubuntu-centric — other distros exist but they’re second-class citizens.

Install

Lima

brew install lima

That’s it. No daemon to configure, no service to start. limactl is your CLI.

Multipass

brew install --cask multipass

Multipass installs a menu bar app and a background helper. It’s heavier than Lima on install but you also never have to think about it again.

Starting a VM

Lima — Ubuntu 24.04

limactl start template://ubuntu-24.04

First run pulls the cloud image (~600 MB), creates the VM, and drops you at a shell prompt. Subsequent starts are fast — under 10 seconds on an M2.

List your instances:

limactl list
NAME              STATUS     SSH                CPUS    MEMORY    DISK      DIR
ubuntu-24.04      Running    127.0.0.1:60022    4       4GiB      100GiB    ~/.lima/ubuntu-24.04

Get a shell:

limactl shell ubuntu-24.04

Multipass — Ubuntu 24.04

multipass launch 24.04 --name devbox --cpus 4 --memory 4G --disk 40G

Multipass defaults to the latest Ubuntu LTS if you skip the version. It’s slightly faster to first boot than Lima in practice — partly because Canonical’s image pipeline optimizes heavily for Multipass.

multipass list
Name                    State             IPv4             Image
devbox                  Running           192.168.64.4     Ubuntu 24.04 LTS

multipass shell devbox

One notable difference: Multipass gives your VM a real LAN IP address immediately. Lima’s networking is host-only by default — you reach services via forwarded ports, not a direct IP. For most dev work it doesn’t matter; for testing something that needs to be reachable from other devices on your network, Multipass wins.

File Sharing

This is where things get real. Dev workflows live and die on how fast your editor’s changes land inside the VM.

Lima — virtiofs (the right answer)

Lima defaults to sshfs for compatibility but you want virtiofs if you’re on Apple Silicon:

vmType: vz        # Apple Virtualization Framework
rosetta:
  enabled: true   # x86 emulation on Apple Silicon, optional
mounts:
  - location: "~"
    writable: false
  - location: "~/projects"
    writable: true
    mountType: virtiofs

virtiofs on Apple Silicon is legitimately fast — close to native APFS speeds for sequential reads. sshfs by comparison feels like you’re copying files through a wet paper towel.

Restart the VM after editing the config:

limactl stop ubuntu-24.04
limactl start ubuntu-24.04

Multipass — 9p / native mounts

multipass mount ~/projects devbox:/home/ubuntu/projects

Multipass uses 9p (Plan 9 filesystem protocol) for host mounts. It works, it’s automatic, but virtiofs on Lima is faster for I/O-heavy workloads like npm install or cargo build. On an M2 Pro doing a cold npm install of a mid-size project, Lima with virtiofs finishes in roughly 60% of the time Multipass takes. Not scientific, not reproducible on your machine, but it tracks with what others have reported.

Docker Setup

Lima — Docker Template

Lima ships a docker.yaml template that sets up a full Docker Engine (not containerd) inside the VM and exports the socket:

limactl start template://docker

Once it’s running, add the Docker context on your host:

docker context create lima-docker \
  --docker "host=unix:///Users/$(whoami)/.lima/docker/sock/docker.sock"

docker context use lima-docker

Now docker commands on your host run against the VM’s engine:

docker run --rm hello-world
# Hello from Docker! — running inside Lima, transparent to you

Build an image from your host, against code in your mounted project dir:

cd ~/projects/myapp
docker build -t myapp:local .
docker run --rm -p 8080:8080 myapp:local

Port forwarding is automatic — Lima forwards ports declared in the container or via -p back to localhost.

Lima also has a default template which uses containerd + nerdctl instead of Docker Engine. If you want to go full OCI-native and ditch the Docker daemon entirely, that’s your path. nerdctl is a drop-in replacement for most docker commands.

limactl start template://default   # containerd + nerdctl
limactl shell default
nerdctl run --rm hello-world

Multipass — Manual Docker Install

Multipass doesn’t have a Docker template. You install Docker Engine yourself inside the VM:

multipass shell devbox

Inside the VM:

curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker ubuntu
newgrp docker

Then expose the socket from outside. The cleanest approach uses SSH forwarding:

# Get the VM's IP
multipass info devbox | grep IPv4
# 192.168.64.4

docker context create multipass-devbox \
  --docker "host=ssh://ubuntu@192.168.64.4"

docker context use multipass-devbox

For passwordless SSH, copy your key:

ssh-copy-id ubuntu@192.168.64.4

It works, but it’s five steps where Lima is two. If you’re setting this up once and forgetting it, no big deal. If you’re scripting dev environment provisioning, Lima’s template approach is cleaner.

Resource Overhead

Both VMs idle at roughly the same RAM — the QEMU/vz overhead is similar. On an M2 MacBook Pro with 16 GB:

• Lima (ubuntu-24.04, 4 GB assigned): ~700 MB host RAM overhead on top of assigned guest RAM. Startup: ~8s.
• Multipass (24.04, 4 GB assigned): ~600 MB host RAM overhead. Startup: ~6s.

Neither is meaningfully lighter. The difference is close enough to be noise across reboots.

CPU at idle is basically zero for both once the VM has fully booted. This is the real win over Docker Desktop, which runs a LinuxKit VM with a hypervisor layer that tends to spin up periodically even when you’re doing nothing.

Snapshot and Lifecycle Management

Lima

limactl stop ubuntu-24.04
limactl snapshot create ubuntu-24.04 --tag before-experiment
limactl start ubuntu-24.04

# Oops, broke something
limactl stop ubuntu-24.04
limactl snapshot apply ubuntu-24.04 --tag before-experiment
limactl start ubuntu-24.04

Snapshots are fast (copy-on-write via QEMU) and use minimal extra disk.

Multipass

multipass snapshot devbox

# Restore
multipass restore devbox.snapshot1

Both support snapshots. Lima’s interface is slightly more explicit about naming; Multipass auto-increments. Pick whichever mental model you prefer.

When to Use Lima

Lima is the right call when:

• You want containerd-native workflows (no Docker daemon)
• You’re using or building tools in the Rancher/Colima ecosystem and want to understand what’s underneath
• You care about virtiofs performance for heavy build workloads
• You want to run non-Ubuntu distros (the Fedora and Alpine templates are solid)
• You’re scripting dev environment setup and want YAML-defined, reproducible VMs

# Custom Lima config for a dev VM
limactl create --name myproject /path/to/myproject.yaml
limactl start myproject

The YAML config is version-controllable. Drop it in your repo’s devenv/ folder, and any team member can reproduce your exact VM config with one command.

When to Use Multipass

Multipass wins when:

• You need an Ubuntu VM in under 2 minutes with zero config
• Your workflow is “SSH in, do Linux stuff, SSH out”
• You need the VM to have a proper LAN IP (lab testing, network-adjacent work)
• You’re already deep in the Ubuntu/Canonical ecosystem
• You want a simple, stable tool that Just Works without reading docs

# Spin up a test environment, run a thing, nuke it
multipass launch 24.04 --name throwaway --cpus 2 --memory 2G
multipass shell throwaway
# ... do stuff ...
multipass delete throwaway && multipass purge

The ephemeral VM workflow is where Multipass genuinely shines. It’s fast, it’s clean, and multipass purge removes all traces.

What About OrbStack and Colima?

Briefly, since you’ll see them in the same breath:

Colima is Lima with a simpler CLI and opinionated defaults for Docker/containerd. If Lima feels like too many knobs, Colima is Lima with the knobs pre-set. colima start just works. It uses Lima under the hood.

OrbStack is the slick commercial option ($8/month after trial, free for students/OSS). It’s faster than both Lima and Multipass, has a polished macOS UI, and handles Docker contexts automatically. If you’re a professional who bills by the hour and values your time, OrbStack is probably worth it. If you’re a home lab tinkerer who objects on principle to paying for what QEMU does for free, Lima is your jam.

This article isn’t a Lima vs OrbStack comparison because that’s a different conversation. The short version: OrbStack is faster and easier; Lima/Multipass are free and give you more control.

Verdict

Lima if you’re container-focused, want reproducible YAML-defined VMs, or are building on Apple Silicon and care about virtiofs performance. It’s the power tool.

Multipass if you need an Ubuntu box fast and don’t want to think about it. Install, launch, shell, done. It’s the Swiss Army knife you reach for without reading the manual.

Both beat Docker Desktop’s resource footprint and neither sends you to a pricing page when you need to run containers at work. That alone makes the 20-minute setup time worth it.

Your 2 AM self debugging a container network issue will appreciate having a real Linux VM you can actually poke at — not a hypervisor abstraction that hides everything useful behind a Docker Desktop settings pane.

Quick Reference

# Lima cheatsheet
brew install lima
limactl start template://ubuntu-24.04   # Ubuntu VM
limactl start template://docker          # VM with Docker Engine + socket
limactl start template://default         # VM with containerd + nerdctl
limactl list
limactl shell <name>
limactl stop <name>
limactl delete <name>

# Multipass cheatsheet
brew install --cask multipass
multipass launch 24.04 --name devbox --cpus 4 --memory 4G
multipass list
multipass shell devbox
multipass mount ~/projects devbox:/home/ubuntu/projects
multipass stop devbox
multipass delete devbox && multipass purge