Welcome to the eleventh 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!
Table of contents:
- Legion Game Jam
- Game Updates
- Learning Material Updates
- Library & Tooling Updates
- Popular Workgroup Issues in Github
- Meeting Minutes
- Requests for Contribution
- Open-source & Rust only.
- Projects should use some ECS library (you can choose Legion if you don't have one).
- Team working and recycling old assets are allowed.
Submissions open to August 1st 2020.
It can be RPG, strategic, arcade or else; multi or solo. What you want. Just try to include a little bit of history and culture taste. Don't be afraid, it is not ranked.
Also, participants are encouraged to document the development process at the event's forum.
^ Click to see the latest version of the game's trailer
Way of Rhea (steam) is an upcoming puzzle platformer that takes place in a world where you can only interact with objects that match your current color. It's being built in a custom engine, and custom scripting language both written in Rust by Mason Remaley. This month's updates:
- A demo was released as part of the Steam Game Festival! The festival has since ended, so the demo is no longer available.
- @masonremaley ran An AMA at /r/rust_gamedev and /r/IndieDev about the development of the game.
- The studio hosted a speedrun competition as part of the Steam festival, here's the winning run.
- A colorblind friendly mode was added to the game, and a couple other changes were made in response to feedback from the festival.
A/B Street - Adjust Traffic Patterns in Real Cities
^ Measuring the effects of some changes
A/B Street is a traffic simulation game exploring how small changes to roads affect cyclists, transit users, pedestrians, and drivers.
- Alpha release with a trailer, an excited reaction from r/seattle, and some local press coverage
- Support for parking lots, automatically inferring the number and position of individual slots from OpenStreetMap geometry
- Names of roads shown in-game, in a way that doesn't cause clutter with agents moving nearby
- Work starting on light rail and restricting through-traffic to zones
^ In-game visual scripting prototype
A summary of recent changes:
- Visuals: added two new artist-painted levels: Space and Dinosaurs.
- Gameplay: AI can now play all game modes, added Quick Game option,
- In-game visual scripting prototype.
- Physics tweaks and improved terrain normal sampling
- Multiplayer: added in-game chat, private matches with secret links, improved game setup UI. Numerous bugfixes and tweaks
- Playable Browser build.
Garden: June Devlog
- Soil collision detection & changes to the soil column generation.
- Plant sim & terrain updates happen at different times & separately.
- Proper Global Illumination research.
- Automatic in-game texture reloading.
^ Animation improvements
Veloren is an open world, open-source voxel RPG inspired by Dwarf Fortress and Cube World.
In June, Veloren did a big interview with GamingOnLinux, be sure to check it out! Veloren's lead artist also started a weekly blog about his work on Veloren, which you can see here. Veloren recently reached the first page of most starred projects on Gitlab! The Veloren Youtube channel also reached 1000 subscribers.
A lot has been done over the last month towards 0.7, which is slated to release at the beginning of August. Lots of work has been done improving UI and animations. These will help towards the goal of 0.7 being the "progression" update. Many improvements have been made to the continuous integration system to make it more reliable and faster. Mac support was added to Airshipper, the Veloren launcher. Significant work was done on the world simulation front. This includes economic simulations that will represent trade and resource pricing in settlements and cities. Castle generation is also now in the works.
Test coverage and documentation has started to improve, and a workflow around it is being developed. The project is now hosting a proper documentation site that is updated with each merge. A #ux working group was created to facilitate discussions on improvements to player interactions in Veloren. Lots of translations were merged, including Swedish, Polish, and Brazilian Portugese. The skill system is moving on to implementation, being a coordinated effort between the game design, art, and combat working groups.
You can read more about some specific topics from June:
- Mod Analysis
- Improving CI
- Economic Research
- Compilation Improvements
- Improving Test Coverage
- Skill System Work
- Animation updates
In July, work will be done to complete the progression systems. There will be financial meetings held to discuss how funds from the project's Open Collective will be distributed.
Also, check out a talk about open source and Veloren:
^ The initial destruction prototype applied across different thrust levels
Zero to Game is a project that documents the creation of an independent space game from zero.
My plan for this website is to narrate my independent development of a computer game in the Rust programming language. I've never done this before, and so I hope to be able to show you the progression right from zero all the way up to a game.
- Zero game programming experience.
- Zero experience in the Rust programming language.
- Zero experience making assets, images, sounds, models, etcetera.
Currently published posts:
- #1 "Finding Zero" - where the game development journey is beginning.
- #2 "Inspiring Design" - how Factorio, Screeps, and Space Station 13 are inspiring the game's design.
- #3 "Picking Technology" - researching a technology path for the game project to start out on.
- #4 "Leading Design Challenges" - the spacetime issues with combining gameplay inside and outside of spaceships.
- #5 "Fast Spaceship Physics" - prototyping a spaceship physics simulation aimed at speed.
- #6 "Physical Destruction" - the structure and implementation of a spaceship destruction prototype.
- #7 "Rendering in Rust" - working through from tutorial code to meet the needs of the game's first Rust scene render.
It can be played online here!
Scale's objective is to become a granular society simulation, filled with fully autonomous agents interacting with their world in real time.
runner is a simple side-scrolling endless runner game that takes place in a bright world that only has our fearless adventurer & a few pesky beings that are bent on keeping her from running! It uses specs for ECS and has multiple frontends: sdl2 & quicksilver. Between the two frontends it can target the majority of the platforms: Web, Mac, Linux, Windows (untested) & possible even iOS & Android.
^ Part of the game map
To win the game, one player must successfully move any animal into the Den(兽穴) of the opponent or eat all animals of the opponent. The basic move is just one space either forward, backward, left, or right. The pieces never move diagonally. Each player has eight pieces, different animals with different degrees of power, a larger power piece can eat a little power piece, but rat can eat elephant. Here's a picture of the pieces, their English names, and relative powers indicated by a number. See full rules at ancientchess.com or Wikipedia.
The project uses alpha beta pruning algorithm for AI and provides a python module to use AlphaZero algorithm for training.
Guacamole Runner is a small game made with Tetra and Shipyard in approximately 2 days by @EllenNyan. The game's concept is that the player is constantly falling and must jump off planes to stay in the air. When they go over the top of the dirt tiles they plant flowers which gives them points.
Wooting Snake is a snake game where the visuals are represented on your keyboard lights, instead of a computer screen.
Anthony Brigante started working on a 2D sandbox game. Two devlogs were released this month:
^ Click to see a demo video
Weegames is a fast-paced minigame collection. There are 23 odd games all made using free images and sounds. The more minigames you beat the faster they get.
blub is a WIP 3D fluid simulation playground build with wgpu-rs and imgui-rs. It focuses primarily on hybrid approaches lagrangian/eularian approaches (PIC/FLIP/APIC..). Check the project's README for more details.
Learning Material Updates
^ Click to watch the video demo
@twitu has published a three-part blog series about simulating a group of virtual agents (boids) that will swim around an enclosed space behaving like a school of fish.
This is a beautiful application of procedural graphics generation, where simple rules create complex patterns. It's almost entirely inspired by Sebastian Lague's Coding Adventure with boids.
- A fistful of boids - Setting up the scene and basic animation
- For a few boids more - Generating boids and obstacle avoidance
- The school, the boid and the Rusty - Simulating a flock, parallelism and benchmarking performance
This could be helpful for someone new to rust and trying to get into game development and looking for the right libraries to use.
Library & Tooling Updates
Just what everyone's always wanted, Rust on the Sony PSP! 😆
This project is a port and improvement of the unofficial C/C++ PSPSDK from 2005 It does not require a custom GCC toolchain to be installed. Only Rust nightly and a cargo subcommand.
The psp crate provides a
psp::sys submodule that houses the entire Sony PSP
API. The authors are working to have these interfaces merged into the libc crate.
The PSP, unfortunately, uses non-standard dynamic linking,
(and some libraries are statically linked!), so function definitions
marked extern are not enough. Eventually, this sys lib will be wrapped with a more
Rather than patching LLVM or rustc, the rust-psp team has also merged a
mipsel-sony-psp target upstream, and published cargo-psp. This is a subcommand
that works exactly like cargo build, except it also builds the crate into a
PSP-specific executable format called
PRX and packages that into an
EBOOT.PBP, the standard format for a PSP Homebrew.
The crate has reached full user-mode parity with the unofficial C/C++ SDK.
Kernel-mode support still needs to be worked on. Aside from library
imports, there is also support for PSP-specific custom assembly instructions
vfpu_asm! macro, with no need for a custom compiler toolchain.
There is also optional
embedded-graphics support and a function to benchmark
or time your code.
The next major milestone for rust-psp is std support. If you are interested in helping out, please feel free to join the rust-psp channel in the PSP Homebrew discord server.
glam is a simple and fast linear algebra crate for games and graphics.
This month glam 0.9 was published to crates.io. This update is a breaking change from 0.8.
In 0.9 the
Vec3 type was changed from being a 128 byte SIMD vector type to a
tuple of three floats. This changes the size of
Vec3 from 16 bytes to 12 bytes
and the alignment from 16 bytes to 4 bytes. This might not affect all users but
Vec3 was used in a context where the size or alignment mattered, such as in
FFI or as input to shaders, this could cause breakage.
The SIMD parts of
Vec3 were moved to a new type,
A for Aligned)
which is 16 byte aligned and thus 16 bytes in size. The
Vec3A type is still
there for users who want the performance benefits of the SIMD implementation.
The motivation for this change was that it is potentially surprising and
confusing for new users that the
Vec3 type was not 12 bytes. Also, it's common
that users needed a
Vec3 that was just 12 bytes.
While glam is reasonably stable it has not yet reached a 1.0 release so it seemed like now is the time to address such issues in the API.
^ Mun language server diagnostics in action
Mun is a scripting language for gamedev focused on quick iteration times that is written in Rust.
After the dust of the Mun v0.2 release settled, this month's focus has been on fixing several issues found by community members, improving the overall quality of the code base and working towards the next release: Mun v0.3.
Their June updates include:
- Make It or Break It contest;
- several fixes for issues that arose thanks to the contest;
- the foundation for Mun projects;
- an initial language server setup;
GameLisp (glisp) is a scripting language built for and in Rust and utilizes syntax from the LISP family of programming languages. It provides a fast and efficient garbage collector that runs every frame instead of freezing a thread.
- 256 bit supports
- Almost all the API was reworked for better naming consistency
While the project itself started earlier this year, with this month's release
yaks gained an overhauled API, further leaning into the promise of
- systems are any functions or closures of a specific signature,
Executoris a container for one or more systems,
- system execution order can be defined when building an
Executorto create concurrent chains of systems,
- resources used by systems (any data that is not associated with an entity) are now borrowed for the duration of execution, instead of being owned by the framework.
All items in the library are exhaustively documented, and the repository contains a fully annotated example.
parallel cargo feature can be disabled to force
yaks to become single-threaded, which allows using code
written with the framework on platforms without threading - notably, web.
Also, two new examples came from the awesome macroquad community:
megaui is macroquad's imgui-like UI system. Recently, megaui got decent input widgets: input fields, editboxes, and sliders. All of them support copy-pasting back and forth from the browser. Check out the web demo (source):
nanoserde by @fedor_games is a fork of makepad-tinyserde with syn/quote/proc_macro2 dependencies removed. It attempts to solve a serde's problems of long clean compilation time, increased incremental build time, and build artifacts size. nanoserde may be useful when the whole game has less than a minute clean build time and spending ~40s on serde is unreasonable.
> cargo tree nanoserde v0.1.0 (/../nanoserde) └── nanoserde-derive v0.1.0 (/../nanoserde/derive)
Some benchmarks and tiled map deserializing example could be found here.
- A rework of the text rendering API, which improves performance and fixes a number of long-standing bugs
- Functions for capturing the player's mouse
- Various tweaks and bug fixes under the hood
Also, a new guide has been added to Tetra's website, listing some things to consider when distributing your game to the public. This guide is still a work in progress, so contributions are welcomed!
Project "NodeFX" by Christian Vallentin (@MrVallentin) is an unnamed node-based tool for creating GLSL shaders in real-time, entirely written in Rust.
This month added support for both 2D and 3D SDF nodes. The above screenshot is a meta example of creating a node using some of the 2D SDF primitives and operations. An example of some 3D SDFs can be found on Twitter.
Next month is all about adding more UI, to make the application more user-friendly and fully-fledged. After UI has been added, there is a planned release of the application. More information can be found on Twitter.
Göld is a WIP game engine for hacking together 3D games using old tech. It uses wgpu-rs and is based on the simple mental model of PyGame or Löve, but for Goldsrc/Quake-era tech.
The ultimate goal of the project is to have a simple engine that can do basically everything that many simplistic 3D games will need, without making an attempt at being too general.
- Quake 2 maps loading (although not Quake/Goldsrc maps yet) and rendering with proper BSP culling and frustum culling.
- Loading and rendering of HL1 models.
- Simple dynamic lighting system.
Arsenal is the concept for a 2D and 3D game engine that is fully integrated with Blender and built on a Rust core. The engine will be built around an entity component system ( probably Shipyard ) for its performance and game design advantages. The vision of Arsenal is to build an Open Source game engine that is suitable for games of any scale and that is easily approachable by a wide audience of both complete beginners and seasoned experts.
Arsenal currently has a POC working, but there is no support for adding custom game logic. The next major step for Arsenal is to get initial scripting support in Shipyard. The scripting plan for Arsenal borrows heavily from the Amethyst scripting RFC with the first target scripting language being Python. Other languages that are candidates for being added later are be Mun, Lua, and maybe other languages written in Rust such as Gluon.
More information on the Arsenal development direction can be found in the latest Arsenal development blog post.
Katharos Technology has gone live on GitHub Sponsors as a means to fund development of the development of the Arsenal game engine and supporting Rust gamedev libraries and tools such as GFX, and WGPU.
Vimnail - a Mouseless Image Editor
Vimnail is a WIP mode-based image editor inspired by Vim. The goal of the project is to be able to compose images without using the mouse.
Popular Workgroup Issues in Github
Requests for Contribution
- gl-rs is seeking new maintainers;
- Embark's open issues (embark.rs);
- winit's "Good first issue" and “help wanted” issues;
- 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;
Just an interesting Rust gamedev link from the past. :)
During RustConf 2018, Catherine West gave a keynote talk "Using Rust For Game Development" that introduced a lot of people to the concept of ECS and is now considered a classic. You can watch the recording here (slides).
A few months later an extended text version was released.
That's all news for today, thanks for reading!