The Fascinating History of Rust
In July 2010, at the Mozilla annual summit, Graydon Hoare casually started his powerpoint presentation with a modest statement: “I have been writing a compiled, concurrent, safe systems programming language for the past four and a half years. A small group of people in Mozilla got interested in it this past year and we do not know exactly what will come of it.”
Little did he know that his small project would far exceed all expectations, becoming a game-changer in the programming world. Rust would not only be adopted by tech giants to power their products but also achieve a groundbreaking milestone no one thought possible — join C and Assembly in the Linux Kernel. Today, Rust is celebrated as one of the most loved programming languages, topping developer surveys year after year. With its growing popularity, now is the perfect time to look back at its fascinating journey while exploring the design goals and features that set it apart.
Origins and Early Development
Rust’s journey began in 2006 as Graydon Hoare’s personal project where he drew inspiration from decades-old programming languages like CLU, Erlang, and Limbo, believing their overlooked innovations could solve modern challenges. He defined Rust as “technology from the past come to save the future from itself,” a sentiment echoed by other early developers who described Rust as being based on “mostly decades-old research”.
For several years, Hoare worked on the project quietly in his free time, sharing it with no one at Mozilla. That changed around 2009, when a small group at Mozilla started taking interest in what he was building. Interestingly, the Rust programming language is named after the Rust fungus, but not for the reasons one might think. The name was chosen simply because the creator liked how it sounded. That said, Rust fungus is also known for its resilience and ability to spread rapidly, providing an apt metaphor for the language’s eventual impact.
Mozilla’s Involvement and Iterative Development
Thanks to the interest his presentation raised, Mozilla began sponsoring Rust in 2010. The newly created Rust team built the language using empiric iteration. The creators knew from the beginning what the final version of the language had to look like, but the path to get there was not clear at all at that time. In the words of Nico Matsakis, one of the core team members of Rust: “It took a long time to figure out how Rust ought to work.” The team experimented with new language features by implementing and testing them. If a feature felt right, it was kept. If not, it was discarded. This iterative approach led to many failed experiments, but it also resulted in the innovative features that define Rust today. Steve Klabnik described this process best: “Rust has lost more features than many languages had in the first place.”
Technical Evolution
Early Rust versions contained features such as explicit object-oriented programming via an “obj” keyword, a typestates system that would model the state of a value explicitly in the typesystem, and default pure functions to disallow implicit side effects.
What’s more interesting is that the first version of Rust used a garbage collector for memory safety. Over time, this was replaced with the groundbreaking type system and borrow checker paradigm that make Rust so unique and appealing today. While the early development of Rust might seem chaotic, the language benefited from a team of incredibly talented developers. Early projects where Rust was battle-tested included rewriting the Rust compiler, which was originally written in OCaml, and parts of Gecko, the rendering engine behind Firefox.
Governance and Community
In 2013, Graydon stepped down from his “Benevolent Dictator For Life” role, allowing Rust to evolve organically under a more federated governance structure.
In the following years, Rust underwent significant transformations, particularly in its type system. Type state was removed, various language features were streamlined, and the garbage collector was phased out. During this time, Rust’s innovative ownership system was refined and expanded, becoming the foundation for preventing memory-related bugs and ensuring safe memory management.
A Request for Comments process was established in 2014, and on January 9, 2015, Rust 1 alpha was released. January 9 falls on a Friday proving once and for all that Rust developers are crazy enough to kick off major releases right before the weekend.
The year 2015 also marked the introduction of Rust’s unofficial mascot, Ferris the Crab.
Infrastructure and Tools
Rust’s evolution wouldn’t have been possible without the innovations of Cargo and Crates.io. Cargo, introduced early in Rust’s development, simplified dependency management, project builds, and testing, making it an indispensable tool for Rust developers. Crates.io emerged as Rust’s official package registry and a central hub for sharing and discovering community-contributed libraries, known as “crates.”
While Rusts toolchain is impressive, testing and monitoring APIs remain a critical concern for developers.
That’s where today’s sponsor, EchoAPI, comes in. By integrating Echo API into the development workflow, you can effortlessly create automated testing scenarios for APIs built in Rust or any other language. Echo API is ultra-lightweight, fast and offers a suite of powerful features, including unlimited interface testing, run collections or robust offline support, so you can work anywhere, anytime. On top of that, their free features are guaranteed to stay free forever, so please check them out by clicking this link.
Industry Adoption and Recognition
Back to this article, in the following years, Rust gained significant traction not only within Mozilla but also among other major tech companies.
In 2017, the Firefox web browser shipped with Rust code, and Tokio, the asynchronous Rust runtime, received a grant from the Mozilla Open Source Support fund to support its development.
In 2018, Rust reached another major milestone with the release of a new edition, the first big update since Rust 1.0, introducing refinements to its syntax, module system, and tooling. Rust employs a unique system of editions to introduce significant, yet backward-compatible, enhancements to the language. These editions are not major versions but represent coherent sets of features and changes that developers can opt into.
By 2019, Rust was seeing broader adoption across the tech industry. Major companies began integrating it into their workflows, recognizing its performance and memory safety advantages. NPM used Rust to improve their package manager’s performance, Microsoft explored Rust for secure low-level systems development in Windows, and Google integrated Rust in Android to enhance memory safety and performance in system-level components.
Linux Kernel Integration and Foundation
A historic milestone was reached in 2021 when Rust was accepted into the Linux kernel. Linus Torvalds and the Linux maintainers embraced Rust as a way to introduce memory safety into the kernel while exploring new promising technologies.
As Torvalds noted: “To me Rust was one of those things that made technical sense but to me personally even more important was that we need to not stagnate as a kernel and as developers.”
The Rust Foundation was subsequently founded as a collaborative effort between Rust’s core team and major corporate sponsors, aiming to ensure the long-term sustainability, development, and governance of the Rust programming language.
However, challenges emerged in early 2023 when the Foundation found itself at the center of controversy due to a proposed trademark policy change. The draft policy aimed to regulate how the Rust name and logo could be used, including recommendations for avoiding “Rust” in crate names. This move was met with strong resistance from the community, as it was seen as overly restrictive and counter to Rust’s open and collaborative ethos. The backlash prompted the Foundation to issue an apology and commit to revising the policy with greater transparency and community input.
During this time, members of the Rust community initiated a synchronized fork of the language, naming it CrabLang, not as a permanent split but rather as a symbolic protest.
Future Prospects
In recent years, Rust has outgrown its label as a systems programming language and is steadily emerging as a serious contender in sectors like web development, game development, and even machine learning. Despite its steep learning curve, Rust’s unmatched performance, safety, and versatility make it a compelling choice for modern software development.
If you want to explore other programming languages you can check some of the other videos on my channel.
Until next time, thank you for reading!