Welcome to the 48th 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!

You can follow the newsletter creation process by watching the coordination issues. Want something mentioned in the next newsletter? Send us a pull request. Feel free to send PRs about your own projects!

Announcements 

Rust GameDev Meetup #29 

YouTube preview: “Blade: Advanced Pipeline” slide showing a texture diagram

The 29th Rust Gamedev Meetup took place in July. You can watch the recording of the meetup here on YouTube. The schedule:

The meetups take place on the second Saturday of every month via the Rust Gamedev Discord server and are also streamed on Twitch.

Game Updates 

Colony 

tiled map with lots of grass and trees, some resources and a couple of named pawns

Colony by @ryankopf is a colony simulator game built with Bevy that is open source and is in a pre-alpha stage. Similar to other colony simulator games like Dwarf Fortress or Rimworld, there are units that have their own traits and can be instructed to perform tasks like farming and chopping trees.

You can have your units build things, farm stuff, and explore, and the game is soon to be moving onto adding more content and UI, as core features are being completed.

Discussions: /r/rust

Open Combat 

OpenCombat completed HUD Game HUD is now more complete

Open Combat (Website, GitHub, Discord) is a real-time tactical game which takes place during the 2nd World War.

Some major changes this month:

  • HUD has been filled with a minimap and squad information.
  • Multiple issues about zoom and move on map have been fixed.
  • A high-definition map has been created.

Some fixes and improvements have to be done, but the devs are near to publishing the official demo of the game!

CyberGate 

Universal quic server The browser uses webtransport (Left), the native uses quinn (Right)

CyberGate (YouTube, Discord), CyberSoul is developing an ambitious multiplayer project, utilizing procedural generation and AI to offer a dynamic universe.

The latest updates to CyberGate include:

  • Implemented a Webtransport Client and a universal quic server.
  • A custom game launcher that is reliable and efficient.
  • Universal mechanism to save, load, and upgrade the game world from disk.
  • Optimized multithreaded evolution algorithms for generating universes.
  • Created an accessible editor for fine-tuning component values.

Participate in Testing and Engage with CyberSoul: on Discord.

Way of Rhea 

Way of Rhea on SteamDeck

Way of Rhea is a puzzle game with hard puzzles but forgiving mechanics being produced by @masonremaley in a custom Rust engine. You can support development by checking out the free demo and wishlisting on Steam or signing up for the mailing list!

Recent updates:

  • Way of Rhea now natively supports Linux, and Steam Deck! Mason released a writeup on the port here.
  • Way of Rhea was part of the Cerebral Puzzle Showcase.
  • Crash handling was improved, and the build process was simplified (necessary for post-release support). A fix was landed to backtrace-rs as part of the improved crash handling.
  • Time controls were released as part of the updated demo.

tiny-snake.rs 

tiny-snake.rs running in the terminal

tiny-snake.rs by @Rodrigodd is a terminal snake game, with a minimal binary size.

The entire game is implemented in a single file of pure Rust code, with zero dependencies. All interactions with the system are done through raw syscalls (so it only runs on Linux, sorry) and the program is completely panic-free (panic handling increases the binary size by almost 4KiB).

The game can be compiled using a single rustc command, and the resulting binary is only 2760 bytes.

Discussions: /r/rust

8bit Duels 

Screenshot featuring the new enemiy: the crow

8bit Duels (Discord) is a turn-based strategy game made by @ThousandthStar. It has been in development for the past year, and the release is right around the corner! A new blog post along with a release Youtube video is coming soon on this channel.

This month’s update includes a completely remade user interface. The devlog covers the change from the bevy_ui crate to belly, which provides a nice HTML-like syntax for building the UI. The last devlog post will address the re-implemented UI and the new troop: the Crow!

The Crow, as seen in the screenshot above, is a hooded bird assassin with two daggers. It can attack twice per turn, dealing 2 damage each time. The Crow is the last of the five 8bit Duels characters.

Ant Colony Simulation 

