Restate: retries that resume instead of starting over, and the state that survives them
Restate is the platform for building resilient applications that tolerate all infrastructure faults w/o the need for a PhD.
At a glance
- What is it?
- Restate is a Rust platform that turns ordinary building blocks into durable, distributed ones: retries that recover partial progress, exactly-once delivery across request-response, one-way messages and scheduled tasks, promises and timers that outlive the process, and per-entity key/value state written back with the execution record. The licence is the detail to read first.
- Who is it for?
- Restate is worth an afternoon if your current failure handling is a retry loop that repeats work, a queue with at-least-once semantics, and a sleep in a request handler. Its primitives attack exactly those three shapes, and the suspend-and-resume behaviour is the part that pays off on serverless targets.
- Can I use it commercially?
- Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
- Is it still maintained?
- Yes. The repository received new commits within the last day.
- What is it written in?
- Mainly Rust, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- restatedev/restate4,702 ★ · +237
| Repository | 2026-09-23 | 2026-11-15 |
|---|---|---|
| restatedev/restate | 4.5k | 4.7k |
237 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
A retry resumes rather than repeating finished work
The central primitive is Reliable Execution. The promise is that code runs to completion, and that when something fails the failure produces a retry which uses the Durable Execution mechanism to recover partial progress instead of starting the handler again from the top. That distinction is the whole argument for the platform, because the usual retry story in application code re-sends a payment, re-charges a card, or re-emits a message every time a downstream call times out. Here, the completed steps are recorded and are not re-executed. What you write is therefore ordinary sequential code with a failure model attached, and the recovery is not something you implement per handler. The cost is that your handlers stop being free functions: they run inside a runtime that owns their progress, which is why the SDKs, and not your own framework, are the integration point.
Exactly-once covers three different invocation shapes
Reliable Communication is the second primitive, and its scope is stated as services communicating with exactly-once semantics whether the exchange is request-response, a one-way message, or a scheduled task. Three shapes matter because each fails differently. A request-response call fails halfway and has to resume at the right step. A one-way message fails in transit and must not be delivered twice to a consumer that has already processed it. A scheduled task fires later, possibly after a deploy, and must still run exactly once. Restate delivers messages reliably and leans on Durable Execution underneath so that neither loss nor duplication occurs. For a reader assessing fit, the practical question is what your current transport promises. A broker with at-least-once delivery puts deduplication on your consumers; moving to Restate moves that responsibility to the platform, which is a real reduction in code but also a real commitment.
Promises and timers outlive the process that created them
Durable Promises and Timers let you register a promise, a future, or a timer with Restate so that they become resilient to failure, covering the cases the page names explicitly: sleep, webhooks and timers. They are recovered across failures, across processes, and across time, which is a stronger claim than keeping a timer in a process that can be killed. The related primitive is Suspending User Code: long running code suspends while it awaits a promise or future and resumes when that promise is resolved. That mechanism is what makes the serverless case work, because a suspended handler is not holding a machine awake, and it is also what makes a three day webhook wait cheap. The trade is that your await points become durable objects in the runtime rather than in-process futures, so the code you write is still sequential but the scheduling is not yours. If you have a handler that sleeps for a day, this is the part that changes its cost profile.
State is attached on invocation and written back on completion
Consistent State is implemented as stateful entities with isolated key/value state per entity. Two details make it more than a cache. Restate persists the key/value updates together with the execution progress, so a state change and the step that caused it cannot diverge. And the state is attached to the request when the invocation arrives and written back when it completes, rather than being read and written by your handler around the work. The stated benefit is efficiency for FaaS deployments, which follows from the second detail: a stateless function receives its state as part of its input. What this costs you is the ordinary key/value discipline. Each entity is isolated, so there is no cross-entity transaction unless the platform provides one, and nothing on this page describes a query interface across entities. If your data model is a wide relational one rather than a set of entities with their own keys, that is the question to ask before adopting the model.
Three published ports and a host gateway in the container command
Pre-built binaries of both the CLI and the server are offered for macOS and Linux, and each has three package manager routes. The server installs with `brew install restatedev/tap/restate-server`, runs with `npx @restatedev/restate-server`, or runs as a container:
docker run --rm -p 8080:8080 -p 9070:9070 -p 9071:9071 \
--add-host=host.docker.internal:host-gateway docker.restate.dev/restatedev/restate:latestThree ports are published, and the `--add-host` line exists so the container can reach services on your machine, which is what a local development setup needs and what you should think twice about elsewhere. The CLI is separate, with `brew install restatedev/tap/restate`, `npm install --global @restatedev/restate` or `npx @restatedev/restate`, and both pieces can also be downloaded as binaries from the release page. The Quickstart claims you can be running within two minutes, and the Tour is the follow-up read for the features. SDKs exist for TypeScript, Java and Kotlin, Python, Go and Rust.
Minor version upgrades move your data for you
Restate follows Semantic Versioning, and the upgrade promise is specific: you can move from a `x.y` release to `x.(y+1)` without performing any manual data migration, because Restate runs the migration for you. That is the number to check first when planning a production rollout, since a runtime that stores its own state is exactly the kind of component that otherwise forces migration downtime. The scope is deliberately limited to the minor version, so a major version is not covered by that sentence. The second half of the versioning story lives in the SDKs rather than the server, and each SDK README carries its own supported version matrix, linked for Java and Kotlin, TypeScript, Go, Python and Rust. Practical consequence: the server upgrade and the SDK upgrade are two separate compatibility decisions, and the matrix you need is the one for your language, not the server's release notes. The current release list shows v1.8.1-hotfix.2, v1.8.1 and v1.7.14.
The Rust workspace has to build on Linux and macOS at once
The repository is a Cargo workspace with a `resolver = "2"`, edition 2024, `rust-version` 1.98.1, and a workspace version that tracks the release line. Members cover the CLI, the crates, the utilities, the server, a `lite` component, benchmarks, and a `tools/` set that includes `restate-doctor`, `restatectl`, a mock service endpoint, an xtask runner and a Wireshark dissector for the service protocol. Default members are a narrower set, so a plain build does not compile everything. The `justfile` explains the awkward parts: on Linux the test feature list can simply be `--all-features`, while on macOS a safe list has to be computed, because `taskdump` only compiles on Linux and Cargo's `dep:` syntax suppresses implicit features. It also derives the Docker image tag from the git branch and short hash, falling back to Sapling, then to `unknown`. That fallback exists so evaluation does not crash inside a Docker build context where the worktree pointer is meaningless.
Editorial conclusion
Restate is worth an afternoon if your current failure handling is a retry loop that repeats work, a queue with at-least-once semantics, and a sleep in a request handler. Its primitives attack exactly those three shapes, and the suspend-and-resume behaviour is the part that pays off on serverless targets. It is a poor fit if your organisation needs an OSI approved licence, since the workspace manifest declares BUSL-1.1, or if you want a single SDK across five languages with one compatibility story, since each SDK keeps its own version matrix. Before you commit, check four things yourself: the licence in the repository root, the supported version matrix in the SDK you intend to use, whether your platform is in the pre-built binary set, which is macOS and Linux, and whether the operational tools named in the workspace, restate-doctor and restatectl, cover the diagnosis you currently do by hand.
Frequently asked questions
what is restate
Restate is a platform for building resilient applications, written in Rust, that provides distributed durable versions of common building blocks: workflows, event processing, microservice orchestration, async tasks and stateful actors. SDKs are published for TypeScript, Java and Kotlin, Python, Go and Rust.
Is Restate open source?
Check before you assume it. The repository is public and the code is readable, but the Cargo workspace declares the licence as BUSL-1.1 rather than an OSI approved licence, so read the LICENSE file at the repository root and decide what that means for your distribution.
restate vs airflow
The project does not publish that comparison on its front page. What it describes is a set of runtime primitives instead of a scheduler: retries that recover partial progress, exactly-once messaging for request-response, one-way messages and scheduled tasks, promises and timers that survive failures, and per-entity key/value state written back with the execution record.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/restatedev-restate)Star history chart for your README
[](https://hysenlabs.com/projects/restatedev-restate)Was this useful?