Source becomes software. Evidence earns promotion.
AI may propose a faster path. It does not get to move the finish line.
Rune wraps Cargo with a deterministic build path and a separate, budgeted discovery path.
An approved plan replays without a model. Exploration may suggest a candidate, but it cannot edit the acceptance contract or silently enter the build.
A plan is bound to the exact source tree, lockfile, compiler identity, policy, and target.
Its ID is the SHA-256 of canonical JSON. Edit a source file and ordinary rune build refuses with a stale-plan reason until you approve a new plan with --freeze.
The normal path replays the approved plan using Cargo’s locked, offline mode.
rune build runs the equivalent of cargo build --release --locked --offline, records an artifact digest, and writes a receipt stating that model calls equal zero.
rune verify rebuilds in a clean target directoryRecall. Propose. Apply. Evaluate. Retain. Record.
Recipes are ranked by workload, hardware, compiler, ABI, target, and policy fingerprints. Ranking is only a suggestion. A paid proposal reserves its dollar and token budget first; output remains data until tested.
The contract, thresholds, and hidden holdout live outside the candidate tree.
Static gates reject new unsafe, dependencies, build scripts, proc-macros, network access, process creation, environment reads, and filesystem writes before candidate code is built.
Promotion binds approval to the exact artifact, target, compiler, policy, contract, and evaluator version.
An Ed25519 evaluator receipt authenticates the report bytes. A trusted key must be supplied independently of the candidate workspace.
A squared-distance fixture reached a 3.51× geometric-mean speedup with a 95% CI of [3.511, 3.513].
The experiment used 40 interleaved pairs after five warmups, pinned to one core. A candidate that dropped the final partial chunk passed visible tests, then failed the hidden length-7 holdout.
Rune turns optimization from an act of faith into a chain of inspectable decisions.
Explain shows the recipe, measurements, and cost behind a decision. Rollback restores the previous approved plan. Cleanup is dry-run by default and quarantines only owned generated objects.
Rune is not a new Rust compiler and does not replace rustc. It is a learning orchestration layer around Cargo and rustc: it remembers which source-level optimization recipes worked, where they worked, what they cost, and why other candidates failed.
Rustc still parses, optimizes, and emits machine code. Rune owns the surrounding loop: context, candidate search, controlled edits, independent evaluation, evidence memory, promotion, rollback, and artifact lineage.
Rune describes the optimization context using source semantics, workload distribution, target architecture, CPU features, compiler version, ABI, and policy fingerprint.
A match on source text alone is not enough; hardware or policy drift changes the context.Memory stores recipe descriptors linked to baseline and candidate hashes, raw measurements, confidence intervals, failures, evaluator version, resource cost, and retention class.
A recipe says “this worked under these conditions,” not “apply this everywhere.”Contextually similar recipes are ranked first. If local memory cannot supply a useful candidate, rune improve may request one bounded model proposal after reserving its dollar and token budget.
An exact replacement or pinned Agent Booster sidecar applies the edit only after source-hash, path, symlink, and size checks. A placement confidence score is never treated as correctness.
The baseline remains untouched and available for comparison or rollback.A separate evaluator compiles, runs visible tests, challenges a hidden holdout, applies capability gates, and performs paired interleaved benchmarks. The optimizer cannot edit these rules.
Even a previously successful recipe must pass again when compiler, target, policy, or contract changes.Validated evidence enters memory. Rejected candidates remain searchable with their failure scope, preventing the system from repeatedly paying for known-bad ideas while avoiding overgeneralization.
Approval is bound to the exact tested artifact; memory only improves the next search order.Frozen memory selected a validated improvement in 154 of 288 fresh cases across twelve synthetic sorting contexts, versus 35.5% expected for uniform random selection and 36.8% for the training-selected fixed algorithm. All 24 seed blocks favored memory and the preregistered confirmation gates passed.
Scope: one shared host, synthetic sorting contexts, and harness-supplied feature metadata. This does not prove general compiler improvement, autonomous algorithm invention, or production-wide transfer.
Most optimization systems own one part of the loop. Rune connects search, measurement, safety policy, economics, memory, artifact identity, and rollback while keeping proposal power separate from approval power.
| Approach | What it optimizes | What it remembers | Who decides | Rune’s distinction |
|---|---|---|---|---|
| rustc / LLVM | Compiler IR and machine code through built-in passes and heuristics. | Normally no cross-project evidence memory between ordinary builds. | The compiler’s tested implementation and flags. | Rune reuses rustc, then governs source-level alternatives and evidence across runs. |
| AI coding agent | Open-ended source edits guided by prompts and repository context. | Conversation or agent memory, often without artifact-bound performance evidence. | Frequently the same agent proposes and informally judges the edit. | Rune treats model output as untrusted candidate data and grades it independently. |
| PGO | Compiler decisions guided by profiles from representative executions. | Profile data tied to instrumented workloads and compiler tooling. | The compiler applies profile-guided transformations. | Rune can search algorithmic or source-level alternatives; it complements rather than replaces PGO. |
| Autotuner | A predefined parameter or implementation search space. | Measurements for configurations in that search domain. | A scoring objective selects the winner. | Rune adds semantic contracts, capability gates, cost accounting, negative memory, and signed promotion evidence. |
| Rune | Contextual source-level recipes executed by the existing Rust toolchain. | Scoped successes and failures with hashes, costs, statistics, policy, and evaluator identity. | An independent evaluator under a frozen contract. | A deterministic build path remains agent-free; learning changes search priority, never the acceptance rules. |
Approved builds replay pinned inputs offline with zero model calls. Exploration is explicit, separate, and reversible.
Rejected candidates keep their failure scope, so later searches can avoid repeating expensive mistakes without banning an idea everywhere.
Target, CPU features, compiler, ABI, workload, and policy travel with the result. An x86 win does not silently become an ARM approval.
Hidden tests, thresholds, capability policy, signing keys, and promotion permissions stay outside the candidate workspace.
Paid calls reserve budget before execution, reconcile provider-reported cost, and attach resource cost to the evidence record.
Plans, artifact digests, measurements, evaluator receipts, cleanup ownership, and rollback targets form one auditable chain.
Rune is not a replacement for rustc’s optimizer, LLVM, PGO, formal verification, or a hardened sandbox. It adds the most value when optimization must be reproducible, governed, budgeted, hardware-aware, and auditable. Its published learning result is promising but deliberately narrow; broad production generalization remains unproven.
rune improve call1,325 tokens; ledger reconciledThese results come from the repository’s fixtures and tests. The confidence interval measures within-session variance, not drift across days; recipe selection uses synthetic records; the live-call ledger check is not an independent billing audit. Rune’s broader cross-family generalization remains unproven.
Install the rune-toolchain package, freeze a plan from committed inputs, verify its artifact, then inspect the evidence trail.
$ cargo install rune-toolchain $ cd your-cargo-workspace $ rune build --freeze ✓ plan approved · build offline · digest recorded $ rune verify ✓ clean rebuild matches recorded artifact $ rune explain # plan lineage · budget · measurements · evidence
rune-toolchainUser-facing orchestration and commands.
rune-toolchain-corePlans, tree digests, plan store, and cost ledger.
rune-toolchain-cargoToolchain identity and locked offline Cargo builds.
rune-toolchain-editHash-checked exact-replace and Agent Booster edits.
rune-toolchain-evalIsolation, hidden holdouts, paired statistics, and receipts.
rune-toolchain-memoryRecipe ranking, approval keys, snapshots, and studies.
rune-toolchain-targetCross-build descriptors, executors, and artifact envelopes.
rune-toolchain-gcOwnership manifests, leases, quarantine, and purge.