Skip to content
The Internet Is Getting Rusty, but in a Good Way

Insight // Technology

The Internet Is Getting Rusty, but in a Good Way

Nov 17, 2026 17 min read HyScaler Team

Something shifted on GitHub this year. Between March and September 2026, the share of pull requests that began with an agent’s first draft jumped from 17% to more than 40%. Over the same year, Rust became the fastest-growing major language on the platform, doubling its contributors. [1]

Coincidence? Probably not. Rust’s old problem was that people found it hard to learn. An agent doesn’t have that problem, and what’s left is a language that gives you memory safety without a garbage collector. [2] Teams that make the switch still pay for it, though, and the bill arrives at build time, in compile time, disk space and disk writes.

What does GitHub’s 2026 data show?

Start with the raw volume. GitHub’s Octoverse 2026 report, published on 28 October 2026, counted this over the previous twelve months: [1]

  • 17.9 billion pushes, more than 2024 and 2025 combined,
  • 34.3 billion commits across public and private repositories, more than three times the level two years earlier,
  • 1.3 billion merged pull requests, an average of 3.5 million a day,
  • more than 225 million developers on the platform.
Rewrite in Rust in context: GitHub's Octoverse 2026 figures on commits, pushes and pull requests started by agents

Who starts the work is changing faster than the totals. September alone brought 110 million agent-started pull requests, roughly six times March’s count. And among repositories created this year, those with an agent configuration file logged eight times as many commits, on average, as those without. [1]

In GitHub’s own reading, more and more work now starts with a developer directing an agent, and review is where they shape what comes back. [1]

Why is Rust growing so fast on GitHub?

GitHub doesn’t say why outright, but its numbers line up in an interesting way. TypeScript, Python and JavaScript added the most contributors in absolute terms, while Rust’s percentage gain beat every other top language. [1]

Rewrite in Rust and AI: share of merged pull requests with detected AI involvement by language, and Rust's growth on GitHub

Set that beside how much of each language’s merged work shows AI involvement: [1]

LanguagesMerged pull requests with detected AI involvement
TypeScript, Python, RustAbout 40% to 44%
Java, C#, C++About 21% to 34%

GitHub gives one range per group, with no figure for each language. It observes that the communities growing quickest also carry the highest AI shares, and leaves the cause open. [1]

Outside GitHub, the signals agree. On 18 November 2026, crates.io listed 380,771 crates and 562.8 billion downloads. [3] Developers rate it highly: Rust topped the admired list in the 2025 Stack Overflow Developer Survey, at 72%. [4] And it is spreading at work. In the Rust project’s 2024 State of Rust survey, 38% of respondents used Rust for most of their coding at work, up from 34% the year before, and 45% said their organisation made non-trivial use of it. [5]

GitHub also floats an idea that matters to anyone choosing a stack. Language choice has long followed what developers want to build, what their team knows and what existing systems need. The report asks whether a fourth factor is arriving: the language an agent picks when nobody tells it which one to use. [1]

If agents write the code, why not use the safest and fastest language?

Rust’s costs were always human ones. The learning curve is steep, and the compiler refuses code until it is right. Ask Rust users what limits their productivity and slow compilation comes out on top. [5] An agent has no learning curve to climb, and its twentieth compiler error costs it no more than its first.

Types are part of it. GitHub’s 2025 report put TypeScript’s rise down to developers moving toward typed languages that make agent-assisted coding more reliable in production. [6] In a follow-up, Why AI is pushing developers toward typed languages, it pointed to a 2025 academic study [7] of code generated by language models, which found that 94% of the compilation errors came from failed type checks. [8] A compiler catches those before anyone runs the program.

Security pushes the same way. Veracode’s Spring 2026 GenAI code security update found that in 45% of code generation tasks, the model introduced a known security flaw. [9] Developers have noticed. In Stack Overflow’s 2025 survey, 46% said they distrust the accuracy of AI tools, against 33% who trust it. [10]

