Drop in a Python, Go, TypeScript, Java, C, C++, C#, or Ruby project — get back a Cargo crate that mirrors your structure, types, and logic. The LLM generates; the compiler judges. So the result is verified, not vibes.
Every step is a deterministic or compiler-grounded improvement — not a prompt tweak. Each number is what cargo check actually reported.
errors — drop it, build it, run it. Clean Go→Rust on the bundled calculator example.
errors fixed by applying rustc's own machine-applicable suggestions, before the model spends a token.
clean / compiles-with-gaps / failed. Scriptable, CI-ready, and never lies about which one you got.
$ rustyfi ./myapp -o ./myapp-rust rustyfi 🎺🦀 ▸ Analyzing source ▸ Scaffolding + pinning type contract · Compiler-checking the contract before translation… ▸ Translating to Rust ████████████ 12/12 ▸ Verifying with cargo check · Auto-fixed 37 errors with the compiler's own suggestions (no AI) ✓ compiles clean · 12 translated from go · 18 files · 0 todo!() stubs → cd ./myapp-rust && cargo run
--deep engages the agentic doctor on stubborn errors.One cheap call per package pins the canonical Rust API — then compiles it as a skeleton before fan-out. A structurally broken contract is regenerated, never multiplied into 180 errors across every file. The cheap model with the contract beats the expensive model without it.
cargo check emits structured, machine-applicable suggestions for a huge class of errors. Rustyfi applies them directly — and tries the "maybe" ones only when they reduce the error count. The compiler is the oracle, so a wrong guess never sticks.
The fix loop sees the trait the compiler says is unsatisfied, the type defined two modules away, the existing impls, and rustc --explain — instead of one file and a bare error string. That's how the trait-bound tail finally shrinks.
For the stubborn last mile, an agentic loop reads, searches, edits, and re-checks the crate until it compiles or the budget caps. Edits are confined to src/ and snapshot-reverted — it can never make the crate worse than it found it.
For CLI tools, Rustyfi mines a fixture corpus from the project's README and --help output, captures golden stdout / stderr / exit-code from the original program, then — once the translation compiles — runs the same inputs against the Rust binary and diffs the results. The original is the ground truth. A passing diff means the same behavior on the tested cases; it's differential testing, not a proof of equivalence. Rustyfi is honest about that distinction.
Artifacts emitted: behavior.yaml (the corpus) and behavior_report.json (per-case pass/fail with diffs). Under --deep, the agentic doctor also repairs behavioral mismatches — keeping an edit only when behavior improves and the crate still compiles. A regression in either direction is reverted.
On the bundled calculator example the compiler gave a clean bill of health. The behavioral oracle found a difference the type system is blind to:
# input: 33 / 3 original (Go) stdout: 11 translated (Rust) stdout: 11.0000000000 # exit codes match · stderr empty on both → FAIL (stdout differs)
--help; deduplicate and normalise.cargo build succeeds, replay every case and compare byte-for-byte.behavior.yaml and behavior_report.json; piped into CI or read by the doctor.--deep repair — agentic doctor targets only failing cases; edits kept only when diff improves and still compiles.A library has no CLI to diff. So Rustyfi synthesizes a thin driver that exercises the public API in both the source language and Rust, then diffs the output — turning a library into a comparable program. On itsdangerous, the translated Signer verified byte-identical to Python across sign, unsign, and tamper-rejection — both drivers model-generated, the diff normalized for harmless language reprs (Python True vs Rust true).
It ships today as a verified engine capability; auto-wiring it into every library translation is gated behind a flag while it hardens (it costs a model call per run). It is honest by construction — when it can't synthesize a runnable driver it skips rather than inventing a false mismatch.
Translating real software between languages is not a solved problem, and Rustyfi doesn't pretend otherwise. Pure-logic projects — CLIs, libraries, parsers, algorithms — usually come out compiling clean: drop them, build them, run them. Complex real-world apps — framework-heavy, native-library-bound — come out as a compiling skeleton with your modules wired up and the type-chaos eliminated, plus an honest NEXT_STEPS.md punch-list of what's left.
What no tool can do — including this one — is take an arbitrary framework-heavy app and emit clean idiomatic Rust with zero human follow-up. Closing that last mile means mapping one ecosystem's semantics onto another's, which needs a human or a stronger model in the loop. Rustyfi gets you most of the way and is honest about the rest. The result banner and exit code never lie about which outcome you got.