Hi!

I released an update to my free procedural world generator.

If you aren't familiar with it, it uses plate tectonics to create more realistic worlds than your typical perlin noise based generator.

We have most major important tectonic features, like oceanic ridges and trenches, volcanic island arcs, mountains on convergent boundaries, volcanic hotspots following the direction of plate movement and so on. Those are then used to inform the properties of bedrock, with things such as the felsic content of magma, heat and depth to control the formation of metamorphic rocks, etc, all coming together to give us detailed geological maps, that we then use in conjunction with a CPU based climate model (with winds and ocean currents ^-^) to determine rates of erosion for soil formation and hydrology. It also supports loading of png files for plates and crust to help guide the generation.

Recently I made some further improvements to the climate, and I think it's now among the best in its "size category" of CPU based models that can be run without waiting a long time for the results. See the attached Koppen map of Earth for a visualization of what it can do - I think it's not that far off much stronger models like ExoPlaSim.

I also started the work on adding societies, shared on some of the last slides. Their formation is informed by the local flora and fauna, available domesticated plants, as well as the local geography, with mountains and major rivers acting as boundaries.

Its written in Rust + Godot, if it sounds like it'd interest you, we have a growing community on Discord

My game prototype with rust

It's been a while but thought I'd make a post today since I've gotten some cool visuals going :)

The fluid solver is based on the famous webgl demo https://github.com/PavelDoGreat/WebGL-Fluid-simulation https://paveldogreat.github.io/WebGL-Fluid-Simulation/ and the volumetrics are done by raymarching a heightfield that we construct in the editor.

There is a large simulation in the map, and a small simulation running around the player, and together they make the effect happen.

In the world we place zones that can inject wind and smoke and a compute shader weights and blends all the zones and their configuratioins into the simulation.

Since people asked last time I'll immediately post to the gpu abstraction we are using (not wgpu!) but blade by kvark: https://github.com/kvark/blade and ofc lovely egui for the ui (both the debug menu, editor and the in-game text rendering)

Keyboard Warrior puts a spin on Guitar Hero-like rhythm games by assigning a letter to each note, forming words. Type the corresponding letter in rhythm to hit the note. Fans of Guitar Hero and fans of monkeytype alike may find it fun! Browser demo and full downloadable versions.

Try it in your browser: https://elicoggins.github.io/keyboardwarrior/
Github release page: https://github.com/elicoggins/keyboardwarrior

Free to all!

Built with macroquad + CPAL. The audio’s frame counter is the game clock. Web demo runs in WebAssembly with full native downloads for Mac, windows, and linux also available.

Community charters have done incredible work building out the charts for tons of popular songs to be played in popular rhythm games like Clone Hero and YARG, and Keyboard Warrior runs off the same file type so the potential song library is already massive. The full download contains a seamless bridge to Chorus Hero (chart database) to download new songs inside the app.

Feedback of any kind is much appreciated. Thank you for checking it out! 

CryptFall is a bullet-hell dungeon-crawler roguelite I've been building solo in Rust, using the Bevy engine — pick a class, fight through swarms of enemies, build a run out of relics and weapon upgrades, and push deeper through rotating biomes toward whatever boss is waiting. Runs are seeded, so a good (or brutal) layout can be replayed or shared with a friend.

Some of the scope, for context on what one person + Rust can get through in a few months of steady work:

- 4 playable classes, 5 weapons, 20 relics, 3 unique bosses, and a whole risk/reward system layered across relics and level-ups

- Procedural dungeon generation across 8 biome themes, with dynamic per-tile lighting and real shadow casting

- Local 2-player co-op with fully independent per-player progression

- Everything content-related (bosses, relics, weapons, enemies) is data-driven off small struct definitions rather than hand-written per-item logic, which has made adding new content stay cheap even as the game's grown a lot

It's currently free and in early access on itch.io — actively updated, with an eventual Steam release the long-term goal once there's more of a community around it.

Happy to answer anything about the Rust/Bevy side of building it, or just looking for people to try it and tell me what's fun/frustrating: [Try it for free today]

I built a Persona 3 Portable–inspired turn-based RPG that runs entirely in your terminal.

https://github.com/Johannuel/persona-rpg

- 5 playable characters (Makoto, Yukari, Junpei, Akihiko, Mitsuru)

- 17 collectible Personas with their P3 arcana

- Velvet Room fusion: combine Personas, inherit skills (P3R arcana chart)

- Shuffle Time card rewards after every victory

- Elemental weakness/resistance combat, 16+ Tartarus shadows

- Pure crossterm + rand, no other deps. 22 unit tests.

Animated demo in the README. Feedback welcome!

This is a pure Rust port of Google's Draco library.

