By The Rust Reality Check
Developer Bykozy’s viral “Rust is a disappointment” blog post ignited a firestorm across Hacker News and Twitter last week, crystallizing years of mounting frustration with the memory-safe darling of systems programming. The timing couldn’t be worse for Rust evangelists—the backlash arrives just as CPython core developers propose making Rust a mandatory dependency, threatening to eliminate Python support on dozens of legacy platforms.
The controversy exposes a widening gap between Rust’s promises of “fearless concurrency” and “zero-cost abstractions” and the reality developers face: glacial compile times, borrow checker battles, and complexity that erodes productivity. Bykozy isn’t alone—his criticisms echo complaints from veteran Rust developers who, after writing hundreds of thousands of lines of Rust code, still fight the language daily.
The Criticisms Are Real, Not Skill Issues
Bykozy doesn’t mince words: Rust “sacrificed sanity and practicality for memory safety—and gets none of them at the end of the day.” His four core arguments cut to the bone. Compilation is “insanely slow by design” due to monomorphization and borrow checker demands, making it “impossible to make Rust compile fast.” The complexity is unavoidable—there’s no garbage collector coming, ever, forcing developers into Arc<Mutex<Box<T>>> patterns for basic shared state.
Even experienced developers struggle constantly. One veteran with “hundreds of thousands of lines over several years” reported still battling the borrow checker on minor changes. Small modifications to ownership structure force you to unspool half your codebase before the compiler agrees to run. The borrow checker needs ALL reference lifetimes at compile time—an unrealistic requirement that rejects far too many well-behaving programs.
Graph traversals require workarounds like Rc<RefCell<T>>, eroding both ergonomics and performance. Ten-minute builds kill flow state. This isn’t a learning curve problem—it’s a fundamental tradeoff baked into the language.
CPython’s Rust Proposal: Cargo Cult Engineering
The CPython Rust integration proposal exposes the “rewrite everything in Rust” mentality at its most absurd. Core developers Emma Smith and Kirill Podoprigora want Rust to start as optional extension modules but eventually become a required dependency throughout the CPython codebase.
The fallout? Python would disappear from multiple platforms: RISC OS, HP PA-RISC, PowerPC Mac, and others with zero Rust support. Critics warned it “would effectively eliminate modern Python on several platforms.” Then there’s bootstrapping hell—building Rust requires Python, but building Python would require Rust. Which do you install first on a fresh system?
The CPython core team acknowledged going from one to two languages is a “massive step up in complexity, both technical and social.” The proposal landed amid growing Rust criticism—terrible optics for a language already accused of overpromising and underdelivering.
Where Rust Actually Shines
Rust isn’t worthless—far from it. Discord’s voice system rewrite cut CPU usage from 20% to under 5% per core. Their message storage migration from Go to Rust delivered a 10x performance improvement. Dropbox replaced their Python storage backend with Rust, slashing memory usage by 75% and saving millions in server costs annually. Dropbox engineers called betting on Rust “one of the best decisions we made.”
The Linux kernel runs over 150,000 lines of Rust code. Google reported a 70% reduction in Android memory vulnerabilities after migrating to Rust. For systems programming, performance-critical applications, and safety-critical environments where bugs equal disasters, Rust delivers on its promises.
The pattern is clear: Rust excels with immutable, acyclic data structures—compilers, parsers, blockchains. It dominates where memory safety matters more than developer velocity.
Where Rust Falls Short
Bykozy identifies Rust’s Achilles heel: mutable shared state. GUI development, databases, and stateful services hit performance penalties through Mutex and Arc, negating Rust’s advantages. The ownership model that prevents data races also prevents straightforward business logic.
Rapid prototyping becomes impractical when every architecture decision locks you into ownership patterns. The learning curve isn’t just steep—it never flattens. Complexity drives developers toward Node.js and Go for services where memory safety isn’t critical.
Bykozy calls Rust “mediocre”—viable but overhyped, suited for specific use cases like static site generators, not universal adoption. That’s the fairest assessment yet.
Memory Safety Isn’t Everything
Rust’s entire value proposition rests on eliminating memory bugs, which cause 70% of security issues in systems software. But Bykozy points to the Cloudflare outage caused by an unwrap() panic: “memory safe and unreliable.” Rust crashes just as hard—it panics instead of exhibiting undefined behavior.
For embedded systems, malfunctioning is sometimes preferable to crashing. Memory safety solves one class of bugs while introducing new failure modes. It’s a tradeoff, not a panacea.
The Verdict: Right Tool, Wrong Hype
Rust isn’t the future of programming—it’s a specialized tool for specific problems. The industry needs to stop treating it as the default choice for everything. Use Rust where it shines: kernel development, embedded systems, parsers, performance-critical paths in mature applications.
Don’t use Rust for rapid prototyping, stateful business logic, or projects where developer velocity matters more than memory safety. Stop rewriting working systems in Rust to pad your resume. The CPython proposal is a wake-up call—mandatory Rust adoption helps no one.
Match the tool to the problem, not the hype to your career goals. Rust has a place in modern software development. That place isn’t everywhere.
