Hello and welcome to the State of Rust. Rust is a systems language pursuing the trifecta: safe, concurrent, and fast.

Over the past 6 months since the last one of these updates was written, Rust has evolved significantly: the standard library was refactored to make Rust more convenient to use in embedded or bare-metal platforms, the language has been greatly simplified (moving most pointer types into libraries) and the package ecosystem has been thriving under a new package manager.

The Rust Project

Rust is now its own organization on GitHub! This reflects that Rust is a major project with its own community and culture, and not simply another project under the Mozilla umbrella. Additionally, the meeting minutes now live in that organization, if you're interested in watching those. We have also introduced a Discourse forum for discussing the design and implementation of Rust and its standard libraries. An RFC process has been introduced for proposing changes to the language.

We now have official nightlies and a script that installs them, which provides a dead-simple way to install Rust without waiting over half an hour for a build. Our online sandbox also provides instant gratification, and all doc examples are runnable in it.

Moving on from meta-topics, many changes have happened in the language itself. Many features have been removed. These and other less-major changes make the language simpler, more consistent, and more powerful. An incomplete list:

  • do expressions
  • The Freeze kind
  • The priv keyword (everything is private-by-default)
  • All variations of @-pointers. They are replaced by the library type, Gc<T>, which shares many of the same problems @ did, implementation-wise.
  • All variations of ~-pointers. They are replaced by the library types, Box<T> and Vec<T> for ~T and ~[T] respectively.
  • Dereferencing is now overloadable, via the Deref and DerefMut types. This makes creating and using smart pointers much more painless!
  • A "placement new", or more accurately, "placement box" feature has been added. This replaces ~expr and will be extensible to user types. box 42i has type Box<int>. This feature is still baking.

The libraries have also seen a lot of love. Rather than having a single, monolithic libextra, there are now multiple more focused libraries. A list is available on our fancy new documentation index page. Of particular note, a huge amount of effort was spent splitting libstd itself into smaller pieces. There is a (rather large!) subset, which lives in libcore that uses no dynamic allocation or other such runtime features. libcore is suitable for use in embedded, bare-metal, and other resource constrained environments. libstd still presents a unified interface to all of the individual pieces, and is the stable entry point to the entire standard library.

The compiler has also grown a plugin system, that allows for user-defined syntax extensions, lint passes, and exportable macros. This is not well documented yet, but the new regex crate takes great advantage of this to provide compile-time checked regular expressions that can compile directly into Rust code, rather than always running them in a virtual machine at runtime or requiring a complex JIT compiler for good performance.

Steve Klabnik has been hired on a 6 month contract to improve our documentation. He has been busy filling in examples and writing our new guide. Our documentation will be vastly improved as time goes on, in preparation for the big 1.0.

The Rust Ecosystem

Perhaps the most marked change in Rust is its community. It is growing faster than I could have anticipated. There are many projects being undertaken by groups of people who aren't also working on the compiler or standard library. This is a significant shift from the past, where trying to do a project in Rust almost forced you to improve Rust or abandon it. In particular:

  • The Zinc project is building a bare-metal ARM stack aiming at writing a completely safe RTOS toolkit. It uses a loadable syntax extension to describe the hardware features of a particular hardware platform.
  • The Piston project is a growing community of game developers building libraries and an engine to make developing interactive graphical applications painless and safe.
  • The Iron project has created a Rack-inspired web framework that allows easily composable "middleware" to stack and build a robust web application.

There are many other smaller libraries and projects the community is undertaking, however these three represent major areas that Rust is great for and are the largest (in terms of developers/maturity) in their respective spaces.

Making things even better, the official package manager, Cargo, has finally been released! It is only in alpha, but is maturing quickly. The magnificent Rust CI is tracking which repositories have Cargo support. Uptake has been rapid, which bodes very well for its continued success.

Looking Forward ("Is Rust ready yet?")

Rust is not ready yet. It still has a few more release cycles before 1.0. In particular, the "unboxed closure" and "dynamically sized types" work is not yet complete. There are also many minor changes to improve ergonomics in the pipeline. That said, it is becoming more stable, and many major features are complete. If you want to, give it a spin, and let us know how it goes!