This Month in Rust GameDev #20 - March 2021

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

• Game Updates
• Learning Material Updates
• Engine Updates
• Library & Tooling Updates
• Requests for Contribution

Rust GameDev Meetup #

The third Rust Gamedev Meetup happened in March. It was an opportunity for developers to show off what Rust projects they've been working on in the game ecosystem. Developers showed off game engine demos, in-game playthroughs, tooling, and more. You can watch the recording of the meetup here on Youtube.

The next meetup will take place on the 10th of April at 16:00 GMT on the Rust Gamedev Discord server, and can also be streamed on Twitch. If you would like to show off what you've been working on, fill out this form.

Game Updates #

MineWars #

MineWars (Twitter, Reddit) by @jamadazi is Minesweeper reimagined as a Multiplayer Real Time Strategy!

Capture mines. Move them around. Cause explosion chains. Take out enemy mines. Defend your Cities. Fight for territory. Eliminate other players. Play on a procedurally-generated map.

The game has been privately in development for many months and was just announced publicly. The project is currently working towards an alpha release for public playtesting. Read the announcement on the website for more information.

Made in the Bevy Game Engine.

sm64js #

sm64js (GitHub, Discord) is a rewrite of the decompilation project of Super Mario 64 in JavaScript with a strong focus on massive multiplayer online. The backend recently has been rewritten in Rust by @marior and is now live.

You can find more information about it in this recent blog post, where the developers of a similar mod called Net64 are talking about several decompilation projects.

Some of the most recent additions are:

• Karts and gliders.
• Health meters.
• More visuals with butterflies and fish.

A stress test is scheduled for 2021-04-17 17:30 UTC and everyone is invited to join.

Outer Wonders #

Outer Wonders by the Utopixel Studio is a pixelart puzzle-based adventure game built using SDL2.

Explore a world of fantasy in Outer Wonders. Play as Bibi, the cute round monkey, unveil the natural wonders surrounding your native village, and unravel their mysteries in this ecological puzzle-based adventure game.

March was mostly about various preparations for the upcoming playable demo release. Some of the recent updates:

• More lively in-game environments.
• Scripted cutscenes.
• Translations.
• Linux support progress.
• Lot's of level and technical testing.
• The playable demo will be released on April 16.

You can read the full March devlogs here.

Aladin Lite #

Mars heightmap with a RdBu colormap rendered with Aladin Lite v3

Aladin Lite is a spatial image survey visualizer developed by the Astronomical Observatory of Strasbourg in France. Since its first release in 2013, Aladin Lite has been used by astronomers as well as amateurs that are curious about exploring the sky.

Originally developed using 2D Javascript canvas, its core has been fully rewritten in Rust and WebGL2 using wasm-bindgen. New features include:

• The support of multiple allsky projections (mercator, aitoff, ...).
• The blending of multiple surveys.
• The support of FITS file images.

For more information, see a talk done at the ADASS 2020 conference. A web page is also available here for you to test. You are also very welcolme to contribute to the project by e.g. posting issues on the project's github.

Portal Explorer #

"Portal in portal" scene

Portal Explorer by @optozorax is a web visualizator of mind-blowing portals.

In Portal Explorer you can view how interesting portals are constructed, and visually explore their properties by moving and rotating them. This program doesn't work well on mobile, better opened from PC. The most interesting scene is portal in portal.

Created using ray-tracing in shaders, engine is macroquad, interface is egui.

Name Needed #

Agents wandering around, hauling items and digging blocks

Name Needed by @DomWilliams0 is a one man effort to produce an open source, intuitive and high performance Dwarf Fortress-esque game.

The engine is custom, built with SDL2 and OpenGL. It's still early days, but steady progress has been made over the last 18 months. The developer aims to release occasional technical devlogs about interesting parts of the engine, which so far include:

• Long term vision and goals
• High level engine architecture
• Intelligent entity behaviors

Orbital Decay #

Orbital Decay gameplay

