Temporal vs Resonate

Side-by-side comparison of Temporal and Resonate — programming model, deployment, and guarantees — to help you evaluate Resonate as a Temporal alternative.

SDK version

This page reflects @resonatehq/sdk v0.11.4 (TypeScript, current on npm), resonate-sdk v0.7.4 (Python), resonate-sdk v0.6.0 (Rust, on crates.io), and the Resonate Go SDK 0.1.0.

Are you coming from Temporal?

This guide is meant to help you understand the differences and similarities between Temporal and Resonate — concept by concept, with side-by-side migration code in every SDK.

About the code

Temporal blocks below are excerpted from the official temporalio/samples-{typescript,python,go} repos and the Rust SDK's in-repo examples (temporalio/sdk-rust/crates/sdk/examples/) — trimmed for focus, elisions marked, never rewritten. Resonate blocks come from the examples library, pinned to the latest released SDKs. Some patterns don't have a Resonate example in every language yet; those gaps are noted inline.

Durability#

One of Temporal’s core value propositions is Durable Execution. Essentially, Durable Execution is the ability for a function to recover in another process after a hard failure and resume from where it left off.

Resonate also provides Durable Execution.

In Resonate, if your process crashes, your function can recover and resume from where it left off in another process.

Programming model#

If you have experience with Temporal, then you are familiar with thinking in terms of Workflows and Activities.

Resonate does not have proprietary function types such as Workflows and Activities; it just uses functions.

Here is the most basic migration — a Workflow that calls one Activity, and the equivalent Resonate function calling one step:

Temporalsamples-python/hello/hello_activity.py·python

@activity.defn
def compose_greeting(input: ComposeGreetingInput) -> str:
    return f"{input.greeting}, {input.name}!"

@workflow.defn
class GreetingWorkflow:
    @workflow.run
    async def run(self, name: str) -> str:
        return await workflow.execute_activity(
            compose_greeting,
            ComposeGreetingInput("Hello", name),
            start_to_close_timeout=timedelta(seconds=10),
        )

Resonateexample-hello-world-py/main.py·python

def bar(_: Context, greetee: str) -> str:
    return f"Hello {greetee} from bar!"

@resonate.register
async def foo(ctx: Context, greetee: str) -> str:
    bar_greeting = await ctx.run(bar, greetee=greetee)
    return bar_greeting

See it in action: example-hello-world-py

Temporalsamples-typescript/hello-world/src/workflows.ts + activities.ts·typescript

// activities.ts
export async function greet(name: string): Promise<string> {
  return `Hello, ${name}!`;
}

// workflows.ts
const { greet } = proxyActivities<typeof activities>({
  startToCloseTimeout: '1 minute',
});

export async function example(name: string): Promise<string> {
  return await greet(name);
}

Resonateexample-hello-world-ts/index.ts·typescript

async function bar(_: Context, greetee: string): Promise<string> {
  return `Hello ${greetee} from bar!`;
}

function* foo(ctx: Context, greetee: string): Generator<any, string, any> {
  const barGreeting = yield* ctx.run(bar, greetee);
  return barGreeting;
}

const fooR = resonate.register("foo", foo);

See it in action: example-hello-world-ts

Temporalsdk-rust/crates/sdk/examples/hello_world/workflows.rs·rust

#[workflow]
pub struct HelloWorldWorkflow;

#[workflow_methods]
impl HelloWorldWorkflow {
    #[run]
    pub async fn run(ctx: &mut WorkflowContext<Self>, name: String) -> WorkflowResult<String> {
        ctx.start_activity(
            GreetingActivities::greet, name,
            ActivityOptions::start_to_close_timeout(Duration::from_secs(10)),
        ).await
    }
}

#[activities]
impl GreetingActivities {
    #[activity]
    pub async fn greet(_ctx: ActivityContext, name: String) -> Result<String, ActivityError> {
        Ok(format!("Hello, {}!", name))
    }
}

Resonateexample-hello-world-rs/src/main.rs·rust

#[resonate::function]
async fn greet(ctx: &Context, name: String) -> Result<String> {
    let greeting = ctx.run(format_greeting, name).await?;
    Ok(greeting)
}

#[resonate::function]
async fn format_greeting(name: String) -> Result<String> {
    Ok(format!("Hello, {name}!"))
}

See it in action: example-hello-world-rs

Temporalsamples-go/helloworld/helloworld.go·go

func Workflow(ctx workflow.Context, name string) (string, error) {
    ao := workflow.ActivityOptions{StartToCloseTimeout: 10 * time.Second}
    ctx = workflow.WithActivityOptions(ctx, ao)

    var result string
    err := workflow.ExecuteActivity(ctx, Activity, name).Get(ctx, &result)
    return result, err
}

func Activity(ctx context.Context, name string) (string, error) {
    return "Hello " + name + "!", nil
}

Resonateexample-hello-world-go/main.go·go

func greet(_ *resonate.Context, args GreetArgs) (string, error) {
    return fmt.Sprintf("hello, %s!", args.Name), nil
}

