The Rust Rewrite: Why Windows and Linux Are Finally Abandoning C/C++

For four decades, the digital world has been held together by the programming equivalent of duct tape and prayers: C and C++. From the operating system running your laptop to the firmware in your microwave, these languages gave developers absolute control over hardware. But that power came with a fatal flaw.

Before you read: We’ve previously discussed how Valve bypassed the Windows monopoly at the OS level in Proton’s Silent Coup. But underneath both of those operating systems, a much deeper architectural war is currently being waged over the kernel itself.

Table of contents

• The 70 Percent Problem
• Linus Torvalds and the Gates of Hell
• Microsoft’s Quiet Capitulation
• The Reality Check
• Fun Facts
• Sources

The 70 Percent Problem

I honestly never thought I would see the day when the US government would weigh in on compiler choices. But earlier this year, the White House Office of the National Cyber Director (ONCD) issued a blunt report urging the tech industry to abandon C and C++ in favor of memory-safe languages.

They didn’t do this out of a sudden passion for modern syntax. They did it because of the math.

Both Microsoft and Google have independently published data showing that roughly 70% of all severe security vulnerabilities in Windows and Chrome are memory safety issues. We are talking about buffer overflows, use-after-free bugs, and out-of-bounds reads. Debugging a C++ use-after-free vulnerability is like trying to find a gas leak with a lighter. You usually find it, but you don’t survive the discovery.

For years, the industry’s solution was just to “code better.” We built endless static analysis tools and sanitizers. None of it worked. Human beings simply cannot write millions of lines of manual memory management without screwing up. Enter Rust.

Linus Torvalds and the Gates of Hell

If you know anything about Linux creator Linus Torvalds, you know he famously hates C++ and has fiercely guarded the Linux kernel as a C-only sanctuary since 1991. Pitching a new language for the kernel was widely considered a career-ending move.

Yet, in late 2022, Torvalds officially merged the initial Rust support into Linux 6.1.

Replacing C in the Linux kernel is like attempting to swap out the foundation of the Empire State Building while people are still working on the 80th floor. But the Linux community realized that Rust’s “borrow checker”—a notoriously strict compiler feature that refuses to compile your code if it detects potential memory bugs—was the only way to stop the endless bleeding of security patches. Rust guarantees memory safety at compile time without needing a garbage collector, meaning it runs exactly as fast as C.

Microsoft’s Quiet Capitulation

Over in Redmond, Microsoft is undergoing an even more radical shift. The Windows kernel is a monolithic beast, carrying decades of legacy code. One of its most notorious components is Win32k.sys, the graphics and window management subsystem that has been a goldmine for attackers looking for privilege escalation exploits.

Microsoft is actively rewriting core parts of the Windows kernel, including Win32k, in Rust. The company that literally built its empire on Visual C++ is now shipping Rust code in the heart of its flagship operating system. When Microsoft admits that C++ is too dangerous for kernel space, the debate is officially over.

The Reality Check

Frankly, the “Rewrite it in Rust” crowd can be insufferable. They treat the language like a religious artifact that cures all software ailments. The reality on the ground is much harsher.

Rust’s compilation times are abysmal. If you are used to the rapid iteration of modern web dev, compiling a massive Rust codebase will give you enough time to rethink your life choices. The learning curve is also a brick wall; developers have to unlearn decades of object-oriented habits and fight the compiler for weeks before things click.

We are not going to see C and C++ disappear tomorrow. There are billions of lines of legacy code running the global financial system, aerospace infrastructure, and legacy game engines. But the default choice for new systems programming has irrevocably changed. The era of manual memory management is ending, and frankly, good riddance.

Fun Facts

• The Staircase Epiphany: Rust creator Graydon Hoare was inspired to start working on the language in 2006 after the elevator in his apartment building crashed due to a software bug, forcing him to climb 21 flights of stairs.
• What is a Segfault anyway? The term “segmentation fault” dates back to the 1960s with the Multics operating system, which used physical memory segments. When a program tried to access a segment it didn’t own, the system threw a “fault.”

Sources

• White House Office of the National Cyber Director (ONCD) Report on Memory Safety (2024)
• Microsoft Security Response Center: “A proactive approach to more secure code”
• Google Chromium Project: “Memory safety in Chrome”
• Linux Kernel Mailing List (LKML): Rust support merged in 6.1