Orbital Decay by @stevebob is an open-source turn-based tactical roguelike with a focus on ranged combat. Deal enough damage to enemies to get through their armour without breaching the hull of the station, or risk being pulled into the void. It was made for the 7 Day Roguelike 2021 game jam.

Traverse a procedurally-generated space station to reach the fuel bay on the 5th floor. Choose your weapons and upgrades wisely to make it past the station's former crew - now a horde of ravenous undead.

Read more about Orbital Decay on its development blog.

Disguiser #

Disguiser (itch.io, source code) by @mcneja is a coffee-break turn-based stealth game inspired by Thief that was made for the 7 Day Roguelike 2021 game jam. The randomly-generated mansions are loosely based on Chinese courtyard houses, with symmetry, enclosed gardens, and a public-to-private gradient from the entrance northward.

The development process is documented in a bunch of devlog posts.

Discussions: /r/rust_gamedev

secbot #

secbot (web version, souce code) by Herbert Wolverson is another 7DRL submission:

The idea behind SecBot is that an outpost has ceased communications, so the morally dubious Bracket Corporation dispatch a security bot to find out what happened. Upon arrival, it becomes clear that things aren't going well for the colony - so the player rushes around collecting colonists and shepherding them back to the spaceship. I tried to bake some narrative/flavor into the game, and create a fun game you can enjoy over a coffee-break.

Btw, Herbert is going to give a "Learning Rust With Game Development" talk at Rust Meetup Linz on April 22.

Bounty Bros. #

Click the image to play the game in your browser!

Bounty Bros. is a prototype game similar to the old Legend of Zelda® games developed by Katharos Technology as a testing ground for a future commercial game.

In the last 2 months Bounty Bros. has gotten a lot of updates. Now you can play the game right inside of your browser on desktop or mobile devices!

• You can no longer walk through walls or objects.
• You can now walk into buildings.
• The camera follows the player without passing beyond the map borders.
• Rendering is now scaled pixel-perfect.
• Mobile touch controls were added.
• There is a new retro mode that tries to make it look like the game is running on an old CRT television.

All of the source code, excluding assets and artwork, was also made available and split into two independent projects.

These projects were released under the Katharos License. This license has moral and ethical implications that you may or may not agree with, so please read it before making use of these projects:

• Bevy Retro (forum) - a Bevy plugin for pixel-perfect games.
• Skip'n Go (forum) - a simple game engine for making top-down pixel games.

You can read the full update in the Blog Post.

pGLOWrpg #

pGLOWrpg (Twitter) by @Roal_Yr is a Procedurally Generated Living Open World RPG, a long-term project in development, which aims to be a narrative text-based game with maximum portability and accessibility.

Recent updates include:

• Reformatting a print interface, making it very easy to link text UI and code.
• Switching to .ron file format for storing configs and strings.
• Implementing individual strings coloring for better visual perception.

rusty-bomber #

rusty-bomber (source code) by @rgripper and @Cupnfish is a BomberMan clone written using Bevy & Rapier that works on desktop and web.

Check out the devlog for more details about the project's internals.

Stellary 2 #

▶️ Click to watch the full video

Stellary 2 by @CoffeJunkStudio is a 3D real-time space shooter in which the player has to control his spaceship to colonize each planet in the solar system.

In the last month, the game concept has been overhauled. Most importantly:

• Planets become inhabitable over time, starting with the outermost one in order to bring head-to-head matches to an end eventually.
• Full focus on multiplayer, including AIs.
• Players can’t die mid-game anymore. When defeated, they re-spawn and lose a colony for it (if they have one) instead of dying. This prevents long waiting times when playing against friends.

You can follow the development of Stellary 2 on Twitter.

A/B Street #

A/B Street by @dabreegster is a traffic simulation game exploring how small changes to roads affect cyclists, transit users, pedestrians, and drivers, with support for any city with OpenStreetMap coverage.

In March, elevation data courtesy of Eldan was imported, letting cycling speeds uphill be adjusted. Importing any area from OpenStreetMap can now be done from the UI with no command-line experience, and custom travel demand models based on UK-wide census data can now be generated. Some important simulation fixes for roundabouts improve gridlock, and Michael and Yuwen helped adjust the UI panel layout for smaller screens.