func main() {
    r, _ := resonate.New(resonate.Config{URL: "http://localhost:8001"})
    defer r.Stop()

    greetFn, _ := resonate.Register(r, "greet", greet)
    h, _ := greetFn.Run(ctx, id, GreetArgs{Name: "world"})
    out, _ := h.Result(ctx)
    fmt.Println(out)
}

See it in action: example-hello-world-go

@resonate.register (and its per-SDK equivalents) replaces the @workflow.defn / @activity.defn split. A step is just a function passed to ctx.run — no Task Queue wiring, no mandatory timeout policy.

Resonate promotes a procedural programming model that enables you to compose functions indefinitely and recursively.

Consider this factorial example. How might you implement it in Temporal?

python

@resonate.register
async def factorial(ctx: Context, n: int) -> int:
    if n <= 1:
        return 1
    r = await ctx.options(target="factorial-workers").rpc("factorial", n - 1)
    return n * r


async def main():
    handle = resonate.run("factorial-5", factorial, n=5)
    result = await handle.result()
    print(result)

See it in action: example-recursive-factorial-py

typescript

function* factorial(ctx: Context, n: number): Generator<any, number, any> {
  if (n <= 1) {
    return 1;
  }
  const result = yield* ctx.rpc(
    "factorial",
    n - 1,
    ctx.options({ target: "poll://any@factorial-workers" }),
  );

  return n * result;
}

const factorialR = resonate.register("factorial", factorial);

async function main() {
  const result = await factorialR.run("factorial-5", 5);
  console.log(result);
}

See it in action: example-recursive-factorial-ts

rust

#[resonate::function]
async fn factorial(ctx: &Context, n: u64) -> Result<u64> {
    if n <= 1 {
        return Ok(1);
    }
    let result: u64 = ctx
        .rpc("factorial", n - 1)
        .target("poll://any@factorial-workers")
        .await?;

    Ok(n * result)
}

#[tokio::main]
async fn main() {
    let resonate = Resonate::local();
    resonate.register(factorial).unwrap();

    let result: u64 = resonate.run("factorial-5", factorial, 5).await.unwrap();
    println!("{result}");

    resonate.stop().await.unwrap();
}

See it in action: example-recursive-factorial-rs

type Args struct {
	N int `json:"n"`
}

func factorial(ctx *resonate.Context, args Args) (int, error) {
	if args.N <= 1 {
		return 1, nil
	}
	f, err := ctx.RPC("factorial", Args{N: args.N - 1})
	if err != nil {
		return 0, err
	}
	var result int
	if err := f.Await(&result); err != nil {
		return 0, err
	}
	return args.N * result, nil
}

func main() {
	r, _ := resonate.New(resonate.Config{URL: "http://localhost:8001"})
	defer func() { _ = r.Stop() }()

	factorialFn, _ := resonate.Register(r, "factorial", factorial)

	h, _ := factorialFn.Run(context.Background(), "factorial-5", Args{N: 5})
	result, _ := h.Result(context.Background())
	fmt.Println(result)
}

See it in action: example-recursive-factorial-go

In Temporal, recursion like this means child workflows (executeChild / ExecuteChildWorkflow) — each a separately registered Workflow type, each accruing its own event history. That history accounting is what makes deep or unbounded recursion awkward in Temporal; in Resonate a function simply calls itself by its registered name (ctx.run / ctx.rpc), with no separate type and no per-child history to manage.

Zero-dependency development#

In Temporal, you always need a Temporal Service for your Worker to connect to, whether that is a local development instance or a production instance.

Resonate offers a zero-dependency development experience, where a Worker (single node application) can run without connecting to a Resonate Server.

python

from resonate.resonate import Resonate

resonate = Resonate()  # no url, no RESONATE_URL/RESONATE_HOST env -> in-memory, no server

#...

typescript

import { Resonate } from "@resonatehq/sdk";

const resonate = new Resonate();

// ...

rust

use resonate::prelude::*;

let resonate = Resonate::local();

// ...

import (
	resonate "github.com/resonatehq/resonate-sdk-go"
	"github.com/resonatehq/resonate-sdk-go/localnet"
)

// Local development mode runs the server state machine in-process,
// using in-memory storage for promises and tasks.
pid := "dev-worker"
r, _ := resonate.New(resonate.Config{
	Network:   localnet.NewLocal("default", &pid),
	Heartbeat: resonate.NoopHeartbeat{}, // localnet has no lease endpoint to heartbeat against
})

// ...

Human-in-the-loop#

In Temporal, you can use Signals to unblock a Workflow Execution with input from a human — define a signal, register a handler, flip a flag, and await a condition:

Temporalsamples-python/hello/hello_signal.py·python

@workflow.defn
class GreetingWorkflow:
    @workflow.run
    async def run(self) -> List[str]:
        greetings: List[str] = []
        while True:
            await workflow.wait_condition(
                lambda: not self._pending_greetings.empty() or self._exit)
            # …drain self._pending_greetings into greetings…
            if self._exit:
                return greetings

    @workflow.signal
    def exit(self) -> None:
        self._exit = True

