Rust's Precarious Position
Last updated on
Rust is a modern programming language that has emerged with outstanding memory safety and performance. While it is consistently praised by many developers and ranks high as a “most-loved language,” its position in the real world remains precarious. Let’s examine the reality and limitations Rust faces in key areas where powerful incumbent languages hold strong.
1. Safety-Critical Sectors
Given that memory safety is the language’s greatest advantage, Rust was expected to be well-suited for safety-critical systems in aerospace, automotive, and medical fields. However, this domain has been dominated for decades by languages like C/C++ and Ada. In particular, Ada has been used for a long time in systems requiring extreme reliability, such as aerospace and defense, proving its stability through a strong type system and concurrency support.
In a situation where established players are firmly entrenched, there is very little room for Rust to squeeze in. The nature of this field, which requires a long time to verify existing code and gain recognition for stability, means that Rust adoption remains confined to a few corporate experiments.
2. The Embedded Space
Embedded systems often operate in environments with extremely limited memory and processing power. Therefore, the binary size of a program is a critical factor. According to an authoritative survey, the Eclipse Foundation’s “2024 IoT & Embedded Developer Survey,” the languages most used by developers (multiple responses were allowed) were C++ (68%) and C (65%). This shows that the modern features of C++ are increasingly preferred in complex embedded systems, elevating its status to be on par with, or even ahead of, the traditional powerhouse, C.
Within this C/C++ stronghold, Rust shows a usage rate of about 17%. While it is growing rapidly, a significant gap with the mainstream languages still exists. Furthermore, because Rust includes various safety features during compilation, its binary files tend to be larger than those of C. In small devices where even kilobytes (KB) of memory must be conserved, this characteristic still acts as a barrier to Rust adoption.
3. The Linux Kernel
The official inclusion of Rust in the Linux kernel starting with version 6.1 in 2022 was a highly symbolic event. It was seen as recognition of Rust’s potential as a systems programming language.
However, now, some time later, the reality of Rust within the Linux kernel is still minimal. Based on a cloc analysis as of June 2025, the Linux kernel has about 29 million lines of pure code (excluding comments and blanks). While C and C header files account for approximately 92.3% of this, Rust code amounts to only about 19,000 lines, or just 0.07% of the total.
The summary table below clearly shows the proportion of major systems languages within the kernel.
| Rank | Language | Lines of Code | Percentage (%) |
|---|---|---|---|
| 1 | C & C/C++ Header | 26,759,325 | 92.33% |
| 5 | Assembly | 231,789 | 0.80% |
| 13 | Rust | 19,030 | 0.07% |
The currently included Rust code is mostly basic infrastructure for writing drivers, with no part in core functionalities. It appears it will take a considerable amount of time for Rust to have a meaningful presence in the Linux kernel.
4. The Server Space
When discussing the server space, one should not only think of server-side scripting languages that generate dynamic website content. A much broader domain exists, including web servers that first handle user requests (Nginx, Apache), cloud infrastructure, and large-scale enterprise application servers. Looking at the reality of this market, Rust’s position becomes even narrower.
- The Kings of Infrastructure Software, C/C++: The foundation of server infrastructure—web servers like Nginx and Apache, numerous database systems, and core OS network functions—is mostly built with C/C++. This area demands maximum performance and low-level memory control, where decades of accumulated code and stability are paramount. Although Rust aims to be a replacement, it is realistically very difficult to replace this massive C/C++ asset that already runs the world.
- The Absolute Ruler of the Enterprise Market, Java: The market for large corporate backend systems and stability-critical application servers in the financial sector is dominated by Java and the Spring framework. The stability of the JVM (Java Virtual Machine), its vast libraries, and rich developer ecosystem form a formidable barrier that other languages cannot easily overcome.
- The Darling of the Cloud Era, Go: In the modern cloud-native environment, Go has emerged as a new powerhouse. Tools symbolizing the container ecosystem, like Docker and Kubernetes, were developed in Go. With its simple syntax, excellent concurrency handling, and easy deployment, it has been adopted for developing countless microservices and API servers.
As seen, the server space has clear dominant players in each area. Rust must compete in a battleground against the performance of C/C++, the stability and ecosystem of Java, and the productivity and concurrency of Go. While there are cases of some companies adopting Rust to push the performance of systems written in C++ or Go to the extreme, this is a tiny fraction of the overall server market. In most cases, it is still difficult for Rust to prove it has advantages that outweigh the “proven stability” and “productivity” offered by the dominant language in each respective field.
The Realistic Dilemma of Adopting Rust
The biggest barrier to adopting Rust is undoubtedly the “cost” issue. The steep learning curve inevitably leads to lower initial development productivity, and the limited talent pool makes it difficult to find skilled developers, driving up labor costs.
Despite these obvious drawbacks and initial investment costs, why do companies in certain situations seriously consider Rust? It is because of the powerful incentive of long-term “Running Cost” reduction.
For example, consider a large-scale Java-based service operating on numerous servers. While Java has a stable and vast ecosystem, it runs on the JVM and tends to consume more memory and CPU resources than a native language like Rust. If the core bottlenecks or high-resource microservices of this service were replaced with Rust, memory usage and CPU occupancy could be dramatically reduced. This translates directly into tangible cost savings on server resources and data center electricity bills.
Ultimately, adopting Rust requires a realistic cost calculation. The initial investment cost here implies two main factors of increased labor cost. First, the lower productivity due to the steep learning curve leads to an extension of the development period, increasing the total project labor cost. Second, the scarcity of developers in the market means that the unit labor cost (salary) itself is high.
Whether this cost can be borne can be gauged by the following inequality:
Initial Investment Cost (Total labor cost from extended development period + High unit labor costs) < Long-Term Gain (Reduced operating costs + Value of preventing security incidents)
When this inequality is judged to hold true, Rust can finally become an attractive option.
However, this calculation is not so simple. Despite these advantages, realistic alternatives are still powerful.
- Java: Modern versions of Java are continuously improving efficiency through performance enhancements and the introduction of virtual threads. It may be more rational to optimize the existing Java stack than to incur the massive cost of switching to Rust.
- Go: If you need generally higher performance and development productivity compared to Java, Go, with its gentler learning curve and larger developer pool, can provide “good enough” performance as a realistic alternative.
- Ada: In extreme situations requiring native performance faster than Go and the highest level of stability, it might be more practical to consider Ada, which has been hardened for decades in the aerospace and defense industries.
In conclusion, even with the clear weapons of “memory safety” and “operating cost reduction,” Rust remains in a difficult position. This is because even in areas where the value Rust provides is needed, strong and realistic alternatives like Java, Go, and Ada exist. For now, choosing Rust is less of a “wisest investment” and more of a “highly strategic choice” that requires clear cost calculations and accepting various trade-offs.