resonate-basic-durable-world-usage-rust

Implement durable Rust workflows using Resonate's #[resonate::function] attribute.

6|Updated Jan 8, 2026
One-click install
npx skills add https://github.com/resonatehq/resonate-skills --skill resonate-basic-durable-world-usage-rust
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: resonate-basic-durable-world-usage-rust
Source: https://github.com/resonatehq/resonate-skills/tree/main/resonate-basic-durable-world-usage-rust
Command: npx skills add https://github.com/resonatehq/resonate-skills --skill resonate-basic-durable-world-usage-rust

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Rust developers building long-running, crash-safe workflows need a structured pattern to declare durable functions, manage context and results, and ensure checkpoint-replay semantics with a clean API surface.

Core Features & Use Cases

  • Durable function patterns: Workflow, Leaf with Info, and Pure leaf shapes using #[resonate::function].
  • Context APIs: Use ctx.run, ctx.rpc, and ctx.sleep (with Duration) and .spawn() for parallelism, plus builder options for timeouts and routing.
  • Use Case: Orchestrate a multi-step Rust workflow that loads data, processes it in parallel, and handles retries with checkpointing.

Quick Start

Define a simple Rust function annotated with #[resonate::function] to implement a small workflow that calls a leaf with ctx.run and returns a Result.

Frequently Asked Questions about resonate-basic-durable-world-usage-rust

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I write durable functions in Rust for long-running workflows?

Durable functions in Rust use the #[resonate::function] attribute to define Workflow, Leaf with Info, and Pure leaf shapes, providing checkpoint-replay semantics for crash-safe long-running workflows.

What context APIs are available for orchestrating multi-step Rust workflows?

Context APIs for orchestrating Rust workflows include ctx.run for execution, ctx.rpc for remote calls, ctx.sleep with Duration for delays, and .spawn() for parallel processing of multi-step operations.

When do I need durable functions with checkpointing in Rust?

Durable functions with checkpointing are needed when building long-running Rust workflows that require crash safety, automatic retries, and replay semantics to prevent data loss during multi-step processing.

Can I execute parallel tasks in a durable Rust workflow?

Parallel tasks in durable Rust workflows are executed using the .spawn() method on the context API, enabling concurrent operations with checkpointed results for crash-safe parallel processing.

What's the best way to structure a Rust workflow that loads data and processes it in parallel?

The best way to structure parallel Rust workflows is using the Workflow function shape with #[resonate::function], leveraging ctx.run for data loading and .spawn() for parallel processing with automatic checkpointing.

Does the Resonate Rust SDK support timeouts and routing for workflow steps?

The Resonate Rust SDK supports builder options for configuring timeouts and routing on context APIs like ctx.run and ctx.rpc, satisfying v0.1.0 SDK requirements for durable function signatures.