Unblock it externally·python

await handle.signal(GreetingWorkflow.exit)

Temporalsamples-typescript/signals-queries/src/workflows.ts·typescript

export const unblockSignal = wf.defineSignal('unblock');
export const isBlockedQuery = wf.defineQuery<boolean>('isBlocked');

export async function unblockOrCancel(): Promise<void> {
  let isBlocked = true;
  wf.setHandler(unblockSignal, () => void (isBlocked = false));
  wf.setHandler(isBlockedQuery, () => isBlocked);
  await wf.condition(() => !isBlocked);              // blocks here
}

Unblock it externally·typescript

await handle.signal(unblockSignal);

Temporalsdk-rust/crates/sdk/examples/message_passing/workflows.rs·rust

#[workflow]
pub struct MessagePassingWorkflow { counter: i32 }

#[workflow_methods]
impl MessagePassingWorkflow {
    #[run]
    pub async fn run(ctx: &mut WorkflowContext<Self>, target: i32) -> WorkflowResult<i32> {
        ctx.wait_condition(|s| s.counter >= target).await;   // blocks here
        Ok(ctx.state(|s| s.counter))
    }

    #[signal]
    pub fn increment(&mut self, _ctx: &mut SyncWorkflowContext<Self>, amount: i32) {
        self.counter += amount;
    }
}

Unblock it externally by sending the increment signal. The Resonate Rust equivalent is in the tabs below.

Temporalsamples-go/await-signals/await_signals_workflow.go (excerpt)·go

func AwaitSignalsWorkflow(ctx workflow.Context) (err error) {
    var a AwaitSignals
    workflow.Go(ctx, a.Listen)                     // signal handlers in a goroutine
    err = workflow.Await(ctx, func() bool {        // blocks until Signal1 arrives
        return a.Signal1Received
    })
    // … then awaits Signal2 and Signal3 via workflow.AwaitWithTimeout …
    return
}
// a.Listen: selector.AddReceive(workflow.GetSignalChannel(ctx, "Signal1"), …)

With Resonate, you can achieve the same effect by creating a Durable Promise that is not attached to any function execution, and then await on it. Then, you can resolve it from anywhere, optionally sending data into the function while doing so.

python

# worker.py
@resonate.register
async def foo(ctx: Context) -> str:
    blocking_promise = ctx.promise()
    promise_id = await blocking_promise.id()
    # ... hand promise_id to the human, e.g. via a leaf that emails/pages them ...
    # wait for the promise to be resolved
    data = await blocking_promise
    # ...
    return data

See it in action: example-human-in-the-loop-py

python

# client.py
from resonate.types import Value

async def main():
    # ...
    await resonate.promises.resolve(promise_id, Value(data=data))

typescript

function* foo(context: Context) {
  const blockingPromise = yield* context.promise();
  // ...
  // wait for the promise to be resolved
  data = yield* blockingPromise;
  // ...
}

See it in action: example-human-in-the-loop-ts

typescript

// client.ts
// promises.resolve does not run the codec, so encode the payload the way the
// codec expects: JSON → base64 string in the `data` field.
const data = Buffer.from(JSON.stringify(value), "utf8").toString("base64");
await resonate.promises.resolve(promiseId, { data });

rust

// worker.rs
#[resonate::function]
async fn foo(ctx: &Context) -> Result<()> {
    // Latent durable promise — no function backing it. Resolved externally.
    let blocking_promise = ctx.promise::<bool>().create()?;
    let _promise_id = blocking_promise.id().await?;
    // ...
    // suspend until the promise is resolved (survives crashes)
    let _data = blocking_promise.await?;
    // ...
    Ok(())
}

See it in action: example-human-in-the-loop-rs

rust

use resonate::types::Value;

// resolve from anywhere
resonate
    .promises
    .resolve(&promise_id, Value::from_serializable(data)?)
    .await?;

func foo(ctx *resonate.Context, _ struct{}) (string, error) {
	// Latent durable promise — no function backing it. Resolved externally.
	f, err := ctx.Promise()
	if err != nil {
		return "", err
	}
	promiseID := f.ID() // hand this ID to whoever resolves it
	_ = promiseID
	// ...
	// Await suspends the workflow until the promise settles (survives crashes).
	var data string
	if err := f.Await(&data); err != nil {
		return "", err
	}
	// ...
	return data, nil
}

See it in action: example-human-in-the-loop-go

shell

# Resolve the latent promise from outside the running program — e.g. a human
# approving the request via the Resonate CLI or server API.
# `data` must be a JSON-quoted string: the CLI base64-encodes it before storing,
# and the worker's codec base64-decodes then JSON-parses it. A bare "approved"
# would decode to the bytes `approved`, which is not valid JSON (DecodingError).
resonate promises resolve <promise-id> --value '{"headers": {}, "data": "\"approved\""}'

Durable timers#

Temporal's sleep-for-days shows a durable timer racing against a signal. Resonate's equivalent is ctx.sleep — a single durable promise that survives crashes.

