Browse documentation

Start here

Septa at a glance

Rust types, Elixir-style actors and a development loop inspired by Unison: what Septa brings together, and what you can build with it.

Septa is a runtime and developer toolkit for building stateful software in Rust. It brings together Rust’s types and ownership, Elixir-style actors and a development experience inspired by Unison. The focus is software that remembers things, handles concurrent requests and needs to continue work after interruption.

It is designed for development with AI coding agents. Agents write and test Rust within a defined profile; people set requirements, inspect the system’s behaviour and permissions, and review the results. You can also write and edit the code yourself.

What you can build

  • Concurrent services: APIs, job processing and I/O-heavy applications with many operations in progress.
  • Domain-driven applications: orders, accounts, inventory and approvals, with clear owners for state and business rules.
  • Workflows and AI agents: operations that wait for a person, timer or tool result and need to retain their progress.
  • Libraries, frameworks and databases: reusable foundations for other applications. At Lorena Labs, we’re building a graph database on Septa.

See what to build for examples and limits.

The ideas we brought together

From Rust: precise types and ownership. Types describe the data your program accepts and produces: an order, a reservation or a failure. Ownership adds rules for using and sharing memory safely. Septa keeps these checks within its supported Rust profile, so mistakes can be caught before code runs.

From Elixir and Erlang: concurrent work organized around messages. Their process model lets independent parts of a system communicate by sending messages. In Septa, an actor owns state and handles messages with typed contracts. Inventory and Checkout can have separate responsibilities while running in the same application; each actor does not need its own microservice. See actors and concurrency.

From Unison: exact code identities and a shorter development loop. Unison identifies code by its content, using a hash: a fingerprint of a definition and its dependencies. Septa takes inspiration from this: code and dependency identities pin down what runs and help determine when test results can be reused. Supported edits run on the installed runtime without a new native application build each time. See code identity and test reuse.

Why Septa exists explains the choices behind the runtime.

How the pieces work together

Consider an application that reserves stock and waits for payment. This is a design example showing how the parts fit:

  1. Types describe the conversation. Checkout requests a reservation with an item and quantity. Inventory replies with a reservation or a reason it could not make one. The interface tells each side what to expect.
  2. Actors give state an owner. Inventory owns stock and reservations. Checkout asks it to make a change instead of modifying its data directly. This keeps the stock rules with the code responsible for enforcing them.
  3. Effects expose operations and permissions constrain them. An effect is a request for something outside a pure calculation, such as reading the clock or contacting a payment provider. Septa tracks these requests; scoped grants and runtime checks decide whether a particular request is allowed.
  4. Durable execution retains progress. While Checkout waits, the runtime preserves the state, recorded outcomes and code needed to resume supported work after a restart. External operations still need retry rules: a payment provider may have acted before a connection failed.
  5. The same boundaries make testing easier. Tests can supply a payment refusal or a fixed time without calling live services. With the same code, inputs, supplied effect answers and execution settings, core decisions are repeatable. Code identities tie the test results to the version tested.

Effects give the runtime operations it can authorize, test with controlled answers and record for recovery. Actors organize the affected state.

Explore the system model, effects and deterministic tests or durable execution.

What development feels like

An agent changes a library, checks it and runs its consumer’s tests. Eligible unchanged cases can reuse earlier results. A local watch loop checks a candidate before selecting it for new executions, so a failed edit leaves the previous accepted version serving.

People can review the source, possible operations, configured permissions and test evidence. Code identities show what was tested; they do not prove it trustworthy.

The runtime still checks and transforms source internally. Follow the shared development workflow for the commands and remaining unification work.

Where full Rust fits

The managed core uses checked integers and exact decimals, and excludes floating-point arithmetic. It suits business decisions and state transitions; graphics and numerical kernels need a different execution boundary.

Full Rust remains available through explicit native integrations, including existing libraries and OS APIs. Native components have their own builds and permissions. Arbitrary Cargo crates are not drop-in managed dependencies.

Try it

Start with a durable counter or a library and its consumer. The counter keeps state between processes; the library example shows the edit-and-test loop.

These docs describe the planned first release. The runtime is not publicly released yet, and examples currently use the name effectful. See release status.

For a more familiar starting point: Rust · Elixir or Erlang · Functional programming · New to Rust.

Search concepts, guides and reference.