lots of glowing particles (aka ants) moving to the destination

Ant Colony Simulation depicts an ant colony where the ants have a simple task: to find food and bring it back to the colony. To achieve this goal, they use signals called pheromones. These pheromone signals guide the ants to the food source and back to their colony.

@BonesaiDev released a couple of videos about the project:

The project is written using Bevy. You can find the source code on GitHub.

Follow @BonesaiDev on Twitter or on YouTube to receive future updates about this and their other AI simulation projects.

Cargo Space 

Screenshot of an astronaut in front of stars and two galaxies

Cargo Space (Discord) by @johanhelsing is a co-op 2d space game where you build a ship and fly it through space looking for new parts, fighting pirates and the environment.

This months development was all about making endless procedurally generated parallaxing space backgrounds, choosing an appropriate rng crate, and making the implementation seedable and cross-platform deterministic.

Johan’s devlog entry explains all this in detail, as well as how distant parallax can be an immersive replacement for ui and minimaps.

Veloren 

Veloren visual comparison The 0.15 release party map

Veloren is an open world, open-source voxel RPG inspired by Dwarf Fortress and Cube World.

In July, Veloren released version 0.15! You can read about the release in the 0.15 blog post, and watch the release party trailer. Here are some of the changes in this release:

  • The first world boss, the ‘frost giga’: seek him out if you dare!
  • A new dungeon: Adlet caves.
  • Airships can now be used by players.
  • Enemy loot is now shared between players.
  • A reputation system: if you commit crimes, NPCs will remember it!
  • Improved AI: NPCs will talk to players and each other about events in the world.
  • Much richer world simulation: NPCs will migrate and pass on rumours.
  • You can now choose your character’s starting town.
  • A durability and repair system.
  • Improved accessibility, performance, bug fixes, and much, much more!

Work over July includes TCP receive buffer increase, spawn tab completion, loot changes, translation updates, dwarven quarry ⛏️ (still inactive in game), coastal town, desert city fixes, CI optimization, and shorter item count texts. Work is going on to add a web-based translation tool for Veloren.

July’s full weekly devlogs: “This Week In Veloren…”: #213, #214.

Idu 

concrete islands, some dirts, water, lots of vines

Idu (Discord) is a strategic sandbox game about growing plants that wish to reclaim nature, developed by Elina Shakhnovich and Johann Tael featuring a bespoke Vulkan-based engine in Rust.

This month a new demo was released:

  • New water mechanics: instantly fill large pools and build channels to transport water.
  • A climbing plant.
  • A new particle system for special effects.
  • Swimming and improved climbing out of water.
  • Configurable keybindings.

MEANWHILE IN SECTOR 80 

YouTube preview: weapon bench

MEANWHILE IN SECTOR 80 (Discord, mailing list) by Second Half Games is an upcoming third-person action-engineering space game.

This month the third update was released, you can watch or read it. Highlights:

  • New engineering system allows inspecting objects around the player, modifying your equipment using workbenches, and adding wires between sockets located on different pieces of equipment.
  • Improved physics simulation that now features heat radiation and incandescence.

Space Kitty 

GIF from the trailer: 2d space arcade gameplay

Space Kitty by @ghashy is a platformer about a Kitty floating in space in search of crackers.

Somewhere in the distant space there are lots of tasty crackers floating around. In search of this highly valuable resource there are two competing parties - the DOGS and the KITTY. One can never say when the contest had begun, but it’s clear that to this day there is a game for the title of the Great Cracker Collector. Every time the cracker is taken the lucky one emits a signal to the base about his achievement. The KITTY - highly responsible and intelligent creature - always sends the exact amount of collected treasures, while the DOGS rely on their feelings. Some of them truly believe that they got multiple crackers at a time, some just can’t count, and about honesty of the others one can only guess…

The source code of the game can be found on GitHub.

Discussions: /r/rust_gamedev

Flesh 

Screenshot of the Steam page

Flesh by @im_oab is a 2D-horizontal shmup game with hand-drawn animation, an organic/fleshy theme and a unique story. It is implemented using Tetra.