Watch the time units

Temporal accepts human strings ('30 days') or a timedelta. Resonate's units differ per SDK: TypeScript takes milliseconds, Python takes a timedelta, Go and Rust take a native Duration. Converting '30 days' for the TS SDK means 30 * 24 * 60 * 60 * 1000.

Temporalsamples-python/sleep_for_days/workflows.py·python

# raced against a completion signal inside asyncio.wait(...):
await workflow.sleep(timedelta(days=30))   # timedelta

Resonateexample-durable-sleep-py/worker.py·python

@resonate.register
async def sleeping_workflow(ctx: Context, wf_id: str, secs: float) -> str:
    await ctx.sleep(timedelta(seconds=secs))    # timedelta, not a bare number
    return f"Workflow {wf_id} slept for {secs} seconds."

See it in action: example-durable-sleep-py

Temporalsamples-typescript/sleep-for-days/src/workflows.ts·typescript

await Promise.race([sleep('30 days'), condition(() => isComplete)]);

Resonateexample-durable-sleep-ts/worker.ts·typescript

function* sleepingWorkflow(ctx: Context, ms: number) {
  yield* ctx.sleep(ms);                     // milliseconds
  return `Slept for ${ms / 1000} seconds`;
}

See it in action: example-durable-sleep-ts

Temporalsdk-rust/crates/sdk/examples/timer_examples/workflows.rs·rust

#[run]
pub async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<String> {
    ctx.timer(Duration::from_secs(1)).await;   // durable timer
    // …select! race + cancellable-timer demo omitted…
}

Resonateexample-durable-sleep-rs/src/bin/worker.rs·rust

#[resonate::function]
async fn sleeping_workflow(ctx: &Context, secs: u64) -> Result<String> {
    ctx.sleep(Duration::from_secs(secs)).await?;   // std::time::Duration
    Ok(format!("Slept for {secs} seconds"))
}

See it in action: example-durable-sleep-rs

Temporalsamples-go/sleep-for-days/sleepfordays_workflow.go·go

selector := workflow.NewSelector(ctx)
selector.AddFuture(workflow.NewTimer(ctx, time.Hour*24*30), func(f workflow.Future) {})
selector.AddReceive(sigChan, func(c workflow.ReceiveChannel, more bool) { isComplete = true })
selector.Select(ctx)

Resonateexample-durable-sleep-go/main.go·go

func sleepingWorkflow(ctx *resonate.Context, args SleepArgs) (string, error) {
    d := time.Duration(args.Secs) * time.Second
    f, err := ctx.Sleep(d)                   // time.Duration
    if err != nil {
        return "", err
    }
    if err := f.Await(nil); err != nil {     // Await(nil) — no return value
        return "", err
    }
    return fmt.Sprintf("slept for %d second(s)", args.Secs), nil
}

See it in action: example-durable-sleep-go

Fan-out / fan-in#

Start many units of work in parallel, then join all results. In Temporal you spawn activities (or children) without awaiting, then await them together. Resonate is the same shape: start each with a non-blocking invocation, then await each promise.

Spawning differs per SDK

The non-blocking spawn step — TS ctx.beginRun, Rust .spawn(), Go ctx.RPC — each returns a future immediately; you await them after all are started. Python needs no separate spawn call: ctx.run/ctx.rpc already return a future the moment they're called, so fanning out is just calling several before awaiting any of them.

Temporalsamples-python/hello/hello_parallel_activity.py·python

results = await asyncio.gather(
    workflow.execute_activity(say_hello_activity, "user1", start_to_close_timeout=timedelta(seconds=5)),
    workflow.execute_activity(say_hello_activity, "user2", start_to_close_timeout=timedelta(seconds=5)),
    # …user3 … user5 …
)

Resonateexample-fan-out-fan-in-py/workflow.py·python

# fan-out: ctx.run returns a future immediately, without blocking
email_f = ctx.run(send_email, event)
sms_f = ctx.run(send_sms, event)
# fan-in: await each
email = await email_f
sms = await sms_f

See it in action: example-fan-out-fan-in-py

Temporalsamples-typescript/child-workflows/src/workflows.ts·typescript

const responseArray = await Promise.all(
  names.map((name) => executeChild(childWorkflow, { args: [name] })),
);

Resonateexample-fan-out-fan-in-ts/src/workflow.ts·typescript

// fan-out: beginRun returns a future immediately
const emailFuture = yield* ctx.beginRun(sendEmail, event);
const smsFuture   = yield* ctx.beginRun(sendSms, event);
// fan-in: await each
const results = [yield* emailFuture, yield* smsFuture];

See it in action: example-fan-out-fan-in-ts

Temporal Rust has no dedicated fan-out sample — its child_workflows example starts children sequentially. The Resonate Rust equivalent fans out with .spawn():

Resonateexample-fan-out-fan-in-rs/src/main.rs·rust

