This page documents Bevy's error codes for the current release. In case you are looking for the latest error codes from Bevy's main branch, you can find them in the repository.

To keep Rust rules on references (either one mutable reference or any number of immutable references) on a component, it is not possible to have two queries on the same component when one request mutable access to it in the same system.

Erroneous code example:

use bevy::prelude::*;

#[derive(Component)]
struct Player;

#[derive(Component)]
struct Enemy;

fn move_enemies_to_player(
    mut enemies: Query<&mut Transform, With<Enemy>>,
    player: Query<&Transform, With<Player>>,
) {
    // ...
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_system(move_enemies_to_player)
        .run();
}

This will panic, as it's not possible to have both a mutable and an immutable query on Transform at the same time.

You have two solutions:

Solution #1: use disjoint queries using Without

As a Player entity won't be an Enemy at the same time, those two queries will actually never target the same entity. This can be encoded in the query filter with Without:

use bevy::prelude::*;

#[derive(Component)]
struct Player;

#[derive(Component)]
struct Enemy;

fn move_enemies_to_player(
    mut enemies: Query<&mut Transform, With<Enemy>>,
    player: Query<&Transform, (With<Player>, Without<Enemy>)>,
) {
    // ...
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_system(move_enemies_to_player)
        .run();
}

Solution #2: use a ParamSet

A ParamSet will let you have conflicting queries as a parameter, but you will still be responsible of not using them at the same time in your system.

use bevy::prelude::*;

#[derive(Component)]
struct Player;

#[derive(Component)]
struct Enemy;

fn move_enemies_to_player(
    mut transforms: ParamSet<(
        Query<&mut Transform, With<Enemy>>,
        Query<&Transform, With<Player>>,
    )>,
) {
    // ...
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_system(move_enemies_to_player)
        .run();
}

To keep Rust rules on references (either one mutable reference or any number of immutable references) on a resource, it is not possible to have more than one resource of a kind if one is mutable in the same system. This can happen between Res<T> and ResMut<T> for the same T, or between NonSend<T> and NonSendMut<T> for the same T.

Erroneous code example:

use bevy::prelude::*;

fn update_materials(
    mut material_updater: ResMut<Assets<StandardMaterial>>,
    current_materials: Res<Assets<StandardMaterial>>,
) {
    // ...
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_system(update_materials)
        .run();
}

This will panic, as it's not possible to have both a mutable and an immutable resource on State at the same time.

As a mutable resource already provide access to the current resource value, you can remove the immutable resource.

use bevy::prelude::*;

fn update_materials(
    mut material_updater: ResMut<Assets<StandardMaterial>>,
) {
    // ...
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_system(update_materials)
        .run();
}

As commands are executed asynchronously, it is possible to issue a command on an entity that will no longer exist at the time of the command execution.

Erroneous code example:

use bevy::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_startup_system(setup)
        .add_system(despawning)
        .add_system(use_entity.after(despawning))
        .run();
}

#[derive(Resource)]
struct MyEntity(Entity);

#[derive(Component)]
struct Hello;

fn setup(mut commands: Commands) {
    let entity = commands.spawn_empty().id();
    commands.insert_resource(MyEntity(entity));
}

fn despawning(mut commands: Commands, entity: Option<Res<MyEntity>>) {
    if let Some(my_entity) = entity {
        commands.entity(my_entity.0).despawn();
        commands.remove_resource::<MyEntity>();
    }
}

fn use_entity(mut commands: Commands, entity: Option<Res<MyEntity>>) {
    if let Some(my_entity) = entity {
        commands.entity(my_entity.0).insert(Hello);
    }
}

This will panic, as system use_entity is executed after system despawning. Without the system ordering specified here, the ordering would be random and this code would panic half the time.

The default panic message is telling you the entity id (0v0) and the command that failed (adding a component Hello):

thread 'main' panicked at 'error[B0003]: Could not add a component (of type `use_entity_after_despawn::Hello`) to entity 0v0 because it doesn't exist in this World.', /bevy/crates/bevy_ecs/src/system/commands/mod.rs:752:13

But you don't know which system tried to add a component, and which system despawned the entity.

To get the system that created the command that panics, you can enable the trace feature of Bevy. This will add a panic handler that will print more information:

   0: bevy_ecs::schedule::stage::system_commands
           with name="use_entity_after_despawn::use_entity"
             at crates/bevy_ecs/src/schedule/stage.rs:880
   1: bevy_ecs::schedule::stage
           with name=Update
             at crates/bevy_ecs/src/schedule/mod.rs:337
   2: bevy_app::app::frame
             at crates/bevy_app/src/app.rs:113
   3: bevy_app::app::bevy_app
             at crates/bevy_app/src/app.rs:126
