🚀 ObzenFlow v0.1 is live · Start here

A durable execution runtime in Rust for high-consequence systems.

ObzenFlow records every event, decision, and effect, and reconstructs any run exactly through deterministic replay. Correctness lives in the core. Storage, transport, and deployment stay swappable at the edge. Ships as a single binary, with no platform, broker, or cluster to run.

What is ObzenFlow? View on GitHub

What makes ObzenFlow durable?

Durability and correctness forged from first principles.

After any crash or restart, ObzenFlow’s runtime rebuilds state by replaying the original journal of events through the same pure function that created it. This concept of durability has held since the 1950s, when Mealy and Moore described precisely how a state machine evolves over a record of inputs, decades before anyone called the pattern durable execution. Building ObzenFlow on automata theory is how it provides durability and correctness without coupling you to a database. Journals can be in memory, on disk, or any form of pluggable storage.

Effects are data

State machines sit at the heart of ObzenFlow’s durable execution runtime, and they never perform I/O.

A transition decides the next state and returns its effects, like sending an email or calling an API. That split between deciding and doing, drawn from automata theory and functional programming, is what makes durable execution possible.

Deterministic replay

State is a fold of the journal through a pure function. Treating the journal as an input tape enables perfect reconstruction.

A run reconstructs exactly, with recorded effect outcomes read back from the journal instead of fired again. Every event carries its causality and intent, so the journal is a faithful record of durable execution.

Infrastructure is just infrastructure

The journal is a port behind a single Journal<T> trait, and the core cannot even know which backend holds it.

Today that means a log on disk or an in-memory journal for tests, and any other backend, PostgreSQL, SQLite, or object storage, is a trait implementation away rather than a rewrite. You are coupled to no database and no disk.

Boundaries the compiler enforces

ObzenFlow follows onion architecture, with the domain core at the centre and infrastructure at the outer edge.

Dependencies point only inward, so the core cannot be shaped by storage or other infrastructure concerns. Rust’s crate graph enforces that, so swapping infrastructure, like the web server hosting your Prometheus metrics, stays a contained change at the edge rather than a rewrite.

The full theory: Mealy Machines, Moore Machines, and Why Event Sourcing Works and Onion Architecture in Practice.

Explore ObzenFlow

A simple programming model, with durable execution underneath.

The ObzenFlow durable execution stack, from typed stage syntax through supervision, journals, replay, and pluggable infrastructure.

What is ObzenFlow?

Learn what ObzenFlow is and why durable execution matters.

See how typed flows, supervised stages, and ordered journals work together, what guarantees they provide, and where ObzenFlow fits in high-consequence systems.

Understand ObzenFlow

Try It Today

Start with a real example.

Start with the smallest flow, then move into service backends and live AI workloads.

Getting Started.: Learn the core flow! model with the smallest runnable example in the repo. Getting started tutorial
Model bank transactions.: See HTTP ingress, joins, and projections in a journal-backed service. Bank transactions tutorial
Live AI inference.: Carry the same runtime model into budgeting, chunking, and replayable AI workflows. AI inference tutorial

char_transform.rs

Ok(flow! {
    name: "char_transform",
    journals: disk_journals(PathBuf::from("target/char-transform-logs")),

    stages: {
        characters = source!(CharInput => characters_handler);
        transform_text = transform!(CharInput -> TextChunk => transform_text_handler);
        collect_text = stateful!(TextChunk -> TransformedText => collect_text_handler);
        output = sink!(TransformedText => output_handler);
    },

    topology: {
        characters |> transform_text;
        transform_text |> collect_text;
        collect_text |> output;
    }
})

Open Source

MIT and Apache 2.0, like Rust itself.

ObzenFlow is available under the MIT License or Apache License 2.0, at your option. Both are OSI-approved licenses, so the framework stays open to inspect, modify, and build on.

Proudly created in Canada. 🇨🇦 Built for the world. ❤️

View on GitHub How to contribute →

The OSI Approved Open Source License mark, OSI, and Open Source Initiative are trademarks of Open Source Initiative. ObzenFlow is not affiliated with or endorsed by OSI.