r/bevy

Greetings!

I’m working on a game called Standing Orders, a tactical RPG auto-battler where you prepare your forces and issue orders before watching the battle unfold. This is an uninterrupted demo battle; I’d especially appreciate feedback on readability and pacing.

This has been a project I've been working on for the last month or so. I've been developing this using Bevy 0.19. I was heavily inspired by games like Unicorn Overlord, Expedition 33, Fire Emblem and Final Fantasy Tactics. :D

I just released v0.1.0 of HyperVox, a voxel graphical calculator for N-dimensional mathematical expressions.

It takes one or more mathematical expressions and renders them as 3D voxel graphics. Expressions are evaluated over an N-dimensional space, so shapes can be defined in more than three dimensions.

Each expression is parsed and evaluated into a sign grid. All sign grids are composited front-to-back into one voxel grid, where each voxel takes the color of the first expression that fills it. A single mesh with per-corner ambient occlusion is built from that composite.

With more than three dimensions, only the three dimensions mapped to the X, Y, Z axes vary spatially; the rest are held at fixed values, so the render shows a 3D slice of the N-dimensional space.

• Repo: https://github.com/timasoft/hypervox
• Live single-threaded WASM build: https://timasoft.github.io/hypervox/

AI Usage: At the start of this project, I used AI extensively to understand how to use Bevy and compile it to WASM (though AI didn't help much with the WASM compilation part). Since then, I've used AI to analyze the codebase and generate optimization ideas, which I then benchmark and verify. If an AI-suggested optimization gives a >10% speedup, I ask it a few questions about the implementation details and then write the final code myself, as AI often struggles to produce optimal, idiomatic Rust. I also use AI to review almost all of my commits/PRs to catch anything I might have missed or done unidiomatically.

Why I'm posting: I have run out of ideas for optimizations and would love your help finding other ways to speed up the regeneration time!

Current optimizations:

• Using a custom expression evaluator (hypervox_expr) instead of evalexpr
• "Compiling" expressions to Box<dyn Fn> instead of evaluating with a large match block
• Constant folding and algebraic simplification
• Common subexpression elimination (CSE) using let n = x in {expr}
• Fused MulAdd
• Multi-level invariant hoisting
• unsafe set_len to skip zeroing memory (buffer is immediately overwritten)
• Multi-threaded memory copying using split_at_mut and copy_from_slice
• Ambient Occlusion (AO) caching
• Multi-threaded grid/composite computation

Also, if you have ideas about new features or UI improvements, please share them with me!

Ever wondered how to make a circular progress in #bevy?
On my blog I'll show you how!
https://kieselweich.com/post/01_circular_bevy_progress

Bit of a different post than what's normally here, but thought folks might find this neat: I ended up going with Bevy ECS to create an agent runtime (https://github.com/GEMISIS/leviath), and the performance numbers have been fantastic so far! Really lives up to the hype of an ECS system, even outside of the traditional game world 😄

It's my grass system. Here are some of its features
- Dynamic painting, the grassier the texture underneath the denser and lusher it is. When you paint you can see it grow lol.
- It also uses the color of the terrain beneath it to update its color, so the grass is "drier" if there's some sand in the textures used for example.
Here's how it looks in a forest-y setting

A little over 4 years ago I started Bonsai as a side project: a Rust library for building complex, deterministic AI behavior with behavior trees. It has since found its way into a wide range of applications.

The video shows two of them: on the left, a Titanfall 2 gameplay where all the players except the first person view is a NPC (bot) driven by Bonsai behavior trees. On the right, a robot from NASA lunabotics 2026 autonomously digging and dumping regolith in a simulated lunar environment – also powered by Bonsai.

A lot of the library's usefulness today comes from the community. Thanks to everyone who has contributed PRs, filed issues, and pushed it further than I would have on my own.

Repo link in the comments.

I've been working on this rhythm game since late March and recently I've started replacing what I felt was placeholder programmer art, which included the world surrounding the track. So now there's different "biomes" of procedural terrain, dynamically generated for each song you play. I'm really happy with how the aesthetics of the game are turning out! Still very much a work in progress though.

I finally got my own cel shader working in Bevy without using the third-party `bevy_wind_waker_shader` crate! 🎉 It still needs some improvements, but I’m happy with the result so far.

My GitHub repo: https://github.com/abc3dz/Tekkk

https://cenullum.com/mine_mage_minion/raylib_bevy/

The link to the game: https://tilcob.itch.io/flood-of-packages

Third post about my game here — ~40 days since the last one. The biggest changes since then:

• Reworked every model — characters, trees, buildings, props. Still no modeling software: everything is Bevy primitives merged into low-poly meshes with vertex colors, so thousands of props batch under a single material.
• More mature post-processing — toned the whole look down: custom bokeh depth of field, softer bloom, atmospheric haze, SSAO, god rays and a reactive color grade. Less saturated-toy-look, more grounded.
• Rival AI stronghold — an AI opponent in the desert that runs its own economy, raises buildings, and defends its town while you build yours.
• RTS skirmish mode — a separate mode with box-select, worker economy, barracks training, buildable walls/towers, and a minimap. Runs in-process, so you can enter/leave it without closing the window.
• Save system — 5 manual slots + periodic autosave, snapshot-based (serialize the logic resources, not the ECS world).
• Endgame perf pass — steering LOD, animation culling for off-screen bipeds, lazy materials.

All Rust + Bevy 0.19. Happy to answer questions about any of it!

Still looking for contributors
https://github.com/miskibin/warbell/