Getting Rust-y

Rust 1.0 is here and stable

Rust image via Shutterstock

A commitment to stability has helped churn out Rust 1.0, with claims of blazingly fast performance, prevention of nearly all segfaults and guaranteed thread safety. Being open source and now also openly governed is the icing on the cake.

The system language Rust, which stands up as a competitor to the likes of C, C++ and Google’s Go, has hit version 1.0. The language combines low-level control of performance with high-level convenience and security guarantees.

Because Rust 1.0 doesn’t require a garbage collector or runtime to achieve the above goals, its libraries can be used as a direct replacement for C.

Unlike previous versions of the release, we are presented for the first time with a stable syntax; the developers behind its release have finally committed to a stable shipment, meaning breaking changes are unlikely to come for a long while. The Rust core team cited the creation of the language as a result of “a lot of iteration and experimentation”.

Rust today is both simpler and more powerful than we originally thought would be possible. But all that experimentation also made it difficult to maintain projects written in Rust, since the language and standard library were constantly changing.

The 1.0 release marks the end of that churn. This release is the official beginning of our commitment to stability, and as such it offers a firm foundation for building applications and libraries.

To bring in their new features as quickly and comprehensively as possible, the team will jump immediately into a train-based release schedule: new updates released every six weeks. Just like Spring Data and Eclipse, compiler and language improvements will make their way out into the ecosystem at large as quickly as possible, with the Rust 1.1 beta also release in conjunction with the stable 1.0 shipment.

Is Rust the real deal?

Is Rust all its cracked up to be? How does it compare to C and Go? Firstly, Rust’s syntax is very similar to C, yet contains advanced constructs to prevent invalid memory accesses and better support for multicore architectures.

Other characteristics of the language include pattern matching and algebraic data types (enums), type inferences, higher-order functions (closures) and generics and polymorphism in the form of Java-like interfaces in combination with Haskell-like types classes (traits).

SEE ALSO: Rust 1.0.0: Coming Spring 2015

Rust 1.0 supports both functional and object-oriented programming practices. Concurrency is realised via lightweight tasks such as those found in Erlang or other actuator-based languages. Since 2011, Rust programs have been written in the Rust compiler rustc, which relies in turn on LLVM backend technology.

Recently, the team behind Rust has adopted an open governance model, making sure that all changes, bug fixes and documentation improvements are completed out in the open by way of their RFC policy. All major decisions are made with the intention that “all stakeholders can be confident about the direction the language is evolving in”.

More information about Rust can be found at

Inline Feedbacks
View all comments