This is where Rust’s compiler earns its keep. Its ownership rules guarantee memory safety with no garbage collector running in the background, [2] and many concurrency bugs turn into compile-time errors instead of runtime ones. [11] Code that breaks those rules doesn’t build. For an agent working in a loop, that means a reviewer that answers in seconds and points at the line it objects to.

Agentic coding and rewrite in Rust: how a strict compiler acts as first reviewer in an agent's write, check and fix loop

Washington has taken notice. DARPA’s TRACTOR programme, short for Translating All C to Rust, aims to automate the translation of legacy C code into safe Rust. [12]

Where the argument needs care

Now the sceptic’s view. Agents don’t write most of the code yet. On GitHub, agents open a little over two in five pull requests. [1] Google said in October 2024 that more than a quarter of all new code at Google is generated by AI, then reviewed and accepted by engineers. [13] Big numbers, but neither one is a majority.

Rust’s compiler has blind spots of its own. It will stop a memory error, and it will just as happily compile an agent’s wrong business rule, written perfectly. Someone still has to review the code, and Rust is hard to read if you don’t know it, so part of the effort shifts to the reviewer. Every fix an agent makes is also another build. Working through compiler errors in a loop, an agent compiles far more often than a person would, and those builds add up.

How strong is the security case for Rust?

Look at where serious bugs have come from in C and C++. At Microsoft, about 70% of the vulnerabilities it assigns a CVE each year were memory safety issues, its security response team reported in 2019. [14]

Google has data on what happens when new code stops adding to that pile. In Rust in Android: move fast and fix things, published in November 2025, it reported: [15]

  • memory safety vulnerabilities fell below 20% of Android’s total for the first time,
  • its Rust code shows a 1000x reduction in memory safety vulnerability density compared with Android’s C and C++ code,
  • Rust changes have a 4x lower rollback rate and spend 25% less time in code review.

That last point was the one Google called its biggest surprise. Its takeaway was that the safer path had become the faster one as well, and the strategy behind it focused on new code. [15] The White House made a similar case at national level in February 2024, in a report announced as Future Software Should Be Memory Safe. [16]

What is the state of security in scripting language stacks?

If your application is written in PHP, Python, JavaScript or Ruby, the code you write is already memory safe. The risk sits elsewhere.

Some of it sits underneath you. CPython, the original and most-maintained implementation of Python, is written in C, [17] and so is the PHP interpreter. [18] A flaw in that layer reaches every application built on it. CVE-2024-4577, a flaw in PHP’s CGI mode on Windows, scored 9.8 out of 10, let an attacker run arbitrary PHP code on the server, and was on the US list of known exploited vulnerabilities two days after it was published. [19]

Dependencies are a bigger exposure. Sonatype’s 2026 State of the Software Supply Chain report found more than 454,600 new malicious packages during 2025, taking its running total past 1.233 million across npm, PyPI, Maven Central, NuGet and Hugging Face. [20]

Other bugs simply wait for a user. A dynamically typed language only finds a wrong type or a missing field when someone reaches that line in production.

Rust helps with the last of these, because the compiler catches type errors before release. It helps with the first only where Rust code actually replaces the C underneath. Packages it doesn’t fix at all. Rust has a public registry too, with the same problem: in September 2025 the crates.io team removed two malicious crates, downloaded 7,181 and 1,243 times, that searched for cryptocurrency private keys. [21] Our piece on trust and security in open source software covers that side.

How much faster is Rust?

Fast enough that some well-known engineering teams moved their hottest code to it and published the results. Every figure below is the team’s own:

