Welcome to the third issue of the Rust GameDev Workgroup’s monthly newsletter.

Rust is a systems language pursuing the trifecta: safety, concurrency, and speed. These goals are well-aligned with game development.

We hope to build an inviting ecosystem for anyone wishing to use Rust in their development process! Want to get involved? Join the Rust GameDev working group!

Game Updates 

Sulis - a Turn-Based RPG 

chest and inventory with items

Sulis is a Role Playing Game (RPG) with turn based, tactical combat, deep character customization and an engaging storyline. The game has been built from the ground up with modding and custom content in mind. Currently supported on Windows and Linux platforms.

The game is currently fully playable and includes the first act of The Twin Expanse, an old school RPG campaign in the vein of classic games such as Baldur’s Gate, but mixing in modern elements from titles like Divinity: Original Sin and Pillars of Eternity.

The core game engine as well as the campaign are still under heavy development. Users are encouraged to file issues with bugs, feature requests, or any other feedback.

flaming fingers spell demonstration


  • Cross platform native binaries, currently built for Windows and Linux
  • Multiple campaigns with over 8 hours of playtime, featuring both handcrafted and procedural content.
  • A detailed and fully realized world and story - check out the Lore page.
  • Designed with modding in mind - although more work still needs to be done in this area.
  • A powerful 2D graphics engine with zoom, scalable UI, HiDPI support, and a swappable graphics backend.
  • Runs on very modest hardware - even software renderers (although at a reduced frame rate).

ability tree gui

The GPLv3-licensed source code is hosted on GitHub. Sulis is written in Rust, with scripting in Lua and most data files in the YAML format.

Discussions: /r/rust_gamedev


Bumpy terrain with a rivers and trees

Veloren is an open-world, open-source multiplayer voxel RPG. The game is in an early stage of development, but is playable.

This month a v0.4 version was released and a player survey results was published.

Some of October’s improvements:

  • lots of bugfixes and optimizations;
  • improved erosion, rivers and water flow physics;
  • user interface improvements;
  • improved game lore;
  • RFC procedure for 0.5 development.

New video: “Cities, dungeons and other structures” [/r/veloren].

The full weekly devlogs “This Week In Veloren…”: #36, #37, #38, #39.

Also, check out /r/veloren subreddit, it’s pretty active.

Canon Collision 

Exported models with textureas and skeletal animations

Canon Collision by @rukai is an Undertale + Homestuck fan-made platform fighter with powerful tools for modding. It was forked from another project of rukai’s PF Sandbox so he could focus on making a game rather then an engine.

This month, exporting and hot-reloading assets from blender, freelook camera, textures, and animations were added to the project.


Antorum screenshot: a few human characters, a few rats and an inventory UI

Antorum is a multiplayer RPG where players build their characters and fight against the growing threats on the isle. The game server is authoritative and written in Rust, while the client is written in Unity/C#.

This month, @dooskington published a bunch of devlogs:

As described in the 7th devlog, an initial version of a “grubbnet” crate was published.

It’s a lightweight TCP client/server for writing networked applications and games. It abstracts socket code, keeps track of connections, and delivers everything back to the developer in a nice list of events. In addition to handling network events (such as client connects and disconnects), handling incoming packets is as easy as grabbing an iterator over the incoming packet queue.

It’s the same networking crate that the Antorum game server uses under the hood.

Ferris Fencing 

Two crabs fencing on a 1D map

Ferris Fencing is a live tournament in which player-programmed bots combat each other on a RISC-V virtual machine. It is a showcase of CKB-VM, a simple implementation of the RISC-V instruction set, written in the Rust programming language.

Here’re the rules.

The Ferris Fencing tournament is not yet live, but fencers may begin building their bots and testing them locally. Instructions are in the GitHub repo.

Tennis Academy v0.03 & v0.0.4 

4 courts with players

@oliviff released v0.0.3 and v0.0.4 updates for Tennis Academy:

  • 🏘️ improved reception area queueing
  • 🎆 timed effects when players disappear
  • ⛹️ click to collect coins from player
  • 👟 4 courts on screen
  • ⛹️ matching t-shirts for players
  • 💯 money is now score
  • 🚥 court + t-shirt colour matching logic
  • 📊 score multipliers


Virtual piano keyboard

piano-rs is a multiplayer piano using UDP sockets that can be played using computer keyboard, in the terminal.

Discussions: /r/rust

Will it dissolve? 

Dissolve gameplay demo

“Will it dissolve?” is a small puzzle game for “Open Jam 2019” where you have to prepare the level so that it will automatically convert and dissolve in the future.

Programmed with the help of the Tetra engine. The source code is available here.

Garden Devlog: October 

Garden screenshot: a tree, leaves, water and ruins

Garden is an upcoming game centered around growing realistic plants.

