Repository avatar
AI Tools
v2.1.0
active

rust-anything

io.github.erkamyaman/rust-anything

Rewrite an app in Rust one piece at a time, checked against the original's recorded behavior.

Documentation

The rust-anything crab

rust-anything

Rewrite your app in Rust, and prove it still behaves the same.

New in 2.0: Prettier, ported to Rust. 19x faster · 15,837 of 17,224 recorded runs fully in Rust · every run byte-identical

crates.io version npm version Tests GitHub stars Featured in Awesome REA Mentioned in Awesome Rust

Quick start · Languages · Real-world ports · How it works · Whole apps · FAQ

Made in Türkiye 🇹🇷 by erKam Yaman · MIT · ❤️ Sponsor me

Sponsored by CodeRabbit

English · Türkçe · Українська · 简体中文 · 繁體中文 · Deutsch · Français · Русский · 日本語 · 한국어 · Azərbaycanca · Oʻzbekcha · Қазақша · Кыргызча · Türkmençe · Татарча · ئۇيغۇرچە · Português · Tiếng Việt

Record
record runs the original on generated edge cases, semantic traps and your own inputs, and saves what it returns or throws.
Port
bridge generates the Rust crate and a wrapper, so callers keep the original API. You or your agent write the Rust.
Check
diff replays every recorded case against the Rust, and nothing ships until they all match and gate passes.
Lift
When replay passes with no fallback and every unit passes gate, app lift makes it a pure Rust app. The original is never touched.

Rewrite your whole app in Rust, one piece at a time. rust-anything records what your Node.js (TypeScript/JavaScript), Python, C, Go, Ruby, Java or Kotlin app does today, then checks every piece of the Rust rewrite against that recording before it moves on, until the app is pure Rust. CLIs, HTTP servers and libraries; your coding agent (or you) writes the Rust. It can only catch what the recording covers: see What it can't catch. Whole tools and servers, or only the slow part, one hot path at a time:

Real project, same output as the originalOriginalWith rust-anything
Prettier 3.6.2, 2,360 JS/TS files from the command line128.6 s6.9 s: 19x faster
Prettier, 6,305 Markdown files from the command line352 s22.5 s: 15.6x faster
json-server, a whole Node server: memory at idle74 MB3.5 MB, one 5.3 MB binary
json-server, from start to first response79 to 85 ms8 to 10 ms
Fuse.js search over 50,000 strings, per query91.2 ms2.8 ms: 32x faster

Prettier: 15,837 of 17,224 recorded runs format fully in Rust across 10 languages (JavaScript, TypeScript, JSX, JSON, GraphQL, YAML, Markdown, CSS, SCSS, Less), and all 17,224 match Prettier byte for byte, since anything not ported yet falls back to Prettier. json-server: 514/514 recorded HTTP cases match on a pure Rust binary. Measured on an Apple M4, two runs each, every output compared before timing (details). Calling Rust once per small function is usually slower than a JIT; rust-anything finds the loop worth moving, and moves it.

Prettier and its Rust port format the same 59 real files, one process per file: Prettier takes 3.63 s, the Rust port 0.20 s, with the same output byte for byte.
Prettier against its Rust port on 59 real files from ms, Fuse.js and json-server (Apple M4). Same output, byte for byte. How it was measured.

json-server as a Node server and as one Rust binary: memory at idle 74 MB and 3.5 MB, start to first response 79 to 85 ms and 8 to 10 ms, and 514 of 514 recorded HTTP cases match.
json-server, a whole Node server, lifted to a pure Rust binary (Apple M4). How it was measured.

rust-anything is an independent project, not affiliated with or endorsed by the Rust Project or the Rust Foundation. "Rust" is a trademark of the Rust Foundation.

[!WARNING] record and app record run your original code, calling each function (or the whole app) on many generated inputs, and app record runs every case twice. diff, gate and app replay run the same cases again, on the port or the original. Code that writes files, talks to a database or calls the network does that once per case. Run them on a copy of the project, with a test database and no production credentials in the environment.

Quick start