Rewrite in Rust in numbers: memory safety and performance figures from Google, Cloudflare, Astral and Microsoft
WhoWhat movedResult reportedSource
CloudflareIts HTTP proxy, from NGINX (C with Lua) to Pingora (Rust)Over 1 trillion requests a day on a third of the CPU and memoryCloudflare[22]
DiscordIts Read States service, from Go to RustLatency spikes every two minutes, caused by garbage collection, removed; latency, CPU and memory all betterDiscord[23]
AstralPython packaging, with uv written in Rust10 to 100 times faster than pipuv documentation[24]
AstralPython linting and formatting, with Ruff written in RustBetween 10x and 100x quicker than Flake8 and BlackRuff documentation[25]

Read them as vendor numbers, measured on each team’s own software, and in Cloudflare’s and Discord’s case a few years old now. GitHub sees the same appetite from users: its look at the fastest-growing tools names uv among projects that reflect a growing intolerance for slow feedback loops. [26]

What does Rust cost? The bill for compiling

Rust does much of its checking at compile time, so that is where you pay: in waiting time, in disk space and in disk writes. Rust’s maintainers publish their own data on all three. [27]

The cost of a rewrite in Rust: Rust project survey results on build times and the effect of a faster linker

Build time

Slow compilation is the complaint Rust developers raise most. The Rust compiler performance survey 2025 drew more than 3,700 responses, and the average rating for build performance was 6 out of 10. 55% of respondents wait more than ten seconds for a rebuild. Among people who had stopped using Rust, about 45% named long compile times as at least one of the reasons. [27]

The single most common complaint was waiting for an incremental rebuild after a small change. Part of the reason, the survey says, is that changing one crate in a workspace rebuilds everything that depends on it, and the final linking step always runs from scratch. [27]

Clean builds hurt more. Cargo fetches every dependency, and all of theirs, and compiles the lot from source. [28] A continuous integration run with no cache rebuilds the whole tree, and about 20% of survey respondents called clean builds a significant blocker. [27]

Disk space

Build output gets big. Rust users raised the disk space eaten by compiler artifacts as a challenge in the project’s 2024 survey, right next to slow compilation. [5]

Debug information is one reason. Cargo’s default development profile generates full debug information for your own code and for every dependency. [29] That lets you step through code in a debugger, and it also swells the build directory and slows compiling and linking. [27]

Duplication is another. Build output lands in the project’s own target directory, with debug and release builds stored in separate folders. [30] Two checkouts of the same project, or two profiles in one checkout, compile and store the same dependencies twice.

Disk writes and the last step

The disk takes a beating as well. Every build writes object files, incremental compilation data and debug information, then links a complete binary. Linking always starts from scratch, [27] so even a one-line change ends with the whole executable being written out again.

How much does that last step matter? The Rust project measured it when it made LLD the default linker on Linux x86-64 in version 1.90. In its announcement, it said roughly half the time of a debug build of ripgrep 13 went on linking. With LLD, linking on an incremental rebuild became 7x faster, cutting total compile time by 40%, and a from-scratch debug build improved by 20%. [31]

Our read: a step that once took half the build, and writes out the whole program every time, is where a slow disk will show up first.

Why agents make the bill bigger

Nobody has measured this directly yet, so treat what follows as our reasoning from the documented facts. A developer usually compiles after finishing a change. Agents compile after every attempt, because the compiler’s response is how it finds out what to fix next. More attempts, more builds.

Then multiply by the number of agents. A common setup gives each agent its own working tree of the repository, which Git supports so that several branches can be checked out at once. [32] Each working tree gets its own target directory, [30] so four agents means four copies of the build output on one disk, and four streams of writes. Pointing them all at a shared build directory brings its own trouble, because builds then wait on each other, and the performance survey already lists Cargo and code editors blocking each other as a pain point. [27] The Cargo documentation suggests a different fix: one cache of compiled dependencies that separate workspaces can all draw on. [30]

So for a team running agents on Rust, the build machine, its cores and its disk, may set the pace more than the model does.

How to keep the bill down

