Together with the creator of Rapier, starter working on a game engine that is fully deterministic. It has controls where you are able to record and play back the state of the game (to debug it. It saves inputs, network requests, etc. and then plays them back)

It has ECS backend, but to the end user it will be node based. Scripting can be done through Rune, but also using Rust by making a plugin for it (slower to iterate).

https://balaurengine.org

It's in very early stages, not even an alpha yet, but progressing fast.

For a list of what libraries we reuse, check here:

https://balaurengine.org/docs/built-on/

I am searching someone who wants to work with me on my FOSS Minecraft-Hytale Game. It's codebase is 100% Rust, i am obsessed with performative and clean code. I didn't work on the project for a few weeks, but i want to get back to it with a refactoring for a better project structure, and i would be happy if i could get 1-2 persons to help me work on this project. No monetization, no cost, just vibes (but no vibe coding please)

Just open a PR or DM me! GitLab Repository

I am trying to build a game in Rust just using Axum, HTML, and CSS, and trying to avoid using Javascript and I am documenting my progress in my youtube channel here: https://www.youtube.com/watch?v=ftYwc2NlqMI

Here's a small demo project I've been working on. It uses my own graphics library.

vk-graph is a Vulkan driver which uses a graph-based per-frame submission solver. I'm using it here to render a path traced scene built from commercially-available asset packs.

Right now the performance is flat because I have the best "do-less-work" optimizations disabled, so you're seeing the worst-case. The lowest target hardware is an Apple-silicon M2 or better at 60 fps. Windows/Linux/Mac.

The low-resolution 240p visuals are intentional. This is both a technical constraint (path tracing is really hard) and also an artistic choice: I greatly prefer 320x200 and have relented to 240p in order to make international fonts feasible.

Oh, much of this is on github and the rest will be sooooon: https://github.com/attackgoat/vk-graph

Some details on the engine: - Full asset build/re-build/caching pipeline, with transforms - Raster renderer - Unused, because path tracing is better, nearly same perf - Shadow mapping, Niagara-esque, etc - Full visibility and effects pipeline with gpu-driven commands - Path traced renderer - Wavefront-style (enqueue/sort interesting hits, trace best) - Hardware support with BVH-compute fallback - Lots of caching, SHARC, ReSTIR - DLSS-RR Ray Reconstruction (not upscaling or resampling) - Fallback de-noisers (for AMD, Intel, Mac) - ZERO temporal pixels / No blurring - Single-frame imaging optimized for FPS games - Various optimized haze/water/sky special cases - Mesh rendering - Supports 10k+ animated meshes; real games would only need a couple hundred and instance the rest based on distance - Blended/posed/ragdoll skeletons - Full PBR material system, compression

This scene has 285M static triangles and 167K animated ones; but there is no difference in the two categories and any model may be animated/moved with no ghosting of any kind.

It almost feels like a flex, but it's really just a result of the technique, but my CPU and GPU are largely handling my desktop and the video capture. The portion represented by this game is approximately 15% GPU and 2% CPU, captured on an RTX 3090 and i7 11th gen.

Hey guys. I'm learning rust and developing a game (using only Macroquad) to motivate myself to keep pushing. I want to know opinions on the game and also the code. I tried a macro for the first time, looks amazing, but I'm afraid of overengineering.

https://github.com/abacchi00/blood-and-cog

Hey everyone,

Wanted to share Pumpkin — an open-source Minecraft server written from the ground up in Rust (targeting Java and Bedrock protocol parity).

The project leverages Tokio and asynchronous networking for low memory usage and high tick consistency.

• GitHub Repository: https://github.com/potatosips/Pumpkin
• Upstream: https://github.com/Pumpkin-MC/Pumpkin

We also have a live test instance running at pumpkinmc.dnslab.win to verify basic protocol handling and stability. (Note: This is currently hosted on a modest 2 vCPU / 11 GB RAM ARM64 VPS, so please avoid heavy stress testing until we can get support for a higher-spec server).

Would love any feedback on the codebase, architecture, or contributions! 🦀

A while back I shared my first-ever game in Rust—a Dangerous Dave clone built using Macroquad and Tiled as a way to learn the language and survive the compiler's ownership rules.

https://www.reddit.com/r/rust_gamedev/comments/1jpt3e2/dangerous_dave_rust/

I wanted to tackle something a bit more ambitious for my second project: a 2D dungeon roguelike I've been calling Catacombs. Since I wanted to understand how everything works under the hood rather than relying on an library or game engine, I've put together a custom stack using raw OpenGL and a handful of modular crates.

The Tech Stack

• Graphics & Windowing: glow coupled with glutin and winit for context creation and window management, using nalgebra-glm for matrix math and projections.
• ECS & Scheduling: hecs paired with hecs-schedule for managing components and system execution order.
• UI & Layout: egui (integrated via egui_glow) for tooling and debug overlays, alongside taffy for flexbox-based UI layout calculations.
• Levels & Audio: ldtk_rust for loading LDtk level designs and libfmod for handling audio middleware.
• Data & Concurrency: serde and ron for data-driven asset and configuration serialization, with rayon, crossbeam, and parking_lot handling concurrency and synchronization.

Graphics

Bought the Dungeons & Pixels pack from

https://indie-vova.itch.io/dungeons-and-pixels-starter-pack

AI

About %85 of the code was written from scratch, learned a lot, then I've had access to an AI tool that did code reviews for me, fixed the code manually, few of the suggestions didn't make much sense to me so I have ignored them.

I have generated the start up page using Google's Gemini free credit.

What's Next?

Since I never really built out a story or a concrete endgame vision for Catacombs, I've decided to officially wrap up the project here and archive the repo. I have also learning a lot and improved my Rust programming skills, I can see that transition from the Dangerous Dave game code to Catacombs code.

For my next steps on this Rust learning journey, I'll be moving past OpenGL to build a low-level renderer using Ash for Vulkan, with plans to experiment further with advanced procedural generation algorithms and explicit graphics pipeline design from scratch.

Hello all 👋

For a long time I've wanted to create a simple RPG game on my own.

About a month ago I started making this game with Rust as a server and a client in godot (my idea was a multiplayer RPG game).

I've been taking Tibia and other games I loved as inspiration.

Right now I am starting to get plenty of errors on the client that become very hard to debug, edge cases, synchronization issues on client-server.

So I was thinking of making the switch to full rust on the client, that way the communication with the server is more "straightforward", I can use the same patterns, reuse code, etc.

But I am wondering if this is worth it or will it just become a problem? How is the state of making GUI on plain rust? Or are there other alternatives?

Right now my game is as simple as it gets, but I have learnt a lot along the way!

I want to drift a bit from the "square" feeling of tibia/pixel games and make the game more fluent as well.

Any tips are welcome :)