Oxidize is a Claude skill that turns Claude into a disciplined Rust-migration engineer. Point it at a Python service, a Node app, a C/C++ hot path, a Go/Java/Ruby module — and it runs a safe, incremental migration: it decides whether the rewrite is even worth it, finds the seams, stands up interop, proves the new Rust behaves exactly like the old code with differential tests, and rolls out behind a flag you can revert in one step.

It's built to avoid the three ways Rust rewrites usually die:

  • The big-bang rewrite that never ships — instead: incremental, module-by-module, always shippable.
  • Literal translation that fights the borrow checker — instead: idiom mapping (errors, ownership, OOP, async).
  • Cutting over without proving parity — instead: the old code is an oracle; differential tests gate every step.

It will also tell you when not to migrate. A skill that greenlights every rewrite is a liability.

Install

Pick whichever fits how you work — all three come from this one repo.

As a Claude Code plugin (recommended — one command):

/plugin marketplace add DeVaNsHk72/oxidize
/plugin install oxidize@oxidize

As a plain skill (no plugin system):

git clone https://github.com/DeVaNsHk72/oxidize
cp -r oxidize/skills/oxidize ~/.claude/skills/oxidize      # user-level
# or: cp -r oxidize/skills/oxidize .claude/skills/oxidize  # project-level

From the packaged file: grab oxidize.skill from the latest release and open it — click Save skill.

Then just ask, in plain language:

"Port the tokenizer in src/parse.py to Rust — it's our hot path." "Can we rewrite this Express image service in Rust without a big-bang?" "Replace our slow C extension with a safe Rust one behind PyO3."

The skill triggers on migration intent even when you don't name it.

Supported source languages

Python, JavaScript / TypeScript / Node, C, C++, Java / JVM, Ruby, C# / .NET, and Go — via the interop path that fits (in-process FFI, WebAssembly, or a strangler service).

What's inside

oxidize/
├── .claude-plugin/                   # marketplace.json + plugin.json (one-command install)
├── skills/oxidize/
│   ├── SKILL.md                      # phased workflow + when-to-migrate judgment + idiom cheat-sheet
│   ├── references/
│   │   ├── strategy.md               # FFI vs strangler-service vs wasm vs rewrite; seams; safe rollout
│   │   ├── interop.md                # PyO3, napi-rs, cxx, bindgen, JNI, magnus, csbindgen, wasm — with code
│   │   ├── translation-patterns.md   # source idiom -> idiomatic Rust (nulls, exceptions, inheritance, GC memory)
│   │   ├── verification.md           # differential/golden tests, proptest, insta, cargo-fuzz, criterion
│   │   ├── production.md             # Cargo workspace, clippy/fmt/deny/audit, CI, MSRV, release
│   │   └── pitfalls.md               # over-cloning, unsafe misuse, Arc<Mutex> soup, async spread — and escapes
│   ├── scripts/
│   │   ├── assess.sh                 # read-only codebase inventory (languages, LOC, deps, entry points)
│   │   └── parity_check.py           # reusable differential/golden harness: run old vs new, diff outputs
│   └── assets/templates/             # copy-paste Cargo workspace, deny.toml, GitHub Actions CI
├── CHANGELOG.md
└── LICENSE

The workflow it runs

  1. Assess — inventory the codebase, find hot paths and seams.
  2. Decide — is the migration worth it? smallest valuable slice? cheaper win first?
  3. Strategy — pick FFI / strangler / wasm / rewrite and the migration order.
  4. Scaffold — Cargo workspace + lint/CI gates from commit one.
  5. Verify first — stand up the differential harness before porting logic.
  6. Port — module by module, parity first, proven against the oracle, then idiomatic.
  7. Roll out — shadow, canary, cutover, delete old code — all behind a flag.

Contributing

Issues and PRs welcome — especially interop recipes for more source languages and real-world migration war stories. See CHANGELOG.md for release history.

License

MIT — use it, fork it, share it.