Erkam Yaman, a developer based in Istanbul, has released rust-anything, an open-source tool that records what a TypeScript, Python, C, Go, Ruby or Java app does today, then checks each piece of a Rust rewrite against that recording before the next piece moves, until the whole app is Rust. Your coding agent writes the Rust. The tool supplies the profile, the plan, the replay and the check that says a piece is finished.
The first version landed on npm early on 17 November NZ time, and version 1.4.0 followed on 18 November. It’s MIT-licensed, installs from crates.io or npm, and registers itself with Claude Code, Codex, Cursor and Gemini CLI. PHP is in preview. The README says it’s an independent project, not affiliated with the Rust Project or the Rust Foundation.
How a piece moves to Rust
The README’s tagline is “Rewrite your whole app in Rust. Keep it working the whole way.” The mechanism is a loop that runs on one unit of code at a time, a file, a package or a module depending on the language.
It starts by profiling a real workload to find where the time goes, then plans the port order. A bridge crate (napi-rs or wasm-bindgen for JavaScript, PyO3 for Python, and generated wrappers for the other languages) lets the rest of the app keep calling the same API while the code underneath moves to Rust. The tool then runs the original on generated edge cases, such as emoji, NaN and negative zero, and saves what it returns or throws. Your agent writes the Rust, and every recorded case gets replayed against it.

Two later steps cover production. In shadow mode the app runs both versions, returns the original’s answer and reports any mismatch, so Rust errors never reach callers. The gate then runs formatting, clippy with warnings denied, tests and an audit of unsafe code before it calls a piece done. Setting RUST_ANYTHING_MODE to old, shadow or new switches between the versions. The README describes that as a setting you change, not an automatic rollback.
For whole apps, the tool records a CLI or HTTP server from the outside, puts a Rust front door in front of it, and wires units in one at a time. The final app lift step strips out the fallback path and the bridges, and it refuses to run until every case passes with no fallbacks. The original code is never touched.
The speed numbers come from moving the loop
The README leads with “up to 20x faster”, and its table has six workloads. Each one has a benchmark in the repository’s demo folder, and the README says it first checks that the results match the original.
| Workload | Language | Original | With rust-anything |
|---|---|---|---|
| x18n sidebar search, 50,000 keys | TypeScript (Node) | 10 ms per query | 0.5 ms, 20x faster |
| The same search in the browser (wasm, one thread) | TypeScript | 10 ms | 0.95 ms, 11.5x faster |
slugify, 20,000 strings | Python | 98 ms | 17x faster |
Shellwords.shellescape, 50,000 values | Ruby | 88 ms | 11.8x faster |
Slugify, 50,000 strings | Go | 49 ms | 4x faster |
slugify, 50,000 strings | Java | 43 ms | 3x faster |
Those gains come from batching. A Rust function called once per item pays the cost of crossing the language bridge each time, and the README says that’s usually slower than a JIT, the just-in-time compiler that makes Node, the JVM and Go fast. So profile finds the loop around the slow function, and --batch generates a class that takes all the items once and runs the work across every core.

The project’s own x18n case study shows the other side. It ported all 29 functions of x18n’s core that can move without an API change. Every gate passed and 7,925 recorded cases matched exactly, but the report says the ports run slower as called from JavaScript because the bridge costs more than the work. Its recommendation for x18n: don’t ship them. In the batch table, compiled originals gain less: Go and Java run 4x and 3x faster as batches, while per-call ports ran at 0.93x and 0.68x.
What a pass doesn’t cover
The README is plain that passing means the Rust matches every recorded case and nothing more. It lists what falls outside the recording.

- Inputs nobody recorded. The generated cases and any inputs you supply are the ceiling, and the README suggests adding production samples and bug reports.
- Regexes. Rust’s
regexcrate has no lookaround or backreferences, and a pattern that compiles can still treat\wor case-insensitive matching on non-ASCII text differently from JavaScript, Python or Java. - Anything that changes between runs. Hash order and concurrency differences can change for real in a port.
- Anything not in the output. Timing, memory, and side effects other than stdout, stderr, exit codes, written files and HTTP responses, such as database and network calls, aren’t compared.
Setting it up
The README suggests pasting an install prompt into your agent, or running two commands yourself:
cargo install rust-anything
rust-anything setup
setup adds an MCP server to each agent it finds, installs a workflow skill where the agent reads skills, and saves a .rust-anything.bak copy of any settings file it changes. Prebuilt binaries for macOS, Linux and Windows are attached to each GitHub release, and npm install -g rust-anything installs the same binary. Recording and replaying run the original in its own runtime, so you need Rust plus the runtime for your language: Node 22.6 or later, Python 3.9 or later, Go 1.21 or later, Ruby 3 or later, or JDK 17 or later.
The FAQ says the tool runs locally and sends none of your code anywhere, while your agent’s model provider sees whatever your agent sends it. Porting PHP units through PHP’s FFI is the next step on the project’s issue tracker.
Sources
- rust-anything, README and docs, GitHub
- Releases, rust-anything on GitHub
- x18n core case study, rust-anything demo
- Design decisions, rust-anything
- rust-anything on crates.io
- rust-anything on npm
Discover more from Sulat AI & Tech News
Subscribe to get the latest posts sent to your email.




