By ByteBot
A comprehensive Go-to-Rust migration guide from corrode.dev hit Hacker News’ front page this week, arriving alongside the freshest real-world validation the debate has had: Bun, the JavaScript runtime acquired by Anthropic, completed a Zig-to-Rust rewrite this month with a 99.8% test pass rate and 3-8MB binary size reduction. This isn’t theory anymore. Teams are doing this in production, 2026 benchmarks put a 40-50% latency gap on paper, and the corrode.dev guide is the most honest treatment of when it’s actually worth it.
Why Go Teams Are Actually Looking at Rust Now
Go’s correctness guarantees are convention-based, not enforced. Nil pointer dereferences survive code review and testing because the compiler has no opinion about them — only runtime execution reveals the problem. The -race flag catches data races during test execution, but code paths that aren’t exercised in tests stay vulnerable until production. Error handling discipline relies on linters like errcheck or golangci-lint, not the type system.
Rust moves all of this into the compiler. Option<T> replaces nullable pointers; absence is impossible to ignore. Send and Sync trait bounds make data races a compile-time error, not a runtime surprise. The ? operator makes error propagation explicit without boilerplate. Paul Dix, InfluxDB’s founder, cited data races as the primary driver for their Rust rewrite — they spent years chasing bugs that couldn’t exist in Rust. Andrew Lamb, InfluxDB staff engineer after the migration: “I hadn’t had to chase down a crash… weird multi-threaded race condition.” That reduction in oncall burden is the actual return on investment.
// Go: runtime panic if user is nil — compiler doesn't warn
return user.Account.Notify()
// Rust: compiler requires handling the None case
let user = self.repo.find(id)?; // won't compile unless None is handledWhat 2026 Benchmarks Actually Show
The numbers are real but workload-dependent. Under sustained high RPS with CPU-bound work, Rust delivers 40-50% lower tail latency, 2-4x memory reduction, and 2-12x CPU efficiency compared to Go. Bun’s migration data is the freshest: 892K HTTP req/s (Rust) vs 812K (Zig) on the same AWS hardware, with AWS Lambda cold starts dropping from 940ms to 290ms. For services where memory compounds at scale, the difference between Rust’s 50-80MB production footprint and Go’s 100-320MB is meaningful.
However, the AI infrastructure benchmark analysis from dev.to cuts through the noise: “Measure before you migrate. If your production evidence does not show GC pauses, you do not have a Go-to-Rust problem.” For services where most latency comes from upstream calls — LLM inference at 800-2000ms, database queries — the framework’s speed is irrelevant. Go’s goroutines scale elegantly in I/O-heavy workloads, and Rust’s advantage evaporates when the bottleneck isn’t the runtime.
The Migration Strategy That Actually Works
Big-bang rewrites fail. The corrode.dev guide’s core advice: pick one service with a clear API boundary, maintain identical endpoint contracts across the rewrite, and keep the rest of the Go codebase oblivious to what changed. Three patterns work in practice: the strangler (route specific API endpoints to a new Rust service while the rest stays in Go), the sidecar (replace background workers and queue consumers where the boundary is natural), and hot-path isolation (rewrite the one service that’s perpetually the reliability or latency bottleneck). Discord’s migration is the canonical example — isolated service, same contract, incremental traffic shift.
The translation trap costs teams months. Writing “Go in Rust” — converting every if err != nil to Rust literally, or spawning goroutine-equivalent tokio::spawn calls everywhere — produces verbose, unidiomatic code that fights the language. if err != nil becomes the ? operator; concurrency in axum is automatic. The recommended backend stack — axum, tokio, sqlx, serde, tracing — covers 90% of what most services need. Budget 3-6 months for a team to reach proficiency; weeks 2-4 hit a wall with the borrow checker, but by month three, most engineers report it becomes an ally rather than an obstacle. The Rust project goals update from May 2026 confirms work is underway on Polonius, the next-generation borrow checker that may reduce this friction for newcomers.
Related: Rust 1.96 Ships May 28: Fix Your WebAssembly Builds Now
When Not to Migrate
Go stays better than Rust in several categories that matter to a lot of teams. Kubernetes operators and controllers are overwhelmingly Go — client-go and controller-runtime have no Rust equivalents at production maturity. CLI tools benefit from Go’s near-instant compile times and trivial cross-compilation. Glue services and thin API layers don’t justify Rust’s boilerplate-to-logic ratio. Jon Seager, VP Engineering at Canonical, put it plainly while Canonical was actively adopting Rust elsewhere: “Go is a very fine choice for networking services.” Juju, Canonical’s large Go codebase, isn’t going anywhere.
Compile time is the concrete regression: clean release builds in Rust take 30-120 seconds against Go’s 2-10 seconds — a 10-60x gap in iteration speed that compounds across a team’s workday. Add the 3-6 month proficiency curve against Go’s 2-4 weeks, and the total migration cost is real. The corrode.dev guide is excellent, but it was written by someone who runs a Rust consultancy — read it with that in mind. The decision rule is simpler than the coverage suggests: use Go for the 80% of services where velocity matters, reach for Rust for the 20% where reliability or performance justify the cost.
Key Takeaways
- The Go-to-Rust migration debate has moved from theory to data: Bun’s 99.8% test pass rate and the corrode.dev guide give teams concrete evidence to work from
- Rust eliminates entire categories of Go production bugs — nil panics, data races, missed error paths — by making them compile-time errors instead of runtime surprises
- 2026 benchmarks show 40-50% lower tail latency and 2-4x memory reduction, but only in CPU-bound, high-RPS workloads — measure your actual bottlenecks first
- Migration strategies that work: strangler pattern, sidecar replacement, hot-path isolation — never big-bang rewrites; maintain API contracts across the boundary
- Go wins for Kubernetes tooling, CLI utilities, glue services, and anywhere iteration speed matters more than compile-time correctness guarantees