// fan-out: .spawn() returns a handle immediately
let h1 = ctx.run(process_item, items[0].clone()).spawn()?;
let h2 = ctx.run(process_item, items[1].clone()).spawn()?;
// fan-in: await each
let r1 = h1.await?;
let r2 = h2.await?;

See it in action: example-fan-out-fan-in-rs

Temporalsamples-go/splitmerge-future/splitmerge_workflow.go·go

var results []workflow.Future
for i := 0; i < processorCount; i++ {                    // fan-out
    results = append(results, workflow.ExecuteActivity(ctx, ChunkProcessingActivity, i+1))
}
for i := 0; i < processorCount; i++ {                    // fan-in
    var r ChunkResult
    _ = results[i].Get(ctx, &r)
}

Resonateexample-fan-out-fan-in-go/main.go·go

futures := make([]*resonate.Future, 0, len(args.Channels))
for _, ch := range args.Channels {                       // fan-out
    f, _ := ctx.RPC("send", SendArgs{Channel: ch, Message: args.Message})
    futures = append(futures, f)
}
for _, f := range futures {                              // fan-in
    var d Delivery
    _ = f.Await(&d)
}

See it in action: example-fan-out-fan-in-go

Saga / compensation#

A saga runs a sequence of steps and, on failure, runs compensations to undo the completed ones. Temporal's samples register compensation closures and drain them on error. Resonate's examples write the compensation inline in a try/catch, because the durable generator itself is the recovery record.

Temporal — samples-python/message_passing/waiting_for_handlers_and_compensation/workflows.py (the compensation itself is a single activity call):

python

async def workflow_compensation(self):
    await workflow.execute_activity(
        activity_executed_to_perform_workflow_compensation,
        start_to_close_timeout=timedelta(seconds=10),
    )

Resonateexample-money-transfer-py/main.py·python

from resonate.retry import Never


async def transfer_money(ctx: Context, source, target, amount, *, simulate_credit_failure=False):
    transfer_id = ctx.info.id                    # the workflow id is the transfer id
    await ctx.run(apply_entry, f"{transfer_id}-debit", source, -amount, "debit")
    try:
        await ctx.options(retry_policy=Never()).run(
            credit_target, f"{transfer_id}-credit", target, amount,
            fail=simulate_credit_failure,
        )
    except Exception as err:
        # compensate inline
        await ctx.run(apply_entry, f"{transfer_id}-reversal", source, amount, "reversal")
        return {"transfer_id": transfer_id, "status": "compensated", "error": str(err)}
    return {"transfer_id": transfer_id, "status": "committed"}

See it in action: example-money-transfer-py

Temporalsamples-typescript/saga/src/workflows.ts·typescript

const compensations: Compensation[] = [];
try {
  await addAddress({ accountId, address });
  compensations.unshift({ message: '…', fn: () => clearPostalAddresses({ accountId }) });

  // …addClient + its compensation omitted for brevity…
  await addBankAccount({ accountId, details });
  compensations.unshift({ message: '…', fn: () => disconnectBankAccounts({ accountId }) });
} catch (err) {
  await compensate(compensations);   // drains the stack LIFO
  throw err;
}

Resonateexample-saga-booking-ts/src/workflow.ts·typescript

let flightId: string | undefined;
let hotelId: string | undefined;
try {
  flightId = yield* ctx.run(bookFlight, tripId);
  hotelId  = yield* ctx.run(bookHotel, tripId);
  const carId = yield* ctx.run(bookCarRental, tripId, shouldFail,
    ctx.options({ retryPolicy: noRetry }));
  return { status: "success", tripId, flightId, hotelId, carId };
} catch (error) {
  if (hotelId)  yield* ctx.run(cancelHotel, tripId, hotelId);
  if (flightId) yield* ctx.run(cancelFlight, tripId, flightId);
  return { status: "failed", tripId, error: (error as Error).message };
}

Temporal pushes typed Compensation closures onto a stack and drains it in a separate compensate() function. Resonate writes the undo inline in catch, guarded by if (hotelId) — no stack, no helper.

See it in action: example-saga-booking-ts

Temporalsdk-rust/crates/sdk/examples/saga/workflows.rs·rust

#[run]
pub async fn run(ctx: &mut WorkflowContext<Self>, trip_id: String) -> WorkflowResult<Vec<String>> {
    let mut saga = Saga::new(ctx, activity_opts());
    match Self::book_trip(&mut saga, trip_id).await {
        Ok(ids) => Ok(ids),
        Err(e) => { saga.compensate().await; Err(e.into()) }   // run compensations
    }
}
// book_trip: saga.step(book_hotel, …, cancel_hotel).await? — one step + compensation per booking

Resonateexample-money-transfer-rs/src/main.rs·rust