Egregoria #

Egregoria (GitHub, Discord) by @Uriopass is a simulation oriented city builder that tries to replicate modern society as well as possible.

The 8th devlog was published. Updates include:

• Multiplayer based on deterministic lockstep
• Economy revamp inspired by Anno 1800
• Infinite world using procedural generation
• Many more QoL features

See also the YouTube summary video of the past 6 months of development.

Gargoyle's Quest #

Gargoyle's Quest by @ShamylZakariya is an implementation of level one of the 1990 Gameboy platformer built using wgpu.

Fishgame #

Game footage with the new weapon.

Fishgame (web build) is an online multiplayer game, created in a collaboration between Nakama, an open-source scalable game server, and the Macroquad game engine.

This month:

• fishgame migrated to nakama-rs (featured in this newsletter as well).
• Also a second weapon, the sword, was added to the game.

Veloren #

Waiting for the airship to land

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

In March, Veloren released 0.9. Lots of work throughout the month was put towards preparing for this. NPC merchants and trading was merged. Many changes were made to combat, including buffs and combat. Player-to-player trading was also implemented. Lots of work was done in optimizing Veloren. This included significantly improving how long physics was talking, and network improvements. Metrics tracking was also overhauled to better track the different systems in Veloren. Pathfinding is also working through an overhaul. A large feature implemented in March was Airships being merged into the game. This prompted a redo of how physics in the game is handled.

A survey was sent out in preparation for the release. A lot of information was gathered about how players experience Veloren, and the items they like or don't like. These can all be ready in devblog #112. This was followed up by the 0.9 release, which turned out to be the largest yet. At peak, 133 players joined the main server. There were problems throughout the release party relating to networking, as well as our tick performance.

March's full weekly devlogs: "This Week In Veloren...": #109, #110, #111, #112. #113.

Theta Wave #

Enemies can now be easily spawned in formations

Theta Wave is an open-source space shooter game by developers @micah_tigley and @carlosupina. It is one of the showcase games for the Amethyst Engine. In the past month, the "Foundations" update was released which included numerous refactors that improved the accessibility of contributing to the game.

They are now working on the "Formations" update which will organize how waves of enemies are spawned into the game.

Notable changes:

• Formations can be defined in a data file
• New InvasionFormation phase where formations of enemies are spawned from a pool of formations

Harvest Hero #

Harvest Hero (Discord, Twitter) by @bombfuse is an arcade/roguelite where you whack Groobles. Built on top of Emerald.

Harvest Hero has undergone a large change, migrating from semi-randomly generated levels to handcrafted levels that are randomly selected throughout your playthrough.

This means using Ogmo to design levels, and using nano-ogmo to import them.

Updates:

• General UI update
• Importing ogmo levels via nano-ogmo
• April Fools demo

Station Iapetus #

Click on the iamge to see the gameplay video on YouTube

Station Iapetus by @mrDIMAS is a 3rd person shooter on the prison Iapetus near the Saturn. This month's updates include:

• Inventory fixes and improvements
• Splash damage for grenades
• Weapon recoil
• More items
• Bots now hear player
• More assets
• First level improvements
• Procedural animation of impact for bots
• More sounds
• Separate scene for menu with music
• Pause game when in menu
• More switches in options menu
• Turrets

Way of Rhea #

Way of Rhea is a picturesque puzzle platformer—without the platforming. Solve mind bending color puzzles, unlock new areas of a vibrant hub world, and talk to NPCs to unravel the mysteries of a world you left behind!

Way of Rhea is being produced by @masonremaley. Latest Way of Rhea developments:

• A free demo was distributed as part of Indie Maker Syndicate's online event
• The demo included a number of minor visual improvements aimed at better communicating the game's mechanics
• Progress is being made adding new artwork to the game
• Tools for laying out artwork in game were improved
• A crash reporter was implemented to give players the option to report issues directly to Way of Rhea's Discord. A writeup will be posted explaining how it works soon!
• Work has begun on a dialog system for chatting w/ NPCs!

