Introduction
Brothers, those of us in IT, especially those of us working at the low level and in systems, who hasn’t been tormented by memory issues in C/C++?
Buffer overflows, dangling pointers, Use-After-Free… … at best, they cause program crashes, and at worst, they create security vulnerabilities that can be exploited by hackers with a single click. How many nights have we stayed up and how much hair have we lost trying to patch these holes?
For so many years, everyone has been shouting about the “successor to C++”, but there has never been a definitive answer.
Until November 13, Google provided us with a hardcore answer. Google’s Jeff Vander Stoep announced a milestone: With the continuous embrace of Rust by the Android system, the number of memory safety vulnerabilities has, for the first time in history, dropped below 20% of the total vulnerabilities!
But do you think that’s all? Hey, what truly amazed me is the following set of data.
🚀 The Biggest Surprise: Faster and More Stable!
I initially thought Google switched to Rust for safety, at most sacrificing some development efficiency, considering it a “safety investment”.
However, Jeff from Google bluntly stated: “We use Rust for safety… but the biggest surprise is its impact on software delivery.”
Look at this set of data, it’s quite impressive:
- Rollback Rate Reduced by 4 Times The probability of needing a “rollback” after deploying code written in Rust is 4 times lower than that of C++!
- Code Review Time Reduced by 25% Code reviews are faster, indicating higher code quality and fewer disputes.
What does this indicate? It shows that Rust’s strict compiler and ownership model help you eliminate most low-level errors during the development phase.
This made even Google’s executives exclaim:
“A safer path is now also the faster one.”
🛡️ A 1000-Fold Difference: Why Rust?
Let’s look at the safety data, which is even more “devastating”.
Compared to the C/C++ codebase of Android, Rust’s memory safety vulnerability density has plummeted by 1000 times!
This is not an exaggeration. Google provided a trend chart:
- In 2019, Android had 223 memory safety vulnerabilities.
- By 2024, this number has dropped to less than 50.
This is all thanks to Rust. Rust’s ownership, borrowing, and lifetimes mechanisms, eliminate the vast majority of memory safety risks at compile time.
In simple terms: previously, when using C++, you had to manage every “key” (memory pointer) yourself, and if you didn’t manage it well, problems would arise; now with Rust, the compiler acts as your “personal steward”; if you don’t follow the rules, it simply won’t let you compile.
🧐 Wait, Does Rust Have No Bugs?
Hey, we can’t make such absolute statements. As seasoned engineers, we all know that doesn’t exist.
Google also candidly emphasizes: “Defense-in-Depth” is the way to go.
They even revealed a “bombshell”: in an AVIF image parser (CrabbyAVIF) written in <span>unsafe Rust</span>, they discovered a high-risk memory safety vulnerability (CVE-2025-48530, CVSS score 8.1), which theoretically could lead to remote code execution.
Seeing this, you might say: “Look! Rust is not that great!”
Hold on, the follow-up to this matter is the technical focus:
- “Unsafe” Does Not Mean Unsecure This vulnerability appeared in an
<span>unsafe</span>code block.<span>unsafe</span>is a “backdoor” provided by Rust that allows you to perform operations that the compiler cannot guarantee are safe (such as interacting with C/C++). The key point is,<span>unsafe</span>does not mean turning off all safety checks; it simply shifts the responsibility of ensuring safety from the compiler to the programmer. And Google’s data proves that, even with<span>unsafe Rust</span>, its vulnerability density is still much lower than that of C/C++. - The Victory of Defense-in-Depth Interestingly, although this vulnerability was discovered, it never made it into a public release. Moreover, Google’s engineers found that even if this bug had been released, another “bodyguard” built into the Android system—the Scudo memory allocator—would have made this vulnerability impossible for hackers to exploit!
This is “Defense-in-Depth”! If one layer fails, there are second and third layers.
🌍 Next Steps: Rust Will Deepen into Android’s “No-Man’s Land”
Having tasted the sweetness, Google now has ambitions beyond this.
They are planning to promote Rust’s “safety and productivity advantages” to more core “no-man’s land” areas of the Android ecosystem:
- Kernel
- Firmware
- Key Apps (such as Chromium, Nearby Presence, MLS security layer, etc.)
For example, the PNG, JSON, and font parsers in Chromium, which have traditionally been high-risk modules, have already been replaced with Rust’s memory-safe implementations.
Conclusion
As an IT professional, I have watched C/C++ shine for so many years; they certainly won’t disappear overnight.
But Google’s practical report presents the data clearly: A safer and proven more efficient choice has arrived.
Brothers, I think: Rust is worth our time to learn.
Has your team started using Rust? Or are you still observing? Let’s discuss your thoughts in the comments!