Use any database or queue for storage and message transport. Then just write Async Await.
An SDK in your app, one binary beside it.
Server · SDKs — all Apache 2.0
await ctx.run(chargeCard, order)
Async Await · any Resonate SDK
Postgres
the database or queue you already run
HTTP
the transport you already use
A new server for every stack — that’s Distributed Async Await working. Run something else? Bring your own provider.
Durable execution, now on NATS and ScyllaDBThe reliability tax
In a production system, the code that does the actual work is the small part. The rest keeps it alive when something goes wrong — retries, timeouts, idempotency keys, the state machines that remember where a job was when the process died.
By most counts that defensive scaffolding is more than two-thirds of what you ship — and almost none of it is the product. It doesn’t have to be yours to write.
// the product — the actual work
// keeping it alive when something goes wrong
Simple to use
You write ordinary async functions, and that Async Await is the workflow — the shape of your code is the shape of the execution.
Most of what you’ll write rests on three verbs. A workflow that runs forever is a while loop.
// the common surface
ctx.run(step) // execute a step durably
ctx.rpc(fn) // call another function
ctx.sleep('30d') // wait — a second or a month…and ctx.detached when you want to kick something off and not wait on it.
Simple to reason about
The primitive is a durable promise. Everything your code waits on resolves to one — written down the moment it’s made and settled when it’s done.
The promise lives outside the process that made it, in storage you run, so when that machine crashes a new process reads the last promise that was kept and picks up from there.
The process can die.
The promise is still kept.
Runs on your infrastructure
The core server is a single binary. It runs alongside the rest of your stack, and its state lives in your own Postgres — the database you already know how to run and back up. On NATS, an implementation of the protocol runs natively on the broker itself.
When you want to know what a workflow is doing, you ask the CLI. resonate tree prints the whole call graph; resonate promises get inspects a single step. Underneath, the state is rows in your own Postgres, and you can read it with plain SQL.
your stack
▢ resonate — one binary└─ state → your Postgres
$ resonate tree order/42
A promise is written once and updated when it completes, not on every step. The cost of a workflow follows how much it does.
An open protocol
Durable execution is a protocol. Resonate is an implementation of it, open source under Apache 2.0, and you adopt it the way you adopt HTTP or SQL. The servers on NATS and ScyllaDB are separate implementations of the same protocol, source-available under BUSL 1.1.
You can run Resonate, read it, fork it, or build your own. The implementation is tested against the specification — differential testing, deterministic simulation, linearizability checks: how Resonate is tested.
the open specification — programming, execution & system models
We value your privacy
We use strictly necessary cookies to run this site. With your consent we also use Google Analytics to understand traffic. We do not load analytics until you choose to allow it. Privacy Policy.