macOS · Apple Silicon · Swift + Go

Docker & Linux
on macOS, unboxed.

A lightweight, OrbStack-style runtime that boots a Linux VM with Apple's Virtualization.framework — then projects the Docker engine, file sharing, x86 translation and port mapping straight onto macOS. No Docker Desktop.

Named for the Oort cloud — the vast shell of countless small icy bodies at the edge of our solar system. Here: the many lightweight machines & sandboxes orbiting one shared kernel.

~1.2 s resume · ~4.5 s cold stock docker CLI brew install MIT licensed
What works today

A working clone — verified on real hardware.

oort studies why OrbStack is fast and light, then reimplements the core mechanisms by hand. One command to start; the stock docker CLI just works.

⚡

Instant resume ✓

oort suspend freezes the whole VM; the next start resumes in ~1.2 s with containers still running. OrbStack cold-boots.

🪪

Domains + trusted HTTPS ✓

https://web.oort.local just works — any container, any port, per-name certs from a local CA. No -p publishing.

📂

~/Oort in Finder ✓

The guest's and every machine's live filesystem, browsable and read-write from macOS — no sudo, no kexts.

🪄

The mac command ✓

Run Mac commands from any Linux shell: mac open https://…, mac pbpaste. Output and exit codes round-trip.

🌱

Machine time-travel ✓

snapshot / restore / fork a whole Linux machine — git for dev environments. OrbStack can't.

🤖

AI-agent sandboxes ✓

oort mcp gives coding agents disposable machines with snapshot-on-risk and fork-to-explore — built on time-travel.

🐳

Docker over vsock ✓

dockerd projected onto a macOS socket; the stock CLI works via an auto-selected oort docker context.

🔗

ssh + VS Code ✓

ssh oort on a stable localhost port; pick host "oort" in VS Code Remote-SSH and develop inside.

♻️

Disk gives space back ✓

Guest TRIM punches APFS holes on the Mac — freed space returns automatically (daily) or on demand.

⚙️

Rosetta x86-64 ✓

--platform linux/amd64 images run via Apple's Rosetta translation — far faster than QEMU.

☸️

Kubernetes (k3s) ✓

One command runs k3s in the guest and projects the kube API onto localhost:6443.

🪶

zram + ballooning ✓

Kernel-tier memory efficiency: zram swap plus an active balloon that returns idle RAM to macOS.

Quick start

From zero to docker run in four steps.

Requires macOS 13+ on Apple Silicon. The CLI is oort (so it never clashes with OrbStack's own orb).

1

Install (brew) — or clone the repo

The app is self-contained: first start downloads the Ubuntu image and builds the golden disk under ~/.oort, automatically.

zshcopy
$ brew install qemu                          # one external tool (image conversion)
$ brew install --cask everettjf/tap/oort
# hackers: git clone https://github.com/everettjf/oort && ./oort build-image
2

Start the VM

Boots Docker, file sharing, Rosetta and port forwarding. A reused golden disk is ready in seconds.

zsh — ~/dev/oortcopy
$ ./oort start
starting oort VM…
waiting for Docker.... ready.
$ eval "$(./oort env)"   # export DOCKER_HOST=unix://~/.oort/docker.sock
3

Use the stock Docker CLI

It's just Docker. Run containers, publish ports, even run x86-64 images via Rosetta.

zsh — dockercopy
$ docker run --rm hello-world
Hello from Docker!
$ docker run -p 8080:80 nginx        # curl localhost:8080 on the Mac
$ docker run --platform linux/amd64 alpine uname -m
x86_64                                # via Rosetta
4

Go further — machines & Kubernetes

Spin up named Linux machines, or bring up a k3s cluster with a single command.

zsh — oortcopy
$ oort machine create dev ubuntu   # named Linux machine
$ oort machine shell dev
$ oort k8s enable                  # k3s in the guest
$ kubectl get nodes
NAME      STATUS   ROLES                  AGE   VERSION
oort   Ready    control-plane,master   12s   v1.30…
How it works

Two halves: a Swift engine and a Go guest agent.

VZ

Swift virtualization engine

Builds a VZVirtualMachineConfiguration — virtio-blk root disk, NAT net, vsock, VirtioFS, Rosetta share, memory balloon — and owns the lifecycle on a dedicated VM queue.

↔

vsock socket projection

Each host Unix socket is a tunnel to a guest vsock port: dockerd on 2375, the exec agent on 2376, TCP forwards on 2377.

Go

Static guest agent

A tiny static linux/arm64 binary splices the Docker socket, runs oort exec commands, and forwards published ports — steady under load where Python wasn't.

🔒

Durability by design

An exclusive flock on the disk image stops two VMs corrupting it; graceful-only shutdown; oort reset restores the golden snapshot instantly.

macOS host Linux guest (VZ) ┌───────────────────┐ ┌───────────────────────┐ │ docker CLI / oort │ │ oort-guest (Go) │ │ │ │ │ │ │ │ DOCKER_HOST │ vsock │ 2375 → /run/docker.sock│ │ unix socket ────┼───────┼──▶ 2376 → oort exec │ │ │ │ │ 2377 → port forward │ │ oort (Swift/VZ) │ │ │ │ │ • disk • NAT │ │ dockerd · containerd │ │ • VirtioFS │ virtiofs /mnt/mac · Rosetta │ │ • Rosetta share ─┼───────┼──▶ binfmt_misc │ └───────────────────┘ └───────────────────────┘

◇ Honest status

Everything above is verified on real hardware by a 32-test end-to-end suite — boot, Docker, domains + HTTPS, ssh, Finder fs, the mac command, suspend/resume with surviving containers, time-travel, MCP sandboxes, and self-healing watchdogs for wedged daemons. Cold start ~4.5 s (stock kernel) / ~2.8 s (self-built); resume ~1.2 s.

Known residual: bind-mount metadata speed (VirtioFS is 8–35× slower per-file than the guest disk; real npm install is only ~1.2× — oort fastvol covers the hot paths). Matching OrbStack's general virtiofs speed needs a custom VMM — deliberately deferred. See the roadmap.

Open source · MIT

Boot Linux. Run Docker. Stay light.

brew install --cask everettjf/tap/oort — you're one oort start away.