#[resonate::function]
async fn transfer_money(ctx: &Context, args: TransferArgs) -> Result<TransferResult> {
    // Step 1 — debit the source (durable checkpoint).
    ctx.run(apply_entry, EntryArgs {
        op_id: format!("{}-debit", args.transfer_id),
        account: args.source.clone(),
        amount: -args.amount,
        note: "debit".to_string(),
    }).await?;

    // Step 2 — credit the target; on failure, compensate by reversing the debit.
    let credit_outcome = ctx.run(credit_target, CreditArgs {
        op_id: format!("{}-credit", args.transfer_id),
        target: args.target.clone(),
        amount: args.amount,
        fail: args.simulate_credit_failure,
    }).await;

    if let Err(err) = credit_outcome {
        // compensate inline — also durable + idempotent
        ctx.run(apply_entry, EntryArgs {
            op_id: format!("{}-reversal", args.transfer_id),
            account: args.source.clone(),
            amount: args.amount,
            note: "reversal".to_string(),
        }).await?;
        return Ok(TransferResult {
            transfer_id: args.transfer_id,
            status: "compensated".to_string(),
            error: Some(err.to_string()),
        });
    }

    Ok(TransferResult {
        transfer_id: args.transfer_id,
        status: "committed".to_string(),
        error: None,
    })
}

See it in action: example-money-transfer-rs

Temporal — samples-go/saga/workflow.go (uses stacked defer for LIFO compensation):

func TransferMoney(ctx workflow.Context, td TransferDetails) (err error) {
    err = workflow.ExecuteActivity(ctx, Withdraw, td).Get(ctx, nil)
    if err != nil { return err }
    defer func() {
        if err != nil {
            errC := workflow.ExecuteActivity(ctx, WithdrawCompensation, td).Get(ctx, nil)
            err = multierr.Append(err, errC)
        }
    }()

    err = workflow.ExecuteActivity(ctx, Deposit, td).Get(ctx, nil)
    // …Deposit's own defer-compensation + a final failing step omitted for brevity…
    return err
}

No Resonate Go saga example yet

There is currently no example-saga-booking-go or example-money-transfer-go. The migration maps the same way as the other languages — ctx.Run(...) per step, compensation inline in the error branch — but until a Go example ships, treat this cell as a known gap rather than a worked sample.

Long-running loops#

Temporal's continue-as-new exists to reset a Workflow's event history before it hits the size limit. Resonate has no per-execution event history that grows unboundedly, so for finite loops you just… loop.

One production caveat

For bounded loops, the Resonate example is a plain while/for — no continue-as-new needed. But for truly unbounded loops, a naive loop in a single durable invocation accumulates child promises that get re-walked on replay; once replay time exceeds the task lease, the worker loop stalls and stops making progress. The production-correct pattern is ctx.detached tail-recursion (the SDK docblock calls this out explicitly). The shipped examples below use the naive loop, which is correct for demos and bounded counts; reach for detached when the loop is genuinely infinite.

Temporalsamples-typescript/continue-as-new/src/workflows.ts·typescript

export async function loopingWorkflow(iteration = 0): Promise<void> {
  if (iteration === 10) return;
  await sleep(1000);
  await continueAsNew<typeof loopingWorkflow>(iteration + 1);
}

Resonateexample-infinite-workflow-ts/src/workflow.ts·typescript

function* healthMonitor(ctx: Context, config: MonitorConfig): Generator<any, MonitorResult, any> {
  let iteration = 0;
  // No continueAsNew — Resonate has no history limit.
  while (iteration < config.maxIterations) {
    iteration++;
    yield* ctx.run(checkAllServices, config.services, iteration);
    if (iteration < config.maxIterations) yield* ctx.sleep(config.intervalMs);
  }
  // ...
}

For a genuinely unbounded loop, split per-iteration with ctx.detached (from the SDK docblock):

typescript

function* playGame(ctx: Context, n: number) {
  // ...one iteration of work...
  yield* ctx.detached(playGame, n + 1);   // tail call, then return
}

See it in action: example-infinite-workflow-ts

Temporalsamples-go/child-workflow-continue-as-new/child_workflow.go·go

func SampleChildWorkflow(ctx workflow.Context, totalCount, runCount int) (string, error) {
    if runCount <= 0 {
        return "", errors.New("invalid run count")
    }
    totalCount++
    runCount--
    if runCount == 0 {
        return fmt.Sprintf("completed after %v runs", totalCount), nil
    }
    return "", workflow.NewContinueAsNewError(ctx, SampleChildWorkflow, totalCount, runCount)
}

Resonateexample-infinite-workflow-go/main.go·go

func heartbeatWorkflow(ctx *resonate.Context, args WorkflowArgs) (WorkflowResult, error) {
    for i := 0; args.Iterations == 0 || i < args.Iterations; i++ {
        tickF, err := ctx.Run(heartbeatTick, TickArgs{Tick: i + 1})
        if err != nil { return WorkflowResult{}, err }
        if err := tickF.Await(nil); err != nil { return WorkflowResult{}, err }

        sleepF, err := ctx.Sleep(time.Duration(args.IntervalSec) * time.Second)
        if err != nil { return WorkflowResult{}, err }
        if err := sleepF.Await(nil); err != nil { return WorkflowResult{}, err }
    }
    return WorkflowResult{Ticks: args.Iterations}, nil
}

The Go SDK also has ctx.Detached for the unbounded case; the shipped example uses a plain for loop.

