Resonate Rust SDK

The Resonate Rust SDK lets you build reliable, distributed applications using Rust's async/await model. Built on tokio, it gives you durable execution with automatic recovery, idempotency, and distributed coordination — without the infrastructure headache.

Resonate is a durable execution engine. Write your business logic as normal async Rust functions, annotate them with #[resonate_sdk::function], and Resonate handles retries, recovery, and replay. If your process crashes mid-workflow, execution resumes from the last checkpoint — not from the beginning.

Links

• Evaluate Resonate
• Example applications
• Skill guide (Rust SDK)
• Join the Discord

Installation

cargo add resonate-sdk tokio --features tokio/full
cargo add serde --features derive

Or add to your Cargo.toml directly:

[dependencies]
resonate-sdk = "0.1"
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }

To track the latest development version, use a git dependency:

[dependencies]
resonate-sdk = { git = "https://github.com/resonatehq/resonate-sdk-rust", branch = "main" }

Quick example

use resonate_sdk::prelude::*;
use serde::{Deserialize, Serialize};

// A workflow function — receives &Context for durable sub-task orchestration.
#[resonate_sdk::function]
async fn greet(ctx: &Context, name: String) -> Result<String> {
    let greeting = ctx.run(format_greeting, name).await?;
    Ok(greeting)
}

// A leaf function — pure computation, no Context needed.
#[resonate_sdk::function]
async fn format_greeting(name: String) -> Result<String> {
    Ok(format!("Hello, {}!", name))
}

#[tokio::main]
async fn main() {
    let resonate = Resonate::new(ResonateConfig {
        url: Some("http://localhost:8001".into()),
        ..Default::default()
    });

    resonate.register(greet).unwrap();
    resonate.register(format_greeting).unwrap();

    let result: String = resonate
        .run("greet-1", greet, "World".into())
        .await
        .expect("workflow failed");

    println!("{result}");
}

Run a server with resonate dev (install via brew install resonatehq/tap/resonate), then cargo run.

Parallel execution

Use .spawn() to fan out durable tasks in parallel:

#[resonate_sdk::function]
async fn fan_out(ctx: &Context) -> Result<Vec<String>> {
    // Spawn tasks in parallel
    let h1 = ctx.run(process, "alpha".into()).spawn().await?;
    let h2 = ctx.run(process, "beta".into()).spawn().await?;
    let h3 = ctx.run(process, "gamma".into()).spawn().await?;

    // Collect results — each is individually durable
    let r1 = h1.await?;
    let r2 = h2.await?;
    let r3 = h3.await?;

    Ok(vec![r1, r2, r3])
}

If the process crashes after h1 completes but before h2 finishes, only h2 and h3 re-execute on recovery. h1's result is replayed from the durable log.

API overview

Entry point

Client APIs (Ephemeral World)

Context APIs (Durable World)

All builders support .await (sequential) or .spawn().await (parallel, returns a handle).

Builder options

All builders support:

• .timeout(Duration) — execution timeout
• .target(&str) — target worker group

Client-side builders (resonate.run(), resonate.rpc()) additionally support:

• .version(u32) — version tag
• .tags(HashMap<String, String>) — metadata tags

Function annotation

#[resonate_sdk::function] detects the function kind from the first parameter:

Environment variables

Constructor arguments take precedence over environment variables. If no URL is configured, the SDK runs in local mode (in-memory, no server required).

License

Apache-2.0