Rust Adoption Stalled: What It Means and What I'd Bet On Instead

Rust just did the thing everyone said would eventually happen. In July 2026, it entered the TIOBE Index top 10 for the first time ever, landing at No. 10, up from somewhere around No. 18 a year earlier.^[1] That was the headline of the index's 25th-anniversary edition, and the Rust crowd took a victory lap. Fair enough. It's a real milestone for a language that started as a Mozilla side project.

But I've been watching this language for years, and the top-10 headline hides the more interesting story. Rust is the most admired programming language on earth, and has been for nearly a decade. It is also, by any honest measure of who actually ships it for a living, a niche language. Those two facts sitting next to each other is the whole thing. The loudest language is not the winning one, and pretending otherwise sets people up to bet wrong.

The affection is not in dispute

Let's give Rust its due, because it earned it. Rust was named the most admired programming language in the 2025 Stack Overflow Developer Survey.^[2]That is not a one-off. It has topped Stack Overflow's most-loved and most-admired list for nine consecutive years, from 2016 through 2024. Nine years. Nothing else comes close to that kind of sustained developer affection. When people who use a tool keep saying they want to keep using it, year after year, that signal is worth taking seriously.

And the ecosystem numbers are not tiny. JetBrains estimated roughly 2,267,000 developers used Rust in the prior 12 months, with about 709,000 naming it their primary language.^[3] The official 2025 State of Rust Survey pulled 7,156 responses, basically flat against 7,310 the year before.^[4] This is a language with a large, engaged, loyal community. None of that is in question.

Now look at who actually ships it

Here's where the story turns. Despite all that love, professional adoption stays thin. JetBrains' 2025 State of Rust data shows only about 26% of Rust users apply it in professional projects. Sixty-five percent use it for side or hobby projects, and 52% are still learning the language.^[3] Read that again. The single biggest cohort of Rust users is people who are still figuring it out, and the second is people using it after hours.

The job market says the same thing, just more bluntly. filtra.io-tracked data showed roughly 606 open Rust roles globally as of February 2026.^[5]Globally. That's not a typo. Now, postings did grow about 35% year over year, and they crossed 1,000 monthly listings for the first time in January 2025, so the direction is up. But you have to hold both numbers in your head at once. A 35% growth rate on a very small base is still a very small base. If you're a bootcamp grad deciding what to learn to get hired, 606 open roles worldwide is a rounding error next to what Python, JavaScript, or even Go put on the board.

The compile-time complaint tells you why this ceiling exists. Across the 2025 survey, compilation speed and resource usage remained the single biggest developer gripe, same as the year before.^[4]That is the tax you pay for the guarantees. The borrow checker that makes Rust safe is the same thing that makes it slow to compile and hard to learn. You don't get the safety for free. You pay for it in ramp-up time and in feedback-loop latency, and a lot of teams look at that bill and decide it's not worth it for the service they're shipping.

Where Rust actually wins, and it wins hard

So if the industry-wide takeover isn't happening, is Rust just hype? No. And this is the part the “Rust is dying” crowd gets wrong just as badly as the “Rust eats everything” crowd. In the specific place Rust is designed for, memory-safety-critical systems code, the payoff is not marginal. It's enormous, and it's measured.

Google is the receipt here. In 2025, Google reported that memory-safety vulnerabilities fell below 20% of Android's total vulnerabilities for the first time, down from over 70% a few years earlier.^[6]That drop was driven by writing new code in Rust, not by better patching of old C and C++. Think about what that means. They didn't get better at cleaning up messes. They stopped making the mess in the first place.

The density numbers are almost hard to believe. Google measured roughly a 1000x lower memory-safety vulnerability density in Rust versus C and C++ on Android, about 0.2 versus around 1,000 flaws per million lines of code.^[6]And it wasn't just safer, it was operationally cheaper. Rust changes saw roughly 4x lower rollback rates, about 20% fewer revisions, and 25% less time in code review. Android now holds roughly 5 million lines of Rust, and Google says net new first-party Rust code slightly passed C++ volumes by Q3 2025.^[6]