See it in action: example-infinite-workflow-go

No Resonate Python infinite-workflow example yet

example-infinite-workflow-py does not exist. Temporal's source is samples-python/hello/hello_continue_as_new.py (workflow.continue_as_new(iteration + 1)). The Resonate equivalent is a plain while loop (while … : await ctx.run(...) ; await ctx.sleep(...)), with ctx.detached("workflow_name", n + 1) for the unbounded case (detached dispatches by registered name, not by function reference) — but until an example ships, treat this as a known gap.

No Resonate Rust infinite-workflow example yet

example-infinite-workflow-rs does not exist yet. Temporal's Rust continue_as_new example (sdk-rust/crates/sdk/examples/continue_as_new) maps to a plain Resonate loop/while with ctx.detached for the unbounded case — treat the missing Resonate example as a known gap until one ships.

Distributed mutex#

Temporal's mutex sample is ~130 lines across two workflows: a lock-manager workflow with a signal queue, uuid4() release tokens, continueAsNew for history management, and timeout-based deadlock prevention. In Resonate, the generator itself is the lock.

TypeScript only

This pattern currently has a Resonate example in TypeScript only.

Temporalsamples-typescript/mutex/src/workflows.ts (excerpt)·typescript

export async function lockWorkflow(requests = Array<LockRequest>()): Promise<void> {
  setHandler(lockRequestSignal, (req) => { requests.push(req); });
  while (!workflowInfo().continueAsNewSuggested) {
    await condition(() => requests.length > 0);
    const req = requests.shift()!;
    const releaseSignalName = uuid4();
    await getExternalWorkflowHandle(req.initiatorId).signal(lockAcquiredSignal, { releaseSignalName });
    let released = false;
    setHandler(defineSignal(releaseSignalName), () => { released = true; });
    await condition(() => released, req.timeoutMs);   // auto-release on timeout
  }
  if (requests.length > 0) await continueAsNew<typeof lockWorkflow>(requests);
}

Resonateexample-distributed-mutex-ts/src/workflow.ts·typescript

function* exclusiveResourceAccess(ctx: Context, resource: string, workers: string[]): Generator<any, MutexResult, any> {
  const results: WorkResult[] = [];
  // The generator IS the lock: each yield* blocks until the previous completes,
  // so no two workers touch the resource at once.
  for (let i = 0; i < workers.length; i++) {
    const result = yield* ctx.run(accessResource, resource, workers[i]!);
    results.push(result);
  }
  return { resource, processed: results };
}

No lock-manager workflow, no dynamic signal names, no uuid4() tokens, no continueAsNew, no deadlock surface. Sequential yield* ctx.run() calls are serialized by the runtime, with crash recovery built in.

See it in action: example-distributed-mutex-ts

Encryption#

Temporal encrypts payloads with a PayloadCodec (encode/decode over Payload[]), a DataConverter wrapping it, and a separate codec server so the Web UI can decrypt. Resonate takes a single Encryptor as one constructor option; workflow code is untouched.

TypeScript only

This pattern currently has a Resonate example in TypeScript only.

Temporalsamples-typescript/encryption/src/encryption-codec.ts (excerpt)·typescript

export class EncryptionCodec implements PayloadCodec {
  async encode(payloads: Payload[]): Promise<Payload[]> {
    return Promise.all(payloads.map(async (payload) => ({
      metadata: {
        [METADATA_ENCODING_KEY]: encode(ENCODING),
        [METADATA_ENCRYPTION_KEY_ID]: encode(this.defaultKeyId),
      },
      data: await encrypt(temporal.api.common.v1.Payload.encode(payload).finish(), this.keys.get(this.defaultKeyId)!),
    })));
  }
  async decode(payloads: Payload[]): Promise<Payload[]> { /* …mirror of encode… */ }
}

Resonateexample-encryption-ts/src/encryptor.ts + index.ts·typescript

export class AesGcmEncryptor implements Encryptor {
  encrypt(plaintext: Value): Value {
    if (!plaintext.data) return plaintext;
    const iv = randomBytes(IV_LENGTH);
    const cipher = createCipheriv(ALGORITHM, this.rawKey, iv);
    const packed = Buffer.concat([iv, cipher.update(plaintext.data, "utf8"), cipher.final(), cipher.getAuthTag()]);
    return { headers: { ...plaintext.headers, "x-encrypted": "true" }, data: packed.toString("base64") };
  }
  decrypt(ciphertext: Value): Value { /* …mirror of encrypt… */ }
}

// wired once at startup — workflow code is unchanged:
const resonate = new Resonate({ encryptor: new AesGcmEncryptor(ENCRYPTION_KEY, "demo-key-v1") });

Temporal: a PayloadCodec over protobuf Payload[], a DataConverter, and a codec server (~7 files). Resonate: one Encryptor (encrypt(Value): Value) passed as a constructor option. The SDK handles promise-store serialization transparently.

See it in action: example-encryption-ts

What doesn't map yet

