Borrow anothermachine'sruntime
Your laptop is out of RAM. The machine in the other room isn't. runtime-orbit runs your builds and containers over there — over plain SSH — while published ports come straight back to localhost. You keep working. Your fans stop spinning.
# install on both machines (macOS / Linux)
$ curl -fsSL https://slothlabs.org/install/runtime-orbit | sh
# on the beefy machine — the donor
$ runtime-orbit donor setup
# on the laptop that needs the RAM
$ runtime-orbit setup --ip 192.168.1.20
✓ authorized · no password to copy anywhere
✓ docker → the donor · 64 GB, 16 cores
✓ self-test passed — localhost works
✦ its RAM and CPU · your localhostOpen source · Docker Desktop · OrbStack · Rancher Desktop · colima · Lima · Podman · containerd · MIT
Docker runs where you type. That's the bug.
Your laptop is the worst machine you own for running Docker — it's the one you also need for everything else. The compute should live somewhere else. Getting there usually means fragile SSH hacks and broken port mapping.
Docker melts your laptop
A big image build pins every core, drains the battery, and turns the fans into a jet engine. Meanwhile you can't type in your editor without lag.
That 64 GB tower sits idle
The gaming PC, the old Mac, the Linux box under the desk — all of them have RAM and cores to spare while your laptop suffocates. They're doing nothing.
Remote Docker leaks your ports
Set DOCKER_HOST=ssh:// and the build runs remotely — but -p 8080:80 now binds on the remote box. curl localhost:8080 hits nothing. The transparency breaks.
Standard Docker contexts.
Ports that follow you home.
Docker already speaks to remote daemons over SSH. runtime-orbit does the two things that make it usable every day: it sets everything up with one command per machine, and it keeps your published ports reachable on your own localhost.
Borrower
docker CLI · localhost
Donor
runtime · RAM · disk
One command per machine
runtime-orbit donor setup on the beefy machine gets it ready to lend and prints the other side’s command. runtime-orbit setup --ip <donor> on the laptop authorizes itself, detects the donor’s runtime socket, and creates a standard docker context. Both idempotent — safe to re-run.
A real docker context — not a wrapper
The donor’s runtime socket is forwarded to a local unix socket, and the context points at that. Because it’s a stock context, docker, docker compose, Testcontainers and every tool that respects DOCKER_HOST just work. Nothing wraps or shadows your docker binary.
Ports reconciled on every event
runtime-orbit up opens one multiplexed SSH connection and starts a reconciler. It subscribes to the runtime’s event stream and keeps ssh -L tunnels in sync with the published ports — so -p 8080:80 on the donor is curl localhost:8080 here, automatically.
Transparent, or it's not worth it.
The whole point is that Docker feels local while running somewhere else. Every feature exists to protect that illusion.
Automatic port forwarding
The magicThe core trick. runtime-orbit watches the donor's runtime and opens/closes SSH tunnels as containers start and stop. Published ports are always live on your localhost — no manual -L juggling.
A dashboard for both machines
New in 0.2RAM meters, cores, IPs and load for each side; the donor's containers with CPU, memory and network; tunnel throughput as live rates; and how much RAM is not on this machine. --json for scripts.
Authorization without the ceremony
No ssh-copy-id, no editing authorized_keys. Type the donor's password once inside setup — or use a 6-digit pairing code and no password at all. The donor can enable SSH and stop sleeping from its own setup.
Standard docker context
It manages a normal docker context. No shim over the docker binary — full native compatibility with docker, compose, Testcontainers and anything that reads DOCKER_HOST.
Runtime-agnostic
Docker Desktop, OrbStack, Rancher Desktop, colima, Lima, Podman, containerd. It probes for all of them, resolves symlinks so one engine is never listed twice, and tells you which socket it picked.
Routing tables and RAM budgets
New in 0.2Delegate everything, or set a borrow ceiling and a local budget — stay here until 5 GB is used, then route away. Rules like postgres:* → local keep a database on your own disk. route explain says why.
doctor, on both sides
Every check with a clear ✓/✗/! and the exact fix. The donor's doctor catches the things that actually break a borrow: no runtime, SSH off, and a machine that falls asleep mid-build.
One multiplexed connection
A single SSH ControlMaster carries the runtime socket and every port tunnel. Low overhead, fast reconnects, clean teardown — and it survives the event stream dropping without killing your tunnels.
Reversible by design
up remembers your previous context; down restores it and drops every tunnel. Your local Docker is exactly where you left it — and it refuses to restore into a context it manages.
Two commands to start.
The rest for when you want them.
No daemon to babysit, no config file to learn. One command on each machine sets it up — everything else exists for the day something goes sideways, or you want a say in where things run.
docker context gets you halfway.
A raw DOCKER_HOST=ssh:// runs the build remotely — then leaves your ports stranded on the wrong machine and the setup to you. runtime-orbit closes that last, most annoying gap.
Mac and Linux today.
Every machine next.
Runtime detection is one probe and the transport is one thin layer, so new platforms plug in without touching the core. macOS and Linux work on both sides today.
Mac & Linux, either side
The unix socket path, in both directions: any mix of macOS and Linux, with automatic port forwarding, the live dashboard, in-app pairing, and the routing table.
Windows donors without WSL gymnastics
Today a Windows machine lends fine from inside a WSL2 distro. Next is reaching Docker Desktop's socket from Windows itself, so the gaming rig needs no setup you can see.
Source sync + more than one donor
Optional file sync so bind-mounts and hot-reload work across machines, and picking between several donors — the routing table already has the right shape for it.
Give the work
to the machine that can take it.
Install it on both machines, run one command on each. Free and open source — always.
# macOS / Linux
$ curl -fsSL https://slothlabs.org/install/runtime-orbit | sh
# or with Homebrew
$ brew install slothlabsorg/tap/runtime-orbit
# Windows: run the same line inside a WSL2 distroSSH transport · Docker Desktop · OrbStack · Rancher Desktop · colima · Lima · Podman · containerd · Rust CLI · MIT license