CostWhat causes itWhat reduces it
Slow rebuildsWorkspace changes trigger dependent rebuilds; linking starts from scratchType-check with cargo check, which skips code generation [33]; use the LLD linker, the default on Linux x86-64 since Rust 1.90 [31]; split very large crates
Slow full buildsEvery dependency is compiled from sourceCache compiled dependencies in continuous integration; use a shared compilation cache such as sccache [30]
Disk spaceFull debug information for all dependencies; one build directory per checkout and per profileReduce debug information in the development profile [29]; remove stale build directories on a schedule
Disk writesEverything a build writes out, plus a complete relink each timePut build directories on fast local storage; limit how many builds run at once

None of this is news to the people who build Rust. Its blog describes a faster linker by default, a parallel compiler front end, caching of macro expansion, and automatic cleaning of Cargo’s cache. [27] [5] [34]

When is Rust the wrong choice?

Microsoft’s TypeScript team makes a useful counterexample. When it set out to speed up the TypeScript compiler, it announced a native port expected to cut most build times by 10x, with the Visual Studio Code codebase loading in the editor in about 1.2 seconds instead of 9.6. The team wrote that port in Go. [35]

Step back and the shift is toward native code for the parts of the stack that run all the time: compilers, bundlers, package managers, proxies and databases. Rust is the most visible part of it, alongside Go and newer languages such as Zig, which 64% of its users admired in the Stack Overflow survey. [4]

Finding people is harder. Only 14.8% of Stack Overflow’s 2025 respondents had done extensive work in Rust in the past year, compared with 66% for JavaScript, 57.9% for Python and 29.4% for Java. [4] And any rewrite can bring new bugs, even when none of them are memory bugs.

Should you rewrite in Rust?

Probably not all of it. Find the part that is slow or exposed, move that, and leave the rest where it is.

Should you rewrite in Rust: move it to Rust, keep a Rust core with a scripting shell, or leave it alone
AnswerFits whenFirst step
Move it to RustA hot path where latency matters, C or C++ code that faces the internet, command-line and build tools, or a service billed by CPU and memoryMeasure, then port one service
Rust core, script shellThe application is in Python, PHP or JavaScript and one module is slow or riskyRewrite that module as a native Python extension with PyO3 [36] or compile it to WebAssembly for JavaScript [37]
Leave it aloneBusiness rules that change weekly, standard admin screens, or code that spends its time waiting on a databaseFix the query or the cache first

Porting with agents, step by step

  1. Profile first. Find the code that uses the CPU, the memory or the on-call rota.
  2. Pick one bounded component with a clear interface and good tests.
  3. Size the build machine before you start. Cores, memory and fast disk for as many parallel builds as you plan to run.
  4. Let the agent port, and let the compiler and the tests reject. Keep the existing tests as the definition of correct behaviour.
  5. Run old and new side by side on real traffic, then switch over gradually with a way back.
  6. Measure the result against the number you wrote down in step one, including the build cost.

Frequently asked questions

What is driving Rust’s growth?

On GitHub, its contributor count doubled in a year, the quickest rise of any top language in Octoverse 2026. [1] Native speed with memory safety explains much of the appeal, and agents benefit from a compiler that flags mistakes before anything runs.

Is Rust a good language for AI coding agents?

In several ways, yes. Its strict compiler gives an agent precise feedback, and on GitHub, Rust sits with TypeScript and Python in the group where AI touches the most merged work. [1] The cost is more builds, which take time and disk.

Why are Rust compile times slow?

Rust does its safety checks and heavy optimisation at compile time, compiles every dependency from source, and relinks the whole program on each build. More than half of those who answered the Rust project’s 2025 performance survey said a rebuild takes them over ten seconds. [27]

Why does a Rust build use so much disk space?

By default, development builds keep debugging data for your code and for each dependency, and every checkout and build profile stores its own compiled copy of those dependencies. [29] [30]

Is Rust faster than Go?

