bevy

Invoke this skill when:

• Implementing features in a Bevy game or application
• Designing component architectures for ECS
• Creating or debugging Bevy systems
• Working with Bevy's UI system
• Building and testing Bevy projects
• Troubleshooting common Bevy issues
• Organizing project structure for Bevy applications

⚠️ Bevy 0.17 Breaking Changes

If working with Bevy 0.17, be aware of significant API changes:

• Material handles now wrapped in MeshMaterial3d (not Handle)
• Event system replaced with observer pattern (commands.trigger(), add_observer())
• Color arithmetic operations removed (use component extraction)

See references/bevy_specific_tips.md for complete Bevy 0.17 migration guide and examples.

Consult Bevy Registry Examples First

The registry examples are your bible. Always check them before implementing new features.

Location:

```bash

~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bevy-0.17.1/examples

```

There are MANY examples covering all aspects of Bevy development. Review relevant examples to understand best practices and working patterns.

Use Plugin Structure

Break your app into discrete modules using plugins. This improves organization and makes code discoverable.

```rust

pub struct CombatPlugin;

impl Plugin for CombatPlugin {

fn build(&self, app: &mut App) {

app

.add_event::()

.add_systems(Update, (process_damage, check_death));

}

}

```

See references/bevy_specific_tips.md for detailed plugin patterns and examples.

Design Before Coding

Pure ECS demands careful data modeling. It's hard to search a massive list of systems in one file!

Before implementing:

1. Design the data model (entities, components, events, systems)
2. Check Bevy examples for similar patterns
3. Review docs and existing code
4. Create a plugin for the feature domain

See references/bevy_specific_tips.md for domain-driven design guidance.

Think in ECS Terms

Bevy is an Entity Component System (ECS) engine. Always think in terms of data (components) and transformations (systems), not objects and methods.

Separation of Concerns:

• Components = Pure data, no logic
• Systems = Pure logic, operate on components
• Events = Communication between systems
• Resources = Global state (use sparingly)

Component-Driven Design

Keep components focused:

```rust

// ✅ GOOD: Small, focused components

#[derive(Component)]

pub struct Health { pub current: f32, pub max: f32 }

#[derive(Component)]

pub struct Armor { pub defense: f32 }

// ❌ BAD: Monolithic component

#[derive(Component)]

pub struct CombatStats {

pub health: f32,

pub armor: f32,

pub strength: f32,

// ... wastes memory for entities that only have some stats

}

```

Add helper methods via impl blocks:

```rust

impl Health {

pub fn is_alive(&self) -> bool {

self.current > 0.0

}

pub fn percentage(&self) -> f32 {

self.current / self.max

}

}

```

For detailed component patterns, see references/ecs_patterns.md.

System Design and Ordering

Order systems by dependencies:

```rust

.add_systems(

Update,

(

// 1. Input processing

handle_input,

// 2. State changes

process_events,

update_state,

// 3. Derive properties from state

calculate_derived_values,

// 4. Visual updates

update_materials,

update_animations,

// 5. UI updates (must run last)

update_ui_displays,

),

)

```

Use change detection to optimize:

```rust

// Only process entities where Health changed

pub fn update_health_bar(

query: Query<(&Health, &mut HealthBar), Changed>,

) {

for (health, mut bar) in query.iter_mut() {

bar.width = health.percentage() * 100.0;

}

}

```

For detailed query patterns and system design, see references/ecs_patterns.md.

Build Commands

Development (faster iteration):

```bash

cargo build --features bevy/dynamic_linking

```

• Uses dynamic linking for faster compile times
• 2-3x faster than release builds
• Only use during development
• CRITICAL: Always use this for development builds

Quick Check:

```bash

cargo check

```

• Fastest way to verify compilation
• Use after every significant change

Release (production):

```bash

cargo build --release

```

• Full optimization
• Use for final testing and distribution

Build Management - CRITICAL

DO NOT delete target binaries freely! Bevy takes minutes to rebuild from scratch.

• Avoid cargo clean unless absolutely necessary
• Each clean rebuild costs valuable development time
• Be mindful of versions, targets, and crate dependencies getting tangled
• Bevy is under active development - stick to one version per project

See references/bevy_specific_tips.md for detailed build optimization and version management.

Testing Workflow

1. After component changes: Run cargo check
2. After system changes: Run cargo check then cargo build --features bevy/dynamic_linking
3. Manual testing:

- Does the game launch?

- Do the new features work?

- Are console logs showing expected output?

- Do visual changes appear correctly?

Validation points - Let the user test at these milestones:

• New entity spawned
• New mechanic implemented
• Visual effects added
• Major system changes

Bevy uses a flexbox-like layout system. Follow the marker component pattern:

1. Create marker components:

```rust

#[derive(Component)]

pub struct HealthBar;

#[derive(Component)]

pub struct ScoreDisplay;

```

2. Setup in Startup:

