Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

How Ratect Compares to Other Tools

This page compares Ratect against what a project is actually likely to be choosing between today: Docker Compose, Make, Task, Earthly, Dagger, and just.

None of these six exist to lose to Ratect. Each was built to solve a real problem, several of them solve it better than Ratect does for the case they targeted, and picking the right one is usually about which problem you actually have — not which tool wins a feature count. What follows is honest about both directions.

Reach for Ratect when the problem is running development tasks identically on every machine, isolated from your host and from each other, with real dependency orchestration. Two of those are for free just by running in Docker at all: the image is built the same way regardless of what’s on your host (reproducibility), and by default each run gets its own disposable network — created fresh per invocation, named after that run, torn down after — so containers on one run can’t reach containers or ports from another (isolation), unless you deliberately opt out with --use-network. The third — a database or another service that needs to actually be ready, not just started, before your task touches it — is Ratect’s own design, not a side effect of Docker. That’s a narrower claim than “runs my project”; the sections below say plainly where it isn’t the best fit.

Docker Compose

Compose defines and runs multi-container applications — the closest match to Ratect in shape (containers, networks, dependencies between them), and the one most likely to already be sitting in a project you’re looking at.

Where Compose wins: it’s the default, not an alternative you have to choose — ships with Docker Desktop and Engine, and most developers already know it. Bringing up a stack and leaving it running (the actual point of a docker-compose.yml) needs less ceremony in Compose than expressing the same thing as a Ratect task, because that’s what Compose is for and Ratect’s task model isn’t. docker compose watch gives you a live dev loop with no equivalent in Ratect at all.

Where Ratect wins: Compose has no task layer — no prerequisites, no distinct build/test/lint verbs, no per-invocation ephemeral containers. depends_on: condition: service_healthy gates start order on a health check, which is real and useful, but Compose has nothing like setup_commands — a scripted step that runs inside a dependency once it’s healthy but before anything depends on it starts. Seeding a database before code touches it means an init container or an entrypoint script you write and maintain yourself; in Ratect it’s a config field. The isolation model differs too: a Compose stack is meant to be brought up once and left running, its network and containers shared across however many docker compose exec calls you make against it afterward. Ratect’s network and containers, by default, are scoped to one task invocation and torn down when it finishes, rather than persisting for the next run to reach. And a Compose service runs as its image’s user unless you set user: to a uid yourself, so on a rootful Linux daemon what it writes through a bind mount is usually root’s, where Ratect’s identity runs the container as you there, and gives it the same $HOME on every daemon.

Make

GNU Make — the original. Targets, prerequisites, recipes, and a dependency graph driven by file timestamps — genuinely incremental, in a way nothing else on this page (Ratect included) fully replicates.

Where Make wins: it’s already installed, on nearly every Unix-like system, with zero extra daemon and zero extra dependency — spinning up Docker for a one-line shell command is real overhead Make never pays. Make’s own incremental rebuild — skip a target outright if its prerequisites’ files haven’t changed — is a genuine capability Ratect doesn’t have; a Ratect task always runs, and whether the tool inside the container decides to skip work is between that tool and its own cache, not something Ratect tracks itself.

Where Ratect wins: Make runs on whatever’s already on your host — the exact “works on my machine” problem Ratect exists to remove, and whatever a recipe installs, writes, or leaves running stays on your host too, since Make has no isolation from it at all. It also has no native model for orchestrating dependent services (bring up a database, wait for it, run something against it); that’s shell script bolted onto a recipe, not something the tool understands.

Task

Taskfiles — YAML, explicitly positioned as “inspired by Make, designed for modern workflows.” Closest in spirit to Ratect and Batect’s own “define tasks in a file” model of any tool here — but Task runs on the host by default; Docker is something you can reach for per-task, not the execution model itself.

Where Task wins: far lighter for tasks that don’t need containerizing at all — no daemon, near-instant startup, and it works the same on Windows without Docker Desktop in the loop. Its sources/generates fields give file-based skip-if-unchanged tracking similar to Make’s, which Ratect has no equivalent of.

