by erkamyaman
Rewrite your whole app in Rust, one piece at a time, checked against the original's recorded behavior at every step. CLIs, HTTP servers and libraries in TypeScript, Python, C, Go, Ruby and Java.
# Add to your Claude Code skills
git clone https://github.com/erkamyaman/rust-anythingGuides for using ai agents skills like rust-anything.
See how rust-anything compares with popular alternatives.
rust-anything is an open-source ai agents skill for AI coding assistants such as Claude Code, Codex CLI, and ChatGPT, built by erkamyaman. Rewrite your whole app in Rust, one piece at a time, checked against the original's recorded behavior at every step. CLIs, HTTP servers and libraries in TypeScript, Python, C, Go, Ruby and Java. It has 447 GitHub stars.
rust-anything's catalog security scan is still queued. You can run an instant dependency and prompt-injection check now with the "Scan for vulnerabilities" button above.
Clone the repository with "git clone https://github.com/erkamyaman/rust-anything" and add it to your Claude Code skills directory (see the Installation section above).
rust-anything is primarily written in Rust. It is open-source under erkamyaman on GitHub, so you can review or fork the full source.
Yes. SkillsLLM lists many other AI Agents skills you can browse and compare side by side. Open the AI Agents category from the badge at the top of this page, or use the Related Skills and comparison links further down to weigh rust-anything against similar tools.
No comments yet. Be the first to share your thoughts!
Available after the catalog security scan passes.
⚠️ Third-Party Software Notice
This skill is third-party open-source software developed and hosted independently on GitHub. SkillsLLM is an informational directory and does not control or maintain the underlying repository.
Any security checks, ratings, or warnings displayed by SkillsLLM are automated and limited in scope. They do not constitute a security certification or guarantee that the software is safe, error-free, or free from malicious code, vulnerabilities, compromised dependencies, or prompt-injection risks.
Review the source code, permissions, dependencies, and configuration before installing or running any third-party skill. Use is at your own risk. To the maximum extent permitted by applicable law, SkillsLLM is not liable for losses arising from third-party software.
The deep catalog scan for this skill is still queued. Run an instant dependency check now instead.
Rewrite your whole app in Rust, one piece at a time. rust-anything records what your TypeScript/JavaScript, Python, C, Go, Ruby or Java 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. Only need the slow part fast? Port just that, one hot path at a time:
| Real workload, same results as the original | Original | With rust-anything |
|---|---|---|
| x18n's 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) | 10 ms | 0.95 ms: 11.5x |
slugify over 20,000 strings (Python) |
98 ms | 17x faster |
Shellwords.shellescape from Ruby's standard library, 50,000 values |
88 ms | 11.8x faster |
Slugify over 50,000 strings (Go) |
49 ms | 4x faster |
slugify over 50,000 strings (Java) |
43 ms | 3x faster |
Measured on 4 cores; every number has a benchmark in demo/ that first checks the
results are identical. Calling Rust once per small function is usually slower than a JIT;
rust-anything finds the loop worth moving, and moves it.
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.
Paste this into Claude Code, Codex, Cursor or Gemini CLI 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 and Gemini CLI
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:
src/parser/ to Rust with rust-anything; port the first unit and prove it."rust/text-rs against the original and tell me whether to ship it."| Agent | rust-anything setup adds |
|---|---|
| Claude Code | MCP server in ~/.claude.json, skill in ~/.claude/skills/ |
| Codex | MCP server in ~/.codex/config.toml, skill in ~/.codex/skills/ |
| Cursor | MCP server in ~/.cursor/mcp.json |
| Gemini CLI | MCP server in ~/.gemini/settings.json |
| Any other MCP client | add 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).
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, ...) 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.
| Language | Unit | Bridge | Recorded and replayed by |
|---|---|---|---|
| TypeScript/JavaScript | folder or file | napi-rs or wasm-bindgen with a generated binary wire; classes and async included | Node, running the .ts sources |
| Python | package or module | PyO3 (abi3), direct conversion, typed exceptions | Python, importing the original |
| C | .c file |
extern "C" functions with the original names and a header |
the original compiled to a shared library, called through ctypes, one fork per case |
| Go | package | typed cgo calls and a generated binary wire, in a package with the original API | a generated Go driver, built as its own module |
| Ruby | file or folder of module functions | a magnus extension under the original modules | a generated Ruby driver |
| Java | package of public static methods |
typed JNI and a generated binary wire, in wrapper classes with the original methods | a generated reflection driver |
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, pyproject.toml, Gemfile,
package.json, else the most common source files); --lang overrides it. Types come from the
source: TS types, Python hints, C and Go and Java signatures, Ruby YARD tags; untyped parameters
used as numbers are inferred as numbers.
profile ──> analyze ──> bridge ──> record ──> port.rs ──> diff ──> bench ──> shadow ──> gate
where the what to the Rust what the you or every faster? both side done means
time goes port first crate and original your agent recorded the by side in this passes
wrapper does write it case verdict production
The original stays the source of truth: record runs it on edge cases (and your own inputs) and
saves what it returns or throws; diff replays every case against the Rust; nothing ships until
they all match and gate passes. Callers keep the original API throughout.
A whole app goes through the same loop unit by unit, inside a frame that proves the whole program (Port a whole app):
analyze --whole-app ──> app record ──> app front-door ──> per unit: the loop above, then app wire ──> app lift
shape, every what the app Rust owns the gate passes, so the unit answers in pure Rust,
dependency, the does from the entry point; the Rust: replay 100%, fallback rate down proved by
decisions to make outside original answers replay
| Step | Command | What it does |
|---|---|---|
| 0. Profile | rust-anything profile <repo> -- node bench.mjs |
Runs a real workload under the language's profiler (node, cProfile, go test pprof, JFR, a Ruby tracer): hot functions by inclusive time, their callers, and which loops to batch; flags code that is already compiled (numba, Cython, JAX), where Rust gains little |
| 1. Plan | rust-anything analyze <repo> |
Units, port order, risks with file:line, bridge per unit, dependency-to-crate fit, best first ports; --whole-app adds entry points and shape, every dependency (imported or declared) with its crate, pieces (units that import each other move together) and numbered decisions with a recommended answer |
| 2. Bridg |