Paste this into Claude Code, Codex, Cursor, Gemini CLI or OpenCode and let your agent install it:

Install rust-anything: run `cargo install rust-anything`, then `rust-anything setup`.
Tell me when to restart you.

Or yourself:

cargo install rust-anything   # from crates.io
rust-anything setup           # registers it with Claude Code, Codex, Cursor, Gemini CLI and OpenCode

No Rust toolchain yet? Prebuilt binaries for macOS, Linux and Windows are attached to each GitHub release, and for JavaScript projects npm install -g rust-anything installs the same binary.

In Claude Code you can also install it as a plugin (the MCP server and the skill; the CLI above must be on your PATH):

/plugin install rust-anything --marketplace erkamyaman/rust-anything

setup adds the MCP server to each agent it finds and installs the workflow skill where the agent reads skills. It keeps your other settings, is safe to run again, and --remove undoes it. Then ask your agent, for example:

  • "Rewrite this CLI in Rust with rust-anything, end to end, and prove it behaves the same."
  • "This search feels slow. Profile it with rust-anything and move the hot loop to Rust."
  • "Plan a migration of src/parser/ to Rust with rust-anything; port the first unit and prove it."
  • "Bench the Rust port in rust/text-rs against the original and tell me whether to ship it."

Works with

Agentrust-anything setup adds
Claude CodeMCP server in ~/.claude.json, skill in ~/.claude/skills/
CodexMCP server in ~/.codex/config.toml, skill in ~/.codex/skills/
CursorMCP server in ~/.cursor/mcp.json
Gemini CLIMCP server in ~/.gemini/settings.json
OpenCodeMCP server in ~/.config/opencode/opencode.json (mcp.servers), skill in ~/.config/opencode/skills/
Any other MCP clientadd rust-anything mcp as a stdio server by hand (see Install)

Before changing a file that exists, setup saves a copy beside it (<file>.rust-anything.bak).

To wire OpenCode up by hand, put the server in ~/.config/opencode/opencode.json (command is the whole argv) and copy skills/rust-anything/ to ~/.config/opencode/skills/rust-anything/:

{
  "mcp": {
    "servers": {
      "rust-anything": { "type": "local", "command": ["rust-anything", "mcp"] }
    }
  }
}

Or run the steps yourself:

rust-anything profile . -- node bench.mjs              # what is hot, and who calls it
rust-anything bridge . src/fuzzy.ts --batch fuzzyScore:text
# write src/port.rs (or let your agent), then:
rust-anything record rust/fuzzy-rs && rust-anything build rust/fuzzy-rs
rust-anything diff rust/fuzzy-rs                       # every recorded case must match
rust-anything bench rust/fuzzy-rs                      # faster? the verdict says
rust-anything gate rust/fuzzy-rs                       # done means this passes

rust-anything does not translate code: your coding agent (Claude Code, Codex, Cursor, OpenCode, ...) or you write the Rust. rust-anything supplies what an agent cannot guess reliably: where the time goes, what to port first and in which order, a bridge so the rest of the code calls the Rust with its API unchanged, the exact behavior the port must match, a safe way to ship it, and a gate that says when a port is done.

Same output is not enough. Record what the app sends too, and a rewrite that mails twice fails:

app record with --effects smtp records one welcome email per signup; app replay of a rewrite that prints the same output but mails twice reports 0/2 cases passed, failing on effects, and the report shows the extra email.
A real run of app record --effects and app replay. See Side effects.

Languages

