Async Rust can be frustrating because the compiler errors feel disconnected from your intent, so you try to fix things without understanding why.
Even working code can hang or run out of order at runtime, with no obvious place to begin debugging.
This chapter guides you to build the state machine behind an async fn by hand, then uses that as a model to reason about common async bugs and compiler errors.
aibodh.com/posts/async-rust-…
Async Rust can be frustrating because the compiler errors feel disconnected from your intent, so you try to fix things without understanding why.
Even working code can hang or run out of order at runtime, with no obvious place to begin debugging.
This chapter guides you to build the state machine behind an async fn by hand, then uses that as a model to reason about common async bugs and compiler errors.
aibodh.com/posts/async-rust-…
The Impatient Programmer's Guide to Bevy and Rust: Chapter 12 - Let There Be Networking
By the end of this chapter, you'll learn to:
- Understand how multiplayer games actually work under the hood, the four systems every online game needs (identity, persistence, real-time sync, and server authority).
- See why SpacetimeDB is a fundamentally different approach: instead of stitching together a web server, a database, a WebSocket layer, and an auth system, you write one Rust module.
- Set up SpacetimeDB locally, publish your first server module.
- Implement the server side: a player table that stores who exists in your world, and reducers that automatically handle players joining, leaving, and coming back.
- Connect your Bevy game to the server so that clicking Multiplayer opens a live connection screen showing your player name and who else is currently online.
- Run two instances of your game side by side and watch them recognize each other as separate players on the same shared server.
aibodh.com/posts/bevy-rust-g…
Continuing my Bevy + Rust tutorial series.
Chapter 7 - Let There Be Enemies
Learn to build intelligent enemies that hunt and attack the player using A* pathfinding and AI behavior systems.
By the end of this chapter, you'll learn:
- Implement A* pathfinding for enemies to navigate around obstacles
- Reuse player systems for enemies (movement, animation, combat)
- Build AI behaviors
aibodh.com/posts/bevy-rust-g…
Chapter 6 - Let There Be Particles
Continuing my Bevy + Rust tutorial series. Learn to build a particle system to create stunning visual effects. Implement custom shaders, additive blending, and bring magic into your game.
By the end of this chapter, you’ll learn:
- How to spawn and update thousands of particles efficiently
- Add variance for organic, natural looking effects
- Custom shaders with additive blending for that magical glow
- Building a flexible system that’s easy to extend
- Give your player magical powers
aibodh.com/posts/bevy-rust-g…
The Impatient Programmer's Guide to Bevy and Rust: Chapter 5 - Let There Be Pickups
Continuing my Bevy + Rust tutorial series.
By the end of this chapter, your player can pick up items on the map while the camera smoothly tracks their movement.
Inventory System
Walk near a plant or mushroom and watch it disappear into your inventory. The game logs what you collected and keeps a running count.
- Automatic pickup when you get close to items
- Track multiple item types (herbs, flowers, mushrooms, wood)
- See your total collection in console logs
Camera System
Zoom in 2× for a closer view of your character and world. The camera follows smoothly as you move—no jarring jumps or stuttering motion.
- Zoomed-in view that shows your character and world up close
- Smooth camera motion that keeps the player centered
You'll also learn about Rust's borrow checker and its rules while having the usual fun.
aibodh.com/posts/bevy-rust-g…
Chapter 4 - Let There Be Collisions
Continuing my Rust + Bevy tutorial series.
It focuses on the state machine design pattern and how Rust's type system makes it powerful.
What you'll build:
- Game states (loading, playing, paused)
- Character state machine (idle, walking, running, jumping)
- Tile-based collision
- Debug overlay and depth sorting
What you'll learn:
The state machine pattern and why it fits Rust so well. You'll see how enums let you define all possible states upfront, and how the compiler guarantees your entity is in exactly one state at any moment.
This connects to a broader principle called "making illegal states unrepresentable", designing your types so invalid combinations can't compile, rather than checking for them at runtime.
aibodh.com/posts/bevy-rust-g…
@sundarpichai @Google feature request for next nano banana, generating sprite sheets for 2d games, it will save indie devs SO much time! 🎮
Chapter 3 - Let The Data Flow
Continuing my Rust + Bevy tutorial series.
In this chapter, we move beyond hardcoded logic to build a flexible, data-driven character system.
We cover:
- Decoupling character attributes and animation config into external RON files.
- Building a generic animation engine that handles Walk, Run, and Jump states for any character.
- Implementing runtime character switching
This chapter demonstrates how separating data from behavior makes your game code scalable and easier to maintain.
aibodh.com/posts/bevy-rust-g…
Chapter 2 - Let there Be a World.
Continuing my Rust + Bevy tutorial series.
It teaches you procedural world generation using Wave Function Collapse and Bevy.
You'll build a layered terrain system by defining socket-based compatibility rules that determine which tiles can connect, creating coherent landscapes with dirt, grass, water, and props.
By the end, you'll understand how simple constraint rules generate natural-looking game worlds and how adjusting weights controls terrain density and variety.
aibodh.com/posts/bevy-rust-g…