Coming from Rust

Septa code is Rust within a supported profile. Structs, enums, pattern matching and ownership remain useful tools. Septa adds a coordinated model for checking, durable execution, effects, code identity and authority.

The main shift is deciding which logic belongs in that managed model. Keep domain decisions and durable progress in the core. Connect the wider native Rust ecosystem through explicit interfaces.

What carries over

Use types to make invalid states difficult to represent. Give distinct outcomes distinct enum variants. Use ownership to make state responsibility clear. Write small library functions and test what they mean.

Within the admitted surface, compatibility is judged against ordinary Rust under the documented configuration. A Rust program compiling with rustc alone does not establish that Septa admits it: the profile reference is the boundary.

What changes

In a native Rust application	In Septa’s managed core
A process owns the current in-memory state	A durable actor owns state with a persistent identity
A library can directly invoke available operating-system APIs	Supported external interactions cross typed effect boundaries
A dependency is selected through a package name and version constraint	Exact content identities make the selected code explicit
An edit commonly triggers a native application build	The installed runtime checks, lowers and executes supported code
Recovery is an application concern	Durable progress follows the runtime’s stated recovery contract

“Zero-build” describes the application and library feedback loop. The runtime still performs compilation work internally. Building the runtime or a native host uses its separate native build process.

A productive first exercise

Run the durable counter and notice that separate CLI processes read the same actor state. Then build a library and its consumer. The library remains ordinary source with functions; the consumer supplies an execution context.

Ask your coding agent to work inside the supported profile and treat a located refusal as a design constraint. A useful task is: “Keep the arithmetic in this library, expose a small typed operation, and show the tests and effect boundaries.”

Native Rust stays available

An ordinary Rust host can own transport and integration work while calling the runtime through its public interfaces. That gives existing libraries a deliberate place in the system. Their build process and operating-system authority remain part of the native boundary.

Read Extend with native Rust before importing a library that relies on threads, ambient I/O, unsupported language features or floating-point computation.