Rust Slides to #16 as Zig, Swift, and Mojo Reshape Systems Programming

In April 2025, a GitHub user filed a DMCA takedown notice against a Zig language repository. By December, the Zig Software Foundation had pulled every repository from the platform entirely, migrating to a self-hosted Forgejo instance. The Foundation's statement was blunt: GitHub's AI training policies had made the platform 'actively hostile to open-source maintainers.' The move was not merely logistical. A systems-language community with no corporate benefactor and no venture funding had decided that the cost of free hosting — code scraped for model training, issue trackers flooded with AI-generated bug reports — had grown too high to bear. It was the kind of decision that only a small, ideologically coherent community could make, and it said as much about Zig's culture as any compiler release ever could.

The Zig exodus arrived at a moment when systems programming languages are undergoing a quiet but consequential reshuffling. None of the newcomers — Rust, Zig, Swift, or Mojo — has displaced C or C++ in absolute terms, and probably none ever will in the way that phrase is usually meant. But each is carving a distinct path through the infrastructure layer, and the choices their communities make about governance, platform dependency, concurrency models, and safety guarantees are starting to harden into permanent features of the landscape. The burn is slow. It is also unmistakably real.

In April 2026, the TIOBE Index placed Rust at #16, down from a peak of #13 the previous year, according to TechRepublic's coverage of the rankings. The slide came despite — or perhaps because of — a year of extraordinary institutional wins. Linux kernel 7.0 shipped with stable Rust support that same month, ending the language's experimental phase in the world's most consequential codebase. Meta had formalized Rust as a first-class language alongside C++ for backend services. Cloudflare, AWS, and Microsoft each deepened their Rust investments. And yet the index moved downward, as if to remind everyone that adoption in the systems space registers differently than it does elsewhere.

The paradox resolves once you accept that systems languages are judged on a different clock. Their adoption cycles are measured in decades, not quarters. C took roughly fifteen years to move from Bell Labs curiosity to the lingua franca of operating systems. C++ needed a full decade before the ISO committee even existed. What Rust, Zig, Swift, and Mojo are experiencing is not failure but the normal velocity of infrastructure software — a pace that confuses observers accustomed to the explosive, then equally explosive, growth curves of JavaScript frameworks. The TIOBE slide is less a verdict than a measurement artifact: an index built for spotting trends in application languages, now being asked to weigh the gravitational pull of a language whose adoption happens inside kernels and firmware.

Adoption in the systems space is also lumpy in ways that rankings cannot capture. A single institutional commitment — the Linux kernel accepting Rust, the U.S. government's 2024 recommendation favoring memory-safe languages, Android's accelerating reliance on Rust for new code — matters more than a thousand hobbyist projects. These are anchors. Once embedded, they are extraordinarily difficult to remove. The real question is not whether Rust is 'winning' against C on a leaderboard, but whether the next generation of critical infrastructure will be written in a language where use-after-free is a compiler error rather than a CVE. On that metric, the arrow points in one direction.

Zig offers a different answer to the same question, and the contrast illuminates both projects. Where Rust wraps safety in an ownership system that demands a steep learning curve, Zig's pitch is legibility. It compiles C code, interoperates with C libraries without FFI friction, and gives programmers explicit control over allocation. Its toolchain can cross-compile to any target from any host — a property that has made it quietly indispensable in the embedded and game-development spaces. 'Zig is like C, only better,' InfoWorld's Serdar Yegulalp wrote, capturing both the ambition and the modesty of the project. The language cracked the TIOBE top 50 in 2023 and has since become, by Stack Overflow's survey data, one of the highest-paying languages for developers. Its ascent is narrow but deep.

We are not asking maintainers to accept a platform that trains AI on their code without consent, floods their inboxes with generated bug reports, and treats open-source communities as free training data. We are simply leaving.— Zig Software Foundation statement, December 2025

The Foundation's departure from GitHub was not an outlier in Zig's story. It was an expression of the language's founding ethos. Andrew Kelley, Zig's creator, has long been explicit about his skepticism of venture-funded infrastructure. The language is funded through the Zig Software Foundation, a 501(c)(3) nonprofit, and its toolchain is built to minimize external dependencies — no LLVM dependency in the self-hosted compiler, no package manager that phones home. Where Rust's governance has professionalized, with a foundation backed by Amazon, Google, Huawei, Meta, and Microsoft, Zig has deliberately stayed lean, suspicious of corporate embrace. Neither approach is obviously correct. Both carry costs that will only become visible at scale.

