Awesome Rust Migrations

Migrating existing codebases to Rust — and eliminating memory-safety vulnerabilities at the source.

Rewriting C, C++, and other legacy code in Rust is now a serious, funded, engineering discipline: Google is rewriting dependencies with AI assistance, CISA and the NSA tell vendors to publish memory-safe roadmaps, and DARPA is paying to translate all of C. This list tracks the evidence, the rewrites, the tools, and the research.

Contents

• The Evidence
• AI-Assisted Rewrites
• Automated Translation and C2Rust Case Studies
• Production Adoptions at Scale
• Language Toolchains Rewritten in Rust
• Tools and Interop
• Research
• Guides, Articles, and Talks
• Choosing Crates
• Adjacent Lists

The Evidence

The data and policy behind the migration movement. Memory safety bugs are the majority of serious vulnerabilities in C and C++ codebases, and Rust measurably eliminates them.

• Scaling Memory Safety: AI-Assisted Rewrites of C/C++ Dependencies to Rust - Google's pilot using Gemini to rewrite C/C++ dependencies such as giflib into Rust, with the process, verification, and lessons from scaling AI-assisted translation.
• Gemini 4 Argon: our next era of frontier intelligence - Google's September 2026 announcement scaling the giflib pilot to company-wide migration: Argon agents port C/C++ codebases to Rust from tens of thousands of lines in re2 and libgav1 up to 800K+ lines for the Fuchsia Zircon kernel, under automated and manual auditing and emulation testing; for libgav1, agents replaced 32K lines of hand-written SIMD with auto-vectorizing safe Rust, 2.7x faster than the previous Rust port with identical video output.
• Rust in Android: move fast and fix things - 2025 update: Android memory-safety vulnerabilities fell below 20% of the total for the first time, with Rust code showing roughly 1000x lower memory-safety vulnerability density than C and C++ code.
• Eliminating memory safety vulnerabilities at the source - Google Security Blog analysis of why new safe code beats rewriting old code, and how Android's strategy turns off the tap of new memory-unsafe code.
• Chromium: Memory safety - The Chromium project's canonical page: roughly 70% of serious security bugs are memory safety issues, and the plan to address them, including Rust.
• The Case for Memory Safe Roadmaps - Joint guidance from CISA, NSA, FBI, and international partners urging every technology manufacturer to publish a memory-safe roadmap and describe how memory-unsafe dependencies will be eliminated.
• Software Memory Safety Is Cybersecurity - CISA advisory AA23-352A on memory safety as a national cybersecurity concern, with language-by-language migration recommendations.
• Memory Safe Languages: Reducing Vulnerabilities in Modern Software Development - Joint NSA and CISA Cybersecurity Information Sheet (2024) on adopting memory-safe languages, expanding on NSA's original Software Memory Safety guidance and the White House ONCD "Back to the Building Blocks" report.
• Prossimo: Memory Safety - Internet Security Research Group initiative funding memory-safe rewrites and foundations, including rav1d, rustls, zlib-rs, and Rust support in the Linux kernel.
• Rust Is Tier-1 Language at Microsoft - Rust Foundation guest post by Microsoft's Rust tooling lead: Rust now sits alongside C++, C#, and TypeScript as a Tier-1 internal language at Microsoft, backed by rustc_codegen_utc, an MSVC-native code-generation backend already building 100+ internal projects and enabling deep Rust/C++ interop.
• Introducing CUDA Rust: Two Tracks for Writing GPU Kernels - NVIDIA's September 2026 announcement of native Rust GPU kernels compiled to PTX (cuda-oxide for SIMT, cutile-rs for tiles), where aliasing and out-of-bounds errors fail at compile time; the Nova Linux driver is already written in Rust.
• DARPA TRACTOR - DARPA program to automate translation of legacy C code to Rust using software analysis and machine learning.
• TRACTOR Benchmarks - MIT Lincoln Laboratory benchmarks and evaluation work for DARPA's C-to-Rust translation program.

AI-Assisted Rewrites

Projects pushing the limits of AI-assisted rewrites into Rust, where behavior compatibility and test suites are the bar.

