Bevy Rogue
An early prototype roguelike built in Rust with Bevy, combining bracket-lib's roguelike systems with Bevy's ECS for procedural map generation, FOV, and turn-based combat.
screenshots
about
About the Project
bevy_rogue started from two ideas colliding at the right time. A friend suggested I try Rust — I use C++ professionally, so it seemed like a natural next step. Around the same time I'd been playing DoomRL and wanted to make a roguelike. Bevy is the most widely used Rust game engine, and when I discovered it uses an Entity Component System — a pattern I'd always been curious about but hadn't deeply explored — the project wrote itself.
In its current state it's an early prototype. The map is procedurally generated as you explore, enemies wander the dungeon and engage in simple turn-based combat, and a field-of-view system limits what you can see. Get surrounded and it's game over.
Features
Procedural map generation that expands as you move, field-of-view with fog of war, turn-based combat, and wandering enemies that can surround and overwhelm the player.
tech breakdown
The project is built on three main pillars: Bevy for the ECS architecture, rendering, and game loop; bevy_ecs_tilemap for efficient tile-based map rendering; and bracket-lib, the Rust roguelike crate from Hands-on Rust, for roguelike-specific systems like FOV and map generation algorithms.
The core approach was essentially a conversion of bracket-lib's roguelike systems into Bevy's ECS — taking bracket's battle-tested roguelike logic and restructuring it as Bevy components and systems. This gave better performance, expandability, and access to Bevy's rendering and audio pipeline (though audio hasn't been implemented yet).
Working in Bevy's ECS was the primary learning objective. Rather than objects with methods, everything is data — components attached to entities, and systems that query for specific combinations of components. It's a genuinely different way of thinking about game architecture, and one that maps surprisingly well to how roguelikes are typically structured.
what i learned
Rust's borrow checker is famously challenging at first, but working through it alongside Bevy's ECS was a useful combination. The borrow checker pushes you away from shared mutable state — which is exactly what ECS encourages anyway. Once that clicked, the two systems started to feel complementary rather than combative.
ECS is a pattern I'd read about but never really used in anger before this project. Having to think in systems and components rather than objects and methods was a genuine shift, and one that's already influenced how I think about architecture in my professional work in UE5.