Compared to other tools
A side-by-side comparison of yoink with Kamal, Kubernetes, Dokku, Coolify, and plain docker compose.
Many tools do a similar job to yoink. The correct tool depends on your scale, on the number of operators, and on how much always-on infrastructure you want to operate.
At-a-glance matrix
✓ = built-in, ◐ = partial or opt-in, ✗ = not in scope.
| yoink | Kamal | Coolify | Dokku | Komodo | Uncloud | compose | k8s | |
|---|---|---|---|---|---|---|---|---|
| Single binary, no control plane | ✓ | ✓ | ✗ (web app + DB) | ◐ (host-side runtime) | ✗ (Core + per-host agents) | ✗ (per-host daemon) | ✓ | ✗ |
| Always-on services to operate | none | none | Coolify Core + DB | Dokku on each host | Komodo Core + Periphery | uncloudd per host | none | etcd + control plane |
| Config-as-code (YAML, in your repo) | ✓ | ✓ | ◐ (UI primary, GitOps opt-in) | ✗ (CLI + buildpacks) | ◐ (UI primary, “Resource Sync” opt-in) | ✓ | ✓ | ✓ |
| CLI + files only, no GUI required | ✓ | ✓ | ✗ (UI is the primary surface) | ✓ | ✗ (UI is the primary surface) | ✓ | ✓ | ✓ |
| Agent-friendly (scriptable end-to-end) | ✓ | ✓ | ◐ (REST API exists, UI-first) | ✓ | ◐ (API exists, UI-first) | ✓ | ✓ | ✓ |
| Multiple services per host | ✓ | ◐ (one container per service per host) | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Replicas behind a proxy | ✓ | ✗ | ✓ | ✗ | ✓ | ✓ | ◐ | ✓ |
| Multi-host | ✓ | ✓ | ✓ | ✗ (single host) | ✓ | ✓ | ✗ | ✓ |
| Per-tier network isolation | ✓ | ✗ | ◐ | ✗ | ◐ | ◐ | ✓ | ✓ |
| Dependency-ordered deploys | ✓ | ✗ | ✓ | ✗ | ✓ | ✓ | ◐ | ✓ |
| Bundled reverse proxy (HTTPS, ACME) | ✓ (Caddy) | ✓ (kamal-proxy) | ✓ (Traefik) | ✓ (nginx) | ✗ | ✓ (Caddy) | ✗ | ◐ (Ingress controller of choice) |
| Healthcheck-gated rolling swap | ✓ | ✓ | ✓ | ◐ | ✓ | ✓ | ✗ | ✓ |
| Drift detection | ✓ | ✗ | ✗ | ✗ | ✓ | ✓ | ✗ | ✓ |
| Pre-merge dry-run / diff | ✓ | ✗ | ✗ | ✗ | ✗ | ✗ | ✗ | ✓ (kubectl diff) |
| Sealed in-repo secrets (no external service) | ✓ (age) | ✗ (external vault required) | ✗ | ✗ | ✗ | ✗ | ✗ | ✗ |
| Standalone deploy (no registry, no CI) | ✓ | ✗ | ✗ | ✓ (git push) | ✗ | ✗ | ✓ (local) | ✗ |
| Secure-by-default container options | ✓ | ✗ | ✗ | ✗ | ✗ | ✗ | ✗ | ◐ (Pod Security Standards) |
| Port-forward to non-published services | ✓ (yoink pf, auto-spawns socat sidecar) | ✗ | ✗ | ✗ | ✗ | ✗ | ✗ | ✓ (kubectl port-forward) |
| TUI dashboard | ✓ (k9s-style) | ✗ | n/a (web UI) | ✗ | n/a (web UI) | ✗ | ✗ | ◐ (k9s, third-party) |
| One-press rollback | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✗ | ✓ |
| Auto-scaling | ✗ | ✗ | ✗ | ✗ | ✗ | ✗ | ✗ | ✓ |
| Multi-tenancy / RBAC | ✗ | ✗ | ✓ | ◐ | ✓ | ✗ | ✗ | ✓ |
yoink is ahead on these rows:
- Single-binary operation.
- Drift detection.
- Sealed in-repo secrets.
- Hardened container defaults.
- Pre-merge diff.
- Standalone (no-registry) mode.
- Port-forward to services that do not publish host ports. In this group of tools, only Kubernetes has the same kubectl-style function.
- One-line templates (
yoink add postgres,yoink add openclaw,yoink add gh:acme/templates/foo). See the templates guide.
yoink deliberately does not compete on auto-scaling, multi-tenancy, and web UIs.
vs. Kamal
Kamal is the nearest tool to yoink. Each one is a binary (Rust for yoink, Ruby for Kamal) that connects to hosts over SSH and drives Docker.
| Feature | yoink | Kamal |
|---|---|---|
| Image build | yoink build [--push] (optional) | kamal build (built-in) |
| Reverse proxy | Bundled Caddy (admin-API push, mTLS, h2c, sealed certs) | First-party kamal-proxy |
| Replicas (multiple containers per service) | ✓ (replicas: N) | ✗ (one container per service per host) |
| Per-tier networks | ✓ (networks: [api, redis]) | ✗ (single shared network) |
| Dependency-ordered deploys | ✓ (depends_on: topo-sort, parallel waves) | ✗ |
| Drift detection | ✓ (yoink.spec_hash label) | ✗ |
| Pre-merge dry-run / diff | ✓ (yoink up --dry-run --format=markdown → sticky PR comment) | ✗ |
| TUI dashboard | ✓ (k9s-style) | ✗ (CLI only) |
| Service deploy history + one-press rollback | ✓ (TUI H then r) | ✓ (CLI kamal rollback <version>) |
| Secrets store | age-sealed secrets.age in the repo (default, no external service). provider: command runs any CLI (1Password op, Doppler, Vault, AWS Secrets Manager, Infisical CLI, Bitwarden) | 1Password / Bitwarden / LastPass / generic shell command |
| Accessory / app templates | yoink add postgres, yoink add openclaw, yoink add gh:owner/repo/path (yoink gets the template from GitHub, generates sealed secrets, and adds the fragment: a poor-man’s helm) | First-class accessories: block |
| Resource limits | k8s-style ("500m", "2Gi") | docker-style (cpus: 2, memory: 1g) |
Per-service pids_limit | ✓ | ✗ |
| Secure-by-default RunOptions | ✓ (cap_drop=ALL, no-new-privileges, read_only=true, pids_limit=1024, init=tini, tmpfs noexec, binds default :ro) | ✗ (docker defaults) |
| Port-forward to non-published services | ✓ (yoink pf <svc>, auto-spawns socat sidecar, thus the locked-down “no publish:” default does not make debugging awkward) | ✗ (you bring your own ssh -L) |
| No-registry deploy | ✓ (yoink up --build ships any service with a build: block through an ephemeral unregistry sidecar. Only the missing layers go across the SSH wire, no registry account is necessary, and there is a tarball fallback) | ✗ (registry required) |
| Driven by AI agents / CI scripts | ✓ (CLI + YAML, identical local & remote) | ✓ (CLI + YAML) |
| Maturity | New (born 2026) | Mature (born 2023, used at 37signals scale) |
| Ecosystem | Rust-built, opinionated for “I run a few heterogeneous services” | Ruby/Rails ecosystem, rails new → kamal init is the canonical Rails deploy story today |
Kamal fits when: you have a Rails, Phoenix, or Hanami app, and you want one tool that builds, deploys, and routes. You do not need replicas or per-tier network isolation.
yoink fits when: you have several services with different shapes (Rust API + Node web + Postgres). You want drift detection, sealed in-repo secrets, and a k9s-style TUI for inspection and rollback. yoink also fits a hobby project that needs the standalone loop with no registry and no CI.
vs. Coolify
Coolify is a self-hosted PaaS, similar to an open-source Heroku or Render. It runs as a long-lived web app on one of your hosts. It manages build pipelines, databases, env vars, auto-deploys from git, and a UI for non-engineers. yoink is much narrower. It does the “deploy these containers to these hosts” part and has none of the PaaS surface area.
| yoink | Coolify | |
|---|---|---|
| Architecture | Single binary, runs on demand | Coolify Core (web app + DB + queue) on one host, agent on each managed host |
| Operator interface | CLI + TUI (keyboard-only) | Web UI (primary), REST API (secondary) |
| State of truth | The yoink.yaml of the git repo | The database of Coolify (UI-edited, with an optional JSON export of environments + projects) |
| Build pipelines | Out of scope (use CI / yoink build) | Built-in (Nixpacks, Dockerfile, buildpacks) |
| One-click databases (Postgres / MySQL / Mongo) | Out of scope | Built-in templates with backups |
| Auto-deploy on git push | Out of scope (CI calls yoink up) | Built-in (webhook + build) |
| Multi-user, RBAC, audit log | ◐ (audit log only, no users and no RBAC) | ✓ |
| Bundled reverse proxy | ✓ (Caddy) | ✓ (Traefik) |
| Drift detection | ✓ | ✗ |
| Driven by AI agents / CI scripts | ✓ (all operations are CLI + YAML, no clicks required) | ◐ (REST API exists, but UI is the primary surface. Agents must learn the API and cannot only edit files) |
| Best fit | Engineers who already have a CI + git workflow and want a thin deploy layer | Teams who want a Heroku-shaped product and accept that they operate Coolify as a long-lived service |
Coolify fits when: you want a batteries-included PaaS (build, deploy, database, web UI, multi-user). You also accept that you operate Coolify as a long-running service on one of your hosts.
yoink fits when: you already have CI and git for the build pipeline. You want the deploy layer to be a thin CLI that you run on demand. You prefer not to run one more web app and database to deploy your apps.
vs. Dokku
Dokku is the original “Heroku in a box”. A single host runs Dokku, and you git push dokku main. Then a buildpack or Dockerfile flow ships your app behind nginx with auto-TLS. Dokku needs little infrastructure and is opinionated about the “git push to deploy” loop.
| yoink | Dokku | |
|---|---|---|
| Architecture | Single binary, runs on demand | Per-host runtime (dokku on each host that it manages) |
| Number of hosts | Many | One per Dokku install (no native multi-host) |
| Deploy trigger | yoink up from your laptop or CI | git push dokku main |
| Image build | Optional (yoink build) or in CI | Built-in (Buildpacks, Dockerfile, Lambda) |
| Bundled reverse proxy | ✓ (Caddy, ACME) | ✓ (nginx, Let’s Encrypt plugin) |
| Multiple services per host | ✓ | ✓ (multiple “apps”) |
| Replicas | ✓ | ✗ (one container per app process type) |
| Per-tier networks | ✓ | ◐ (Dokku networks plugin) |
| Drift detection | ✓ | ✗ |
| Sealed in-repo secrets | ✓ (age) | ✗ (env vars set on the host) |
| Driven by AI agents / CI scripts | ✓ (CLI + YAML, identical local & remote) | ✓ (CLI on the host, SSH to operate remotely) |
| Best fit | Multi-host fleets where the deploy tool is a thin client | Single host that you SSH into, “git push to deploy” is the daily loop |
Dokku fits when: one host is sufficient, the buildpack ergonomics fit your stack, and “git push to deploy” is the experience that you want.
yoink fits when: you want the same “add a config and run a command” simplicity, but across multiple hosts, with replicas, drift detection, and sealed in-repo secrets. You also prefer not to maintain a Dokku install on each host.
vs. Komodo
Komodo is also a Rust-built deploy and management tool for self-hosted containers, and it shares many features with yoink. The largest difference is ceremony. Komodo is a long-running web service with a control plane and per-host agents. yoink is a single binary that you run from your laptop or CI.
| yoink | Komodo | |
|---|---|---|
| Architecture | Single Rust binary, runs on demand | Komodo Core (web service + UI) + Komodo Periphery (agent on each managed host) |
| Always-on services to operate | None | Two: Core (with a database, MongoDB or FerretDB) + Periphery on each host |
| Operator interface | CLI + TUI (k9s-style, keyboard-only) | Web UI (primary) + CLI/API |
| State of truth | The yoink.yaml of the git repo | The database of Komodo (UI-edited, with optional GitOps “Resource Sync” file imports) |
| Deploy trigger | yoink up from your laptop or CI | Click in the UI, webhook, scheduled, or sync-from-git |
| Multi-user / RBAC | None (operator-as-user) | First-class users, groups, permissions |
| Auth | That which ssh + git + your secret store give you | OAuth (GitHub / Google) + local accounts, built in |
| Bring-your-own-host | yoink connects to any host that you can ssh into | Each host needs Periphery installed + reachable from Core |
| Container shape | yoink-managed containers from a per-service spec | Stacks (compose files) / Deployments / Builds / Repos |
| Drift detection | ✓ (yoink.spec_hash label) | ✓ (UI shows diff between desired and live) |
| Bundled reverse proxy | ✓ (Caddy) | ✗ (bring your own) |
| Healthcheck-gated rolling swap | ✓ | ✓ (compose-style) |
| Audit log of who deployed what | JSONL audit log on each host (yoink audit log) + git history of yoink.yaml + per-container deploy labels | First-class audit log in the database |
| Driven by AI agents / CI scripts | ✓ (CLI + YAML, no GUI in the loop) | ◐ (API exists, but UI is the primary surface) |
| Best fit team size | 1 to 3 operators who share a repo | 3+ operators, a team that benefits from a UI + RBAC |
Komodo fits when: you want a UI for people who do not use a CLI, you manage more hosts than one operator can remember, and RBAC matters. The control-plane functions must also be worth the overhead of a database, a web service, and per-host agents.
yoink fits when: a single binary on your laptop is the full control surface, and the git repo is the source of truth. You prefer not to operate one more service with a database. The CLI and TUI work best for 1 to 3 operators (or for AI agents and CI runners) who are comfortable in a terminal.
vs. Uncloud
Uncloud is for the same situation as yoink: a small fleet, multiple services, and deliberately not Kubernetes. The largest difference is again ceremony. Uncloud installs a daemon (uncloudd) on each managed host and connects the daemons into a WireGuard mesh. yoink is a one-binary client that talks to docker over plain ssh.
| yoink | Uncloud | |
|---|---|---|
| Architecture | Single client binary that talks to docker on each host over ssh | Per-host daemon (uncloudd) on each managed host, peer-to-peer (no master) |
| Always-on services to operate | None | One daemon per host (auto-installed by uncloud machine init) |
| Cross-host networking | None. yoink relies on the per-host networks of docker, and cross-host is your routing decision (for example Tailscale or public DNS) | First-class. Uncloud builds a WireGuard mesh between hosts, and services connect to each other by name across hosts |
| Reverse proxy / public ingress | ✓ (bundled Caddy with admin-API push, sealed certs, mTLS) | First-class. Built-in Caddy-based ingress with auto-TLS |
| State of truth | The yoink.yaml of the git repo | Cluster state is in the daemon mesh. YAML config is also supported |
| Drift detection | ✓ (yoink.spec_hash label) | ✓ (compares running state to declared spec) |
| Multi-host service replicas | ✓ (per-host counts, services[].hosts: whitelist) | ✓ (cluster-aware scheduling) |
| Onboarding a new host | Already works if you can ssh into it | uncloud machine init to install + join the mesh |
| Driven by AI agents / CI scripts | ✓ (CLI + YAML, no daemon to coordinate with) | ✓ (CLI + YAML, daemon-aware) |
| What yoink leaves to other tools that Uncloud bundles | cross-host service-to-service networking | n/a |
| Best fit | “I have ssh access to my hosts and want a deploy tool that respects that” | “I want a self-hosted lightweight cluster with mesh + ingress built in” |
Uncloud fits when: cross-host service-to-service networking matters (your api on one host talks to your worker on a different host). You also accept a daemon on each host as the price of that function.
yoink fits when: you already have a routing answer (Tailscale, a single edge host, public DNS everywhere). You do not want an always-on yoink-specific service on the host, and the docker daemon over ssh is sufficient surface area.
The two tools agree on “small fleet of containers, opinionated defaults”. They disagree on whether the deploy tool also owns the network fabric.
vs. plain docker compose
Compose is a YAML schema that declares a stack on a single host. yoink is a deploy tool that runs against any number of hosts.
| yoink | docker compose | |
|---|---|---|
| Multi-host | ✓ | ✗ (one host, or you script around it) |
| Healthcheck-gated rolling swap | ✓ | ✗ (docker compose up -d recreates without gating) |
| Per-service drift detection | ✓ | ✗ |
| Bundled reverse proxy with HTTPS | ✓ (Caddy + ACME / sealed certs) | ✗ (bring your own) |
| Secure-by-default container options | ✓ | ✗ (the defaults of compose are dev-friendly: full caps, writable rootfs, no pids cap) |
| Port-forward to non-published services | ✓ (yoink pf <svc>, auto-spawns socat sidecar) | ✗ (bring your own docker exec / temporary ports: edit) |
| Pre-deploy hooks (for example migrations) | ✓ (hooks.pre_deploy) | partial (depends_on + healthcheck workaround) |
| Secrets store | ✓ (age-sealed secrets.age in the repo by default, provider: command for any external CLI) | ✗ (env file or external) |
| TUI / drift dashboard | ✓ | ✗ |
| Driven by AI agents / CI scripts | ✓ | ✓ |
| Single binary, no Python/Compose runtime | ✓ | ✗ (Compose v2 ships with docker, but still a separate runtime) |
compose fits when: you have a local stack on a dev machine or a single-host hobby project, or you are already comfortable with deploy scripts around compose.
yoink fits when: you want the “declarative containers” model of compose with a real deploy story (rolling, multi-host, drift detection, secrets, hardened defaults, bundled proxy).
vs. Kubernetes
yoink is for people who do not want a control plane.
| yoink | Kubernetes | |
|---|---|---|
| Control plane | None | etcd + apiserver + controller-manager + scheduler + kubelet on every node |
| Operator overhead | Single Rust binary on your laptop | A team |
| Auto-scaling | ✗ | ✓ (HPA / VPA / Cluster Autoscaler) |
| Multi-tenant / RBAC | ✗ | ✓ |
| Service mesh, ingress controllers, CSI, CNI plugins | ✗ | The whole ecosystem |
| Replicas + healthcheck-gated rolling swap | ✓ | ✓ (Deployments) |
| Per-tier network isolation | ✓ (named docker networks) | ✓ (NetworkPolicy + CNI) |
| Resource limits (cpu/memory) | ✓ | ✓ |
| Secrets management | ✓ (age-sealed in-repo by default, provider: command to any external CLI) | ✓ (Secrets / external store) |
| Port-forward to non-published services | ✓ (yoink pf <svc>, auto-spawns socat sidecar) | ✓ (kubectl port-forward) |
| Driven by AI agents / CI scripts | ✓ (CLI + one YAML file) | ✓ (kubectl + many YAML files) |
| Imperative deploy command | yoink up | kubectl apply -f |
Kubernetes fits when: you have a real infrastructure team, you need autoscaling or multi-tenancy, or you operate across many regions. It also fits when your engineering org uses it as the standard, or when you want a service mesh.
yoink fits when: you want the Kubernetes ideas that give a benefit at small scale (drift detection, per-tier networks, healthcheck-gated rolls, declarative config, in-repo secrets), without the control plane and the team to operate it.
vs. nothing: just ssh + docker run
This is the baseline. Many small deployments are exactly this, and that is fine.
“Just ssh + docker run” fits when: you have one container, and you deploy only occasionally. You also accept that docker run does not roll, does not healthcheck, does not drain, and does not track who deployed what and when.
yoink fits when: you have shell scripts that wrap ssh + docker run, and you want to stop writing them. The yoink config has approximately the shape of those scripts, but it is declarative. yoink also gives you the rolling, healthcheck, drift, and history functions that you otherwise build yourself.
See also
- What and why: the design philosophy on one page.
- First deploy: a five-minute tutorial, if the matrix points you to yoink.
- Architecture: drift detection, deploy lock, healthcheck-gated swap.
- Example configs: complete
yoink.yamlfiles for three kinds of deploy.