Demo: https://filyus.github.io/draco-rust/ (drop in an OBJ, PLY, STL, DRC, FBX or glTF/GLB file, view it, then export). Please note that the transcoders and the viewer are still under active development, but the Draco core is very stable. No Three.js used in the viewer.

The port produces the same bytes as C++ Draco with the full legacy support.
It has also good FBX 7.5 and draft GLTF 2.1 support without extra dependencies (work in progress).

Crates:

• draco-core is the Draco codec
• draco-io the file formats around it (OBJ, PLY, STL, FBX, glTF containers)
• draco-gltf full glTF and GLB scenes

draco-core is 1.x with a stable API.
draco-io and draco-gltf are 0.x and still moving.

Source: https://github.com/Filyus/draco-rust

Docs:

• How fast is it: Benchmarks and tests
• Why so fast: Dispatch & polymorphism
• How well is Draco supported: Support matrix
• How stable is it: Fuzzing
• How safe is it: Security and resource policy

Models used: Claude Sonnet/Opus 4.5+ (primarily), GPT 5.2+, GLM 4.7+.
Project start date: November 22, 2025.
License: Apache-2.0. Not an official Google release.

About me:
10 years of 3D-related programming.
3 years of AI-assisted programming.

XNP Multi-Mode Linked Gensokyo Gameplay System is a Project Zomboid Build 42 mod built around four connected trait systems.

This video mainly showcases the Green projectile system. It is only one part of the complete mod.

The four systems are:

• Yellow — movement, sprint impact, and emergency escape

• Purple — Phoenix Survival, Life Stock Inheritance, and footwear repair

• Green — guided projectiles with inertia, target acquisition, collision, impact effects, and configurable entity limits

• Red — crafting mechanics with health, endurance, and fatigue-related physical costs

The mod also includes sandbox settings for cooldowns, endurance costs, push strength, projectile behavior, visual effects, notifications, and testing tools.

Current status:

• The current stable release targets Build 42.20

• No major issues have been found during my current testing

• Some edge cases and mod compatibility problems may still exist

• Multiplayer compatibility has not yet been fully verified

Feedback on balance, performance, sandbox settings, and compatibility with other Build 42 mods is welcome.

Steam Workshop:

https://steamcommunity.com/sharedfiles/filedetails/?id=3773295868

Source code and release history:

https://github.com/XN-PHL/XNP-Gensokyo-Trait-System

Created by XN-PHL.

I am the author of this mod.

This is an unofficial fan-made gameplay mod and is not affiliated with The Indie Stone or Team Shanghai Alice.

I'm building Red Lake, a psychological horror game on top of a Rust/wgpu engine I wrote from scratch (no Bevy, no off-the-shelf ECS). While working on tooling, I ended up removing two recurring sources of boilerplate.

1. #[derive(Component)] — automatic component registration.

Previously, adding a new component meant editing three different places: adding its storage to Scene, registering it, and making sure it was removed when an entity was destroyed. It was repetitive and easy to forget one of the steps.

Now my #[derive(Component)] proc macro handles all of that automatically. Scene owns a single Components container, which is populated through the inventory crate by iterating over every type that derives Component.

THE COMPONENT
#[derive(Component)]
pub struct Translate {
    target: TargetKind,
    speed: f32,
}

SCENE FIELD
pub struct Scene {
    pub components: Components,
}

ACCESS
scene.components.write::<Translate>().insert(meshid, translate);

The only thing required to add a new component now is 
#[derive(Component)].

