Docker Desktop vs Colima vs OrbStack: Which Wastes the Least Disk on Mac?

If you run containers on a Mac, you have already felt the sting of a suddenly bloated ~ directory. The Colima vs Docker Desktop disk space debate is real: a single busy developer machine can accumulate 40–80 GB of VM disks, pulled images, and layer caches before anyone notices. Add OrbStack to the comparison and the picture gets more nuanced, because all three tools store data in different places and age that data differently. This guide walks through exactly where each runtime hides its files, how big those files grow in practice, and what you can safely delete without breaking your workflow.

Why Container Runtimes Eat So Much Disk

Containers on macOS require a Linux kernel, so every runtime spins up a virtual machine. That VM needs a disk image, and Docker's layer-based image format means every pulled image stores its full layer tree—even layers shared with other images are deduplicated only inside one runtime, not across runtimes if you run more than one. On top of that, build caches, log files, and leftover volumes accumulate silently over weeks and months.

The three categories of storage you should track are:

• VM disk images — the virtual disk the Linux guest runs on; grows as you pull images and write data inside the VM.
• Container images and layer cache — the OCI image layers, stored inside the VM disk or in a host-side daemon directory.
• Host-side config and daemon data — settings, credentials, extension files, and sometimes a separate host-side BuildKit cache.

Where Each Runtime Stores Its Files

Knowing the actual paths is the first step to auditing your disk. Here is a reference map for all three tools on macOS (Apple Silicon and Intel):

A few notes: Docker Desktop's Docker.raw (or Docker.qcow2 on older installs) is a sparse file, so du -sh will report its logical size while ls -lh reports the on-disk size. Colima uses QEMU with a qcow2 file that also grows dynamically but does not automatically shrink when you delete images inside the VM. OrbStack uses a proprietary storage backend under ~/Library/Application Support/OrbStack/data/ and is generally better at reclaiming freed space.

Docker Desktop: The Heaviest Default Footprint

Docker Desktop is the most popular choice and also the most disk-hungry by default. Beyond the VM disk, it installs a menu-bar app, a system extension, and optionally Docker Extensions—each of which can add hundreds of megabytes. The application bundle itself lives at /Applications/Docker.app and weighs roughly 700 MB–1 GB. The real culprit, though, is the VM disk image at ~/Library/Containers/com.docker.docker/Data/vms/0/data/Docker.raw, which can silently swell past 50 GB on an active machine.

Docker Desktop does provide a Disk Usage panel under Settings > Resources > Advanced that shows allocated vs. used space inside the VM, and a Clean / Purge button to reclaim space. However, the raw file rarely shrinks automatically even after running docker system prune -a --volumes inside the VM—you often need to reset the VM disk entirely to recover the space on the host filesystem.

BuildKit cache (used by docker buildx) can accumulate separately under ~/.docker/buildx/ and inside the VM's /var/lib/buildkit/. You can clear it with:

docker buildx prune --all

Colima: Lean CLI Runtime with a Few Gotchas

Colima is a lightweight, open-source CLI wrapper around Lima and QEMU (or the Virtualization framework on Apple Silicon). Its install footprint is tiny—you get a binary via Homebrew and a ~/.colima/ directory. The VM disk lives at ~/.colima/default/disk.qcow2. You can inspect its logical and actual sizes with:

ls -lh ~/.colima/default/disk.qcow2
du -sh ~/.colima/default/disk.qcow2

The default disk allocation is 60 GB (configurable at init time with --disk). The qcow2 file only uses space that the guest has actually written, so a fresh Colima with a handful of images might sit at 8–12 GB. The catch is that QEMU does not automatically punch holes when the guest deletes files; running docker system prune inside the VM frees blocks logically but the qcow2 file on your Mac does not shrink until you compact it:

colima stop
qemu-img convert -O qcow2 ~/.colima/default/disk.qcow2 ~/.colima/default/disk-compact.qcow2
mv ~/.colima/default/disk-compact.qcow2 ~/.colima/default/disk.qcow2

This is the main disk-hygiene step that many Colima users skip, leading to a bloated qcow2 file months later.

OrbStack: Best at Staying Small

