Safer, faster and more reliable software: the industrial impact of Rust

Ever had to spend days or even weeks to find the cause of a race condition? Or those pesky common vulnerabilities and exposures (CVEs) because of a piece of memory that was lost somewhere? The Rust programming language aims to solve these problems. The language shines in its strict ways to force a programmer to write correct and fast code, combining many of the greatest hits from other programming languages. In addition, it brings a whole load of modern tooling that comes right out of the box, making testing, dependency management and documentation alongside programming a breeze.

When adopting Rust, you get more than a new programming language. After a one-step installation, Rust is ready for its first “Hello, World!”. With it, come the package manager called Cargo, a built-in unit test framework, a linter and a way to generate documentation – tools that are often used by engineers. This complete ecosystem makes it easy to set up a new project and get going right away. As it provides a standardized deployment setup, new developers and those keen to learn Rust quickly feel at home. For deployment, it’s a ubiquitous language, ranging from small devices to cloud infrastructure solutions. It allows the reuse of business logic in libraries on many devices between these extremes.

The Rust language itself also packs a punch with its stable releases since 2015. Using its modern functional aspects and compile-time guarantees, something like fearless concurrency comes as second nature. The compiler is very strict with analysis but also very helpful to developers by providing useful suggestions and examples on how to solve the encountered issues. It makes sure that the developer writes safe software, which can’t crash due to bad memory management. By eliminating the mental memory model, this results in higher confidence in functionally correct and stable code when deploying a new version of a project. Common mistakes, such as accessing data in C++ that’s no longer available or race conditions in Java, are things of the past with Rust.

But everything comes at a cost. The Rust language is no exception to this. The penalty for a safe language is a steep learning curve to feel at home. Especially the borrow checker, the part that makes the Rust memory management so solid, will really cause some head scratching for the first few violation reports. Furthermore, Rust is still growing, which brings growing pains. This is mainly noticeable in the availability of external libraries or, as Rust calls them, “crates.” For example, graphical user interface crates are very much in development. The strict compiler does help to have high-quality crates available for use, but overall, Rust lacks the quantity and diversity of more established programming languages.

Compared to other contemporary languages, however, Rust is in a unique position. It capitalizes on its immutability by design, strict error results and rich tooling to provide a singular role between programming languages. It has the speed of a systems language like C, the safety orientation of a functional language like Haskell and the ease of use offered by Python with its package management and included tooling.

Rust in practice

Alten has completed several projects showcasing the advantages of Rust. One example concerns a client who asked us to reduce the energy usage in their server application, which we achieved by using Rust in their software. The context for this investigation was that the client is physically limited in how much power they can draw from the electricity grid. We proposed to increase the efficiency of the available servers by utilizing Rust instead of Java. We decided to test the efficiency difference using a backtracking algorithm as synthetic workload since the largest workload is computation, based on the large data set they have. This synthetic workload creates solution datasets based on the computation results that are stored in memory until a valid solution has been found.

Between Java and Rust, we initially saw no real difference in operating speed. Java is very optimized for executing calculations. However, when we limited the memory usage of the Java program, Java eventually plummeted in performance. This is because Java caches earlier calculation results to reuse later on, thus increasing efficiency at the cost of huge memory requirements, which is undesirable in small JVMs. The project demonstrated that equal processing power is available, with reduced memory consumption for Rust.

Another client project had to do with embedded systems. Rust has a trick up its sleeve here: concurrency. In contemporary embedded systems, because of all the potential problems that come with using concurrency, this feature is completely ignored. Rust claims fearless concurrency with its memory constraints. And indeed, using a scheduling library called Embassy, it’s possible to create tasks and run them asynchronously. Create as many tasks as you want. Communication between tasks is organized via communication channels, sharing content instead of a memory location. Given these frameworks, the Rust compiler will guarantee that there are no race conditions and memory issues during runtime. This makes it a breeze to implement new functionality whilst the project remains flexible for expansion. All of this is available on embedded targets like ST’s STM32, Nordic’s NRF series and Espressif chips.

The future for software

Where will Rust be in the near future? With its compile-time safety, fearless concurrency and broad ecosystem, we at Alten certainly see a solid foundation for adaptation. And we’re not alone. During Rust Week 2025, there were multiple talks from big companies like Volvo, with embedded low-power software, and Google, with their Android team. They all presented figures with double productivity after two years compared to software with equal functionality and complexity written in C++, almost on par with a Go team at Google. Developers have higher confidence in correctness, making code reviews easier to perform.

Another observation is the reduction in software bugs. The Android team showed that the total number of bugs reduced to 20 percent of what they had prior to Rust usage, with the severity of the remaining bugs being much lower. This demonstrates that the team’s efforts to combat security issues in the Android project via Rust are successful and have a direct impact on the deliverables. Thanks to Rust, they need fewer defense mechanisms like sandboxes, as common security vulnerabilities with undefined behavior are eliminated. Other companies like Microsoft and Meta are committed to Rust as well, creating parts of their core infrastructure in Rust.

Alten’s experience with Rust, and that of many other big companies, is very positive. The complete ecosystem and the way Rust forces a developer into writing correct code really make the whole package shine. We think Rust is the future for software, making languages like C or C++ obsolete for many projects. We’ve already done various projects where using Rust improved a system, and we see potential for many more.