After almost three years of development, it’s finally out on Steam!

Dive into a surreal journey as you devour a ship and battle peculiar creatures in this 2D side-scrolling bullet hell shmup. Unleash your skills, dodge relentless barrages, and uncover hidden mysteries in a hand-drawn world of flesh and gore.

The demo version was also updated, so consider trying the project out yourself.

Discussions: /r/rust_gamedev

HackeRPG 

Screenshot of a level up window asking the player if they want new GPU, VRM or register

HackeRPG is a WIP action game where you play as a developer who needs to fight viruses and bugs with coding in real-time. The game’s features include controlling your character using coding and expanding your toolset by programming your own functions, variables and daemons.

Recent updates include:

  • The first playable prototype is now avalable on itch.io.
  • Sound effects.
  • Input autocomplete.
  • New enemies.

Here’s a YouTube video that showcases the current gameplay.

Engine Updates 

Bevy v0.11 

bevy ssao

Bevy is a refreshingly simple data-driven game engine built in Rust. It is free and open-source forever!

Bevy 0.11 brought many incredible new features. You can check out the full release blog post here, but here are some highlights:

Discussions: /r/rust, Hacker News, Twitter, Mastodon

Fyrox 

GIF showing focusing camera on object in the editor

Fyrox (GitHub, Discord, Twitter) is a game engine that aims to be easy to use and provide a large set of out-of-the-box features.

This month Fyrox v0.31 was released. Highlights include:

  • A huge bunch of editor improvements like the ability to create custom editor plugins, ability to open multiple scenes, saving/loading docking manager layout, and a separate panel for camera preview.
  • Inverter node for AI behaviour trees.
  • 9-slice image widget.
  • Lots of API docs and the book improvements, mostly related to UI stuff.

Discussions: /r/rust

Learning Material Updates 

Mobile Development with Bevy 

@Nikl spent some time developing a mobile game using Bevy and documented findings on his blog. The first post contains notes on general project setup and some Android specific solutions.

GitHub workflows were created for automatic builds. A guide on how to set up an iOS workflow was released at the end of July.

Gentle Intro to GPUs for Backend Devs Pt1 

Diagram of WGPU stack from the article

Vladimir Zaytsev released the first part of a series about introducing backend engineers to GPU programming:

In this series of articles, I would like to offer a gentle and popular introduction to GPU programming specifically tailored for engineers. Whether you’re new to GPU programming or simply want to expand your knowledge, we’ve got you covered. I’ll explain the fundamentals of GPU programming in a way that’s easy to grasp if you’re more accustomed to working with backend services.

The first part gives a high-level introduction into GPU compute landscape and walks a reader through a toy GPU program written with wgpu.

Tooling Updates 

Rerun 

Rerun showing a large 3D point cloud

Rerun (Discord, GitHub) is an open-source SDK for logging complex visual data paired with a visualizer for exploring that data over time. While its primary focus is on robotics and computer vision, it can be useful for all kinds of rapid prototyping & algorithm development.

v0.8.0 and subsequently v0.8.1 are out now!

A few of the biggest highlights:

  • Pinhole logging is now easier to use in many cases.
  • The visualizer can now show coordinate arrows for all affine transforms within the view.
  • Users that build their own Viewer applications can now add fully custom Space Views.
  • New optional flush_timeout specifies how long Rerun will wait if a TCP stream is disconnected during a flush.
  • The RecordingStream now offers a stateful time API, similar to the Python APIs
  • Defaults to 8ms long microbatches instead of 50ms. This makes the default behavior more suitable for use-cases like real-time video feeds.
  • The web viewer now incremental loads .rrd files when streaming over HTTP. #2412

There’s a growing community on Discord waiting for you to join in case you have any questions, comments or just want to follow the latest development. The GitHub project is MIT/Apache licensed and open to contribute for everyone, be it with suggestions, bugs or PRs.

glTF IBL Sampler UI 

