Survey date: November 11, 2026
1. Introduction
When you hear Rust, you might think of it as a replacement for C or C++. In fact, it is used in areas such as operating systems and browsers, where speed and fine-grained resource management are required.
However, Rust's recent role goes beyond that. There are also examples of replacing parts of services built in Python with Rust, building the internals of components used from Python in Rust, and newly building the foundation for running AI agents in Rust.
In this report, we trace the history and features of Rust to explain why it is attracting attention. We also cover a case study introduced by Anthropic of migrating a Python-based service to Rust, as well as NVIDIA OpenShell.
2. Conclusion: A Language That Aims to Achieve Both Performance and Safety
Rust is a programming language that values high execution performance and fine-grained control over memory, while aiming to prevent many problems caused by memory handling before the program runs.
It is particularly valued for the following combination:
- It offers fine-grained control close to that of C and C++.
- Its ownership system allows unsafe memory usage to be checked at compile time.
- Because garbage collection is not mandatory, latency and resource usage can be easier to predict in some cases.
- Development tools such as Cargo are well established.
- It can be combined with existing Python and C/C++ systems.
However, using Rust does not guarantee that code will always become faster or that bugs will disappear. Since learning it and migrating to it take effort, it needs to be chosen according to the use case.
3. History of Rust: From a Personal Experiment to Shared Infrastructure
2006: Started as a Personal Project
Rust began in 2006 as Graydon Hoare's personal project. It was created with the goal of building a systems programming language that could achieve both safety and performance.
2009–2010: Mozilla Support and Public Release
In 2009, Mozilla began funding the work, and by the end of the year it had become an in-house project. After that, development proceeded openly as a project of Mozilla Research.
Some sources say it "started in 2010." This difference comes from whether the starting point is taken to be the beginning of personal development or the project's adoption and public release at Mozilla.
2012 Onward: Refining Practicality Through Servo
Mozilla supported Servo, a browser engine written in Rust. A browser is large-scale software where performance, concurrency, and safety all matter. Rust was developed and refined while building real systems like this.
2015: Rust 1.0
Rust 1.0 was released in May 2015. As a stable release, it valued compatibility and marked a major milestone toward making it easier to build practical software for the long term.
2021: Establishment of the Rust Foundation
The Rust Foundation was established, creating a system in which multiple companies and the community support the language and related infrastructure. It has grown as shared infrastructure supported by everyone, rather than relying on Mozilla alone.
2025: Stabilization of the Rust 2024 Edition
The Rust 2024 Edition has "2024" in its name, but it was released as stable in 2025. Editions are a mechanism for evolving the language while helping existing code keep working. Libraries using different editions can be combined.
Viewed historically, Rust was not born from a single new idea alone; rather, it is a project that has incorporated the results of past languages and research and has been nurtured by many people as practical, shared infrastructure.
Sources: Prehistory of Rust / 10th Anniversary Retrospective by the Founder / Rust 1.0 Announcement / Rust 2024
4. What Kind of Language Is Rust?
Rust is a general-purpose language that checks types before execution and compiles programs to machine code for execution. It can be used not only for low-level development such as OSs, but also for web services, CLIs, data processing, and supporting infrastructure around AI.
The design of the language reflects the influence of various earlier languages.
- C++: The idea of managing resources such as memory and files in fine detail.
- ML / OCaml family: Type-driven ways of writing code, such as type inference and pattern matching.
- Haskell: The approach of tying shared behavior to types.
- Memory management research: The idea of checking reference safety in advance.
In short, it is a language that combines C++-like resource management with the expressive power of functional languages through types.
Source: Rust Reference: Influences
5. "Ownership" at the Heart of Rust
Rust's defining features are ownership, borrowing, and lifetimes.
In languages like C and C++ that allow fine-grained control over memory, problems can occur such as using memory that has already been freed, or freeing the same memory twice. Such problems can sometimes lead to vulnerabilities.
In Rust, the responsibility for managing data is handled as "ownership." When other processes temporarily use data, they "borrow" it. The compiler checks things like whether those references outlive the original data.
As an analogy, it is a mechanism for verifying, before running the program, who the "owner" of the data is and who is borrowing it until when.
However, it is not a silver bullet. Logic bugs, deadlocks, and memory leaks can still occur. Also, if there are problems in unsafe code or at the boundary with other languages, code using safe Rust can still be affected.
Sources: Rust Official Book: Ownership / Unsafe Rust
6. Why Rust Tends to Be Lightweight and Fast
There is no single reason why Rust is fast.
More Can Be Decided Before Execution
Based on information such as types and call targets, the compiler can optimize the code into native machine code.
Memory Usage Is Easy to Tune
You can design your code with awareness of where data is placed, copying, and memory allocation. Reducing unnecessary allocations and copies can lead to improvements in speed and memory usage.
No Mandatory Garbage Collection
Garbage collection (GC) is a mechanism that finds and reclaims memory that is no longer needed while the program is running. Rust does not require it, and instead manages resources using ownership and related mechanisms.
Because of this, depending on the application, it can be easier to avoid delays caused by collection pauses and to estimate resource usage. On the other hand, languages that use GC have the advantage of being easier to develop in — neither is always superior.
Easier to Achieve Both Convenience and Speed
Rust provides features such as iterators and generics that improve readability and reusability. Because the compiler can turn these into efficient code, it is easier to achieve both "writing conveniently" and "running fast."
However, operations such as bounds checks, memory allocation, and locks do incur costs. Simply rewriting code in Rust does not guarantee that it will always become faster, nor is there any guarantee that it will always be faster than C++.
Source: Rust Official: Iterators and Performance
7. Why It Has Come to Be Used So Widely
If performance were the only consideration, C and C++ are also excellent. Rust is attracting attention because, in addition to performance, it is also expected to offer safety and maintainability.
- In infrastructure that handles input over networks, memory safety is helpful.
- Concurrent processing can be built while keeping memory usage and latency under control.
- Builds, dependencies, and tests can be handled in a relatively unified way with Cargo.
- It can be introduced into only part of an existing system.
- Large-scale adoption cases are increasing, building up material to inform adoption decisions.
In particular, it can be said to be a good fit for areas where both performance and reliability are required, such as operating systems, browsers, networking, cloud infrastructure, and AI agent runtime environments.
8. What Replacing Python with Rust Means
"Replacing Python with Rust" actually takes several forms.
① Porting the Service Itself to Rust
This is the approach of rewriting all or a major part of a service written in Python in Rust. It can be a candidate when startup time, memory consumption, latency, and similar issues are a concern.
However, porting involves development, validation, and maintenance costs. Performance improvements are not necessarily caused by the language alone; in some cases, changes to algorithms or architecture contribute to the improvement.
② Keeping Python as the Interface and Using Rust for Only Part of the Internals
This is the approach of maintaining Python's ease of writing and existing code while implementing performance-intensive parts in Rust.
For example, Pydantic v2 keeps the same usage from Python while using Rust for the core data-validation logic.
③ Building Python Development Tools in Rust
uv is a Rust-built tool for Python package management and related tasks. This is an example not of eliminating Python, but of building tools that support Python development in Rust.
In other words, Rust and Python are not in a simple competitive relationship. A combination is possible: develop quickly in Python, and use Rust where performance and safety matter.
Note that in AI GPU computation, even when called from Python, native code such as CUDA is often running internally. Therefore, simply changing the caller to Rust does not automatically make GPU matrix operations faster.
9. Anthropic's Python-to-Rust Porting Case
Anthropic noted in its Announcement of Claude Fable 5.2 / Mythos 5.2 on November 9, 2026, that an agent team using an early version of Fable 5.2 had ported an important production service from Python to Rust.
According to the company, efficiency and reliability improved after the port, and startup became about 26x faster.
For this case, the following distinctions are important.
- The target was an "important production service." It is not stated that the AI model itself was rewritten.
- The figure of about 26x is the company's announcement about startup. It does not mean that inference speed or overall system throughput became 26x faster.
- The name of the target service, absolute times, and details of the measurement conditions are not shown in the relevant passage.
Even so, this report is an interesting case suggesting that porting to Rust can be an option for operational challenges in services built with Python.
10. Representative Adoption Cases
Azure Boost
Microsoft's Azure Boost is a mechanism for offloading processing such as networking and storage associated with virtualization to dedicated hardware. Microsoft explains its policy of using Rust as the primary language for new Azure Boost code.
However, this does not mean that all of Azure was replaced from C with Rust. Nor can the performance improvements in Azure Boost be attributed to Rust alone.
Discord
Discord has published a case of migrating a service handling read states from Go to Rust. The aim was to reduce GC-related latency spikes that occurred under specific load conditions.
This is an example where Rust may be chosen depending on the required latency and resource characteristics, not only for services written in C/C++ but also for services written in Go. On the other hand, this is not a general claim that Go is always slow.
Source: Discord Official: Why Discord is switching from Go to Rust
Linux Kernel
The Linux kernel is written mainly in C, but work to make Rust usable is also underway. This is not a rewrite of the entire existing Linux in Rust, but an effort to increase options while allowing C and Rust to coexist.
Sources: Official Linux documentation / Rust for Linux
NVIDIA OpenShell
NVIDIA OpenShell is an execution platform that controls file operations, communication, and other actions by AI agents through policies.
Rust is used in the sandbox runtime, which handles Linux isolation mechanisms, and in the server responsible for sandbox management and related tasks. Meanwhile, there are also SDKs in Python, TypeScript, Go, and other languages.
In other words, it uses Rust for the foundation, with users connecting from multiple languages. It can be seen as an example not only of replacing C/C++, but also of building a new AI foundation in Rust.
OpenShell has been accepted as a CNCF Sandbox project. Here, "CNCF Sandbox" is the name of the project's incubation stage and has a different meaning from the runtime isolation environment provided by OpenShell.
Individuals can also participate in development, but the Contributing Guide requires obtaining maintainer vouch approval before the first PR. AI-assisted implementation is allowed, but the submitter is required to understand and be able to explain their own changes.
11. Security and Government Interest
Mishandling memory can lead to serious vulnerabilities in OSs, browsers, and other software. Microsoft and Chromium each explain that about 70% of the vulnerabilities they examined were related to memory safety.
However, these figures differ in scope, time period, severity, and other factors. Numbers from different studies cannot be compared as statistics collected under the same conditions.
The U.S. NSA, CISA, and others also recommend planning a migration to memory-safe languages. Examples cited include not only Rust, but also Python, Go, Java, and others. This does not mean that "only Rust was mandated" or that "C/C++ was completely banned."
Sources: Microsoft's explanation / Chromium's explanation / Joint recommendation by the NSA and others
12. Rust's Weaknesses and Caveats
Rust has clear strengths, but adoption also comes with the following costs.
- Learning ownership, borrowing, and lifetimes takes time.
- Long compile times and language complexity can burden development.
- For small prototypes, Python can be more concise and allow faster development in some cases.
- There are migration costs related to existing libraries, team experience, interoperability with other languages, and more.
- Even with Rust, design mistakes and logic errors do not go away.
In addition, Rust's safety also depends on whether implementations such as unsafe code, dependency libraries, and interfaces with other languages are correct. On November 9, 2026, Microsoft reported an issue related to an unsafe implementation inside the Rust standard library.
Sources: Rust User Survey / Microsoft FORGE report
13. Summary
Rust is used not only as a language for writing low-level, machine-close code as an alternative to C/C++, but also for combining with Python and for building new foundations for the cloud and AI agents.
Using Rust makes it possible to aim for both performance and safety. It can be combined with Python, with only part of the processing built in Rust.
On the other hand, Rust also requires learning effort, migration effort, and build effort. Simply adopting it does not guarantee speed or safety. A realistic approach is to use it together with existing languages, based on the use case and measurement results.
Postscript: Rust 1.100.0 Is Out
On November 12, just before this article went out, Rust 1.100.0 was released — the milestone 100th release in the 1.x line.
The main changes are as follows.
- Never type (!) stabilized — after 10 years and 5 stabilization attempts, the type of computations that never return a value can now be named anywhere in code
- Allocator API stabilized — custom allocators can now be used with types such as Vec and Box
- DropGuard added — a helper that runs a closure on every exit path from a scope, making cleanup and rollback easier to write
- Cargo min-publish-age — you can set a cooldown so Cargo waits before adopting freshly published versions, a supply-chain security measure
- Cargo unused-dependency warnings — Cargo now reports dependencies that are no longer used
A deep language change like the never type and a supply-chain safeguard landed in the same milestone release.
Source: Announcing Rust 1.100.0
Top comments (0)