Tutorial Link

This chapter helps builds a navigable 3D viewport from scratch in Bevy 0.19, starting with the three essentials of any scene (a camera, a light, and a mesh).

We'll be working on more features in the upcoming chapters, stay tuned :)

Tutorial Link

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.

Please let me know in comments if my async series is helpful or not.

Who Runs Your Rust Future? Hands-On Intro to Async Rust

I wrote a hands-on intro to async Rust where you build a future and the runner that drives it. It assumes you've written async/await in JS and know Rust basics (structs, enums, closures). No prior async Rust needed.

What the first chapter covers:

• Who actually runs your async code in Rust
• What calling an async function actually does, compared to a JS Promise
• What 'running' a future actually means, step by step
• The waker: how a future says when it's worth polling again, so you can sleep instead of spinning the CPU
• Building a Oneshot channel by hand
• Writing block_on, a runner that drives a future to completion

Everything is built from std only, no dependencies. Also, this chapter is a part of a bigger series that goes deep into async Rust.

Bevy Game Engine Explained Visually

A visual tour of how Bevy helps you compose complex, emergent games from small independent systems and a data-driven architecture.

Tutorial Link

Chapter 7 - Let There Be Enemies

Continuing my Bevy + Rust tutorial series. 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

Tutorial Link

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

Tutorial Link

Continuing my Bevy + Rust tutorial series. By the end, 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.

• 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.

Tutorial Link

Continuing my Bevy + Rust tutorial series. In this chapter, your character finally interacts properly with the world, no more walking through trees or floating on top of water.

What you'll build:

• Player collides with trees, rocks, and water.
• Character walks behind objects, creating depth in your 2D world.
• Loading screens and pause menus.
• Debug feature to visualize the collision map

Tutorial Link

Continuing my Rust + Bevy tutorial series. This chapter demonstrates data-oriented design in Rust by refactoring hardcoded character logic into a flexible, data-driven system. We cover:

Deserializing character config from external RON files using Serde Building generic systems that operate on trait-bounded components Leveraging Rust's type system (HashMap, enums, closures) for runtime character switching The tutorial shows how separating data from behavior eliminates code duplication while maintaining type safety—a core Rust principle that scales as your project grows.

Chapter 2 - Let There Be a World (Procedural Generation) This chapter teaches you procedural world generation using Wave Function Collapse and Bevy.

A layered terrain system where tiles snap together based on simple rules. You'll create landscapes with dirt, grass, water, and decorative props.

By the end, you'll understand how simple constraint rules generate natural-looking game worlds and how tweaking few parameters lead to a lot of variety.

It also gently touches on rust concepts like references, lifetimes, closures, generic and trait bound. (Hoping to go deep in further chapters)