SUPER DURABLE
Book a call
Menu

DEX / CORE PRODUCT

Dead simple.
More power.

Dex is a durable execution platform built around explicit steps, typed state, and reliable transitions. Write the business logic. Dex keeps it moving.

Start with OSSStar–Explore BYOC

STRUCTURAL PERSISTENCE

Your application's data and actions belong together.

Most backend systems persist data in one place and reconstruct in-flight actions from queues, logs, and bespoke recovery code. Dex models both as one durable flow.

verification.goGO
// Durable data and external input.
var Verified = dex.DefineAttribute[bool]("verified")
var VerifyChannel = dex.DefineChannel[bool]("verify")

func (WaitVerifyStep) WaitFor(...) (dex.Wait, error) {
  return dex.AnyOf(
    VerifyChannel.ForOne(),
    dex.Timer(24*time.Hour),
  ), nil
}

func (WaitVerifyStep) Execute(ctx dex.Context, _ string) (dex.StepDecision, error) {
  if err := Verified.Set(ctx, true); err != nil {
    return dex.StepDecision{}, err
  }
  return dex.GracefulComplete("active"), nil
}
State saved. Timer durable. Progress never lost.

BASIC FEATURES

Durable Variables, branch & loop, backoff retry, sleep.

Familiar control-flow concepts become durable without becoming magical. Every branch, child task, and value has a visible place in the model.

01 / STATE

Durable variables

Declare typed attributes once. Read and write them across Steps without building a separate persistence layer.

02 / BRANCH

Branch & loop

Return a transition to the next Step—or loop back to any earlier Step. The route itself is persisted.

03 / RETRY

Backoff retry

Retry on a durable backoff schedule that survives restarts. Dex automatically displays error messages and details for debugging.

04 / TIMER

Durable timer

Sleep for seconds or months without occupying a worker. Dex persists the timer and resumes the Flow when it fires.

ADVANCED FEATURES

Durable communication, multi-threading, locking, error handling, and more.

01REQUEST / MUTATE

RPC for external read + write

Let external callers read durable state, update it, and trigger the next durable action through a typed RPC boundary.

dex.RPC · InvokeRPC · ReplyAndMove
02INTERNAL / EXTERNAL

Channels for communication

Connect external events and internal durable threads through typed channels that persist every message and wait condition.

DefineChannel · PublishToChannel · Channel.ForOne
03PARALLEL / JOIN

Fan-out + fan-in

Start concurrent durable branches, wait for all—or a chosen quorum—and continue with their collected results.

GoToMulti · Channel.ForN · MovementOf
04RETRY / COMPENSATE

Error handling & SAGA

Model retries, failure transitions, and compensating actions explicitly so recovery becomes part of the durable program.

ExecuteRetry · ProceedToOnExecuteFailure
05PARALLEL / JOIN

Multi-threading

Run multiple durable branches concurrently, coordinate their progress, and join all—or only the results you need.

MovementOf · GoToMulti · Channel.ForN
06LOCK / ATTRIBUTE

Locking

Declare exactly which attributes a Step or RPC protects with LockAttribute and the corresponding lock options.

LockAttribute · ExecuteLockAttributes
07SYNC / DURABLE

Waiting

Wait for a Step, attribute value, channel message, timer, or a composition of conditions without keeping a worker alive.

WaitForStepCompletion · WaitForAttributeEqual
08DATA / SYNC

Storage sync

Automatically synchronize data persisted by Durable Execution with the databases and storage systems your applications already use.

PostgreSQL · S3 · Databricks · Snowflake
09COMPOSABLE / EXTENSIBLE

And more

Combine durable primitives to model the distributed-system behavior your application needs without hiding the control flow.

Timers · signals · observability · more

OPEN CORE. YOUR CHOICE OF CLOUD.

Run it yourself or bring Dex into your environment.

Start from the open-source core, then work with Super Durable when you need a production deployment in your own cloud.

Talk about Dex