Rust Cracks TIOBE Top 10: Systems-Language Slow Burn Catches Fire

In the first week of July 2026, the TIOBE Index, the dutifully compiled popularity gauge that the software industry loves to hate and hates to need, published a milestone twenty-five years in the making. For the first time since the index began tracking in 2001, Rust entered the top ten. Not a rounding error. Not a flash in the pan. A systems language with no corporate sugar daddy, no university-training-pipeline lock-in, and a famously steep learning curve had pushed past venerable incumbents to sit alongside Python, C, C++, Java, and JavaScript. The news landed with remarkably little fanfare, which is itself the story.

What makes the ranking significant is not the number itself but what it signals about institutional adoption velocity. InfoWorld noted that memory safety and speed are the obvious drivers, but the deeper current is regulatory: governments on multiple continents are now formally recommending memory-safe languages for critical infrastructure. The U.S. Office of the National Cyber Director published its report on software measurability in early 2024. CISA followed with its own guidance. The EU's Cyber Resilience Act is inching toward enforcement. None of these documents say "use Rust." They don't have to. The engineering leads reading them do the math.

The Linux kernel project, long the symbolic fortress of C, has become the most visible proving ground. In May 2026, stable kernel maintainer Greg Kroah-Hartman addressed Rust Week and was characteristically blunt. "The Rust experiment is over," he said, as ZDNET reported. "It's real." Kroah-Hartman went further in a July talk, arguing that Rust adoption was not merely a quality-of-life improvement for kernel developers but an existential hedge. The volume of incoming code, increasingly authored or assisted by large language models, was accelerating beyond what human review could reliably catch. A language that eliminated entire classes of bugs at compile time was no longer a luxury.

The Rust experiment is over. It's real., Greg Kroah-Hartman, Linux stable kernel maintainer, speaking at Rust Week 2026

Kroah-Hartman's framing captures something subtle about the systems-language moment. For two decades, the calculus was simple: C and C++ run the world, and the cost of moving off them was higher than the cost of living with their sharp edges. What changed was not a single breakthrough but a slow accumulation of pressure. The talent pipeline shifted left: graduates who cut their teeth on Rust in university were entering the workforce, and they were not nostalgic for manual memory management. Infrastructure teams that had spent years patching the same class of buffer-overflow CVEs began asking pointed questions about the economics of staying put. And the AI-fueled code-generation wave, ironically, made the argument for Rust stronger, not weaker. If more code is being written by machines, the argument goes, it had better be code that a compiler can verify before it ever reaches production.

If Rust's ascent is a story of consensus-building and institutional patience, Zig is the story of a language that seems determined to earn its place the hard way. Zig occupies a peculiar position in the systems-language landscape. It does not offer Rust's borrow checker or its memory-safety guarantees. Instead, it promises something more subtle: a cleaner C, with comptime metaprogramming, no hidden allocations, and a build system designed to make cross-compilation feel like a first-class feature rather than an afterthought. It is a language for people who like C's mental model but are exhausted by C's toolchain, undefined behavior, and forty years of accumulated foot-guns.

That positioning got tested in spectacular fashion in mid-July 2026, when the JavaScript runtime Bun, originally written in Zig, announced it had been ported to Rust with the assistance of Anthropic's Claude. The port, which covered roughly half a million lines of code, took eleven days and cost approximately $165,000 at API pricing, according to The Register. Zig creator Andrew Kelley did not mince words about the result. He called it "unreviewed slop" and argued that an AI-assisted rewrite that no human had carefully reviewed was not a port but a liability. The Register's Joab Jackson reported that Kelley saw the episode as emblematic of a deeper problem: the tooling ecosystem around large-language-model code generation was incentivizing quantity over quality, and Zig, with its smaller community and thinner corpus of training data, was structurally disadvantaged in an AI race measured by lines of code.

Kelley's skepticism about AI-generated code did not begin with the Bun dispute. In May 2026, as Business Insider reported, Kelley, who serves as president of the Zig Software Foundation, formally banned contributors from submitting AI-generated code to the Zig project. His rationale was characteristically unvarnished: AI coding contributions, he said, are "invariably garbage" and have "no value whatsoever." The policy landed in a language-community ecosystem that was already fracturing along AI lines. Linus Torvalds, for his part, took the opposite view. In July 2026, he told anti-AI programmers to "fork it," ZDNET reported, making clear that the Linux kernel would not bar AI-assisted contributions so long as they met the same review standards as any other patch. The contrast between the two positions is not merely a disagreement about tooling. It is a debate about what a language community exists to protect.

Mojo occupies yet another lane entirely, one that looks less like a systems language in the traditional sense and more like an attempt to collapse the two-language problem that has defined scientific computing and machine learning for a generation. Announced in May 2023 by Chris Lattner, the architect behind LLVM, Clang, and Swift, Mojo promised to combine Python's syntax and usability with C's performance, as heise online reported at launch. The target was clear: the millions of Python programmers who write their model logic in one language and then wait for a C++ rewrite when performance matters. Mojo's pitch was that they could write once and get both.