A few coverage gaps to plan around: saga in Go has no example yet (example-money-transfer-go / example-saga-booking-go); long-running loops in Python and Rust have no example yet (example-infinite-workflow-py / -rs); distributed mutex and encryption are TypeScript-only. The examples library is the source of truth for what exists today.

Distributed execution#

In Temporal, you can run multiple Workers to handle the load of your application. You use Task Queue Names to identify which Workers should handle which Workflows and Activities.

In Resonate, you can register workers in groups and send invocations to the groups. Resonate will automatically load balance the invocations across the Workers in the group.

python

# worker.py
resonate = Resonate(
    url="http://localhost:8001",
    group="workers",
    # ...
)

See it in action: example-load-balancing-py

python

# client.py
resonate = Resonate(
    url="http://localhost:8001",
    group="client",
)

async def main():
    # ...
    handle = resonate.options(target="poll://any@workers").rpc(promise_id, "function_name", params)
    result = await handle.result()

typescript

// worker.ts
const resonate = new Resonate({
  url: "http://localhost:8001",
  group: "workers",
});

See it in action: example-load-balancing-ts

typescript

//client.ts
const resonate = new Resonate({
  url: "http://localhost:8001",
  group: "client",
});

async function main() {
  resonate.rpc(
    promiseId,
    "function_name",
    params,
    resonate.options({
      target: "poll://any@workers",
    })
  );
}

rust

// worker.rs
let resonate = Resonate::new(ResonateConfig {
    url: Some("http://localhost:8001".into()),
    group: Some("workers".into()),
    ..Default::default()
});

See it in action: example-load-balancing-rs

rust

// client.rs
let resonate = Resonate::new(ResonateConfig {
    url: Some("http://localhost:8001".into()),
    group: Some("client".into()),
    ..Default::default()
});

let result: u64 = resonate
    .rpc(&promise_id, "function_name", params)
    .target("poll://any@workers")
    .await?;

// worker
r, _ := resonate.New(resonate.Config{
	Network: httpnet.NewHTTP("http://localhost:8001", httpnet.HTTPOptions{
		Group: "workers",
	}),
})

See it in action: example-load-balancing-go

// client
r, _ := resonate.New(resonate.Config{
	Network: httpnet.NewHTTP("http://localhost:8001", httpnet.HTTPOptions{
		Group: "client",
	}),
})

h, _ := r.RPC(context.Background(), promiseID, "function_name", params,
	resonate.RPCOptions{Target: "poll://any@workers"})

Decentralized architecture#

In Temporal, any given Workflow Execution is tied to a specific Temporal Service. This forces a star-like topology (centralized system) where all Workers in an application connect to a single Temporal Service.

Additionally, Temporal requires you to size your Temporal Service ahead of time to handle the load of all Workers in your application. If you size it incorrectly, you have to migrate to a new setup, which is a complex process.

Resonate applications, on the other hand, can use multiple Resonate Servers to durably store data (Durable Promises), which can be added dynamically as the application scales.

Centralized Temporal topology: every Worker connects to a single Temporal Service, sized ahead of time.

System complexity#

The level of system complexity is perhaps the biggest difference between Resonate and Temporal.

Resonate at its core believes in simplicity.

This belief drives many of the design decisions in Resonate, and has resulted in a much smaller API surface than Temporal.

This smaller API surface and desire for simplicity have also resulted in a much smaller set of components.

For example, Temporal SDKs run to tens of thousands of lines of code to manage the complexity of their implementation — roughly 48,000 in TypeScript, 69,000 in Python, and 84,000 in Go. The Resonate SDKs are between about 6,000 and 14,000 lines depending on the language. (SDK source only, excluding tests and generated protobuf bindings, measured at the time of writing — clone the repos and check.)

A Temporal Service is a complex system consisting of multiple individual components, each consisting of tens of thousands of lines of code, that need to be configured, deployed, and scaled independently. A Resonate Server, on the other hand, is a single binary that is easy to deploy. And the Resonate system can scale by just adding more Resonate Servers, each with an underlying database.

Additionally, Temporal exposes many complex APIs to the developer which they are required to use for failure detection, load balancing, and more. Resonate's belief in simplicity means that much of this complexity is pushed into the platform and automatically handled for you.

For example, Temporal defines four separate Activity timeouts — schedule-to-close, start-to-close, schedule-to-start, and heartbeat. Only one of them is strictly required (either schedule-to-close or start-to-close), but each covers a different failure mode, so choosing the right combination is a decision you make per Activity. Long-running Activities that need failure detected before the timeout expires record heartbeats themselves, and Workers expose a set of concurrency and rate-limiting knobs to tune.

Resonate exposes a single timeout to the developer — the resolution deadline of the Durable Promise. Failure detection, heartbeating, and load balancing across Workers are handled by the platform: the SDK heartbeats the task lease, the server notices a dead Worker, and the task is re-dispatched without any application code.

Ultimately, as a developer, you will find many areas where Resonate has chosen to promote a specific model for the sake of simplicity, and to avoid indulging in what we believe to be unnecessary complexity.