This is the case for Rust in one paragraph. When the cost of a bug is a remote exploit on a billion phones, the borrow checker's tax is obviously worth paying. When the cost of a bug is a 500 error you fix and redeploy in ten minutes, it obviously isn't. Rust doesn't need to win the whole industry. It needs to win the code where memory bugs are catastrophic, and there it is winning cleanly.

The kernel story is more honest than the hype

The Linux kernel is where a lot of people expected Rust to plant its flag, and it's a useful reality check. Rust in the kernel remains a small fraction of the codebase, around 25,000 lines against 34 million lines of C.^[7]The Rust subsystem was declared past its experimental phase in 2025, which matters. But that same year, the first CVE tied to Rust kernel code was assigned, which is a healthy reminder that “memory safe” is not “bug free.” Safety in the language closes one whole class of vulnerability. It does not make the code correct.

Reporting through 2025 and 2026 kept using the same word for all of this: leveling off.^[8]Techzine and JetBrains both framed Rust's kernel and broader adoption curve as a steady structural presence rather than an accelerating takeover. The organizational data backs that framing. Non-trivial Rust use at organizations sat around 45.5%, up from 38.7% the prior year, but it held roughly steady into 2025 rather than climbing further.^[4]That's a plateau, not a launch ramp. The honest read is that Rust found its niche and settled into it, which is a very different outcome from the one the loudest advocates promised.

Cargo is the underrated asset

If you want to know where Rust's real durable advantage lives, it isn't the job board and it isn't the kernel. It's the tooling. Cargo, Rust's build tool and package manager, was rated the most admired cloud development and infrastructure tool at 71% in the Stack Overflow survey.^[2] Not the most admired Rust tool. The most admired infrastructure tool, period, beating things far outside the Rust world.

I think this is the most underrated fact in the whole Rust story. Anyone who has fought with C++ build systems, or juggled Python virtual environments and dependency hell, knows that tooling is where languages actually live or die day to day. Cargo got that right from the start. The build, the package manager, the test runner, the formatter, the doc generator, all of it coheres in a way that older systems languages never managed. That is the kind of advantage that compounds quietly. It doesn't show up in a TIOBE ranking, but it's the reason people who try Rust tend to stay.

The regulatory tailwind is the wildcard

Here's the factor that could move the plateau, and it's not a technical one. CISA and the White House Office of the National Cyber Director ran a “Secure by Design” push that required critical-infrastructure software makers to publish a memory-safety roadmap by January 1, 2026.^[9] Over 296 organizations, including Google and GitHub, had signed the pledge by late 2025, against a backdrop where roughly 70% of severe security defects get attributed to memory-safety errors.

This is the thing that could turn Rust from “admired” into “mandated” in specific corners. When the government tells infrastructure vendors to publish a plan for getting off memory-unsafe languages, Rust is the most obvious destination for a lot of that new code. It doesn't create a million jobs overnight. But it changes the default in exactly the high-stakes systems niche where Rust already wins, and regulatory defaults are stickier than fashion.

What I'd actually bet on

So put it together. Rust is not going to displace Go for backend services, or Python for data and glue, or JavaScript for the web. The adoption curve leveled off, the job market is thin at 606 global roles, and two-thirds of users still keep it in side projects. Anyone selling you “learn Rust and the jobs will flood in” is reading the hype, not the data.

But the opposite bet is just as wrong. Rust owns the memory-safety-critical niche, and that niche is expanding, not shrinking. Google's numbers make the technical case unarguable. Cargo gives it a tooling moat. And the CISA push is quietly rewiring the defaults for critical infrastructure. That is a language settling into a durable, well-defended position, not one flaming out.

My honest read: learn Rust for leverage, not for volume. If you want to work on operating systems, browsers, embedded, cryptography, security infrastructure, or anywhere a memory bug is a catastrophe, Rust is increasingly the correct default and the skill will pay. If you want the biggest pool of jobs and the fastest path to shipping a CRUD app, it's the wrong tool and no amount of admiration changes that. The loudest language isn't winning the whole board. It's winning the squares that matter most, and holding them. That's a better outcome than the takeover everyone kept predicting, and a more honest one to plan around.