Why does Septa exist?

At Lorena Labs, we’ve spent years building domain-driven applications in Rust. We love the language. Septa is our attempt to give it the runtime and development tools we’ve always wanted.

We want to keep Rust

Rust’s type system is a big reason we use it for business applications. It helps us express domain rules in code and catch mistakes before the application runs. Ownership and borrowing prevent a whole class of memory errors. We want to keep those strengths, along with access to the Rust ecosystem.

But we don’t enjoy waiting for builds. And when we’re modelling concurrent work, we often wish we had Elixir’s actor model.

Actors, effects and capabilities belong together

Actors are a useful fit for the applications we build. Each actor owns some state and handles messages. That gives us a way to model domain responsibilities and concurrent work without turning every component into a separate service.

Rust already has ractor, an excellent actor library inspired by Erlang. What we wanted was a system that combines typed actors with managed effects, scoped capabilities and durable execution.

A typed message tells us what an actor can receive. An effect declares an operation it can request. Scoped grants and runtime checks determine whether it is allowed to make that request. Durable execution lets it retain state and progress across supported restarts.

We also want to see which actors communicate, what they exchange and which permissions apply. Separate views should show declared connections, permitted operations and recorded execution. This helps people review implementations written by coding agents.

A smaller Rust profile for business logic

Our business logic mostly works with records, identifiers, quantities, money and state transitions. We don’t use floating-point arithmetic in that core, so Septa leaves it out. Checked integers and exact decimals cover the arithmetic we need.

This is part of a curated Rust profile with deterministic execution and explicit effects. It gives us a smaller set of behaviours to check, replay and reason about. It also gives coding agents a clearly defined language to work within.

Leaving out floats serves that deterministic model. The shorter build loop comes from running supported code on an installed runtime, without invoking Cargo and a native build for every application edit. The runtime still checks and lowers the source before running it.

Unison changed how we think about code

Unison is another favourite language. Its content-addressed code model identifies definitions by their content rather than their names. That makes a different approach to builds and dependencies possible.

Septa takes inspiration from that approach. Code and dependencies have exact content identities, so a dependency pin refers to specific code. An update changes that identity. The tools can use these identities to track what changed and reuse test results when the inputs relevant to a case are unchanged.

We want less time spent rebuilding and resolving dependency changes, with a clear record of which code a test result applies to. Content addressing helps make that possible; it doesn’t make the dependency trustworthy by itself.

Full Rust is still available

Some work needs native libraries, operating-system APIs or floating-point computation. Ordinary Rust can handle it in native components connected to Septa through explicit host interfaces. Those components keep their own builds, permissions and failure behaviour.

The managed core supports a defined subset of Rust, so arbitrary Cargo crates won’t run inside it unchanged. We keep access to the wider ecosystem through those native interfaces.

What we want to build

We want to build applications, libraries, databases and frameworks on Septa. We’re already building a graph database with it at Lorena Labs. As agents write more of the code, people still need to understand the system’s behaviour and permissions.

Read Septa at a glance →

Search concepts, guides and reference.