Durable by design.
Here's how ObzenFlow brings durable execution to streaming workflows. The syntax composes your business logic into a graph of typed stages. The runtime journals every step, and algebraic effects keep replay and resume safe even when the flow calls third-party APIs. Journals run on swappable disk or memory backends, so there's no infrastructure to adopt. On disk, a committed fact survives the process that wrote it. In memory, nothing outlives the process.
Show me the code.
ObzenFlow combines a concise DSL for wiring typed stages into a durable graph with ordinary Rust handlers for your business logic. Bring your own business logic. Wire up your stages then let ObzenFlow add supervision, journaling, and replay.
Stages
A stage is one unit of work in your flow, picked from seven stage types. Each declares exactly what it takes in and every fact it can produce, and your logic plugs in as plain Rust.
Effects
An effect is any call to the outside world, like a payment gateway. A live run makes the call and journals the outcome, and replay and resume read it back instead of calling again.
Topology
The topology wires stages together with typed edges. The compiler checks every edge, so a flow that connects mismatched stages never builds.
flow! {
name: "order_flow",
journals: disk_journals(journal_root),
stages: {
orders = source!(Order => orders_feed);
validate = transform!(
Order -> { ValidOrder, RejectedOrder } => validate
);
authorize = effectful_transform!(
ValidOrder -> { Authorized, Declined }
with {
authorize_breaker,
authorize_retry,
authorize_limiter,
}
=> authorize
);
rejected = sink!(RejectedOrder => rejections);
paid = sink!(Authorized => fulfillment);
declined = sink!(Declined => declines);
},
topology: {
orders |> validate;
validate |> authorize;
validate |> rejected;
authorize |> paid;
authorize |> declined;
}
}Durability and correctness forged from first principles.
Effects are data
Deterministic replay
Infrastructure is just infrastructure
Journal<T> trait, and the core cannot even know which backend holds it.Boundaries the compiler enforces
Durable execution without infrastructure lock‑in or coupling.
Journal<T> is defined in ObzenFlow’s domain core. DiskJournal implements that port in the infrastructure layer; the core has no dependency on its disk format or storage SDK. The built-in disk implementation provides durable execution from a single binary, while another backend can implement the same contract without changing how runs are reconstructed, replayed, or resumed. Rust and Cargo enforce that boundary, keeping correctness independent of the infrastructure that stores the journal.
Next, build a durable workflow.
Building Durable Workflows introduces the stages, effects, and composites every ObzenFlow program is built from.