🚀 Wings 0.2 is here!
Build Bevy apps with the design language you love: Cupertino, Material, or Fluent UI - powered by a modular Rust framework.
Wings brings together theming, animation, navigation, responsive layouts, and MVVM to help you turn ideas into polished interfaces.
🦀 Built with Rust. Powered by Bevy. Ready for your next idea.
Explore Wings:
https://doublegarts.com/opensource/wingsframework
https://crates.io/crates/bevy_wings
https://github.com/doublegarts/bevy_wings
#Wings #RustLang #Bevy #UI #OpenSource #Cupertino #MaterialDesign #FluentUI

Preprocess one animated Jax model into four meshlet LODs and 30 geometry pages, choose an adapter-scaled population, stream GPU-requested pages, reject hidden work with a two-pass depth pyramid, and submit compacted static and skinned populations through indirect draws.

Nanite-style is deliberate wording. This is not Unreal Engine's Nanite implementation. It uses CPU-generated grid-quantized LODs, fixed-size meshlet pages, a CPU-managed residency cache, ordinary WGSL vertex shaders, and four WebGPU indirect commands. It has no mesh shaders, persistent cluster hierarchy, GPU decompression, disk page store, or production-quality simplifier.

I've posted about this project before. Eldiron is a retro-style CRPG engine that's currently in development. It looks like the engine is to be able to create top-down Ultima-inspired CRPGs, 2.5D isometric CRPGs, and even first-person CRPGs.

The source code is available on Github btw. The engine has been under development for around 5 years now. According to the dev, it's getting closer to v1.0.

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

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

I've been poking at Godot games to see how they solve things (UI, save systems, that sort of thing), and every time it was the same dance: unpack the pck, hit an encrypted file table, give up.

GDRE Tools does the hard part already, decompiling scripts and converting textures, but it needs the 32 byte key pasted by hand, and nothing tells you where that key is. It sits in the game's own executable, so I wrote gore to find it.

gore is a Rust CLI that wraps the whole pipeline:

• finds the pack in a standalone .pck, a self contained exe, or appended to the binary
• if the file table is encrypted, scans the executable for the key and only accepts one that decrypts the table and matches its MD5, so a wrong key never gets reported
• extracts everything and checks the MD5 of every file the pack stores
• runs GDRE Tools on the result, so you end up with project.godot, .gd scripts and converted assets

Formats v0 to v4, so Godot 2.x up to current 4.x. I tested it on four games: SNAPTIC demo (4.7.1, encrypted v4), Lucid Blocks (4.6), Buckshot Roulette (4.1.1, pack inside the exe) and Brotato (3.7, base pack plus a DLC in a second pack). All of them came out with every MD5 matching.

What it doesn't do: APK, and sparse bundle packs, it refuses those with an error. And if the game ships a patched engine you still need that exact editor version to open the project.

https://github.com/figurophobia/gore

If anyone tries it on an older game, a Godot 3 title or a 2.1 one, I'd like to know what the pack header says. Those formats I could only test with packs I generated myself.

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!

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...

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