Engine Updates #

Tetra #

Tetra is a simple 2D game framework, inspired by XNA, Love2D, and Raylib. This month, versions 0.6.1 and 0.6.2 were released, featuring:

• Support for blend modes and premultiplied alpha
• Scissor rectangles (useful for UI rendering)
• Word wrapping for text
• More events and methods for tracking/controlling the window's state
• Bugfixes and docs improvements

For more details, see the changelog.

Additionally, a template repository has been created, demonstrating some useful patterns for structuring a Tetra project.

Starframe #

Starframe by @molentum is a work-in-progress game engine for physics-y sidescrolling 2D games.

This month, its physics engine was revamped once more (for the last time, hopefully), implementing a modern solver method called Extended Position-Based Dynamics. Also, a blog post was published, covering the development of the physics engine so far in a great deal of mathematical detail.

Emerald #

Emerald by @bombfuse is a 2D game engine focused on being as portable as possible.

The ultimate goal of Emerald is to be a fully featured engine that you can slap onto any device with relative ease. It's currently able to run on WASM, Raspberry Pi, Mac, Windows, and Linux thanks to miniquad.

Features include physics via rapier2d, ECS via hecs, and font rendering via fontdue.

Recent updates:

• Rendering to textures was added (example).
• WASM game sample.

rg3d #

rg3d (Discord, Twitter) is a game engine that aims to be easy to use and provide a large set of out-of-box features. Some of the recent engine updates:

• Context menus and tooltips (huge thanks to MinusGix).
• Performance improvements for UI.
• Parallax Mapping.
• Ability to enable/disable scenes.
• Expansion strategies for TreeView.
• LOD system fixes.
• Graphical fixes.
• First version of engine's architecture overview.
• Various bug fixes and small improvements.

Editor updates:

• Ability to edit collision groups and mask for colliders.
• Ability to clear command stack.
• Ability to change render path for meshes.
• LOD editor.
• "Collapse All", "Expand All", "Locate Selection" buttons for world outliner.
• "Fit Collider" feature fixes.
• Picking fixes.
• Change selection when paste from clipboard.
• "Slow" and "Fast" camera movement modifiers.
• Navmesh selection fixes.
• Simple TBN visualizer.
• Parallax mapping switch in settings.

Oxygengine v0.16.0 #

Integration of RAUI (UI/UX) crate with Oxygengine game engine

Oxygengine by @PsichiX is the hottest HTML5 + WASM game engine for games written in Rust with web-sys. The goal of this project is to combine professional game development tools under one highly modular toolset.

