Rust 1.0 Released

Rust is a systems programming language that aims to provide memory safety without relying on garbage collection or a runtime. Graydon Hoare began it as a spare-time project in 2006, and Mozilla backed its development from late 2009. The first stable release, Rust 1.0, was published by the Rust Core Team on 15 May 2015. The 1.0 announcement introduced Rust as "a new programming language aiming to make it easier to build reliable, efficient systems", combining low-level control over performance with high-level convenience and safety guarantees.

Most people who look Rust up meet one word early: ownership. This article traces where Rust came from, what 1.0 promised, and why ownership sits at the centre of the design.

A spare-time project, 2006–2009

In 2016 Hoare published Rust's pre-publication history on GitHub as "rust-prehistory". As he describes it, Rust was a personal project from 2006 to 2009 and, after late 2009, a Mozilla project conducted in private. The uptick in work in mid-to-late 2009, he writes, is when Mozilla started funding him on the clock.

He asks readers to take the archive in a particular light: not a grand plan being executed, but years of puttering in circles while he slowly convinced himself there was something there. He had spent years criticising other languages and making notes on how one might be done "right" or "differently"; the archive records the gradual coaxing into belief that he could make something that ran.

2010: the Mozilla Annual Summit

Hoare introduced Rust at the Mozilla Annual Summit in July 2010, in a talk titled "Project Servo". His slides say he had been writing "a compiled, concurrent, safe, systems programming language for the past four and a half years", and that a small group inside Mozilla had become interested over the past year. He was at pains to reassure: Mozilla was not rewriting the browser.

The slides gave two motives. First, C++, which he called "well past expiration date": memory unsafe, with no ownership policies and no concurrency control. Second, most new languages were unsuitable for the niche he cared about, for reasons such as a JVM or CLR tie-in, complex garbage collection combined with pointer-heavy data and poor memory use, or neglect of concurrency. Rust, he said, mostly cribbed from past languages — Mesa, CLU, Erlang, Newsqueak, Limbo and others from the 1970s to the 1990s — collecting lessons already learned rather than inventing new ones.

15 May 2015: Rust 1.0

The 1.0 announcement put Rust's difference down to its type system, which it described as a refinement and codification of the best practices hammered out by generations of C and C++ programmers. Experienced programmers would save time otherwise spent debugging; newcomers could write low-level code without minor mistakes turning into mysterious crashes. And it achieved this without requiring a garbage collector or runtime, so Rust libraries could serve as a "drop-in replacement" for C.

Above all, 1.0 meant the end of churn. Rust had gone through so much iteration that projects written in it were hard to maintain, because the language and standard library kept changing. The announcement called 1.0 "the official beginning of our commitment to stability": from then on, breaking changes were largely out of scope.

The announcement closes with a long list of people who had contributed changes since the previous release. Graydon Hoare is among them.

Ownership and borrowing

At the heart of Rust's safety is ownership. The official book, The Rust Programming Language, describes two familiar ways of managing memory: a garbage collector that looks for no-longer-used memory as the program runs, or explicit allocation and freeing by the programmer. "Rust uses a third approach: Memory is managed through a system of ownership with a set of rules that the compiler checks."

The book calls creating a reference borrowing: you can borrow something, but you have to give it back, and you never own it. Keep to the reference rules and data races — several threads changing the same data at once — cannot occur; in the book's words, Rust prevents them "by refusing to compile code with data races". Catching errors at compile time rather than at run time is, together with its type system, what most distinguishes Rust.

After 1.0

Stack Overflow's 2022 developer survey reported Rust "on its seventh year as the most loved language", with 87% of developers saying they wanted to continue using it. On 8 February 2021 the Rust Foundation was launched as an independent non-profit to steward the language and its ecosystem, with AWS, Huawei, Google, Microsoft and Mozilla as founding members. In December 2022 Linux 6.1 took in initial Rust support; that story is told in Rust enters the Linux kernel.

Rust's place among its contemporaries is on the programming-languages timeline. Reading the history of C++, the language Hoare called past its expiration date, shows where his frustration came from.