Restate — Durable Execution Engine for Distributed Applications

Introduction

Restate is a durable execution engine that sits between your services and handles the hard parts of distributed computing: retries, state management, idempotency, and workflow coordination. You write ordinary functions in TypeScript, Java, Kotlin, Go, Python, or Rust, and Restate ensures they run to completion even through crashes and restarts.

What Restate Does

• Provides durable execution: functions resume from where they left off after failures
• Manages persistent state per function invocation without an external database
• Handles reliable RPC between services with built-in retries and deduplication
• Supports workflow patterns like sagas, compensation, and human-in-the-loop approvals
• Offers a journal-based execution model that replays on recovery

Architecture Overview

Restate is a single-binary server written in Rust that acts as a proxy between callers and service handlers. It intercepts function calls and journals each step (state reads, RPC calls, side effects) in a local log. On failure, the runtime replays the journal to restore the function to its pre-crash state without re-executing side effects. Services connect to Restate via HTTP and communicate using a lightweight protocol over request-response.

Self-Hosting & Configuration

• Install the server binary via Homebrew, Docker, or download from GitHub Releases
• The server runs as a single process with an embedded log store (RocksDB-based)
• Configure via environment variables or a TOML configuration file
• Services register with Restate by pointing to their HTTP endpoint URL
• The admin API on port 9070 manages deployments, state queries, and invocation inspection

Key Features

• Language-agnostic: SDKs for TypeScript, Java, Kotlin, Go, Python, and Rust
• Journaled execution ensures exactly-once side effects across retries
• Keyed state: per-key persistent state without external databases
• Virtual objects: stateful entities addressed by key, similar to the actor model
• Built-in invocation scheduling with cron-like timers and delayed calls

Comparison with Similar Tools

• Temporal — mature durable workflow platform; Restate is lighter and embeds state in the runtime itself
• Inngest — event-driven durable functions; Restate provides lower-level primitives with more protocol control
• AWS Step Functions — managed workflow service; Restate is self-hosted and language-native
• Dapr — sidecar-based distributed runtime; Restate focuses specifically on durable execution and journaling
• Azure Durable Functions — cloud-tied durable execution; Restate is vendor-neutral and self-hostable

FAQ

Q: How is Restate different from Temporal? A: Restate embeds state and journaling into a lightweight single-binary server, while Temporal requires a cluster with a separate database. Restate aims for simpler operations with a smaller infrastructure footprint.

Q: Do I need to change my code to use Restate? A: You annotate functions with SDK decorators and use the Restate context for state and RPC, but business logic remains ordinary code. No special DSL or workflow language is needed.

Q: What happens when the Restate server restarts? A: In-flight invocations are replayed from the journal. Side effects already executed are skipped, and the function resumes from the last journaled step.

Q: Can Restate run in production? A: Yes. Restate is used in production by multiple companies. The server supports persistent storage and can handle high-throughput workloads.

Sources

• https://github.com/restatedev/restate
• https://restate.dev