I Will Not Write Rust Again

The core message is blunt: the author says they’re done rewriting in Rust and don’t plan to return, even while praising Rust’s best features. Rust’s tooling and capabilities—especially enums, safety, performance, and conveniences like serialization/deserialization—still earn admiration. But the day-to-day experience of writing Rust is described as something they simply don’t enjoy, and that dislike outweighs the language’s technical strengths.

That tension drives the search for a replacement language. The transcript highlights a preference for tagged unions (the Rust enum pattern) because they map well to server workloads where incoming data includes a type discriminator and the payload varies accordingly. The author also contrasts this with other ecosystems: TypeScript is popular for heterogeneous server data, Go is “a huge pain” for that style of heterogenous modeling, yet the author still likes writing Go. They even cite a year of Go work, including building a Doom-style multiplayer game with thousands of players and using Go for game control alongside Zig.

The next step, they say, is to try something new in 2025—most likely Zig. The pitch for Zig centers on metaprogramming and the idea of “comptime” as more straightforward than Rust’s macro ecosystem. Instead of learning separate macro syntax and wrestling with multiple language layers, Zig keeps metaprogramming inside the same language, which the author frames as a productivity advantage. They also argue that manual memory management in Zig feels more honest and enjoyable than Rust’s approach, which they describe as forcing developers to contort code to avoid manual memory management—through lifetimes and other constraints. The comparison is intentionally emotional: Rust’s safety mechanisms are portrayed as a trade that removes the “raw” satisfaction the author associates with lower-level programming.

To explain that “raw” pull, the transcript reaches back to the author’s past love for C and hardware-adjacent work: building custom network protocols, writing flash drivers, manipulating registers, controlling motors, handling camera image capture, and even writing semaphore-style synchronization. That history becomes the lens for why Zig might fit—because it could recreate the feeling of direct control and engineering joy.

There’s also a social proof angle. The author claims to respect Hashimoto (Mr Hashimoto) and points to the presence of Zig in teams shipping high-performance products used by large numbers of people. They contrast this with what they perceive as fewer Rust deployments at similar scale, while noting Go’s broader adoption.

Finally, the transcript leaves room for uncertainty. The author admits they might still end up sticking with Go, but insists they won’t rewrite in Rust again. The closing is a single-take, no-nuance declaration: they’re out, and they’re moving on—possibly to Zig, possibly to something else, but away from Rust.