Three years later, Mojo has not set the world on fire, but it has not fizzled either, which is its own kind of achievement in a language-design landscape littered with ambitious projects that peaked at the Hacker News launch thread. Modular, the company Lattner co-founded to build Mojo, open-sourced the language's core in late 2024, a move that was read by some observers as a sign of confidence and by others as a concession that proprietary tooling was never going to build the community Mojo needed. The language now occupies an odd niche: serious enough to be used in production at a handful of AI labs, young enough that its standard library still has gaps, and ambitious enough that its designers talk about eventually targeting embedded systems alongside GPU clusters. Whether Mojo can thread the needle between Python's ubiquity and Rust's performance remains an open question.

Swift, meanwhile, has been conducting its own quiet campaign for relevance outside the Apple ecosystem. The language that Lattner shepherded into existence at Apple has, since its 2015 open-sourcing, steadily accumulated server-side infrastructure: the Vapor web framework, the SwiftNIO networking library, and a growing collection of packages on the Swift Package Index. Apple's own investment in Swift for server use has been intermittent at best, a pattern that has frustrated advocates who see a language with strong memory safety, a modern type system, and a syntax that new programmers find approachable. The launch of Swift 6 in late 2024 brought full data-race safety to the language's concurrency model, a feature that puts it in the same conversation as Rust's borrow checker, albeit through a different design philosophy. Adoption outside the Apple ecosystem remains modest, but the codebases that have taken the bet tend to be the kind that accumulate slowly and stick around for a long time.

Taken together, these four languages represent something more interesting than competition. They represent a fragmentation of the systems-programming monoculture that C and C++ sustained for nearly forty years. And fragmentation, in this context, is a sign of health. Different languages optimize for different values, and different values produce different trade-offs. Rust optimizes for correctness and safety at compile time, at the cost of a longer learning curve and slower iteration speed. Zig optimizes for simplicity and control, at the cost of runtime safety guarantees that Rust provides by default. Mojo optimizes for the Python-to-hardware gap, at the cost of being tied to a younger, narrower ecosystem. Swift optimizes for approachability and Apple-platform integration, at the cost of being perennially at the mercy of a single company's strategic priorities.

The cost to maintainers is the part of the conversation that language-adoption discussions often elide. A language is not just a compiler and a specification. It is a community, a governance model, a backwards-compatibility promise, and a set of tools that either work reliably or don't. Rust's governance has been through multiple rounds of turbulence, including a high-profile moderation-team resignation in 2021, and the Rust Foundation is still figuring out how to fund core development without creating the kind of corporate capture that has bedevilled other open-source projects. Zig's governance is leaner, more dependent on a small group of maintainers, and more vulnerable to burnout. The Zig Software Foundation's decision to ban AI contributions is, in one reading, an attempt to protect the quality of the project. In another, it is a bet that the community can grow fast enough without the productivity multiplier that AI-assisted coding represents. The bet may or may not pay off.

The future-readers argument, never the most popular item on a language-design roadmap, is the one that engineers who have maintained code for more than five years tend to bring up first. A language that makes cleverness cheap and clarity expensive will produce codebases that are legible to their original authors and inscrutable to everyone else. Rust's borrow checker, for all its initial friction, produces code whose ownership semantics are explicit and machine-checked. A future reader, even one unfamiliar with the specific codebase, can reason about where memory is allocated and where it is freed without tracing through a maze of macros and conventions. Zig's explicitness about allocations serves a similar purpose. You can see, at the call site, whether a function allocates. The information is not hidden in documentation or tribal knowledge. It is in the signature.

The most telling metric for any systems language is not its TIOBE ranking or its GitHub stars but the codebases that adopted it five years ago and are still running. Rust's five-year report card looks strong by that measure: the Amazon Firecracker hypervisor, the Dropbox storage backend, and a growing list of Android and Linux kernel components are all written in Rust and are not being rewritten in something else. Zig's five-year report card is harder to evaluate because the language has been a moving target. Bun's rewrite to Rust complicates the narrative, though it is worth noting that Bun's original Zig codebase was, by the accounts of its own maintainers, one of the largest and most visible Zig projects in existence. Its departure leaves a dent. Mojo and Swift's server-side story have not yet been running long enough at scale for a meaningful five-year retro.

The language wars, as they are performed on social media and conference stages, tend to frame the question as: which language is winning? The more useful question, the one that shows up in architecture decision records and hiring plans, is: which language is right for this problem, with this team, for this expected lifespan of the code? The answer is increasingly not C, not C++, and not a single successor but a menu of successors, each with its own constituency and its own accumulating track record. The systems-language slow burn, in other words, is not a competition between Rust and Zig and Mojo and Swift. It is the gradual, uneven, and still-incomplete transition to a world in which writing systems software without compile-time safety guarantees is no longer the default. The milestone to watch for is not the next TIOBE index. It is the first critical-infrastructure CVE that a regulator points to and says: this would not have happened in Rust.