Auto is Rust's Script Layer
Python taught the world that fast iteration wins. Rust taught the world that safety wins. Auto refuses to choose.
You (or an AI) write Auto. The AutoVM runs it instantly — no compile step, so the iterate-refresh loop is seconds, not minutes. When the work is done, a2r transpiles that same source into short, idiomatic Rust that links against a2r-std and ships with native performance and memory safety. The compiler guarantees the script's behavior matches the shipped Rust's behavior.
See it: one program, two execution modes
Edit the Auto on the left. Hit Run in VM to execute instantly (no compile). Hit Transpile to Rust to see the exact Rust a2r produces. Hit Run Both & Compare to watch the two backends agree in real time.
No output yet
No output yet
The three acts
Dev — write Auto, run it in the VM, iterate in seconds. No compile waiting on every turn. AI gets to be wrong many times, fast, because being wrong is cheap.
Ship — a2r turns the same source into Rust you'd have written by hand: real trait / impl / Box<dyn>, generics, ownership, Result + ?. Link a2r-std, cargo build --release, deploy.
Bridge — the transpiler is on the hook for agreement. AutoVM output == transpiled-Rust output. Not a claim: verified by 260 three-way parity tests across ten real libraries (plus consumer-mode crates — see dashboard).
Why this beats "Python now, rewrite in Rust later"
| Python + C/C++ (or Rust) | Auto + Rust (a2r) | |
|---|---|---|
| Ecosystem | Two split ecosystems; FFI is a bridge with real cliffs | One ecosystem — Auto fully supports Rust's patterns + std + crates, a2r-std is the thin mirror |
| Capability parity | Python lacks types/ownership/zero-cost abstractions; C/Rust lack ergonomics | Auto and Rust agree on what a program means (same trait/generic/ownership/async semantics) |
| Migration cost | Python → C/C++ is a complete rewrite project, heavy AI involvement | Auto → Rust is mechanical transpilation; the compiler guarantees behavior |
| Behavior consistency | None — Python and C disagree on numerics, concurrency, memory routinely | Enforced — the parity harness fails the build on divergence |
| AI assistance | Python is easy to generate; the C/Rust rewrite is a second mountain | Auto is easy to generate (script mode tolerates imperfection); the Rust step is deterministic |
The core difference: with Python+C, the rewrite is a design problem (the two languages don't agree on semantics). With Auto+Rust, the "rewrite" is a compiler step — and compilers are more reliable than AI rewrites.
Evidence, not promises
Auto's "VM and Rust behave identically" claim is backed by an automated three-way parity harness: AutoVM vs a2r-transpiled Rust vs native Rust, on real libraries. This is the part that distinguishes a credible tool from marketing copy.
L1 — verified three-way today (260 test cases):
| Library | Cases | What it exercises |
|---|---|---|
| serde_json | 56/56 | full JSON parser: recursive descent, escapes, error paths |
| regex | 45/45 | pattern matching, backtracking |
| url | 30/30 | URL parse/normalize, scheme validation |
| base64 | 33/33 | encode/decode, padding and alphabet edge cases |
| cli_app | 32/32 | pure std text processing (wc-style) |
| string_utils | 22/22 | string ops across module boundaries |
| trait_advanced | 18/18 | specs/traits: default methods, associated types, bounded generics |
| tokio | 13/13 | async/await future composition |
| generators | 6/6 | yield iterators, lazy sequences |
| http_client_sync | 5/5 | synchronous HTTP against a mock server |
See the live parity dashboard for the full matrix and per-library details.
Honest boundaries (L3 — roadmap, not yet verified):
Every previously-listed trait divergence is now fixed and three-way verified (associated types, default method bodies, generic spec impls, bounded generic functions, the http_client_sync harness). What remains open is documented in known-divergences, not hidden:
- sha2 / rusqlite / reqwest parity libraries — planned, not yet verified.
- Generator lazy chains (range → map → filter over
~Iter) — no Auto syntax yet; language roadmap item. - tokio spawn/join + mpsc channels — the verified subset covers serial future composition; parallel spawn awaits VM support.
Auto does not pretend to be finished where it isn't. The L1 list is what's verified; the L3 list is on the roadmap, and every chapter in the tour tells you which tier a feature is in.
Start here
→ From Script to Ship — the interactive tour — six chapters, every block runnable in your browser.
→ Parity dashboard — the evidence.
→ Script-to-Ship demos — runnable single-file examples (serde_json, regex, wc) you can clone and ship.
# Dev — interpret instantly, no compile
auto main.at
# Ship — transpile to Rust, then cargo build for release
auto trans --path main.at rust