UI with field for input file and separate panels for different output parts

glTF IBL Sampler UI by @pcwalton is an artist-friendly egui frontend that wraps glTF IBL Sampler to generate cubemap skyboxes from panoramas.

It provides an easy way to generate skyboxes for use in Bevy and other new game engines that use the modern KTX2 format as their native texture format. By default, the panorama is split up into base color, diffuse, and specular parts, with the mipmap levels corresponding to different roughness values of the material.

Library Updates 

bevy_xpbd 

Balls held by string swinging and hitting each other in a Newton’s cradle Newton’s cradle simulated using bevy_xpbd

bevy_xpbd by @Jondolf is a 2D and 3D physics engine based on Extended Position Based Dynamics for the Bevy game engine. It uses Bevy’s Entity Component System (ECS) directly for the simulation data and logic, which makes the design and API feel better integrated into Bevy while avoiding the overhead associated with copying lots of data to a separate data structure like in many other physics engines such as bevy_rapier.

In mid-July, bevy_xpbd 0.2 was released, featuring:

  • Spatial queries (ray casting, shape casting, point projection, intersection tests);
  • Bevy 0.11 support;
  • Improved scheduling;
  • Velocity damping;
  • Gravity scale;
  • Locking translational and rotational axes;

and much more. You can find more details in the release post and changelog.

A lot of work was also done during the rest of July. The physics debug renderer was improved, collision stability issues were significantly reduced, external impulses were added, and Bevy’s own Transforms can now be used directly for moving bodies. The narrow phase part of collision detection was also refactored into a separate plugin, which makes multithreading and several upcoming features much easier to implement while also improving modularity.

Discussions: /r/rust_gamedev

Sparsey 

Sparsey by @LechintanTudor is a fast and flexible Entity Component System based on sparse sets.

The latest release, v0.11.0, improves the performance of adding and removing components from entities and adds new functions for running systems that only borrow data from one of World, Resources or SyncResources.

Hanabi 

Glowing particles circling and raising up Hanabi effect entirely simulated on GPU thanks to the new Expression API of v0.7

The Hanabi library (GitHub, docs.rs) is a modern VFX library for the Bevy game engine. It focuses on scale to produce stunning visual effects (VFX) in real time, offloading most of the work to the GPU (compute shaders), with minimal CPU intervention. The design is inspired by modern particle systems found in other industry-leading game engines.

This month, Hanabi saw its biggest release so far. Version 0.7 of Hanabi not only brings support for Bevy 0.11, but also adds a whole new Expression API to provide a new level of customizing for VFX authors. With expressions, developers can combine simple building blocks like simulation parameters (time, delta_time), effect properties (user-defined variables controlled from CPU), and math operators (add, mul, cos, …), to directly modify each attribute of a particle (position, velocity, …) and form complex behaviors with complete control. The expression API complements and extends the existing Modifier-based workflow to achieve even more complex effects.

This release also marks a major stepping stone toward the ability to build a visual editor (node graph) to build and tweak visual effects in real time.

Other changes include the ability to set a screen-space size for particles, and a new KillSphereModifier to confine particles to the inside or the outside of a sphere. See the CHANGELOG for all details.

Iced 

olf primitives gradually fade out and damaged regions are marked with red rectangles Visualisation of damaged regions during the incremental rendering

Iced is a Rust GUI library focused on simplicity and type safety.

Iced v0.10 is a huge release that brings a lot of updates. Some highlights:

  • Huge improvements to the text handling strategy thanks to the adoption of cosmic-text.
  • A new CPU-only software renderer based on tiny-skia.
  • Runtime renderer fallback.
  • Configurable LineHeight support for text widgets.
  • Nested overlays.
  • Backend-specific primitives.
  • Offscreen rendering & screenshots.
  • Gradients for backgrounds.
  • ComboBox widget.

Discussions: /r/rust

Other News 

Discussions 

Requests for Contribution 

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

Want something mentioned in the next newsletter? Send us a pull request.

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