Skip to main content

Aristotle for Rust makes the proof boundary part of the release decision

Harmonic's new Rust support can check stated properties, including unsafe code. Its documentation also identifies assumptions and gaps reviewers need to read.

A magnifying lens above interlocking metal blocks on a pale workbench
TechKili · AI-generated conceptual illustration with Cloudflare FLUX
Share this article:
In this article

Harmonic has released Rust support for Aristotle, extending its verification service beyond C and Verilog. The useful question for a development team is which behavior a result proves under which assumptions. A successful result should be read with that boundary attached, rather than treated as a general certificate for the whole application.

The November 16, 2026 announcement says the service is available immediately and can address functional properties, unsafe Rust and equivalence when rewriting C. These are vendor capability claims; the detailed documentation is more specific about the limits of the assurance.

A proved property is a precise, conditional result

According to the overview, developers describe properties in English and submit source code. Aristotle returns machine-checked proofs or evidence against a property, with a summary of assumptions and coverage.

Reported status What the reviewer should take from it
Proved The stated property holds under the reported assumptions and preconditions.
Refuted Evidence contradicts the property; inspect the counterexample or proof of its negation.
Unresolved The property is not verified; a stopped run or failed final check is not a pass.

This makes the specification an engineering deliverable. If a function must avoid panics as well as return the right value, those are separate requirements to state. An omitted requirement cannot become part of the assurance simply because nearby properties passed.

Unsafe support has a documented model boundary

The Rust guide says Aristotle reasons about a formal model derived from Rust's mid-level intermediate representation. It supports safe and unsafe code, but explicitly says its model does not yet detect every form of Rust undefined behavior. Examples include incomplete checks of reference dereferenceability and value validity across certain ABI-compatible type changes.

That qualification matters more than the shorthand claim that code has no undefined behavior. Reviewers need to understand what the model covers, which functions were reached and what external behavior was assumed. For Solana, the guide says programs called through cross-program invocation remain outside verification, even when their source is available.

Manifest illustrates why conditions belong beside the result

Harmonic's Manifest case study reports 28 proved properties and two corrected findings in the Solana order book. Its claim that valid swaps succeed depends on stated liquidity, funding, account and arithmetic conditions.

The case also says called token and system programs are assumed rather than proved, and no compute-unit bound is established. Those are material limits: functional progress under the model is not a promise that every transaction will fit an execution budget. These are the vendor's reported results, not an independent TechKili audit.

Start with a component whose requirements you can review

TechKili's assessment is to evaluate a bounded component with explicit input conditions and required behavior, then inspect the returned boundary before expanding the scope. Keep tests and broader system review focused on concerns that the proof does not cover. The release supplies another way to obtain evidence; responsibility for choosing the right requirements remains with the team.

Sources and research limits

TechKili reviewed the release, documentation and vendor case study; we did not run an independent verification trial.