LanguageUnitBridgeRecorded and replayed by
TypeScript/JavaScriptfolder or filenapi-rs or wasm-bindgen with a generated binary wire; classes and async includedNode, running the .ts sources
Pythonpackage or modulePyO3 (abi3), direct conversion, typed exceptionsPython, importing the original
C.c fileextern "C" functions with the original names and a headerthe original compiled to a shared library, called through ctypes, one fork per case
Gopackagetyped cgo calls and a generated binary wire, in a package with the original APIa generated Go driver, built as its own module
Rubyfile or folder of module functionsa magnus extension under the original modulesa generated Ruby driver
Javapackage of public static methodstyped JNI and a generated binary wire, in wrapper classes with the original methodsa generated reflection driver
KotlinGradle module of top-level functions and @JvmStatic methodsthe Java bridge: typed JNI in Java wrapper classes calling the compiled Kotlin staticsa generated reflection driver, with the Kotlin sources compiled by kotlinc
PHPfolder of functions and public static methodscoming next: PHP FFI over a C ABIwhole apps today: app record, app replay and the front door, for CLIs and servers (php -S)
C#folder of public static methodscoming next: P/Invoke over a C ABIwhole apps today: app record, app replay and the front door, for CLIs and ASP.NET servers (dotnet <app>.dll)

Every language except C also gets batch classes (--batch): the items cross once and stay in Rust, and each call runs over all of them on all cores.

The language is detected from the repository (go.mod, pom.xml, build.gradle/build.gradle.kts, a .csproj or .sln, pyproject.toml, Gemfile, composer.json, package.json, else the most common source files); a Gradle module with .kt sources and no .java sources is Kotlin, mixed modules stay Java. --lang overrides it. Types come from the source: TS types, Python hints, C, Go, Java, Kotlin and C# signatures, Ruby YARD tags, PHP types and phpdoc; untyped parameters used as numbers are inferred as numbers.

For Android, rust-anything build <crate> --profile android builds the same JNI library with the NDK for arm64-v8a, armeabi-v7a and x86_64 (or the --abi values you pass) and installs it into <crate>/jniLibs/<abi>/; --api sets the API level (minimum 26, which the generated Java runtime needs). It finds the NDK from ANDROID_NDK_HOME/ANDROID_NDK_ROOT or the SDK, needs the Rust targets (rustup target add aarch64-linux-android armv7-linux-androideabi x86_64-linux-android), links 64-bit libraries with 16 KB page alignment, and checks that every JNI entry point is exported. Gradle looks in src/main/jniLibs by default, so pass --jni-libs app/src/main/jniLibs or add <crate>/jniLibs to sourceSets.main.jniLibs.srcDirs. rust-anything record <crate> --profile android runs the original Kotlin unit under ART on a connected device (adb), dexes the generated driver with d8 from the SDK's build-tools, and pulls the results back as the same cases.jsonl; diff <crate> --profile android replays them against the .so built for the device's ABI. Both need adb, a device, kotlinc, an SDK with build-tools and a platform, and --device <serial> when more than one device is connected. The profile covers logic units: Activity/Compose/XML UI, lifecycle and SDK-only classes stay in Kotlin, and each call crosses JNI, so prefer the generated batch wrappers for hot loops. On a host, record and diff keep using the desktop JVM.

For PHP, analyze plans a PHP app (Composer packages and PSR-4 autoloading, risks such as loose comparison and integer overflow into floats, Composer packages mapped to crates), and a PHP CLI or server can be recorded, replayed and put behind a Rust front door. Porting its units into Rust through PHP's FFI is the next step (issue #2).

C# works the same way: analyze reads .csproj projects and their NuGet packages (mapped to crates), resolves using directives to folders, and flags what C# does differently (decimal, dynamic, LINQ's deferred queries, Task, lock, reflection). A C# CLI or ASP.NET server can be recorded, replayed and put behind a Rust front door; porting units through P/Invoke comes next.

Learn more

Sponsors

rust-anything is free and open source. If it helps your work, please consider sponsoring it.
Your support keeps development going.

Company sponsor: CodeRabbit

Sponsors: Santosh Yadav, Hakan Soytürk, Ali Yilmaz, Ashley Hunter, Fatih Uzuntaş

Become a sponsor

Contributing

Issues and pull requests are welcome; CONTRIBUTING.md covers the setup, where tests go, and how to add a language. Design choices and their reasons are in DECISIONS.md. Case studies of real ports are especially welcome. Please report security problems privately (SECURITY.md), and see the code of conduct.

License

MIT © Erkam Yaman. Ports and generated code in your repository are yours.

NPM
rust-anything
Install Command
npm install rust-anything
Runtime: npx