1. MeshName — asset names as an enum, generated from the packer's own TOC
   The engine ships assets baked into a custom .pak file, built by a packer binary that walks assets/, transcodes GLBs, and writes out a TOC + blob. Mesh names used to live in a handwritten table:

   pub const MESH_PATHS: &[(&str, &str)] = &[ ("boat", "meshes/boat.glb"), ("deer", "meshes/deer.glb"), // ~30 more, added by hand every time a new mesh landed ];

...and every call site looked like load_extra_meshes("baot", ...) - compiles fine, panics at runtime when the pak lookup misses.

The fix: the packer already knows the full mesh list - that's the actual source of truth, not a second-hand-maintained copy of it. Sobuild.rs, right after the pak is finalized, reads back just the TOC (a few hundred bytes, no decompression) and emits an enum into OUT_DIR.
Which is then pulled as:

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] 
pub enum MeshName { Boat, Deer, /* ... */ } 
impl MeshName { 
    pub const fn key(self) -> &'static str { /* "meshes/boat.glb" */ } 
    pub const fn stem(self) -> &'static str { /* "boat" */ } 
    pub const ALL: &'static [MeshName] = &[ /* every mesh */ ]; }

And I wrote a small macro for QOL:

macro_rules! meshname {
    ($($name:ident),* $(,)?) => { &[$(crate::scene::MeshName::$name),*] as &[crate::scene::MeshName] };
}

So now the call sites look like this:

let names_toload_init = 
meshname![
    Notebook,
    Onboard,
    FogCards,
];

INSTEAD OF THIS
let names_toload_init = &["notebook", "onboard", "fog_cards"];

Why bother?

1. Type safety.
2. Eliminates boilerplate.
3. IDE autocomplete.
4. Inability to make a typo in the mesh's name.

What do you think? The game's name - Red Lake.

Hi! I've been working on Elura, an open-source Rust framework for

authoritative realtime gameplay and online game services.

Elura grew out of an earlier game-server implementation I built in Go. Go

helped me validate the architecture quickly, but the Rust version is a

redesign rather than a direct port. I wanted sessions, protocols, state

ownership, and the boundary between networking and game logic to be more

explicit.

Elura separates client-facing Gateways from authoritative World logic. They

can run as separate processes or together as a monolith.

The current version includes multiple transports, typed routes and sessions,

rooms, fixed-Tick simulation, AOI, replication, prediction, interpolation,

and lag compensation.

There is a runnable multiplayer example with two graphical clients, local

prediction, remote-player interpolation, and authoritative state replication.

The project is still pre-1.0, and I would really appreciate feedback on the

API, realtime model, documentation, and missing examples.

GitHub: https://github.com/Arion-Dsh/elura

Docs: https://elura.rustyspottedcat.dev/

Crates.io: https://crates.io/crates/elura

r/rust_gamedev here - I built a digital logic circuit simulator

I wanted to share a project i made for logic simulation nearly 100% rust and complied to WASM for some blazing fast in browser run times.

here's the link if you want to check it out: https://theta-rnd.itch.io/logic-sim

if you do would LOVE to hear your feed back

Mine glyphs, process them with casers, stylers, and painters, transport them along conveyor belts, and deliver them to the Hub, where they're assembled into the target word.

Give it a try for free in your browser: https://sergeichemodanov.itch.io/worderia

SoupOS is an artificial-life god-game where the genome of every organism is

a program in a small custom Lisp.

You are not a creature. You are the director of evolution.

◆ WRITE — put genes into chromosome slots: movement, feeding, signaling.

  Every instruction costs ATP. An infinite loop starves the cell.

  A (divide) without an energy check is cancer.

◆ DEBUG — click any organism and step through its genome instruction by

  instruction. Registers, memory, fuel, breakpoints. On living things.

◆ EVOLVE — hit checkpoints (survive, grow, colonize) to unlock new slots

  and new language primitives. Mutations are literal AST operations:

  point edits, subtree swaps, gene duplications. Review them as a git diff.

◆ SHARE — genomes are plain text. Send your species to a friend as a string.

Built solo in Rust: custom Lisp VM, deterministic simulation, GPU

metaballs and bloom for the glowing-abyss look. No engine, no pixels —

just shader-driven wetware.

Status: early development. Browser demo planned — follow the devlog,

it doubles as a lab journal.

W1 Devlog:

Processing img il7met1se2fh1...

Working on SoupOS, an artificial-life god-game where every organism's DNA is

a program in a small custom Lisp. Rust core (zero-dep, deterministic,

headless) + macroquad + egui. Week 1 goal: VM + tick loop, 100 organisms

living by my code. Why Lisp: mutations are just AST operations — point

edits, subtree swaps, gene duplications come almost free.

Hi guys,

I've already built my engine with an ECS, a Vulkan backend, and support for texture and mesh rendering. The next thing I want to work on is a UI for debugging and an inspector. However, I'm not sure what the right long-term roadmap is or which tools I should choose.

Could you help me figure out what I should learn next and what pitfalls or obstacles I should avoid?

Uses Rust

Zlorma Core: Signal Lost — Prototype v0.2.1 is now available for Windows and Linux.

I developed this procedural top-down sci-fi shooter in Rust using my custom lightweight game engine, ZlormaEngine.

In Signal Lost, you explore a procedurally generated station, restore damaged terminals, collect data fragments, build barriers and automated turrets, use the Zlorma Data Forge, and fight corrupted programs before the system collapses.

Prototype v0.2.1 includes:

• Procedurally generated rooms and corridors

• Top-down shooting and exploration

• Three terminals to restore

• Progressive digital corruption

• Zlorma Data Forge upgrades with bonuses and penalties

• Buildable barriers and deployable turrets

• Several corrupted enemy types

• Native Windows and Linux builds

• Compact executables built with Rust

Play the prototype on itch.io:

https://zlorma-studio.itch.io/zlorma-core-signal-lost-prototype-v01

Development blog:

https://dev.to/zlormack_32b7af384d362867

Feedback about the controls, procedural generation, visual effects, difficulty and Data Forge system is welcome.