Rust 1.0 has been released

[HeroesGraveDev]

(Rust the programming language, not the game)

Throughout Rust’s development, a lot of breaking changes have happened, but now that 1.0 is released, things are guaranteed to be mostly backwards-compatible (Changes are allowed that would require parts of code to be more explicit, as long as the explicit form works on both the old and new versions of the compiler).

Announcing Rust 1.0 | Rust Blog

Over the last 1.5 years I’ve been learning Rust (well, you never really stop learning a language until you stop using it), and have found myself preferring it over Java for use in gamedev. I’ve entered two Ludum Dares, written an Entity-Component System library, amongst other various utility libraries (thankfully, most of which I’ve abandoned as the language and other libraries evolved to make them redundant), and have two more libraries in progress (windowing and graphics) that aren’t publicly available yet.

This paragraph from the documentation does a better job of explaining Rust than I ever could.

Rust is a systems programming language focused on three goals: safety, speed, and concurrency. It maintains these goals without having a garbage collector, making it a useful language for a number of use cases other languages aren’t good at: embedding in other languages, programs with specific space and time requirements, and writing low-level code, like device drivers and operating systems. It improves on current languages targeting this space by having a number of compile-time safety checks that produce no runtime overhead, while eliminating all data races. Rust also aims to achieve ‘zero-cost abstractions’ even though some of these abstractions feel like those of a high-level language. Even then, Rust still allows precise control like a low-level language would.

The biggest difficulty I found in learning Rust was that you have to get out of the OOP & inheritance mindset of Java. Rust still supports OOP, but not in the same sense that Java does. Think of Java where you can extend interfaces, but not classes and you get the general idea of Rust’s OOP. Fortunately, the generics system is very powerful (not as much as C++ templates, but they cause headaches), which makes using traits (equivalent of Java interfaces) much more viable. Most importantly: You can’t write Java in Rust.

Several useful features didn’t make it into 1.0 because at the time they weren’t deemed stable enough to commit to. If you want these features, there’s always the nightly builds.

If you’re interested in learning Rust for gamedev, here’s a list of libraries:

• glfw-rs: GLFW3 bindings (For those of you who like LWJGL 3)
• rust-sdl2: SDL2 bindings (For those of you who like SDL2)
• glutin: Cross-platform windowing library. Similar to GLFW3, but easier to compile on Windows because it’s written in pure rust.
• gl-rs: OpenGL bindings generator for the people who use Pure LWJGL (For those of you who only have experience with LWJGL, you’ll need a windowing library such as glfw-rs, rust-sdl2, or glutin)
• piston: Higher-level abstracted graphics library.
• piston-image: Pure rust image encoding/decoding (Part of the piston project, but is standalone).
• glium: Safe abstraction over OpenGL. Only supports glutin for windowing, or can run in headless mode.
• gfx-rs: High-performance bindless graphics API (Abstracts over OpenGL/D3D/Vulkan)
• gfx_scene: Scene management built on top of gfx-rs
• snowmew: Multi-threaded game engine that uses a Copy-On-Write game state for high performance and safe concurrency (possibly out of date)
• ecs-rs: Entity-Component System framework. (Written by me. Only works on nightly for now)
• Various other things

Various useful links:

• Rust Website
• Documentation
• Official Package Repository
• Rust on Github
• Official Users’ Forum
• /r/rust
• /r/rust_gamedev

It would also be interesting to have a discussion on what you think of the language.