OrbStack is the newest entrant and was designed with macOS-native performance in mind. It uses Apple's Virtualization framework exclusively (no QEMU on Apple Silicon) and a smarter storage backend that more aggressively reclaims freed space. The data lives at ~/Library/Application Support/OrbStack/data/, and unlike Docker Desktop's fixed raw image, OrbStack can return freed space to macOS without requiring a VM reset.

OrbStack also runs both Docker containers and Linux machines from a single daemon, so you are not tempted to install a second runtime. Its application bundle at /Applications/OrbStack.app is roughly 200–400 MB—considerably smaller than Docker Desktop's bundle.

The main consideration with OrbStack is that the storage layout is opaque: you cannot simply open Finder and inspect layers the way you can with Colima's qcow2. You rely on OrbStack's built-in disk usage UI or on standard Docker CLI commands like docker system df to see what is consuming space.

How to Audit and Reclaim Disk Space Across All Three (Step-by-Step)

Regardless of which runtime you use, this process will surface wasted space and let you recover it safely.

1. Check your Docker disk usage summary. Run docker system df to see images, containers, volumes, and build cache totals. This works identically with Docker Desktop, Colima, and OrbStack.
2. Remove unused images and stopped containers. Run docker system prune -a to delete all images not referenced by a running container, plus stopped containers and dangling volumes. Add --volumes to also remove anonymous volumes.
3. Clear BuildKit cache. Run docker buildx prune --all if you use buildx or multi-platform builds—this cache is not touched by system prune.
4. Compact the VM disk (Colima only). After pruning inside the VM, follow the qemu-img convert steps in the Colima section above to actually shrink the qcow2 on your Mac.
5. Audit host-side directories. Check ~/.docker/ for credential helpers, config files, and any leftover plugin directories. On Docker Desktop also check ~/Library/Containers/com.docker.docker/ and ~/Library/Application Support/Docker Desktop/.
6. Look at related developer caches. Container workflows often accompany large caches elsewhere—~/Library/Caches/, ~/.m2/repository, ~/.gradle/caches, ~/.npm, and ~/Library/Developer/Xcode/DerivedData can each grow independently. A tool like Crumb can audit all of these at once and show what is safe before you delete.

For a broader look at what is consuming disk across your whole Mac, the guide on what is taking up space on your Mac covers the full picture beyond just developer tools. If you are specifically tracking system data growing without a clear cause, see what is System Data in Mac storage—container VM files sometimes get counted there in the Storage overview.

Which Runtime Wastes the Least Disk?

If disk efficiency is your top priority, the ranking in practice looks like this:

• OrbStack — best at reclaiming freed space automatically; smallest application bundle; single daemon for Docker and Linux VMs.
• Colima — lean by default, but requires manual qcow2 compaction to actually return space to the host; excellent if you want full transparency into your VM disk file.
• Docker Desktop — largest footprint out of the box; good visibility tools (the Disk Usage panel), but the raw VM image shrinks poorly without a full reset; extensions and the application bundle add extra overhead.

That said, the delta between runtimes matters far less than your image hygiene habits. A developer who runs docker system prune -a monthly on Docker Desktop will use less disk than one who never prunes on OrbStack. The runtime choice determines how efficiently freed space flows back to your Mac; your pruning discipline determines how much space gets freed in the first place.

Should You Run More Than One Runtime at a Time?

Many developers have Docker Desktop installed from years ago and then added Colima or OrbStack when Desktop felt too heavy. If both are installed simultaneously, you may be paying the disk and memory cost of two VM disks and two image stores with no images shared between them. Before you pull the same base image twice, check what is installed:

ls ~/Library/Containers/com.docker.docker  # Docker Desktop
ls ~/.colima/                              # Colima
ls ~/Library/Application\ Support/OrbStack # OrbStack

If you are fully migrated to Colima or OrbStack, uninstalling Docker Desktop via its own Troubleshoot > Uninstall menu (or by dragging to Trash and then removing ~/Library/Containers/com.docker.docker and ~/Library/Group Containers/group.com.docker) can free 30 GB or more on a machine that has been running Docker Desktop for a year or two.