• Version 0.16.0 was focused on integration of RAUI crate into the engine to allow building rich UI/UX experience for your games using declarative mode UI composition (which now makes currently used simple UI Elements feature deprecated and it's gonna be removed at some point in the near future).
• In addition to that basic web game demo and pokemon-like RPG demo were enhanced with new UI showing how to build UI/UX with RAUI.
• Next months will be focused on making RPG showing full potential of what you can do with RAUI in Oxygengine, as well as remaking Visual Novel module to be entirely based on RAUI in a way similar to how RenPy is made!

Bevy v0.5 #

Material grid with varying PBR properties

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

Bevy 0.5 was a massive community effort. You can check out the full release blog post here, but here are some highlights:

• Physically Based Rendering (PBR).
• GLTF Improvements, such as support for PBR textures and a new top-level GLTF asset type.
• Bevy ECS V2: a complete rewrite of the Bevy ECS core with a hybrid component storage model, Archetype Graphs, stateful queries, and across-the-board performance improvements.
• A brand new Parallel System Executor packed with features: explicit system dependencies, system labels, system sets, improved run criteria, and increased parallelism.
• Reliable change detection: efficiently query changes to any component or resource at any point in time (even across frames).
• State System Rewrite: a new stack-based state system that makes running systems for different states (ex: menus vs in-game) much easier.
• Rich text: style text "spans" with different colors / fonts while still respecting layout.
• HIDPI text: render crisp text at any resolution.
• 2D world space text, world to screen space conversions, 2d/3d orthographic camera improvements, render layers, sprite flipping, improved color space handling, wireframes, timer improvements, and more!

Discussions: /r/rust, Hacker News, Twitter

Learning Material Updates #

Robo Instructus Is a Coding Game Built Entirely in Rust #

This month Tammy Xu published an article about Alex Butler's two-year journey of creating Robo Instructus. The article touches lots of topics like: why a custom game engine in Rust was choosen, design of the custom scripting language, and game design of programming puzzles.

Bevy Cheatbook: Major Overhaul for Bevy 0.5 #

The Unofficial Bevy Cheatbook by @jamadazi is a practical reference book for the Bevy Game Engine. It teaches programming patterns, features, and solutions to common problems. Written to be concise and easy to learn from.

The book recently got a major overhaul for the big new Bevy 0.5 release. Many pages were expanded or rewritten, new content added, and community feedback addressed.

If you are interested in Bevy, this book is now one of the most detailed learning resources. Have fun making cool things with Bevy!

Bevy Game Template #

Bevy game template by @nikl_me is a template repository for a Bevy game.

The goal is to present a possible structure for Bevy games and at the same time reduce the amount of copy paste when starting a new project. The repository includes a GitHub workflow for Linux, MacOS, and Windows builds (WASM will be supported soon) and comes with a small, opinionated example game.

Reverse-Engineering NES Tetris to Add Hard Drop #

NES Tetris with Hard Drop and Ghost Piece

A blog post describing the process of reverse-engineering the rendering and input-handling logic in the NES version of Tetris, and using a rust embedded domain-specific language to make a patching tool that generates code (6502 machine code) to add hard drop (instantly dropping the current piece) and to render a ghost piece (the dotted outline showing where the current piece will land).

The patching tool uses the crate mos6502_assembler to specify 6502 assembly in rust and generate machine code. Many of the reverse-engineering experiments were done using this rust NES emulator. The result is available as an IPS Patch.

Discussions: Hacker News, /r/rust

Tutorial: Writing a tiny Entity Component System in Rust #

@kettlecorn wrote a beginner-friendly tutorial that dives into the inner workings of the Entity-Component-System pattern. The tutorial walks through a minimalist ECS implementation to illustrate how the pattern works, and why it's useful.

Discussion: /r/rust

Writing a 3D Shooter Using rg3d #

@mrDIMAS started a tutorial series about making a 3D shooter using the rg3d game engine. So far three parts were released:

• "Character Controller" - engine & editor basics, simple character controller.
• "Weapons" - player weapon with recoil and simple impact effect.
• "Bots, AI" - bots, actor animations, and a simple AI.

Using Tests to Speed Up Your Feedback Loop #

@philipk shared a blog post about using tests not only for verifying correctness, but also for faster feedback loops in some circumstances. RobotCards - a WIP game that uses the Legion ECS - is used as a practical example.

Discussions: /r/rust_gamedev

Library & Tooling Updates #

genesis #

genesis by @StygianLightning is a library for generating statically-typed ECS worlds by using a procedural macro.

Unlike other ECS libraries and frameworks, which do dynamic borrow-checking at runtime, you define all your components upfront and generate a completely statically typed ECS, with borrow checking done at compile time. Gone are the days of passing a World between functions, only to encounter a dynamic borrow checking problem!

genesis is a lightweight ECS library that doesn't provide any scheduling capabilities. Instead, you can query the storage for each component type directly.

Shipyard v0.5 #

Shipyard by @leudz is an ECS library built on top of sparse sets and focused on usability and speed.

Main changes of the latest version:

• The system! macro, packs, and Shiperator trait were removed.
• Bulk add entity - faster way than adding entities one by one.
• Accurate modification tracking by default.
• No more try_* - now all functions that can fail because of storage access return a Result while almost all others panic.
• More flexible workload building and debugging.
• Customizable views and storages.
• Significant performance improvements.

Planck ECS #

Planck ECS (GitHub, Blog, Patreon) by @jojolepro is a brand new minimalist and safe ECS library.

The 1.0 release happened in the past month, featuring: various fixes, quality of life improvements, removal of unsafe code and completion of tests and documentation.

The library is currently considered completed, which means that all planned features are implemented, tested and benchmarked. Future updates will focus on performance improvements and usability improvements.

Planck ECS is also used in Shotcaller which is featured in this newsletter too.

You can read more about the library on the Blog and on GitHub.

Discussions: /r/rust

hecs v0.5 #

hecs is a fast, lightweight, and unopinionated archetypal ECS library.

Version 0.5 introduces a column-major serialization mode. This imitates the in-memory data layout, enabling higher performance than the already-fast row-major serialization mode. Because columnar layout places similar data nearby, it also improves the effectiveness of compression.

Other changes include major optimizations to spawning entities and adding/removing components, inspired by the archetype graph model recently adopted by bevy.

rkyv v0.5 #

rkyv is a zero-copy deserialization framework for Rust. It's similar to FlatBuffers and Cap'n Proto and can be used for data storage and messaging.

A benchmark was put together to compare rkyv against other leading serialization solutions and gather feedback and use cases for development. A summary and analysis of the results is also available.

Version 0.5 is hot off the presses and rolls up features from the 0.4 development cycle:

• Derive macros can now implement PartialEq and PartialOrd between archived and unarchived types.
• Custom type bounds for serialization and deserialization can be added with derive attributes.
• Helper types like AlignedVec and Infallible were introduced to improve ergonomics.
• const_generics are now enabled by default.
• Helper functions have been added to make getting root objects easier.
• Several bugfixes and performance improvements.

A feedback issue is still open for providing feedback on further development.

gba v0.4 #

gba is a crate for making GBA games with Rust. This month it was updated to 0.4! It's using the new thumbv4-none-eabi target, and has an overall simpler build process than before.

The project is still a work in progress, but if you've wanted to try an embedded experience this is an easy way to test the waters. No hardware required! Compiled binaries can be run in a GBA emulator just fine.

kira #

kira by @tesselode is a game audio library tailored to composers and other people who need expressive audio.

v0.5.0 was released with mixer send tracks, new effects, and playback position tracking for instances, as well as a variety of smaller improvements.

Discussions: /r/rust, Twitter

Quinn v0.7 #

Quinn is an async-friendly implementation of the state-of-the-art QUIC transport protocol soon to be standardized by the IETF.

QUIC is a uniquely versatile foundation for building application protocols. Its support for low-latency communication, multiplexing, fine-grained reliability, and security make an excellent basis for real-time game networking, providing an array of powerful primitives unavailable on UDP or TCP.

Quinn 0.7 introduces support for Tokio 1.0 and many optimizations and bug fixes, and updates to draft 32 of the proposed standard. With last call underway in the IETF, the devs expect to release an implementation of the final standard soon with no major changes.

nakama-rs #

nakama-rs is a pure Rust implementation of the Nakama protocol.

Nakama is an open-source server designed to power modern games and apps. Features include user accounts, chat, social, matchmaker, realtime multiplayer, and much more.

Being pure Rust, nakama-rs brings the full API and socket options to any platform Rust works on.

smaa-rs #

The smaa-rs library provides fast and high quality post-process anti-aliaising using the SMAA algorithm. It is designed to be easy to integrate into other wgpu applications with only a few added lines of code.

The 0.2 series released this month includes a steamlined API which makes it easier to enable/disable anti-aliasing via a configuration setting. Currently SMAA 1x is supported with SMAA S2x likely to be added depending on interest.

wgpu #

Voxel Bunny rendering with conservative rasterization

wgpu is a WebGPU implementation in Rust. It is safe, efficient, and portable: can target both native (Vulkan/D3D/Metal) and the Web.

Most progress in March was focused around WGSL shaders and validation. naga has seen a lot of improvements in the SPIR-V and WGSL parsing, as well as backend code generation. Most importantly, it now fully validates both statements and expressions. No more accidental foot shots from adding vec2 and vec3 in the shaders!

The last and the biggest (in terms of shader complexity) example - "water" has been successfully ported to WGSL 🎉.

A small addition to our native-only features - conservative rasterization feature - was added by @wumpf and demonstrated on a voxel bunny 🐇

Finally, there is a blog post on Mozilla graphics team blog about the progress using wgpu in Gecko.

Discussions: /r/rust_gamedev

rust-gpu v0.3 #

The Khronos Sci-Fi helmet model in a glTF model viewer created by @msiglreith using rust-gpu

rust-gpu is a new codegen backend by Embark Studios for Rust, aimed at making Rust a first class language for writing GPU shaders! This past month was the release of rust-gpu v0.3. Some of the highlights:

• A lot of technical debt that was visible to users (such as #[allow(unused_attributes)]) was removed.
• rust-gpu now also supports basic ADT enums and has a whole inference pass for storage class variables.
• All Embark's shaders for their internal engine are now written in Rust - no more GLSL/HLSL, just Rust for all CPU & GPU code!

Full release notes are available here.

For more information on how to get started with using rust-gpu in your projects, check out the Rust-GPU Dev Guide.

Discussions: /r/rust

rafx #

Rafx rendering an example tilemap from LDTK level editor

Rafx is a multi-backend renderer that optionally integrates with the distill asset pipeline. This month, a fourth layer was introduced to the library, rafx-renderer. It provides a plugin system, simplifying framework setup in a project.

The demo now includes a tilemap renderer that integrates with the LDTK level editor. The distill integration processes the level files offline for very efficient loading/rendering at runtime.

Sprite rendering in general is also much faster now. Scenes with 40k-100k sprites can render at 60fps (measured on M1 mini) depending on transparency/distinct Z values in the scene. New examples demonstrate tilemap and sprite rendering.

Early work was also done to reuse descriptor sets across frames and reduce dynamic memory allocation when working with descriptor sets. Rafx also includes more options for HDR tonemapping.

FemtoVG #

FemtoVG is a 2D canvas like vector graphics library based on nanovg that has been previously featured in this newsletter.

This month, the FemtoVG team has implemented a new rendering backend based on the wgpu library. This work is being done in this fork of FemtoVG and will be merged into the main repo soon. The team is currently looking for users to try out the new backend and provide feedback.

Join the FemtoVG Discord channel.

Kajiya #

Kajiya by @h3r2tic is a real-time global illumination renderer.

It utilizes Vulkan Ray Tracing via ash and hassle-rs to implement multi-bounce light transport in fully dynamic scenes. By shooting only two rays per pixel on average, it keeps performance high; thanks to a voxel-based light cache and extensive spatio-temporal filtering, it keeps noise low. It supports physically-based rendering of GLTF scenes, and achieves a close match to reference path-tracing.

Kajiya is still in its infancy, and not yet available to the public, but you can get glimpses of its development by following the author on Twitter.

Bevy Retro #

Pixel-perfect collision example

Bevy Retro is a new Bevy plugin designed for making pixel-perfect games.

This project was released under the Katharos License. This license has moral and ethical implications that you may or may not agree with, so please read it before making use of this project.

Bevy Retro features:

• Web and desktop support out of the box - it even runs in Safari on iOS!
• Integer pixel coordinates - no need to round floats to keep pixels aligned!
• Support for sprites, sprite sheets and animations.
• A super simple hierarchy system.
• A custom, scaled, pixel-perfect renderer with three camera modes: fixed width, fixed height, and letter-boxed.
• An LDtk map loading plugin.
• Pixel-perfect collision detection.
• Support for post-processing effects using custom shaders or the built-in CRT filter.
• Support for custom pixel aspect ratios.

Feel free to discuss the project and provide feedback on GitHub.

RAUI v0.28.1 #

RAUI + Tetra TODO app demo

RAUI by @PsichiX is a Renderer Agnostic User Interface crate that is based on declarative mode UI composition similar to React.js and UE4 Slate system.

This month's updates:

• Advanced navigation system mainly for the use in Oxygengine game engine.
• Tesselation renderer module to allow buildings Vertex + Index + Batch buffers for backends that allows to render meshes.
• Tetra integration crate that allows use of RAUI with Tetra game framework.
• Porting demos to Tetra which became one of two mainly supported backends for RAUI.

egui-macroquad #

Code example of usage of this library.

egui-macroquad is a small library to use egui inside of macroquad. It consists only of two functions.

Used in Portal Explorer, see the section above.

building-blocks v0.6.0 #

In v0.6.0, the building-blocks voxel library brings a couple important features for scaling up to large maps:

• pyramids for level of detail
• multichannel arrays

There is still much work to be done to optimize the voxel mesh LOD at large scales and improve the cosmetics of LOD transitions, but the preliminary work has allowed us to demonstrate the feasibility of this approach with a new demo that you can view here.

Full release notes are available on here.

Discussions: /r/rust

WhatTheFrame #

WhatTheFrame by @JMS55 is a frame-based cpu profiler crate along with a GTK (gtk4-rs) based GUI.

This project aims to answer the question: Which frames of my game are slow, and why?

It aims to be simple to use, consisting of only 3 functions: Call let _r = Profiler::new_frame() at the start of each frame, let _r = Profiler::new_task("task_name") whenever you want to profile a task, and finally Profiler::end_profiling() once at the end.

You can then open the resulting .wtf profile in the GUI and analyze the results.

This month was spent designing and implementing both the GUI and profiler crate. The core functionality of both programs are complete, and all that remains is cleanup, tweaks, optimization, and finally packaging the GUI up.

Bitmapflow #

Bitmapflow interpolating a walking mech animation

Bitmapflow (GitHub) by @bauxitedev is a tool to help you generate inbetweens for animated sprites. In other words, it makes your animations smoother. It uses optical flow to try to guess how the pixels move between frames, and blends them accordingly. The results are far from perfect, and probably require some editing by hand afterwards, but it can produce decent results.

It supports loading and saving animated gifs, spritesheets and individual frames.

The tool is written using godot-rust and executables are available for Windows, although Linux support will be coming soon. (If you compile the program from source, it already works on Linux.)

A full demonstration and walkthrough of the program is available on YouTube.

You can try it out yourself on itch.io.

Discussions: /r/rust_gamedev

Graphite #

"Graphite" drawn using the circles and rectangles of the new tool drawing system

Graphite (GitHub, Discord, Twitter) is an in-progress vector and raster graphics editor built on a nondestructive node-based workflow.

The team has grown from 1 to 5 in the past month and major progress was made building core architectural Rust code. A large accomplishment was designing the software architecture diagram.

The current editor now has functional Select, Rectangle, and Ellipse tools thanks to the newly-added tool state machine and SVG viewport drawing. The UI now also implements tool-related icons and buttons, bringing it closer to parity with the design mockup. The team also set up a Web/Rust-WASM build system, GitHub CI to confirm PRs compile, and put together starter documentation for the codebase, UX design, and manual.

Graphite is making rapid progress towards becoming a nondestructive, procedural graphics editor suitable of replacing traditional 2D DCC applications. Please join the Discord - and consider asking for a tour of the code and how you can help!

Requests for Contribution #

• femtovg is looking for help with the wgpu backend.
• Embark's open issues (embark.rs).
• gfx-rs's "contributor-friendly" issues.
• wgpu's "help wanted" issues.
• luminance's "low hanging fruit" issues.
• ggez's "good first issue" issues.
• Veloren's "beginner" issues.
• Amethyst's "good first issue" issues.
• A/B Street's "good first issue" issues.
• Mun's "good first issue" issues.
• SIMple Mechanic's good first issues.
• Bevy's "good first issue" issues.

---

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!

Discuss this post on: /r/rust, Twitter, Discord.