```rust

pub fn setup_ui(mut commands: Commands) {

commands.spawn((

HealthBar,

Node {

position_type: PositionType::Absolute,

left: Val::Px(10.0),

top: Val::Px(10.0),

width: Val::Px(200.0),

height: Val::Px(20.0),

..default()

},

BackgroundColor(Color::srgba(0.8, 0.2, 0.2, 0.9)),

));

}

```

3. Update in Update:

```rust

pub fn update_health_ui(

health: Query<&Health, With>,

mut ui: Query<&mut Node, With>,

) {

if let (Ok(health), Ok(mut node)) = (health.get_single(), ui.get_single_mut()) {

node.width = Val::Px(health.percentage() * 200.0);

}

}

```

For detailed UI patterns including positioning, styling, and text updates, see references/ui_development.md.

Phase-Based Development

Break features into phases:

Phase 1: Foundation - Core components and basic systems

Phase 2: Content - Add entities and populate world

Phase 3: Polish - UI improvements and visual effects

Phase 4: Advanced Features - Complex mechanics and AI

Iteration Pattern

```

1. Plan → 2. Implement → 3. Build → 4. Test → 5. Refine

↑ ↓

←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←

```

Each phase should have:

1. Clear success criteria (checklist of what works)
2. Manual test cases (step-by-step testing procedures)
3. User validation points (when to let user test)

When to Optimize

For prototypes (7-100 entities):

• No optimization needed
• Change detection is sufficient
• Focus on features, not performance

For production (100+ entities):

• Use spatial partitioning for proximity queries
• Batch material updates
• Consider Fixed timestep for physics
• Profile before optimizing

Query Optimization Tips

1. Use change detection: Query<&Component, Changed>
2. Filter early: Query<&A, (With, Without)> instead of filtering in loops
3. Check resource changes: Return early if resource hasn't changed

Critical mistakes and their solutions are documented in references/common_pitfalls.md. Key pitfalls include:

1. Forgetting to register systems in main.rs
2. Borrowing conflicts (use get_many_mut for multiple mutations)
3. Not using Changed for expensive operations
4. Wrong system ordering (input → state → derived → visual → UI)
5. Entity queries after despawn (use if let Ok() pattern)
6. Material/asset handle confusion (store handles properly)

Review references/common_pitfalls.md before implementing complex features.

When implementing multi-step features, use the plan-implementer subagent with this structure:

```

Goal: [One sentence describing end state]

Current State: [What exists now]

Requirements: [Numbered list of what to build]

Implementation Steps: [Suggested approach]

Success Criteria: [How to verify it works]

Notes: [Important context, edge cases, design principles]

```

Example:

```

Implement Health System

Goal: Implement a health system with damage, healing, and death mechanics.

Current State:

• Player entity exists
• No health tracking yet

Requirements:

1. Create Health component with current/max values
2. Create DamageEvent for dealing damage
3. Create system to process damage events
4. Add death detection when health reaches 0
5. Add visual health bar UI

Implementation Steps:

1. Create Health component in src/components/properties.rs
2. Create DamageEvent in src/events.rs
3. Create process_damage system in src/systems/combat.rs
4. Create check_death system
5. Create health bar UI in src/systems/ui/health_bar.rs
6. Register all systems in main.rs in correct order

Success Criteria:

• Player spawns with Health component
• Damage events reduce health
• Health bar updates when health changes
• Entity despawns when health reaches 0
• Code compiles without errors

```

For details on recommended file organization, module structure, and component file patterns, see references/project_structure.md.

This skill includes detailed reference documentation:

• references/bevy_specific_tips.md - START HERE: Registry examples, plugin structure, build optimization, version management, domain-driven design for ECS
• references/ecs_patterns.md - Component design patterns, query patterns, and common ECS design patterns (Derivation, State Machine, Threshold/Trigger, Event-Driven, Initialization)
• references/ui_development.md - Bevy UI hierarchy, component patterns, layout tips, positioning, styling, and text updates
• references/common_pitfalls.md - Common mistakes and their solutions (system registration, borrowing conflicts, change detection, system ordering, entity queries, asset handles)
• references/project_structure.md - Recommended file organization, module structure, component file patterns, and change detection

Load these references as needed to inform implementation decisions.

Bevy Documentation:

• Official Bevy Book: https://bevyengine.org/learn/book/
• Bevy Examples: https://github.com/bevyengine/bevy/tree/main/examples (also in ~/.cargo/registry/...)
• Bevy Cheat Book: https://bevy-cheatbook.github.io/
• Plugin Guide: https://bevy.org/learn/quick-start/getting-started/plugins/
• System Sets: https://bevy-cheatbook.github.io/programming/system-sets.html
• Setup & Optimization: https://bevy.org/learn/quick-start/getting-started/setup/

ECS Design Principles:

• Prefer composition over inheritance
• One component = one concern
• Systems should be pure functions
• Use events to decouple systems
• Design data model before coding
• Check registry examples first

---

Remember: Think in terms of data (components) and transformations (systems), not objects and methods. Always consult registry examples and design your data model before diving into implementation. This is the key to effective Bevy development.