Continuum

English | 简体中文

CIHex.pmDocumentationLicense

Continuum is a durable execution engine for Elixir. Write a multi-step business process as straight-line Elixir code; failures, restarts, and node death cause the workflow to resume exactly where it left off with identical state, by replaying its event history through the same pure orchestration code.

It is OTP-native and Postgres-backed — no separate cluster service, no paid SaaS dependency, no polyglot SDK. Continuum lives in your application's supervision tree and uses the database you already run.

Why Continuum

Continuum is to durable execution what Phoenix is to web and Oban is to job queues: the obvious answer to "how do I run a multi-step business process that survives a crash?" for Elixir-first teams.

Deliberately out of scope: polyglot SDKs, cross-language activities, a separate cluster service, and Kubernetes operators.

Quickstart

defmodule MyApp.OrderFlow do

  use Continuum.Workflow, version: 1



  def run(%{order_id: id, items: items}) do

    {:ok, validated} = activity Validation.check(items)



    {:ok, charge} =

      activity Payments.charge(id, validated.total),

        retry: [max_attempts: 5, backoff: :exponential],

        compensate: {Payments, :refund, [id]}



    case await signal(:fraud_review, timeout: hours(24)) do

      :approved -> activity Fulfillment.ship(id)

      :rejected ->

        compensate(charge)

        {:error, :fraud_rejected}



      :timeout  -> activity Fulfillment.ship(id)

    end

  end

end

{:ok, run_id} = Continuum.start(MyApp.OrderFlow, %{order_id: "o1", items: [...]})



# from anywhere — durable mailbox, survives restarts

:ok = Continuum.signal(run_id, :fraud_review, :approved)



# blocks via PubSub with poll fallback

{:ok, %{state: :completed, result: result}} = Continuum.await(run_id, 30_000)

Installation

Add Continuum and a Postgres driver to your dependencies:

def deps do

  [

    {:continuum, "~> 0.5"},

    {:postgrex, "~> 0.19"}

  ]

end

Point Continuum at your repo:

# config/config.exs

config :continuum, repo: MyApp.Repo, journal: Continuum.Runtime.Journal.Postgres

Generate and run the migration:

mix continuum.gen.migration --repo MyApp.Repo

mix ecto.migrate

Add Continuum's runtime children to your supervision tree, after your repo:

def start(_type, _args) do

  children =

    [

      MyApp.Repo,

      {Phoenix.PubSub, name: MyApp.PubSub}

    ] ++

      Continuum.children() ++

      [MyAppWeb.Endpoint]



  Supervisor.start_link(children, strategy: :one_for_one, name: MyApp.Supervisor)

end

Features

Determinism by construction

Durable execution

Workflow composition

Operations & observability

Multi-tenancy & clustering

Testing

Continuum.Test provides an in-memory journal for fast unit tests, Postgres helpers for integration tests, signal/timer injection, golden-history replay, and an opt-in paranoid re-replay mode that catches divergence.

Parent/child example

defmodule MyApp.BatchFlow do

  use Continuum.Workflow, version: 1



  def run(%{order_ids: ids}) do

    ids

    |> Enum.map(fn id ->

      start_child MyApp.OrderFlow, %{order_id: id}, id: id

    end)

    |> Enum.map(&await_child/1)

  end

end

Observer

The optional Continuum.Observer LiveView lists runs, renders the journal event timeline per run, and exposes operator actions for cancelling a run and sending a signal. It is mounted from a host Phoenix router and ships no authentication of its own — wrap it in your existing admin pipeline.

Continuum Observer runs index

import Continuum.Observer.Router



scope "/admin" do

  pipe_through [:browser, :authenticate_admin]



  continuum_observer "/continuum", instance: :myapp_continuum

end

To see the UI locally, the repo bundles a self-contained demo:

docker compose up -d

MIX_ENV=test iex -S mix run dev/observer_demo.exs

# then open http://localhost:4000/continuum

The demo seeds three runs in different states and prints iex helpers for spawning more, sending signals, and cancelling. See guides/observer.md for production mount instructions.

Documentation

Full docs are published on HexDocs. The guides cover the entire surface:

See examples/continuum_example_orders for a Phoenix app exercising activity → signal/timeout → compensation, parent/child batches, continue_as_new, per-workflow snapshots, namespaces, the Observer, and OpenTelemetry.

Upgrading? See the migration guides .

Status

Continuum is v0.5 (pre-1.0). The durable engine, determinism enforcement, workflow composition, observability, and clustering surface are implemented and covered by tests, including crash-resume, lease-fencing races, and property-based replay. APIs may still change before 1.0 — pin to a specific 0.x in production. See CHANGELOG.md for release history.

Development

A docker-compose.yml brings up Postgres for local development and tests.

mix deps.get

docker compose up -d                  # Postgres on localhost:5432

mix compile --warnings-as-errors

mix test                              # unit + integration suite

mix test.cluster                      # real :peer cluster tests (run separately)

mix format

License

Copyright 2026 The Continuum Authors. (yyeger)

Licensed under the Apache License, Version 2.0.