thread 'main' panicked at 'error[B0003]: Could not add a component (of type `use_entity_after_despawn::Hello`) to entity 0v0 because it doesn't exist in this World.', /bevy/crates/bevy_ecs/src/system/commands/mod.rs:752:13

From the first two lines, you now know that it panics while executing a command from the system use_entity.

To get the system that created the despawn command, you can enable DEBUG logs for crate bevy_ecs, for example by setting the environment variable RUST_LOG=bevy_ecs=debug. This will log:

DEBUG stage{name=Update}:system_commands{name="use_entity_after_despawn::despawning"}: bevy_ecs::world: Despawning entity 0v0
thread 'main' panicked at 'error[B0003]: Could not add a component (of type `use_entity_after_despawn::Hello`) to entity 0v0 because it doesn't exist in this World.', /bevy/crates/bevy_ecs/src/system/commands/mod.rs:752:13

From the first line, you know the entity 0v0 was despawned when executing a command from system despawning. In a real case, you could have many log lines, you will need to search for the exact entity from the panic message.

Combining those two, you should get enough information to understand why this panic is happening and how to fix it:

DEBUG stage{name=Update}:system_commands{name="use_entity_after_despawn::despawning"}: bevy_ecs::world: Despawning entity 0v0
   0: bevy_ecs::schedule::stage::system_commands
           with name="use_entity_after_despawn::use_entity"
             at crates/bevy_ecs/src/schedule/stage.rs:880
   1: bevy_ecs::schedule::stage
           with name=Update
             at crates/bevy_ecs/src/schedule/mod.rs:337
thread 'main' panicked at 'error[B0003]: Could not add a component (of type `use_entity_after_despawn::Hello`) to entity 0v0 because it doesn't exist in this World.', /bevy/crates/bevy_ecs/src/system/commands/mod.rs:752:13

A runtime warning.

An Entity with a hierarchy-inherited component has a Parent without the hierarchy-inherited component in question.

The hierarchy-inherited components defined in bevy include:

• ComputedVisibility
• GlobalTransform

Third party plugins may also define their own hierarchy components, so read the warning message carefully and pay attention to the exact type of the missing component.

To fix this warning, add the missing hierarchy component to all ancestors of entities with the hierarchy component you wish to use.

The following code will cause a warning to be emitted:

use bevy::prelude::*;

// WARNING: this code is buggy
fn setup_cube(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    commands
        .spawn(TransformBundle::default())
        .with_children(|parent| {
            // cube
            parent.spawn(PbrBundle {
                mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
                material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
                transform: Transform::from_xyz(0.0, 0.5, 0.0),
                ..default()
            });
        });

    // camera
    commands.spawn(Camera3dBundle {
        transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
        ..default()
    });
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_startup_system(setup_cube)
        .run();
}

This code will not show a cube on screen. This is because the entity spawned with commands.spawn(…) doesn't have a ComputedVisibility component. Since the cube is spawned as a child of an entity without the ComputedVisibility component, it will not be visible at all.

To fix this, you must use SpatialBundle over TransformBundle, as follows:

use bevy::prelude::*;

fn setup_cube(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    commands
        // We use SpatialBundle instead of TransformBundle, it contains the
        // ComputedVisibility component needed to display the cube,
        // In addition to the Transform and GlobalTransform components.
        .spawn(SpatialBundle::default())
        .with_children(|parent| {
            // cube
            parent.spawn(PbrBundle {
                mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
                material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
                transform: Transform::from_xyz(0.0, 0.5, 0.0),
                ..default()
            });
        });

    // camera
    commands.spawn(Camera3dBundle {
        transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
        ..default()
    });
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_startup_system(setup_cube)
        .run();
}

A similar problem occurs when the GlobalTransform component is missing. However, when a parent GlobalTransform is missing, it will simply prevent all transform propagation, including when updating the Transform component of the child.

You will most likely encounter this warning when loading a scene as a child of a pre-existing Entity that does not have the proper components.

A runtime warning.

Separate font atlases are created for each font and font size. This is expensive, and the memory is never reclaimed when e.g. interpolating TextStyle::font_size or UiScale::scale.

If you need to smoothly scale font size, use Transform::scale.

You can disable this warning by setting TextSettings::allow_dynamic_font_size to true or raise the limit by setting TextSettings::max_font_atlases.