The following changes were made since the last devlog:

  • Improved flowers were added.
  • The plant simulation code is almost finalized, and developers will be able to start adding new species soon.
  • The procedural ruin generation was improved: no more floating concrete chunks.

Watch the video demo here.

Also, a new design plan was created:

  • The main objective is to restore the luscious ecosystem in a polluted wasteland. The player will have to continuously figure out how to handle different environmental constraints to keep trees growing, collect enough fruit and figure out what to do with them, and unlock new goals and flora.
  • But for players who are interested in wild, goalless plant growth, there’ll also be a sandbox mode. As one progresses in the main game and “unlocks” more trees, playing around with creating flourishing jungle troves will be possible.

To stay informed of smaller updates, screenshots, and new devlogs, follow @logicsoup on Twitter.

EVE Aether Wars Backend Optimization 

@aidanhs shared a small EVE Aether Wars backend optimization success story:

To double the tick rate to 30Hz, our underlying @rustlang layer from last time needed…a two line bugfix and some metrics support. Nice proof point for reliable software in Rust!

Robo Instructus 

Alex Butler continues to polish their “Robo Instructus” game; 1.12, 1.13, and 1.14 versions were released: non-ascii code input, new icons, bugfixes, and better translations.

You can contribute to translations here.

translated menu items

Godot and Rust 

Ludum Dare 45 

Ludum Dare is a regular game jam event, during which developers create games from scratch in a weekend based on a theme suggested by the community.

LD45’s theme was “Start with nothing”. Here are some of the games made with Rust:

  • “Working Title” by @NoahRosenzweig made with Amethyst (source code).

    Experience a work in progress.

    Play through the development process of a 2D platformer game, and watch your environment transform as you progress… The further you get, the more features are added, including menacing enemies, destructive spikes, and adaptive music.

    Working Title: an early stage of the game

  • “Mindmaze” by @sigodme (source code).

    A small and unhurried story about devious passages of the trapped human mind. Begin in the middle of oblivion as shadow and take a walk through every chamber of this place to find all shards of lost personality. Can you find the way out?!

    Mindmaze: main menu

  • “Legally Dead” by @vilcans made with ggez (source code).

    With nothing, not even memories, you find yourself maneuvering some kind of craft in strange caves.

    ultra-low-poly ship in low-poly caves

    Check out the devlog post: “Tools and tech for my game written in Rust”.

Amethyst Games 

Library & Tooling updates 

Dev Time Optimization – Part 1 (1.9x speedup, 65% less disk usage) 

Compile times (full and incremental) are one of Rust’s pain points. Azriel published a devlog about optimizing Will’s build times. Summary:

In a 45k LOC / 102-crate workspace, moving tests from member crates into a single workspace_tests crate achieved the following improvements:

  • Build and test duration in release mode reduced from 23 minutes to 13 minutes.
  • Debug artifact disk usage reduced from 20 G to 7 G (65% reduction, fresh build), or 230 G to 50 G (78% reduction, ongoing development).

Discussions: /r/rust

🛈 Tip: Speed Up Iteration Time By Using LLD Linker 

Takeaways from an interesting tweet from VladZhukov0 and a /r/rust thread “Is the rust compiler really THAT slow?”:

  • Try switching to LLD linker:

    RUSTFLAGS="-C link-arg=-fuse-ld=lld" cargo run
    # Alternatively, you can set `rustflags` in your `.cargo/config`

    Depending on your project structure, OS, and toolchain this can potentially speed up the incremental compilation a few times.

  • Also, try disabling debug information (if you don’t need it):

    # in your `Cargo.toml`
    debug = 0

Now the linking only takes around one second, compared to 10 seconds previously.

Reduced my average compilation time from 10-20s (which is a bit crazyness for gamedev iteration) to 5-7s. Wonder why haven’t I tried this before?🤔

Also, see this GameDev WG tracker/complaint issue: #50 “Linking Time”.

RLSL: a Rust to SPIR-V Compiler 

RLSL code sample
a simple fragment shader that renders a red circle (temporary syntax)

This month, @MaikKlein_DEV gave a talk at The Khronos Group’s meetup in Munich about bringing Rust to the GPU: here’re the slides.

RLSL (Rust Like Shading Language) is an experimental project that allows compiling Rust to SPIR-V.

Current features:

  • Supports cargo;
  • Multiple entry points can be defined in the same SPIR-V module;
  • Currently supports Vertex, Fragment and Compute shaders;
  • Shader code can run on the CPU because rlsl is a subset of Rust.

Also, check out older posts:

Discussions: /r/rust, hacker news

gfx-rs v0.4 

sailor screenshot: vector terrain map and some basic UI
a screenshot from Yatekii/sailor - a wgpu-based sailing navigation application

gfx-rs v0.4 was released: major changes were described in the last blog post, for the detailed list of changes, see the CHANGELOG.

Vulkano: Why Command Buffers Are So Complicated? 

vulkano logo

