If you like creepy weird stuff, you will most likely enjoy my game too!

https://store.steampowered.com/app/5150820/Red_Lake_Demo/

The only person standing between us and a total collapse of Rust Graphics Programming civilization is one guy Gwihlidal, and his glorious gwihlidal/vk-mem-rs: Rust bindings for AMD Vulkan Memory Allocator (VMA)

Should I just write my own bindings for VMA? Or hold my nose and use gpu-allocator, even though I know I will have handle thread locking and aliasing memory for render graph passes myself.

Not to even mention the fact that gpu-allocator doesn't have budget tracking OR public memory suballocation...

The game is called Monster Girl Tactics: Oubliette!
The Steam version is fully SFW, but there is a NSFW version.

You can uncensor the demo with a free patch from Itch.io: https://minolione.itch.io/mgto-demo-uncensor-patch

And you can learn about the game's uncensored version from my showcase website or by reading player reviews

• Zero AI
• Built in Rust, using Bevy!
• A solo project, on a zero-dollar budget, created over 5500 hours of work

I've been using Rust since early 2022, and Bevy since around that same time, then I started full-time work on this game in May 2024. The codebase is ~102k lines of code.

If the game piques your interest, I'd be happy if you gave the free demo a try!

Developing in rust is great. Along the way I created this steam mock library that I announced here a while back: https://github.com/dagit/steamworks-mock

And today I'm announcing that the game I used that to develop is now on steam: https://store.steampowered.com/app/4687280/Supplant/

The basic idea of supplant is that capturing a piece let's you take it over. So a white pawn capturing a black knight becomes a white knight. Demotions happen too the same way. Kings are the only exception. Aside from that it's chess as usual. However, this one change really mixes up tactical reasoning. I think it makes chess feel new and exciting again for veteran players without introducing anything gimmicky or RNG.

I also ended up making my own gui library to do this. I wanted some features winit doesn't support (mainly native popup windows/menus). I hope to release my gui library in the future but it might take me a few months to get there. I need to polish things up a bit before handing it to other people. And finishing the game as a solo dev was a lot more work than I anticipated. So I need a bit of a break.

I paid a friend for the steam page art work. I think he did a great job. All the in game assets are just chess fonts. Because I'm terrible at art lol.

I really enjoyed how easily you can make things into a library with cargo. That allowed me to create bot tournaments and stuff like that during development to help tune game parameters and stuff. Experimentation is easy and clean in rust.

Let me know if you have any questions. I have a few more game ideas in me but not sure how soon I'll start on them. I hope to able to open source at least one library with each game I ship.

bevy-neura is built on Neura, using DX12, Metal, and Vulkan for neural network training and inference, enabling you to build AI-native games in Bevy.

Hope it's ok to post some Claude stuff. Rust is really the core of why this was even possible

You roll dice, pair them into dominoes, and lay them down to score!

Make use of dice items and rolling runes to achieve high scores and crazy combos.

Coded in a custom rust engine

https://store.steampowered.com/app/4999210/Diceminoes?utm_source=rustgamedev

The attached trailer was captured in the native wgpu build. The playable browser version uses three.js rendering over the shared Rust core.

Loot Hole is a digging game with shared Rust gameplay, now playable in the browser: https://playgama.ai/play/kw6t5foxgs

I'm the developer. You dig up buried objects, sell your finds, upgrade your equipment, and reach deeper layers below the yard.

The architecture ended up with Rust owning gameplay and terrain across hosts, wgpu for native rendering, and three.js/DOM for browser presentation. The web calls the shared Rust core through WASM. We also generate the web ABI layout from Rust so the two sides don't hand-maintain buffer offsets.

We originally started in Babylon Lite/WebGPU, then moved to three.js. Building the Rust/wgpu version didn't make startup size and browser support stop mattering, so three.js came back as the web renderer while the Rust core stayed. The browser launch path has a budget below 1,000,000 compressed bytes; the full game is larger.

Other work along the way included shared Slang shader functions for GLSL/SPIR-V, deterministic terrain across native and WASM builds, and four upstream opus-rs fixes from comparing our game effects against libopus. The decoder PRs are open. Example: https://github.com/restsend/opus-rs/pull/58

I'd be interested in other people's experience with this split, particularly keeping the JS/WASM boundary cheap while sharing gameplay with native hosts.

AI disclosure: AI was used for coding, image generation, and translations. Music and sound effects were mostly made without AI.

pardon my aim on controller 😂