Run locally

The repo ships a one-command dev harness (a Justfile over deploy/local-proc/) that runs scarab-server straight from the tree, giving you a loop that rebuilds and reruns with no image to publish. It runs the durable core end-to-end on your machine. To deploy the packaged chart instead (on kind/colima or a live cluster), see Installation; the Overview compares the two paths.

If you would rather look before you install, the live demo is a running instance — read-only for visitors, so it shows you the UI but will not run your pipeline. Everything below runs the real thing on your machine.

Prerequisites

• docker, kind, kubectl: the stack runs scarab-server against a local kind cluster.
• cargo (Rust toolchain, see rust-toolchain.toml): the server is built from source.
• python3: the demo submits a pipeline over the REST API.
• just: the task runner.

Bring up the stack

just up      # Postgres + MinIO + kind + scarab-server (background)

just up starts Postgres and MinIO (via deploy/local-proc/compose.yaml), creates a kind cluster (deploy/local-proc/kind.yaml), and runs scarab-server in converged mode against them.

Submit a pipeline and watch it complete

just demo    # submit a one-step pipeline and watch it run to completion

This posts a pipeline to the running server and follows it to a terminal state, the walking skeleton that survives killing the control plane mid-run.

Iterate

just serve   # run scarab-server in the FOREGROUND against the dev stack (Ctrl-C to stop)
just logs    # tail the background server log
just docs    # serve this documentation site locally
just down    # tear the whole stack down

The other mode: Helm inside the cluster

just up runs the server as a host process (kind for step Pods). For the real path inside the cluster (scarab-server deployed via the Helm chart on colima, with Postgres and MinIO inside the cluster), use just local-helm (just local-helm local builds from the tree; just local-helm sha-<sha> pins a published build). See Installation.

See the UI

just ui starts the SolidJS web UI (Vite on http://localhost:5173), which proxies /v1 to the running server. It’s an early scaffold today. The rich UI, with a live DAG and logs streamed over SSE, is a follow-up.

What just happened

The server persisted every step transition to Postgres as a durable state machine. Kill the control plane mid-run and bring it back: the run resumes from where it stopped rather than restarting. That durability contract is the whole point.

References

• ADR-0002, Durability model: durable DAG orchestrator + at-least-once steps