Where Ratect wins: the same reproducibility and isolation gap as Make — Task’s default is your host toolchain, so “works on my machine” is back on the table unless you deliberately containerize each task yourself, and even then there’s no built-in service-dependency/readiness model to reach for.

Earthly

Worth naming plainly: Earthly is no longer actively maintained — its own README says so directly, pointing at a post titled “shutting down Earthly Cloud.” Its last tagged release was mid-2025. Comparing against it now is closer to Ratect’s own relationship with Batect than a live rivalry.

While it was under active development, Earthly’s actual design point was a containerized build framework — Dockerfile-and-Makefile-flavored syntax, BuildKit-based, with a real target-level build-cache graph more sophisticated than Ratect’s cache volume mounts for the specific job of producing cacheable build artifacts identically locally and in CI.

Where Ratect wins today, practically: it’s maintained. Setting that aside, the two tools’ centers of gravity differ anyway — Earthly is oriented around building artifacts; Ratect’s health_check/setup_commands/ dependencies model is oriented around running and orchestrating live services, which was never Earthly’s target.

Dagger

A programmable automation engine, not a config format: pipelines are code, in a real language (Go, Python, TypeScript, and others), compiling down to containers as Dagger’s own primitive. The pitch is portability — the same pipeline runs on your laptop, in CI, or in Dagger’s own cloud — backed by built-in OpenTelemetry tracing.

Where Dagger wins: a real programming language for pipeline logic — loops, conditionals, functions, tests for the pipeline itself — which ratect.toml/batect.yml’s declarative shape deliberately doesn’t offer, and isn’t trying to. For a genuinely complex pipeline that outgrows what a static config file can express cleanly, that’s a real advantage, not a rounding error.

Where Ratect wins: simplicity for the common case. Most projects need “run these containers, in this order, with these dependencies” — a small TOML/YAML file to read and edit, not SDK code in a general-purpose language to write and maintain. Ratect’s Batect-compatibility story (an existing batect.yml keeps working, field-for-field) also has no Dagger analogue — Dagger is a from-scratch mental model, not a migration path from anything.

just

Its own README calls it “a command runner, not a build system” — a deliberate, stated distinction from Make, not an oversight. justfile recipes run on the host, with none of Make’s dependency-graph or incremental-rebuild machinery.

Where just wins: about as light as this category gets — a single small binary, no daemon, recipes that are just shell commands with better ergonomics (parameters, cross-platform support, no .PHONY workarounds). For “give me short, memorable names for the commands I run all the time,” reaching for Ratect and its Docker daemon is real overhead for no benefit.

Where Ratect wins: just doesn’t attempt reproducibility or isolation at all — recipes run in your own shell, on your own machine — and it has no service-orchestration model whatsoever. Neither is a flaw in just; it’s explicitly not trying to be either of those things.

If you’re choosing

Reach for…when the problem is
Ratectdevelopment tasks that need to run identically everywhere, isolated from your host, and/or real services (a database, another API) they depend on actually being ready first
Docker Composebringing up and living inside a multi-container stack, more than running discrete tasks against it
Makeyou already have make everywhere you need it, and don’t need containers, isolation, or cross-machine reproducibility
TaskMake-like ergonomics without Make’s own syntax, for tasks that don’t need Docker
Daggera pipeline complex enough to genuinely need a real programming language, not a config file
justshort, memorable shortcuts for commands you already know how to run

Earthly isn’t in that table on purpose — recommending an unmaintained tool for new work doesn’t make sense regardless of what it used to be good at; see its own section above for what that was.

Nothing here is exclusive — a real project often uses more than one of these at once (a justfile that shells out to ratect run, or a Compose stack a Ratect task talks to). This is a guide to which problem each tool was built for, not a bracket with one winner.

Coming from Batect? Its own comparison page ranged over shell scripts, Docker Compose, Dojo, Earthly, CI tools with a local runner (GitLab CI, CircleCI), and Vagrant — reasonable choices when it was written. Of those, Docker Compose and Earthly are the two this page also covers. To move a batect.yml project over, see Migrating a Batect Project to Ratect.

Starting fresh rather than from a batect.yml? Installation is next.