Often slightly, and more predictably, because Rust has no garbage collector. Go compiles much faster and is easier to learn, and Microsoft chose it for the TypeScript compiler port. [35] Discord went the opposite direction for one service, porting it off Go to get rid of garbage collection pauses. [23]

Are PHP and Python insecure?

Not in themselves. Application code in both is memory safe. The risks are flaws in the C runtime and extensions, malicious or vulnerable packages, and errors that only appear at runtime. [17] [19] [20]

Does rewriting in Rust fix supply chain attacks?

No. Rust removes memory safety bugs. It does not make third-party packages trustworthy, and crates.io has had to remove malicious crates of its own. [21]

Sources

Numbers in square brackets in the text link to the source for that statement.

  1. GitHub, Octoverse 2026: Commits, pushes, reach new highs in 2026 as developers build with agents, 28 October 2026
  2. The Rust Programming Language, Understanding Ownership
  3. crates.io, registry totals from its summary API, read 18 November 2026
  4. Stack Overflow, 2025 Developer Survey, technology
  5. Rust Blog, 2024 State of Rust survey results, 13 February 2025
  6. GitHub, Octoverse 2025: A new developer joins GitHub every second as AI leads TypeScript to #1, 28 October 2025
  7. GitHub, Why AI is pushing developers toward typed languages, 8 January 2026
  8. Mündler, He, Wang, Sen, Song and Vechev, Type-Constrained Code Generation with Language Models, arXiv:2504.09246, 2025
  9. Veracode, Spring 2026 GenAI code security update
  10. Stack Overflow, 2025 Developer Survey, AI
  11. The Rust Programming Language, Fearless Concurrency
  12. DARPA, TRACTOR: Translating All C to Rust
  13. Google, Q3 2024 earnings remarks from the chief executive, October 2024
  14. Microsoft Security Response Center, A proactive approach to more secure code, July 2019
  15. Google Security Blog, Rust in Android: move fast and fix things, November 2025
  16. The White House, Office of the National Cyber Director, Future Software Should Be Memory Safe, 26 February 2024
  17. Python Software Foundation, The Python Language Reference, Introduction
  18. The PHP Group, php-src, the PHP interpreter source code
  19. NIST National Vulnerability Database, CVE-2024-4577
  20. Sonatype, 2026 State of the Software Supply Chain, open source malware
  21. Rust Blog, crates.io: Malicious crates faster_log and async_println, 24 September 2025
  22. Cloudflare, How we built Pingora, the proxy that connects Cloudflare to the Internet
  23. Discord, Why Discord is switching from Go to Rust
  24. Astral, uv documentation
  25. Astral, Ruff documentation
  26. GitHub, What the fastest-growing tools reveal about how software is being built, 3 February 2026
  27. Rust Blog, Rust compiler performance survey 2025 results, 10 September 2025
  28. The Cargo Book, Dependencies
  29. The Cargo Book, Profiles
  30. The Cargo Book, Build Cache
  31. Rust Blog, Faster linking times with 1.90.0 stable on Linux using the LLD linker, 1 September 2025
  32. Git, git-worktree documentation
  33. The Cargo Book, cargo check
  34. Rust Blog, Cargo cache cleaning, 11 December 2023
  35. Microsoft, A 10x Faster TypeScript, 11 March 2025
  36. PyO3 user guide
  37. The wasm-bindgen Guide

How HyScaler can help you modernise

Usually only part of a system is worth porting: the slow or exposed piece, plus a plan for the build cost that comes with it. We help you find that piece and do the work.

Our product modernization team profiles a system and plans what to port, what to refactor and what to leave. For the components worth rebuilding, our software development services team does the build, and cloud-based application development covers services that need to scale.

For the pipeline, our DevOps engineering team sets up the caching, parallel builds and side-by-side releases that keep a Rust port’s build bill under control.

Bring the service that pages you most often, and we will help you work out whether it should rust. Talk to our team.