Swift's systems-language ambitions are younger and arrive from a stranger angle. The language Apple launched in 2014 to replace Objective-C spent its first decade as a mobile-platform language with a modest side interest in server-side work. That changed in late 2025, when the Swift Android workgroup shipped nightly preview releases of the Swift SDK for Android, as reported by Paul Krill at InfoWorld. Suddenly, a language long dismissed as 'Apple's thing' had a credible cross-platform story. For teams already writing Swift on iOS, the ability to share substantial code with an Android client — without touching Kotlin or Java — rewrote the economic calculus. A language born inside a walled garden was learning to grow outside it.

The cross-platform push coincided with Swift 6's enforcement of complete data-race safety through its actor model and sendable checking — a migration that has been, charitably, rocky for existing codebases. Where Rust asks developers to prove safety to the compiler up front, Swift 6 retrofits safety guarantees onto a language with a decade of pre-concurrency code in production. Teams report that the migration reveals architectural decisions made long before actors existed: singletons that are not sendable, callback patterns that predate structured concurrency, assumptions about thread-safety that were never formalized. It is the price of growing a systems language inside a platform ecosystem and then asking it to be something larger, and the Swift community is paying it in full.

Mojo entered the conversation from a direction that none of the others could reach. Announced by Modular in 2023 and stewarded by Chris Lattner — the architect of Swift and LLVM — Mojo is positioned as a systems language for AI workloads: Python-syntax-compatible but compiled, with first-class support for SIMD, GPU programming, and the kind of low-level control that CPython abstracts away. By 2026, Mojo remains in early access, with Modular's MAX platform serving as both its runtime and its commercial moat. Adoption numbers are small. But the concentration of interest among ML infrastructure teams — the people building the next generation of inference engines, training orchestrators, and model-serving runtimes — is striking. Mojo is not trying to replace C in an operating system kernel. It is trying to replace the C underneath Python in the hottest layer of the stack.

What unites these four languages is less their technical choices than their shared refusal to accept the status quo of systems programming as a C-and-C++ duopoly. What divides them is everything else: Rust's exhaustive type system versus Zig's minimalist comptime metaprogramming, Swift's actor-model concurrency versus Rust's async/await and ownership, Mojo's Pythonic syntax versus everyone else's C-like grammar. These are not minor aesthetic disagreements. They encode fundamentally different theories about what makes systems code safe, maintainable, and comprehensible to the next generation of engineers. And the next generation will have to live with whichever theory gets embedded deepest in the infrastructure.

What Language Choice Costs the People Who Choose It

Every language adoption decision is also a hiring decision, a maintenance decision, and a bet on the future of a particular community. Teams that adopted Rust in 2019 for a network service now have five years of Rust in production. The developers who learned the borrow checker during the pandemic are now senior engineers, and they bring their language preferences with them into architectural decisions. Choosing Zig means betting that explicit control and small-tool philosophy will age better than Rust's safety-first approach — and that you can hire for it. Choosing Swift for server-side means betting that the Apple ecosystem's gravitational pull will produce enough open-source contributors to sustain a cross-platform future. None of these bets is safe.

Then there is the variable that did not exist five years ago: large language models trained on open-source code. The Zig Foundation's GitHub exit was explicitly motivated by AI training concerns, but the issue cuts across every language community. Rust's foundation has been quieter on the subject, yet individual maintainers have expressed alarm at the volume of AI-generated pull requests and bug reports. One Rust compiler contributor described the phenomenon to me as 'plausible-looking nonsense from a confidently wrong model' — generated patches that look correct on first glance but introduce subtle unsoundness that only a human reviewer steeped in the type system would catch. The systems-language slow burn now includes a novel cost: the cost of being popular enough to scrape, and the maintenance burden of filtering synthetic contributions.

The codebases that adopted these languages five years ago are now the test cases that matter. Rust's first production users at Firefox — the Stylo CSS engine shipped in 2017 — have nearly a decade of data on what Rust maintenance actually costs. Early Zig adopters in the embedded and game-development spaces have built real tooling on a language that has not yet reached 1.0, a bet on a compiler that is still finding its final shape. Swift's server-side frameworks — Vapor, Hummingbird — have accumulated enough production hours to demonstrate that the language works outside Cupertino's climate-controlled garden, even as Swift 6 forces a reckoning with old concurrency assumptions. None of these stories is a failure. None is an unambiguous triumph. They are the slow, unglamorous work of infrastructure maturation, the kind of work that does not trend.

Watch for two things in the next eighteen months. The first is whether the Linux kernel's Rust experiment expands beyond drivers into core subsystems — a threshold that would signal something closer to institutional permanence in the most conservative codebase on Earth. The second is whether Zig's post-GitHub infrastructure experiment succeeds or isolates the language from the network effects that helped Rust grow. The systems-language question has never been 'which one wins.' It has always been which communities figure out how to sustain themselves long enough for the code to matter. On that question, the jury is still out, and the slow burn continues.