• Bun Zig-to-Rust rewrite - Bun merged "Rewrite Bun in Rust" on May 14, 2026 from the claude/phase-a-port branch, adding a Rust workspace across thousands of files; Bun canary builds are released from every main commit via bun upgrade --canary.
• Grit - GitButler's AI-authored Git reimplementation in Rust, targeting close behavior compatibility with upstream Git by porting and running the Git test suite against grit-git.
• Ladybird's Rust adoption - Browser project adopting Rust with AI assistance, starting with LibJS because it is relatively isolated and has extensive test coverage.
• pacquet - Official pnpm rewrite in Rust, porting the pnpm CLI from TypeScript to Rust while matching pnpm behavior, flags, defaults, error codes, file formats, and directory layout.
• pgrust - PostgreSQL rewrite in Rust using AI-assisted engineering, with PostgreSQL behavior and compatibility tests as the bar.
• OpenAI Habitat Python-to-Rust rewrite - OpenAI rewrote its Habitat storage service from Python to Rust in Q2 2026 with two engineers plus Codex and GPT-5.5; the Rust service now handles 95% of production requests (over 20M requests per second at the Python version's peak), with 6x CPU and 15x memory efficiency.
• tsz - AI-assisted Rust implementation of a TypeScript checker targeting drop-in tsc compatibility, with conformance progress reported against the official TypeScript test suite.

Automated Translation and C2Rust Case Studies

These are mostly not AI-assisted, but they are the prior art for automated translation, cleanup, safety work, and compatibility.

• libbzip2-rs - Drop-in compatible Rust implementation of bzip2 created with C2Rust and later used by the bzip2 crate.
• libyaml-safer - Fully safe Rust fork of unsafe-libyaml, originally translated from libyaml with C2Rust.
• rav1d - Fully safe Rust port of the dav1d AV1 decoder, created with C2Rust and then refactored toward safer, more idiomatic Rust.
• rexpat - Rust port of Expat used as a C2Rust case study.
• sapp-kms - C2Rust-derived port of sokol's KMS backend, cleaned up but still unsafe.
• spiro.rlib - Fully safe C2Rust-derived port of the spiro spline interpolation library.
• tsuki - Fully safe C2Rust-derived port of the Lua interpreter.
• unsafe-libyaml - Mostly direct C2Rust-derived port of libyaml, kept fully unsafe with minor cleanup.
• zlib-rs - Rust implementation of zlib exposed as both a C dynamic library and a Rust crate.

Production Adoptions at Scale

Not necessarily AI-assisted — these show large production systems replacing services and infrastructure with Rust implementations.

• Cloudflare FL2 front line - Cloudflare rebuilt the 15-year-old Front Line proxy in front of roughly 20% of the internet from NGINX/OpenResty and Lua (FL1) into Rust (FL2), using an adapter layer to run Rust modules inside the old system first and the Flamingo automated test framework to prove parity during the cutover.
• Discord Read States Go-to-Rust rewrite - Discord's writeup of rewriting the Read States service from Go to Rust after garbage-collector spikes caused latency problems; the canonical account of what problems Rust actually solves and what it costs in ecosystem maturity.
• Shipping JPEG XL in Chrome - Chrome 155 ships JPEG XL decoding via jxl-rs, a safety-first Rust reimplementation replacing the roughly 100,000-line multithreaded C++ reference decoder; Mozilla made a Rust decoder its condition for Firefox adoption, so every major engine gets the memory-safe path.
• Rust for CPython (Python Language Summit 2026) - Official status update on bringing Rust into the CPython interpreter itself: incremental integration targeting Python 3.16, the build system already compiling CPython with Rust across platforms in CI, a ~60-contributor team led by core developers, and open discussion of sanitizer compatibility and acceptance criteria.
• Three years migrating latency-sensitive services to Rust - Stephen Blum's writeup of a three-year migration of latency-sensitive services from Python, Go, JVM, and C, measured against fifteen dashboard panels that predated the migration: replacing an nginx balancer with Pingora took average balancer time from 600ms to 101ms on identical hardware and traffic, hottest-path publish latency fell from ~350µs to ~50µs, and a candid post-mortem covers a Tokio failure where unbounded task-per-request spawns grew a 100 MiB pod to 3.7 GiB until backpressure at the ingest edge fixed it.
• gRPC Rust - Tonic officially moved into the gRPC project under the CNCF, with Google building a new production-grade grpc-rust implementation alongside it.
• InfluxDB Rust monolith - InfluxData rewrote core account and resource management APIs from Go microservices into a single Rust monolith, using the strangler pattern for a zero-downtime migration.
• Grab's Counter Service - Grab deliberately rewrote a Go service in idiomatic Rust rather than translating it line by line, migrating traffic incrementally.
• rustls - Memory-safe TLS library in Rust, Prossimo-funded and available as an officially supported TLS backend in curl, giving the incumbent C TLS ecosystem a production Rust alternative.
• Rustwright - Alpha Rust reimplementation of Playwright's browser-control engine under Playwright-shaped Python and Node APIs; reports 515 shared parity cases and 1,046 Docker-gate tests, plus local diagnostic speed and client-memory gains, while explicitly saying full behavioral parity is not yet proven.
• Turso - Rust rewrite of SQLite evolving into a pluggable database core; its new PostgreSQL frontend compiles PostgreSQL syntax and types to Turso bytecode, targets common-application compatibility rather than 100% PostgreSQL parity, and documents simulation, oracle, fuzz, and formal-method testing.
• WhatsApp wamedia rewrite - Meta's writeup of rewriting WhatsApp's media validation library from 160,000 lines of C++ to 90,000 lines of Rust, validated with differential fuzzing and a parallel rollout with rollback, with performance and memory improvements.
• libsignal - Signal's Rust cryptography and protocol library, migrated from libsignal-protocol-c and shipped to billions of devices behind FFI bridges to Swift, Java, and TypeScript.

Language Toolchains Rewritten in Rust

The loudest mass migration of all: other languages' compilers, package managers, linters, type checkers, and bundlers rebuilt in Rust, usually 10-100x faster than the tools they replace. AI-authored toolchain rewrites such as pacquet and tsz are listed under AI-Assisted Rewrites.

Python

• ty - Astral's Python type checker in Rust, a fast alternative to mypy and pyright that reached beta in December 2025.
• uv - Rust Python package and project manager designed as a fast replacement for tools such as pip, pip-tools, pipx, poetry, and virtualenv.
• Ruff - Rust Python linter and formatter that replaces or consolidates tools such as Flake8, isort, and Black.
• Pyrefly - Meta's Rust rewrite of its OCaml-based Pyre type checker, built on a custom incremental computation engine and validated on Instagram's codebase before its 1.0 release in 2026.
• pixi - Prefix.dev's Rust package manager for the conda ecosystem, built on the rattler crates — a full Rust reimplementation of conda metadata, SAT solving, downloading, and installing that has since moved into the conda organization itself.

JavaScript and TypeScript

• Astro 7 - Astro rewrote its .astro compiler in Rust, made its Rust-powered Markdown and MDX pipeline the default, and reports 15-61% faster builds across benchmark sites.
• Biome - Rust web toolchain for formatting, linting, and code analysis, positioned as a faster alternative to common JavaScript tooling.
• Deno 2.0 - Rust-based JavaScript and TypeScript runtime with Node.js and npm compatibility, plus built-in formatter, linter, test runner, and task runner.
• Lightning CSS - Rust CSS parser, transformer, bundler, and minifier used by Parcel and other tools.
• Next.js Compiler - Rust/SWC-based compiler that replaces Babel for individual files and Terser for minification in Next.js.
• Oxc - Rust JavaScript tooling stack covering parser, linter (oxlint), formatter, transformer, resolver, and minifier.
• Rolldown - Rust Rollup-compatible bundler used by Vite to replace its previous esbuild/Rollup split.
• Rspack - Rust Webpack-compatible bundler designed for progressive migration from Webpack.
• SWC - Rust platform for JavaScript and TypeScript compilation that replaces Babel; the base layer under the Next.js Compiler and many other tools.
• Tailwind CSS v4 - New high-performance Tailwind engine using Rust-powered pieces and Lightning CSS, with substantially faster full and incremental builds.
• Turbopack - Vercel's Rust-based successor to Webpack, introduced through Next.js.

Ruby

• Porting the YJIT Ruby Compiler to Rust - Shopify ported Ruby's YJIT JIT compiler from C to Rust, shipping as the default in Ruby 3.2; the write-up covers fighting the borrow checker over cyclic compiler data structures and why Rust still won on development velocity and safety.

Cross-Ecosystem

• mise - Polyglot tool version manager and task runner in Rust (formerly rtx), a drop-in replacement for asdf, nvm, pyenv, rbenv, and direnv, with native backends steadily replacing asdf's shell-script plugins.
• proto - Moonrepo's Rust-based multi-language toolchain manager, using WebAssembly plugins instead of shell scripts to version Node.js, Bun, Deno, Python, and other runtimes.

Tools and Interop

Translators, migration platforms, and the FFI/interop machinery that makes incremental migration practical.

• C2Rust - C-to-Rust translator and refactoring toolkit for migrating C code to Rust.
• Corrode - Older C-to-Rust translator, useful historical context for deterministic translation.
• ShiftCodex - AI code migration platform built around translate, test, fix, and re-run loops.
• autocxx - Google's tool for calling C++ from Rust with a safe, generated binding layer, designed for incrementally introducing Rust into large C++ codebases such as Chromium.
• crubit - Google's bidirectional C++ and Rust interoperability tooling.
• cxx - Safe interop between Rust and C++ with a shared bridge definition and static analysis of the boundary.
• bindgen - Generates Rust FFI bindings from C and C++ headers, the first tool most migrations touch.
• uniffi - Mozilla's toolkit for generating foreign-language bindings from Rust, used to ship Rust cores behind Kotlin, Swift, and Python APIs.
• corrosion - CMake integration for Cargo, for adding Rust targets to existing C and C++ builds.
• Rust/C++ Interop Initiative - Rust Foundation initiative mapping and closing Rust/C++ interoperability gaps, the practical prerequisite for incremental C++ to Rust migration in large codebases.
• CO3: Toward the Optimal FFI - Design exploration of a bidirectional Rust/C FFI model: pure-Rust declarations for imports and exports of functions, statics, methods, and opaque types, with ownership transfer across the boundary and static monomorphization or runtime tag dispatch where C has no generics.
• neon - Safe Rust to Node.js bindings, the standard way to put a Rust core behind Electron desktop apps.
• wasm-bindgen - Rust to WebAssembly bindings, used to ship shared Rust cores into web apps and browser extensions such as Proton Pass.

Research

Academic work on C-to-Rust translation, from LLM-assisted pipelines to program-analysis-guided migration.

• C2RustXW - C-to-Rust translation that combines program analysis, LLM translation, dependency-aware ordering, and execution-based validation.
• EvoC2Rust - Skeleton-guided framework for project-level C-to-Rust translation.
• Rustine - Repository-level C-to-Rust translation system targeting compilable, idiomatic, safer Rust with test-verified functional equivalence.
• &inator - Correct and precise C-to-Rust interface translation.
• SafeTrans - LLM-assisted C-to-Rust transpilation with iterative repair.
• SACTOR - LLM-driven multi-step C-to-Rust translation using static analysis.
• RustMap - Project-scale C-to-Rust migration using program analysis, LLMs, dependency guidance, and test feedback.
• LLM4C2Rust - Retrieval-augmented C/C++ to Rust transpilation framework focused on memory safety.
• Scylla - Formalized translation of an applicative subset of C to safe Rust, targeting memory safety by construction rather than after-the-fact cleanup.
• CNnotator - LLM-guided synthesis of CN memory-safety annotations for C code, cutting the manual annotation effort needed to verify legacy C during migration.
• MISRust - Mapping of MISRA-C++ safety-critical coding guidelines to Rust, supporting qualification arguments for Rust in safety-critical migrations.

Guides, Articles, and Talks

Practical write-ups on how teams actually run these migrations.

• Memory-Unsafe Code Is a Liability - Corrode's 2026 essay on why memory safety is the lowest-hanging fruit in software security and where Rust fits in migration plans.
• C++ to Rust Migration - Luca Palmieri's guide to incremental C++ to Rust migration for large, active, customer-deployed systems.
• Rewriting in Rust: Performance, Failures, 2026 Reality Check - JetBrains survey of Rewrite It In Rust attempts, separating the projects where rewrites delivered measurable performance and safety wins from those that stalled or were abandoned.
• A Year of Rust in ClickHouse - Alexey Milovidov's account of integrating Rust into the 1.5M-line C++ ClickHouse codebase without a rewrite: the BLAKE3 beachhead, skim and PRQL experiments, and replacing the C++ Delta Lake reader with delta-kernel-rs — including hermetic builds, vendoring, MSan-instrumented Rust, and fuzzers catching panics in Rust libraries.
• How to use Rust in ClickHouse: avoiding a full rewrite - Annotated P99 CONF 2025 talk on why a large C++ codebase should adopt Rust incrementally: pick a rip-out-able component first, and expect 672 transitive dependencies, FFI ownership bugs, and sanitizer friction along the way.
• Porting C to Rust for a Fast and Safe AV1 Media Decoder - Prossimo write-up on the goals and approach behind rav1d.
• Making the rav1d Video Decoder 1% Faster - Performance case study on a C2Rust-derived port.
• Translating bzip2 with C2Rust - Trifecta Tech Foundation write-up on translating bzip2 with C2Rust.
• Rust Is Eating JavaScript - Lee Robinson's evolving survey of Rust replacing JavaScript tooling, updated in 2026 with Turbopack, Rolldown, Oxc, Biome, Rspack, Tailwind CSS v4, Deno, uv, and Ruff.
• Using GPT-4 to Assist in C to Rust Translation - Galois experiment using GPT-4 for behavior-preserving refactoring in C2Rust output.
• Function Argument Nullability Using an LLM - Galois article on augmenting C2Rust migration analysis with an LLM.
• Canonical Funded a PhD to Translate C to Rust. Ask Why. - Critical analysis of what AI C-to-Rust translation leaves behind, the residual-unsafe-code problem, and how Google's data argues for writing new safe code rather than translating the old corpus.
• Ghosts in the Silicon: Fixing Memory Safety and Surviving Hardware Decay - Discussion with computer scientist Dan Wallach covering DARPA TRACTOR, the correctness-safety-idiomaticity trilemma of automated translation, and why manual rewrites cannot scale to the legacy C corpus.
• How Turborepo is porting from Go to Rust - Vercel's account of incrementally porting Turborepo from Go to Rust instead of a full rewrite: the Rust shim wrapping Go compiled as a C static library, JSON-over-FFI to shrink the interop surface, and the musl static-linking pitfalls that forced a two-binary design.
• Cross-platform Rust: how WhatsApp, Signal and more ship Rust to billions of devices - Analysis of the two production architectures for shared Rust cores (whole-core vs targeted libraries), UniFFI versus raw FFI bridging, and WhatsApp's C++ to Rust media library migration.

Choosing Crates

A migration is not finished when the code compiles — the next question is which crates to build on. These are curated, opinionated answers from people who have spent serious time in the ecosystem.

• blessed.rs - Community-curated guide to the crates most often reached for per task, organized by domain; the standard answer to "which crate should I use".
• stdx - Kerkour's extended-standard-library project: a curated, supply-chain-conscious set of crates designed to work from 2 KiB embedded targets up to large servers.
• Lessons learned building stdx - The design rationale behind stdx: why an extended standard library, heap-allocation discipline, and runtime-agnostic APIs.
• Rust Cookbook - Practical recipes for common tasks using the best crate for each job, from the Rust Nursery.

Adjacent Lists

• Awesome Rust - Rust code and resources.
• Awesome AI Rust Rewrites - The AI-assisted-rewrite-focused ancestor of this list.
• Awesome Alternatives in Rust - Reimplementations and alternatives written in Rust.
• Awesome Transpilers - Transpilers and source-to-source compilers.

Footnotes

This list is intentionally narrow. It is not a general Rust list, a general AI coding list, or a list of greenfield Rust projects. Scale and ambition matter: entries should replace a meaningful surface of an established system or demonstrate unusual migration scope. Small wrappers, plugins, and accelerators are out of scope even when they are useful and well built.

Good entries should show at least one serious validation signal: test results, compatibility target, benchmark data, migration log, source and target code links, or discussion of unsafe code and semantic gaps.

Contributions are welcome. See CONTRIBUTING.md. To steer the list's direction, join the standing direction discussion; to propose content without opening a PR, use the suggest-an-entry thread.

This list started as an expansion of malisper's Awesome AI Rust Rewrites (CC0), which is linked in Adjacent Lists above.