A twitter thread by @Tomaka about why command buffers in Vulkano (a Rust library that wraps around Vulkan graphics API) are so complicated.

splines v3.0 

a spline sample with node handles

splines, a crate by @phaazon to handle spline interpolation, just got released in version 3.0.0.

That version adds support for stroke Bézier interpolation, which is a Bézier interpolation but allows you to break the handles (instead of the regular 180° angle formed by the handle with the Interpolation::Bezier mode).

spline-editor got a patch to allows you to try stroke Bézier.

This Month in Mun - October 2019 

Mun is a scripting language for gamedev focused on quick iteration times that is written in Rust.

The Mun Team started October with the launch of the mun-lang.org website, Discord server, and OpenCollective and processing the feedback from a larger audience. Now the team is moving towards v0.1 release.

Also, check out /r/rust “The Mun programming language is going live!” post.


ultraviolet benchmarks table

ultraviolet by @fu5ha is a crate to do basic, computer-graphics-related, linear algebra, but fast, by taking full advantage of SIMD.

<…> To do this, it uses an “SoA” (Structure of Arrays) architecture such that each Wec (wide-vec) actually contains the data for 4 Vecs and will do any operation on all 4 of the vector ‘lanes’ at the same time. Doing this is potentially much (factor of 10) faster than an “AoS” (Array of Structs) layout, as all current Rust linear algebra libraries do, depending on your work load. However, algorithms must be carefully architected to take full advantage of this, and doing so can be easier said than done, especially if your algorithm involves significant branching.

Discussions: /r/rust

This month in rustsim #8 (Aug - Sep - Oct 2019) 

salva’s logo

Main updates:

  • salva.rs - two new crates for fluid simulation: salva2d and salva3d!

    Salva is a new project dedicated to fluid simulation. The goal of salva is to provide CPU-based, particle-based, 2D and 3D, fluid simulation libraries that can be used for interactive and offline application like animation. It could be used, to some extents, for video games (especially the 2D version), as long as the number of particles is kept small.

    Watch a “Fluid simulation with salva 0.1 and nphysics 0.13” video or play with the online 2D or 3D WASM demos yourself.

  • nphysics 0.13 brings: some support of breakable joint constraints, and more improvements on the integration with ECS.

  • @sebcrozet (the main developer of all the current rustsim projects) have been added to the GitHub sponsor beta.

Discussions: /r/rust


cyclone physics demo
a little demo of “particle” simulation

cyclone-physics-rs by @heyrutvik a new WIP game physics engine based on the “Game Physics Engine Development” book.

Cynic64’s WIP Rendering Engine 

@cynic64 shared a demo video and a report about their WIP rendering engine.

It’s based on Vulkano and consists of three repos:

  • re-ll - low level abstractions for Vulkano’s command buffers and windows.
  • render-engine - Vulkan abstraction.
  • test-render-engine - various little programs created with render-engine. “pretty” is the one shown in the video, “base” shows the basic functionality.

Rust Roguelike Tutorial 

“Doors” demo

The Roguelike Tutorial by @blackfuture includes almost 40 chapters now and continues to grow.

Some of the October’s updates:

  • traps and doors;
  • mapgen algorithms including Waveform Collapse;
  • prefab levels and sections;
  • guided procgen for towns.

All chapters have links to WASM demos.

Also, 0.5 version of rltk-rs brings abstraction between back-ends, better compile time, web version improvements, and more examples.

Nannou awarded Mozilla grant for foundational audio development 

Nannou & mozilla logos

Nannou is a creative coding framework that aims to make it easy for artists to express themselves with simple, fast, reliable code.

Nannou has been awarded 10K USD in funding as a part of the MOSS Mission Partners track. The proposed work is aimed towards improving the state of some foundational crates within the Rust audio ecosystem over the next three to four months.

Key areas of our work will include:

  • Addressing some long-standing issues in CPAL.
  • Review and improve CPAL’s web audio support.
  • Implement a simple web app and guide demonstrating CPAL’s web audio support.
  • Design, develop and document a standard audio graph abstraction and crate, reflecting on lessons learned and limitations of prior efforts, and the requirements of the wider rust audio community.

Discussions: /r/rust


amethyst logo

Meeting Minutes 

See all meeting issues including full text notes or join the next meeting.

Requests for Contribution 


Just an interesting Rust gamedev link from the past. :)

Gravisim screenshot

Gravisim by @bcamp1 is a simulation of universal gravitation. It uses Newton’s Law for Universal Gravitation to run an n-body physics simulation.

Check out a video demo in this /r/rust announcement.

That’s all news for today, thanks for reading!

Want something mentioned in the next newsletter? Send us a pull request. Feel free to send PRs about your own projects!

Also, subscribe to @rust_gamedev on Twitter or /r/rust_gamedev subreddit if you want to receive fresh news!

Discussions of this post: /r/rust, twitter.