How it works

Rust → Charon → Aeneas → Lean → Leanstral → kernel.

rustproof is designed to take a Rust crate, find the functions whose behavior can be proven, patch them at build time into the subset Aeneas accepts, extract them to Lean 4, propose theorems in plain English and Lean, generate proofs with Leanstral, and check every proof with the Lean kernel.

Install the Claude Code plugin coming soonBricks
01 / THE PIPELINE

Twelve idempotent steps, keyed by content hash.

The pipeline as it is designed, in order.

1 · scanClassifyprovable, patchable, excluded
2 · rankPrioritizehow provable, how important
3 · patchApply bricksbefore/after diffs
4 · extractCharon → AeneasMIR → LLBC → Lean 4
5 · proposeTheoremsEnglish first, Lean second
6 · proveLeanstralparallel search, in the cloud
7 · checkLean kernelno sorry, allowed axioms only
8 · mutateWeak-spec detectiona surviving mutant flags the spec
9 · counterexampleFind the inputproperty search, fuzzing
10 · buildPatched treeoverflow checks on
11 · testDifferential + yourson the patched build
12 · reportEvery surfacepane, PR, dashboard, CLI
02 / THE PROOF BOUNDARY

I/O is a boundary, not a blocker.

What can be proven

Pure, deterministic, typed functions: validation, parsing, pricing and scoring rules, data transformations, numeric kernels, state machines.

What’s excluded

I/O, network, filesystem, clocks, randomness, global mutable state, concurrency and async, unsafe code, FFI, and anything that depends on library types Aeneas has no model for and no brick can replace. Excluded functions will be visible in every surface, with the reason.

Overflow

Aeneas models arithmetic so that overflow is a failure, matching Rust’s debug builds. Release builds wrap silently. The patched build is designed to set overflow-checks = true, so the shipped binary matches the model everywhere, and a theorem’s precondition is exactly the set of inputs on which the code doesn’t fail.

Where it will live

.rustproof/
  manifest.toml   obligations, hashes, bricks, approvals
  patches/        one patch per obligation (may be empty)
  specs/          theorem statements (CODEOWNERS)
  proofs/         generated proofs
  lean/           Lake project; Generated/ is Aeneas output
  state/          local step cache (never committed)
03 / STATUS VOCABULARY

One set of states, every surface.

Every status shows its glyph and its label, so it reads without color; two pairs share a glyph, and the label tells them apart.

StateMeaningWho acts
ProvenSpec approved; proof checked by the Lean kernel against the current patched treeNo one
CheckingVerification runningSystem
SearchingProof search or repair runningSystem
Needs reviewA spec, or a patch that requires approval, is waiting for a personA person
FailingProof doesn't check; repair hasn't succeededAgent, then a person
CounterexampleA concrete input breaks the claimAgent, then a person
Weak specSpec still holds for a mutantA person
StaleThe function or a callee changed since its proof was checked; cleared automatically if re-extraction yields the same LeanSystem (re-patch, re-prove)
ExcludedOutside the proof boundaryNo one

See it on your own crate.

/rustproof:init will report how much is provable as-is, how much with patches, and what is excluded and why.

Install the Claude Code plugin coming soonRequest early access coming soon