From b61397e32bca34958e57198c0969359da647eafa Mon Sep 17 00:00:00 2001
From: Niklas Eicker <git@nikl.me>
Date: Thu, 6 Jul 2023 01:21:33 +0200
Subject: [PATCH 01/30] Reduce android example APK size (#8932)

# Objective

The current mobile example produces an APK of 1.5 Gb.
- Running the example on a real device takes significant time (around
one minute just to copy the file over USB to my phone).
- Default virtual devices in Android studio run out of space after the
first install. This can of course be solved/configured, but it causes
unnecessary friction.
- One impression could be, that Bevy produces bloated APKs. 1.5Gb is
even double the size of debug builds for desktop examples.

## Solution

- Strip the debug symbols of the shared libraries before they are copied
to the APK

APK size after this change: 200Mb
Copy time on my machine: ~8s

## Considered alternative

APKs built in release mode are only 50Mb in size, but require setting up
signing for the profile and compile longer.
---
 examples/mobile/Cargo.toml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/examples/mobile/Cargo.toml b/examples/mobile/Cargo.toml
index 8101ca0da6b4fa..02c7d3f8a33632 100644
--- a/examples/mobile/Cargo.toml
+++ b/examples/mobile/Cargo.toml
@@ -18,6 +18,8 @@ package = "org.bevyengine.example"
 apk_name = "bevyexample"
 assets = "../../assets"
 resources = "../../assets/android-res"
+# This strips debug symbols from the shared libraries, drastically reducing APK size. If you need them, remove the option.
+strip = "strip"
 build_targets = ["aarch64-linux-android", "armv7-linux-androideabi"]
 
 [package.metadata.android.sdk]

From 048e00fc32265a9ee92fcf60a365a6efcea03ef2 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Thu, 6 Jul 2023 07:35:17 +0100
Subject: [PATCH 02/30] Remove unnecessary `clone_weak` (#9053)

# Objective

In `extract_uinodes` it's not neccessary to clone the
`DEFAULT_IMAGE_HANDLE.typed()` handle.
---
 crates/bevy_ui/src/render/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 66fa5e15be7be5..6a480721ca1eb4 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -396,7 +396,7 @@ pub fn extract_uinodes(
                 }
                 (image.texture.clone_weak(), image.flip_x, image.flip_y)
             } else {
-                (DEFAULT_IMAGE_HANDLE.typed().clone_weak(), false, false)
+                (DEFAULT_IMAGE_HANDLE.typed(), false, false)
             };
 
             extracted_uinodes.uinodes.push(ExtractedUiNode {

From 9655acebb673b437a56df824d6fac28b6b8c7fb8 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Thu, 6 Jul 2023 21:27:54 +0100
Subject: [PATCH 03/30] Divide by `UiScale` when converting UI coordinates from
 physical to logical (#8720)

# Objective

After the UI layout is computed when the coordinates are converted back
from physical coordinates to logical coordinates the `UiScale` is
ignored. This results in a confusing situation where we have two
different systems of logical coordinates.

Example:

```rust
use bevy::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_systems(Startup, setup)
        .add_systems(Update, update)
        .run();
}

fn setup(mut commands: Commands, mut ui_scale: ResMut<UiScale>) {
    ui_scale.scale = 4.;

    commands.spawn(Camera2dBundle::default());
    commands.spawn(NodeBundle {
        style: Style {
            align_items: AlignItems::Center,
            justify_content: JustifyContent::Center,
            width: Val::Percent(100.),
            ..Default::default()
        },
        ..Default::default()
    })
    .with_children(|builder| {
        builder.spawn(NodeBundle {
            style: Style {
                width: Val::Px(100.),
                height: Val::Px(100.),
                ..Default::default()
            },
            background_color: Color::MAROON.into(),
            ..Default::default()
        }).with_children(|builder| {
            builder.spawn(TextBundle::from_section("", TextStyle::default());
        });
    });
}

fn update(
    mut text_query: Query<(&mut Text, &Parent)>,
    node_query: Query<Ref<Node>>,
) {
    for (mut text, parent) in text_query.iter_mut() {
        let node = node_query.get(parent.get()).unwrap();
        if node.is_changed() {
            text.sections[0].value = format!("size: {}", node.size());
        }
    }
}
```
result:

![Bevy App 30_05_2023
16_54_32](https://github.com/bevyengine/bevy/assets/27962798/a5ecbf31-0a12-4669-87df-b0c32f058732)

We asked for a 100x100 UI node but the Node's size is multiplied by the
value of `UiScale` to give a logical size of 400x400.

## Solution

Divide the output physical coordinates by `UiScale` in
`ui_layout_system` and multiply the logical viewport size by `UiScale`
when creating the projection matrix for the UI's `ExtractedView` in
`extract_default_ui_camera_view`.

---

## Changelog
* The UI layout's physical coordinates are divided by both the window
scale factor and `UiScale` when converting them back to logical
coordinates. The logical size of Ui nodes now matches the values given
to their size constraints.
* Multiply the logical viewport size by `UiScale` before creating the
projection matrix for the UI's `ExtractedView` in
`extract_default_ui_camera_view`.
* In `ui_focus_system` the cursor position returned from `Window` is
divided by `UiScale`.
* Added a scale factor parameter to `Node::physical_size` and
`Node::physical_rect`.
* The example `viewport_debug` now uses a `UiScale` of 2. to ensure that
viewport coordinates are working correctly with a non-unit `UiScale`.

## Migration Guide

Physical UI coordinates are now divided by both the `UiScale` and the
window's scale factor to compute the logical sizes and positions of UI
nodes.

This ensures that UI Node size and position values, held by the `Node`
and `GlobalTransform` components, conform to the same logical coordinate
system as the style constraints from which they are derived,
irrespective of the current `scale_factor` and `UiScale`.

---------

Co-authored-by: Carter Anderson <mcanders1@gmail.com>
---
 crates/bevy_ui/src/focus.rs       |   8 ++-
 crates/bevy_ui/src/layout/mod.rs  |   2 +-
 crates/bevy_ui/src/render/mod.rs  |  55 +++++++++++-----
 crates/bevy_ui/src/ui_node.rs     |  23 ++++---
 crates/bevy_ui/src/widget/text.rs |   3 +-
 examples/ui/viewport_debug.rs     | 104 ++++++++++++++++--------------
 6 files changed, 117 insertions(+), 78 deletions(-)

diff --git a/crates/bevy_ui/src/focus.rs b/crates/bevy_ui/src/focus.rs
index 2b180fa7c2dd22..7837d19ac0bfaf 100644
--- a/crates/bevy_ui/src/focus.rs
+++ b/crates/bevy_ui/src/focus.rs
@@ -1,4 +1,4 @@
-use crate::{camera_config::UiCameraConfig, CalculatedClip, Node, UiStack};
+use crate::{camera_config::UiCameraConfig, CalculatedClip, Node, UiScale, UiStack};
 use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::{
     change_detection::DetectChangesMut,
@@ -138,6 +138,7 @@ pub fn ui_focus_system(
     windows: Query<&Window>,
     mouse_button_input: Res<Input<MouseButton>>,
     touches_input: Res<Touches>,
+    ui_scale: Res<UiScale>,
     ui_stack: Res<UiStack>,
     mut node_query: Query<NodeQuery>,
     primary_window: Query<Entity, With<PrimaryWindow>>,
@@ -187,7 +188,10 @@ pub fn ui_focus_system(
                 .ok()
                 .and_then(|window| window.cursor_position())
         })
-        .or_else(|| touches_input.first_pressed_position());
+        .or_else(|| touches_input.first_pressed_position())
+        // The cursor position returned by `Window` only takes into account the window scale factor and not `UiScale`.
+        // To convert the cursor position to logical UI viewport coordinates we have to divide it by `UiScale`.
+        .map(|cursor_position| cursor_position / ui_scale.scale as f32);
 
     // prepare an iterator that contains all the nodes that have the cursor in their rect,
     // from the top node to the bottom one. this will also reset the interaction to `None`
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index ca38a415003b82..cc4cc9301db91b 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -301,7 +301,7 @@ pub fn ui_layout_system(
     // compute layouts
     ui_surface.compute_window_layouts();
 
-    let physical_to_logical_factor = 1. / logical_to_physical_factor;
+    let physical_to_logical_factor = 1. / scale_factor;
 
     let to_logical = |v| (physical_to_logical_factor * v as f64) as f32;
 
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 6a480721ca1eb4..4eb26df186957a 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -8,11 +8,11 @@ use bevy_window::{PrimaryWindow, Window};
 pub use pipeline::*;
 pub use render_pass::*;
 
-use crate::UiTextureAtlasImage;
 use crate::{
-    prelude::UiCameraConfig, BackgroundColor, BorderColor, CalculatedClip, Node, UiImage, UiStack,
+    prelude::UiCameraConfig, BackgroundColor, BorderColor, CalculatedClip, ContentSize, Node,
+    Style, UiImage, UiScale, UiStack, UiTextureAtlasImage, Val,
 };
-use crate::{ContentSize, Style, Val};
+
 use bevy_app::prelude::*;
 use bevy_asset::{load_internal_asset, AssetEvent, Assets, Handle, HandleUntyped};
 use bevy_ecs::prelude::*;
@@ -170,7 +170,6 @@ pub fn extract_atlas_uinodes(
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
     images: Extract<Res<Assets<Image>>>,
     texture_atlases: Extract<Res<Assets<TextureAtlas>>>,
-
     ui_stack: Extract<Res<UiStack>>,
     uinode_query: Extract<
         Query<
@@ -258,6 +257,7 @@ fn resolve_border_thickness(value: Val, parent_width: f32, viewport_size: Vec2)
 pub fn extract_uinode_borders(
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
     windows: Extract<Query<&Window, With<PrimaryWindow>>>,
+    ui_scale: Extract<Res<UiScale>>,
     ui_stack: Extract<Res<UiStack>>,
     uinode_query: Extract<
         Query<
@@ -277,10 +277,13 @@ pub fn extract_uinode_borders(
 ) {
     let image = bevy_render::texture::DEFAULT_IMAGE_HANDLE.typed();
 
-    let viewport_size = windows
+    let ui_logical_viewport_size = windows
         .get_single()
         .map(|window| Vec2::new(window.resolution.width(), window.resolution.height()))
-        .unwrap_or(Vec2::ZERO);
+        .unwrap_or(Vec2::ZERO)
+        // The logical window resolutin returned by `Window` only takes into account the window scale factor and not `UiScale`,
+        // so we have to divide by `UiScale` to get the size of the UI viewport.
+        / ui_scale.scale as f32;
 
     for (stack_index, entity) in ui_stack.uinodes.iter().enumerate() {
         if let Ok((node, global_transform, style, border_color, parent, visibility, clip)) =
@@ -300,11 +303,21 @@ pub fn extract_uinode_borders(
             let parent_width = parent
                 .and_then(|parent| parent_node_query.get(parent.get()).ok())
                 .map(|parent_node| parent_node.size().x)
-                .unwrap_or(viewport_size.x);
-            let left = resolve_border_thickness(style.border.left, parent_width, viewport_size);
-            let right = resolve_border_thickness(style.border.right, parent_width, viewport_size);
-            let top = resolve_border_thickness(style.border.top, parent_width, viewport_size);
-            let bottom = resolve_border_thickness(style.border.bottom, parent_width, viewport_size);
+                .unwrap_or(ui_logical_viewport_size.x);
+            let left =
+                resolve_border_thickness(style.border.left, parent_width, ui_logical_viewport_size);
+            let right = resolve_border_thickness(
+                style.border.right,
+                parent_width,
+                ui_logical_viewport_size,
+            );
+            let top =
+                resolve_border_thickness(style.border.top, parent_width, ui_logical_viewport_size);
+            let bottom = resolve_border_thickness(
+                style.border.bottom,
+                parent_width,
+                ui_logical_viewport_size,
+            );
 
             // Calculate the border rects, ensuring no overlap.
             // The border occupies the space between the node's bounding rect and the node's bounding rect inset in each direction by the node's corresponding border value.
@@ -433,8 +446,10 @@ pub struct DefaultCameraView(pub Entity);
 
 pub fn extract_default_ui_camera_view<T: Component>(
     mut commands: Commands,
+    ui_scale: Extract<Res<UiScale>>,
     query: Extract<Query<(Entity, &Camera, Option<&UiCameraConfig>), With<T>>>,
 ) {
+    let scale = (ui_scale.scale as f32).recip();
     for (entity, camera, camera_ui) in &query {
         // ignore cameras with disabled ui
         if matches!(camera_ui, Some(&UiCameraConfig { show_ui: false, .. })) {
@@ -446,8 +461,14 @@ pub fn extract_default_ui_camera_view<T: Component>(
             camera.physical_viewport_size(),
         ) {
             // use a projection matrix with the origin in the top left instead of the bottom left that comes with OrthographicProjection
-            let projection_matrix =
-                Mat4::orthographic_rh(0.0, logical_size.x, logical_size.y, 0.0, 0.0, UI_CAMERA_FAR);
+            let projection_matrix = Mat4::orthographic_rh(
+                0.0,
+                logical_size.x * scale,
+                logical_size.y * scale,
+                0.0,
+                0.0,
+                UI_CAMERA_FAR,
+            );
             let default_camera_view = commands
                 .spawn(ExtractedView {
                     projection: projection_matrix,
@@ -481,6 +502,7 @@ pub fn extract_text_uinodes(
     texture_atlases: Extract<Res<Assets<TextureAtlas>>>,
     windows: Extract<Query<&Window, With<PrimaryWindow>>>,
     ui_stack: Extract<Res<UiStack>>,
+    ui_scale: Extract<Res<UiScale>>,
     uinode_query: Extract<
         Query<(
             &Node,
@@ -495,10 +517,11 @@ pub fn extract_text_uinodes(
     // TODO: Support window-independent UI scale: https://github.com/bevyengine/bevy/issues/5621
     let scale_factor = windows
         .get_single()
-        .map(|window| window.resolution.scale_factor() as f32)
-        .unwrap_or(1.0);
+        .map(|window| window.resolution.scale_factor())
+        .unwrap_or(1.0)
+        * ui_scale.scale;
 
-    let inverse_scale_factor = scale_factor.recip();
+    let inverse_scale_factor = (scale_factor as f32).recip();
 
     for (stack_index, entity) in ui_stack.uinodes.iter().enumerate() {
         if let Ok((uinode, global_transform, text, text_layout_info, visibility, clip)) =
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index 532007ed3b752e..c4c128198e840f 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -29,12 +29,12 @@ impl Node {
         self.calculated_size
     }
 
-    /// Returns the size of the node in physical pixels based on the given scale factor.
+    /// Returns the size of the node in physical pixels based on the given scale factor and `UiScale`.
     #[inline]
-    pub fn physical_size(&self, scale_factor: f64) -> Vec2 {
+    pub fn physical_size(&self, scale_factor: f64, ui_scale: f64) -> Vec2 {
         Vec2::new(
-            (self.calculated_size.x as f64 * scale_factor) as f32,
-            (self.calculated_size.y as f64 * scale_factor) as f32,
+            (self.calculated_size.x as f64 * scale_factor * ui_scale) as f32,
+            (self.calculated_size.y as f64 * scale_factor * ui_scale) as f32,
         )
     }
 
@@ -46,16 +46,21 @@ impl Node {
 
     /// Returns the physical pixel coordinates of the UI node, based on its [`GlobalTransform`] and the scale factor.
     #[inline]
-    pub fn physical_rect(&self, transform: &GlobalTransform, scale_factor: f64) -> Rect {
+    pub fn physical_rect(
+        &self,
+        transform: &GlobalTransform,
+        scale_factor: f64,
+        ui_scale: f64,
+    ) -> Rect {
         let rect = self.logical_rect(transform);
         Rect {
             min: Vec2::new(
-                (rect.min.x as f64 * scale_factor) as f32,
-                (rect.min.y as f64 * scale_factor) as f32,
+                (rect.min.x as f64 * scale_factor * ui_scale) as f32,
+                (rect.min.y as f64 * scale_factor * ui_scale) as f32,
             ),
             max: Vec2::new(
-                (rect.max.x as f64 * scale_factor) as f32,
-                (rect.max.y as f64 * scale_factor) as f32,
+                (rect.max.x as f64 * scale_factor * ui_scale) as f32,
+                (rect.max.y as f64 * scale_factor * ui_scale) as f32,
             ),
         }
     }
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index 06d876eb7a684a..82b47ceb5bd891 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -184,7 +184,8 @@ fn queue_text(
             // With `NoWrap` set, no constraints are placed on the width of the text.
             Vec2::splat(f32::INFINITY)
         } else {
-            node.physical_size(scale_factor)
+            // `scale_factor` is already multiplied by `UiScale`
+            node.physical_size(scale_factor, 1.)
         };
 
         match text_pipeline.queue_text(
diff --git a/examples/ui/viewport_debug.rs b/examples/ui/viewport_debug.rs
index 691d70ee6a3d8c..bec9809b33ae49 100644
--- a/examples/ui/viewport_debug.rs
+++ b/examples/ui/viewport_debug.rs
@@ -1,10 +1,14 @@
-//! An example for debugging viewport coordinates
-
+//! A simple example for debugging viewport coordinates
+//!
+//! This example creates two uinode trees, one using viewport coordinates and one using pixel coordinates,
+//! and then switches between them once per second using the `Display` style property.
+//! If there are no problems both layouts should be identical, except for the color of the margin changing which is used to signal that the displayed uinode tree has changed
+//! (red for viewport, yellow for pixel).
 use bevy::prelude::*;
 
 const PALETTE: [Color; 10] = [
-    Color::ORANGE,
-    Color::BLUE,
+    Color::RED,
+    Color::YELLOW,
     Color::WHITE,
     Color::BEIGE,
     Color::CYAN,
@@ -15,7 +19,7 @@ const PALETTE: [Color; 10] = [
     Color::BLACK,
 ];
 
-#[derive(Default, Debug, Hash, Eq, PartialEq, Clone, States)]
+#[derive(Component, Default, PartialEq)]
 enum Coords {
     #[default]
     Viewport,
@@ -24,66 +28,66 @@ enum Coords {
 
 fn main() {
     App::new()
+        .insert_resource(UiScale { scale: 2.0 })
         .add_plugins(DefaultPlugins.set(WindowPlugin {
             primary_window: Some(Window {
-                resolution: [800., 600.].into(),
+                resolution: [1600., 1200.].into(),
                 title: "Viewport Coordinates Debug".to_string(),
                 resizable: false,
                 ..Default::default()
             }),
             ..Default::default()
         }))
-        .add_state::<Coords>()
         .add_systems(Startup, setup)
-        .add_systems(OnEnter(Coords::Viewport), spawn_with_viewport_coords)
-        .add_systems(OnEnter(Coords::Pixel), spawn_with_pixel_coords)
-        .add_systems(OnExit(Coords::Viewport), despawn_nodes)
-        .add_systems(OnExit(Coords::Pixel), despawn_nodes)
         .add_systems(Update, update)
         .run();
 }
 
-fn despawn_nodes(mut commands: Commands, query: Query<Entity, With<Node>>) {
-    for entity in query.iter() {
-        commands.entity(entity).despawn();
-    }
-}
-
 fn update(
     mut timer: Local<f32>,
+    mut visible_tree: Local<Coords>,
     time: Res<Time>,
-    state: Res<State<Coords>>,
-    mut next_state: ResMut<NextState<Coords>>,
+    mut coords_style_query: Query<(&Coords, &mut Style)>,
 ) {
-    *timer += time.delta_seconds();
-    if 1. <= *timer {
-        *timer = 0.;
-        next_state.set(if *state.get() == Coords::Viewport {
-            Coords::Pixel
-        } else {
-            Coords::Viewport
-        });
+    *timer -= time.delta_seconds();
+    if *timer <= 0. {
+        *timer = 1.;
+        *visible_tree = match *visible_tree {
+            Coords::Viewport => Coords::Pixel,
+            Coords::Pixel => Coords::Viewport,
+        };
+        for (coords, mut style) in coords_style_query.iter_mut() {
+            style.display = if *coords == *visible_tree {
+                Display::Flex
+            } else {
+                Display::None
+            };
+        }
     }
 }
 
 fn setup(mut commands: Commands) {
     commands.spawn(Camera2dBundle::default());
+    spawn_with_viewport_coords(&mut commands);
+    spawn_with_pixel_coords(&mut commands);
 }
 
-fn spawn_with_viewport_coords(mut commands: Commands) {
+fn spawn_with_viewport_coords(commands: &mut Commands) {
     commands
-        .spawn(NodeBundle {
-            style: Style {
-                width: Val::Vw(100.),
-                height: Val::Vh(100.),
-                border: UiRect::axes(Val::Vw(5.), Val::Vh(5.)),
-                flex_wrap: FlexWrap::Wrap,
+        .spawn((
+            NodeBundle {
+                style: Style {
+                    width: Val::Vw(100.),
+                    height: Val::Vh(100.),
+                    border: UiRect::axes(Val::Vw(5.), Val::Vh(5.)),
+                    flex_wrap: FlexWrap::Wrap,
+                    ..default()
+                },
+                border_color: PALETTE[0].into(),
                 ..default()
             },
-            background_color: PALETTE[0].into(),
-            border_color: PALETTE[1].into(),
-            ..default()
-        })
+            Coords::Viewport,
+        ))
         .with_children(|builder| {
             builder.spawn(NodeBundle {
                 style: Style {
@@ -155,20 +159,22 @@ fn spawn_with_viewport_coords(mut commands: Commands) {
         });
 }
 
-fn spawn_with_pixel_coords(mut commands: Commands) {
+fn spawn_with_pixel_coords(commands: &mut Commands) {
     commands
-        .spawn(NodeBundle {
-            style: Style {
-                width: Val::Px(800.),
-                height: Val::Px(600.),
-                border: UiRect::axes(Val::Px(40.), Val::Px(30.)),
-                flex_wrap: FlexWrap::Wrap,
+        .spawn((
+            NodeBundle {
+                style: Style {
+                    width: Val::Px(800.),
+                    height: Val::Px(600.),
+                    border: UiRect::axes(Val::Px(40.), Val::Px(30.)),
+                    flex_wrap: FlexWrap::Wrap,
+                    ..default()
+                },
+                border_color: PALETTE[1].into(),
                 ..default()
             },
-            background_color: PALETTE[1].into(),
-            border_color: PALETTE[0].into(),
-            ..default()
-        })
+            Coords::Pixel,
+        ))
         .with_children(|builder| {
             builder.spawn(NodeBundle {
                 style: Style {

From d96933ad9cfc492767ce4f2a0fd239ee109e0375 Mon Sep 17 00:00:00 2001
From: Gino Valente <49806985+MrGVSV@users.noreply.github.com>
Date: Thu, 6 Jul 2023 14:04:26 -0700
Subject: [PATCH 04/30] bevy_scene: Add `SceneFilter` (#6793)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Objective

Currently, `DynamicScene`s extract all components listed in the given
(or the world's) type registry. This acts as a quasi-filter of sorts.
However, it can be troublesome to use effectively and lacks decent
control.

For example, say you need to serialize only the following component over
the network:

```rust
#[derive(Reflect, Component, Default)]
#[reflect(Component)]
struct NPC {
  name: Option<String>
}
```

To do this, you'd need to:
1. Create a new `AppTypeRegistry`
2. Register `NPC`
3. Register `Option<String>`

If we skip Step 3, then the entire scene might fail to serialize as
`Option<String>` requires registration.

Not only is this annoying and easy to forget, but it can leave users
with an impossible task: serializing a third-party type that contains
private types.

Generally, the third-party crate will register their private types
within a plugin so the user doesn't need to do it themselves. However,
this means we are now unable to serialize _just_ that type— we're forced
to allow everything!

## Solution

Add the `SceneFilter` enum for filtering components to extract.

This filter can be used to optionally allow or deny entire sets of
components/resources. With the `DynamicSceneBuilder`, users have more
control over how their `DynamicScene`s are built.

To only serialize a subset of components, use the `allow` method:
```rust
let scene = builder
  .allow::<ComponentA>()
  .allow::<ComponentB>()
  .extract_entity(entity)
  .build();
```

To serialize everything _but_ a subset of components, use the `deny`
method:
```rust
let scene = builder
  .deny::<ComponentA>()
  .deny::<ComponentB>()
  .extract_entity(entity)
  .build();
```

Or create a custom filter:
```rust
let components = HashSet::from([type_id]);

let filter = SceneFilter::Allowlist(components);
// let filter = SceneFilter::Denylist(components);

let scene = builder
  .with_filter(Some(filter))
  .extract_entity(entity)
  .build();
```

Similar operations exist for resources:

<details>
<summary>View Resource Methods</summary>

To only serialize a subset of resources, use the `allow_resource`
method:
```rust
let scene = builder
  .allow_resource::<ResourceA>()
  .extract_resources()
  .build();
```

To serialize everything _but_ a subset of resources, use the
`deny_resource` method:
```rust
let scene = builder
  .deny_resource::<ResourceA>()
  .extract_resources()
  .build();
```

Or create a custom filter:
```rust
let resources = HashSet::from([type_id]);

let filter = SceneFilter::Allowlist(resources);
// let filter = SceneFilter::Denylist(resources);

let scene = builder
  .with_resource_filter(Some(filter))
  .extract_resources()
  .build();
```

</details>

### Open Questions

- [x] ~~`allow` and `deny` are mutually exclusive. Currently, they
overwrite each other. Should this instead be a panic?~~ Took @soqb's
suggestion and made it so that the opposing method simply removes that
type from the list.
- [x] ~~`DynamicSceneBuilder` extracts entity data as soon as
`extract_entity`/`extract_entities` is called. Should this behavior
instead be moved to the `build` method to prevent ordering mixups (e.g.
`.allow::<Foo>().extract_entity(entity)` vs
`.extract_entity(entity).allow::<Foo>()`)? The tradeoff would be
iterating over the given entities twice: once at extraction and again at
build.~~ Based on the feedback from @Testare it sounds like it might be
better to just keep the current functionality (if anything we can open a
separate PR that adds deferred methods for extraction, so the
choice/performance hit is up to the user).
- [ ] An alternative might be to remove the filter from
`DynamicSceneBuilder` and have it as a separate parameter to the
extraction methods (either in the existing ones or as added
`extract_entity_with_filter`-type methods). Is this preferable?
- [x] ~~Should we include constructors that include common types to
allow/deny? For example, a `SceneFilter::standard_allowlist` that
includes things like `Parent` and `Children`?~~ Consensus suggests we
should. I may split this out into a followup PR, though.
- [x] ~~Should we add the ability to remove types from the filter
regardless of whether an allowlist or denylist (e.g.
`filter.remove::<Foo>()`)?~~ See the first list item
- [x] ~~Should `SceneFilter` be an enum? Would it make more sense as a
struct that contains an `is_denylist` boolean?~~ With the added
`SceneFilter::None` state (replacing the need to wrap in an `Option` or
rely on an empty `Denylist`), it seems an enum is better suited now
- [x] ~~Bikeshed: Do we like the naming convention? Should we instead
use `include`/`exclude` terminology?~~ Sounds like we're sticking with
`allow`/`deny`!
- [x] ~~Does this feature need a new example? Do we simply include it in
the existing one (maybe even as a comment?)? Should this be done in a
followup PR instead?~~ Example will be added in a followup PR

### Followup Tasks

- [ ] Add a dedicated `SceneFilter` example
- [ ] Possibly add default types to the filter (e.g. deny things like
`ComputedVisibility`, allow `Parent`, etc)

---

## Changelog

- Added the `SceneFilter` enum for filtering components and resources
when building a `DynamicScene`
- Added methods:
  - `DynamicSceneBuilder::with_filter`
  - `DynamicSceneBuilder::allow`
  - `DynamicSceneBuilder::deny`
  - `DynamicSceneBuilder::allow_all`
  - `DynamicSceneBuilder::deny_all`
  - `DynamicSceneBuilder::with_resource_filter`
  - `DynamicSceneBuilder::allow_resource`
  - `DynamicSceneBuilder::deny_resource`
  - `DynamicSceneBuilder::allow_all_resources`
  - `DynamicSceneBuilder::deny_all_resources`
- Removed methods:
  - `DynamicSceneBuilder::from_world_with_type_registry`
- `DynamicScene::from_scene` and `DynamicScene::from_world` no longer
require an `AppTypeRegistry` reference

## Migration Guide

- `DynamicScene::from_scene` and `DynamicScene::from_world` no longer
require an `AppTypeRegistry` reference:
  ```rust
  // OLD
  let registry = world.resource::<AppTypeRegistry>();
  let dynamic_scene = DynamicScene::from_world(&world, registry);
  // let dynamic_scene = DynamicScene::from_scene(&scene, registry);

  // NEW
  let dynamic_scene = DynamicScene::from_world(&world);
  // let dynamic_scene = DynamicScene::from_scene(&scene);
  ```

- Removed `DynamicSceneBuilder::from_world_with_type_registry`. Now the
registry is automatically taken from the given world:
  ```rust
  // OLD
  let registry = world.resource::<AppTypeRegistry>();
let builder = DynamicSceneBuilder::from_world_with_type_registry(&world,
registry);

  // NEW
  let builder = DynamicSceneBuilder::from_world(&world);
  ```
---
 crates/bevy_scene/src/dynamic_scene.rs        |   9 +-
 .../bevy_scene/src/dynamic_scene_builder.rs   | 281 ++++++++++++++++--
 crates/bevy_scene/src/lib.rs                  |   5 +-
 crates/bevy_scene/src/scene_filter.rs         | 278 +++++++++++++++++
 crates/bevy_scene/src/serde.rs                |  26 +-
 examples/scene/scene.rs                       |  20 +-
 6 files changed, 571 insertions(+), 48 deletions(-)
 create mode 100644 crates/bevy_scene/src/scene_filter.rs

diff --git a/crates/bevy_scene/src/dynamic_scene.rs b/crates/bevy_scene/src/dynamic_scene.rs
index 0ec7c99eca92d5..6ede5728342834 100644
--- a/crates/bevy_scene/src/dynamic_scene.rs
+++ b/crates/bevy_scene/src/dynamic_scene.rs
@@ -45,14 +45,13 @@ pub struct DynamicEntity {
 
 impl DynamicScene {
     /// Create a new dynamic scene from a given scene.
-    pub fn from_scene(scene: &Scene, type_registry: &AppTypeRegistry) -> Self {
-        Self::from_world(&scene.world, type_registry)
+    pub fn from_scene(scene: &Scene) -> Self {
+        Self::from_world(&scene.world)
     }
 
     /// Create a new dynamic scene from a given world.
-    pub fn from_world(world: &World, type_registry: &AppTypeRegistry) -> Self {
-        let mut builder =
-            DynamicSceneBuilder::from_world_with_type_registry(world, type_registry.clone());
+    pub fn from_world(world: &World) -> Self {
+        let mut builder = DynamicSceneBuilder::from_world(world);
 
         builder.extract_entities(world.iter_entities().map(|entity| entity.id()));
         builder.extract_resources();
diff --git a/crates/bevy_scene/src/dynamic_scene_builder.rs b/crates/bevy_scene/src/dynamic_scene_builder.rs
index 484262ba18dd9c..62e5a3ed1f348b 100644
--- a/crates/bevy_scene/src/dynamic_scene_builder.rs
+++ b/crates/bevy_scene/src/dynamic_scene_builder.rs
@@ -1,5 +1,6 @@
-use crate::{DynamicEntity, DynamicScene};
-use bevy_ecs::component::ComponentId;
+use crate::{DynamicEntity, DynamicScene, SceneFilter};
+use bevy_ecs::component::{Component, ComponentId};
+use bevy_ecs::system::Resource;
 use bevy_ecs::{
     prelude::Entity,
     reflect::{AppTypeRegistry, ReflectComponent, ReflectResource},
@@ -11,9 +12,27 @@ use std::collections::BTreeMap;
 
 /// A [`DynamicScene`] builder, used to build a scene from a [`World`] by extracting some entities and resources.
 ///
+/// # Component Extraction
+///
+/// By default, all components registered with [`ReflectComponent`] type data in a world's [`AppTypeRegistry`] will be extracted.
+/// (this type data is added automatically during registration if [`Reflect`] is derived with the `#[reflect(Component)]` attribute).
+/// This can be changed by [specifying a filter](DynamicSceneBuilder::with_filter) or by explicitly
+/// [allowing](DynamicSceneBuilder::allow)/[denying](DynamicSceneBuilder::deny) certain components.
+///
+/// Extraction happens immediately and uses the filter as it exists during the time of extraction.
+///
+/// # Resource Extraction
+///
+/// By default, all resources registered with [`ReflectResource`] type data in a world's [`AppTypeRegistry`] will be extracted.
+/// (this type data is added automatically during registration if [`Reflect`] is derived with the `#[reflect(Resource)]` attribute).
+/// This can be changed by [specifying a filter](DynamicSceneBuilder::with_resource_filter) or by explicitly
+/// [allowing](DynamicSceneBuilder::allow_resource)/[denying](DynamicSceneBuilder::deny_resource) certain resources.
+///
+/// Extraction happens immediately and uses the filter as it exists during the time of extraction.
+///
 /// # Entity Order
 ///
-/// Extracted entities will always be stored in ascending order based on their [id](Entity::index).
+/// Extracted entities will always be stored in ascending order based on their [index](Entity::index).
 /// This means that inserting `Entity(1v0)` then `Entity(0v0)` will always result in the entities
 /// being ordered as `[Entity(0v0), Entity(1v0)]`.
 ///
@@ -38,31 +57,117 @@ use std::collections::BTreeMap;
 pub struct DynamicSceneBuilder<'w> {
     extracted_resources: BTreeMap<ComponentId, Box<dyn Reflect>>,
     extracted_scene: BTreeMap<Entity, DynamicEntity>,
-    type_registry: AppTypeRegistry,
+    component_filter: SceneFilter,
+    resource_filter: SceneFilter,
     original_world: &'w World,
 }
 
 impl<'w> DynamicSceneBuilder<'w> {
     /// Prepare a builder that will extract entities and their component from the given [`World`].
-    /// All components registered in that world's [`AppTypeRegistry`] resource will be extracted.
     pub fn from_world(world: &'w World) -> Self {
         Self {
             extracted_resources: default(),
             extracted_scene: default(),
-            type_registry: world.resource::<AppTypeRegistry>().clone(),
+            component_filter: SceneFilter::default(),
+            resource_filter: SceneFilter::default(),
             original_world: world,
         }
     }
 
-    /// Prepare a builder that will extract entities and their component from the given [`World`].
-    /// Only components registered in the given [`AppTypeRegistry`] will be extracted.
-    pub fn from_world_with_type_registry(world: &'w World, type_registry: AppTypeRegistry) -> Self {
-        Self {
-            extracted_resources: default(),
-            extracted_scene: default(),
-            type_registry,
-            original_world: world,
-        }
+    /// Specify a custom component [`SceneFilter`] to be used with this builder.
+    pub fn with_filter(&mut self, filter: SceneFilter) -> &mut Self {
+        self.component_filter = filter;
+        self
+    }
+
+    /// Specify a custom resource [`SceneFilter`] to be used with this builder.
+    pub fn with_resource_filter(&mut self, filter: SceneFilter) -> &mut Self {
+        self.resource_filter = filter;
+        self
+    }
+
+    /// Allows the given component type, `T`, to be included in the generated scene.
+    ///
+    /// This method may be called multiple times for any number of components.
+    ///
+    /// This is the inverse of [`deny`](Self::deny).
+    /// If `T` has already been denied, then it will be removed from the denylist.
+    pub fn allow<T: Component>(&mut self) -> &mut Self {
+        self.component_filter.allow::<T>();
+        self
+    }
+
+    /// Denies the given component type, `T`, from being included in the generated scene.
+    ///
+    /// This method may be called multiple times for any number of components.
+    ///
+    /// This is the inverse of [`allow`](Self::allow).
+    /// If `T` has already been allowed, then it will be removed from the allowlist.
+    pub fn deny<T: Component>(&mut self) -> &mut Self {
+        self.component_filter.deny::<T>();
+        self
+    }
+
+    /// Updates the filter to allow all component types.
+    ///
+    /// This is useful for resetting the filter so that types may be selectively [denied].
+    ///
+    /// [denied]: Self::deny
+    pub fn allow_all(&mut self) -> &mut Self {
+        self.component_filter = SceneFilter::allow_all();
+        self
+    }
+
+    /// Updates the filter to deny all component types.
+    ///
+    /// This is useful for resetting the filter so that types may be selectively [allowed].
+    ///
+    /// [allowed]: Self::allow
+    pub fn deny_all(&mut self) -> &mut Self {
+        self.component_filter = SceneFilter::deny_all();
+        self
+    }
+
+    /// Allows the given resource type, `T`, to be included in the generated scene.
+    ///
+    /// This method may be called multiple times for any number of resources.
+    ///
+    /// This is the inverse of [`deny_resource`](Self::deny_resource).
+    /// If `T` has already been denied, then it will be removed from the denylist.
+    pub fn allow_resource<T: Resource>(&mut self) -> &mut Self {
+        self.resource_filter.allow::<T>();
+        self
+    }
+
+    /// Denies the given resource type, `T`, from being included in the generated scene.
+    ///
+    /// This method may be called multiple times for any number of resources.
+    ///
+    /// This is the inverse of [`allow_resource`](Self::allow_resource).
+    /// If `T` has already been allowed, then it will be removed from the allowlist.
+    pub fn deny_resource<T: Resource>(&mut self) -> &mut Self {
+        self.resource_filter.deny::<T>();
+        self
+    }
+
+    /// Updates the filter to allow all resource types.
+    ///
+    /// This is useful for resetting the filter so that types may be selectively [denied].
+    ///
+    /// [denied]: Self::deny_resource
+    pub fn allow_all_resources(&mut self) -> &mut Self {
+        self.resource_filter = SceneFilter::allow_all();
+        self
+    }
+
+    /// Updates the filter to deny all resource types.
+    ///
+    /// This is useful for resetting the filter so that types may be selectively [allowed].
+    ///
+    /// [allowed]: Self::allow_resource
+    pub fn deny_all_resources(&mut self) -> &mut Self {
+        self.resource_filter = SceneFilter::deny_all();
+        self
     }
 
     /// Consume the builder, producing a [`DynamicScene`].
@@ -97,7 +202,10 @@ impl<'w> DynamicSceneBuilder<'w> {
     ///
     /// Re-extracting an entity that was already extracted will have no effect.
     ///
-    /// Extracting entities can be used to extract entities from a query:
+    /// To control which components are extracted, use the [`allow`] or
+    /// [`deny`] helper methods.
+    ///
+    /// This method may be used to extract entities from a query:
     /// ```
     /// # use bevy_scene::DynamicSceneBuilder;
     /// # use bevy_ecs::reflect::AppTypeRegistry;
@@ -118,8 +226,13 @@ impl<'w> DynamicSceneBuilder<'w> {
     /// builder.extract_entities(query.iter(&world));
     /// let scene = builder.build();
     /// ```
+    ///
+    /// Note that components extracted from queried entities must still pass through the filter if one is set.
+    ///
+    /// [`allow`]: Self::allow
+    /// [`deny`]: Self::deny
     pub fn extract_entities(&mut self, entities: impl Iterator<Item = Entity>) -> &mut Self {
-        let type_registry = self.type_registry.read();
+        let type_registry = self.original_world.resource::<AppTypeRegistry>().read();
 
         for entity in entities {
             if self.extracted_scene.contains_key(&entity) {
@@ -139,6 +252,14 @@ impl<'w> DynamicSceneBuilder<'w> {
                         .components()
                         .get_info(component_id)?
                         .type_id()?;
+
+                    let is_denied = self.component_filter.is_denied_by_id(type_id);
+
+                    if is_denied {
+                        // Component is either in the denylist or _not_ in the allowlist
+                        return None;
+                    }
+
                     let component = type_registry
                         .get(type_id)?
                         .data::<ReflectComponent>()?
@@ -151,14 +272,16 @@ impl<'w> DynamicSceneBuilder<'w> {
             self.extracted_scene.insert(entity, entry);
         }
 
-        drop(type_registry);
         self
     }
 
     /// Extract resources from the builder's [`World`].
     ///
-    /// Only resources registered in the builder's [`AppTypeRegistry`] will be extracted.
     /// Re-extracting a resource that was already extracted will have no effect.
+    ///
+    /// To control which resources are extracted, use the [`allow_resource`] or
+    /// [`deny_resource`] helper methods.
+    ///
     /// ```
     /// # use bevy_scene::DynamicSceneBuilder;
     /// # use bevy_ecs::reflect::AppTypeRegistry;
@@ -176,8 +299,12 @@ impl<'w> DynamicSceneBuilder<'w> {
     /// builder.extract_resources();
     /// let scene = builder.build();
     /// ```
+    ///
+    /// [`allow_resource`]: Self::allow_resource
+    /// [`deny_resource`]: Self::deny_resource
     pub fn extract_resources(&mut self) -> &mut Self {
-        let type_registry = self.type_registry.read();
+        let type_registry = self.original_world.resource::<AppTypeRegistry>().read();
+
         for (component_id, _) in self.original_world.storages().resources.iter() {
             let mut extract_and_push = || {
                 let type_id = self
@@ -185,6 +312,14 @@ impl<'w> DynamicSceneBuilder<'w> {
                     .components()
                     .get_info(component_id)?
                     .type_id()?;
+
+                let is_denied = self.resource_filter.is_denied_by_id(type_id);
+
+                if is_denied {
+                    // Resource is either in the denylist or _not_ in the allowlist
+                    return None;
+                }
+
                 let resource = type_registry
                     .get(type_id)?
                     .data::<ReflectResource>()?
@@ -225,6 +360,10 @@ mod tests {
     #[reflect(Resource)]
     struct ResourceA;
 
+    #[derive(Resource, Reflect, Default, Eq, PartialEq, Debug)]
+    #[reflect(Resource)]
+    struct ResourceB;
+
     #[test]
     fn extract_one_entity() {
         let mut world = World::default();
@@ -401,4 +540,106 @@ mod tests {
         assert_eq!(scene.resources.len(), 1);
         assert!(scene.resources[0].represents::<ResourceA>());
     }
+
+    #[test]
+    fn should_extract_allowed_components() {
+        let mut world = World::default();
+
+        let atr = AppTypeRegistry::default();
+        {
+            let mut register = atr.write();
+            register.register::<ComponentA>();
+            register.register::<ComponentB>();
+        }
+        world.insert_resource(atr);
+
+        let entity_a_b = world.spawn((ComponentA, ComponentB)).id();
+        let entity_a = world.spawn(ComponentA).id();
+        let entity_b = world.spawn(ComponentB).id();
+
+        let mut builder = DynamicSceneBuilder::from_world(&world);
+        builder
+            .allow::<ComponentA>()
+            .extract_entities([entity_a_b, entity_a, entity_b].into_iter());
+        let scene = builder.build();
+
+        assert_eq!(scene.entities.len(), 3);
+        assert!(scene.entities[0].components[0].represents::<ComponentA>());
+        assert!(scene.entities[1].components[0].represents::<ComponentA>());
+        assert_eq!(scene.entities[2].components.len(), 0);
+    }
+
+    #[test]
+    fn should_not_extract_denied_components() {
+        let mut world = World::default();
+
+        let atr = AppTypeRegistry::default();
+        {
+            let mut register = atr.write();
+            register.register::<ComponentA>();
+            register.register::<ComponentB>();
+        }
+        world.insert_resource(atr);
+
+        let entity_a_b = world.spawn((ComponentA, ComponentB)).id();
+        let entity_a = world.spawn(ComponentA).id();
+        let entity_b = world.spawn(ComponentB).id();
+
+        let mut builder = DynamicSceneBuilder::from_world(&world);
+        builder
+            .deny::<ComponentA>()
+            .extract_entities([entity_a_b, entity_a, entity_b].into_iter());
+        let scene = builder.build();
+
+        assert_eq!(scene.entities.len(), 3);
+        assert!(scene.entities[0].components[0].represents::<ComponentB>());
+        assert_eq!(scene.entities[1].components.len(), 0);
+        assert!(scene.entities[2].components[0].represents::<ComponentB>());
+    }
+
+    #[test]
+    fn should_extract_allowed_resources() {
+        let mut world = World::default();
+
+        let atr = AppTypeRegistry::default();
+        {
+            let mut register = atr.write();
+            register.register::<ResourceA>();
+            register.register::<ResourceB>();
+        }
+        world.insert_resource(atr);
+
+        world.insert_resource(ResourceA);
+        world.insert_resource(ResourceB);
+
+        let mut builder = DynamicSceneBuilder::from_world(&world);
+        builder.allow_resource::<ResourceA>().extract_resources();
+        let scene = builder.build();
+
+        assert_eq!(scene.resources.len(), 1);
+        assert!(scene.resources[0].represents::<ResourceA>());
+    }
+
+    #[test]
+    fn should_not_extract_denied_resources() {
+        let mut world = World::default();
+
+        let atr = AppTypeRegistry::default();
+        {
+            let mut register = atr.write();
+            register.register::<ResourceA>();
+            register.register::<ResourceB>();
+        }
+        world.insert_resource(atr);
+
+        world.insert_resource(ResourceA);
+        world.insert_resource(ResourceB);
+
+        let mut builder = DynamicSceneBuilder::from_world(&world);
+        builder.deny_resource::<ResourceA>().extract_resources();
+        let scene = builder.build();
+
+        assert_eq!(scene.resources.len(), 1);
+        assert!(scene.resources[0].represents::<ResourceB>());
+    }
 }
diff --git a/crates/bevy_scene/src/lib.rs b/crates/bevy_scene/src/lib.rs
index 4185d1886285c1..e3ca8a2fee5739 100644
--- a/crates/bevy_scene/src/lib.rs
+++ b/crates/bevy_scene/src/lib.rs
@@ -4,6 +4,7 @@ mod bundle;
 mod dynamic_scene;
 mod dynamic_scene_builder;
 mod scene;
+mod scene_filter;
 mod scene_loader;
 mod scene_spawner;
 
@@ -14,13 +15,15 @@ pub use bundle::*;
 pub use dynamic_scene::*;
 pub use dynamic_scene_builder::*;
 pub use scene::*;
+pub use scene_filter::*;
 pub use scene_loader::*;
 pub use scene_spawner::*;
 
 pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
-        DynamicScene, DynamicSceneBuilder, DynamicSceneBundle, Scene, SceneBundle, SceneSpawner,
+        DynamicScene, DynamicSceneBuilder, DynamicSceneBundle, Scene, SceneBundle, SceneFilter,
+        SceneSpawner,
     };
 }
 
diff --git a/crates/bevy_scene/src/scene_filter.rs b/crates/bevy_scene/src/scene_filter.rs
new file mode 100644
index 00000000000000..a5076e5d9d668b
--- /dev/null
+++ b/crates/bevy_scene/src/scene_filter.rs
@@ -0,0 +1,278 @@
+use bevy_utils::hashbrown::hash_set::IntoIter;
+use bevy_utils::HashSet;
+use std::any::{Any, TypeId};
+
+/// A filter used to control which types can be added to a [`DynamicScene`].
+///
+/// This scene filter _can_ be used more generically to represent a filter for any given type;
+/// however, note that its intended usage with `DynamicScene` only considers [components] and [resources].
+/// Adding types that are not a component or resource will have no effect when used with `DynamicScene`.
+///
+/// [`DynamicScene`]: crate::DynamicScene
+/// [components]: bevy_ecs::prelude::Component
+/// [resources]: bevy_ecs::prelude::Resource
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub enum SceneFilter {
+    /// Represents an unset filter.
+    ///
+    /// This is the equivalent of an empty [`Denylist`] or an [`Allowlist`] containing every type—
+    /// essentially, all types are permissible.
+    ///
+    /// [Allowing] a type will convert this filter to an `Allowlist`.
+    /// Similarly, [denying] a type will convert this filter to a `Denylist`.
+    ///
+    /// [`Denylist`]: SceneFilter::Denylist
+    /// [`Allowlist`]: SceneFilter::Allowlist
+    /// [Allowing]: SceneFilter::allow
+    /// [denying]: SceneFilter::deny
+    #[default]
+    Unset,
+    /// Contains the set of permitted types by their [`TypeId`].
+    ///
+    /// Types not contained within this set should not be allowed to be saved to an associated [`DynamicScene`].
+    ///
+    /// [`DynamicScene`]: crate::DynamicScene
+    Allowlist(HashSet<TypeId>),
+    /// Contains the set of prohibited types by their [`TypeId`].
+    ///
+    /// Types contained within this set should not be allowed to be saved to an associated [`DynamicScene`].
+    ///
+    /// [`DynamicScene`]: crate::DynamicScene
+    Denylist(HashSet<TypeId>),
+}
+
+impl SceneFilter {
+    /// Creates a filter where all types are allowed.
+    ///
+    /// This is the equivalent of creating an empty [`Denylist`].
+    ///
+    /// [`Denylist`]: SceneFilter::Denylist
+    pub fn allow_all() -> Self {
+        Self::Denylist(HashSet::new())
+    }
+
+    /// Creates a filter where all types are denied.
+    ///
+    /// This is the equivalent of creating an empty [`Allowlist`].
+    ///
+    /// [`Allowlist`]: SceneFilter::Allowlist
+    pub fn deny_all() -> Self {
+        Self::Allowlist(HashSet::new())
+    }
+
+    /// Allow the given type, `T`.
+    ///
+    /// If this filter is already set as a [`Denylist`],
+    /// then the given type will be removed from the denied set.
+    ///
+    /// If this filter is [`Unset`], then it will be completely replaced by a new [`Allowlist`].
+    ///
+    /// [`Denylist`]: SceneFilter::Denylist
+    /// [`Unset`]: SceneFilter::Unset
+    /// [`Allowlist`]: SceneFilter::Allowlist
+    pub fn allow<T: Any>(&mut self) -> &mut Self {
+        self.allow_by_id(TypeId::of::<T>())
+    }
+
+    /// Allow the given type.
+    ///
+    /// If this filter is already set as a [`Denylist`],
+    /// then the given type will be removed from the denied set.
+    ///
+    /// If this filter is [`Unset`], then it will be completely replaced by a new [`Allowlist`].
+    ///
+    /// [`Denylist`]: SceneFilter::Denylist
+    /// [`Unset`]: SceneFilter::Unset
+    /// [`Allowlist`]: SceneFilter::Allowlist
+    pub fn allow_by_id(&mut self, type_id: TypeId) -> &mut Self {
+        match self {
+            Self::Unset => {
+                *self = Self::Allowlist(HashSet::from([type_id]));
+            }
+            Self::Allowlist(list) => {
+                list.insert(type_id);
+            }
+            Self::Denylist(list) => {
+                list.remove(&type_id);
+            }
+        }
+        self
+    }
+
+    /// Deny the given type, `T`.
+    ///
+    /// If this filter is already set as an [`Allowlist`],
+    /// then the given type will be removed from the allowed set.
+    ///
+    /// If this filter is [`Unset`], then it will be completely replaced by a new [`Denylist`].
+    ///
+    /// [`Allowlist`]: SceneFilter::Allowlist
+    /// [`Unset`]: SceneFilter::Unset
+    /// [`Denylist`]: SceneFilter::Denylist
+    pub fn deny<T: Any>(&mut self) -> &mut Self {
+        self.deny_by_id(TypeId::of::<T>())
+    }
+
+    /// Deny the given type.
+    ///
+    /// If this filter is already set as an [`Allowlist`],
+    /// then the given type will be removed from the allowed set.
+    ///
+    /// If this filter is [`Unset`], then it will be completely replaced by a new [`Denylist`].
+    ///
+    /// [`Allowlist`]: SceneFilter::Allowlist
+    /// [`Unset`]: SceneFilter::Unset
+    /// [`Denylist`]: SceneFilter::Denylist
+    pub fn deny_by_id(&mut self, type_id: TypeId) -> &mut Self {
+        match self {
+            Self::Unset => *self = Self::Denylist(HashSet::from([type_id])),
+            Self::Allowlist(list) => {
+                list.remove(&type_id);
+            }
+            Self::Denylist(list) => {
+                list.insert(type_id);
+            }
+        }
+        self
+    }
+
+    /// Returns true if the given type, `T`, is allowed by the filter.
+    ///
+    /// If the filter is [`Unset`], this will always return `true`.
+    ///
+    /// [`Unset`]: SceneFilter::Unset
+    pub fn is_allowed<T: Any>(&self) -> bool {
+        self.is_allowed_by_id(TypeId::of::<T>())
+    }
+
+    /// Returns true if the given type is allowed by the filter.
+    ///
+    /// If the filter is [`Unset`], this will always return `true`.
+    ///
+    /// [`Unset`]: SceneFilter::Unset
+    pub fn is_allowed_by_id(&self, type_id: TypeId) -> bool {
+        match self {
+            Self::Unset => true,
+            Self::Allowlist(list) => list.contains(&type_id),
+            Self::Denylist(list) => !list.contains(&type_id),
+        }
+    }
+
+    /// Returns true if the given type, `T`, is denied by the filter.
+    ///
+    /// If the filter is [`Unset`], this will always return `false`.
+    ///
+    /// [`Unset`]: SceneFilter::Unset
+    pub fn is_denied<T: Any>(&self) -> bool {
+        self.is_denied_by_id(TypeId::of::<T>())
+    }
+
+    /// Returns true if the given type is denied by the filter.
+    ///
+    /// If the filter is [`Unset`], this will always return `false`.
+    ///
+    /// [`Unset`]: SceneFilter::Unset
+    pub fn is_denied_by_id(&self, type_id: TypeId) -> bool {
+        !self.is_allowed_by_id(type_id)
+    }
+
+    /// Returns an iterator over the items in the filter.
+    ///
+    /// If the filter is [`Unset`], this will return an empty iterator.
+    ///
+    /// [`Unset`]: SceneFilter::Unset
+    pub fn iter(&self) -> Box<dyn ExactSizeIterator<Item = &TypeId> + '_> {
+        match self {
+            Self::Unset => Box::new(core::iter::empty()),
+            Self::Allowlist(list) | Self::Denylist(list) => Box::new(list.iter()),
+        }
+    }
+
+    /// Returns the number of items in the filter.
+    ///
+    /// If the filter is [`Unset`], this will always return a length of zero.
+    ///
+    /// [`Unset`]: SceneFilter::Unset
+    pub fn len(&self) -> usize {
+        match self {
+            Self::Unset => 0,
+            Self::Allowlist(list) | Self::Denylist(list) => list.len(),
+        }
+    }
+
+    /// Returns true if there are zero items in the filter.
+    ///
+    /// If the filter is [`Unset`], this will always return `true`.
+    ///
+    /// [`Unset`]: SceneFilter::Unset
+    pub fn is_empty(&self) -> bool {
+        match self {
+            Self::Unset => true,
+            Self::Allowlist(list) | Self::Denylist(list) => list.is_empty(),
+        }
+    }
+}
+
+impl IntoIterator for SceneFilter {
+    type Item = TypeId;
+    type IntoIter = IntoIter<TypeId>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        match self {
+            Self::Unset => HashSet::new().into_iter(),
+            Self::Allowlist(list) | Self::Denylist(list) => list.into_iter(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn should_set_list_type_if_none() {
+        let mut filter = SceneFilter::Unset;
+        filter.allow::<i32>();
+        assert!(matches!(filter, SceneFilter::Allowlist(_)));
+
+        let mut filter = SceneFilter::Unset;
+        filter.deny::<i32>();
+        assert!(matches!(filter, SceneFilter::Denylist(_)));
+    }
+
+    #[test]
+    fn should_add_to_list() {
+        let mut filter = SceneFilter::default();
+        filter.allow::<i16>();
+        filter.allow::<i32>();
+        assert_eq!(2, filter.len());
+        assert!(filter.is_allowed::<i16>());
+        assert!(filter.is_allowed::<i32>());
+
+        let mut filter = SceneFilter::default();
+        filter.deny::<i16>();
+        filter.deny::<i32>();
+        assert_eq!(2, filter.len());
+        assert!(filter.is_denied::<i16>());
+        assert!(filter.is_denied::<i32>());
+    }
+
+    #[test]
+    fn should_remove_from_list() {
+        let mut filter = SceneFilter::default();
+        filter.allow::<i16>();
+        filter.allow::<i32>();
+        filter.deny::<i32>();
+        assert_eq!(1, filter.len());
+        assert!(filter.is_allowed::<i16>());
+        assert!(!filter.is_allowed::<i32>());
+
+        let mut filter = SceneFilter::default();
+        filter.deny::<i16>();
+        filter.deny::<i32>();
+        filter.allow::<i32>();
+        assert_eq!(1, filter.len());
+        assert!(filter.is_denied::<i16>());
+        assert!(!filter.is_denied::<i32>());
+    }
+}
diff --git a/crates/bevy_scene/src/serde.rs b/crates/bevy_scene/src/serde.rs
index a16a8d8957543b..492c6ac33077ed 100644
--- a/crates/bevy_scene/src/serde.rs
+++ b/crates/bevy_scene/src/serde.rs
@@ -630,7 +630,7 @@ mod tests {
 
         let registry = world.resource::<AppTypeRegistry>();
 
-        let scene = DynamicScene::from_world(&world, registry);
+        let scene = DynamicScene::from_world(&world);
 
         let serialized = scene
             .serialize_ron(&world.resource::<AppTypeRegistry>().0)
@@ -680,7 +680,7 @@ mod tests {
 
         let registry = world.resource::<AppTypeRegistry>();
 
-        let scene = DynamicScene::from_world(&world, registry);
+        let scene = DynamicScene::from_world(&world);
 
         let scene_serializer = SceneSerializer::new(&scene, &registry.0);
         let serialized_scene = postcard::to_allocvec(&scene_serializer).unwrap();
@@ -718,7 +718,7 @@ mod tests {
 
         let registry = world.resource::<AppTypeRegistry>();
 
-        let scene = DynamicScene::from_world(&world, registry);
+        let scene = DynamicScene::from_world(&world);
 
         let scene_serializer = SceneSerializer::new(&scene, &registry.0);
         let mut buf = Vec::new();
@@ -761,7 +761,7 @@ mod tests {
 
         let registry = world.resource::<AppTypeRegistry>();
 
-        let scene = DynamicScene::from_world(&world, registry);
+        let scene = DynamicScene::from_world(&world);
 
         let scene_serializer = SceneSerializer::new(&scene, &registry.0);
         let serialized_scene = bincode::serialize(&scene_serializer).unwrap();
@@ -835,8 +835,7 @@ mod tests {
         #[should_panic(expected = "entity count did not match")]
         fn should_panic_when_entity_count_not_eq() {
             let mut world = create_world();
-            let registry = world.resource::<AppTypeRegistry>();
-            let scene_a = DynamicScene::from_world(&world, registry);
+            let scene_a = DynamicScene::from_world(&world);
 
             world.spawn(MyComponent {
                 foo: [1, 2, 3],
@@ -844,8 +843,7 @@ mod tests {
                 baz: MyEnum::Unit,
             });
 
-            let registry = world.resource::<AppTypeRegistry>();
-            let scene_b = DynamicScene::from_world(&world, registry);
+            let scene_b = DynamicScene::from_world(&world);
 
             assert_scene_eq(&scene_a, &scene_b);
         }
@@ -863,8 +861,7 @@ mod tests {
                 })
                 .id();
 
-            let registry = world.resource::<AppTypeRegistry>();
-            let scene_a = DynamicScene::from_world(&world, registry);
+            let scene_a = DynamicScene::from_world(&world);
 
             world.entity_mut(entity).insert(MyComponent {
                 foo: [3, 2, 1],
@@ -872,8 +869,7 @@ mod tests {
                 baz: MyEnum::Unit,
             });
 
-            let registry = world.resource::<AppTypeRegistry>();
-            let scene_b = DynamicScene::from_world(&world, registry);
+            let scene_b = DynamicScene::from_world(&world);
 
             assert_scene_eq(&scene_a, &scene_b);
         }
@@ -891,13 +887,11 @@ mod tests {
                 })
                 .id();
 
-            let registry = world.resource::<AppTypeRegistry>();
-            let scene_a = DynamicScene::from_world(&world, registry);
+            let scene_a = DynamicScene::from_world(&world);
 
             world.entity_mut(entity).remove::<MyComponent>();
 
-            let registry = world.resource::<AppTypeRegistry>();
-            let scene_b = DynamicScene::from_world(&world, registry);
+            let scene_b = DynamicScene::from_world(&world);
 
             assert_scene_eq(&scene_a, &scene_b);
         }
diff --git a/examples/scene/scene.rs b/examples/scene/scene.rs
index ad4dd8d3efea21..e4e7b508befa8e 100644
--- a/examples/scene/scene.rs
+++ b/examples/scene/scene.rs
@@ -100,9 +100,18 @@ fn log_system(
 }
 
 fn save_scene_system(world: &mut World) {
-    // Scenes can be created from any ECS World. You can either create a new one for the scene or
-    // use the current World.
+    // Scenes can be created from any ECS World.
+    // You can either create a new one for the scene or use the current World.
+    // For demonstration purposes, we'll create a new one.
     let mut scene_world = World::new();
+
+    // The `TypeRegistry` resource contains information about all registered types (including components).
+    // This is used to construct scenes, so we'll want to ensure that our previous type registrations
+    // exist in this new scene world as well.
+    // To do this, we can simply clone the `AppTypeRegistry` resource.
+    let type_registry = world.resource::<AppTypeRegistry>().clone();
+    scene_world.insert_resource(type_registry);
+
     let mut component_b = ComponentB::from_world(world);
     component_b.value = "hello".to_string();
     scene_world.spawn((
@@ -113,12 +122,11 @@ fn save_scene_system(world: &mut World) {
     scene_world.spawn(ComponentA { x: 3.0, y: 4.0 });
     scene_world.insert_resource(ResourceA { score: 1 });
 
-    // The TypeRegistry resource contains information about all registered types (including
-    // components). This is used to construct scenes.
-    let type_registry = world.resource::<AppTypeRegistry>();
-    let scene = DynamicScene::from_world(&scene_world, type_registry);
+    // With our sample world ready to go, we can now create our scene:
+    let scene = DynamicScene::from_world(&scene_world);
 
     // Scenes can be serialized like this:
+    let type_registry = world.resource::<AppTypeRegistry>();
     let serialized_scene = scene.serialize_ron(type_registry).unwrap();
 
     // Showing the scene in the console

From 95ade6d6a036a5f1eae763931811e38433815e1b Mon Sep 17 00:00:00 2001
From: Nolan Darilek <nolan@thewordnerd.info>
Date: Fri, 7 Jul 2023 17:49:53 -0500
Subject: [PATCH 05/30] Bump `accesskit` and `accesskit_winit`. (#8655)

# Objective

`accesskit` and `accesskit_winit` need to be upgraded.

## Solution

Upgrade `accesskit` and `accesskit_winit`.

---

## Changelog

### Changed

* Upgrade accesskit to v0.11.
* Upgrade accesskit_winit to v0.14.
---
 crates/bevy_a11y/Cargo.toml  | 2 +-
 crates/bevy_winit/Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_a11y/Cargo.toml b/crates/bevy_a11y/Cargo.toml
index d4957d89c80de3..4d95f2d14450b7 100644
--- a/crates/bevy_a11y/Cargo.toml
+++ b/crates/bevy_a11y/Cargo.toml
@@ -14,4 +14,4 @@ bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
 bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
 
-accesskit = "0.10"
+accesskit = "0.11"
diff --git a/crates/bevy_winit/Cargo.toml b/crates/bevy_winit/Cargo.toml
index 1851c1db324bed..0b8362127448b7 100644
--- a/crates/bevy_winit/Cargo.toml
+++ b/crates/bevy_winit/Cargo.toml
@@ -29,7 +29,7 @@ bevy_tasks = { path = "../bevy_tasks", version = "0.11.0-dev" }
 
 # other
 winit = { version = "0.28", default-features = false }
-accesskit_winit = { version = "0.12", default-features = false }
+accesskit_winit = { version = "0.14", default-features = false, features = ["async-io"] }
 approx = { version = "0.5", default-features = false }
 raw-window-handle = "0.5"
 

From fb4c21e3e62b3789e8e768ac63dc2205ddec698f Mon Sep 17 00:00:00 2001
From: "Ida \"Iyes" <40234599+inodentry@users.noreply.github.com>
Date: Sat, 8 Jul 2023 02:01:17 +0300
Subject: [PATCH 06/30] bevy_audio: ECS-based API redesign (#8424)

# Objective

Improve the `bevy_audio` API to make it more user-friendly and
ECS-idiomatic. This PR is a first-pass at addressing some of the most
obvious (to me) problems. In the interest of keeping the scope small,
further improvements can be done in future PRs.

The current `bevy_audio` API is very clunky to work with, due to how it
(ab)uses bevy assets to represent audio sinks.

The user needs to write a lot of boilerplate (accessing
`Res<Assets<AudioSink>>`) and deal with a lot of cognitive overhead
(worry about strong vs. weak handles, etc.) in order to control audio
playback.

Audio playback is initiated via a centralized `Audio` resource, which
makes it difficult to keep track of many different sounds playing in a
typical game.

Further, everything carries a generic type parameter for the sound
source type, making it difficult to mix custom sound sources (such as
procedurally generated audio or unofficial formats) with regular audio
assets.

Let's fix these issues.

## Solution

Refactor `bevy_audio` to a more idiomatic ECS API. Remove the `Audio`
resource. Do everything via entities and components instead.

Audio playback data is now stored in components:
- `PlaybackSettings`, `SpatialSettings`, `Handle<AudioSource>` are now
components. The user inserts them to tell Bevy to play a sound and
configure the initial playback parameters.
- `AudioSink`, `SpatialAudioSink` are now components instead of special
magical "asset" types. They are inserted by Bevy when it actually begins
playing the sound, and can be queried for by the user in order to
control the sound during playback.

Bundles: `AudioBundle` and `SpatialAudioBundle` are available to make it
easy for users to play sounds. Spawn an entity with one of these bundles
(or insert them to a complex entity alongside other stuff) to play a
sound.

Each entity represents a sound to be played.

There is also a new "auto-despawn" feature (activated using
`PlaybackSettings`), which, if enabled, tells Bevy to despawn entities
when the sink playback finishes. This allows for "fire-and-forget" sound
playback. Users can simply
spawn entities whenever they want to play sounds and not have to worry
about leaking memory.

## Unsolved Questions

I think the current design is *fine*. I'd be happy for it to be merged.
It has some possibly-surprising usability pitfalls, but I think it is
still much better than the old `bevy_audio`. Here are some discussion
questions for things that we could further improve. I'm undecided on
these questions, which is why I didn't implement them. We should decide
which of these should be addressed in this PR, and what should be left
for future PRs. Or if they should be addressed at all.

### What happens when sounds start playing?

Currently, the audio sink components are inserted and the bundle
components are kept. Should Bevy remove the bundle components? Something
else?

The current design allows an entity to be reused for playing the same
sound with the same parameters repeatedly. This is a niche use case I'd
like to be supported, but if we have to give it up for a simpler design,
I'd be fine with that.

### What happens if users remove any of the components themselves?

As described above, currently, entities can be reused. Removing the
audio sink causes it to be "detached" (I kept the old `Drop` impl), so
the sound keeps playing. However, if the audio bundle components are not
removed, Bevy will detect this entity as a "queued" sound entity again
(has the bundle compoenents, without a sink component), just like before
playing the sound the first time, and start playing the sound again.

This behavior might be surprising? Should we do something different?

### Should mutations to `PlaybackSettings` be applied to the audio sink?

We currently do not do that. `PlaybackSettings` is just for the initial
settings when the sound starts playing. This is clearly documented.

Do we want to keep this behavior, or do we want to allow users to use
`PlaybackSettings` instead of `AudioSink`/`SpatialAudioSink` to control
sounds during playback too?

I think I prefer for them to be kept separate. It is not a bad mental
model once you understand it, and it is documented.

### Should `AudioSink` and `SpatialAudioSink` be unified into a single
component type?

They provide a similar API (via the `AudioSinkPlayback` trait) and it
might be annoying for users to have to deal with both of them. The
unification could be done using an enum that is matched on internally by
the methods. Spatial audio has extra features, so this might make it
harder to access. I think we shouldn't.

### Automatic synchronization of spatial sound properties from
Transforms?

Should Bevy automatically apply changes to Transforms to spatial audio
entities? How do we distinguish between listener and emitter? Which one
does the transform represent? Where should the other one come from?

Alternatively, leave this problem for now, and address it in a future
PR. Or do nothing, and let users deal with it, as shown in the
`spatial_audio_2d` and `spatial_audio_3d` examples.

---

## Changelog

Added:
- `AudioBundle`/`SpatialAudioBundle`, add them to entities to play
sounds.

Removed:
 - The `Audio` resource.
 - `AudioOutput` is no longer `pub`.

Changed:
 - `AudioSink`, `SpatialAudioSink` are now components instead of assets.

## Migration Guide

// TODO: write a more detailed migration guide, after the "unsolved
questions" are answered and this PR is finalized.

Before:

```rust

/// Need to store handles somewhere
#[derive(Resource)]
struct MyMusic {
    sink: Handle<AudioSink>,
}

fn play_music(
    asset_server: Res<AssetServer>,
    audio: Res<Audio>,
    audio_sinks: Res<Assets<AudioSink>>,
    mut commands: Commands,
) {
    let weak_handle = audio.play_with_settings(
        asset_server.load("music.ogg"),
        PlaybackSettings::LOOP.with_volume(0.5),
    );
    // upgrade to strong handle and store it
    commands.insert_resource(MyMusic {
        sink: audio_sinks.get_handle(weak_handle),
    });
}

fn toggle_pause_music(
    audio_sinks: Res<Assets<AudioSink>>,
    mymusic: Option<Res<MyMusic>>,
) {
    if let Some(mymusic) = &mymusic {
        if let Some(sink) = audio_sinks.get(&mymusic.sink) {
            sink.toggle();
        }
    }
}
```

Now:

```rust
/// Marker component for our music entity
#[derive(Component)]
struct MyMusic;

fn play_music(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
) {
    commands.spawn((
        AudioBundle::from_audio_source(asset_server.load("music.ogg"))
            .with_settings(PlaybackSettings::LOOP.with_volume(0.5)),
        MyMusic,
    ));
}

fn toggle_pause_music(
    // `AudioSink` will be inserted by Bevy when the audio starts playing
    query_music: Query<&AudioSink, With<MyMusic>>,
) {
    if let Ok(sink) = query.get_single() {
        sink.toggle();
    }
}
```
---
 crates/bevy_audio/src/audio.rs        | 423 +++++++++-----------------
 crates/bevy_audio/src/audio_output.rs | 310 +++++++++++--------
 crates/bevy_audio/src/lib.rs          |  53 ++--
 crates/bevy_audio/src/sinks.rs        |  53 +---
 examples/audio/audio.rs               |   8 +-
 examples/audio/audio_control.rs       |  45 +--
 examples/audio/decodable.rs           |   7 +-
 examples/audio/spatial_audio_2d.rs    |  49 ++-
 examples/audio/spatial_audio_3d.rs    |  55 ++--
 examples/games/breakout.rs            |   8 +-
 examples/mobile/src/lib.rs            |   8 +-
 11 files changed, 451 insertions(+), 568 deletions(-)

diff --git a/crates/bevy_audio/src/audio.rs b/crates/bevy_audio/src/audio.rs
index 0e17168f9b6a65..546e158e3f9061 100644
--- a/crates/bevy_audio/src/audio.rs
+++ b/crates/bevy_audio/src/audio.rs
@@ -1,256 +1,9 @@
-use crate::{AudioSink, AudioSource, Decodable, SpatialAudioSink};
-use bevy_asset::{Asset, Handle, HandleId};
+use crate::{AudioSource, Decodable};
+use bevy_asset::{Asset, Handle};
 use bevy_derive::{Deref, DerefMut};
-use bevy_ecs::system::Resource;
+use bevy_ecs::prelude::*;
 use bevy_math::Vec3;
 use bevy_transform::prelude::Transform;
-use parking_lot::RwLock;
-use std::{collections::VecDeque, fmt};
-
-/// Use this [`Resource`] to play audio.
-///
-/// ```
-/// # use bevy_ecs::system::Res;
-/// # use bevy_asset::AssetServer;
-/// # use bevy_audio::Audio;
-/// fn play_audio_system(asset_server: Res<AssetServer>, audio: Res<Audio>) {
-///     audio.play(asset_server.load("my_sound.ogg"));
-/// }
-/// ```
-#[derive(Resource)]
-pub struct Audio<Source = AudioSource>
-where
-    Source: Asset + Decodable,
-{
-    /// Queue for playing audio from asset handles
-    pub(crate) queue: RwLock<VecDeque<AudioToPlay<Source>>>,
-}
-
-impl<Source: Asset> fmt::Debug for Audio<Source>
-where
-    Source: Decodable,
-{
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("Audio").field("queue", &self.queue).finish()
-    }
-}
-
-impl<Source> Default for Audio<Source>
-where
-    Source: Asset + Decodable,
-{
-    fn default() -> Self {
-        Self {
-            queue: Default::default(),
-        }
-    }
-}
-
-impl<Source> Audio<Source>
-where
-    Source: Asset + Decodable,
-{
-    /// Play audio from a [`Handle`] to the audio source
-    ///
-    /// ```
-    /// # use bevy_ecs::system::Res;
-    /// # use bevy_asset::AssetServer;
-    /// # use bevy_audio::Audio;
-    /// fn play_audio_system(asset_server: Res<AssetServer>, audio: Res<Audio>) {
-    ///     audio.play(asset_server.load("my_sound.ogg"));
-    /// }
-    /// ```
-    ///
-    /// Returns a weak [`Handle`] to the [`AudioSink`]. If this handle isn't changed to a
-    /// strong one, the sink will be detached and the sound will continue playing. Changing it
-    /// to a strong handle allows you to control the playback through the [`AudioSink`] asset.
-    ///
-    /// ```
-    /// # use bevy_ecs::system::Res;
-    /// # use bevy_asset::{AssetServer, Assets};
-    /// # use bevy_audio::{Audio, AudioSink};
-    /// fn play_audio_system(
-    ///     asset_server: Res<AssetServer>,
-    ///     audio: Res<Audio>,
-    ///     audio_sinks: Res<Assets<AudioSink>>,
-    /// ) {
-    ///     // This is a weak handle, and can't be used to control playback.
-    ///     let weak_handle = audio.play(asset_server.load("my_sound.ogg"));
-    ///     // This is now a strong handle, and can be used to control playback.
-    ///     let strong_handle = audio_sinks.get_handle(weak_handle);
-    /// }
-    /// ```
-    pub fn play(&self, audio_source: Handle<Source>) -> Handle<AudioSink> {
-        let id = HandleId::random::<AudioSink>();
-        let config = AudioToPlay {
-            settings: PlaybackSettings::ONCE,
-            sink_handle: id,
-            source_handle: audio_source,
-            spatial: None,
-        };
-        self.queue.write().push_back(config);
-        Handle::<AudioSink>::weak(id)
-    }
-
-    /// Play audio from a [`Handle`] to the audio source with [`PlaybackSettings`] that
-    /// allows looping or changing volume from the start.
-    ///
-    /// ```
-    /// # use bevy_ecs::system::Res;
-    /// # use bevy_asset::AssetServer;
-    /// # use bevy_audio::{Audio, Volume};
-    /// # use bevy_audio::PlaybackSettings;
-    /// fn play_audio_system(asset_server: Res<AssetServer>, audio: Res<Audio>) {
-    ///     audio.play_with_settings(
-    ///         asset_server.load("my_sound.ogg"),
-    ///         PlaybackSettings::LOOP.with_volume(Volume::new_relative(0.75)),
-    ///     );
-    /// }
-    /// ```
-    ///
-    /// See [`Self::play`] on how to control playback once it's started.
-    pub fn play_with_settings(
-        &self,
-        audio_source: Handle<Source>,
-        settings: PlaybackSettings,
-    ) -> Handle<AudioSink> {
-        let id = HandleId::random::<AudioSink>();
-        let config = AudioToPlay {
-            settings,
-            sink_handle: id,
-            source_handle: audio_source,
-            spatial: None,
-        };
-        self.queue.write().push_back(config);
-        Handle::<AudioSink>::weak(id)
-    }
-
-    /// Play audio from a [`Handle`] to the audio source, placing the listener at the given
-    /// transform, an ear on each side separated by `gap`. The audio emitter will placed at
-    /// `emitter`.
-    ///
-    /// `bevy_audio` is not using HRTF for spatial audio, but is transforming the sound to a mono
-    /// track, and then changing the level of each stereo channel according to the distance between
-    /// the emitter and each ear by amplifying the difference between what the two ears hear.
-    ///
-    /// ```
-    /// # use bevy_ecs::system::Res;
-    /// # use bevy_asset::AssetServer;
-    /// # use bevy_audio::Audio;
-    /// # use bevy_math::Vec3;
-    /// # use bevy_transform::prelude::Transform;
-    /// fn play_spatial_audio_system(asset_server: Res<AssetServer>, audio: Res<Audio>) {
-    ///     // Sound will be to the left and behind the listener
-    ///     audio.play_spatial(
-    ///         asset_server.load("my_sound.ogg"),
-    ///         Transform::IDENTITY,
-    ///         1.0,
-    ///         Vec3::new(-2.0, 0.0, 1.0),
-    ///     );
-    /// }
-    /// ```
-    ///
-    /// Returns a weak [`Handle`] to the [`SpatialAudioSink`]. If this handle isn't changed to a
-    /// strong one, the sink will be detached and the sound will continue playing. Changing it
-    /// to a strong handle allows you to control the playback, or move the listener and emitter
-    /// through the [`SpatialAudioSink`] asset.
-    ///
-    /// ```
-    /// # use bevy_ecs::system::Res;
-    /// # use bevy_asset::{AssetServer, Assets};
-    /// # use bevy_audio::{Audio, SpatialAudioSink};
-    /// # use bevy_math::Vec3;
-    /// # use bevy_transform::prelude::Transform;
-    /// fn play_spatial_audio_system(
-    ///     asset_server: Res<AssetServer>,
-    ///     audio: Res<Audio>,
-    ///     spatial_audio_sinks: Res<Assets<SpatialAudioSink>>,
-    /// ) {
-    ///     // This is a weak handle, and can't be used to control playback.
-    ///     let weak_handle = audio.play_spatial(
-    ///         asset_server.load("my_sound.ogg"),
-    ///         Transform::IDENTITY,
-    ///         1.0,
-    ///         Vec3::new(-2.0, 0.0, 1.0),
-    ///     );
-    ///     // This is now a strong handle, and can be used to control playback, or move the emitter.
-    ///     let strong_handle = spatial_audio_sinks.get_handle(weak_handle);
-    /// }
-    /// ```
-    pub fn play_spatial(
-        &self,
-        audio_source: Handle<Source>,
-        listener: Transform,
-        gap: f32,
-        emitter: Vec3,
-    ) -> Handle<SpatialAudioSink> {
-        let id = HandleId::random::<SpatialAudioSink>();
-        let config = AudioToPlay {
-            settings: PlaybackSettings::ONCE,
-            sink_handle: id,
-            source_handle: audio_source,
-            spatial: Some(SpatialSettings {
-                left_ear: (listener.translation + listener.left() * gap / 2.0).to_array(),
-                right_ear: (listener.translation + listener.right() * gap / 2.0).to_array(),
-                emitter: emitter.to_array(),
-            }),
-        };
-        self.queue.write().push_back(config);
-        Handle::<SpatialAudioSink>::weak(id)
-    }
-
-    /// Play spatial audio from a [`Handle`] to the audio source with [`PlaybackSettings`] that
-    /// allows looping or changing volume from the start. The listener is placed at the given
-    /// transform, an ear on each side separated by `gap`. The audio emitter is placed at
-    /// `emitter`.
-    ///
-    /// `bevy_audio` is not using HRTF for spatial audio, but is transforming the sound to a mono
-    /// track, and then changing the level of each stereo channel according to the distance between
-    /// the emitter and each ear by amplifying the difference between what the two ears hear.
-    ///
-    /// ```
-    /// # use bevy_ecs::system::Res;
-    /// # use bevy_asset::AssetServer;
-    /// # use bevy_audio::{Audio, Volume};
-    /// # use bevy_audio::PlaybackSettings;
-    /// # use bevy_math::Vec3;
-    /// # use bevy_transform::prelude::Transform;
-    /// fn play_spatial_audio_system(asset_server: Res<AssetServer>, audio: Res<Audio>) {
-    ///     audio.play_spatial_with_settings(
-    ///         asset_server.load("my_sound.ogg"),
-    ///         PlaybackSettings::LOOP.with_volume(Volume::new_relative(0.75)),
-    ///         Transform::IDENTITY,
-    ///         1.0,
-    ///         Vec3::new(-2.0, 0.0, 1.0),
-    ///     );
-    /// }
-    /// ```
-    ///
-    /// See [`Self::play_spatial`] on how to control playback once it's started, or how to move
-    /// the listener or the emitter.
-    pub fn play_spatial_with_settings(
-        &self,
-        audio_source: Handle<Source>,
-        settings: PlaybackSettings,
-        listener: Transform,
-        gap: f32,
-        emitter: Vec3,
-    ) -> Handle<SpatialAudioSink> {
-        let id = HandleId::random::<SpatialAudioSink>();
-        let config = AudioToPlay {
-            settings,
-            sink_handle: id,
-            source_handle: audio_source,
-            spatial: Some(SpatialSettings {
-                left_ear: (listener.translation + listener.left() * gap / 2.0).to_array(),
-                right_ear: (listener.translation + listener.right() * gap / 2.0).to_array(),
-                emitter: emitter.to_array(),
-            }),
-        };
-        self.queue.write().push_back(config);
-        Handle::<SpatialAudioSink>::weak(id)
-    }
-}
 
 /// Defines the volume to play an audio source at.
 #[derive(Clone, Copy, Debug)]
@@ -278,7 +31,7 @@ impl Volume {
     }
 }
 
-/// A volume level equivalent to a positive only float.
+/// A volume level equivalent to a non-negative float.
 #[derive(Clone, Copy, Deref, DerefMut, Debug)]
 pub struct VolumeLevel(pub(crate) f32);
 
@@ -300,38 +53,83 @@ impl VolumeLevel {
     }
 }
 
-/// Settings to control playback from the start.
-#[derive(Clone, Copy, Debug)]
+/// How should Bevy manage the sound playback?
+#[derive(Debug, Clone, Copy)]
+pub enum PlaybackMode {
+    /// Play the sound once. Do nothing when it ends.
+    Once,
+    /// Repeat the sound forever.
+    Loop,
+    /// Despawn the entity when the sound finishes playing.
+    Despawn,
+    /// Remove the audio components from the entity, when the sound finishes playing.
+    Remove,
+}
+
+/// Initial settings to be used when audio starts playing.
+/// If you would like to control the audio while it is playing, query for the
+/// [`AudioSink`][crate::AudioSink] or [`SpatialAudioSink`][crate::SpatialAudioSink]
+/// components. Changes to this component will *not* be applied to already-playing audio.
+#[derive(Component, Clone, Copy, Debug)]
 pub struct PlaybackSettings {
-    /// Play in repeat
-    pub repeat: bool,
+    /// The desired playback behavior.
+    pub mode: PlaybackMode,
     /// Volume to play at.
     pub volume: Volume,
     /// Speed to play at.
     pub speed: f32,
+    /// Create the sink in paused state.
+    /// Useful for "deferred playback", if you want to prepare
+    /// the entity, but hear the sound later.
+    pub paused: bool,
 }
 
 impl Default for PlaybackSettings {
     fn default() -> Self {
+        // TODO: what should the default be: ONCE/DESPAWN/REMOVE?
         Self::ONCE
     }
 }
 
 impl PlaybackSettings {
-    /// Will play the associate audio source once.
+    /// Will play the associated audio source once.
     pub const ONCE: PlaybackSettings = PlaybackSettings {
-        repeat: false,
+        mode: PlaybackMode::Once,
         volume: Volume::Relative(VolumeLevel(1.0)),
         speed: 1.0,
+        paused: false,
     };
 
-    /// Will play the associate audio source in a loop.
+    /// Will play the associated audio source in a loop.
     pub const LOOP: PlaybackSettings = PlaybackSettings {
-        repeat: true,
+        mode: PlaybackMode::Loop,
         volume: Volume::Relative(VolumeLevel(1.0)),
         speed: 1.0,
+        paused: false,
     };
 
+    /// Will play the associated audio source once and despawn the entity afterwards.
+    pub const DESPAWN: PlaybackSettings = PlaybackSettings {
+        mode: PlaybackMode::Despawn,
+        volume: Volume::Relative(VolumeLevel(1.0)),
+        speed: 1.0,
+        paused: false,
+    };
+
+    /// Will play the associated audio source once and remove the audio components afterwards.
+    pub const REMOVE: PlaybackSettings = PlaybackSettings {
+        mode: PlaybackMode::Remove,
+        volume: Volume::Relative(VolumeLevel(1.0)),
+        speed: 1.0,
+        paused: false,
+    };
+
+    /// Helper to start in a paused state.
+    pub const fn paused(mut self) -> Self {
+        self.paused = true;
+        self
+    }
+
     /// Helper to set the volume from start of playback.
     pub const fn with_volume(mut self, volume: Volume) -> Self {
         self.volume = volume;
@@ -345,40 +143,35 @@ impl PlaybackSettings {
     }
 }
 
-#[derive(Clone)]
-pub(crate) struct SpatialSettings {
+/// Settings for playing spatial audio.
+///
+/// Note: Bevy does not currently support HRTF or any other high-quality 3D sound rendering
+/// features. Spatial audio is implemented via simple left-right stereo panning.
+#[derive(Component, Clone, Debug)]
+pub struct SpatialSettings {
     pub(crate) left_ear: [f32; 3],
     pub(crate) right_ear: [f32; 3],
     pub(crate) emitter: [f32; 3],
 }
 
-#[derive(Clone)]
-pub(crate) struct AudioToPlay<Source>
-where
-    Source: Asset + Decodable,
-{
-    pub(crate) sink_handle: HandleId,
-    pub(crate) source_handle: Handle<Source>,
-    pub(crate) settings: PlaybackSettings,
-    pub(crate) spatial: Option<SpatialSettings>,
-}
-
-impl<Source> fmt::Debug for AudioToPlay<Source>
-where
-    Source: Asset + Decodable,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("AudioToPlay")
-            .field("sink_handle", &self.sink_handle)
-            .field("source_handle", &self.source_handle)
-            .field("settings", &self.settings)
-            .finish()
+impl SpatialSettings {
+    /// Configure spatial audio coming from the `emitter` position and heard by a `listener`.
+    ///
+    /// The `listener` transform provides the position and rotation where the sound is to be
+    /// heard from. `gap` is the distance between the left and right "ears" of the listener.
+    /// `emitter` is the position where the sound comes from.
+    pub fn new(listener: Transform, gap: f32, emitter: Vec3) -> Self {
+        SpatialSettings {
+            left_ear: (listener.translation + listener.left() * gap / 2.0).to_array(),
+            right_ear: (listener.translation + listener.right() * gap / 2.0).to_array(),
+            emitter: emitter.to_array(),
+        }
     }
 }
 
 /// Use this [`Resource`] to control the global volume of all audio with a [`Volume::Relative`] volume.
 ///
-/// Keep in mind that changing this value will not affect already playing audio.
+/// Note: changing this value will not affect already playing audio.
 #[derive(Resource, Default, Clone, Copy)]
 pub struct GlobalVolume {
     /// The global volume of all audio.
@@ -393,3 +186,67 @@ impl GlobalVolume {
         }
     }
 }
+
+/// Bundle for playing a standard bevy audio asset
+pub type AudioBundle = AudioSourceBundle<AudioSource>;
+
+/// Bundle for playing a standard bevy audio asset with a 3D position
+pub type SpatialAudioBundle = SpatialAudioSourceBundle<AudioSource>;
+
+/// Bundle for playing a sound.
+///
+/// Insert this bundle onto an entity to trigger a sound source to begin playing.
+///
+/// If the handle refers to an unavailable asset (such as if it has not finished loading yet),
+/// the audio will not begin playing immediately. The audio will play when the asset is ready.
+///
+/// When Bevy begins the audio playback, an [`AudioSink`][crate::AudioSink] component will be
+/// added to the entity. You can use that component to control the audio settings during playback.
+#[derive(Bundle)]
+pub struct AudioSourceBundle<Source = AudioSource>
+where
+    Source: Asset + Decodable,
+{
+    /// Asset containing the audio data to play.
+    pub source: Handle<Source>,
+    /// Initial settings that the audio starts playing with.
+    /// If you would like to control the audio while it is playing,
+    /// query for the [`AudioSink`][crate::AudioSink] component.
+    /// Changes to this component will *not* be applied to already-playing audio.
+    pub settings: PlaybackSettings,
+}
+
+impl<T: Decodable + Asset> Default for AudioSourceBundle<T> {
+    fn default() -> Self {
+        Self {
+            source: Default::default(),
+            settings: Default::default(),
+        }
+    }
+}
+
+/// Bundle for playing a sound with a 3D position.
+///
+/// Insert this bundle onto an entity to trigger a sound source to begin playing.
+///
+/// If the handle refers to an unavailable asset (such as if it has not finished loading yet),
+/// the audio will not begin playing immediately. The audio will play when the asset is ready.
+///
+/// When Bevy begins the audio playback, a [`SpatialAudioSink`][crate::SpatialAudioSink]
+/// component will be added to the entity. You can use that component to control the audio
+/// settings during playback.
+#[derive(Bundle)]
+pub struct SpatialAudioSourceBundle<Source = AudioSource>
+where
+    Source: Asset + Decodable,
+{
+    /// Asset containing the audio data to play.
+    pub source: Handle<Source>,
+    /// Initial settings that the audio starts playing with.
+    /// If you would like to control the audio while it is playing,
+    /// query for the [`SpatialAudioSink`][crate::SpatialAudioSink] component.
+    /// Changes to this component will *not* be applied to already-playing audio.
+    pub settings: PlaybackSettings,
+    /// Spatial audio configuration. Specifies the positions of the source and listener.
+    pub spatial: SpatialSettings,
+}
diff --git a/crates/bevy_audio/src/audio_output.rs b/crates/bevy_audio/src/audio_output.rs
index a133f1fb0e1bd8..fd2173f6726d38 100644
--- a/crates/bevy_audio/src/audio_output.rs
+++ b/crates/bevy_audio/src/audio_output.rs
@@ -1,11 +1,11 @@
 use crate::{
-    Audio, AudioSource, Decodable, GlobalVolume, SpatialAudioSink, SpatialSettings, Volume,
+    AudioSourceBundle, Decodable, GlobalVolume, PlaybackMode, PlaybackSettings, SpatialAudioSink,
+    SpatialAudioSourceBundle, SpatialSettings, Volume,
 };
-use bevy_asset::{Asset, Assets};
-use bevy_ecs::system::{Res, ResMut, Resource};
+use bevy_asset::{Asset, Assets, Handle};
+use bevy_ecs::prelude::*;
 use bevy_utils::tracing::warn;
 use rodio::{OutputStream, OutputStreamHandle, Sink, Source, SpatialSink};
-use std::marker::PhantomData;
 
 use crate::AudioSink;
 
@@ -22,157 +22,227 @@ use crate::AudioSink;
 /// since the memory cost will be the same.
 /// However, repeatedly inserting this resource into the app will **leak more memory**.
 #[derive(Resource)]
-pub struct AudioOutput<Source = AudioSource>
-where
-    Source: Decodable,
-{
+pub(crate) struct AudioOutput {
     stream_handle: Option<OutputStreamHandle>,
-    phantom: PhantomData<Source>,
 }
 
-impl<Source> Default for AudioOutput<Source>
-where
-    Source: Decodable,
-{
+impl Default for AudioOutput {
     fn default() -> Self {
         if let Ok((stream, stream_handle)) = OutputStream::try_default() {
             // We leak `OutputStream` to prevent the audio from stopping.
             std::mem::forget(stream);
             Self {
                 stream_handle: Some(stream_handle),
-                phantom: PhantomData,
             }
         } else {
             warn!("No audio device found.");
             Self {
                 stream_handle: None,
-                phantom: PhantomData,
             }
         }
     }
 }
 
-impl<Source> AudioOutput<Source>
-where
-    Source: Asset + Decodable,
+/// Marker for internal use, to despawn entities when playback finishes.
+#[derive(Component)]
+pub struct PlaybackDespawnMarker;
+
+/// Marker for internal use, to remove audio components when playback finishes.
+#[derive(Component)]
+pub struct PlaybackRemoveMarker;
+
+/// Plays "queued" audio through the [`AudioOutput`] resource.
+///
+/// "Queued" audio is any audio entity (with the components from
+/// [`AudioBundle`][crate::AudioBundle] or [`SpatialAudioBundle`][crate::SpatialAudioBundle])
+/// that does not have an [`AudioSink`]/[`SpatialAudioSink`] component.
+///
+/// This system detects such entities, checks if their source asset
+/// data is available, and creates/inserts the sink.
+pub(crate) fn play_queued_audio_system<Source: Asset + Decodable>(
+    audio_output: Res<AudioOutput>,
+    audio_sources: Res<Assets<Source>>,
+    global_volume: Res<GlobalVolume>,
+    query_nonplaying: Query<
+        (
+            Entity,
+            &Handle<Source>,
+            &PlaybackSettings,
+            Option<&SpatialSettings>,
+        ),
+        (Without<AudioSink>, Without<SpatialAudioSink>),
+    >,
+    mut commands: Commands,
+) where
     f32: rodio::cpal::FromSample<Source::DecoderItem>,
 {
-    fn play_source(&self, audio_source: &Source, repeat: bool) -> Option<Sink> {
-        self.stream_handle
-            .as_ref()
-            .and_then(|stream_handle| match Sink::try_new(stream_handle) {
-                Ok(sink) => {
-                    if repeat {
-                        sink.append(audio_source.decoder().repeat_infinite());
-                    } else {
-                        sink.append(audio_source.decoder());
-                    }
-                    Some(sink)
-                }
-                Err(err) => {
-                    warn!("Error playing sound: {err:?}");
-                    None
-                }
-            })
-    }
+    let Some(stream_handle) = audio_output.stream_handle.as_ref() else {
+        // audio output unavailable; cannot play sound
+        return;
+    };
 
-    fn play_spatial_source(
-        &self,
-        audio_source: &Source,
-        repeat: bool,
-        spatial: SpatialSettings,
-    ) -> Option<SpatialSink> {
-        self.stream_handle.as_ref().and_then(|stream_handle| {
-            match SpatialSink::try_new(
-                stream_handle,
-                spatial.emitter,
-                spatial.left_ear,
-                spatial.right_ear,
-            ) {
-                Ok(sink) => {
-                    if repeat {
-                        sink.append(audio_source.decoder().repeat_infinite());
-                    } else {
-                        sink.append(audio_source.decoder());
+    for (entity, source_handle, settings, spatial) in &query_nonplaying {
+        if let Some(audio_source) = audio_sources.get(source_handle) {
+            // audio data is available (has loaded), begin playback and insert sink component
+            if let Some(spatial) = spatial {
+                match SpatialSink::try_new(
+                    stream_handle,
+                    spatial.emitter,
+                    spatial.left_ear,
+                    spatial.right_ear,
+                ) {
+                    Ok(sink) => {
+                        sink.set_speed(settings.speed);
+                        match settings.volume {
+                            Volume::Relative(vol) => {
+                                sink.set_volume(vol.0 * global_volume.volume.0);
+                            }
+                            Volume::Absolute(vol) => sink.set_volume(vol.0),
+                        }
+                        if settings.paused {
+                            sink.pause();
+                        }
+                        match settings.mode {
+                            PlaybackMode::Loop => {
+                                sink.append(audio_source.decoder().repeat_infinite());
+                                commands
+                                    .entity(entity)
+                                    .insert(SpatialAudioSink { sink: Some(sink) });
+                            }
+                            PlaybackMode::Once => {
+                                sink.append(audio_source.decoder());
+                                commands
+                                    .entity(entity)
+                                    .insert(SpatialAudioSink { sink: Some(sink) });
+                            }
+                            PlaybackMode::Despawn => {
+                                sink.append(audio_source.decoder());
+                                commands
+                                    .entity(entity)
+                                    // PERF: insert as bundle to reduce archetype moves
+                                    .insert((
+                                        SpatialAudioSink { sink: Some(sink) },
+                                        PlaybackDespawnMarker,
+                                    ));
+                            }
+                            PlaybackMode::Remove => {
+                                sink.append(audio_source.decoder());
+                                commands
+                                    .entity(entity)
+                                    // PERF: insert as bundle to reduce archetype moves
+                                    .insert((
+                                        SpatialAudioSink { sink: Some(sink) },
+                                        PlaybackRemoveMarker,
+                                    ));
+                            }
+                        };
+                    }
+                    Err(err) => {
+                        warn!("Error playing spatial sound: {err:?}");
                     }
-                    Some(sink)
-                }
-                Err(err) => {
-                    warn!("Error playing spatial sound: {err:?}");
-                    None
                 }
-            }
-        })
-    }
-
-    fn try_play_queued(
-        &self,
-        audio_sources: &Assets<Source>,
-        audio: &mut Audio<Source>,
-        sinks: &mut Assets<AudioSink>,
-        spatial_sinks: &mut Assets<SpatialAudioSink>,
-        global_volume: &GlobalVolume,
-    ) {
-        let mut queue = audio.queue.write();
-        let len = queue.len();
-        let mut i = 0;
-        while i < len {
-            let config = queue.pop_front().unwrap();
-            if let Some(audio_source) = audio_sources.get(&config.source_handle) {
-                if let Some(spatial) = config.spatial {
-                    if let Some(sink) =
-                        self.play_spatial_source(audio_source, config.settings.repeat, spatial)
-                    {
-                        sink.set_speed(config.settings.speed);
-                        match config.settings.volume {
+            } else {
+                match Sink::try_new(stream_handle) {
+                    Ok(sink) => {
+                        sink.set_speed(settings.speed);
+                        match settings.volume {
                             Volume::Relative(vol) => {
                                 sink.set_volume(vol.0 * global_volume.volume.0);
                             }
                             Volume::Absolute(vol) => sink.set_volume(vol.0),
                         }
-
-                        // don't keep the strong handle. there is no way to return it to the user here as it is async
-                        let _ = spatial_sinks
-                            .set(config.sink_handle, SpatialAudioSink { sink: Some(sink) });
+                        if settings.paused {
+                            sink.pause();
+                        }
+                        match settings.mode {
+                            PlaybackMode::Loop => {
+                                sink.append(audio_source.decoder().repeat_infinite());
+                                commands
+                                    .entity(entity)
+                                    .insert(AudioSink { sink: Some(sink) });
+                            }
+                            PlaybackMode::Once => {
+                                sink.append(audio_source.decoder());
+                                commands
+                                    .entity(entity)
+                                    .insert(AudioSink { sink: Some(sink) });
+                            }
+                            PlaybackMode::Despawn => {
+                                sink.append(audio_source.decoder());
+                                commands
+                                    .entity(entity)
+                                    // PERF: insert as bundle to reduce archetype moves
+                                    .insert((
+                                        AudioSink { sink: Some(sink) },
+                                        PlaybackDespawnMarker,
+                                    ));
+                            }
+                            PlaybackMode::Remove => {
+                                sink.append(audio_source.decoder());
+                                commands
+                                    .entity(entity)
+                                    // PERF: insert as bundle to reduce archetype moves
+                                    .insert((AudioSink { sink: Some(sink) }, PlaybackRemoveMarker));
+                            }
+                        };
                     }
-                } else if let Some(sink) = self.play_source(audio_source, config.settings.repeat) {
-                    sink.set_speed(config.settings.speed);
-
-                    match config.settings.volume {
-                        Volume::Relative(vol) => sink.set_volume(vol.0 * global_volume.volume.0),
-                        Volume::Absolute(vol) => sink.set_volume(vol.0),
+                    Err(err) => {
+                        warn!("Error playing sound: {err:?}");
                     }
-
-                    // don't keep the strong handle. there is no way to return it to the user here as it is async
-                    let _ = sinks.set(config.sink_handle, AudioSink { sink: Some(sink) });
                 }
-            } else {
-                // audio source hasn't loaded yet. add it back to the queue
-                queue.push_back(config);
             }
-            i += 1;
         }
     }
 }
 
-/// Plays audio currently queued in the [`Audio`] resource through the [`AudioOutput`] resource
-pub fn play_queued_audio_system<Source: Asset + Decodable>(
-    audio_output: Res<AudioOutput<Source>>,
-    audio_sources: Option<Res<Assets<Source>>>,
-    global_volume: Res<GlobalVolume>,
-    mut audio: ResMut<Audio<Source>>,
-    mut sinks: ResMut<Assets<AudioSink>>,
-    mut spatial_sinks: ResMut<Assets<SpatialAudioSink>>,
-) where
-    f32: rodio::cpal::FromSample<Source::DecoderItem>,
-{
-    if let Some(audio_sources) = audio_sources {
-        audio_output.try_play_queued(
-            &*audio_sources,
-            &mut *audio,
-            &mut sinks,
-            &mut spatial_sinks,
-            &global_volume,
-        );
-    };
+pub(crate) fn cleanup_finished_audio<T: Decodable + Asset>(
+    mut commands: Commands,
+    query_nonspatial_despawn: Query<
+        (Entity, &AudioSink),
+        (With<PlaybackDespawnMarker>, With<Handle<T>>),
+    >,
+    query_spatial_despawn: Query<
+        (Entity, &SpatialAudioSink),
+        (With<PlaybackDespawnMarker>, With<Handle<T>>),
+    >,
+    query_nonspatial_remove: Query<
+        (Entity, &AudioSink),
+        (With<PlaybackRemoveMarker>, With<Handle<T>>),
+    >,
+    query_spatial_remove: Query<
+        (Entity, &SpatialAudioSink),
+        (With<PlaybackRemoveMarker>, With<Handle<T>>),
+    >,
+) {
+    for (entity, sink) in &query_nonspatial_despawn {
+        if sink.sink.as_ref().unwrap().empty() {
+            commands.entity(entity).despawn();
+        }
+    }
+    for (entity, sink) in &query_spatial_despawn {
+        if sink.sink.as_ref().unwrap().empty() {
+            commands.entity(entity).despawn();
+        }
+    }
+    for (entity, sink) in &query_nonspatial_remove {
+        if sink.sink.as_ref().unwrap().empty() {
+            commands
+                .entity(entity)
+                .remove::<(AudioSourceBundle<T>, AudioSink, PlaybackRemoveMarker)>();
+        }
+    }
+    for (entity, sink) in &query_spatial_remove {
+        if sink.sink.as_ref().unwrap().empty() {
+            commands.entity(entity).remove::<(
+                SpatialAudioSourceBundle<T>,
+                SpatialAudioSink,
+                PlaybackRemoveMarker,
+            )>();
+        }
+    }
+}
+
+/// Run Condition to only play audio if the audio output is available
+pub(crate) fn audio_output_available(audio_output: Res<AudioOutput>) -> bool {
+    audio_output.stream_handle.is_some()
 }
diff --git a/crates/bevy_audio/src/lib.rs b/crates/bevy_audio/src/lib.rs
index 6544c789698fcc..11b3699096b394 100644
--- a/crates/bevy_audio/src/lib.rs
+++ b/crates/bevy_audio/src/lib.rs
@@ -1,8 +1,8 @@
 //! Audio support for the game engine Bevy
 //!
 //! ```no_run
-//! # use bevy_ecs::{system::Res, event::EventWriter};
-//! # use bevy_audio::{Audio, AudioPlugin};
+//! # use bevy_ecs::prelude::*;
+//! # use bevy_audio::{AudioBundle, AudioPlugin, PlaybackSettings};
 //! # use bevy_asset::{AssetPlugin, AssetServer};
 //! # use bevy_app::{App, AppExit, NoopPluginGroup as MinimalPlugins, Startup};
 //! fn main() {
@@ -12,8 +12,11 @@
 //!         .run();
 //! }
 //!
-//! fn play_background_audio(asset_server: Res<AssetServer>, audio: Res<Audio>) {
-//!     audio.play(asset_server.load("background_audio.ogg"));
+//! fn play_background_audio(asset_server: Res<AssetServer>, mut commands: Commands) {
+//!     commands.spawn(AudioBundle {
+//!         source: asset_server.load("background_audio.ogg"),
+//!         settings: PlaybackSettings::LOOP,
+//!     });
 //! }
 //! ```
 
@@ -30,13 +33,13 @@ mod sinks;
 pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
-        Audio, AudioOutput, AudioSink, AudioSinkPlayback, AudioSource, Decodable, GlobalVolume,
-        PlaybackSettings, SpatialAudioSink,
+        AudioBundle, AudioSink, AudioSinkPlayback, AudioSource, AudioSourceBundle, Decodable,
+        GlobalVolume, PlaybackSettings, SpatialAudioBundle, SpatialAudioSink,
+        SpatialAudioSourceBundle, SpatialSettings,
     };
 }
 
 pub use audio::*;
-pub use audio_output::*;
 pub use audio_source::*;
 
 pub use rodio::cpal::Sample as CpalSample;
@@ -46,28 +49,34 @@ pub use sinks::*;
 
 use bevy_app::prelude::*;
 use bevy_asset::{AddAsset, Asset};
+use bevy_ecs::prelude::*;
+
+use audio_output::*;
+
+/// Set for the audio playback systems, so they can share a run condition
+#[derive(SystemSet, Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
+struct AudioPlaySet;
 
 /// Adds support for audio playback to a Bevy Application
 ///
-/// Use the [`Audio`] resource to play audio.
+/// Insert an [`AudioBundle`] or [`SpatialAudioBundle`] onto your entities to play audio.
 #[derive(Default)]
 pub struct AudioPlugin {
-    /// The global volume for all audio sources with a [`Volume::Relative`] volume.
+    /// The global volume for all audio entities with a [`Volume::Relative`] volume.
     pub global_volume: GlobalVolume,
 }
 
 impl Plugin for AudioPlugin {
     fn build(&self, app: &mut App) {
-        app.init_resource::<AudioOutput<AudioSource>>()
-            .add_asset::<AudioSource>()
-            .add_asset::<AudioSink>()
-            .add_asset::<SpatialAudioSink>()
-            .init_resource::<Audio<AudioSource>>()
-            .insert_resource(self.global_volume)
-            .add_systems(PostUpdate, play_queued_audio_system::<AudioSource>);
+        app.insert_resource(self.global_volume)
+            .configure_set(PostUpdate, AudioPlaySet.run_if(audio_output_available))
+            .init_resource::<AudioOutput>();
 
         #[cfg(any(feature = "mp3", feature = "flac", feature = "wav", feature = "vorbis"))]
-        app.init_asset_loader::<AudioLoader>();
+        {
+            app.add_audio_source::<AudioSource>();
+            app.init_asset_loader::<AudioLoader>();
+        }
     }
 }
 
@@ -77,9 +86,11 @@ impl AddAudioSource for App {
         T: Decodable + Asset,
         f32: rodio::cpal::FromSample<T::DecoderItem>,
     {
-        self.add_asset::<T>()
-            .init_resource::<Audio<T>>()
-            .init_resource::<AudioOutput<T>>()
-            .add_systems(PostUpdate, play_queued_audio_system::<T>)
+        self.add_asset::<T>().add_systems(
+            PostUpdate,
+            play_queued_audio_system::<T>.in_set(AudioPlaySet),
+        );
+        self.add_systems(PostUpdate, cleanup_finished_audio::<T>.in_set(AudioPlaySet));
+        self
     }
 }
diff --git a/crates/bevy_audio/src/sinks.rs b/crates/bevy_audio/src/sinks.rs
index 2746eaf195da27..2f5cf4c29c238a 100644
--- a/crates/bevy_audio/src/sinks.rs
+++ b/crates/bevy_audio/src/sinks.rs
@@ -1,5 +1,5 @@
+use bevy_ecs::component::Component;
 use bevy_math::Vec3;
-use bevy_reflect::{TypePath, TypeUuid};
 use bevy_transform::prelude::Transform;
 use rodio::{Sink, SpatialSink};
 
@@ -65,30 +65,13 @@ pub trait AudioSinkPlayback {
     fn empty(&self) -> bool;
 }
 
-/// Asset controlling the playback of a sound
+/// Used to control audio during playback.
 ///
-/// ```
-/// # use bevy_ecs::system::{Local, Res};
-/// # use bevy_asset::{Assets, Handle};
-/// # use bevy_audio::{AudioSink, AudioSinkPlayback};
-/// // Execution of this system should be controlled by a state or input,
-/// // otherwise it would just toggle between play and pause every frame.
-/// fn pause(
-///     audio_sinks: Res<Assets<AudioSink>>,
-///     music_controller: Local<Handle<AudioSink>>,
-/// ) {
-///     if let Some(sink) = audio_sinks.get(&*music_controller) {
-///         if sink.is_paused() {
-///             sink.play()
-///         } else {
-///             sink.pause()
-///         }
-///     }
-/// }
-/// ```
+/// Bevy inserts this component onto your entities when it begins playing an audio source.
+/// Use [`AudioBundle`][crate::AudioBundle] to trigger that to happen.
 ///
-#[derive(TypePath, TypeUuid)]
-#[uuid = "8BEE570C-57C2-4FC0-8CFB-983A22F7D981"]
+/// You can use this component to modify the playback settings while the audio is playing.
+#[derive(Component)]
 pub struct AudioSink {
     // This field is an Option in order to allow us to have a safe drop that will detach the sink.
     // It will never be None during its life
@@ -139,27 +122,13 @@ impl AudioSinkPlayback for AudioSink {
     }
 }
 
-/// Asset controlling the playback of a sound, or the locations of its listener and emitter.
+/// Used to control spatial audio during playback.
 ///
-/// ```
-/// # use bevy_ecs::system::{Local, Res};
-/// # use bevy_asset::{Assets, Handle};
-/// # use bevy_audio::SpatialAudioSink;
-/// # use bevy_math::Vec3;
-/// // Execution of this system should be controlled by a state or input,
-/// // otherwise it would just trigger every frame.
-/// fn pause(
-///     spatial_audio_sinks: Res<Assets<SpatialAudioSink>>,
-///     audio_controller: Local<Handle<SpatialAudioSink>>,
-/// ) {
-///     if let Some(spatial_sink) = spatial_audio_sinks.get(&*audio_controller) {
-///         spatial_sink.set_emitter_position(Vec3::new(1.0, 0.5, 1.0));
-///     }
-/// }
-/// ```
+/// Bevy inserts this component onto your entities when it begins playing an audio source.
+/// Use [`SpatialAudioBundle`][crate::SpatialAudioBundle] to trigger that to happen.
 ///
-#[derive(TypePath, TypeUuid)]
-#[uuid = "F3CA4C47-595E-453B-96A7-31C3DDF2A177"]
+/// You can use this component to modify the playback settings while the audio is playing.
+#[derive(Component)]
 pub struct SpatialAudioSink {
     // This field is an Option in order to allow us to have a safe drop that will detach the sink.
     // It will never be None during its life
diff --git a/examples/audio/audio.rs b/examples/audio/audio.rs
index 8e70e39847985c..96ebdbb19e121d 100644
--- a/examples/audio/audio.rs
+++ b/examples/audio/audio.rs
@@ -9,7 +9,9 @@ fn main() {
         .run();
 }
 
-fn setup(asset_server: Res<AssetServer>, audio: Res<Audio>) {
-    let music = asset_server.load("sounds/Windless Slopes.ogg");
-    audio.play(music);
+fn setup(asset_server: Res<AssetServer>, mut commands: Commands) {
+    commands.spawn(AudioBundle {
+        source: asset_server.load("sounds/Windless Slopes.ogg"),
+        ..default()
+    });
 }
diff --git a/examples/audio/audio_control.rs b/examples/audio/audio_control.rs
index f14ef902a09e00..05be7807137578 100644
--- a/examples/audio/audio_control.rs
+++ b/examples/audio/audio_control.rs
@@ -10,48 +10,35 @@ fn main() {
         .run();
 }
 
-fn setup(
-    mut commands: Commands,
-    asset_server: Res<AssetServer>,
-    audio: Res<Audio>,
-    audio_sinks: Res<Assets<AudioSink>>,
-) {
-    let music = asset_server.load("sounds/Windless Slopes.ogg");
-    let handle = audio_sinks.get_handle(audio.play(music));
-    commands.insert_resource(MusicController(handle));
+fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
+    commands.spawn((
+        AudioBundle {
+            source: asset_server.load("sounds/Windless Slopes.ogg"),
+            ..default()
+        },
+        MyMusic,
+    ));
 }
 
-#[derive(Resource)]
-struct MusicController(Handle<AudioSink>);
+#[derive(Component)]
+struct MyMusic;
 
-fn update_speed(
-    audio_sinks: Res<Assets<AudioSink>>,
-    music_controller: Res<MusicController>,
-    time: Res<Time>,
-) {
-    if let Some(sink) = audio_sinks.get(&music_controller.0) {
+fn update_speed(music_controller: Query<&AudioSink, With<MyMusic>>, time: Res<Time>) {
+    if let Ok(sink) = music_controller.get_single() {
         sink.set_speed(((time.elapsed_seconds() / 5.0).sin() + 1.0).max(0.1));
     }
 }
 
-fn pause(
-    keyboard_input: Res<Input<KeyCode>>,
-    audio_sinks: Res<Assets<AudioSink>>,
-    music_controller: Res<MusicController>,
-) {
+fn pause(keyboard_input: Res<Input<KeyCode>>, music_controller: Query<&AudioSink, With<MyMusic>>) {
     if keyboard_input.just_pressed(KeyCode::Space) {
-        if let Some(sink) = audio_sinks.get(&music_controller.0) {
+        if let Ok(sink) = music_controller.get_single() {
             sink.toggle();
         }
     }
 }
 
-fn volume(
-    keyboard_input: Res<Input<KeyCode>>,
-    audio_sinks: Res<Assets<AudioSink>>,
-    music_controller: Res<MusicController>,
-) {
-    if let Some(sink) = audio_sinks.get(&music_controller.0) {
+fn volume(keyboard_input: Res<Input<KeyCode>>, music_controller: Query<&AudioSink, With<MyMusic>>) {
+    if let Ok(sink) = music_controller.get_single() {
         if keyboard_input.just_pressed(KeyCode::Plus) {
             sink.set_volume(sink.volume() + 0.1);
         } else if keyboard_input.just_pressed(KeyCode::Minus) {
diff --git a/examples/audio/decodable.rs b/examples/audio/decodable.rs
index 13a986c5af82dd..9ed6539d24c9e7 100644
--- a/examples/audio/decodable.rs
+++ b/examples/audio/decodable.rs
@@ -93,10 +93,13 @@ fn main() {
     .run();
 }
 
-fn setup(mut assets: ResMut<Assets<SineAudio>>, audio: Res<Audio<SineAudio>>) {
+fn setup(mut assets: ResMut<Assets<SineAudio>>, mut commands: Commands) {
     // add a `SineAudio` to the asset server so that it can be played
     let audio_handle = assets.add(SineAudio {
         frequency: 440., //this is the frequency of A4
     });
-    audio.play(audio_handle);
+    commands.spawn(AudioSourceBundle {
+        source: audio_handle,
+        ..default()
+    });
 }
diff --git a/examples/audio/spatial_audio_2d.rs b/examples/audio/spatial_audio_2d.rs
index b5c52bbe20945f..5a9c93a034edcc 100644
--- a/examples/audio/spatial_audio_2d.rs
+++ b/examples/audio/spatial_audio_2d.rs
@@ -18,21 +18,25 @@ fn setup(
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<ColorMaterial>>,
     asset_server: Res<AssetServer>,
-    audio: Res<Audio>,
-    audio_sinks: Res<Assets<SpatialAudioSink>>,
 ) {
     // Space between the two ears
     let gap = 400.0;
 
-    let music = asset_server.load("sounds/Windless Slopes.ogg");
-    let handle = audio_sinks.get_handle(audio.play_spatial_with_settings(
-        music,
-        PlaybackSettings::LOOP,
-        Transform::IDENTITY,
-        gap / AUDIO_SCALE,
-        Vec3::ZERO,
+    // sound emitter
+    commands.spawn((
+        MaterialMesh2dBundle {
+            mesh: meshes.add(shape::Circle::new(15.0).into()).into(),
+            material: materials.add(ColorMaterial::from(Color::BLUE)),
+            transform: Transform::from_translation(Vec3::new(0.0, 50.0, 0.0)),
+            ..default()
+        },
+        Emitter,
+        SpatialAudioBundle {
+            source: asset_server.load("sounds/Windless Slopes.ogg"),
+            settings: PlaybackSettings::LOOP,
+            spatial: SpatialSettings::new(Transform::IDENTITY, gap / AUDIO_SCALE, Vec3::ZERO),
+        },
     ));
-    commands.insert_resource(AudioController(handle));
 
     // left ear
     commands.spawn(SpriteBundle {
@@ -56,17 +60,6 @@ fn setup(
         ..default()
     });
 
-    // sound emitter
-    commands.spawn((
-        MaterialMesh2dBundle {
-            mesh: meshes.add(shape::Circle::new(15.0).into()).into(),
-            material: materials.add(ColorMaterial::from(Color::BLUE)),
-            transform: Transform::from_translation(Vec3::new(0.0, 50.0, 0.0)),
-            ..default()
-        },
-        Emitter,
-    ));
-
     // camera
     commands.spawn(Camera2dBundle::default());
 }
@@ -74,18 +67,14 @@ fn setup(
 #[derive(Component)]
 struct Emitter;
 
-#[derive(Resource)]
-struct AudioController(Handle<SpatialAudioSink>);
-
 fn update_positions(
-    audio_sinks: Res<Assets<SpatialAudioSink>>,
-    music_controller: Res<AudioController>,
     time: Res<Time>,
-    mut emitter: Query<&mut Transform, With<Emitter>>,
+    mut emitters: Query<(&mut Transform, Option<&SpatialAudioSink>), With<Emitter>>,
 ) {
-    if let Some(sink) = audio_sinks.get(&music_controller.0) {
-        let mut emitter_transform = emitter.single_mut();
+    for (mut emitter_transform, sink) in emitters.iter_mut() {
         emitter_transform.translation.x = time.elapsed_seconds().sin() * 500.0;
-        sink.set_emitter_position(emitter_transform.translation / AUDIO_SCALE);
+        if let Some(sink) = &sink {
+            sink.set_emitter_position(emitter_transform.translation / AUDIO_SCALE);
+        }
     }
 }
diff --git a/examples/audio/spatial_audio_3d.rs b/examples/audio/spatial_audio_3d.rs
index c9cfb839a89795..e7cea097687eda 100644
--- a/examples/audio/spatial_audio_3d.rs
+++ b/examples/audio/spatial_audio_3d.rs
@@ -12,23 +12,30 @@ fn main() {
 fn setup(
     mut commands: Commands,
     asset_server: Res<AssetServer>,
-    audio: Res<Audio>,
-    audio_sinks: Res<Assets<SpatialAudioSink>>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
     // Space between the two ears
     let gap = 4.0;
 
-    let music = asset_server.load("sounds/Windless Slopes.ogg");
-    let handle = audio_sinks.get_handle(audio.play_spatial_with_settings(
-        music,
-        PlaybackSettings::LOOP,
-        Transform::IDENTITY,
-        gap,
-        Vec3::ZERO,
+    // sound emitter
+    commands.spawn((
+        PbrBundle {
+            mesh: meshes.add(Mesh::from(shape::UVSphere {
+                radius: 0.2,
+                ..default()
+            })),
+            material: materials.add(Color::BLUE.into()),
+            transform: Transform::from_xyz(0.0, 0.0, 0.0),
+            ..default()
+        },
+        Emitter,
+        SpatialAudioBundle {
+            source: asset_server.load("sounds/Windless Slopes.ogg"),
+            settings: PlaybackSettings::LOOP,
+            spatial: SpatialSettings::new(Transform::IDENTITY, gap, Vec3::ZERO),
+        },
     ));
-    commands.insert_resource(AudioController(handle));
 
     // left ear
     commands.spawn(PbrBundle {
@@ -46,20 +53,6 @@ fn setup(
         ..default()
     });
 
-    // sound emitter
-    commands.spawn((
-        PbrBundle {
-            mesh: meshes.add(Mesh::from(shape::UVSphere {
-                radius: 0.2,
-                ..default()
-            })),
-            material: materials.add(Color::BLUE.into()),
-            transform: Transform::from_xyz(0.0, 0.0, 0.0),
-            ..default()
-        },
-        Emitter,
-    ));
-
     // light
     commands.spawn(PointLightBundle {
         point_light: PointLight {
@@ -80,19 +73,15 @@ fn setup(
 #[derive(Component)]
 struct Emitter;
 
-#[derive(Resource)]
-struct AudioController(Handle<SpatialAudioSink>);
-
 fn update_positions(
-    audio_sinks: Res<Assets<SpatialAudioSink>>,
-    music_controller: Res<AudioController>,
     time: Res<Time>,
-    mut emitter: Query<&mut Transform, With<Emitter>>,
+    mut emitters: Query<(&mut Transform, Option<&SpatialAudioSink>), With<Emitter>>,
 ) {
-    if let Some(sink) = audio_sinks.get(&music_controller.0) {
-        let mut emitter_transform = emitter.single_mut();
+    for (mut emitter_transform, sink) in emitters.iter_mut() {
         emitter_transform.translation.x = time.elapsed_seconds().sin() * 3.0;
         emitter_transform.translation.z = time.elapsed_seconds().cos() * 3.0;
-        sink.set_emitter_position(emitter_transform.translation);
+        if let Some(sink) = &sink {
+            sink.set_emitter_position(emitter_transform.translation);
+        }
     }
 }
diff --git a/examples/games/breakout.rs b/examples/games/breakout.rs
index a1db60dab67ecb..d582856cc52dc0 100644
--- a/examples/games/breakout.rs
+++ b/examples/games/breakout.rs
@@ -404,14 +404,18 @@ fn check_for_collisions(
 }
 
 fn play_collision_sound(
+    mut commands: Commands,
     mut collision_events: EventReader<CollisionEvent>,
-    audio: Res<Audio>,
     sound: Res<CollisionSound>,
 ) {
     // Play a sound once per frame if a collision occurred.
     if !collision_events.is_empty() {
         // This prevents events staying active on the next frame.
         collision_events.clear();
-        audio.play(sound.0.clone());
+        commands.spawn(AudioBundle {
+            source: sound.0.clone(),
+            // auto-despawn the entity when playback finishes
+            settings: PlaybackSettings::DESPAWN,
+        });
     }
 }
diff --git a/examples/mobile/src/lib.rs b/examples/mobile/src/lib.rs
index e6bca949e17547..b89a98490c4eed 100644
--- a/examples/mobile/src/lib.rs
+++ b/examples/mobile/src/lib.rs
@@ -152,7 +152,9 @@ fn button_handler(
     }
 }
 
-fn setup_music(asset_server: Res<AssetServer>, audio: Res<Audio>) {
-    let music = asset_server.load("sounds/Windless Slopes.ogg");
-    audio.play(music);
+fn setup_music(asset_server: Res<AssetServer>, mut commands: Commands) {
+    commands.spawn(AudioBundle {
+        source: asset_server.load("sounds/Windless Slopes.ogg"),
+        settings: PlaybackSettings::LOOP,
+    });
 }

From a1feab939abf8f4c174577aa19fc48cff7ee8dd0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois?= <mockersf@gmail.com>
Date: Sun, 9 Jul 2023 00:31:30 +0200
Subject: [PATCH 07/30] make accesskit_unix optional again (#9074)

# Objective

- accesskit_unix is not optional anymore

## Solution

- Enable `async-io` feature of `accesskit_winit` only when
`accesskit_unix` is enabled
---
 crates/bevy_winit/Cargo.toml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_winit/Cargo.toml b/crates/bevy_winit/Cargo.toml
index 0b8362127448b7..0421993b50b263 100644
--- a/crates/bevy_winit/Cargo.toml
+++ b/crates/bevy_winit/Cargo.toml
@@ -12,7 +12,7 @@ keywords = ["bevy"]
 trace = []
 wayland = ["winit/wayland", "winit/wayland-csd-adwaita"]
 x11 = ["winit/x11"]
-accesskit_unix = ["accesskit_winit/accesskit_unix"]
+accesskit_unix = ["accesskit_winit/accesskit_unix", "accesskit_winit/async-io"]
 
 [dependencies]
 # bevy
@@ -29,7 +29,7 @@ bevy_tasks = { path = "../bevy_tasks", version = "0.11.0-dev" }
 
 # other
 winit = { version = "0.28", default-features = false }
-accesskit_winit = { version = "0.14", default-features = false, features = ["async-io"] }
+accesskit_winit = { version = "0.14", default-features = false }
 approx = { version = "0.5", default-features = false }
 raw-window-handle = "0.5"
 

From d33f5c759c33e657dcd3dc66f2fb828a21221162 Mon Sep 17 00:00:00 2001
From: James Liu <contact@jamessliu.com>
Date: Sat, 8 Jul 2023 21:22:15 -0700
Subject: [PATCH 08/30] Add optional single-threaded feature to
 bevy_ecs/bevy_tasks (#6690)

# Objective
Fixes #6689.

## Solution
Add `single-threaded` as an optional non-default feature to `bevy_ecs`
and `bevy_tasks` that:

 - disable the `ParallelExecutor` as a default runner
 - disables the multi-threaded `TaskPool`
- internally replace `QueryParIter::for_each` calls with
`Query::for_each`.

Removed the `Mutex` and `Arc` usage in the single-threaded task pool.


![image](https://user-images.githubusercontent.com/3137680/202833253-dd2d520f-75e6-4c7b-be2d-5ce1523cbd38.png)

## Future Work/TODO
Create type aliases for `Mutex`, `Arc` that change to single-threaaded
equivalents where possible.

---

## Changelog
Added: Optional default feature `multi-theaded` to that enables
multithreaded parallelism in the engine. Disabling it disables all
multithreading in exchange for higher single threaded performance. Does
nothing on WASM targets.

---------

Co-authored-by: Carter Anderson <mcanders1@gmail.com>
---
 Cargo.toml                                    |  4 +
 crates/bevy_ecs/Cargo.toml                    |  3 +-
 crates/bevy_ecs/src/query/par_iter.rs         | 40 ++++++----
 crates/bevy_ecs/src/query/state.rs            |  6 +-
 crates/bevy_ecs/src/schedule/executor/mod.rs  |  4 +-
 crates/bevy_internal/Cargo.toml               |  1 +
 crates/bevy_internal/src/default_plugins.rs   |  2 +-
 crates/bevy_tasks/Cargo.toml                  |  4 +
 crates/bevy_tasks/src/lib.rs                  |  8 +-
 .../src/single_threaded_task_pool.rs          | 75 +++++++++++++------
 docs/cargo_features.md                        |  1 +
 11 files changed, 101 insertions(+), 47 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 8e8f2f4997a655..3f3f3fdc24fc0b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -44,6 +44,7 @@ default = [
   "bevy_sprite",
   "bevy_text",
   "bevy_ui",
+  "multi-threaded",
   "png",
   "hdr",
   "ktx2",
@@ -199,6 +200,9 @@ filesystem_watcher = ["bevy_internal/filesystem_watcher"]
 # Enable serialization support through serde
 serialize = ["bevy_internal/serialize"]
 
+# Enables multithreaded parallelism in the engine. Disabling it forces all engine tasks to run on a single thread.
+multi-threaded = ["bevy_internal/multi-threaded"]
+
 # Wayland display server support
 wayland = ["bevy_internal/wayland"]
 
diff --git a/crates/bevy_ecs/Cargo.toml b/crates/bevy_ecs/Cargo.toml
index c19073b2c97ae1..7551a987aea980 100644
--- a/crates/bevy_ecs/Cargo.toml
+++ b/crates/bevy_ecs/Cargo.toml
@@ -11,7 +11,8 @@ categories = ["game-engines", "data-structures"]
 
 [features]
 trace = []
-default = ["bevy_reflect"]
+multi-threaded = ["bevy_tasks/multi-threaded"]
+default = ["bevy_reflect", "multi-threaded"]
 
 [dependencies]
 bevy_ptr = { path = "../bevy_ptr", version = "0.11.0-dev" }
diff --git a/crates/bevy_ecs/src/query/par_iter.rs b/crates/bevy_ecs/src/query/par_iter.rs
index 426858b89abb63..6df124848adde9 100644
--- a/crates/bevy_ecs/src/query/par_iter.rs
+++ b/crates/bevy_ecs/src/query/par_iter.rs
@@ -1,5 +1,4 @@
 use crate::{component::Tick, world::unsafe_world_cell::UnsafeWorldCell};
-use bevy_tasks::ComputeTaskPool;
 use std::ops::Range;
 
 use super::{QueryItem, QueryState, ROQueryItem, ReadOnlyWorldQuery, WorldQuery};
@@ -34,6 +33,8 @@ pub struct BatchingStrategy {
     /// increase the scheduling overhead for the iteration.
     ///
     /// Defaults to 1.
+    ///
+    /// [`ComputeTaskPool`]: bevy_tasks::ComputeTaskPool
     pub batches_per_thread: usize,
 }
 
@@ -148,23 +149,36 @@ impl<'w, 's, Q: WorldQuery, F: ReadOnlyWorldQuery> QueryParIter<'w, 's, Q, F> {
     /// [`ComputeTaskPool`]: bevy_tasks::ComputeTaskPool
     #[inline]
     unsafe fn for_each_unchecked<FN: Fn(QueryItem<'w, Q>) + Send + Sync + Clone>(&self, func: FN) {
-        let thread_count = ComputeTaskPool::get().thread_num();
-        if thread_count <= 1 {
+        #[cfg(any(target = "wasm32", not(feature = "multi-threaded")))]
+        {
             self.state
                 .for_each_unchecked_manual(self.world, func, self.last_run, self.this_run);
-        } else {
-            // Need a batch size of at least 1.
-            let batch_size = self.get_batch_size(thread_count).max(1);
-            self.state.par_for_each_unchecked_manual(
-                self.world,
-                batch_size,
-                func,
-                self.last_run,
-                self.this_run,
-            );
+        }
+        #[cfg(all(not(target = "wasm32"), feature = "multi-threaded"))]
+        {
+            let thread_count = bevy_tasks::ComputeTaskPool::get().thread_num();
+            if thread_count <= 1 {
+                self.state.for_each_unchecked_manual(
+                    self.world,
+                    func,
+                    self.last_run,
+                    self.this_run,
+                );
+            } else {
+                // Need a batch size of at least 1.
+                let batch_size = self.get_batch_size(thread_count).max(1);
+                self.state.par_for_each_unchecked_manual(
+                    self.world,
+                    batch_size,
+                    func,
+                    self.last_run,
+                    self.this_run,
+                );
+            }
         }
     }
 
+    #[cfg(all(not(target = "wasm32"), feature = "multi-threaded"))]
     fn get_batch_size(&self, thread_count: usize) -> usize {
         if self.batching_strategy.batch_size_limits.is_empty() {
             return self.batching_strategy.batch_size_limits.start;
diff --git a/crates/bevy_ecs/src/query/state.rs b/crates/bevy_ecs/src/query/state.rs
index aee797ccf662af..ef01805937ad87 100644
--- a/crates/bevy_ecs/src/query/state.rs
+++ b/crates/bevy_ecs/src/query/state.rs
@@ -10,7 +10,6 @@ use crate::{
     storage::{TableId, TableRow},
     world::{unsafe_world_cell::UnsafeWorldCell, World, WorldId},
 };
-use bevy_tasks::ComputeTaskPool;
 #[cfg(feature = "trace")]
 use bevy_utils::tracing::Instrument;
 use fixedbitset::FixedBitSet;
@@ -1031,6 +1030,9 @@ impl<Q: WorldQuery, F: ReadOnlyWorldQuery> QueryState<Q, F> {
     /// have unique access to the components they query.
     /// This does not validate that `world.id()` matches `self.world_id`. Calling this on a `world`
     /// with a mismatched [`WorldId`] is unsound.
+    ///
+    /// [`ComputeTaskPool`]: bevy_tasks::ComputeTaskPool
+    #[cfg(all(not(target = "wasm32"), feature = "multi-threaded"))]
     pub(crate) unsafe fn par_for_each_unchecked_manual<
         'w,
         FN: Fn(Q::Item<'w>) + Send + Sync + Clone,
@@ -1044,7 +1046,7 @@ impl<Q: WorldQuery, F: ReadOnlyWorldQuery> QueryState<Q, F> {
     ) {
         // NOTE: If you are changing query iteration code, remember to update the following places, where relevant:
         // QueryIter, QueryIterationCursor, QueryManyIter, QueryCombinationIter, QueryState::for_each_unchecked_manual, QueryState::par_for_each_unchecked_manual
-        ComputeTaskPool::get().scope(|scope| {
+        bevy_tasks::ComputeTaskPool::get().scope(|scope| {
             if Q::IS_DENSE && F::IS_DENSE {
                 // SAFETY: We only access table data that has been registered in `self.archetype_component_access`.
                 let tables = &world.storages().tables;
diff --git a/crates/bevy_ecs/src/schedule/executor/mod.rs b/crates/bevy_ecs/src/schedule/executor/mod.rs
index ffc4ca1bd78f25..2b2a6c139e46b9 100644
--- a/crates/bevy_ecs/src/schedule/executor/mod.rs
+++ b/crates/bevy_ecs/src/schedule/executor/mod.rs
@@ -33,13 +33,13 @@ pub enum ExecutorKind {
     ///
     /// Useful if you're dealing with a single-threaded environment, saving your threads for
     /// other things, or just trying minimize overhead.
-    #[cfg_attr(target_arch = "wasm32", default)]
+    #[cfg_attr(any(target_arch = "wasm32", not(feature = "multi-threaded")), default)]
     SingleThreaded,
     /// Like [`SingleThreaded`](ExecutorKind::SingleThreaded) but calls [`apply_deferred`](crate::system::System::apply_deferred)
     /// immediately after running each system.
     Simple,
     /// Runs the schedule using a thread pool. Non-conflicting systems can run in parallel.
-    #[cfg_attr(not(target_arch = "wasm32"), default)]
+    #[cfg_attr(all(not(target_arch = "wasm32"), feature = "multi-threaded"), default)]
     MultiThreaded,
 }
 
diff --git a/crates/bevy_internal/Cargo.toml b/crates/bevy_internal/Cargo.toml
index 8c8fa2c4dfb8c8..658ab05977005e 100644
--- a/crates/bevy_internal/Cargo.toml
+++ b/crates/bevy_internal/Cargo.toml
@@ -66,6 +66,7 @@ shader_format_spirv = ["bevy_render/shader_format_spirv"]
 filesystem_watcher = ["bevy_asset/filesystem_watcher"]
 
 serialize = ["bevy_core/serialize", "bevy_input/serialize", "bevy_time/serialize", "bevy_window/serialize", "bevy_transform/serialize", "bevy_math/serialize", "bevy_scene/serialize"]
+multi-threaded = ["bevy_ecs/multi-threaded", "bevy_tasks/multi-threaded"]
 
 # Display server protocol support (X11 is enabled by default)
 wayland = ["bevy_winit/wayland"]
diff --git a/crates/bevy_internal/src/default_plugins.rs b/crates/bevy_internal/src/default_plugins.rs
index fe3be50bf95362..95bee297d81884 100644
--- a/crates/bevy_internal/src/default_plugins.rs
+++ b/crates/bevy_internal/src/default_plugins.rs
@@ -81,7 +81,7 @@ impl PluginGroup for DefaultPlugins {
                 // compressed texture formats
                 .add(bevy_render::texture::ImagePlugin::default());
 
-            #[cfg(not(target_arch = "wasm32"))]
+            #[cfg(all(not(target_arch = "wasm32"), feature = "multi-threaded"))]
             {
                 group = group
                     .add(bevy_render::pipelined_rendering::PipelinedRenderingPlugin::default());
diff --git a/crates/bevy_tasks/Cargo.toml b/crates/bevy_tasks/Cargo.toml
index 60163485955edf..9005800f15bd60 100644
--- a/crates/bevy_tasks/Cargo.toml
+++ b/crates/bevy_tasks/Cargo.toml
@@ -8,6 +8,10 @@ repository = "https://github.com/bevyengine/bevy"
 license = "MIT OR Apache-2.0"
 keywords = ["bevy"]
 
+[features]
+multi-threaded = []
+default = ["multi-threaded"]
+
 [dependencies]
 futures-lite = "1.4.0"
 async-executor = "1.3.0"
diff --git a/crates/bevy_tasks/src/lib.rs b/crates/bevy_tasks/src/lib.rs
index 538222883071f4..ffdce2d63c045f 100644
--- a/crates/bevy_tasks/src/lib.rs
+++ b/crates/bevy_tasks/src/lib.rs
@@ -8,14 +8,14 @@ pub use slice::{ParallelSlice, ParallelSliceMut};
 mod task;
 pub use task::Task;
 
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(not(target_arch = "wasm32"), feature = "multi-threaded"))]
 mod task_pool;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(not(target_arch = "wasm32"), feature = "multi-threaded"))]
 pub use task_pool::{Scope, TaskPool, TaskPoolBuilder};
 
-#[cfg(target_arch = "wasm32")]
+#[cfg(any(target_arch = "wasm32", not(feature = "multi-threaded")))]
 mod single_threaded_task_pool;
-#[cfg(target_arch = "wasm32")]
+#[cfg(any(target_arch = "wasm32", not(feature = "multi-threaded")))]
 pub use single_threaded_task_pool::{Scope, TaskPool, TaskPoolBuilder, ThreadExecutor};
 
 mod usages;
diff --git a/crates/bevy_tasks/src/single_threaded_task_pool.rs b/crates/bevy_tasks/src/single_threaded_task_pool.rs
index b1546884bce51e..92e2928124c94f 100644
--- a/crates/bevy_tasks/src/single_threaded_task_pool.rs
+++ b/crates/bevy_tasks/src/single_threaded_task_pool.rs
@@ -1,9 +1,10 @@
-use std::{
-    future::Future,
-    marker::PhantomData,
-    mem,
-    sync::{Arc, Mutex},
-};
+#[cfg(target_arch = "wasm32")]
+use std::sync::Arc;
+use std::{cell::RefCell, future::Future, marker::PhantomData, mem, rc::Rc};
+
+thread_local! {
+    static LOCAL_EXECUTOR: async_executor::LocalExecutor<'static> = async_executor::LocalExecutor::new();
+}
 
 /// Used to create a TaskPool
 #[derive(Debug, Default, Clone)]
@@ -76,7 +77,7 @@ impl TaskPool {
         1
     }
 
-    /// Allows spawning non-`static futures on the thread pool. The function takes a callback,
+    /// Allows spawning non-'static futures on the thread pool. The function takes a callback,
     /// passing a scope object into it. The scope object provided to the callback can be used
     /// to spawn tasks. This function will await the completion of all tasks before returning.
     ///
@@ -108,8 +109,9 @@ impl TaskPool {
         let executor: &'env async_executor::LocalExecutor<'env> =
             unsafe { mem::transmute(executor) };
 
-        let results: Mutex<Vec<Arc<Mutex<Option<T>>>>> = Mutex::new(Vec::new());
-        let results: &'env Mutex<Vec<Arc<Mutex<Option<T>>>>> = unsafe { mem::transmute(&results) };
+        let results: RefCell<Vec<Rc<RefCell<Option<T>>>>> = RefCell::new(Vec::new());
+        let results: &'env RefCell<Vec<Rc<RefCell<Option<T>>>>> =
+            unsafe { mem::transmute(&results) };
 
         let mut scope = Scope {
             executor,
@@ -125,29 +127,36 @@ impl TaskPool {
         // Loop until all tasks are done
         while executor.try_tick() {}
 
-        let results = scope.results.lock().unwrap();
+        let results = scope.results.borrow();
         results
             .iter()
-            .map(|result| result.lock().unwrap().take().unwrap())
+            .map(|result| result.borrow_mut().take().unwrap())
             .collect()
     }
 
-    /// Spawns a static future onto the JS event loop. For now it is returning FakeTask
-    /// instance with no-op detach method. Returning real Task is possible here, but tricky:
-    /// future is running on JS event loop, Task is running on async_executor::LocalExecutor
-    /// so some proxy future is needed. Moreover currently we don't have long-living
-    /// LocalExecutor here (above `spawn` implementation creates temporary one)
-    /// But for typical use cases it seems that current implementation should be sufficient:
-    /// caller can spawn long-running future writing results to some channel / event queue
-    /// and simply call detach on returned Task (like AssetServer does) - spawned future
-    /// can write results to some channel / event queue.
+    /// Spawns a static future onto the thread pool. The returned Task is a future. It can also be
+    /// cancelled and "detached" allowing it to continue running without having to be polled by the
+    /// end-user.
+    ///
+    /// If the provided future is non-`Send`, [`TaskPool::spawn_local`] should be used instead.
     pub fn spawn<T>(&self, future: impl Future<Output = T> + 'static) -> FakeTask
     where
         T: 'static,
     {
+        #[cfg(target_arch = "wasm32")]
         wasm_bindgen_futures::spawn_local(async move {
             future.await;
         });
+
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            LOCAL_EXECUTOR.with(|executor| {
+                let _task = executor.spawn(future);
+                // Loop until all tasks are done
+                while executor.try_tick() {}
+            });
+        }
+
         FakeTask
     }
 
@@ -158,6 +167,24 @@ impl TaskPool {
     {
         self.spawn(future)
     }
+
+    /// Runs a function with the local executor. Typically used to tick
+    /// the local executor on the main thread as it needs to share time with
+    /// other things.
+    ///
+    /// ```rust
+    /// use bevy_tasks::TaskPool;
+    ///
+    /// TaskPool::new().with_local_executor(|local_executor| {
+    ///     local_executor.try_tick();
+    /// });
+    /// ```
+    pub fn with_local_executor<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce(&async_executor::LocalExecutor) -> R,
+    {
+        LOCAL_EXECUTOR.with(f)
+    }
 }
 
 #[derive(Debug)]
@@ -175,7 +202,7 @@ impl FakeTask {
 pub struct Scope<'scope, 'env: 'scope, T> {
     executor: &'env async_executor::LocalExecutor<'env>,
     // Vector to gather results of all futures spawned during scope run
-    results: &'env Mutex<Vec<Arc<Mutex<Option<T>>>>>,
+    results: &'env RefCell<Vec<Rc<RefCell<Option<T>>>>>,
 
     // make `Scope` invariant over 'scope and 'env
     scope: PhantomData<&'scope mut &'scope ()>,
@@ -211,10 +238,10 @@ impl<'scope, 'env, T: Send + 'env> Scope<'scope, 'env, T> {
     ///
     /// For more information, see [`TaskPool::scope`].
     pub fn spawn_on_scope<Fut: Future<Output = T> + 'env>(&self, f: Fut) {
-        let result = Arc::new(Mutex::new(None));
-        self.results.lock().unwrap().push(result.clone());
+        let result = Rc::new(RefCell::new(None));
+        self.results.borrow_mut().push(result.clone());
         let f = async move {
-            result.lock().unwrap().replace(f.await);
+            result.borrow_mut().replace(f.await);
         };
         self.executor.spawn(f).detach();
     }
diff --git a/docs/cargo_features.md b/docs/cargo_features.md
index bf6a5e55fc643c..497fa403a332c3 100644
--- a/docs/cargo_features.md
+++ b/docs/cargo_features.md
@@ -31,6 +31,7 @@ The default feature set enables most of the expected features of a game engine,
 |filesystem_watcher|Enable watching file system for asset hot reload|
 |hdr|HDR image format support|
 |ktx2|KTX2 compressed texture support|
+|multi-threaded|Enables multithreaded parallelism in the engine. Disabling it forces all engine tasks to run on a single thread.|
 |png|PNG image format support|
 |tonemapping_luts|Include tonemapping Look Up Tables KTX2 files|
 |vorbis|OGG/VORBIS audio format support|

From f213c14d90fd5afb65fc11803777ef7f1c3fbe1b Mon Sep 17 00:00:00 2001
From: B_head <b_head@outlook.jp>
Date: Sun, 9 Jul 2023 13:25:12 +0900
Subject: [PATCH 09/30] Fix not calling `App::finish` and `App::cleanup` in
 `ScheduleRunnerPlugin` (#9054)

This pull request is mutually exclusive with #9066.

# Objective

Complete the initialization of the plugin in `ScheduleRunnerPlugin`.

## Solution

Wait for asynchronous tasks to complete, then `App::finish` and
`App::cleanup` in the runner function.
---
 crates/bevy_app/src/schedule_runner.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/crates/bevy_app/src/schedule_runner.rs b/crates/bevy_app/src/schedule_runner.rs
index c143f75c42f532..d303769f926960 100644
--- a/crates/bevy_app/src/schedule_runner.rs
+++ b/crates/bevy_app/src/schedule_runner.rs
@@ -71,6 +71,13 @@ impl Plugin for ScheduleRunnerPlugin {
     fn build(&self, app: &mut App) {
         let run_mode = self.run_mode;
         app.set_runner(move |mut app: App| {
+            while !app.ready() {
+                #[cfg(not(target_arch = "wasm32"))]
+                bevy_tasks::tick_global_task_pools_on_main_thread();
+            }
+            app.finish();
+            app.cleanup();
+
             let mut app_exit_event_reader = ManualEventReader::<AppExit>::default();
             match run_mode {
                 RunMode::Once => {

From 00943f4f08e62a745952e5ad9fa717aa24de840c Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Sun, 9 Jul 2023 08:33:22 +0100
Subject: [PATCH 10/30] Growing UI nodes Fix (#8931)

# Objective

fixes #8911, #7712

## Solution

Rounding was added to Taffy which fixed issue #7712.
The implementation uses the f32 `round` method which rounds ties
(fractional part is a half) away from zero. Issue #8911 occurs when a
node's min and max bounds on either axis are "ties" and zero is between
them. Then the bounds are rounded away from each other, and the node
grows by a pixel. This alone shouldn't cause the node to expand
continuously, but I think there is some interaction with the way Taffy
recomputes a layout from its cached data that I didn't identify.

This PR fixes #8911 by first disabling Taffy's internal rounding and
using an alternative rounding function that rounds ties up.
Then, instead of rounding the values of the internal layout tree as
Taffy's built-in rounding does, we leave those values unmodified and
only the values stored in the components are rounded. This requires
walking the tree for the UI node geometry update rather than iterating
through a query.

Because the component values are regenerated each update, that should
mean that UI updates are idempotent (ish) now and make the growing node
behaviour seen in issue #8911 impossible.

I expected a performance regression, but it's an improvement on main:

```
cargo run --profile stress-test --features trace_tracy --example many_buttons
```

<img width="461" alt="ui-rounding-fix-compare"
src="https://github.com/bevyengine/bevy/assets/27962798/914bfd50-e18a-4642-b262-fafa69005432">

I guess it makes sense to do the rounding together with the node size
and position updates.

---

## Changelog

`bevy_ui::layout`:
* Taffy's built-in rounding is disabled and rounding is now performed by
`ui_layout_system`.

* Instead of rounding the values of the internal layout tree as Taffy's
built-in rounding does, we leave those values unmodified and only the
values stored in the components are rounded. This requires walking the
tree for the UI node geometry update rather than iterating through a
query. Because the component values are regenerated each update, that
should mean that UI updates are idempotent now and make the growing node
behaviour seen in issue #8911 impossible.

* Added two helper functions `round_ties_up` and
`round_layout_coordinates`.

---------

Co-authored-by: Carter Anderson <mcanders1@gmail.com>
---
 crates/bevy_ui/src/layout/mod.rs | 112 +++++++++++++++++++++++--------
 1 file changed, 85 insertions(+), 27 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index cc4cc9301db91b..8063eaac76a2a5 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -64,10 +64,12 @@ impl fmt::Debug for UiSurface {
 
 impl Default for UiSurface {
     fn default() -> Self {
+        let mut taffy = Taffy::new();
+        taffy.disable_rounding();
         Self {
             entity_to_taffy: Default::default(),
             window_nodes: Default::default(),
-            taffy: Taffy::new(),
+            taffy,
         }
     }
 }
@@ -223,9 +225,10 @@ pub fn ui_layout_system(
     style_query: Query<(Entity, Ref<Style>), With<Node>>,
     mut measure_query: Query<(Entity, &mut ContentSize)>,
     children_query: Query<(Entity, Ref<Children>), With<Node>>,
+    just_children_query: Query<&Children>,
     mut removed_children: RemovedComponents<Children>,
     mut removed_content_sizes: RemovedComponents<ContentSize>,
-    mut node_transform_query: Query<(Entity, &mut Node, &mut Transform, Option<&Parent>)>,
+    mut node_transform_query: Query<(&mut Node, &mut Transform)>,
     mut removed_nodes: RemovedComponents<Node>,
 ) {
     // assume one window for time being...
@@ -301,33 +304,88 @@ pub fn ui_layout_system(
     // compute layouts
     ui_surface.compute_window_layouts();
 
-    let physical_to_logical_factor = 1. / scale_factor;
+    let inverse_target_scale_factor = 1. / scale_factor;
 
-    let to_logical = |v| (physical_to_logical_factor * v as f64) as f32;
-
-    // PERF: try doing this incrementally
-    for (entity, mut node, mut transform, parent) in &mut node_transform_query {
-        let layout = ui_surface.get_layout(entity).unwrap();
-        let new_size = Vec2::new(
-            to_logical(layout.size.width),
-            to_logical(layout.size.height),
-        );
-        // only trigger change detection when the new value is different
-        if node.calculated_size != new_size {
-            node.calculated_size = new_size;
-        }
-        let mut new_position = transform.translation;
-        new_position.x = to_logical(layout.location.x + layout.size.width / 2.0);
-        new_position.y = to_logical(layout.location.y + layout.size.height / 2.0);
-        if let Some(parent) = parent {
-            if let Ok(parent_layout) = ui_surface.get_layout(**parent) {
-                new_position.x -= to_logical(parent_layout.size.width / 2.0);
-                new_position.y -= to_logical(parent_layout.size.height / 2.0);
+    fn update_uinode_geometry_recursive(
+        entity: Entity,
+        ui_surface: &UiSurface,
+        node_transform_query: &mut Query<(&mut Node, &mut Transform)>,
+        children_query: &Query<&Children>,
+        inverse_target_scale_factor: f32,
+        parent_size: Vec2,
+        mut absolute_location: Vec2,
+    ) {
+        if let Ok((mut node, mut transform)) = node_transform_query.get_mut(entity) {
+            let layout = ui_surface.get_layout(entity).unwrap();
+            let layout_size = Vec2::new(layout.size.width, layout.size.height);
+            let layout_location = Vec2::new(layout.location.x, layout.location.y);
+
+            absolute_location += layout_location;
+            let rounded_location = round_layout_coords(layout_location);
+            let rounded_size = round_layout_coords(absolute_location + layout_size)
+                - round_layout_coords(absolute_location);
+
+            let new_size = inverse_target_scale_factor * rounded_size;
+            let new_position =
+                inverse_target_scale_factor * rounded_location + 0.5 * (new_size - parent_size);
+
+            // only trigger change detection when the new values are different
+            if node.calculated_size != new_size {
+                node.calculated_size = new_size;
+            }
+            if transform.translation.truncate() != new_position {
+                transform.translation = new_position.extend(0.);
+            }
+            if let Ok(children) = children_query.get(entity) {
+                for &child_uinode in children {
+                    update_uinode_geometry_recursive(
+                        child_uinode,
+                        ui_surface,
+                        node_transform_query,
+                        children_query,
+                        inverse_target_scale_factor,
+                        new_size,
+                        absolute_location,
+                    );
+                }
             }
         }
-        // only trigger change detection when the new value is different
-        if transform.translation != new_position {
-            transform.translation = new_position;
-        }
+    }
+
+    for entity in root_node_query.iter() {
+        update_uinode_geometry_recursive(
+            entity,
+            &ui_surface,
+            &mut node_transform_query,
+            &just_children_query,
+            inverse_target_scale_factor as f32,
+            Vec2::ZERO,
+            Vec2::ZERO,
+        );
+    }
+}
+
+#[inline]
+/// Round `value` to the closest whole integer, with ties (values with a fractional part equal to 0.5) rounded towards positive infinity.
+fn round_ties_up(value: f32) -> f32 {
+    if 0. <= value || value.fract() != 0.5 {
+        // The `round` function rounds ties away from zero. For positive numbers "away from zero" is towards positive infinity.
+        // So for all positive values, and negative values with a fractional part not equal to 0.5, `round` returns the correct result.
+        value.round()
+    } else {
+        // In the remaining cases, where `value` is negative and its fractional part is equal to 0.5, we use `ceil` to round it up towards positive infinity.
+        value.ceil()
+    }
+}
+
+#[inline]
+/// Rust `f32` only has support for rounding ties away from zero.
+/// When rounding the layout coordinates we need to round ties up, otherwise we can gain a pixel.
+/// For example consider a node with left and right bounds of -50.5 and 49.5 (width: 49.5 - (-50.5) == 100).
+/// After rounding left and right away from zero we get -51 and 50 (width: 50 - (-51) == 101), gaining a pixel.
+fn round_layout_coords(value: Vec2) -> Vec2 {
+    Vec2 {
+        x: round_ties_up(value.x),
+        y: round_ties_up(value.y),
     }
 }

From acdeeb893aca2894ba9299ca066c3f3c4e899feb Mon Sep 17 00:00:00 2001
From: Carter Anderson <mcanders1@gmail.com>
Date: Sun, 9 Jul 2023 01:09:25 -0700
Subject: [PATCH 11/30] Add 0.11.0 changelog (#9078)

This release I'm experimenting with a new changelog format that doesn't
sap hours of extra time to put together. Basically:

1. Sort by "development area" instead of added / changed / fixed. These
distinctions are often unclear anyway and we have no automated way of
assigning them currently. "Development area" sorting feels equally
useful (if not more useful). Our changelog generator also already does
"development area" categorization so this is efficient.
2. Sort by "importance" and trim out irrelevant changes. This is
laborious, but I already do this as part of my blog post construction
methodology, so it isn't "extra" work.
---
 CHANGELOG.md | 684 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 683 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ade264b8a6473f..f6f433f14e2fd7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,7 +7,689 @@ While we try to keep the `Unreleased` changes updated, it is often behind and do
 all merged pull requests. To see a list of all changes since the latest release, you may compare
 current changes on git with [previous release tags][git_tag_comparison].
 
-[git_tag_comparison]: https://github.com/bevyengine/bevy/compare/v0.9.0...main
+[git_tag_comparison]: https://github.com/bevyengine/bevy/compare/v0.10.0...main
+
+## Version 0.11.0 (2023-07-09)
+
+### Rendering
+
+- [Webgpu support][8336]
+- [improve shader import model][5703]
+- [Screen Space Ambient Occlusion (SSAO) MVP][7402]
+- [Temporal Antialiasing (TAA)][7291]
+- [Immediate Mode Line/Gizmo Drawing][6529]
+- [Make render graph slots optional for most cases][8109]
+- [Split opaque and transparent phases][8090]
+- [Built-in skybox][8275]
+- [Add parallax mapping to bevy PBR][5928]
+- [Add port of AMD's Robust Contrast Adaptive Sharpening][7422]
+- [Add RenderGraphApp to simplify adding render nodes][8007]
+- [Add screenshot api][7163]
+- [Add morph targets][8158]
+- [Screenshots in wasm][8455]
+- [Add ViewNode to simplify render node management][8118]
+- [Bias texture mipmaps][7614]
+- [Instanced line rendering for gizmos based on `bevy_polyline`][8427]
+- [Add `RenderTarget::TextureView`][8042]
+- [Change default tonemapping method][8685]
+- [Allow custom depth texture usage][6815]
+- [Use the prepass normal texture in main pass when possible][8231]
+- [Left-handed y-up cubemap coordinates][8122]
+- [Allow SPIR-V shaders to process when shader defs are present][7772]
+- [Remove unnecesssary values Vec from DynamicUniformBuffer and DynamicStorageBuffer][8299]
+- [Add `MAY_DISCARD` shader def, enabling early depth tests for most cases][6697]
+- [Add `Aabb` calculation for `Sprite`, `TextureAtlasSprite` and `Mesh2d`][7885]
+- [Color::Lcha constructors][8041]
+- [Fix Color::as_rgba_linear for Color::Lcha][8040]
+- [Added Globals struct to prepass shader][8070]
+- [Derive Copy and Clone for Collision][8121]
+- [Fix crash when enabling HDR on 2d cameras][8151]
+- [Dither fix][7977]
+- [Compute `vertex_count` for indexed meshes on `GpuMesh`][8460]
+- [Run update_previous_view_projections in PreUpdate schedule][9024]
+- [Added `WebP` image format support][8220]
+- [Add support for pnm textures][8601]
+- [fix invalid bone weights][8316]
+- [Fix pbr shader breaking on missing UVs][8412]
+- [Fix Plane UVs / texture flip][8878]
+- [Fix look_to resulting in NaN rotations][7817]
+- [Fix look_to variable naming][8627]
+- [Fix segfault with 2d gizmos][8223]
+- [Use RenderGraphApp in more places][8298]
+- [Fix viewport change detection][8323]
+- [Remove capacity fields from all Buffer wrapper types][8301]
+- [Sync pbr_types.wgsl StandardMaterial values][8380]
+- [Avoid spawning gizmo meshes when no gizmos are being drawn][8180]
+- [Use a consistent seed for AABB gizmo colors][9030]
+- [bevy_pbr: Do not cull meshes without Aabbs from cascades][8444]
+- [Handle vertex_uvs if they are present in default prepass fragment shader][8330]
+- [Changed (Vec2, Vec2) to Rect in Camera::logical_viewport_rect][7867]
+- [make glsl and spirv support optional][8491]
+- [fix prepass normal_mapping][8978]
+- [conversions between [u8; 4] and Color][8564]
+- [Add option to disable gizmo rendering for specific cameras][8952]
+- [Fix morph target prepass shader][9013]
+- [Fix bloom wasm support][8631]
+- [Fix black spots appearing due to NANs when SSAO is enabled][8926]
+- [fix normal prepass][8890]
+- [Refs #8975 -- Add return to RenderDevice::poll()][8977]
+- [Fix WebGL mode for Adreno GPUs][8508]
+- [Fix parallax mapping][9003]
+- [Added Vec append to BufferVec - Issue #3531][8575]
+- [Fix CAS shader with explicit FullscreenVertexOutput import][8993]
+- [Make `TextureAtlas::texture_handles` `pub` instead of `pub(crate)` (#8633)][8643]
+- [Make Material2d pipeline systems public][8642]
+- [Fix screenshots on Wayland + Nvidia][8701]
+- [Apply codebase changes in preparation for `StandardMaterial` transmission][8704]
+- [Use ViewNode for TAA][8732]
+- [Change Camera3dBundle::tonemapping to Default][8753]
+- [Remove `Component` derive for AlphaMode][8804]
+- [Make setup of Opaque3dPrepass and AlphaMask3dPrepass phase items consistent with others][8408]
+- [Rename `Plane` struct to `HalfSpace`][8744]
+- [Expand `FallbackImage` to include a `GpuImage` for each possible `TextureViewDimension`][6974]
+- [Cascaded shadow maps: Fix prepass ortho depth clamping][8877]
+- [Fix gizmos in WebGPU][8910]
+- [Fix AsBindGroup derive, texture attribute, visibility flag parsing][8868]
+- [Disable camera on window close][8802]
+- [Reflect `Component` and `Default` of `BloomSettings`][8283]
+- [Add Reflection Macros to TextureAtlasSprite][8428]
+- [Implement Reflect on NoFrustumCulling][8801]
+
+### Audio
+
+- [ECS-based API redesign][8424]
+- [Ability to set a Global Volume][7706]
+- [Expose `AudioSink::empty()`][8145]
+
+### Diagnostics
+
+- [Allow systems using Diagnostics to run in parallel][8677]
+- [add a feature for memory tracing with tracy][8272]
+- [Re-add the "frame" span for tracy comparisons][8362]
+- [log to stderr instead of stdout][8886]
+
+### Scenes
+
+- [bevy_scene: Add SceneFilter][6793]
+- [(De) serialize resources in scenes][6846]
+- [add position to scene errors][8065]
+- [Bugfix: Scene reload fix (nonbreaking)][7951]
+- [avoid panic with parented scenes on deleted entities][8512]
+
+### Transform + Hierarchy
+
+- [Fix transform propagation of orphaned entities][7264]
+
+### Gizmo
+
+- [Add a bounding box gizmo][8468]
+- [Added `arc_2d` function for gizmos][8448]
+- [Use AHash to get color from entity in bevy_gizmos][8960]
+- [do not crash when rendering only one gizmo][8434]
+
+### Reflection
+
+- [reflect: stable type path v2][7184]
+- [bevy_reflect: Better proxies][6971]
+- [bevy_reflect: FromReflect Ergonomics Implementation][6056]
+- [bevy_reflect: Allow `#[reflect(default)]` on enum variant fields][8514]
+- [Add FromReflect where Reflect is used][8776]
+- [Add get_at_mut to bevy_reflect::Map trait][8691]
+- [Reflect now requires DynamicTypePath. Remove Reflect::get_type_path()][8764]
+- [bevy_ui: Add `FromReflect` derives][8495]
+- [Add Reflect and FromReflect for AssetPath][8531]
+- [bevy_reflect: Fix trailing comma breaking derives][8014]
+- [Fix Box dyn Reflect struct with a hashmap in it panicking when clone_value is called on it][8184]
+- [bevy_reflect: Add `ReflectFromReflect` to the prelude][8496]
+- [bevy_reflect: Allow construction of MapIter outside of the bevy_reflect crate.][8723]
+- [bevy_reflect: Disambiguate type bounds in where clauses.][8761]
+- [adding reflection for Cow<'static, [T]>][7454]
+- [Do not require mut on ParsedPath::element_mut][8891]
+- [Reflect UUID][8905]
+- [Don't ignore additional entries in `UntypedReflectDeserializerVisitor`][7112]
+- [Construct Box dyn Reflect from world for ReflectComponent][7407]
+- [reflect: avoid deadlock in GenericTypeCell][8957]
+
+### App
+
+- [Allow tuples and single plugins in `add_plugins`, deprecate `add_plugin`][8097]
+- [Merge ScheduleRunnerSettings into ScheduleRunnerPlugin][8585]
+- [correctly setup everything in the default run_once runner][8740]
+- [Fix `Plugin::build` detection][8103]
+- [Fix not calling App::finish and App::cleanup in `ScheduleRunnerPlugin`][9054]
+- [Relaxed runner type from Fn to FnOnce][8961]
+- [Relax FnMut to FnOnce in app::edit_schedule][8982]
+
+### Windowing + Reflection
+
+- [Register missing types in bevy_window][7993]
+- [bevy_reflect: implement Reflect for SmolStr][8771]
+
+### Hierarchy
+
+- [fix panic when moving child][8346]
+- [Remove `Children` component when calling `despawn_descendants`][8476]
+- [Change `despawn_descendants` to return `&mut Self`][8928]
+
+### Time
+
+- [Fix timer with zero duration][8467]
+
+### Assets
+
+- [Delay asset hot reloading][8503]
+- [Add support for custom glTF vertex attributes.][5370]
+- [Fix panic when using debug_asset_server][8485]
+- [`unused_variables` warning when building with `filesystem_watcher` feature disabled][7938]
+- [bevy_asset: Add `LoadContext::get_handle_untyped`][8470]
+
+### Windowing
+
+- [Move cursor position to internal state][7988]
+- [Set cursor hittest during window creation][7966]
+- [do not set hit test unconditionally on window creation][7996]
+- [Add winit's `wayland-csd-adwaita` feature to Bevy's `wayland` feature][8722]
+- [Support to set window theme and expose system window theme changed event][8593]
+- [Touchpad magnify and rotate events][8791]
+- [Fix windows not being centered properly when system interface is scaled][8903]
+- [Expose WindowDestroyed events][9016]
+
+### Animation
+
+- [Register bevy_animation::PlayingAnimation][9023]
+
+### UI
+
+- [Ui Node Borders][7795]
+- [Add CSS Grid support to `bevy_ui`][8026]
+- [`text_system` split][7779]
+- [Replace the local text queues in the text systems with flags stored in a component][8549]
+- [`NoWrap` `Text` feature][8947]
+- [add a default font][8445]
+- [UI texture atlas support][8822]
+- [Improved UI render batching][8793]
+- [Consistent screen-space coordinates][8306]
+- [`UiImage` helper functions][8199]
+- [Perform text scaling calculations per text, not per glyph][7819]
+- [Fix size of clipped text glyphs.][8197]
+- [Apply scale factor to  `ImageMeasure` sizes][8545]
+- [Fix WebGPU error in "ui_pipeline" by adding a flat interpolate attribute][8933]
+- [Rename Interaction::Clicked -> Interaction::Pressed][9027]
+- [Flatten UI `Style` properties that use `Size` + remove `Size`][8548]
+- [Split UI `Overflow` by axis][8095]
+- [Add methods for calculating the size and postion of UI nodes][7930]
+- [Skip the UV calculations for untextured UI nodes][7809]
+- [Fix text measurement algorithm][8425]
+- [Divide by UiScale when converting UI coordinates from physical to logical][8720]
+- [`MeasureFunc` improvements][8402]
+- [Expose sorting methods in `Children`][8522]
+- [Fix min and max size using size value][7948]
+- [Fix the `Text2d` text anchor's incorrect horizontal alignment][8019]
+- [Remove `Val::Undefined`][7485]
+- [`Val` viewport unit variants][8137]
+- [Remove the corresponding measure from Taffy when a `CalculatedSize` component is removed.][8294]
+- [`UiRect` axes constructor][7656]
+- [Fix the UV calculations for clipped and flipped ImageNodes][8195]
+- [Fix text systems broken when resolving merge conflicts in #8026][8422]
+- [Allow `bevy_ui` crate to compile without the `text` feature enabled][8437]
+- [Fix the double leaf node updates in `flex_node_system`][8264]
+- [also import the default handle when feature disabled][8456]
+- [`measure_text_system` text query fix][8466]
+- [Fix panic in example: text_wrap_debug.rs][8497]
+- [UI layout tree debug print][8521]
+- [Fix `Node::physical_rect` and add a `physical_size` method][8551]
+- [Perform `relative_cursor_position` calculation vectorwise in `ui_focus_system`][8795]
+- [Add `UiRect::px()` and `UiRect::percent()` utils][8866]
+- [Add missing dependencies to `bevy_text` feature][8920]
+- [Remove "bevy_text" feature attributes on imports used by non-text systems][8907]
+- [Growing UI nodes Fix][8931]
+
+### ECS
+
+- [Schedule-First: the new and improved add_systems][8079]
+- [Add OnTransition schedule that is ran between OnExit and OnEnter][7936]
+- [`run_if` for `SystemConfigs` via anonymous system sets][7676]
+- [Remove OnUpdate system set][8260]
+- [Rename apply_system_buffers to apply_deferred][8726]
+- [Rename Command's "write" method to "apply"][8814]
+- [Require `#[derive(Event)]` on all Events][7086]
+- [Implement WorldQuery for EntityRef][6960]
+- [Improve or-with disjoint checks][7085]
+- [Add a method to run read-only systems using `&World`][8849]
+- [Reduce branching when inserting components][8053]
+- [Make `#[system_param(ignore)]` and `#[world_query(ignore)]` unnecessary][8030]
+- [Remove `#[system_param(ignore)]` and `#[world_query(ignore)]`][8265]
+- [Extend the `WorldQuery` macro to tuple structs][8119]
+- [Make state private and only accessible through getter for State resource][8009]
+- [implement `Deref` for `State<S>`][8668]
+- [Inline more ECS functions][8083]
+- [Add a `scope` API for world schedules][8387]
+- [Simplify system piping and make it more flexible][8377]
+- [Add `any_component_removed` condition][8326]
+- [Use `UnsafeWorldCell` to increase code quality for `SystemParam`][8174]
+- [Improve safety for the multi-threaded executor using `UnsafeWorldCell`][8292]
+- [Migrate the rest of the engine to `UnsafeWorldCell`][8833]
+- [Make the `Condition` trait generic][8721]
+- [Add or_else combinator to run_conditions.rs][8714]
+- [Add iter_many_manual QueryState method][8772]
+- [Provide access to world storages via UnsafeWorldCell][8987]
+- [Added Has T WorldQuery type][8844]
+- [Add/fix `track_caller` attribute on panicking entity accessor methods][8951]
+- [Increase type safety and clarity for change detection][7905]
+- [Make `WorldQuery` meta types unnameable][7964]
+- [Add a public constructor for `Mut<T>`][7931]
+- [Remove ChangeTrackers][7902]
+- [Derive Eq, PartialEq for Tick][9020]
+- [Initialize empty schedules when calling `.in_schedule` if they do not already exist][7911]
+- [Replace multiple calls to `add_system` with `add_systems`][8001]
+- [don't panic on unknown ambiguity][7950]
+- [add Clone to common conditions][8060]
+- [Make BundleInfo's fields not pub(crate)][8068]
+- [Pass query change ticks to `QueryParIter` instead of always using change ticks from `World`.][8029]
+- [Remove redundant bounds check in `Entities::get`][8108]
+- [Add World::try_run_schedule][8028]
+- [change not implemation to custom system struct][8105]
+- [Fix name conflicts caused by the `SystemParam` and `WorldQuery` macros][8012]
+- [Check for conflicting accesses in `assert_is_system`][8154]
+- [Fix field visibility for read-only `WorldQuery` types][8163]
+- [`Or<T>` should be a new type of `PhantomData<T>`][8212]
+- [Make standard commands more ergonomic (in niche cases)][8249]
+- [Remove base set error variants of `ScheduleBuildError`][8269]
+- [Replace some unsafe system executor code with safe code][8274]
+- [Update `increment_change_tick` to return a strongly-typed `Tick`][8295]
+- [Move event traces to detailed_trace!][7732]
+- [Only trigger state transitons if `next_state != old_state`][8359]
+- [Fix panics and docs when using World schedules][8364]
+- [Improve warning for Send resources marked as non_send][8000]
+- [Reorganize system modules][8419]
+- [Fix boxed labels][8436]
+- [Simplify world schedule methods][8403]
+- [Just print out name string, not the entire Name struct][8494]
+- [Manually implement common traits for `EventId`][8529]
+- [Replace remaining uses of `&T, Changed<T>` with `Ref` in UI system queries][8567]
+- [Rename `UnsafeWorldCell::read_change_tick`][8588]
+- [Improve encapsulation for commands and add docs][8725]
+- [Fix all_tuples + added docs.][8743]
+- [Add `new` and `map` methods to `Ref`][8797]
+- [Allow unsized types as mapped value in `Ref::map`][8817]
+- [Implement `Clone` for `CombinatorSystem`][8826]
+- [Add get_ref to EntityRef][8818]
+- [Make `QueryParIter::for_each_unchecked` private][8848]
+- [Simplify the `ComponentIdFor` type][8845]
+- [Add last_changed_tick and added_tick to ComponentTicks][8803]
+- [Require read-only queries in `QueryState::par_iter`][8832]
+- [Fix any_component_removed][8939]
+- [Deprecate type aliases for `WorldQuery::Fetch`][8843]
+- [bevy_ecs: add untyped methods for inserting components and bundles][7204]
+- [Move AppTypeRegistry to bevy_ecs][8901]
+- [skip check change tick for apply_deferred systems][8760]
+- [Split the bevy_ecs reflect.rs module][8834]
+- [Make function pointers of ecs Reflect* public][8687]
+
+### Rendering + Reflection + Scenes
+
+- [fix: register Cascade in the TypeRegistry][8088]
+
+### Tasks
+
+- [Add optional single-threaded feature to bevy_ecs/bevy_tasks][6690]
+
+### Math
+
+- [Re-export glam_assert feature][8232]
+- [Fix CubicCurve::iter_samples iteration count][8049]
+- [Add integer equivalents for `Rect`][7984]
+- [Add `CubicCurve::segment_count` + `iter_samples` adjustment][8711]
+
+### Rendering + Assets + Meta
+
+- [Add depending bevy features for higher level one][7855]
+
+### ECS + Scenes
+
+- [Make scene handling of entity references robust][7335]
+- [Rename map_entities and map_specific_entities][7570]
+
+### Util
+
+- [bevy_derive: Add `#[deref]` attribute][8552]
+
+### Input
+
+- [Add gamepad rumble support to bevy_input][8398]
+- [Rename keys like `LAlt` to `AltLeft`][8792]
+- [Add window entity to mouse and keyboard events][8852]
+- [Add get_unclamped to Axis][8871]
+
+### Upgrades
+
+- [Upgrade Taffy requirement to v0.3.5][7959]
+- [Update ruzstd and basis universal][8622]
+- [Updated to wgpu 0.16.0, wgpu-hal 0.16.0 and naga 0.12.0][8446]
+- [Update sysinfo requirement from 0.28.1 to 0.29.0][8650]
+- [Update libloading requirement from 0.7 to 0.8][8649]
+- [update syn, encase, glam and hexasphere][8573]
+- [Update android_log-sys requirement from 0.2.0 to 0.3.0][7925]
+- [update bitflags to 2.3][8728]
+- [Update ruzstd requirement from 0.3.1 to 0.4.0][8755]
+- [Update notify requirement from 5.0.0 to 6.0.0][8757]
+- [Bump hashbrown to 0.14][8904]
+- [update ahash and hashbrown][8623]
+- [Bump accesskit and accesskit_winit][8655]
+
+### Examples
+
+- [new example showcase tool][8561]
+- [Adding a bezier curve example][8194]
+- [Add low level post process example using a custom render pass][6909]
+- [Add example to demonstrate manual generation and UV mapping of 3D mesh (generate_custom_mesh) solve #4922][8909]
+- [Add `overflow_debug` example][8198]
+- [UI text wrapping and `LineBreakOn` example][7761]
+- [Size Constraints Example][7956]
+- [UI Display and Visibility Example][7629]
+
+[5370]: https://github.com/bevyengine/bevy/pull/5370
+[5703]: https://github.com/bevyengine/bevy/pull/5703
+[5928]: https://github.com/bevyengine/bevy/pull/5928
+[6529]: https://github.com/bevyengine/bevy/pull/6529
+[6697]: https://github.com/bevyengine/bevy/pull/6697
+[6815]: https://github.com/bevyengine/bevy/pull/6815
+[6846]: https://github.com/bevyengine/bevy/pull/6846
+[6909]: https://github.com/bevyengine/bevy/pull/6909
+[6960]: https://github.com/bevyengine/bevy/pull/6960
+[6971]: https://github.com/bevyengine/bevy/pull/6971
+[6974]: https://github.com/bevyengine/bevy/pull/6974
+[7085]: https://github.com/bevyengine/bevy/pull/7085
+[7086]: https://github.com/bevyengine/bevy/pull/7086
+[7112]: https://github.com/bevyengine/bevy/pull/7112
+[7163]: https://github.com/bevyengine/bevy/pull/7163
+[7184]: https://github.com/bevyengine/bevy/pull/7184
+[7204]: https://github.com/bevyengine/bevy/pull/7204
+[7264]: https://github.com/bevyengine/bevy/pull/7264
+[7291]: https://github.com/bevyengine/bevy/pull/7291
+[7335]: https://github.com/bevyengine/bevy/pull/7335
+[7402]: https://github.com/bevyengine/bevy/pull/7402
+[7407]: https://github.com/bevyengine/bevy/pull/7407
+[7422]: https://github.com/bevyengine/bevy/pull/7422
+[7454]: https://github.com/bevyengine/bevy/pull/7454
+[7485]: https://github.com/bevyengine/bevy/pull/7485
+[7570]: https://github.com/bevyengine/bevy/pull/7570
+[7614]: https://github.com/bevyengine/bevy/pull/7614
+[7629]: https://github.com/bevyengine/bevy/pull/7629
+[7656]: https://github.com/bevyengine/bevy/pull/7656
+[7676]: https://github.com/bevyengine/bevy/pull/7676
+[7706]: https://github.com/bevyengine/bevy/pull/7706
+[7732]: https://github.com/bevyengine/bevy/pull/7732
+[7761]: https://github.com/bevyengine/bevy/pull/7761
+[7772]: https://github.com/bevyengine/bevy/pull/7772
+[7779]: https://github.com/bevyengine/bevy/pull/7779
+[7795]: https://github.com/bevyengine/bevy/pull/7795
+[7809]: https://github.com/bevyengine/bevy/pull/7809
+[7817]: https://github.com/bevyengine/bevy/pull/7817
+[7819]: https://github.com/bevyengine/bevy/pull/7819
+[7855]: https://github.com/bevyengine/bevy/pull/7855
+[7867]: https://github.com/bevyengine/bevy/pull/7867
+[7885]: https://github.com/bevyengine/bevy/pull/7885
+[7902]: https://github.com/bevyengine/bevy/pull/7902
+[7905]: https://github.com/bevyengine/bevy/pull/7905
+[7911]: https://github.com/bevyengine/bevy/pull/7911
+[7925]: https://github.com/bevyengine/bevy/pull/7925
+[7930]: https://github.com/bevyengine/bevy/pull/7930
+[7931]: https://github.com/bevyengine/bevy/pull/7931
+[7936]: https://github.com/bevyengine/bevy/pull/7936
+[7938]: https://github.com/bevyengine/bevy/pull/7938
+[7948]: https://github.com/bevyengine/bevy/pull/7948
+[7950]: https://github.com/bevyengine/bevy/pull/7950
+[7951]: https://github.com/bevyengine/bevy/pull/7951
+[7956]: https://github.com/bevyengine/bevy/pull/7956
+[7959]: https://github.com/bevyengine/bevy/pull/7959
+[7964]: https://github.com/bevyengine/bevy/pull/7964
+[7966]: https://github.com/bevyengine/bevy/pull/7966
+[7977]: https://github.com/bevyengine/bevy/pull/7977
+[7984]: https://github.com/bevyengine/bevy/pull/7984
+[7988]: https://github.com/bevyengine/bevy/pull/7988
+[7993]: https://github.com/bevyengine/bevy/pull/7993
+[7996]: https://github.com/bevyengine/bevy/pull/7996
+[8000]: https://github.com/bevyengine/bevy/pull/8000
+[8001]: https://github.com/bevyengine/bevy/pull/8001
+[8007]: https://github.com/bevyengine/bevy/pull/8007
+[8009]: https://github.com/bevyengine/bevy/pull/8009
+[8012]: https://github.com/bevyengine/bevy/pull/8012
+[8014]: https://github.com/bevyengine/bevy/pull/8014
+[8019]: https://github.com/bevyengine/bevy/pull/8019
+[8026]: https://github.com/bevyengine/bevy/pull/8026
+[8028]: https://github.com/bevyengine/bevy/pull/8028
+[8029]: https://github.com/bevyengine/bevy/pull/8029
+[8030]: https://github.com/bevyengine/bevy/pull/8030
+[8040]: https://github.com/bevyengine/bevy/pull/8040
+[8041]: https://github.com/bevyengine/bevy/pull/8041
+[8042]: https://github.com/bevyengine/bevy/pull/8042
+[8049]: https://github.com/bevyengine/bevy/pull/8049
+[8053]: https://github.com/bevyengine/bevy/pull/8053
+[8060]: https://github.com/bevyengine/bevy/pull/8060
+[8065]: https://github.com/bevyengine/bevy/pull/8065
+[8068]: https://github.com/bevyengine/bevy/pull/8068
+[8070]: https://github.com/bevyengine/bevy/pull/8070
+[8079]: https://github.com/bevyengine/bevy/pull/8079
+[8083]: https://github.com/bevyengine/bevy/pull/8083
+[8088]: https://github.com/bevyengine/bevy/pull/8088
+[8090]: https://github.com/bevyengine/bevy/pull/8090
+[8095]: https://github.com/bevyengine/bevy/pull/8095
+[8097]: https://github.com/bevyengine/bevy/pull/8097
+[8103]: https://github.com/bevyengine/bevy/pull/8103
+[8105]: https://github.com/bevyengine/bevy/pull/8105
+[8108]: https://github.com/bevyengine/bevy/pull/8108
+[8109]: https://github.com/bevyengine/bevy/pull/8109
+[8118]: https://github.com/bevyengine/bevy/pull/8118
+[8119]: https://github.com/bevyengine/bevy/pull/8119
+[8121]: https://github.com/bevyengine/bevy/pull/8121
+[8122]: https://github.com/bevyengine/bevy/pull/8122
+[8137]: https://github.com/bevyengine/bevy/pull/8137
+[8145]: https://github.com/bevyengine/bevy/pull/8145
+[8151]: https://github.com/bevyengine/bevy/pull/8151
+[8154]: https://github.com/bevyengine/bevy/pull/8154
+[8158]: https://github.com/bevyengine/bevy/pull/8158
+[8163]: https://github.com/bevyengine/bevy/pull/8163
+[8174]: https://github.com/bevyengine/bevy/pull/8174
+[8180]: https://github.com/bevyengine/bevy/pull/8180
+[8184]: https://github.com/bevyengine/bevy/pull/8184
+[8194]: https://github.com/bevyengine/bevy/pull/8194
+[8195]: https://github.com/bevyengine/bevy/pull/8195
+[8197]: https://github.com/bevyengine/bevy/pull/8197
+[8198]: https://github.com/bevyengine/bevy/pull/8198
+[8199]: https://github.com/bevyengine/bevy/pull/8199
+[8212]: https://github.com/bevyengine/bevy/pull/8212
+[8220]: https://github.com/bevyengine/bevy/pull/8220
+[8223]: https://github.com/bevyengine/bevy/pull/8223
+[8231]: https://github.com/bevyengine/bevy/pull/8231
+[8232]: https://github.com/bevyengine/bevy/pull/8232
+[8249]: https://github.com/bevyengine/bevy/pull/8249
+[8260]: https://github.com/bevyengine/bevy/pull/8260
+[8264]: https://github.com/bevyengine/bevy/pull/8264
+[8265]: https://github.com/bevyengine/bevy/pull/8265
+[8269]: https://github.com/bevyengine/bevy/pull/8269
+[8272]: https://github.com/bevyengine/bevy/pull/8272
+[8274]: https://github.com/bevyengine/bevy/pull/8274
+[8275]: https://github.com/bevyengine/bevy/pull/8275
+[8283]: https://github.com/bevyengine/bevy/pull/8283
+[8292]: https://github.com/bevyengine/bevy/pull/8292
+[8294]: https://github.com/bevyengine/bevy/pull/8294
+[8295]: https://github.com/bevyengine/bevy/pull/8295
+[8298]: https://github.com/bevyengine/bevy/pull/8298
+[8299]: https://github.com/bevyengine/bevy/pull/8299
+[8301]: https://github.com/bevyengine/bevy/pull/8301
+[8306]: https://github.com/bevyengine/bevy/pull/8306
+[8316]: https://github.com/bevyengine/bevy/pull/8316
+[8323]: https://github.com/bevyengine/bevy/pull/8323
+[8326]: https://github.com/bevyengine/bevy/pull/8326
+[8330]: https://github.com/bevyengine/bevy/pull/8330
+[8336]: https://github.com/bevyengine/bevy/pull/8336
+[8346]: https://github.com/bevyengine/bevy/pull/8346
+[8359]: https://github.com/bevyengine/bevy/pull/8359
+[8362]: https://github.com/bevyengine/bevy/pull/8362
+[8364]: https://github.com/bevyengine/bevy/pull/8364
+[8377]: https://github.com/bevyengine/bevy/pull/8377
+[8380]: https://github.com/bevyengine/bevy/pull/8380
+[8387]: https://github.com/bevyengine/bevy/pull/8387
+[8398]: https://github.com/bevyengine/bevy/pull/8398
+[8402]: https://github.com/bevyengine/bevy/pull/8402
+[8403]: https://github.com/bevyengine/bevy/pull/8403
+[8408]: https://github.com/bevyengine/bevy/pull/8408
+[8412]: https://github.com/bevyengine/bevy/pull/8412
+[8419]: https://github.com/bevyengine/bevy/pull/8419
+[8422]: https://github.com/bevyengine/bevy/pull/8422
+[8425]: https://github.com/bevyengine/bevy/pull/8425
+[8427]: https://github.com/bevyengine/bevy/pull/8427
+[8428]: https://github.com/bevyengine/bevy/pull/8428
+[8434]: https://github.com/bevyengine/bevy/pull/8434
+[8436]: https://github.com/bevyengine/bevy/pull/8436
+[8437]: https://github.com/bevyengine/bevy/pull/8437
+[8444]: https://github.com/bevyengine/bevy/pull/8444
+[8445]: https://github.com/bevyengine/bevy/pull/8445
+[8446]: https://github.com/bevyengine/bevy/pull/8446
+[8448]: https://github.com/bevyengine/bevy/pull/8448
+[8455]: https://github.com/bevyengine/bevy/pull/8455
+[8456]: https://github.com/bevyengine/bevy/pull/8456
+[8460]: https://github.com/bevyengine/bevy/pull/8460
+[8466]: https://github.com/bevyengine/bevy/pull/8466
+[8467]: https://github.com/bevyengine/bevy/pull/8467
+[8468]: https://github.com/bevyengine/bevy/pull/8468
+[8470]: https://github.com/bevyengine/bevy/pull/8470
+[8476]: https://github.com/bevyengine/bevy/pull/8476
+[8485]: https://github.com/bevyengine/bevy/pull/8485
+[8491]: https://github.com/bevyengine/bevy/pull/8491
+[8494]: https://github.com/bevyengine/bevy/pull/8494
+[8495]: https://github.com/bevyengine/bevy/pull/8495
+[8496]: https://github.com/bevyengine/bevy/pull/8496
+[8497]: https://github.com/bevyengine/bevy/pull/8497
+[8503]: https://github.com/bevyengine/bevy/pull/8503
+[8512]: https://github.com/bevyengine/bevy/pull/8512
+[8514]: https://github.com/bevyengine/bevy/pull/8514
+[8521]: https://github.com/bevyengine/bevy/pull/8521
+[8522]: https://github.com/bevyengine/bevy/pull/8522
+[8529]: https://github.com/bevyengine/bevy/pull/8529
+[8531]: https://github.com/bevyengine/bevy/pull/8531
+[8545]: https://github.com/bevyengine/bevy/pull/8545
+[8548]: https://github.com/bevyengine/bevy/pull/8548
+[8549]: https://github.com/bevyengine/bevy/pull/8549
+[8551]: https://github.com/bevyengine/bevy/pull/8551
+[8552]: https://github.com/bevyengine/bevy/pull/8552
+[8561]: https://github.com/bevyengine/bevy/pull/8561
+[8564]: https://github.com/bevyengine/bevy/pull/8564
+[8567]: https://github.com/bevyengine/bevy/pull/8567
+[8573]: https://github.com/bevyengine/bevy/pull/8573
+[8575]: https://github.com/bevyengine/bevy/pull/8575
+[8585]: https://github.com/bevyengine/bevy/pull/8585
+[8588]: https://github.com/bevyengine/bevy/pull/8588
+[8593]: https://github.com/bevyengine/bevy/pull/8593
+[8601]: https://github.com/bevyengine/bevy/pull/8601
+[8622]: https://github.com/bevyengine/bevy/pull/8622
+[8623]: https://github.com/bevyengine/bevy/pull/8623
+[8627]: https://github.com/bevyengine/bevy/pull/8627
+[8631]: https://github.com/bevyengine/bevy/pull/8631
+[8642]: https://github.com/bevyengine/bevy/pull/8642
+[8643]: https://github.com/bevyengine/bevy/pull/8643
+[8649]: https://github.com/bevyengine/bevy/pull/8649
+[8650]: https://github.com/bevyengine/bevy/pull/8650
+[8668]: https://github.com/bevyengine/bevy/pull/8668
+[8677]: https://github.com/bevyengine/bevy/pull/8677
+[8685]: https://github.com/bevyengine/bevy/pull/8685
+[8687]: https://github.com/bevyengine/bevy/pull/8687
+[8691]: https://github.com/bevyengine/bevy/pull/8691
+[8701]: https://github.com/bevyengine/bevy/pull/8701
+[8704]: https://github.com/bevyengine/bevy/pull/8704
+[8711]: https://github.com/bevyengine/bevy/pull/8711
+[8714]: https://github.com/bevyengine/bevy/pull/8714
+[8721]: https://github.com/bevyengine/bevy/pull/8721
+[8722]: https://github.com/bevyengine/bevy/pull/8722
+[8723]: https://github.com/bevyengine/bevy/pull/8723
+[8725]: https://github.com/bevyengine/bevy/pull/8725
+[8726]: https://github.com/bevyengine/bevy/pull/8726
+[8728]: https://github.com/bevyengine/bevy/pull/8728
+[8732]: https://github.com/bevyengine/bevy/pull/8732
+[8740]: https://github.com/bevyengine/bevy/pull/8740
+[8743]: https://github.com/bevyengine/bevy/pull/8743
+[8744]: https://github.com/bevyengine/bevy/pull/8744
+[8753]: https://github.com/bevyengine/bevy/pull/8753
+[8755]: https://github.com/bevyengine/bevy/pull/8755
+[8757]: https://github.com/bevyengine/bevy/pull/8757
+[8760]: https://github.com/bevyengine/bevy/pull/8760
+[8761]: https://github.com/bevyengine/bevy/pull/8761
+[8764]: https://github.com/bevyengine/bevy/pull/8764
+[8771]: https://github.com/bevyengine/bevy/pull/8771
+[8772]: https://github.com/bevyengine/bevy/pull/8772
+[8776]: https://github.com/bevyengine/bevy/pull/8776
+[8791]: https://github.com/bevyengine/bevy/pull/8791
+[8792]: https://github.com/bevyengine/bevy/pull/8792
+[8793]: https://github.com/bevyengine/bevy/pull/8793
+[8795]: https://github.com/bevyengine/bevy/pull/8795
+[8797]: https://github.com/bevyengine/bevy/pull/8797
+[8801]: https://github.com/bevyengine/bevy/pull/8801
+[8802]: https://github.com/bevyengine/bevy/pull/8802
+[8803]: https://github.com/bevyengine/bevy/pull/8803
+[8804]: https://github.com/bevyengine/bevy/pull/8804
+[8814]: https://github.com/bevyengine/bevy/pull/8814
+[8817]: https://github.com/bevyengine/bevy/pull/8817
+[8818]: https://github.com/bevyengine/bevy/pull/8818
+[8822]: https://github.com/bevyengine/bevy/pull/8822
+[8826]: https://github.com/bevyengine/bevy/pull/8826
+[8832]: https://github.com/bevyengine/bevy/pull/8832
+[8833]: https://github.com/bevyengine/bevy/pull/8833
+[8834]: https://github.com/bevyengine/bevy/pull/8834
+[8843]: https://github.com/bevyengine/bevy/pull/8843
+[8844]: https://github.com/bevyengine/bevy/pull/8844
+[8845]: https://github.com/bevyengine/bevy/pull/8845
+[8848]: https://github.com/bevyengine/bevy/pull/8848
+[8849]: https://github.com/bevyengine/bevy/pull/8849
+[8852]: https://github.com/bevyengine/bevy/pull/8852
+[8866]: https://github.com/bevyengine/bevy/pull/8866
+[8868]: https://github.com/bevyengine/bevy/pull/8868
+[8871]: https://github.com/bevyengine/bevy/pull/8871
+[8877]: https://github.com/bevyengine/bevy/pull/8877
+[8878]: https://github.com/bevyengine/bevy/pull/8878
+[8886]: https://github.com/bevyengine/bevy/pull/8886
+[8890]: https://github.com/bevyengine/bevy/pull/8890
+[8891]: https://github.com/bevyengine/bevy/pull/8891
+[8901]: https://github.com/bevyengine/bevy/pull/8901
+[8903]: https://github.com/bevyengine/bevy/pull/8903
+[8904]: https://github.com/bevyengine/bevy/pull/8904
+[8905]: https://github.com/bevyengine/bevy/pull/8905
+[8907]: https://github.com/bevyengine/bevy/pull/8907
+[8909]: https://github.com/bevyengine/bevy/pull/8909
+[8910]: https://github.com/bevyengine/bevy/pull/8910
+[8920]: https://github.com/bevyengine/bevy/pull/8920
+[8928]: https://github.com/bevyengine/bevy/pull/8928
+[8933]: https://github.com/bevyengine/bevy/pull/8933
+[8939]: https://github.com/bevyengine/bevy/pull/8939
+[8947]: https://github.com/bevyengine/bevy/pull/8947
+[8951]: https://github.com/bevyengine/bevy/pull/8951
+[8960]: https://github.com/bevyengine/bevy/pull/8960
+[8957]: https://github.com/bevyengine/bevy/pull/8957
+[9054]: https://github.com/bevyengine/bevy/pull/9054
+[6690]: https://github.com/bevyengine/bevy/pull/6690
+[8424]: https://github.com/bevyengine/bevy/pull/8424
+[8655]: https://github.com/bevyengine/bevy/pull/8655
+[6793]: https://github.com/bevyengine/bevy/pull/6793
+[8720]: https://github.com/bevyengine/bevy/pull/8720
+[9024]: https://github.com/bevyengine/bevy/pull/9024
+[9027]: https://github.com/bevyengine/bevy/pull/9027
+[9016]: https://github.com/bevyengine/bevy/pull/9016
+[9023]: https://github.com/bevyengine/bevy/pull/9023
+[9020]: https://github.com/bevyengine/bevy/pull/9020
+[9030]: https://github.com/bevyengine/bevy/pull/9030
+[9013]: https://github.com/bevyengine/bevy/pull/9013
+[8926]: https://github.com/bevyengine/bevy/pull/8926
+[9003]: https://github.com/bevyengine/bevy/pull/9003
+[8993]: https://github.com/bevyengine/bevy/pull/8993
+[8508]: https://github.com/bevyengine/bevy/pull/8508
+[6056]: https://github.com/bevyengine/bevy/pull/6056
+[8987]: https://github.com/bevyengine/bevy/pull/8987
+[8952]: https://github.com/bevyengine/bevy/pull/8952
+[8961]: https://github.com/bevyengine/bevy/pull/8961
+[8978]: https://github.com/bevyengine/bevy/pull/8978
+[8982]: https://github.com/bevyengine/bevy/pull/8982
+[8977]: https://github.com/bevyengine/bevy/pull/8977
+[8931]: https://github.com/bevyengine/bevy/pull/8931
 
 ## Version 0.10.0 (2023-03-06)
 

From 8ba9571eedada4f3ff43cdf1402670b7fe7c280d Mon Sep 17 00:00:00 2001
From: Carter Anderson <mcanders1@gmail.com>
Date: Sun, 9 Jul 2023 01:43:47 -0700
Subject: [PATCH 12/30] Release 0.11.0 (#9080)

I created this manually as Github didn't want to run CI for the
workflow-generated PR. I'm guessing we didn't hit this in previous
releases because we used bors.

Co-authored-by: Bevy Auto Releaser <41898282+github-actions[bot]@users.noreply.github.com>
---
 Cargo.toml                                    |  6 +-
 crates/bevy_a11y/Cargo.toml                   |  8 +--
 crates/bevy_animation/Cargo.toml              | 24 +++----
 crates/bevy_app/Cargo.toml                    | 12 ++--
 crates/bevy_asset/Cargo.toml                  | 20 +++---
 crates/bevy_audio/Cargo.toml                  | 18 ++---
 crates/bevy_core/Cargo.toml                   | 14 ++--
 crates/bevy_core_pipeline/Cargo.toml          | 22 +++----
 crates/bevy_derive/Cargo.toml                 |  4 +-
 crates/bevy_diagnostic/Cargo.toml             | 14 ++--
 crates/bevy_dylib/Cargo.toml                  |  4 +-
 crates/bevy_dynamic_plugin/Cargo.toml         |  4 +-
 crates/bevy_ecs/Cargo.toml                    | 12 ++--
 crates/bevy_ecs/macros/Cargo.toml             |  4 +-
 crates/bevy_encase_derive/Cargo.toml          |  4 +-
 crates/bevy_gilrs/Cargo.toml                  | 16 ++---
 crates/bevy_gizmos/Cargo.toml                 | 26 ++++----
 crates/bevy_gltf/Cargo.toml                   | 34 +++++-----
 crates/bevy_hierarchy/Cargo.toml              | 14 ++--
 crates/bevy_input/Cargo.toml                  | 14 ++--
 crates/bevy_internal/Cargo.toml               | 66 +++++++++----------
 crates/bevy_log/Cargo.toml                    |  8 +--
 crates/bevy_macro_utils/Cargo.toml            |  2 +-
 crates/bevy_math/Cargo.toml                   |  2 +-
 crates/bevy_mikktspace/Cargo.toml             |  2 +-
 crates/bevy_pbr/Cargo.toml                    | 24 +++----
 crates/bevy_ptr/Cargo.toml                    |  2 +-
 crates/bevy_reflect/Cargo.toml                | 10 +--
 .../bevy_reflect_derive/Cargo.toml            |  4 +-
 crates/bevy_render/Cargo.toml                 | 36 +++++-----
 crates/bevy_render/macros/Cargo.toml          |  4 +-
 crates/bevy_scene/Cargo.toml                  | 20 +++---
 crates/bevy_sprite/Cargo.toml                 | 24 +++----
 crates/bevy_tasks/Cargo.toml                  |  2 +-
 crates/bevy_text/Cargo.toml                   | 22 +++----
 crates/bevy_time/Cargo.toml                   | 10 +--
 crates/bevy_transform/Cargo.toml              | 14 ++--
 crates/bevy_ui/Cargo.toml                     | 36 +++++-----
 crates/bevy_utils/Cargo.toml                  |  4 +-
 crates/bevy_utils/macros/Cargo.toml           |  2 +-
 crates/bevy_window/Cargo.toml                 | 14 ++--
 crates/bevy_winit/Cargo.toml                  | 22 +++----
 tools/build-templated-pages/Cargo.toml        |  2 +-
 43 files changed, 303 insertions(+), 303 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 3f3f3fdc24fc0b..6ccf7a3244b773 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 categories = ["game-engines", "graphics", "gui", "rendering"]
 description = "A refreshingly simple data-driven game engine and app framework"
@@ -249,8 +249,8 @@ shader_format_spirv = ["bevy_internal/shader_format_spirv"]
 webgl2 = ["bevy_internal/webgl"]
 
 [dependencies]
-bevy_dylib = { path = "crates/bevy_dylib", version = "0.11.0-dev", default-features = false, optional = true }
-bevy_internal = { path = "crates/bevy_internal", version = "0.11.0-dev", default-features = false }
+bevy_dylib = { path = "crates/bevy_dylib", version = "0.11.0", default-features = false, optional = true }
+bevy_internal = { path = "crates/bevy_internal", version = "0.11.0", default-features = false }
 
 [dev-dependencies]
 anyhow = "1.0.4"
diff --git a/crates/bevy_a11y/Cargo.toml b/crates/bevy_a11y/Cargo.toml
index 4d95f2d14450b7..ca1bf641569f2c 100644
--- a/crates/bevy_a11y/Cargo.toml
+++ b/crates/bevy_a11y/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_a11y"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Provides accessibility support for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,8 +10,8 @@ keywords = ["bevy", "accessibility", "a11y"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
 
 accesskit = "0.11"
diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index c888d51bb9cb7b..650cc8f906a018 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_animation"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Provides animation functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,14 +10,14 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_core = { path = "../bevy_core", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_render = { path = "../bevy_render", version = "0.11.0-dev" }
-bevy_time = { path = "../bevy_time", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
+bevy_core = { path = "../bevy_core", version = "0.11.0" }
+bevy_math = { path = "../bevy_math", version = "0.11.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
+bevy_render = { path = "../bevy_render", version = "0.11.0" }
+bevy_time = { path = "../bevy_time", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
+bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0" }
diff --git a/crates/bevy_app/Cargo.toml b/crates/bevy_app/Cargo.toml
index 89eec840c98e4c..aca9bfa71c9dc8 100644
--- a/crates/bevy_app/Cargo.toml
+++ b/crates/bevy_app/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_app"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Provides core App functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -16,11 +16,11 @@ bevy_reflect = ["dep:bevy_reflect", "bevy_ecs/bevy_reflect"]
 
 [dependencies]
 # bevy
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev", default-features = false }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", optional = true }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0", default-features = false }
+bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", optional = true }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.11.0" }
 
 # other
 serde = { version = "1.0", features = ["derive"], optional = true }
diff --git a/crates/bevy_asset/Cargo.toml b/crates/bevy_asset/Cargo.toml
index 995f974b1d957e..ba3f082536085d 100644
--- a/crates/bevy_asset/Cargo.toml
+++ b/crates/bevy_asset/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_asset"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Provides asset functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -15,13 +15,13 @@ debug_asset_server = ["filesystem_watcher"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_diagnostic = { path = "../bevy_diagnostic", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_diagnostic = { path = "../bevy_diagnostic", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
+bevy_log = { path = "../bevy_log", version = "0.11.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
+bevy_tasks = { path = "../bevy_tasks", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
 
 # other
 serde = { version = "1", features = ["derive"] }
@@ -34,7 +34,7 @@ notify = { version = "6.0.0", optional = true }
 parking_lot = "0.12.1"
 
 [target.'cfg(target_os = "android")'.dependencies]
-bevy_winit = { path = "../bevy_winit", version = "0.11.0-dev" }
+bevy_winit = { path = "../bevy_winit", version = "0.11.0" }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 wasm-bindgen = { version = "0.2" }
@@ -45,4 +45,4 @@ js-sys = "0.3"
 [dev-dependencies]
 futures-lite = "1.4.0"
 tempfile = "3.2.0"
-bevy_core = { path = "../bevy_core", version = "0.11.0-dev" }
+bevy_core = { path = "../bevy_core", version = "0.11.0" }
diff --git a/crates/bevy_audio/Cargo.toml b/crates/bevy_audio/Cargo.toml
index 1c7e918640c0eb..8127d4d5be9a1e 100644
--- a/crates/bevy_audio/Cargo.toml
+++ b/crates/bevy_audio/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_audio"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Provides audio functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,14 +10,14 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
+bevy_math = { path = "../bevy_math", version = "0.11.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
+bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
+bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
 
 # other
 anyhow = "1.0.4"
diff --git a/crates/bevy_core/Cargo.toml b/crates/bevy_core/Cargo.toml
index 9910209ca89872..5a6daf09d2814b 100644
--- a/crates/bevy_core/Cargo.toml
+++ b/crates/bevy_core/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_core"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Provides core functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -11,12 +11,12 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev", features = ["bevy_reflect"] }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev", features = ["bevy_reflect"] }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.11.0", features = ["bevy_reflect"] }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0", features = ["bevy_reflect"] }
+bevy_math = { path = "../bevy_math", version = "0.11.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
+bevy_tasks = { path = "../bevy_tasks", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
 
 # other
 bytemuck = "1.5"
diff --git a/crates/bevy_core_pipeline/Cargo.toml b/crates/bevy_core_pipeline/Cargo.toml
index d2af8d00b1716f..6da843ff3b8922 100644
--- a/crates/bevy_core_pipeline/Cargo.toml
+++ b/crates/bevy_core_pipeline/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_core_pipeline"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -19,16 +19,16 @@ tonemapping_luts = []
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_core = { path = "../bevy_core", version = "0.11.0-dev" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev" }
-bevy_render = { path = "../bevy_render", version = "0.11.0-dev" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
+bevy_core = { path = "../bevy_core", version = "0.11.0" }
+bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.11.0" }
+bevy_render = { path = "../bevy_render", version = "0.11.0" }
+bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
+bevy_math = { path = "../bevy_math", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
 
 serde = { version = "1", features = ["derive"] }
 bitflags = "2.3"
diff --git a/crates/bevy_derive/Cargo.toml b/crates/bevy_derive/Cargo.toml
index f0e9688f2115b4..9da757fedb96a4 100644
--- a/crates/bevy_derive/Cargo.toml
+++ b/crates/bevy_derive/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_derive"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Provides derive implementations for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -12,7 +12,7 @@ keywords = ["bevy"]
 proc-macro = true
 
 [dependencies]
-bevy_macro_utils = { path = "../bevy_macro_utils", version = "0.11.0-dev" }
+bevy_macro_utils = { path = "../bevy_macro_utils", version = "0.11.0" }
 
 quote = "1.0"
 syn = { version = "2.0", features = ["full"] }
diff --git a/crates/bevy_diagnostic/Cargo.toml b/crates/bevy_diagnostic/Cargo.toml
index 461efa78197288..70d3f6baf8d8d5 100644
--- a/crates/bevy_diagnostic/Cargo.toml
+++ b/crates/bevy_diagnostic/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_diagnostic"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Provides diagnostic functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -14,12 +14,12 @@ dynamic_linking = []
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_core = { path = "../bevy_core", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.11.0-dev" }
-bevy_time = { path = "../bevy_time", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_core = { path = "../bevy_core", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
+bevy_log = { path = "../bevy_log", version = "0.11.0" }
+bevy_time = { path = "../bevy_time", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
 
 # MacOS
 [target.'cfg(all(target_os="macos"))'.dependencies]
diff --git a/crates/bevy_dylib/Cargo.toml b/crates/bevy_dylib/Cargo.toml
index 286f7cf62afd09..a20a84d7897075 100644
--- a/crates/bevy_dylib/Cargo.toml
+++ b/crates/bevy_dylib/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_dylib"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Force the Bevy Engine to be dynamically linked for faster linking"
 homepage = "https://bevyengine.org"
@@ -12,4 +12,4 @@ keywords = ["bevy"]
 crate-type = ["dylib"]
 
 [dependencies]
-bevy_internal = { path = "../bevy_internal", version = "0.11.0-dev", default-features = false }
+bevy_internal = { path = "../bevy_internal", version = "0.11.0", default-features = false }
diff --git a/crates/bevy_dynamic_plugin/Cargo.toml b/crates/bevy_dynamic_plugin/Cargo.toml
index c735c69e2a30b0..a0dc3973811322 100644
--- a/crates/bevy_dynamic_plugin/Cargo.toml
+++ b/crates/bevy_dynamic_plugin/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_dynamic_plugin"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Provides dynamic plugin loading capabilities for non-wasm platforms"
 homepage = "https://bevyengine.org"
@@ -10,7 +10,7 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
 
 # other
 libloading = { version = "0.8" }
diff --git a/crates/bevy_ecs/Cargo.toml b/crates/bevy_ecs/Cargo.toml
index 7551a987aea980..0495a83116d8d5 100644
--- a/crates/bevy_ecs/Cargo.toml
+++ b/crates/bevy_ecs/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_ecs"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Bevy Engine's entity component system"
 homepage = "https://bevyengine.org"
@@ -15,11 +15,11 @@ multi-threaded = ["bevy_tasks/multi-threaded"]
 default = ["bevy_reflect", "multi-threaded"]
 
 [dependencies]
-bevy_ptr = { path = "../bevy_ptr", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", optional = true }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_ecs_macros = { path = "macros", version = "0.11.0-dev" }
+bevy_ptr = { path = "../bevy_ptr", version = "0.11.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", optional = true }
+bevy_tasks = { path = "../bevy_tasks", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_ecs_macros = { path = "macros", version = "0.11.0" }
 
 async-channel = "1.4"
 event-listener = "2.5"
diff --git a/crates/bevy_ecs/macros/Cargo.toml b/crates/bevy_ecs/macros/Cargo.toml
index 9675f105944924..880664f2d7ca0e 100644
--- a/crates/bevy_ecs/macros/Cargo.toml
+++ b/crates/bevy_ecs/macros/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_ecs_macros"
-version = "0.11.0-dev"
+version = "0.11.0"
 description = "Bevy ECS Macros"
 edition = "2021"
 license = "MIT OR Apache-2.0"
@@ -9,7 +9,7 @@ license = "MIT OR Apache-2.0"
 proc-macro = true
 
 [dependencies]
-bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.11.0-dev" }
+bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.11.0" }
 
 syn = "2.0"
 quote = "1.0"
diff --git a/crates/bevy_encase_derive/Cargo.toml b/crates/bevy_encase_derive/Cargo.toml
index be4e0096d55bf7..c9ace9b8ec70d7 100644
--- a/crates/bevy_encase_derive/Cargo.toml
+++ b/crates/bevy_encase_derive/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_encase_derive"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Bevy derive macro for encase"
 homepage = "https://bevyengine.org"
@@ -12,5 +12,5 @@ keywords = ["bevy"]
 proc-macro = true
 
 [dependencies]
-bevy_macro_utils = { path = "../bevy_macro_utils", version = "0.11.0-dev" }
+bevy_macro_utils = { path = "../bevy_macro_utils", version = "0.11.0" }
 encase_derive_impl = "0.6.1"
diff --git a/crates/bevy_gilrs/Cargo.toml b/crates/bevy_gilrs/Cargo.toml
index 28800939fe055a..70c629ab63c142 100644
--- a/crates/bevy_gilrs/Cargo.toml
+++ b/crates/bevy_gilrs/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_gilrs"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Gamepad system made using Gilrs for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,13 +10,13 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_input = { path = "../bevy_input", version = "0.11.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_time = { path = "../bevy_time", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
+bevy_input = { path = "../bevy_input", version = "0.11.0" }
+bevy_log = { path = "../bevy_log", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_time = { path = "../bevy_time", version = "0.11.0" }
 
 # other
 gilrs = "0.10.1"
-thiserror = "1.0"
\ No newline at end of file
+thiserror = "1.0"
diff --git a/crates/bevy_gizmos/Cargo.toml b/crates/bevy_gizmos/Cargo.toml
index aaa4f71355ad11..ce3ddc46c73518 100644
--- a/crates/bevy_gizmos/Cargo.toml
+++ b/crates/bevy_gizmos/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_gizmos"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Provides gizmos for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -13,15 +13,15 @@ webgl = []
 
 [dependencies]
 # Bevy
-bevy_pbr = { path = "../bevy_pbr", version = "0.11.0-dev", optional = true }
-bevy_sprite = { path = "../bevy_sprite", version = "0.11.0-dev", optional = true }
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_render = { path = "../bevy_render", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_core = { path = "../bevy_core", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev" }
-bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.11.0-dev" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
+bevy_pbr = { path = "../bevy_pbr", version = "0.11.0", optional = true }
+bevy_sprite = { path = "../bevy_sprite", version = "0.11.0", optional = true }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
+bevy_math = { path = "../bevy_math", version = "0.11.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
+bevy_render = { path = "../bevy_render", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_core = { path = "../bevy_core", version = "0.11.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.11.0" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.11.0" }
+bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
diff --git a/crates/bevy_gltf/Cargo.toml b/crates/bevy_gltf/Cargo.toml
index 27fdbcc140e417..d2af027043a8e8 100644
--- a/crates/bevy_gltf/Cargo.toml
+++ b/crates/bevy_gltf/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_gltf"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Bevy Engine GLTF loading"
 homepage = "https://bevyengine.org"
@@ -10,22 +10,22 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_animation = { path = "../bevy_animation", version = "0.11.0-dev", optional = true }
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_core = { path = "../bevy_core", version = "0.11.0-dev" }
-bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_pbr = { path = "../bevy_pbr", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_render = { path = "../bevy_render", version = "0.11.0-dev" }
-bevy_scene = { path = "../bevy_scene", version = "0.11.0-dev", features = ["bevy_render"] }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_animation = { path = "../bevy_animation", version = "0.11.0", optional = true }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
+bevy_core = { path = "../bevy_core", version = "0.11.0" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0" }
+bevy_log = { path = "../bevy_log", version = "0.11.0" }
+bevy_math = { path = "../bevy_math", version = "0.11.0" }
+bevy_pbr = { path = "../bevy_pbr", version = "0.11.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
+bevy_render = { path = "../bevy_render", version = "0.11.0" }
+bevy_scene = { path = "../bevy_scene", version = "0.11.0", features = ["bevy_render"] }
+bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
 
 # other
 gltf = { version = "1.0.0", default-features = false, features = [
diff --git a/crates/bevy_hierarchy/Cargo.toml b/crates/bevy_hierarchy/Cargo.toml
index 598cb12fea004d..48c081df6f22f2 100644
--- a/crates/bevy_hierarchy/Cargo.toml
+++ b/crates/bevy_hierarchy/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_hierarchy"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Provides hierarchy functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -13,12 +13,12 @@ trace = []
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_core = { path = "../bevy_core", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev", features = ["bevy_reflect"] }
-bevy_log = { path = "../bevy_log", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_core = { path = "../bevy_core", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0", features = ["bevy_reflect"] }
+bevy_log = { path = "../bevy_log", version = "0.11.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
 
 # other
 smallvec = { version = "1.6", features = ["serde", "union", "const_generics"] }
diff --git a/crates/bevy_input/Cargo.toml b/crates/bevy_input/Cargo.toml
index fd1ac27be4fedf..820d7767aece54 100644
--- a/crates/bevy_input/Cargo.toml
+++ b/crates/bevy_input/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_input"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Provides input functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -14,15 +14,15 @@ serialize = ["serde"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["glam"] }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
+bevy_math = { path = "../bevy_math", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["glam"] }
 
 # other
 serde = { version = "1", features = ["derive"], optional = true }
 thiserror = "1.0"
 
 [dev-dependencies]
-bevy = { path = "../../", version = "0.11.0-dev" }
+bevy = { path = "../../", version = "0.11.0" }
diff --git a/crates/bevy_internal/Cargo.toml b/crates/bevy_internal/Cargo.toml
index 658ab05977005e..4582212d3d4ce5 100644
--- a/crates/bevy_internal/Cargo.toml
+++ b/crates/bevy_internal/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_internal"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "An internal Bevy crate used to facilitate optional dynamic linking via the 'dynamic_linking' feature"
 homepage = "https://bevyengine.org"
@@ -107,36 +107,36 @@ default_font = ["bevy_text?/default_font"]
 
 [dependencies]
 # bevy
-bevy_a11y = { path = "../bevy_a11y", version = "0.11.0-dev" }
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_core = { path = "../bevy_core", version = "0.11.0-dev" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
-bevy_diagnostic = { path = "../bevy_diagnostic", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0-dev" }
-bevy_input = { path = "../bevy_input", version = "0.11.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_ptr = { path = "../bevy_ptr", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_time = { path = "../bevy_time", version = "0.11.0-dev" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_window = { path = "../bevy_window", version = "0.11.0-dev" }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0-dev" }
+bevy_a11y = { path = "../bevy_a11y", version = "0.11.0" }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_core = { path = "../bevy_core", version = "0.11.0" }
+bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
+bevy_diagnostic = { path = "../bevy_diagnostic", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0" }
+bevy_input = { path = "../bevy_input", version = "0.11.0" }
+bevy_log = { path = "../bevy_log", version = "0.11.0" }
+bevy_math = { path = "../bevy_math", version = "0.11.0" }
+bevy_ptr = { path = "../bevy_ptr", version = "0.11.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
+bevy_time = { path = "../bevy_time", version = "0.11.0" }
+bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_window = { path = "../bevy_window", version = "0.11.0" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.11.0" }
 # bevy (optional)
-bevy_animation = { path = "../bevy_animation", optional = true, version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", optional = true, version = "0.11.0-dev" }
-bevy_audio = { path = "../bevy_audio", optional = true, version = "0.11.0-dev" }
-bevy_core_pipeline = { path = "../bevy_core_pipeline", optional = true, version = "0.11.0-dev" }
-bevy_gltf = { path = "../bevy_gltf", optional = true, version = "0.11.0-dev" }
-bevy_pbr = { path = "../bevy_pbr", optional = true, version = "0.11.0-dev" }
-bevy_render = { path = "../bevy_render", optional = true, version = "0.11.0-dev" }
-bevy_dynamic_plugin = { path = "../bevy_dynamic_plugin", optional = true, version = "0.11.0-dev" }
-bevy_scene = { path = "../bevy_scene", optional = true, version = "0.11.0-dev" }
-bevy_sprite = { path = "../bevy_sprite", optional = true, version = "0.11.0-dev" }
-bevy_text = { path = "../bevy_text", optional = true, version = "0.11.0-dev" }
-bevy_ui = { path = "../bevy_ui", optional = true, version = "0.11.0-dev" }
-bevy_winit = { path = "../bevy_winit", optional = true, version = "0.11.0-dev" }
-bevy_gilrs = { path = "../bevy_gilrs", optional = true, version = "0.11.0-dev" }
-bevy_gizmos = { path = "../bevy_gizmos", optional = true, version = "0.11.0-dev", default-features = false }
+bevy_animation = { path = "../bevy_animation", optional = true, version = "0.11.0" }
+bevy_asset = { path = "../bevy_asset", optional = true, version = "0.11.0" }
+bevy_audio = { path = "../bevy_audio", optional = true, version = "0.11.0" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", optional = true, version = "0.11.0" }
+bevy_gltf = { path = "../bevy_gltf", optional = true, version = "0.11.0" }
+bevy_pbr = { path = "../bevy_pbr", optional = true, version = "0.11.0" }
+bevy_render = { path = "../bevy_render", optional = true, version = "0.11.0" }
+bevy_dynamic_plugin = { path = "../bevy_dynamic_plugin", optional = true, version = "0.11.0" }
+bevy_scene = { path = "../bevy_scene", optional = true, version = "0.11.0" }
+bevy_sprite = { path = "../bevy_sprite", optional = true, version = "0.11.0" }
+bevy_text = { path = "../bevy_text", optional = true, version = "0.11.0" }
+bevy_ui = { path = "../bevy_ui", optional = true, version = "0.11.0" }
+bevy_winit = { path = "../bevy_winit", optional = true, version = "0.11.0" }
+bevy_gilrs = { path = "../bevy_gilrs", optional = true, version = "0.11.0" }
+bevy_gizmos = { path = "../bevy_gizmos", optional = true, version = "0.11.0", default-features = false }
diff --git a/crates/bevy_log/Cargo.toml b/crates/bevy_log/Cargo.toml
index c8100c8423fef4..658b6cd02cb526 100644
--- a/crates/bevy_log/Cargo.toml
+++ b/crates/bevy_log/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_log"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Provides logging for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -13,9 +13,9 @@ trace = [ "tracing-error" ]
 trace_tracy_memory = ["dep:tracy-client"]
 
 [dependencies]
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
 
 tracing-subscriber = {version = "0.3.1", features = ["registry", "env-filter"]}
 tracing-chrome = { version = "0.7.0", optional = true }
diff --git a/crates/bevy_macro_utils/Cargo.toml b/crates/bevy_macro_utils/Cargo.toml
index 08c1d0243b96ee..a191a21de11719 100644
--- a/crates/bevy_macro_utils/Cargo.toml
+++ b/crates/bevy_macro_utils/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_macro_utils"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "A collection of utils for Bevy Engine"
 homepage = "https://bevyengine.org"
diff --git a/crates/bevy_math/Cargo.toml b/crates/bevy_math/Cargo.toml
index b6105f6664a261..964f2a0041d6f1 100644
--- a/crates/bevy_math/Cargo.toml
+++ b/crates/bevy_math/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_math"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Provides math functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
diff --git a/crates/bevy_mikktspace/Cargo.toml b/crates/bevy_mikktspace/Cargo.toml
index fc5cbba391e5bc..73f9307bca8ab8 100644
--- a/crates/bevy_mikktspace/Cargo.toml
+++ b/crates/bevy_mikktspace/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_mikktspace"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 authors = ["Benjamin Wasty <benny.wasty@gmail.com>", "David Harvey-Macaulay <alteous@outlook.com>", "Layl Bongers <LaylConway@users.noreply.github.com>"]
 description = "Mikkelsen tangent space algorithm"
diff --git a/crates/bevy_pbr/Cargo.toml b/crates/bevy_pbr/Cargo.toml
index 5d197916169ff6..0fa6bd71ae1eb3 100644
--- a/crates/bevy_pbr/Cargo.toml
+++ b/crates/bevy_pbr/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_pbr"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Adds PBR rendering to Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -13,17 +13,17 @@ webgl = []
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_render = { path = "../bevy_render", version = "0.11.0-dev" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_window = { path = "../bevy_window", version = "0.11.0-dev" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
+bevy_math = { path = "../bevy_math", version = "0.11.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
+bevy_render = { path = "../bevy_render", version = "0.11.0" }
+bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_window = { path = "../bevy_window", version = "0.11.0" }
+bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
 
 # other
 bitflags = "2.3"
diff --git a/crates/bevy_ptr/Cargo.toml b/crates/bevy_ptr/Cargo.toml
index adf236cf34b0d2..1e1e9b9de767c7 100644
--- a/crates/bevy_ptr/Cargo.toml
+++ b/crates/bevy_ptr/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_ptr"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Utilities for working with untyped pointers in a more safe way"
 homepage = "https://bevyengine.org"
diff --git a/crates/bevy_reflect/Cargo.toml b/crates/bevy_reflect/Cargo.toml
index d7b193beed9308..f2ebf141b0c86a 100644
--- a/crates/bevy_reflect/Cargo.toml
+++ b/crates/bevy_reflect/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_reflect"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Dynamically interact with rust types"
 homepage = "https://bevyengine.org"
@@ -18,12 +18,12 @@ documentation = ["bevy_reflect_derive/documentation"]
 
 [dependencies]
 # bevy
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev", features = [
+bevy_math = { path = "../bevy_math", version = "0.11.0", features = [
     "serialize",
 ], optional = true }
-bevy_reflect_derive = { path = "bevy_reflect_derive", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_ptr = { path = "../bevy_ptr", version = "0.11.0-dev" }
+bevy_reflect_derive = { path = "bevy_reflect_derive", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_ptr = { path = "../bevy_ptr", version = "0.11.0" }
 
 # other
 erased-serde = "0.3"
diff --git a/crates/bevy_reflect/bevy_reflect_derive/Cargo.toml b/crates/bevy_reflect/bevy_reflect_derive/Cargo.toml
index fa6b7259dce536..9441ae52b01720 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/Cargo.toml
+++ b/crates/bevy_reflect/bevy_reflect_derive/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_reflect_derive"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Derive implementations for bevy_reflect"
 homepage = "https://bevyengine.org"
@@ -17,7 +17,7 @@ default = []
 documentation = []
 
 [dependencies]
-bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.11.0-dev" }
+bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.11.0" }
 
 syn = { version = "2.0", features = ["full"] }
 proc-macro2 = "1.0"
diff --git a/crates/bevy_render/Cargo.toml b/crates/bevy_render/Cargo.toml
index 739208248325bb..7d04a8d140d55c 100644
--- a/crates/bevy_render/Cargo.toml
+++ b/crates/bevy_render/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_render"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Provides rendering functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -35,23 +35,23 @@ webgl = ["wgpu/webgl"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_core = { path = "../bevy_core", version = "0.11.0-dev" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_encase_derive = { path = "../bevy_encase_derive", version = "0.11.0-dev" }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_mikktspace = { path = "../bevy_mikktspace", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_render_macros = { path = "macros", version = "0.11.0-dev" }
-bevy_time = { path = "../bevy_time", version = "0.11.0-dev" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_window = { path = "../bevy_window", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
+bevy_core = { path = "../bevy_core", version = "0.11.0" }
+bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
+bevy_encase_derive = { path = "../bevy_encase_derive", version = "0.11.0" }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0" }
+bevy_log = { path = "../bevy_log", version = "0.11.0" }
+bevy_math = { path = "../bevy_math", version = "0.11.0" }
+bevy_mikktspace = { path = "../bevy_mikktspace", version = "0.11.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
+bevy_render_macros = { path = "macros", version = "0.11.0" }
+bevy_time = { path = "../bevy_time", version = "0.11.0" }
+bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
+bevy_window = { path = "../bevy_window", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.11.0" }
 
 # rendering
 image = { version = "0.24", default-features = false }
diff --git a/crates/bevy_render/macros/Cargo.toml b/crates/bevy_render/macros/Cargo.toml
index 6f177ab2174b36..e4bd2ff08a50ab 100644
--- a/crates/bevy_render/macros/Cargo.toml
+++ b/crates/bevy_render/macros/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_render_macros"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Derive implementations for bevy_render"
 homepage = "https://bevyengine.org"
@@ -12,7 +12,7 @@ keywords = ["bevy"]
 proc-macro = true
 
 [dependencies]
-bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.11.0-dev" }
+bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.11.0" }
 
 syn = "2.0"
 proc-macro2 = "1.0"
diff --git a/crates/bevy_scene/Cargo.toml b/crates/bevy_scene/Cargo.toml
index 86a40b7ed75a22..0eff8d91ca75ca 100644
--- a/crates/bevy_scene/Cargo.toml
+++ b/crates/bevy_scene/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_scene"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Provides scene functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -14,15 +14,15 @@ serialize = ["dep:serde", "uuid/serde"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0-dev" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_render = { path = "../bevy_render", version = "0.11.0-dev", optional = true }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
+bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0" }
+bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_render = { path = "../bevy_render", version = "0.11.0", optional = true }
 
 # other
 serde = { version = "1.0", features = ["derive"], optional = true }
diff --git a/crates/bevy_sprite/Cargo.toml b/crates/bevy_sprite/Cargo.toml
index c3c522b10b9d41..28a19aa4b711a3 100644
--- a/crates/bevy_sprite/Cargo.toml
+++ b/crates/bevy_sprite/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_sprite"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Provides sprite functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,19 +10,19 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = [
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
+bevy_log = { path = "../bevy_log", version = "0.11.0" }
+bevy_math = { path = "../bevy_math", version = "0.11.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = [
     "bevy",
 ] }
-bevy_render = { path = "../bevy_render", version = "0.11.0-dev" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
+bevy_render = { path = "../bevy_render", version = "0.11.0" }
+bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
 
 # other
 bytemuck = { version = "1.5", features = ["derive"] }
diff --git a/crates/bevy_tasks/Cargo.toml b/crates/bevy_tasks/Cargo.toml
index 9005800f15bd60..7b9255022c3011 100644
--- a/crates/bevy_tasks/Cargo.toml
+++ b/crates/bevy_tasks/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_tasks"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "A task executor for Bevy Engine"
 homepage = "https://bevyengine.org"
diff --git a/crates/bevy_text/Cargo.toml b/crates/bevy_text/Cargo.toml
index 7e17ab8c5640e3..35eaa696ca541d 100644
--- a/crates/bevy_text/Cargo.toml
+++ b/crates/bevy_text/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_text"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Provides text functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -14,16 +14,16 @@ default_font = []
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_render = { path = "../bevy_render", version = "0.11.0-dev" }
-bevy_sprite = { path = "../bevy_sprite", version = "0.11.0-dev" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_window = { path = "../bevy_window", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
+bevy_math = { path = "../bevy_math", version = "0.11.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
+bevy_render = { path = "../bevy_render", version = "0.11.0" }
+bevy_sprite = { path = "../bevy_sprite", version = "0.11.0" }
+bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
+bevy_window = { path = "../bevy_window", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
 
 # other
 anyhow = "1.0.4"
diff --git a/crates/bevy_time/Cargo.toml b/crates/bevy_time/Cargo.toml
index 7d4743b0328348..fe7c0b829e8f27 100644
--- a/crates/bevy_time/Cargo.toml
+++ b/crates/bevy_time/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_time"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Provides time functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -15,10 +15,10 @@ bevy_ci_testing = ["bevy_app/bevy_ci_testing"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev", features = ["bevy_reflect"] }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0", features = ["bevy_reflect"] }
+bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
 
 # other
 crossbeam-channel = "0.5.0"
diff --git a/crates/bevy_transform/Cargo.toml b/crates/bevy_transform/Cargo.toml
index 0b426b6bf9e57c..e33ea9dfe1960b 100644
--- a/crates/bevy_transform/Cargo.toml
+++ b/crates/bevy_transform/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_transform"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Provides transform functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,15 +10,15 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev", features = ["bevy_reflect"] }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0", features = ["bevy_reflect"] }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0" }
+bevy_math = { path = "../bevy_math", version = "0.11.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
 serde = { version = "1", features = ["derive"], optional = true }
 
 [dev-dependencies]
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0-dev" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.11.0" }
 
 [features]
 serialize = ["dep:serde", "bevy_math/serialize"]
diff --git a/crates/bevy_ui/Cargo.toml b/crates/bevy_ui/Cargo.toml
index 0f3bf3320f22d5..d4e5de4f5357ed 100644
--- a/crates/bevy_ui/Cargo.toml
+++ b/crates/bevy_ui/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_ui"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "A custom ECS-driven UI framework built specifically for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,25 +10,25 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_a11y = { path = "../bevy_a11y", version = "0.11.0-dev" }
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.11.0-dev" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0-dev" }
-bevy_input = { path = "../bevy_input", version = "0.11.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = [
+bevy_a11y = { path = "../bevy_a11y", version = "0.11.0" }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.11.0" }
+bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0" }
+bevy_input = { path = "../bevy_input", version = "0.11.0" }
+bevy_log = { path = "../bevy_log", version = "0.11.0" }
+bevy_math = { path = "../bevy_math", version = "0.11.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = [
     "bevy",
 ] }
-bevy_render = { path = "../bevy_render", version = "0.11.0-dev" }
-bevy_sprite = { path = "../bevy_sprite", version = "0.11.0-dev" }
-bevy_text = { path = "../bevy_text", version = "0.11.0-dev", optional = true }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_window = { path = "../bevy_window", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_render = { path = "../bevy_render", version = "0.11.0" }
+bevy_sprite = { path = "../bevy_sprite", version = "0.11.0" }
+bevy_text = { path = "../bevy_text", version = "0.11.0", optional = true }
+bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
+bevy_window = { path = "../bevy_window", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
 
 # other
 taffy = { version = "0.3.10" }
diff --git a/crates/bevy_utils/Cargo.toml b/crates/bevy_utils/Cargo.toml
index e423aa950c4340..30f377f22f778e 100644
--- a/crates/bevy_utils/Cargo.toml
+++ b/crates/bevy_utils/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_utils"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "A collection of utils for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -17,7 +17,7 @@ tracing = { version = "0.1", default-features = false, features = ["std"] }
 instant = { version = "0.1", features = ["wasm-bindgen"] }
 uuid = { version = "1.1", features = ["v4", "serde"] }
 hashbrown = { version = "0.14", features = ["serde"] }
-bevy_utils_proc_macros = {version = "0.11.0-dev", path = "macros"}
+bevy_utils_proc_macros = {version = "0.11.0", path = "macros"}
 petgraph = "0.6"
 thiserror = "1.0"
 
diff --git a/crates/bevy_utils/macros/Cargo.toml b/crates/bevy_utils/macros/Cargo.toml
index b6439e72b6da73..10307bbd656841 100644
--- a/crates/bevy_utils/macros/Cargo.toml
+++ b/crates/bevy_utils/macros/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_utils_proc_macros"
-version = "0.11.0-dev"
+version = "0.11.0"
 description = "Bevy Utils Proc Macros"
 edition = "2021"
 license = "MIT OR Apache-2.0"
diff --git a/crates/bevy_window/Cargo.toml b/crates/bevy_window/Cargo.toml
index c65bcc6e3b97de..85ce90c849f535 100644
--- a/crates/bevy_window/Cargo.toml
+++ b/crates/bevy_window/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_window"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "Provides windowing functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -14,15 +14,15 @@ serialize = ["serde"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = [
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
+bevy_math = { path = "../bevy_math", version = "0.11.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = [
     "glam",
 ] }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
 # Used for close_on_esc
-bevy_input = { path = "../bevy_input", version = "0.11.0-dev" }
+bevy_input = { path = "../bevy_input", version = "0.11.0" }
 raw-window-handle = "0.5"
 
 # other
diff --git a/crates/bevy_winit/Cargo.toml b/crates/bevy_winit/Cargo.toml
index 0421993b50b263..ec881e50a16218 100644
--- a/crates/bevy_winit/Cargo.toml
+++ b/crates/bevy_winit/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_winit"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "A winit window and input backend for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -16,16 +16,16 @@ accesskit_unix = ["accesskit_winit/accesskit_unix", "accesskit_winit/async-io"]
 
 [dependencies]
 # bevy
-bevy_a11y = { path = "../bevy_a11y", version = "0.11.0-dev" }
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0-dev" }
-bevy_input = { path = "../bevy_input", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_window = { path = "../bevy_window", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0-dev" }
+bevy_a11y = { path = "../bevy_a11y", version = "0.11.0" }
+bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0" }
+bevy_input = { path = "../bevy_input", version = "0.11.0" }
+bevy_math = { path = "../bevy_math", version = "0.11.0" }
+bevy_window = { path = "../bevy_window", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.11.0" }
 
 # other
 winit = { version = "0.28", default-features = false }
diff --git a/tools/build-templated-pages/Cargo.toml b/tools/build-templated-pages/Cargo.toml
index 5d0bee2a6aafaa..f91ce653123dd8 100644
--- a/tools/build-templated-pages/Cargo.toml
+++ b/tools/build-templated-pages/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "build-templated-pages"
-version = "0.11.0-dev"
+version = "0.11.0"
 edition = "2021"
 description = "handle templated pages in Bevy repository"
 publish = false

From ffc572728fb7874996a13c31a82e86ef98515995 Mon Sep 17 00:00:00 2001
From: ClayenKitten <68070406+ClayenKitten@users.noreply.github.com>
Date: Mon, 10 Jul 2023 03:11:51 +0300
Subject: [PATCH 13/30] Fix typos throughout the project (#9090)

# Objective

Fix typos throughout the project.

## Solution

[`typos`](https://github.com/crate-ci/typos) project was used for
scanning, but no automatic corrections were applied. I checked
everything by hand before fixing.

Most of the changes are documentation/comments corrections. Also, there
are few trivial changes to code (variable name, pub(crate) function name
and a few error/panic messages).

## Unsolved

`bevy_reflect_derive` has
[typo](https://github.com/ClayenKitten/bevy/blob/1b51053f1958d750cdddffb99828bd0aacb61a78/crates/bevy_reflect/bevy_reflect_derive/src/type_path.rs#L76)
in enum variant name that I didn't fix. Enum is `pub(crate)`, so there
shouldn't be any trouble if fixed. However, code is tightly coupled with
macro usage, so I decided to leave it for more experienced contributor
just in case.
---
 crates/bevy_app/src/main_schedule.rs             |  2 +-
 crates/bevy_core_pipeline/src/bloom/settings.rs  |  4 ++--
 crates/bevy_core_pipeline/src/taa/mod.rs         |  2 +-
 crates/bevy_ecs/macros/src/component.rs          |  2 +-
 crates/bevy_ecs/src/entity/mod.rs                |  2 +-
 crates/bevy_ecs/src/reflect/map_entities.rs      |  2 +-
 crates/bevy_ecs/src/schedule/condition.rs        | 16 ++++++++--------
 .../src/schedule/executor/multi_threaded.rs      |  2 +-
 crates/bevy_ecs/src/schedule/mod.rs              |  2 +-
 crates/bevy_ecs/src/storage/table.rs             |  2 +-
 crates/bevy_ecs/src/system/query.rs              |  8 ++++----
 crates/bevy_ecs/src/system/system_param.rs       |  2 +-
 crates/bevy_gizmos/src/gizmos.rs                 |  8 ++++----
 crates/bevy_gizmos/src/lines.wgsl                |  4 ++--
 crates/bevy_hierarchy/src/child_builder.rs       |  4 ++--
 crates/bevy_pbr/src/render/morph.rs              |  2 +-
 crates/bevy_pbr/src/render/morph.wgsl            |  2 +-
 crates/bevy_pbr/src/render/pbr_lighting.wgsl     |  2 +-
 .../src/container_attributes.rs                  |  2 +-
 .../bevy_reflect_derive/src/derive_data.rs       |  6 +++---
 .../bevy_reflect/bevy_reflect_derive/src/lib.rs  |  2 +-
 crates/bevy_reflect/src/array.rs                 |  2 +-
 crates/bevy_reflect/src/from_reflect.rs          |  2 +-
 crates/bevy_reflect/src/impls/std.rs             |  2 +-
 crates/bevy_reflect/src/list.rs                  |  2 +-
 crates/bevy_reflect/src/type_path.rs             |  2 +-
 crates/bevy_reflect/src/utility.rs               |  2 +-
 crates/bevy_render/macros/src/as_bind_group.rs   |  8 ++++----
 .../bevy_transform/src/components/transform.rs   |  2 +-
 crates/bevy_ui/src/render/mod.rs                 |  2 +-
 crates/bevy_ui/src/stack.rs                      |  2 +-
 crates/bevy_ui/src/ui_node.rs                    | 12 ++++++------
 crates/bevy_ui/src/widget/text.rs                |  2 +-
 crates/bevy_utils/src/syncunsafecell.rs          |  2 +-
 examples/shader/post_processing.rs               |  2 +-
 .../tools/scene_viewer/morph_viewer_plugin.rs    |  2 +-
 examples/ui/display_and_visibility.rs            |  2 +-
 examples/ui/size_constraints.rs                  |  4 ++--
 examples/ui/ui.rs                                |  2 +-
 tools/build-wasm-example/src/main.rs             |  2 +-
 40 files changed, 67 insertions(+), 67 deletions(-)

diff --git a/crates/bevy_app/src/main_schedule.rs b/crates/bevy_app/src/main_schedule.rs
index c940fda5337b97..194185c366ae7a 100644
--- a/crates/bevy_app/src/main_schedule.rs
+++ b/crates/bevy_app/src/main_schedule.rs
@@ -48,7 +48,7 @@ pub struct First;
 
 /// The schedule that contains logic that must run before [`Update`]. For example, a system that reads raw keyboard
 /// input OS events into an `Events` resource. This enables systems in [`Update`] to consume the events from the `Events`
-/// resource without actually knowing about (or taking a direct scheduler dependency on) the "os-level keyboard event sytsem".
+/// resource without actually knowing about (or taking a direct scheduler dependency on) the "os-level keyboard event system".
 ///
 /// [`PreUpdate`] exists to do "engine/plugin preparation work" that ensures the APIs consumed in [`Update`] are "ready".
 /// [`PreUpdate`] abstracts out "pre work implementation details".
diff --git a/crates/bevy_core_pipeline/src/bloom/settings.rs b/crates/bevy_core_pipeline/src/bloom/settings.rs
index 553fa75c6cc0ca..6d5cc2fe035020 100644
--- a/crates/bevy_core_pipeline/src/bloom/settings.rs
+++ b/crates/bevy_core_pipeline/src/bloom/settings.rs
@@ -119,7 +119,7 @@ impl BloomSettings {
         composite_mode: BloomCompositeMode::EnergyConserving,
     };
 
-    /// A preset that's similiar to how older games did bloom.
+    /// A preset that's similar to how older games did bloom.
     pub const OLD_SCHOOL: Self = Self {
         intensity: 0.05,
         low_frequency_boost: 0.7,
@@ -159,7 +159,7 @@ impl Default for BloomSettings {
 /// # Considerations
 /// * Changing these settings creates a physically inaccurate image
 /// * Changing these settings makes it easy to make the final result look worse
-/// * Non-default prefilter settings should be used in conjuction with [`BloomCompositeMode::Additive`]
+/// * Non-default prefilter settings should be used in conjunction with [`BloomCompositeMode::Additive`]
 #[derive(Default, Clone, Reflect)]
 pub struct BloomPrefilterSettings {
     /// Baseline of the quadratic threshold curve (default: 0.0).
diff --git a/crates/bevy_core_pipeline/src/taa/mod.rs b/crates/bevy_core_pipeline/src/taa/mod.rs
index 746f22ded9d66e..01e75ddd15f50d 100644
--- a/crates/bevy_core_pipeline/src/taa/mod.rs
+++ b/crates/bevy_core_pipeline/src/taa/mod.rs
@@ -148,7 +148,7 @@ pub struct TemporalAntiAliasSettings {
     /// Set to true to delete the saved temporal history (past frames).
     ///
     /// Useful for preventing ghosting when the history is no longer
-    /// representive of the current frame, such as in sudden camera cuts.
+    /// representative of the current frame, such as in sudden camera cuts.
     ///
     /// After setting this to true, it will automatically be toggled
     /// back to false after one frame.
diff --git a/crates/bevy_ecs/macros/src/component.rs b/crates/bevy_ecs/macros/src/component.rs
index 65d26a0bf01020..db10910e0c5084 100644
--- a/crates/bevy_ecs/macros/src/component.rs
+++ b/crates/bevy_ecs/macros/src/component.rs
@@ -101,7 +101,7 @@ fn parse_component_attr(ast: &DeriveInput) -> Result<Attrs> {
                 };
                 Ok(())
             } else {
-                Err(nested.error("Unsuported attribute"))
+                Err(nested.error("Unsupported attribute"))
             }
         })?;
     }
diff --git a/crates/bevy_ecs/src/entity/mod.rs b/crates/bevy_ecs/src/entity/mod.rs
index a9a4f14759cb0a..99dd7fe791a30a 100644
--- a/crates/bevy_ecs/src/entity/mod.rs
+++ b/crates/bevy_ecs/src/entity/mod.rs
@@ -905,7 +905,7 @@ mod tests {
 
         assert!(entities.reserve_generations(entity.index, GENERATIONS));
 
-        // The very next entitiy allocated should be a further generation on the same index
+        // The very next entity allocated should be a further generation on the same index
         let next_entity = entities.alloc();
         assert_eq!(next_entity.index(), entity.index());
         assert!(next_entity.generation > entity.generation + GENERATIONS);
diff --git a/crates/bevy_ecs/src/reflect/map_entities.rs b/crates/bevy_ecs/src/reflect/map_entities.rs
index fe02e4794fce2e..bd09bd97b64ade 100644
--- a/crates/bevy_ecs/src/reflect/map_entities.rs
+++ b/crates/bevy_ecs/src/reflect/map_entities.rs
@@ -6,7 +6,7 @@ use crate::{
 use bevy_reflect::FromType;
 
 /// For a specific type of component, this maps any fields with values of type [`Entity`] to a new world.
-/// Since a given `Entity` ID is only valid for the world it came frome, when performing deserialization
+/// Since a given `Entity` ID is only valid for the world it came from, when performing deserialization
 /// any stored IDs need to be re-allocated in the destination world.
 ///
 /// See [`MapEntities`] for more information.
diff --git a/crates/bevy_ecs/src/schedule/condition.rs b/crates/bevy_ecs/src/schedule/condition.rs
index 5f361f931d72a2..abaf9bbf62c2d6 100644
--- a/crates/bevy_ecs/src/schedule/condition.rs
+++ b/crates/bevy_ecs/src/schedule/condition.rs
@@ -246,7 +246,7 @@ pub mod common_conditions {
     /// # let mut app = Schedule::new();
     /// # let mut world = World::new();
     /// app.add_systems(
-    ///     // `resource_exsists` will only return true if the given resource exsists in the world
+    ///     // `resource_exists` will only return true if the given resource exists in the world
     ///     my_system.run_if(resource_exists::<Counter>()),
     /// );
     ///
@@ -324,7 +324,7 @@ pub mod common_conditions {
     /// # let mut world = World::new();
     /// app.add_systems(
     ///     // `resource_exists_and_equals` will only return true
-    ///     // if the given resource exsists and equals the given value
+    ///     // if the given resource exists and equals the given value
     ///     my_system.run_if(resource_exists_and_equals(Counter(0))),
     /// );
     ///
@@ -422,7 +422,7 @@ pub mod common_conditions {
     ///     my_system.run_if(
     ///         resource_changed::<Counter>()
     ///         // By default detecting changes will also trigger if the resource was
-    ///         // just added, this won't work with my example so I will addd a second
+    ///         // just added, this won't work with my example so I will add a second
     ///         // condition to make sure the resource wasn't just added
     ///         .and_then(not(resource_added::<Counter>()))
     ///     ),
@@ -471,11 +471,11 @@ pub mod common_conditions {
     /// # let mut world = World::new();
     /// app.add_systems(
     ///     // `resource_exists_and_changed` will only return true if the
-    ///     // given resource exsists and was just changed (or added)
+    ///     // given resource exists and was just changed (or added)
     ///     my_system.run_if(
     ///         resource_exists_and_changed::<Counter>()
     ///         // By default detecting changes will also trigger if the resource was
-    ///         // just added, this won't work with my example so I will addd a second
+    ///         // just added, this won't work with my example so I will add a second
     ///         // condition to make sure the resource wasn't just added
     ///         .and_then(not(resource_added::<Counter>()))
     ///     ),
@@ -537,7 +537,7 @@ pub mod common_conditions {
     ///     my_system.run_if(
     ///         resource_changed_or_removed::<Counter>()
     ///         // By default detecting changes will also trigger if the resource was
-    ///         // just added, this won't work with my example so I will addd a second
+    ///         // just added, this won't work with my example so I will add a second
     ///         // condition to make sure the resource wasn't just added
     ///         .and_then(not(resource_added::<Counter>()))
     ///     ),
@@ -665,7 +665,7 @@ pub mod common_conditions {
     ///
     /// app.add_systems(
     ///     // `state_exists` will only return true if the
-    ///     // given state exsists
+    ///     // given state exists
     ///     my_system.run_if(state_exists::<GameState>()),
     /// );
     ///
@@ -764,7 +764,7 @@ pub mod common_conditions {
     ///
     /// app.add_systems((
     ///     // `state_exists_and_equals` will only return true if the
-    ///     // given state exsists and equals the given value
+    ///     // given state exists and equals the given value
     ///     play_system.run_if(state_exists_and_equals(GameState::Playing)),
     ///     pause_system.run_if(state_exists_and_equals(GameState::Paused)),
     /// ));
diff --git a/crates/bevy_ecs/src/schedule/executor/multi_threaded.rs b/crates/bevy_ecs/src/schedule/executor/multi_threaded.rs
index e046e9d1ace8e7..8f6a3133c5966e 100644
--- a/crates/bevy_ecs/src/schedule/executor/multi_threaded.rs
+++ b/crates/bevy_ecs/src/schedule/executor/multi_threaded.rs
@@ -476,7 +476,7 @@ impl MultiThreadedExecutor {
     /// - `world` must have permission to access the world data
     ///   used by the specified system.
     /// - `update_archetype_component_access` must have been called with `world`
-    ///   on the system assocaited with `system_index`.
+    ///   on the system associated with `system_index`.
     unsafe fn spawn_system_task<'scope>(
         &mut self,
         scope: &Scope<'_, 'scope, ()>,
diff --git a/crates/bevy_ecs/src/schedule/mod.rs b/crates/bevy_ecs/src/schedule/mod.rs
index 7bb8ef7f660c89..c585fb508fb72b 100644
--- a/crates/bevy_ecs/src/schedule/mod.rs
+++ b/crates/bevy_ecs/src/schedule/mod.rs
@@ -239,7 +239,7 @@ mod tests {
                 partially_ordered == [8, 9, 10] || partially_ordered == [10, 8, 9],
                 "partially_ordered must be [8, 9, 10] or [10, 8, 9]"
             );
-            assert!(order.len() == 11, "must have exacty 11 order entries");
+            assert!(order.len() == 11, "must have exactly 11 order entries");
         }
     }
 
diff --git a/crates/bevy_ecs/src/storage/table.rs b/crates/bevy_ecs/src/storage/table.rs
index bae50e86c22a47..c30ee6ce1248b2 100644
--- a/crates/bevy_ecs/src/storage/table.rs
+++ b/crates/bevy_ecs/src/storage/table.rs
@@ -94,7 +94,7 @@ impl TableRow {
     }
 }
 
-/// A type-erased contiguous container for data of a homogenous type.
+/// A type-erased contiguous container for data of a homogeneous type.
 ///
 /// Conceptually, a [`Column`] is very similar to a type-erased `Vec<T>`.
 /// It also stores the change detection ticks for its components, kept in two separate
diff --git a/crates/bevy_ecs/src/system/query.rs b/crates/bevy_ecs/src/system/query.rs
index fe12856744edb5..50ea3fde790c0f 100644
--- a/crates/bevy_ecs/src/system/query.rs
+++ b/crates/bevy_ecs/src/system/query.rs
@@ -426,7 +426,7 @@ impl<'w, 's, Q: WorldQuery, F: ReadOnlyWorldQuery> Query<'w, 's, Q, F> {
     pub fn iter(&self) -> QueryIter<'_, 's, Q::ReadOnly, F::ReadOnly> {
         // SAFETY:
         // - `self.world` has permission to access the required components.
-        // - The query is read-only, so it can be aliased even if it was originaly mutable.
+        // - The query is read-only, so it can be aliased even if it was originally mutable.
         unsafe {
             self.state
                 .as_readonly()
@@ -492,7 +492,7 @@ impl<'w, 's, Q: WorldQuery, F: ReadOnlyWorldQuery> Query<'w, 's, Q, F> {
     ) -> QueryCombinationIter<'_, 's, Q::ReadOnly, F::ReadOnly, K> {
         // SAFETY:
         // - `self.world` has permission to access the required components.
-        // - The query is read-only, so it can be aliased even if it was originaly mutable.
+        // - The query is read-only, so it can be aliased even if it was originally mutable.
         unsafe {
             self.state.as_readonly().iter_combinations_unchecked_manual(
                 self.world,
@@ -578,7 +578,7 @@ impl<'w, 's, Q: WorldQuery, F: ReadOnlyWorldQuery> Query<'w, 's, Q, F> {
     {
         // SAFETY:
         // - `self.world` has permission to access the required components.
-        // - The query is read-only, so it can be aliased even if it was originaly mutable.
+        // - The query is read-only, so it can be aliased even if it was originally mutable.
         unsafe {
             self.state.as_readonly().iter_many_unchecked_manual(
                 entities,
@@ -734,7 +734,7 @@ impl<'w, 's, Q: WorldQuery, F: ReadOnlyWorldQuery> Query<'w, 's, Q, F> {
     pub fn for_each<'this>(&'this self, f: impl FnMut(ROQueryItem<'this, Q>)) {
         // SAFETY:
         // - `self.world` has permission to access the required components.
-        // - The query is read-only, so it can be aliased even if it was originaly mutable.
+        // - The query is read-only, so it can be aliased even if it was originally mutable.
         unsafe {
             self.state.as_readonly().for_each_unchecked_manual(
                 self.world,
diff --git a/crates/bevy_ecs/src/system/system_param.rs b/crates/bevy_ecs/src/system/system_param.rs
index 4a3be817b8dbbc..ff4321ee6cd50d 100644
--- a/crates/bevy_ecs/src/system/system_param.rs
+++ b/crates/bevy_ecs/src/system/system_param.rs
@@ -627,7 +627,7 @@ unsafe impl SystemParam for &'_ World {
         world: UnsafeWorldCell<'w>,
         _change_tick: Tick,
     ) -> Self::Item<'w, 's> {
-        // SAFETY: Read-only access to the entire world was registerd in `init_state`.
+        // SAFETY: Read-only access to the entire world was registered in `init_state`.
         world.world()
     }
 }
diff --git a/crates/bevy_gizmos/src/gizmos.rs b/crates/bevy_gizmos/src/gizmos.rs
index 974532d11e7c91..e945761f59462a 100644
--- a/crates/bevy_gizmos/src/gizmos.rs
+++ b/crates/bevy_gizmos/src/gizmos.rs
@@ -571,7 +571,7 @@ pub struct CircleBuilder<'a, 's> {
 }
 
 impl CircleBuilder<'_, '_> {
-    /// Set the number of line-segements for this circle.
+    /// Set the number of line-segments for this circle.
     pub fn segments(mut self, segments: usize) -> Self {
         self.segments = segments;
         self
@@ -598,7 +598,7 @@ pub struct SphereBuilder<'a, 's> {
 }
 
 impl SphereBuilder<'_, '_> {
-    /// Set the number of line-segements per circle for this sphere.
+    /// Set the number of line-segments per circle for this sphere.
     pub fn circle_segments(mut self, segments: usize) -> Self {
         self.circle_segments = segments;
         self
@@ -625,7 +625,7 @@ pub struct Circle2dBuilder<'a, 's> {
 }
 
 impl Circle2dBuilder<'_, '_> {
-    /// Set the number of line-segements for this circle.
+    /// Set the number of line-segments for this circle.
     pub fn segments(mut self, segments: usize) -> Self {
         self.segments = segments;
         self
@@ -651,7 +651,7 @@ pub struct Arc2dBuilder<'a, 's> {
 }
 
 impl Arc2dBuilder<'_, '_> {
-    /// Set the number of line-segements for this arc.
+    /// Set the number of line-segments for this arc.
     pub fn segments(mut self, segments: usize) -> Self {
         self.segments = Some(segments);
         self
diff --git a/crates/bevy_gizmos/src/lines.wgsl b/crates/bevy_gizmos/src/lines.wgsl
index 037a9fbcaefbfe..2dbe84653db660 100644
--- a/crates/bevy_gizmos/src/lines.wgsl
+++ b/crates/bevy_gizmos/src/lines.wgsl
@@ -80,10 +80,10 @@ fn vertex(vertex: VertexInput) -> VertexOutput {
         // depth * (clip.w / depth)^-depth_bias. So that when -depth_bias is 1.0, this is equal to clip.w
         // and when equal to 0.0, it is exactly equal to depth.
         // the epsilon is here to prevent the depth from exceeding clip.w when -depth_bias = 1.0 
-        // clip.w represents the near plane in homogenous clip space in bevy, having a depth
+        // clip.w represents the near plane in homogeneous clip space in bevy, having a depth
         // of this value means nothing can be in front of this
         // The reason this uses an exponential function is that it makes it much easier for the 
-        // user to chose a value that is convinient for them
+        // user to chose a value that is convenient for them
         depth = clip.z * exp2(-line_gizmo.depth_bias * log2(clip.w / clip.z - epsilon));
     }
 
diff --git a/crates/bevy_hierarchy/src/child_builder.rs b/crates/bevy_hierarchy/src/child_builder.rs
index 54c942144ecc45..466d6f7b95721f 100644
--- a/crates/bevy_hierarchy/src/child_builder.rs
+++ b/crates/bevy_hierarchy/src/child_builder.rs
@@ -289,7 +289,7 @@ impl<'w, 's, 'a> ChildBuilder<'w, 's, 'a> {
 
 /// Trait for removing, adding and replacing children and parents of an entity.
 pub trait BuildChildren {
-    /// Takes a clousre which builds children for this entity using [`ChildBuilder`].
+    /// Takes a closure which builds children for this entity using [`ChildBuilder`].
     fn with_children(&mut self, f: impl FnOnce(&mut ChildBuilder)) -> &mut Self;
     /// Pushes children to the back of the builder's children. For any entities that are
     /// already a child of this one, this method does nothing.
@@ -458,7 +458,7 @@ impl<'w> WorldChildBuilder<'w> {
 
 /// Trait that defines adding, changing and children and parents of an entity directly through the [`World`].
 pub trait BuildWorldChildren {
-    /// Takes a clousre which builds children for this entity using [`WorldChildBuilder`].
+    /// Takes a closure which builds children for this entity using [`WorldChildBuilder`].
     fn with_children(&mut self, spawn_children: impl FnOnce(&mut WorldChildBuilder)) -> &mut Self;
 
     /// Adds a single child.
diff --git a/crates/bevy_pbr/src/render/morph.rs b/crates/bevy_pbr/src/render/morph.rs
index 90778564d6cfd5..43d2e2f585234c 100644
--- a/crates/bevy_pbr/src/render/morph.rs
+++ b/crates/bevy_pbr/src/render/morph.rs
@@ -52,7 +52,7 @@ fn add_to_alignment<T: Pod + Default>(buffer: &mut BufferVec<T>) {
         // This panic is stripped at compile time, due to n, t_size and can_align being const
         panic!(
             "BufferVec should contain only types with a size multiple or divisible by {n}, \
-            {} has a size of {t_size}, which is neiter multiple or divisible by {n}",
+            {} has a size of {t_size}, which is neither multiple or divisible by {n}",
             std::any::type_name::<T>()
         );
     }
diff --git a/crates/bevy_pbr/src/render/morph.wgsl b/crates/bevy_pbr/src/render/morph.wgsl
index ceabe789943cfb..6cfc6d96028683 100644
--- a/crates/bevy_pbr/src/render/morph.wgsl
+++ b/crates/bevy_pbr/src/render/morph.wgsl
@@ -1,6 +1,6 @@
 // If using this WGSL snippet as an #import, the following should be in scope:
 //
-// - the `morph_weigths` uniform of type `MorphWeights`
+// - the `morph_weights` uniform of type `MorphWeights`
 // - the `morph_targets` 3d texture
 //
 // They are defined in `mesh_types.wgsl` and `mesh_bindings.wgsl`.
diff --git a/crates/bevy_pbr/src/render/pbr_lighting.wgsl b/crates/bevy_pbr/src/render/pbr_lighting.wgsl
index 631167f14ecd45..6658c430340603 100644
--- a/crates/bevy_pbr/src/render/pbr_lighting.wgsl
+++ b/crates/bevy_pbr/src/render/pbr_lighting.wgsl
@@ -222,7 +222,7 @@ fn point_light(
     // where
     // f(v,l) = (f_d(v,l) + f_r(v,l)) * light_color
     // Φ is luminous power in lumens
-    // our rangeAttentuation = 1 / d^2 multiplied with an attenuation factor for smoothing at the edge of the non-physical maximum light radius
+    // our rangeAttenuation = 1 / d^2 multiplied with an attenuation factor for smoothing at the edge of the non-physical maximum light radius
 
     // For a point light, luminous intensity, I, in lumens per steradian is given by:
     // I = Φ / 4 π
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/container_attributes.rs b/crates/bevy_reflect/bevy_reflect_derive/src/container_attributes.rs
index a7acbb2748d90e..d0fb321e3d0e7a 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/container_attributes.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/container_attributes.rs
@@ -249,7 +249,7 @@ impl ReflectTraits {
                                 lit: syn::Lit::Bool(lit),
                                 ..
                             }) => {
-                                // Overrride `lit` if this is a `FromReflect` derive.
+                                // Override `lit` if this is a `FromReflect` derive.
                                 // This typically means a user is opting out of the default implementation
                                 // from the `Reflect` derive and using the `FromReflect` derive directly instead.
                                 is_from_reflect_derive
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/derive_data.rs b/crates/bevy_reflect/bevy_reflect_derive/src/derive_data.rs
index 0bf42461deb70c..7a6d0154346d81 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/derive_data.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/derive_data.rs
@@ -567,7 +567,7 @@ impl<'a> EnumVariant<'a> {
 ///     custom_path: None,
 /// };
 ///
-/// // Eqivalent to "core::marker".
+/// // Equivalent to "core::marker".
 /// let module_path = type_path.module_path();
 /// # Ok::<(), syn::Error>(())
 /// ```
@@ -577,7 +577,7 @@ pub(crate) enum ReflectTypePath<'a> {
     Primitive(&'a Ident),
     /// Using `::my_crate::foo::Bar` syntax.
     ///
-    /// May have a seperate custom path used for the `TypePath` implementation.
+    /// May have a separate custom path used for the `TypePath` implementation.
     External {
         path: &'a Path,
         custom_path: Option<Path>,
@@ -587,7 +587,7 @@ pub(crate) enum ReflectTypePath<'a> {
     ///
     /// The type must be able to be reached with just its name.
     ///
-    /// May have a seperate alias path used for the `TypePath` implementation.
+    /// May have a separate alias path used for the `TypePath` implementation.
     ///
     /// Module and crate are found with [`module_path!()`](core::module_path),
     /// if there is no custom path specified.
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 2061782115988e..216c1c605ebad5 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -523,7 +523,7 @@ pub fn impl_from_reflect_value(input: TokenStream) -> TokenStream {
 /// it requires an 'absolute' path definition.
 ///
 /// Specifically, a leading `::` denoting a global path must be specified
-/// or a preceeding `(in my_crate::foo)` to specify the custom path must be used.
+/// or a preceding `(in my_crate::foo)` to specify the custom path must be used.
 ///
 /// # Examples
 ///
diff --git a/crates/bevy_reflect/src/array.rs b/crates/bevy_reflect/src/array.rs
index c1acb9835678b9..0959826fefd519 100644
--- a/crates/bevy_reflect/src/array.rs
+++ b/crates/bevy_reflect/src/array.rs
@@ -18,7 +18,7 @@ use std::{
 ///
 /// Due to the [type-erasing] nature of the reflection API as a whole,
 /// this trait does not make any guarantees that the implementor's elements
-/// are homogenous (i.e. all the same type).
+/// are homogeneous (i.e. all the same type).
 ///
 /// This trait has a blanket implementation over Rust arrays of up to 32 items.
 /// This implementation can technically contain more than 32,
diff --git a/crates/bevy_reflect/src/from_reflect.rs b/crates/bevy_reflect/src/from_reflect.rs
index ba13fbf13bf1dd..861d0b1d063d19 100644
--- a/crates/bevy_reflect/src/from_reflect.rs
+++ b/crates/bevy_reflect/src/from_reflect.rs
@@ -14,7 +14,7 @@ use crate::{FromType, Reflect};
 /// Additionally, some complex types like `Vec<T>` require that their element types
 /// implement this trait.
 /// The reason for such requirements is that some operations require new data to be constructed,
-/// such as swapping to a new variant or pushing data to a homogenous list.
+/// such as swapping to a new variant or pushing data to a homogeneous list.
 ///
 /// See the [crate-level documentation] to see how this trait can be used.
 ///
diff --git a/crates/bevy_reflect/src/impls/std.rs b/crates/bevy_reflect/src/impls/std.rs
index ab8b482c18df0f..72c79bb76511cc 100644
--- a/crates/bevy_reflect/src/impls/std.rs
+++ b/crates/bevy_reflect/src/impls/std.rs
@@ -1207,7 +1207,7 @@ impl<T: FromReflect + Clone + TypePath> List for Cow<'static, [T]> {
     }
 
     fn drain(self: Box<Self>) -> Vec<Box<dyn Reflect>> {
-        // into_owned() is not uneccessary here because it avoids cloning whenever you have a Cow::Owned already
+        // into_owned() is not unnecessary here because it avoids cloning whenever you have a Cow::Owned already
         #[allow(clippy::unnecessary_to_owned)]
         self.into_owned()
             .into_iter()
diff --git a/crates/bevy_reflect/src/list.rs b/crates/bevy_reflect/src/list.rs
index 94c269c5203c45..5eb8c7885e813c 100644
--- a/crates/bevy_reflect/src/list.rs
+++ b/crates/bevy_reflect/src/list.rs
@@ -29,7 +29,7 @@ use crate::{
 ///
 /// Due to the [type-erasing] nature of the reflection API as a whole,
 /// this trait does not make any guarantees that the implementor's elements
-/// are homogenous (i.e. all the same type).
+/// are homogeneous (i.e. all the same type).
 ///
 /// # Example
 ///
diff --git a/crates/bevy_reflect/src/type_path.rs b/crates/bevy_reflect/src/type_path.rs
index 8238c998cbb5f2..68c2e646905670 100644
--- a/crates/bevy_reflect/src/type_path.rs
+++ b/crates/bevy_reflect/src/type_path.rs
@@ -112,7 +112,7 @@ pub trait TypePath: 'static {
         None
     }
 
-    /// Returns the path to the moudle the type is in, or [`None`] if it is [anonymous].
+    /// Returns the path to the module the type is in, or [`None`] if it is [anonymous].
     ///
     /// For `Option<PhantomData>`, this is `"core::option"`.
     ///
diff --git a/crates/bevy_reflect/src/utility.rs b/crates/bevy_reflect/src/utility.rs
index 8952ffde98c993..e1072841d5b683 100644
--- a/crates/bevy_reflect/src/utility.rs
+++ b/crates/bevy_reflect/src/utility.rs
@@ -232,7 +232,7 @@ impl<T: TypedProperty> GenericTypeCell<T> {
     {
         let type_id = TypeId::of::<G>();
 
-        // Put in a seperate scope, so `mapping` is dropped before `f`,
+        // Put in a separate scope, so `mapping` is dropped before `f`,
         // since `f` might want to call `get_or_insert` recursively
         // and we don't want a deadlock!
         {
diff --git a/crates/bevy_render/macros/src/as_bind_group.rs b/crates/bevy_render/macros/src/as_bind_group.rs
index 06f58aea2db88d..df137e95d8b554 100644
--- a/crates/bevy_render/macros/src/as_bind_group.rs
+++ b/crates/bevy_render/macros/src/as_bind_group.rs
@@ -217,7 +217,7 @@ pub fn derive_as_bind_group(ast: syn::DeriveInput) -> Result<TokenStream> {
                         buffer,
                     } = get_storage_binding_attr(nested_meta_items)?;
                     let visibility =
-                        visibility.hygenic_quote(&quote! { #render_path::render_resource });
+                        visibility.hygienic_quote(&quote! { #render_path::render_resource });
 
                     let field_name = field.ident.as_ref().unwrap();
                     let field_ty = &field.ty;
@@ -271,7 +271,7 @@ pub fn derive_as_bind_group(ast: syn::DeriveInput) -> Result<TokenStream> {
                     } = tex_attrs.as_ref().unwrap();
 
                     let visibility =
-                        visibility.hygenic_quote(&quote! { #render_path::render_resource });
+                        visibility.hygienic_quote(&quote! { #render_path::render_resource });
 
                     let fallback_image = get_fallback_image(&render_path, *dimension);
 
@@ -310,7 +310,7 @@ pub fn derive_as_bind_group(ast: syn::DeriveInput) -> Result<TokenStream> {
                         .expect("sampler attribute must have matching texture attribute");
 
                     let visibility =
-                        visibility.hygenic_quote(&quote! { #render_path::render_resource });
+                        visibility.hygienic_quote(&quote! { #render_path::render_resource });
 
                     let fallback_image = get_fallback_image(&render_path, *dimension);
 
@@ -606,7 +606,7 @@ impl VisibilityFlags {
 }
 
 impl ShaderStageVisibility {
-    fn hygenic_quote(&self, path: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {
+    fn hygienic_quote(&self, path: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {
         match self {
             ShaderStageVisibility::All => quote! { #path::ShaderStages::all() },
             ShaderStageVisibility::None => quote! { #path::ShaderStages::NONE },
diff --git a/crates/bevy_transform/src/components/transform.rs b/crates/bevy_transform/src/components/transform.rs
index e02ebebbbd98dd..5f6f42ab0b91f2 100644
--- a/crates/bevy_transform/src/components/transform.rs
+++ b/crates/bevy_transform/src/components/transform.rs
@@ -337,7 +337,7 @@ impl Transform {
     /// and [`Transform::up`] points towards `up`.
     ///
     /// In some cases it's not possible to construct a rotation. Another axis will be picked in those cases:
-    /// * if `target` is the same as the transtorm translation, `Vec3::Z` is used instead
+    /// * if `target` is the same as the transform translation, `Vec3::Z` is used instead
     /// * if `up` is zero, `Vec3::Y` is used instead
     /// * if the resulting forward direction is parallel with `up`, an orthogonal vector is used as the "right" direction
     #[inline]
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 4eb26df186957a..098f219f3a5762 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -281,7 +281,7 @@ pub fn extract_uinode_borders(
         .get_single()
         .map(|window| Vec2::new(window.resolution.width(), window.resolution.height()))
         .unwrap_or(Vec2::ZERO)
-        // The logical window resolutin returned by `Window` only takes into account the window scale factor and not `UiScale`,
+        // The logical window resolution returned by `Window` only takes into account the window scale factor and not `UiScale`,
         // so we have to divide by `UiScale` to get the size of the UI viewport.
         / ui_scale.scale as f32;
 
diff --git a/crates/bevy_ui/src/stack.rs b/crates/bevy_ui/src/stack.rs
index 6dd063b02ffbc7..c24a8aad66b268 100644
--- a/crates/bevy_ui/src/stack.rs
+++ b/crates/bevy_ui/src/stack.rs
@@ -108,7 +108,7 @@ fn fill_stack_recursively(result: &mut Vec<Entity>, stack: &mut StackingContext)
     stack.entries.sort_by_key(|e| e.z_index);
 
     for entry in &mut stack.entries {
-        // Parent node renders before/behind childs nodes
+        // Parent node renders before/behind child nodes
         result.push(entry.entity);
         fill_stack_recursively(result, &mut entry.stack);
     }
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index c4c128198e840f..2e7a77fbecb6b4 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -289,13 +289,13 @@ impl Val {
 /// ### Flexbox
 ///
 /// - [MDN: Basic Concepts of Grid Layout](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Grid_Layout/Basic_Concepts_of_Grid_Layout)
-/// - [A Complete Guide To Flexbox](https://css-tricks.com/snippets/css/a-guide-to-flexbox/) by CSS Tricks. This is detailed guide with illustrations and comphrehensive written explanation of the different Flexbox properties and how they work.
+/// - [A Complete Guide To Flexbox](https://css-tricks.com/snippets/css/a-guide-to-flexbox/) by CSS Tricks. This is detailed guide with illustrations and comprehensive written explanation of the different Flexbox properties and how they work.
 /// - [Flexbox Froggy](https://flexboxfroggy.com/). An interactive tutorial/game that teaches the essential parts of Flebox in a fun engaging way.
 ///
 /// ### CSS Grid
 ///
 /// - [MDN: Basic Concepts of Flexbox](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Flexible_Box_Layout/Basic_Concepts_of_Flexbox)
-/// - [A Complete Guide To CSS Grid](https://css-tricks.com/snippets/css/complete-guide-grid/) by CSS Tricks. This is detailed guide with illustrations and comphrehensive written explanation of the different CSS Grid properties and how they work.
+/// - [A Complete Guide To CSS Grid](https://css-tricks.com/snippets/css/complete-guide-grid/) by CSS Tricks. This is detailed guide with illustrations and comprehensive written explanation of the different CSS Grid properties and how they work.
 /// - [CSS Grid Garden](https://cssgridgarden.com/). An interactive tutorial/game that teaches the essential parts of CSS Grid in a fun engaging way.
 
 #[derive(Component, Clone, PartialEq, Debug, Reflect)]
@@ -395,7 +395,7 @@ pub struct Style {
     /// For CSS Grid containers:
     ///   - Controls block (vertical) axis alignment of children of this grid container within their grid areas
     ///
-    /// This value is overriden [`JustifySelf`] on the child node is set.
+    /// This value is overridden [`JustifySelf`] on the child node is set.
     ///
     /// <https://developer.mozilla.org/en-US/docs/Web/CSS/align-items>
     pub align_items: AlignItems,
@@ -405,7 +405,7 @@ pub struct Style {
     /// For CSS Grid containers:
     ///   - Sets default inline (horizontal) axis alignment of child items within their grid areas
     ///
-    /// This value is overriden [`JustifySelf`] on the child node is set.
+    /// This value is overridden [`JustifySelf`] on the child node is set.
     ///
     /// <https://developer.mozilla.org/en-US/docs/Web/CSS/justify-items>
     pub justify_items: JustifyItems,
@@ -566,7 +566,7 @@ pub struct Style {
     /// <https://developer.mozilla.org/en-US/docs/Web/CSS/grid-auto-rows>
     pub grid_auto_rows: Vec<GridTrack>,
     /// Defines the size of implicitly created columns. Columns are created implicitly when grid items are given explicit placements that are out of bounds
-    /// of the columns explicitly created using `grid_template_columms`.
+    /// of the columns explicitly created using `grid_template_columns`.
     ///
     /// <https://developer.mozilla.org/en-US/docs/Web/CSS/grid-template-columns>
     pub grid_auto_columns: Vec<GridTrack>,
@@ -1435,7 +1435,7 @@ impl From<RepeatedGridTrack> for Vec<RepeatedGridTrack> {
 ///
 /// The default `span` is 1. If neither `start` or `end` is set then the item will be placed automatically.
 ///
-/// Generally, at most two fields should be set. If all three fields are specifed then `span` will be ignored. If `end` specifies an earlier
+/// Generally, at most two fields should be set. If all three fields are specified then `span` will be ignored. If `end` specifies an earlier
 /// grid line than `start` then `end` will be ignored and the item will have a span of 1.
 ///
 /// <https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Grid_Layout/Line-based_Placement_with_CSS_Grid>
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index 82b47ceb5bd891..391d15e1cbceef 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -99,7 +99,7 @@ fn create_text_measure(
                 content_size.set(TextMeasure { info: measure });
             }
 
-            // Text measure func created succesfully, so set `TextFlags` to schedule a recompute
+            // Text measure func created successfully, so set `TextFlags` to schedule a recompute
             text_flags.needs_new_measure_func = false;
             text_flags.needs_recompute = true;
         }
diff --git a/crates/bevy_utils/src/syncunsafecell.rs b/crates/bevy_utils/src/syncunsafecell.rs
index 839bf7b9d1a558..a2a3ac388507a2 100644
--- a/crates/bevy_utils/src/syncunsafecell.rs
+++ b/crates/bevy_utils/src/syncunsafecell.rs
@@ -12,7 +12,7 @@ pub use core::cell::UnsafeCell;
 /// This is just an `UnsafeCell`, except it implements `Sync`
 /// if `T` implements `Sync`.
 ///
-/// `UnsafeCell` doesn't implement `Sync`, to prevent accidental mis-use.
+/// `UnsafeCell` doesn't implement `Sync`, to prevent accidental misuse.
 /// You can use `SyncUnsafeCell` instead of `UnsafeCell` to allow it to be
 /// shared between threads, if that's intentional.
 /// Providing proper synchronization is still the task of the user,
diff --git a/examples/shader/post_processing.rs b/examples/shader/post_processing.rs
index 470519377078bf..759cc2467769da 100644
--- a/examples/shader/post_processing.rs
+++ b/examples/shader/post_processing.rs
@@ -84,7 +84,7 @@ impl Plugin for PostProcessPlugin {
             // Add a [`Node`] to the [`RenderGraph`]
             // The Node needs to impl FromWorld
             .add_render_graph_node::<PostProcessNode>(
-                // Specifiy the name of the graph, in this case we want the graph for 3d
+                // Specify the name of the graph, in this case we want the graph for 3d
                 core_3d::graph::NAME,
                 // It also needs the name of the node
                 PostProcessNode::NAME,
diff --git a/examples/tools/scene_viewer/morph_viewer_plugin.rs b/examples/tools/scene_viewer/morph_viewer_plugin.rs
index c54c4fcdb4431b..e71a41db95fbf4 100644
--- a/examples/tools/scene_viewer/morph_viewer_plugin.rs
+++ b/examples/tools/scene_viewer/morph_viewer_plugin.rs
@@ -1,6 +1,6 @@
 //! Enable controls for morph targets detected in a loaded scene.
 //!
-//! Collect morph targets and assing keys to them,
+//! Collect morph targets and assign keys to them,
 //! shows on screen additional controls for morph targets.
 //!
 //! Illustrates how to access and modify individual morph target weights.
diff --git a/examples/ui/display_and_visibility.rs b/examples/ui/display_and_visibility.rs
index d5a7f35dce440e..799aca79fd3f42 100644
--- a/examples/ui/display_and_visibility.rs
+++ b/examples/ui/display_and_visibility.rs
@@ -168,7 +168,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                         ..Default::default()
                         });
                     builder.spawn(TextBundle::from_section(
-                        "The UI Node and its descendants will not be visible and will not be alloted any space in the UI layout.\nThe UI Node will not be visible but will still occupy space in the UI layout.\nThe UI node will inherit the visibility property of its parent. If it has no parent it will be visible.",
+                        "The UI Node and its descendants will not be visible and will not be allotted any space in the UI layout.\nThe UI Node will not be visible but will still occupy space in the UI layout.\nThe UI node will inherit the visibility property of its parent. If it has no parent it will be visible.",
                         text_style
                     ));
             });
diff --git a/examples/ui/size_constraints.rs b/examples/ui/size_constraints.rs
index b46430990df659..41a57224fc17df 100644
--- a/examples/ui/size_constraints.rs
+++ b/examples/ui/size_constraints.rs
@@ -94,13 +94,13 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                             ..Default::default()
                         })
                         .with_children(|parent| {
-                            for constaint in [
+                            for constraint in [
                                 Constraint::MinWidth,
                                 Constraint::FlexBasis,
                                 Constraint::Width,
                                 Constraint::MaxWidth,
                             ] {
-                                spawn_button_row(parent, constaint, text_style.clone());
+                                spawn_button_row(parent, constraint, text_style.clone());
                             }
                         });
                 });
diff --git a/examples/ui/ui.rs b/examples/ui/ui.rs
index f1bfbcd622cc14..6cf9a3a07d720b 100644
--- a/examples/ui/ui.rs
+++ b/examples/ui/ui.rs
@@ -290,7 +290,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                         ))
                         .with_children(|parent| {
                             // alt text
-                            // This UI node takes up no space in the layout and the `Text` component is used by the accessiblity module
+                            // This UI node takes up no space in the layout and the `Text` component is used by the accessibility module
                             // and is not rendered.
                             parent.spawn((
                                 NodeBundle {
diff --git a/tools/build-wasm-example/src/main.rs b/tools/build-wasm-example/src/main.rs
index a181084860a31d..0eedf274aeb580 100644
--- a/tools/build-wasm-example/src/main.rs
+++ b/tools/build-wasm-example/src/main.rs
@@ -109,7 +109,7 @@ fn main() {
 
         if cli.optimize_size {
             cmd!(sh, "wasm-opt -Oz --output examples/wasm/target/wasm_example_bg.wasm.optimized examples/wasm/target/wasm_example_bg.wasm")
-                .run().expect("Failed to optimize for size. Do you have wasm-opt corretly set up?");
+                .run().expect("Failed to optimize for size. Do you have wasm-opt correctly set up?");
         }
 
         if cli.test {

From c71ae262923e949842c2df17797abee3eb224879 Mon Sep 17 00:00:00 2001
From: Hennadii Chernyshchyk <genaloner@gmail.com>
Date: Mon, 10 Jul 2023 11:05:13 +0300
Subject: [PATCH 14/30] Update `GlobalTransform` on insertion (#9081)

# Objective

`GlobalTransform` after insertion will be updated only on `Transform` or
hierarchy change.

Fixes #9075

## Solution

Update `GlobalTransform` after insertion too.

---

## Changelog

- `GlobalTransform` is now updated not only on `Transform` or hierarchy
change, but also on insertion.
---
 crates/bevy_transform/src/systems.rs | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_transform/src/systems.rs b/crates/bevy_transform/src/systems.rs
index 46629eca57db9b..420ce7a9e36234 100644
--- a/crates/bevy_transform/src/systems.rs
+++ b/crates/bevy_transform/src/systems.rs
@@ -2,6 +2,7 @@ use crate::components::{GlobalTransform, Transform};
 use bevy_ecs::{
     change_detection::Ref,
     prelude::{Changed, DetectChanges, Entity, Query, With, Without},
+    query::{Added, Or},
     removal_detection::RemovedComponents,
     system::{Local, ParamSet},
 };
@@ -14,7 +15,11 @@ pub fn sync_simple_transforms(
     mut query: ParamSet<(
         Query<
             (&Transform, &mut GlobalTransform),
-            (Changed<Transform>, Without<Parent>, Without<Children>),
+            (
+                Or<(Changed<Transform>, Added<GlobalTransform>)>,
+                Without<Parent>,
+                Without<Children>,
+            ),
         >,
         Query<(Ref<Transform>, &mut GlobalTransform), Without<Children>>,
     )>,
@@ -31,7 +36,7 @@ pub fn sync_simple_transforms(
     let mut query = query.p1();
     let mut iter = query.iter_many_mut(orphaned.iter());
     while let Some((transform, mut global_transform)) = iter.fetch_next() {
-        if !transform.is_changed() {
+        if !transform.is_changed() && !global_transform.is_added() {
             *global_transform = GlobalTransform::from(*transform);
         }
     }
@@ -56,7 +61,7 @@ pub fn propagate_transforms(
     orphaned_entities.sort_unstable();
     root_query.par_iter_mut().for_each_mut(
         |(entity, children, transform, mut global_transform)| {
-            let changed = transform.is_changed() || orphaned_entities.binary_search(&entity).is_ok();
+            let changed = transform.is_changed() || global_transform.is_added() || orphaned_entities.binary_search(&entity).is_ok();
             if changed {
                 *global_transform = GlobalTransform::from(*transform);
             }
@@ -143,7 +148,7 @@ unsafe fn propagate_recursive(
                 return;
             };
 
-        changed |= transform.is_changed();
+        changed |= transform.is_changed() || global_transform.is_added();
         if changed {
             *global_transform = parent.mul_transform(*transform);
         }

From aa031302345f3e8c81248a724a7b298245e2fe60 Mon Sep 17 00:00:00 2001
From: Cptn-Sherman <56683258+Cptn-Sherman@users.noreply.github.com>
Date: Mon, 10 Jul 2023 10:02:16 -0700
Subject: [PATCH 15/30] Fix typo in NamedTypePathDef (#9102)

# Objective
Fixes #9091

## Solution
Rename instances of `Primtive` to `Primitive`

## Migration Guide

Before:

```rust
let type_path = NamedTypePathDef::Primtive(ident);
```

After:
```rust
let type_path = NamedTypePathDef::Primitive(ident);
```
---
 crates/bevy_reflect/bevy_reflect_derive/src/lib.rs       | 2 +-
 crates/bevy_reflect/bevy_reflect_derive/src/type_path.rs | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 216c1c605ebad5..87eee59dc8d67b 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -571,7 +571,7 @@ pub fn impl_type_path(input: TokenStream) -> TokenStream {
                 generics,
             }
         }
-        NamedTypePathDef::Primtive(ref ident) => ReflectTypePath::Primitive(ident),
+        NamedTypePathDef::Primitive(ref ident) => ReflectTypePath::Primitive(ident),
     };
 
     let meta = ReflectMeta::new(type_path, ReflectTraits::default());
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/type_path.rs b/crates/bevy_reflect/bevy_reflect_derive/src/type_path.rs
index 5a2f8c9fae190e..3ef92981a33d97 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/type_path.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/type_path.rs
@@ -73,7 +73,7 @@ pub(crate) enum NamedTypePathDef {
         generics: Generics,
         custom_path: Option<CustomPathDef>,
     },
-    Primtive(Ident),
+    Primitive(Ident),
 }
 
 impl Parse for NamedTypePathDef {
@@ -87,7 +87,7 @@ impl Parse for NamedTypePathDef {
         if path.leading_colon.is_none() && custom_path.is_none() {
             if path.segments.len() == 1 {
                 let ident = path.segments.into_iter().next().unwrap().ident;
-                Ok(NamedTypePathDef::Primtive(ident))
+                Ok(NamedTypePathDef::Primitive(ident))
             } else {
                 Err(input.error("non-customized paths must start with a double colon (`::`)"))
             }

From 6bca1294406cc17f1500e86ce74565c5750600b9 Mon Sep 17 00:00:00 2001
From: Nicola Papale <nicopap@users.noreply.github.com>
Date: Mon, 10 Jul 2023 19:05:03 +0200
Subject: [PATCH 16/30] Remove out-of-date paragraph in `Style::border` (#9103)

# Objective

- bevy now renders borders, doc is out of date

## Solution

- Fix blatant lie
---
 crates/bevy_ui/src/ui_node.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index 2e7a77fbecb6b4..7a41270eeb0e6e 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -496,8 +496,6 @@ pub struct Style {
     ///
     /// The size of the node will be expanded if there are constraints that prevent the layout algorithm from placing the border within the existing node boundary.
     ///
-    /// Rendering for borders is not yet implemented.
-    ///
     /// <https://developer.mozilla.org/en-US/docs/Web/CSS/border-width>
     pub border: UiRect,
 

From 7c3131a76136f1f05f6380cc3ca291543d4b891b Mon Sep 17 00:00:00 2001
From: Carter Anderson <mcanders1@gmail.com>
Date: Mon, 10 Jul 2023 14:19:27 -0700
Subject: [PATCH 17/30] Bump Version after Release (#9106)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

CI-capable version of #9086

---------

Co-authored-by: Bevy Auto Releaser <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: François <mockersf@gmail.com>
---
 Cargo.toml                                    |  6 +-
 crates/bevy_a11y/Cargo.toml                   |  8 +--
 crates/bevy_animation/Cargo.toml              | 24 +++----
 crates/bevy_app/Cargo.toml                    | 12 ++--
 crates/bevy_asset/Cargo.toml                  | 20 +++---
 crates/bevy_audio/Cargo.toml                  | 18 ++---
 crates/bevy_core/Cargo.toml                   | 14 ++--
 crates/bevy_core_pipeline/Cargo.toml          | 22 +++----
 crates/bevy_derive/Cargo.toml                 |  4 +-
 crates/bevy_diagnostic/Cargo.toml             | 14 ++--
 crates/bevy_dylib/Cargo.toml                  |  4 +-
 crates/bevy_dynamic_plugin/Cargo.toml         |  4 +-
 crates/bevy_ecs/Cargo.toml                    | 12 ++--
 crates/bevy_ecs/macros/Cargo.toml             |  4 +-
 crates/bevy_encase_derive/Cargo.toml          |  4 +-
 crates/bevy_gilrs/Cargo.toml                  | 14 ++--
 crates/bevy_gizmos/Cargo.toml                 | 26 ++++----
 crates/bevy_gltf/Cargo.toml                   | 34 +++++-----
 crates/bevy_hierarchy/Cargo.toml              | 14 ++--
 crates/bevy_input/Cargo.toml                  | 14 ++--
 crates/bevy_internal/Cargo.toml               | 66 +++++++++----------
 crates/bevy_log/Cargo.toml                    |  8 +--
 crates/bevy_macro_utils/Cargo.toml            |  2 +-
 crates/bevy_math/Cargo.toml                   |  2 +-
 crates/bevy_mikktspace/Cargo.toml             |  2 +-
 crates/bevy_pbr/Cargo.toml                    | 24 +++----
 crates/bevy_ptr/Cargo.toml                    |  2 +-
 crates/bevy_reflect/Cargo.toml                | 10 +--
 .../bevy_reflect_derive/Cargo.toml            |  4 +-
 crates/bevy_render/Cargo.toml                 | 36 +++++-----
 crates/bevy_render/macros/Cargo.toml          |  4 +-
 crates/bevy_scene/Cargo.toml                  | 20 +++---
 crates/bevy_sprite/Cargo.toml                 | 24 +++----
 crates/bevy_tasks/Cargo.toml                  |  2 +-
 crates/bevy_text/Cargo.toml                   | 22 +++----
 crates/bevy_time/Cargo.toml                   | 10 +--
 crates/bevy_transform/Cargo.toml              | 14 ++--
 crates/bevy_ui/Cargo.toml                     | 36 +++++-----
 crates/bevy_utils/Cargo.toml                  |  4 +-
 crates/bevy_utils/macros/Cargo.toml           |  2 +-
 crates/bevy_window/Cargo.toml                 | 14 ++--
 crates/bevy_winit/Cargo.toml                  | 22 +++----
 tools/build-templated-pages/Cargo.toml        |  2 +-
 43 files changed, 302 insertions(+), 302 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 6ccf7a3244b773..8bb4836745adc2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 categories = ["game-engines", "graphics", "gui", "rendering"]
 description = "A refreshingly simple data-driven game engine and app framework"
@@ -249,8 +249,8 @@ shader_format_spirv = ["bevy_internal/shader_format_spirv"]
 webgl2 = ["bevy_internal/webgl"]
 
 [dependencies]
-bevy_dylib = { path = "crates/bevy_dylib", version = "0.11.0", default-features = false, optional = true }
-bevy_internal = { path = "crates/bevy_internal", version = "0.11.0", default-features = false }
+bevy_dylib = { path = "crates/bevy_dylib", version = "0.12.0-dev", default-features = false, optional = true }
+bevy_internal = { path = "crates/bevy_internal", version = "0.12.0-dev", default-features = false }
 
 [dev-dependencies]
 anyhow = "1.0.4"
diff --git a/crates/bevy_a11y/Cargo.toml b/crates/bevy_a11y/Cargo.toml
index ca1bf641569f2c..6a35a0e661a0e9 100644
--- a/crates/bevy_a11y/Cargo.toml
+++ b/crates/bevy_a11y/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_a11y"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides accessibility support for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,8 +10,8 @@ keywords = ["bevy", "accessibility", "a11y"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
 
 accesskit = "0.11"
diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index 650cc8f906a018..8e529b5171e20c 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_animation"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides animation functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,14 +10,14 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
-bevy_core = { path = "../bevy_core", version = "0.11.0" }
-bevy_math = { path = "../bevy_math", version = "0.11.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
-bevy_render = { path = "../bevy_render", version = "0.11.0" }
-bevy_time = { path = "../bevy_time", version = "0.11.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_core = { path = "../bevy_core", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_render = { path = "../bevy_render", version = "0.12.0-dev" }
+bevy_time = { path = "../bevy_time", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.12.0-dev" }
diff --git a/crates/bevy_app/Cargo.toml b/crates/bevy_app/Cargo.toml
index aca9bfa71c9dc8..27c866dba4b377 100644
--- a/crates/bevy_app/Cargo.toml
+++ b/crates/bevy_app/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_app"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides core App functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -16,11 +16,11 @@ bevy_reflect = ["dep:bevy_reflect", "bevy_ecs/bevy_reflect"]
 
 [dependencies]
 # bevy
-bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0", default-features = false }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", optional = true }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev", default-features = false }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", optional = true }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.12.0-dev" }
 
 # other
 serde = { version = "1.0", features = ["derive"], optional = true }
diff --git a/crates/bevy_asset/Cargo.toml b/crates/bevy_asset/Cargo.toml
index ba3f082536085d..59c2b48aa58664 100644
--- a/crates/bevy_asset/Cargo.toml
+++ b/crates/bevy_asset/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_asset"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides asset functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -15,13 +15,13 @@ debug_asset_server = ["filesystem_watcher"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_diagnostic = { path = "../bevy_diagnostic", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
-bevy_log = { path = "../bevy_log", version = "0.11.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_diagnostic = { path = "../bevy_diagnostic", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_log = { path = "../bevy_log", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_tasks = { path = "../bevy_tasks", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 
 # other
 serde = { version = "1", features = ["derive"] }
@@ -34,7 +34,7 @@ notify = { version = "6.0.0", optional = true }
 parking_lot = "0.12.1"
 
 [target.'cfg(target_os = "android")'.dependencies]
-bevy_winit = { path = "../bevy_winit", version = "0.11.0" }
+bevy_winit = { path = "../bevy_winit", version = "0.12.0-dev" }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 wasm-bindgen = { version = "0.2" }
@@ -45,4 +45,4 @@ js-sys = "0.3"
 [dev-dependencies]
 futures-lite = "1.4.0"
 tempfile = "3.2.0"
-bevy_core = { path = "../bevy_core", version = "0.11.0" }
+bevy_core = { path = "../bevy_core", version = "0.12.0-dev" }
diff --git a/crates/bevy_audio/Cargo.toml b/crates/bevy_audio/Cargo.toml
index 8127d4d5be9a1e..53f3764777bb09 100644
--- a/crates/bevy_audio/Cargo.toml
+++ b/crates/bevy_audio/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_audio"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides audio functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,14 +10,14 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
-bevy_math = { path = "../bevy_math", version = "0.11.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 
 # other
 anyhow = "1.0.4"
diff --git a/crates/bevy_core/Cargo.toml b/crates/bevy_core/Cargo.toml
index 5a6daf09d2814b..c4ecb40dce5f12 100644
--- a/crates/bevy_core/Cargo.toml
+++ b/crates/bevy_core/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_core"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides core functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -11,12 +11,12 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0", features = ["bevy_reflect"] }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0", features = ["bevy_reflect"] }
-bevy_math = { path = "../bevy_math", version = "0.11.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev", features = ["bevy_reflect"] }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev", features = ["bevy_reflect"] }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_tasks = { path = "../bevy_tasks", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 
 # other
 bytemuck = "1.5"
diff --git a/crates/bevy_core_pipeline/Cargo.toml b/crates/bevy_core_pipeline/Cargo.toml
index 6da843ff3b8922..27825880d3473f 100644
--- a/crates/bevy_core_pipeline/Cargo.toml
+++ b/crates/bevy_core_pipeline/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_core_pipeline"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -19,16 +19,16 @@ tonemapping_luts = []
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
-bevy_core = { path = "../bevy_core", version = "0.11.0" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0" }
-bevy_render = { path = "../bevy_render", version = "0.11.0" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
-bevy_math = { path = "../bevy_math", version = "0.11.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_core = { path = "../bevy_core", version = "0.12.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev" }
+bevy_render = { path = "../bevy_render", version = "0.12.0-dev" }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 
 serde = { version = "1", features = ["derive"] }
 bitflags = "2.3"
diff --git a/crates/bevy_derive/Cargo.toml b/crates/bevy_derive/Cargo.toml
index 9da757fedb96a4..b200c175469df9 100644
--- a/crates/bevy_derive/Cargo.toml
+++ b/crates/bevy_derive/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_derive"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides derive implementations for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -12,7 +12,7 @@ keywords = ["bevy"]
 proc-macro = true
 
 [dependencies]
-bevy_macro_utils = { path = "../bevy_macro_utils", version = "0.11.0" }
+bevy_macro_utils = { path = "../bevy_macro_utils", version = "0.12.0-dev" }
 
 quote = "1.0"
 syn = { version = "2.0", features = ["full"] }
diff --git a/crates/bevy_diagnostic/Cargo.toml b/crates/bevy_diagnostic/Cargo.toml
index 70d3f6baf8d8d5..52e3b1b86f15c8 100644
--- a/crates/bevy_diagnostic/Cargo.toml
+++ b/crates/bevy_diagnostic/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_diagnostic"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides diagnostic functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -14,12 +14,12 @@ dynamic_linking = []
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_core = { path = "../bevy_core", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
-bevy_log = { path = "../bevy_log", version = "0.11.0" }
-bevy_time = { path = "../bevy_time", version = "0.11.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_core = { path = "../bevy_core", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_log = { path = "../bevy_log", version = "0.12.0-dev" }
+bevy_time = { path = "../bevy_time", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 
 # MacOS
 [target.'cfg(all(target_os="macos"))'.dependencies]
diff --git a/crates/bevy_dylib/Cargo.toml b/crates/bevy_dylib/Cargo.toml
index a20a84d7897075..f8f40ea5fe3612 100644
--- a/crates/bevy_dylib/Cargo.toml
+++ b/crates/bevy_dylib/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_dylib"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Force the Bevy Engine to be dynamically linked for faster linking"
 homepage = "https://bevyengine.org"
@@ -12,4 +12,4 @@ keywords = ["bevy"]
 crate-type = ["dylib"]
 
 [dependencies]
-bevy_internal = { path = "../bevy_internal", version = "0.11.0", default-features = false }
+bevy_internal = { path = "../bevy_internal", version = "0.12.0-dev", default-features = false }
diff --git a/crates/bevy_dynamic_plugin/Cargo.toml b/crates/bevy_dynamic_plugin/Cargo.toml
index a0dc3973811322..22507f0007f542 100644
--- a/crates/bevy_dynamic_plugin/Cargo.toml
+++ b/crates/bevy_dynamic_plugin/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_dynamic_plugin"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides dynamic plugin loading capabilities for non-wasm platforms"
 homepage = "https://bevyengine.org"
@@ -10,7 +10,7 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
 
 # other
 libloading = { version = "0.8" }
diff --git a/crates/bevy_ecs/Cargo.toml b/crates/bevy_ecs/Cargo.toml
index 0495a83116d8d5..dc13ba8ee05e0e 100644
--- a/crates/bevy_ecs/Cargo.toml
+++ b/crates/bevy_ecs/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_ecs"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Bevy Engine's entity component system"
 homepage = "https://bevyengine.org"
@@ -15,11 +15,11 @@ multi-threaded = ["bevy_tasks/multi-threaded"]
 default = ["bevy_reflect", "multi-threaded"]
 
 [dependencies]
-bevy_ptr = { path = "../bevy_ptr", version = "0.11.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", optional = true }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
-bevy_ecs_macros = { path = "macros", version = "0.11.0" }
+bevy_ptr = { path = "../bevy_ptr", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", optional = true }
+bevy_tasks = { path = "../bevy_tasks", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_ecs_macros = { path = "macros", version = "0.12.0-dev" }
 
 async-channel = "1.4"
 event-listener = "2.5"
diff --git a/crates/bevy_ecs/macros/Cargo.toml b/crates/bevy_ecs/macros/Cargo.toml
index 880664f2d7ca0e..45529ce2019fe0 100644
--- a/crates/bevy_ecs/macros/Cargo.toml
+++ b/crates/bevy_ecs/macros/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_ecs_macros"
-version = "0.11.0"
+version = "0.12.0-dev"
 description = "Bevy ECS Macros"
 edition = "2021"
 license = "MIT OR Apache-2.0"
@@ -9,7 +9,7 @@ license = "MIT OR Apache-2.0"
 proc-macro = true
 
 [dependencies]
-bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.11.0" }
+bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.12.0-dev" }
 
 syn = "2.0"
 quote = "1.0"
diff --git a/crates/bevy_encase_derive/Cargo.toml b/crates/bevy_encase_derive/Cargo.toml
index c9ace9b8ec70d7..a435765011f24e 100644
--- a/crates/bevy_encase_derive/Cargo.toml
+++ b/crates/bevy_encase_derive/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_encase_derive"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Bevy derive macro for encase"
 homepage = "https://bevyengine.org"
@@ -12,5 +12,5 @@ keywords = ["bevy"]
 proc-macro = true
 
 [dependencies]
-bevy_macro_utils = { path = "../bevy_macro_utils", version = "0.11.0" }
+bevy_macro_utils = { path = "../bevy_macro_utils", version = "0.12.0-dev" }
 encase_derive_impl = "0.6.1"
diff --git a/crates/bevy_gilrs/Cargo.toml b/crates/bevy_gilrs/Cargo.toml
index 70c629ab63c142..4f8a51b9064bdb 100644
--- a/crates/bevy_gilrs/Cargo.toml
+++ b/crates/bevy_gilrs/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_gilrs"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Gamepad system made using Gilrs for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,12 +10,12 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
-bevy_input = { path = "../bevy_input", version = "0.11.0" }
-bevy_log = { path = "../bevy_log", version = "0.11.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
-bevy_time = { path = "../bevy_time", version = "0.11.0" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_input = { path = "../bevy_input", version = "0.12.0-dev" }
+bevy_log = { path = "../bevy_log", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_time = { path = "../bevy_time", version = "0.12.0-dev" }
 
 # other
 gilrs = "0.10.1"
diff --git a/crates/bevy_gizmos/Cargo.toml b/crates/bevy_gizmos/Cargo.toml
index ce3ddc46c73518..4a40902afae7b4 100644
--- a/crates/bevy_gizmos/Cargo.toml
+++ b/crates/bevy_gizmos/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_gizmos"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides gizmos for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -13,15 +13,15 @@ webgl = []
 
 [dependencies]
 # Bevy
-bevy_pbr = { path = "../bevy_pbr", version = "0.11.0", optional = true }
-bevy_sprite = { path = "../bevy_sprite", version = "0.11.0", optional = true }
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
-bevy_math = { path = "../bevy_math", version = "0.11.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
-bevy_render = { path = "../bevy_render", version = "0.11.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
-bevy_core = { path = "../bevy_core", version = "0.11.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0" }
-bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.11.0" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
+bevy_pbr = { path = "../bevy_pbr", version = "0.12.0-dev", optional = true }
+bevy_sprite = { path = "../bevy_sprite", version = "0.12.0-dev", optional = true }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_render = { path = "../bevy_render", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_core = { path = "../bevy_core", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.12.0-dev" }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
diff --git a/crates/bevy_gltf/Cargo.toml b/crates/bevy_gltf/Cargo.toml
index d2af027043a8e8..80291f06e22acb 100644
--- a/crates/bevy_gltf/Cargo.toml
+++ b/crates/bevy_gltf/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_gltf"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Bevy Engine GLTF loading"
 homepage = "https://bevyengine.org"
@@ -10,22 +10,22 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_animation = { path = "../bevy_animation", version = "0.11.0", optional = true }
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
-bevy_core = { path = "../bevy_core", version = "0.11.0" }
-bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0" }
-bevy_log = { path = "../bevy_log", version = "0.11.0" }
-bevy_math = { path = "../bevy_math", version = "0.11.0" }
-bevy_pbr = { path = "../bevy_pbr", version = "0.11.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
-bevy_render = { path = "../bevy_render", version = "0.11.0" }
-bevy_scene = { path = "../bevy_scene", version = "0.11.0", features = ["bevy_render"] }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_animation = { path = "../bevy_animation", version = "0.12.0-dev", optional = true }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_core = { path = "../bevy_core", version = "0.12.0-dev" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.12.0-dev" }
+bevy_log = { path = "../bevy_log", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_pbr = { path = "../bevy_pbr", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_render = { path = "../bevy_render", version = "0.12.0-dev" }
+bevy_scene = { path = "../bevy_scene", version = "0.12.0-dev", features = ["bevy_render"] }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 
 # other
 gltf = { version = "1.0.0", default-features = false, features = [
diff --git a/crates/bevy_hierarchy/Cargo.toml b/crates/bevy_hierarchy/Cargo.toml
index 48c081df6f22f2..d6ec89524775dd 100644
--- a/crates/bevy_hierarchy/Cargo.toml
+++ b/crates/bevy_hierarchy/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_hierarchy"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides hierarchy functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -13,12 +13,12 @@ trace = []
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_core = { path = "../bevy_core", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0", features = ["bevy_reflect"] }
-bevy_log = { path = "../bevy_log", version = "0.11.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_core = { path = "../bevy_core", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev", features = ["bevy_reflect"] }
+bevy_log = { path = "../bevy_log", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 
 # other
 smallvec = { version = "1.6", features = ["serde", "union", "const_generics"] }
diff --git a/crates/bevy_input/Cargo.toml b/crates/bevy_input/Cargo.toml
index 820d7767aece54..9f1b890ccc29d2 100644
--- a/crates/bevy_input/Cargo.toml
+++ b/crates/bevy_input/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_input"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides input functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -14,15 +14,15 @@ serialize = ["serde"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
-bevy_math = { path = "../bevy_math", version = "0.11.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["glam"] }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["glam"] }
 
 # other
 serde = { version = "1", features = ["derive"], optional = true }
 thiserror = "1.0"
 
 [dev-dependencies]
-bevy = { path = "../../", version = "0.11.0" }
+bevy = { path = "../../", version = "0.12.0-dev" }
diff --git a/crates/bevy_internal/Cargo.toml b/crates/bevy_internal/Cargo.toml
index 4582212d3d4ce5..28252e43d37c15 100644
--- a/crates/bevy_internal/Cargo.toml
+++ b/crates/bevy_internal/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_internal"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "An internal Bevy crate used to facilitate optional dynamic linking via the 'dynamic_linking' feature"
 homepage = "https://bevyengine.org"
@@ -107,36 +107,36 @@ default_font = ["bevy_text?/default_font"]
 
 [dependencies]
 # bevy
-bevy_a11y = { path = "../bevy_a11y", version = "0.11.0" }
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_core = { path = "../bevy_core", version = "0.11.0" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
-bevy_diagnostic = { path = "../bevy_diagnostic", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0" }
-bevy_input = { path = "../bevy_input", version = "0.11.0" }
-bevy_log = { path = "../bevy_log", version = "0.11.0" }
-bevy_math = { path = "../bevy_math", version = "0.11.0" }
-bevy_ptr = { path = "../bevy_ptr", version = "0.11.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
-bevy_time = { path = "../bevy_time", version = "0.11.0" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
-bevy_window = { path = "../bevy_window", version = "0.11.0" }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0" }
+bevy_a11y = { path = "../bevy_a11y", version = "0.12.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_core = { path = "../bevy_core", version = "0.12.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
+bevy_diagnostic = { path = "../bevy_diagnostic", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.12.0-dev" }
+bevy_input = { path = "../bevy_input", version = "0.12.0-dev" }
+bevy_log = { path = "../bevy_log", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_ptr = { path = "../bevy_ptr", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_time = { path = "../bevy_time", version = "0.12.0-dev" }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_window = { path = "../bevy_window", version = "0.12.0-dev" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.12.0-dev" }
 # bevy (optional)
-bevy_animation = { path = "../bevy_animation", optional = true, version = "0.11.0" }
-bevy_asset = { path = "../bevy_asset", optional = true, version = "0.11.0" }
-bevy_audio = { path = "../bevy_audio", optional = true, version = "0.11.0" }
-bevy_core_pipeline = { path = "../bevy_core_pipeline", optional = true, version = "0.11.0" }
-bevy_gltf = { path = "../bevy_gltf", optional = true, version = "0.11.0" }
-bevy_pbr = { path = "../bevy_pbr", optional = true, version = "0.11.0" }
-bevy_render = { path = "../bevy_render", optional = true, version = "0.11.0" }
-bevy_dynamic_plugin = { path = "../bevy_dynamic_plugin", optional = true, version = "0.11.0" }
-bevy_scene = { path = "../bevy_scene", optional = true, version = "0.11.0" }
-bevy_sprite = { path = "../bevy_sprite", optional = true, version = "0.11.0" }
-bevy_text = { path = "../bevy_text", optional = true, version = "0.11.0" }
-bevy_ui = { path = "../bevy_ui", optional = true, version = "0.11.0" }
-bevy_winit = { path = "../bevy_winit", optional = true, version = "0.11.0" }
-bevy_gilrs = { path = "../bevy_gilrs", optional = true, version = "0.11.0" }
-bevy_gizmos = { path = "../bevy_gizmos", optional = true, version = "0.11.0", default-features = false }
+bevy_animation = { path = "../bevy_animation", optional = true, version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", optional = true, version = "0.12.0-dev" }
+bevy_audio = { path = "../bevy_audio", optional = true, version = "0.12.0-dev" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", optional = true, version = "0.12.0-dev" }
+bevy_gltf = { path = "../bevy_gltf", optional = true, version = "0.12.0-dev" }
+bevy_pbr = { path = "../bevy_pbr", optional = true, version = "0.12.0-dev" }
+bevy_render = { path = "../bevy_render", optional = true, version = "0.12.0-dev" }
+bevy_dynamic_plugin = { path = "../bevy_dynamic_plugin", optional = true, version = "0.12.0-dev" }
+bevy_scene = { path = "../bevy_scene", optional = true, version = "0.12.0-dev" }
+bevy_sprite = { path = "../bevy_sprite", optional = true, version = "0.12.0-dev" }
+bevy_text = { path = "../bevy_text", optional = true, version = "0.12.0-dev" }
+bevy_ui = { path = "../bevy_ui", optional = true, version = "0.12.0-dev" }
+bevy_winit = { path = "../bevy_winit", optional = true, version = "0.12.0-dev" }
+bevy_gilrs = { path = "../bevy_gilrs", optional = true, version = "0.12.0-dev" }
+bevy_gizmos = { path = "../bevy_gizmos", optional = true, version = "0.12.0-dev", default-features = false }
diff --git a/crates/bevy_log/Cargo.toml b/crates/bevy_log/Cargo.toml
index 658b6cd02cb526..edb3823ef4a6d2 100644
--- a/crates/bevy_log/Cargo.toml
+++ b/crates/bevy_log/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_log"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides logging for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -13,9 +13,9 @@ trace = [ "tracing-error" ]
 trace_tracy_memory = ["dep:tracy-client"]
 
 [dependencies]
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
 
 tracing-subscriber = {version = "0.3.1", features = ["registry", "env-filter"]}
 tracing-chrome = { version = "0.7.0", optional = true }
diff --git a/crates/bevy_macro_utils/Cargo.toml b/crates/bevy_macro_utils/Cargo.toml
index a191a21de11719..261e8778806522 100644
--- a/crates/bevy_macro_utils/Cargo.toml
+++ b/crates/bevy_macro_utils/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_macro_utils"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "A collection of utils for Bevy Engine"
 homepage = "https://bevyengine.org"
diff --git a/crates/bevy_math/Cargo.toml b/crates/bevy_math/Cargo.toml
index 964f2a0041d6f1..ac74611a807154 100644
--- a/crates/bevy_math/Cargo.toml
+++ b/crates/bevy_math/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_math"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides math functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
diff --git a/crates/bevy_mikktspace/Cargo.toml b/crates/bevy_mikktspace/Cargo.toml
index 73f9307bca8ab8..e5471e7bc34512 100644
--- a/crates/bevy_mikktspace/Cargo.toml
+++ b/crates/bevy_mikktspace/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_mikktspace"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 authors = ["Benjamin Wasty <benny.wasty@gmail.com>", "David Harvey-Macaulay <alteous@outlook.com>", "Layl Bongers <LaylConway@users.noreply.github.com>"]
 description = "Mikkelsen tangent space algorithm"
diff --git a/crates/bevy_pbr/Cargo.toml b/crates/bevy_pbr/Cargo.toml
index 0fa6bd71ae1eb3..2f3bc6617cc597 100644
--- a/crates/bevy_pbr/Cargo.toml
+++ b/crates/bevy_pbr/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_pbr"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Adds PBR rendering to Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -13,17 +13,17 @@ webgl = []
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
-bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
-bevy_math = { path = "../bevy_math", version = "0.11.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
-bevy_render = { path = "../bevy_render", version = "0.11.0" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
-bevy_window = { path = "../bevy_window", version = "0.11.0" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_render = { path = "../bevy_render", version = "0.12.0-dev" }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_window = { path = "../bevy_window", version = "0.12.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
 
 # other
 bitflags = "2.3"
diff --git a/crates/bevy_ptr/Cargo.toml b/crates/bevy_ptr/Cargo.toml
index 1e1e9b9de767c7..a9cb87a1f4536d 100644
--- a/crates/bevy_ptr/Cargo.toml
+++ b/crates/bevy_ptr/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_ptr"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Utilities for working with untyped pointers in a more safe way"
 homepage = "https://bevyengine.org"
diff --git a/crates/bevy_reflect/Cargo.toml b/crates/bevy_reflect/Cargo.toml
index f2ebf141b0c86a..99c443a3cd0e17 100644
--- a/crates/bevy_reflect/Cargo.toml
+++ b/crates/bevy_reflect/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_reflect"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Dynamically interact with rust types"
 homepage = "https://bevyengine.org"
@@ -18,12 +18,12 @@ documentation = ["bevy_reflect_derive/documentation"]
 
 [dependencies]
 # bevy
-bevy_math = { path = "../bevy_math", version = "0.11.0", features = [
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev", features = [
     "serialize",
 ], optional = true }
-bevy_reflect_derive = { path = "bevy_reflect_derive", version = "0.11.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
-bevy_ptr = { path = "../bevy_ptr", version = "0.11.0" }
+bevy_reflect_derive = { path = "bevy_reflect_derive", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_ptr = { path = "../bevy_ptr", version = "0.12.0-dev" }
 
 # other
 erased-serde = "0.3"
diff --git a/crates/bevy_reflect/bevy_reflect_derive/Cargo.toml b/crates/bevy_reflect/bevy_reflect_derive/Cargo.toml
index 9441ae52b01720..5073873b638c5e 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/Cargo.toml
+++ b/crates/bevy_reflect/bevy_reflect_derive/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_reflect_derive"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Derive implementations for bevy_reflect"
 homepage = "https://bevyengine.org"
@@ -17,7 +17,7 @@ default = []
 documentation = []
 
 [dependencies]
-bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.11.0" }
+bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.12.0-dev" }
 
 syn = { version = "2.0", features = ["full"] }
 proc-macro2 = "1.0"
diff --git a/crates/bevy_render/Cargo.toml b/crates/bevy_render/Cargo.toml
index 7d04a8d140d55c..3d0ac77c11a85c 100644
--- a/crates/bevy_render/Cargo.toml
+++ b/crates/bevy_render/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_render"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides rendering functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -35,23 +35,23 @@ webgl = ["wgpu/webgl"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
-bevy_core = { path = "../bevy_core", version = "0.11.0" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
-bevy_encase_derive = { path = "../bevy_encase_derive", version = "0.11.0" }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0" }
-bevy_log = { path = "../bevy_log", version = "0.11.0" }
-bevy_math = { path = "../bevy_math", version = "0.11.0" }
-bevy_mikktspace = { path = "../bevy_mikktspace", version = "0.11.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
-bevy_render_macros = { path = "macros", version = "0.11.0" }
-bevy_time = { path = "../bevy_time", version = "0.11.0" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
-bevy_window = { path = "../bevy_window", version = "0.11.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_core = { path = "../bevy_core", version = "0.12.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_encase_derive = { path = "../bevy_encase_derive", version = "0.12.0-dev" }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.12.0-dev" }
+bevy_log = { path = "../bevy_log", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_mikktspace = { path = "../bevy_mikktspace", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_render_macros = { path = "macros", version = "0.12.0-dev" }
+bevy_time = { path = "../bevy_time", version = "0.12.0-dev" }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_window = { path = "../bevy_window", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.12.0-dev" }
 
 # rendering
 image = { version = "0.24", default-features = false }
diff --git a/crates/bevy_render/macros/Cargo.toml b/crates/bevy_render/macros/Cargo.toml
index e4bd2ff08a50ab..5ffcadfc98b361 100644
--- a/crates/bevy_render/macros/Cargo.toml
+++ b/crates/bevy_render/macros/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_render_macros"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Derive implementations for bevy_render"
 homepage = "https://bevyengine.org"
@@ -12,7 +12,7 @@ keywords = ["bevy"]
 proc-macro = true
 
 [dependencies]
-bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.11.0" }
+bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.12.0-dev" }
 
 syn = "2.0"
 proc-macro2 = "1.0"
diff --git a/crates/bevy_scene/Cargo.toml b/crates/bevy_scene/Cargo.toml
index 0eff8d91ca75ca..b408a45ea762bc 100644
--- a/crates/bevy_scene/Cargo.toml
+++ b/crates/bevy_scene/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_scene"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides scene functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -14,15 +14,15 @@ serialize = ["dep:serde", "uuid/serde"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
-bevy_render = { path = "../bevy_render", version = "0.11.0", optional = true }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.12.0-dev" }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_render = { path = "../bevy_render", version = "0.12.0-dev", optional = true }
 
 # other
 serde = { version = "1.0", features = ["derive"], optional = true }
diff --git a/crates/bevy_sprite/Cargo.toml b/crates/bevy_sprite/Cargo.toml
index 28a19aa4b711a3..37db1b9eb2a203 100644
--- a/crates/bevy_sprite/Cargo.toml
+++ b/crates/bevy_sprite/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_sprite"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides sprite functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,19 +10,19 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
-bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
-bevy_log = { path = "../bevy_log", version = "0.11.0" }
-bevy_math = { path = "../bevy_math", version = "0.11.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = [
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_log = { path = "../bevy_log", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = [
     "bevy",
 ] }
-bevy_render = { path = "../bevy_render", version = "0.11.0" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
+bevy_render = { path = "../bevy_render", version = "0.12.0-dev" }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
 
 # other
 bytemuck = { version = "1.5", features = ["derive"] }
diff --git a/crates/bevy_tasks/Cargo.toml b/crates/bevy_tasks/Cargo.toml
index 7b9255022c3011..bcedb8b944cc23 100644
--- a/crates/bevy_tasks/Cargo.toml
+++ b/crates/bevy_tasks/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_tasks"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "A task executor for Bevy Engine"
 homepage = "https://bevyengine.org"
diff --git a/crates/bevy_text/Cargo.toml b/crates/bevy_text/Cargo.toml
index 35eaa696ca541d..578526a1e3a0ee 100644
--- a/crates/bevy_text/Cargo.toml
+++ b/crates/bevy_text/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_text"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides text functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -14,16 +14,16 @@ default_font = []
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
-bevy_math = { path = "../bevy_math", version = "0.11.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
-bevy_render = { path = "../bevy_render", version = "0.11.0" }
-bevy_sprite = { path = "../bevy_sprite", version = "0.11.0" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
-bevy_window = { path = "../bevy_window", version = "0.11.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_render = { path = "../bevy_render", version = "0.12.0-dev" }
+bevy_sprite = { path = "../bevy_sprite", version = "0.12.0-dev" }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_window = { path = "../bevy_window", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 
 # other
 anyhow = "1.0.4"
diff --git a/crates/bevy_time/Cargo.toml b/crates/bevy_time/Cargo.toml
index fe7c0b829e8f27..4eb92f7f2946ab 100644
--- a/crates/bevy_time/Cargo.toml
+++ b/crates/bevy_time/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_time"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides time functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -15,10 +15,10 @@ bevy_ci_testing = ["bevy_app/bevy_ci_testing"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0", features = ["bevy_reflect"] }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev", features = ["bevy_reflect"] }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 
 # other
 crossbeam-channel = "0.5.0"
diff --git a/crates/bevy_transform/Cargo.toml b/crates/bevy_transform/Cargo.toml
index e33ea9dfe1960b..9f250745232c56 100644
--- a/crates/bevy_transform/Cargo.toml
+++ b/crates/bevy_transform/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_transform"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides transform functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,15 +10,15 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0", features = ["bevy_reflect"] }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0" }
-bevy_math = { path = "../bevy_math", version = "0.11.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = ["bevy"] }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev", features = ["bevy_reflect"] }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
 serde = { version = "1", features = ["derive"], optional = true }
 
 [dev-dependencies]
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.12.0-dev" }
 
 [features]
 serialize = ["dep:serde", "bevy_math/serialize"]
diff --git a/crates/bevy_ui/Cargo.toml b/crates/bevy_ui/Cargo.toml
index d4e5de4f5357ed..60e8d74477ac55 100644
--- a/crates/bevy_ui/Cargo.toml
+++ b/crates/bevy_ui/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_ui"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "A custom ECS-driven UI framework built specifically for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,25 +10,25 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_a11y = { path = "../bevy_a11y", version = "0.11.0" }
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0" }
-bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.11.0" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0" }
-bevy_input = { path = "../bevy_input", version = "0.11.0" }
-bevy_log = { path = "../bevy_log", version = "0.11.0" }
-bevy_math = { path = "../bevy_math", version = "0.11.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = [
+bevy_a11y = { path = "../bevy_a11y", version = "0.12.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.12.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.12.0-dev" }
+bevy_input = { path = "../bevy_input", version = "0.12.0-dev" }
+bevy_log = { path = "../bevy_log", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = [
     "bevy",
 ] }
-bevy_render = { path = "../bevy_render", version = "0.11.0" }
-bevy_sprite = { path = "../bevy_sprite", version = "0.11.0" }
-bevy_text = { path = "../bevy_text", version = "0.11.0", optional = true }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0" }
-bevy_window = { path = "../bevy_window", version = "0.11.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_render = { path = "../bevy_render", version = "0.12.0-dev" }
+bevy_sprite = { path = "../bevy_sprite", version = "0.12.0-dev" }
+bevy_text = { path = "../bevy_text", version = "0.12.0-dev", optional = true }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_window = { path = "../bevy_window", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 
 # other
 taffy = { version = "0.3.10" }
diff --git a/crates/bevy_utils/Cargo.toml b/crates/bevy_utils/Cargo.toml
index 30f377f22f778e..ba887e8057220b 100644
--- a/crates/bevy_utils/Cargo.toml
+++ b/crates/bevy_utils/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_utils"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "A collection of utils for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -17,7 +17,7 @@ tracing = { version = "0.1", default-features = false, features = ["std"] }
 instant = { version = "0.1", features = ["wasm-bindgen"] }
 uuid = { version = "1.1", features = ["v4", "serde"] }
 hashbrown = { version = "0.14", features = ["serde"] }
-bevy_utils_proc_macros = {version = "0.11.0", path = "macros"}
+bevy_utils_proc_macros = {version = "0.12.0-dev", path = "macros"}
 petgraph = "0.6"
 thiserror = "1.0"
 
diff --git a/crates/bevy_utils/macros/Cargo.toml b/crates/bevy_utils/macros/Cargo.toml
index 10307bbd656841..6cd46fba5a98a5 100644
--- a/crates/bevy_utils/macros/Cargo.toml
+++ b/crates/bevy_utils/macros/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_utils_proc_macros"
-version = "0.11.0"
+version = "0.12.0-dev"
 description = "Bevy Utils Proc Macros"
 edition = "2021"
 license = "MIT OR Apache-2.0"
diff --git a/crates/bevy_window/Cargo.toml b/crates/bevy_window/Cargo.toml
index 85ce90c849f535..8bffd6a53c8167 100644
--- a/crates/bevy_window/Cargo.toml
+++ b/crates/bevy_window/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_window"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides windowing functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -14,15 +14,15 @@ serialize = ["serde"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
-bevy_math = { path = "../bevy_math", version = "0.11.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0", features = [
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = [
     "glam",
 ] }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 # Used for close_on_esc
-bevy_input = { path = "../bevy_input", version = "0.11.0" }
+bevy_input = { path = "../bevy_input", version = "0.12.0-dev" }
 raw-window-handle = "0.5"
 
 # other
diff --git a/crates/bevy_winit/Cargo.toml b/crates/bevy_winit/Cargo.toml
index ec881e50a16218..fd7d4d3a373c1d 100644
--- a/crates/bevy_winit/Cargo.toml
+++ b/crates/bevy_winit/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_winit"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "A winit window and input backend for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -16,16 +16,16 @@ accesskit_unix = ["accesskit_winit/accesskit_unix", "accesskit_winit/async-io"]
 
 [dependencies]
 # bevy
-bevy_a11y = { path = "../bevy_a11y", version = "0.11.0" }
-bevy_app = { path = "../bevy_app", version = "0.11.0" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0" }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0" }
-bevy_input = { path = "../bevy_input", version = "0.11.0" }
-bevy_math = { path = "../bevy_math", version = "0.11.0" }
-bevy_window = { path = "../bevy_window", version = "0.11.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0" }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0" }
+bevy_a11y = { path = "../bevy_a11y", version = "0.12.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.12.0-dev" }
+bevy_input = { path = "../bevy_input", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_window = { path = "../bevy_window", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.12.0-dev" }
 
 # other
 winit = { version = "0.28", default-features = false }
diff --git a/tools/build-templated-pages/Cargo.toml b/tools/build-templated-pages/Cargo.toml
index f91ce653123dd8..4d7405d510dc9f 100644
--- a/tools/build-templated-pages/Cargo.toml
+++ b/tools/build-templated-pages/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "build-templated-pages"
-version = "0.11.0"
+version = "0.12.0-dev"
 edition = "2021"
 description = "handle templated pages in Bevy repository"
 publish = false

From cd0a642fa19476dd9876aa71198ee28b62e0e3f2 Mon Sep 17 00:00:00 2001
From: Tristan Guichaoua <33934311+tguichaoua@users.noreply.github.com>
Date: Tue, 11 Jul 2023 23:24:43 +0200
Subject: [PATCH 18/30] doc(asset): fix asset trait example (#9105)

# Objective

Fix the example code for the `Asset` trait.

## Solution

Add `TypePath` trait on `CustomAsset`.
Add a static check.
---
 crates/bevy_asset/src/loader.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_asset/src/loader.rs b/crates/bevy_asset/src/loader.rs
index a494fd0a2cc01f..6853ebf228df66 100644
--- a/crates/bevy_asset/src/loader.rs
+++ b/crates/bevy_asset/src/loader.rs
@@ -34,14 +34,16 @@ pub trait AssetLoader: Send + Sync + 'static {
 /// and scripts. In Bevy, an asset is any struct that has an unique type id, as shown below:
 ///
 /// ```rust
-/// use bevy_reflect::TypeUuid;
+/// use bevy_reflect::{TypePath, TypeUuid};
 /// use serde::Deserialize;
 ///
-/// #[derive(Debug, Deserialize, TypeUuid)]
+/// #[derive(Debug, Deserialize, TypeUuid, TypePath)]
 /// #[uuid = "39cadc56-aa9c-4543-8640-a018b74b5052"]
 /// pub struct CustomAsset {
 ///     pub value: i32,
 /// }
+/// # fn is_asset<T: bevy_asset::Asset>() {}
+/// # is_asset::<CustomAsset>();
 /// ```
 ///
 /// See the `assets/custom_asset.rs` example in the repository for more details.

From 30d897a8bf42504f85a24792249e1edb72091d9d Mon Sep 17 00:00:00 2001
From: Tristan Guichaoua <33934311+tguichaoua@users.noreply.github.com>
Date: Fri, 14 Jul 2023 00:23:04 +0200
Subject: [PATCH 19/30] fix `clippy::default_constructed_unit_structs` and
 trybuild errors (#9144)

# Objective

With Rust `1.71.0` ([released a few minutes
ago](https://github.com/rust-lang/rust/releases/tag/1.71.0)), clippy
introduced a new lint
([`default_constructed_unit_structs`](https://rust-lang.github.io/rust-clippy/master/index.html#/default_constructed_unit_structs))
wich prevent calling `default()` on unit structs (e.g.
`PhantomData::default()`).

## Solution

Apply the lint suggestion.

---------

Co-authored-by: Carter Anderson <mcanders1@gmail.com>
---
 crates/bevy_asset/src/assets.rs               |  2 +-
 crates/bevy_asset/src/handle.rs               |  2 +-
 crates/bevy_core/src/lib.rs                   |  6 +--
 crates/bevy_ecs/src/event.rs                  |  5 +--
 crates/bevy_internal/src/default_plugins.rs   | 41 +++++++++----------
 .../tests/reflect_derive/generics.fail.stderr |  2 +-
 crates/bevy_tasks/src/thread_executor.rs      |  2 +-
 7 files changed, 28 insertions(+), 32 deletions(-)

diff --git a/crates/bevy_asset/src/assets.rs b/crates/bevy_asset/src/assets.rs
index b0587e95f32bf4..6669d9bc596329 100644
--- a/crates/bevy_asset/src/assets.rs
+++ b/crates/bevy_asset/src/assets.rs
@@ -559,7 +559,7 @@ mod tests {
         let mut app = App::new();
         app.add_plugins((
             bevy_core::TaskPoolPlugin::default(),
-            bevy_core::TypeRegistrationPlugin::default(),
+            bevy_core::TypeRegistrationPlugin,
             crate::AssetPlugin::default(),
         ));
         app.add_asset::<MyAsset>();
diff --git a/crates/bevy_asset/src/handle.rs b/crates/bevy_asset/src/handle.rs
index 035885862d7220..b8e15c83232c59 100644
--- a/crates/bevy_asset/src/handle.rs
+++ b/crates/bevy_asset/src/handle.rs
@@ -390,7 +390,7 @@ impl HandleUntyped {
         Handle {
             handle_type,
             id: self.id,
-            marker: PhantomData::default(),
+            marker: PhantomData,
         }
     }
 }
diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index a9b10b1e81f2b3..977f01489f2869 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -165,7 +165,7 @@ mod tests {
     #[test]
     fn runs_spawn_local_tasks() {
         let mut app = App::new();
-        app.add_plugins((TaskPoolPlugin::default(), TypeRegistrationPlugin::default()));
+        app.add_plugins((TaskPoolPlugin::default(), TypeRegistrationPlugin));
 
         let (async_tx, async_rx) = crossbeam_channel::unbounded();
         AsyncComputeTaskPool::get()
@@ -200,8 +200,8 @@ mod tests {
         let mut app = App::new();
         app.add_plugins((
             TaskPoolPlugin::default(),
-            TypeRegistrationPlugin::default(),
-            FrameCountPlugin::default(),
+            TypeRegistrationPlugin,
+            FrameCountPlugin,
         ));
         app.update();
 
diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index 9c762edc6bcf66..98f1d9f9b9ca4e 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -1038,10 +1038,7 @@ mod tests {
         events.send_default();
 
         let mut reader = events.get_reader();
-        assert_eq!(
-            get_events(&events, &mut reader),
-            vec![EmptyTestEvent::default()]
-        );
+        assert_eq!(get_events(&events, &mut reader), vec![EmptyTestEvent]);
     }
 
     #[test]
diff --git a/crates/bevy_internal/src/default_plugins.rs b/crates/bevy_internal/src/default_plugins.rs
index 95bee297d81884..fb5e3da69173f1 100644
--- a/crates/bevy_internal/src/default_plugins.rs
+++ b/crates/bevy_internal/src/default_plugins.rs
@@ -43,13 +43,13 @@ impl PluginGroup for DefaultPlugins {
         group = group
             .add(bevy_log::LogPlugin::default())
             .add(bevy_core::TaskPoolPlugin::default())
-            .add(bevy_core::TypeRegistrationPlugin::default())
-            .add(bevy_core::FrameCountPlugin::default())
-            .add(bevy_time::TimePlugin::default())
-            .add(bevy_transform::TransformPlugin::default())
-            .add(bevy_hierarchy::HierarchyPlugin::default())
-            .add(bevy_diagnostic::DiagnosticsPlugin::default())
-            .add(bevy_input::InputPlugin::default())
+            .add(bevy_core::TypeRegistrationPlugin)
+            .add(bevy_core::FrameCountPlugin)
+            .add(bevy_time::TimePlugin)
+            .add(bevy_transform::TransformPlugin)
+            .add(bevy_hierarchy::HierarchyPlugin)
+            .add(bevy_diagnostic::DiagnosticsPlugin)
+            .add(bevy_input::InputPlugin)
             .add(bevy_window::WindowPlugin::default())
             .add(bevy_a11y::AccessibilityPlugin);
 
@@ -60,17 +60,17 @@ impl PluginGroup for DefaultPlugins {
 
         #[cfg(feature = "debug_asset_server")]
         {
-            group = group.add(bevy_asset::debug_asset_server::DebugAssetServerPlugin::default());
+            group = group.add(bevy_asset::debug_asset_server::DebugAssetServerPlugin);
         }
 
         #[cfg(feature = "bevy_scene")]
         {
-            group = group.add(bevy_scene::ScenePlugin::default());
+            group = group.add(bevy_scene::ScenePlugin);
         }
 
         #[cfg(feature = "bevy_winit")]
         {
-            group = group.add(bevy_winit::WinitPlugin::default());
+            group = group.add(bevy_winit::WinitPlugin);
         }
 
         #[cfg(feature = "bevy_render")]
@@ -83,29 +83,28 @@ impl PluginGroup for DefaultPlugins {
 
             #[cfg(all(not(target_arch = "wasm32"), feature = "multi-threaded"))]
             {
-                group = group
-                    .add(bevy_render::pipelined_rendering::PipelinedRenderingPlugin::default());
+                group = group.add(bevy_render::pipelined_rendering::PipelinedRenderingPlugin);
             }
         }
 
         #[cfg(feature = "bevy_core_pipeline")]
         {
-            group = group.add(bevy_core_pipeline::CorePipelinePlugin::default());
+            group = group.add(bevy_core_pipeline::CorePipelinePlugin);
         }
 
         #[cfg(feature = "bevy_sprite")]
         {
-            group = group.add(bevy_sprite::SpritePlugin::default());
+            group = group.add(bevy_sprite::SpritePlugin);
         }
 
         #[cfg(feature = "bevy_text")]
         {
-            group = group.add(bevy_text::TextPlugin::default());
+            group = group.add(bevy_text::TextPlugin);
         }
 
         #[cfg(feature = "bevy_ui")]
         {
-            group = group.add(bevy_ui::UiPlugin::default());
+            group = group.add(bevy_ui::UiPlugin);
         }
 
         #[cfg(feature = "bevy_pbr")]
@@ -127,12 +126,12 @@ impl PluginGroup for DefaultPlugins {
 
         #[cfg(feature = "bevy_gilrs")]
         {
-            group = group.add(bevy_gilrs::GilrsPlugin::default());
+            group = group.add(bevy_gilrs::GilrsPlugin);
         }
 
         #[cfg(feature = "bevy_animation")]
         {
-            group = group.add(bevy_animation::AnimationPlugin::default());
+            group = group.add(bevy_animation::AnimationPlugin);
         }
 
         #[cfg(feature = "bevy_gizmos")]
@@ -165,9 +164,9 @@ impl PluginGroup for MinimalPlugins {
     fn build(self) -> PluginGroupBuilder {
         PluginGroupBuilder::start::<Self>()
             .add(bevy_core::TaskPoolPlugin::default())
-            .add(bevy_core::TypeRegistrationPlugin::default())
-            .add(bevy_core::FrameCountPlugin::default())
-            .add(bevy_time::TimePlugin::default())
+            .add(bevy_core::TypeRegistrationPlugin)
+            .add(bevy_core::FrameCountPlugin)
+            .add(bevy_time::TimePlugin)
             .add(bevy_app::ScheduleRunnerPlugin::default())
     }
 }
diff --git a/crates/bevy_reflect_compile_fail_tests/tests/reflect_derive/generics.fail.stderr b/crates/bevy_reflect_compile_fail_tests/tests/reflect_derive/generics.fail.stderr
index 4e0b99529567db..2c503d8a0188c4 100644
--- a/crates/bevy_reflect_compile_fail_tests/tests/reflect_derive/generics.fail.stderr
+++ b/crates/bevy_reflect_compile_fail_tests/tests/reflect_derive/generics.fail.stderr
@@ -28,5 +28,5 @@ note: required for `Foo<NoReflect>` to implement `Reflect`
 4  | #[reflect(from_reflect = false)]
 5  | struct Foo<T> {
    |        ^^^^^^
-   = note: required for the cast from `Foo<NoReflect>` to the object type `dyn Reflect`
+   = note: required for the cast from `Box<Foo<NoReflect>>` to `Box<(dyn Reflect + 'static)>`
    = note: this error originates in the derive macro `Reflect` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/bevy_tasks/src/thread_executor.rs b/crates/bevy_tasks/src/thread_executor.rs
index 7495fe525e0520..0131de91bec561 100644
--- a/crates/bevy_tasks/src/thread_executor.rs
+++ b/crates/bevy_tasks/src/thread_executor.rs
@@ -78,7 +78,7 @@ impl<'task> ThreadExecutor<'task> {
         if thread::current().id() == self.thread_id {
             return Some(ThreadExecutorTicker {
                 executor: self,
-                _marker: PhantomData::default(),
+                _marker: PhantomData,
             });
         }
         None

From c720e7fb5e87ce881140007c14bc50779ea2898e Mon Sep 17 00:00:00 2001
From: Mike <mike.hsu@gmail.com>
Date: Thu, 13 Jul 2023 16:35:06 -0700
Subject: [PATCH 20/30] delete code deprecated in 0.11 (#9128)

# Objective

- remove code deprecated in 0.11

## Changelog

- remove code that was deprecated
---
 crates/bevy_app/src/app.rs                    | 119 +-----------------
 crates/bevy_ecs/src/query/fetch.rs            |   7 --
 crates/bevy_ecs/src/schedule/config.rs        |  88 -------------
 crates/bevy_ecs/src/schedule/schedule.rs      |   7 --
 crates/bevy_ecs/src/world/mod.rs              |  17 ---
 .../bevy_ecs/src/world/unsafe_world_cell.rs   |   7 --
 6 files changed, 3 insertions(+), 242 deletions(-)

diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs
index a761eb151eb301..9b20116ad59138 100644
--- a/crates/bevy_app/src/app.rs
+++ b/crates/bevy_app/src/app.rs
@@ -1,4 +1,4 @@
-use crate::{First, Main, MainSchedulePlugin, Plugin, Plugins, Startup, StateTransition, Update};
+use crate::{First, Main, MainSchedulePlugin, Plugin, Plugins, StateTransition};
 pub use bevy_derive::AppLabel;
 use bevy_ecs::{
     prelude::*,
@@ -328,7 +328,7 @@ impl App {
 
     /// Adds [`State<S>`] and [`NextState<S>`] resources, [`OnEnter`] and [`OnExit`] schedules
     /// for each state variant (if they don't already exist), an instance of [`apply_state_transition::<S>`] in
-    /// [`StateTransition`] so that transitions happen before [`Update`] and
+    /// [`StateTransition`] so that transitions happen before [`Update`](crate::Update) and
     /// a instance of [`run_enter_schedule::<S>`] in [`StateTransition`] with a
     /// [`run_once`](`run_once_condition`) condition to run the on enter schedule of the
     /// initial state.
@@ -357,30 +357,6 @@ impl App {
         self
     }
 
-    /// Adds a system to the default system set and schedule of the app's [`Schedules`].
-    ///
-    /// Refer to the [system module documentation](bevy_ecs::system) to see how a system
-    /// can be defined.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use bevy_app::prelude::*;
-    /// # use bevy_ecs::prelude::*;
-    /// #
-    /// # fn my_system() {}
-    /// # let mut app = App::new();
-    /// #
-    /// app.add_system(my_system);
-    /// ```
-    #[deprecated(
-        since = "0.11.0",
-        note = "Please use `add_systems` instead. If you didn't change the default base set, you should use `add_systems(Update, your_system).`"
-    )]
-    pub fn add_system<M>(&mut self, system: impl IntoSystemConfigs<M>) -> &mut Self {
-        self.add_systems(Update, system)
-    }
-
     /// Adds a system to the given schedule in this app's [`Schedules`].
     ///
     /// # Examples
@@ -416,59 +392,6 @@ impl App {
         self
     }
 
-    /// Adds a system to [`Startup`].
-    ///
-    /// These systems will run exactly once, at the start of the [`App`]'s lifecycle.
-    /// To add a system that runs every frame, see [`add_system`](Self::add_system).
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use bevy_app::prelude::*;
-    /// # use bevy_ecs::prelude::*;
-    /// #
-    /// fn my_startup_system(_commands: Commands) {
-    ///     println!("My startup system");
-    /// }
-    ///
-    /// App::new()
-    ///     .add_systems(Startup, my_startup_system);
-    /// ```
-    #[deprecated(
-        since = "0.11.0",
-        note = "Please use `add_systems` instead. If you didn't change the default base set, you should use `add_systems(Startup, your_system).`"
-    )]
-    pub fn add_startup_system<M>(&mut self, system: impl IntoSystemConfigs<M>) -> &mut Self {
-        self.add_systems(Startup, system)
-    }
-
-    /// Adds a collection of systems to [`Startup`].
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use bevy_app::prelude::*;
-    /// # use bevy_ecs::prelude::*;
-    /// #
-    /// # let mut app = App::new();
-    /// # fn startup_system_a() {}
-    /// # fn startup_system_b() {}
-    /// # fn startup_system_c() {}
-    /// #
-    /// app.add_systems(Startup, (
-    ///     startup_system_a,
-    ///     startup_system_b,
-    ///     startup_system_c,
-    /// ));
-    /// ```
-    #[deprecated(
-        since = "0.11.0",
-        note = "Please use `add_systems` instead. If you didn't change the default base set, you should use `add_systems(Startup, your_system).`"
-    )]
-    pub fn add_startup_systems<M>(&mut self, systems: impl IntoSystemConfigs<M>) -> &mut Self {
-        self.add_systems(Startup, systems.into_configs())
-    }
-
     /// Configures a system set in the default schedule, adding the set if it does not exist.
     pub fn configure_set(
         &mut self,
@@ -656,43 +579,7 @@ impl App {
         self
     }
 
-    /// Adds a single [`Plugin`].
-    ///
-    /// One of Bevy's core principles is modularity. All Bevy engine features are implemented
-    /// as [`Plugin`]s. This includes internal features like the renderer.
-    ///
-    /// Bevy also provides a few sets of default [`Plugin`]s. See [`add_plugins`](Self::add_plugins).
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use bevy_app::prelude::*;
-    /// #
-    /// # // Dummies created to avoid using `bevy_log`,
-    /// # // which pulls in too many dependencies and breaks rust-analyzer
-    /// # pub mod bevy_log {
-    /// #     use bevy_app::prelude::*;
-    /// #     #[derive(Default)]
-    /// #     pub struct LogPlugin;
-    /// #     impl Plugin for LogPlugin{
-    /// #        fn build(&self, app: &mut App) {}
-    /// #     }
-    /// # }
-    /// App::new().add_plugin(bevy_log::LogPlugin::default());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// Panics if the plugin was already added to the application.
-    #[deprecated(since = "0.11.0", note = "Please use `add_plugins` instead.")]
-    pub fn add_plugin<T>(&mut self, plugin: T) -> &mut Self
-    where
-        T: Plugin,
-    {
-        self.add_plugins(plugin)
-    }
-
-    /// Boxed variant of [`add_plugin`](App::add_plugin) that can be used from a
+    /// Boxed variant of [`add_plugins`](App::add_plugins) that can be used from a
     /// [`PluginGroup`](super::PluginGroup)
     pub(crate) fn add_boxed_plugin(
         &mut self,
diff --git a/crates/bevy_ecs/src/query/fetch.rs b/crates/bevy_ecs/src/query/fetch.rs
index e207c6f9623c5e..0e11d42f6b6b2d 100644
--- a/crates/bevy_ecs/src/query/fetch.rs
+++ b/crates/bevy_ecs/src/query/fetch.rs
@@ -460,13 +460,6 @@ pub type QueryItem<'w, Q> = <Q as WorldQuery>::Item<'w>;
 /// The read-only variant of the item type returned when a [`WorldQuery`] is iterated over immutably
 pub type ROQueryItem<'w, Q> = QueryItem<'w, <Q as WorldQuery>::ReadOnly>;
 
-/// The `Fetch` of a [`WorldQuery`], which is used to store state for each archetype/table.
-#[deprecated = "use <Q as WorldQuery>::Fetch<'w> instead"]
-pub type QueryFetch<'w, Q> = <Q as WorldQuery>::Fetch<'w>;
-/// The read-only `Fetch` of a [`WorldQuery`], which is used to store state for each archetype/table.
-#[deprecated = "use <<Q as WorldQuery>::ReadOnly as WorldQuery>::Fetch<'w> instead"]
-pub type ROQueryFetch<'w, Q> = <<Q as WorldQuery>::ReadOnly as WorldQuery>::Fetch<'w>;
-
 /// SAFETY: no component or archetype access
 unsafe impl WorldQuery for Entity {
     type Fetch<'w> = ();
diff --git a/crates/bevy_ecs/src/schedule/config.rs b/crates/bevy_ecs/src/schedule/config.rs
index bc9a687811cfab..708661035ed55d 100644
--- a/crates/bevy_ecs/src/schedule/config.rs
+++ b/crates/bevy_ecs/src/schedule/config.rs
@@ -5,7 +5,6 @@ use crate::{
         condition::{BoxedCondition, Condition},
         graph_utils::{Ambiguity, Dependency, DependencyKind, GraphInfo},
         set::{BoxedSystemSet, IntoSystemSet, SystemSet},
-        ScheduleLabel,
     },
     system::{BoxedSystem, IntoSystem, System},
 };
@@ -294,35 +293,6 @@ where
     fn chain(self) -> SystemConfigs {
         self.into_configs().chain()
     }
-
-    /// This used to add the system to `CoreSchedule::Startup`.
-    /// This was a shorthand for `self.in_schedule(CoreSchedule::Startup)`.
-    ///
-    /// # Panics
-    ///
-    /// Always panics. Please migrate to the new `App::add_systems` with the `Startup` schedule:
-    /// Ex: `app.add_system(foo.on_startup())` -> `app.add_systems(Startup, foo)`
-    #[deprecated(
-        since = "0.11.0",
-        note = "`app.add_system(foo.on_startup())` has been deprecated in favor of `app.add_systems(Startup, foo)`. Please migrate to that API."
-    )]
-    fn on_startup(self) -> SystemConfigs {
-        panic!("`app.add_system(foo.on_startup())` has been deprecated in favor of `app.add_systems(Startup, foo)`. Please migrate to that API.");
-    }
-
-    /// This used to add the system to the provided `schedule`.
-    ///
-    /// # Panics
-    ///
-    /// Always panics. Please migrate to the new `App::add_systems`:
-    /// Ex: `app.add_system(foo.in_schedule(SomeSchedule))` -> `app.add_systems(SomeSchedule, foo)`
-    #[deprecated(
-        since = "0.11.0",
-        note = "`app.add_system(foo.in_schedule(SomeSchedule))` has been deprecated in favor of `app.add_systems(SomeSchedule, foo)`. Please migrate to that API."
-    )]
-    fn in_schedule(self, _schedule: impl ScheduleLabel) -> SystemConfigs {
-        panic!("`app.add_system(foo.in_schedule(SomeSchedule))` has been deprecated in favor of `app.add_systems(SomeSchedule, foo)`. Please migrate to that API.");
-    }
 }
 
 impl IntoSystemConfigs<()> for SystemConfigs {
@@ -471,35 +441,6 @@ pub trait IntoSystemSetConfig: Sized {
     fn ambiguous_with_all(self) -> SystemSetConfig {
         self.into_config().ambiguous_with_all()
     }
-
-    /// This used to configure the set in the `CoreSchedule::Startup` schedule.
-    /// This was a shorthand for `self.in_schedule(CoreSchedule::Startup)`.
-    ///
-    /// # Panics
-    ///
-    /// Always panics. Please migrate to the new `App::configure_set` with the `Startup` schedule:
-    /// Ex: `app.configure_set(MySet.on_startup())` -> `app.configure_set(Startup, MySet)`
-    #[deprecated(
-        since = "0.11.0",
-        note = "`app.configure_set(MySet.on_startup())` has been deprecated in favor of `app.configure_set(Startup, MySet)`. Please migrate to that API."
-    )]
-    fn on_startup(self) -> SystemSetConfigs {
-        panic!("`app.configure_set(MySet.on_startup())` has been deprecated in favor of `app.configure_set(Startup, MySet)`. Please migrate to that API.");
-    }
-
-    /// This used to configure the set in the provided `schedule`.
-    ///
-    /// # Panics
-    ///
-    /// Always panics. Please migrate to the new `App::configure_set`:
-    /// Ex: `app.configure_set(MySet.in_schedule(SomeSchedule))` -> `app.configure_set(SomeSchedule, MySet)`
-    #[deprecated(
-        since = "0.11.0",
-        note = "`app.configure_set(MySet.in_schedule(SomeSchedule))` has been deprecated in favor of `app.configure_set(SomeSchedule, MySet)`. Please migrate to that API."
-    )]
-    fn in_schedule(self, _schedule: impl ScheduleLabel) -> SystemSetConfigs {
-        panic!("`app.configure_set(MySet.in_schedule(SomeSchedule))` has been deprecated in favor of `app.configure_set(SomeSchedule, MySet)`. Please migrate to that API.");
-    }
 }
 
 impl<S: SystemSet> IntoSystemSetConfig for S {
@@ -611,35 +552,6 @@ where
     fn chain(self) -> SystemSetConfigs {
         self.into_configs().chain()
     }
-
-    /// This used to configure the sets in the `CoreSchedule::Startup` schedule.
-    /// This was a shorthand for `self.in_schedule(CoreSchedule::Startup)`.
-    ///
-    /// # Panics
-    ///
-    /// Always panics. Please migrate to the new `App::configure_sets` with the `Startup` schedule:
-    /// Ex: `app.configure_sets((A, B).on_startup())` -> `app.configure_sets(Startup, (A, B))`
-    #[deprecated(
-        since = "0.11.0",
-        note = "`app.configure_sets((A, B).on_startup())` has been deprecated in favor of `app.configure_sets(Startup, (A, B))`. Please migrate to that API."
-    )]
-    fn on_startup(self) -> SystemSetConfigs {
-        panic!("`app.configure_sets((A, B).on_startup())` has been deprecated in favor of `app.configure_sets(Startup, (A, B))`. Please migrate to that API.");
-    }
-
-    /// This used to configure the sets in the provided `schedule`.
-    ///
-    /// # Panics
-    ///
-    /// Always panics. Please migrate to the new `App::configure_set`:
-    /// Ex: `app.configure_sets((A, B).in_schedule(SomeSchedule))` -> `app.configure_sets(SomeSchedule, (A, B))`
-    #[deprecated(
-        since = "0.11.0",
-        note = "`app.configure_sets((A, B).in_schedule(SomeSchedule))` has been deprecated in favor of `app.configure_sets(SomeSchedule, (A, B))`. Please migrate to that API."
-    )]
-    fn in_schedule(self, _schedule: impl ScheduleLabel) -> SystemSetConfigs {
-        panic!("`app.configure_sets((A, B).in_schedule(SomeSchedule))` has been deprecated in favor of `app.configure_sets(SomeSchedule, (A, B))`. Please migrate to that API.");
-    }
 }
 
 impl IntoSystemSetConfigs for SystemSetConfigs {
diff --git a/crates/bevy_ecs/src/schedule/schedule.rs b/crates/bevy_ecs/src/schedule/schedule.rs
index 4f848a003276cc..701e13ff4578f7 100644
--- a/crates/bevy_ecs/src/schedule/schedule.rs
+++ b/crates/bevy_ecs/src/schedule/schedule.rs
@@ -174,13 +174,6 @@ impl Schedule {
         }
     }
 
-    /// Add a system to the schedule.
-    #[deprecated(since = "0.11.0", note = "please use `add_systems` instead")]
-    pub fn add_system<M>(&mut self, system: impl IntoSystemConfigs<M>) -> &mut Self {
-        self.graph.add_systems_inner(system.into_configs(), false);
-        self
-    }
-
     /// Add a collection of systems to the schedule.
     pub fn add_systems<M>(&mut self, systems: impl IntoSystemConfigs<M>) -> &mut Self {
         self.graph.add_systems_inner(systems.into_configs(), false);
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
index a5d1e5fb14e7bc..fae2931f7f8987 100644
--- a/crates/bevy_ecs/src/world/mod.rs
+++ b/crates/bevy_ecs/src/world/mod.rs
@@ -1864,23 +1864,6 @@ impl World {
     pub fn run_schedule(&mut self, label: impl AsRef<dyn ScheduleLabel>) {
         self.schedule_scope(label, |world, sched| sched.run(world));
     }
-
-    /// Runs the [`Schedule`] associated with the `label` a single time.
-    ///
-    /// Unlike the `run_schedule` method, this method takes the label by reference, which can save a clone.
-    ///
-    /// The [`Schedule`] is fetched from the [`Schedules`] resource of the world by its label,
-    /// and system state is cached.
-    ///
-    /// For simple testing use cases, call [`Schedule::run(&mut world)`](Schedule::run) instead.
-    ///
-    /// # Panics
-    ///
-    /// If the requested schedule does not exist.
-    #[deprecated = "Use `World::run_schedule` instead."]
-    pub fn run_schedule_ref(&mut self, label: &dyn ScheduleLabel) {
-        self.schedule_scope(label, |world, sched| sched.run(world));
-    }
 }
 
 impl fmt::Debug for World {
diff --git a/crates/bevy_ecs/src/world/unsafe_world_cell.rs b/crates/bevy_ecs/src/world/unsafe_world_cell.rs
index 9c3ec47406df2e..db89ef8e41e67b 100644
--- a/crates/bevy_ecs/src/world/unsafe_world_cell.rs
+++ b/crates/bevy_ecs/src/world/unsafe_world_cell.rs
@@ -232,13 +232,6 @@ impl<'w> UnsafeWorldCell<'w> {
         &unsafe { self.world_metadata() }.bundles
     }
 
-    /// Reads the current change tick of this world.
-    #[inline]
-    #[deprecated = "this method has been renamed to `UnsafeWorldCell::change_tick`"]
-    pub fn read_change_tick(self) -> Tick {
-        self.change_tick()
-    }
-
     /// Gets the current change tick of this world.
     #[inline]
     pub fn change_tick(self) -> Tick {

From 0df3d7f586fac3ef7b6a8fac4eb56396800d2717 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 14 Jul 2023 00:35:22 +0100
Subject: [PATCH 21/30] Drain `ExtractedUiNodes` in `prepare_uinodes` (#9142)

# Objective

`ExtractedUiNodes` is cleared by the `extract_uinodes` function during
the extraction schedule. Because the Bevy UI renderer uses a painters
algorithm, this makes it impossible for users to create a custom
extraction function that adds items for a node to be drawn behind the
rectangle added by `extract_uniodes`.

## Solution

Drain `ExtractedUiNodes` in `prepare_ui_nodes` instead, after the
extraction schedule has finished.
---
 crates/bevy_ui/src/render/mod.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 098f219f3a5762..743611f97f920a 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -391,8 +391,6 @@ pub fn extract_uinodes(
         >,
     >,
 ) {
-    extracted_uinodes.uinodes.clear();
-
     for (stack_index, entity) in ui_stack.uinodes.iter().enumerate() {
         if let Ok((uinode, transform, color, maybe_image, visibility, clip)) =
             uinode_query.get(*entity)
@@ -636,7 +634,7 @@ pub fn prepare_uinodes(
         image.id() != DEFAULT_IMAGE_HANDLE.id()
     }
 
-    for extracted_uinode in &extracted_uinodes.uinodes {
+    for extracted_uinode in extracted_uinodes.uinodes.drain(..) {
         let mode = if is_textured(&extracted_uinode.image) {
             if current_batch_image.id() != extracted_uinode.image.id() {
                 if is_textured(&current_batch_image) && start != end {

From c7ca7dd22583ae750932460a3e76ec1292c34ade Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 14 Jul 2023 00:35:32 +0100
Subject: [PATCH 22/30] Fix for vertical text bounds and alignment (#9133)

# Objective

In both Text2d and Bevy UI text because of incorrect text size and
alignment calculations if a block of text has empty leading lines then
those lines are ignored. Also, depending on the font size when leading
empty lines are ignored the same number of lines of text can go missing
from the bottom of the text block.

## Example (from murtaugh on discord)

```rust
use bevy::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_systems(Startup, setup)
        .run();
}

fn setup(mut commands: Commands) {
    commands.spawn(Camera2dBundle::default());

    let text = "\nfirst line\nsecond line\nthird line\n";

    commands.spawn(TextBundle {
        text: Text::from_section(
            text.to_string(),
            TextStyle {
                font_size: 60.0,
                color: Color::YELLOW,
                ..Default::default()
            },
        ),
        style: Style {
            position_type: PositionType::Absolute,
            ..Default::default()
        },
        background_color: BackgroundColor(Color::RED),
        ..Default::default()
    });
}

```


![](https://cdn.discordapp.com/attachments/1128294384954257499/1128295142072254525/image.png)

## Solution

`TextPipeline::queue_text`,
`TextMeasureInfo::compute_size_from_section_texts` and
`GlyphBrush::process_glyphs` each have a nearly duplicate section of
code that calculates the minimum bounds around a list of text sections.

The first two functions don't apply any rounding, but `process_glyphs`
also floors all the values. It seems like this difference can cause
conflicts where the text gets incorrectly shaped.

Also when Bevy computes the text bounds it chooses the smallest possible
rect that fits all the glyphs, ignoring white space. The glyphs are then
realigned vertically so the first glyph is on the top line. Any empty
leading lines are missed.

This PR adds a function `compute_text_bounds` that replaces the
duplicate code, so the text bounds are rounded the same way by each
function. Also, since Bevy doesn't use `ab_glyph` to control vertical
alignment, the minimum y bound is just always set to 0 which ensures no
leading empty lines will be missed.

There is another problem in that trailing empty lines are also ignored,
but that's more difficult to deal with and much less important than the
other issues, so I'll leave it for another PR.

<img width="462" alt="fixed_text_align_bounds"
src="https://github.com/bevyengine/bevy/assets/27962798/85e32e2c-d68f-4677-8e87-38e27ade4487">


---

## Changelog

Added a new function `compute_text_bounds` to the `glyph_brush` module
that replaces the text size and bounds calculations in
`TextPipeline::queue_text`,
`TextMeasureInfo::compute_size_from_section_texts` and
`GlyphBrush::process_glyphs`. The text bounds are calculated identically
in each function and the minimum y bound is not derived from the glyphs
but is always set to 0.
---
 crates/bevy_text/src/glyph_brush.rs | 58 +++++++++++++++++++----------
 crates/bevy_text/src/pipeline.rs    | 45 +++-------------------
 2 files changed, 45 insertions(+), 58 deletions(-)

diff --git a/crates/bevy_text/src/glyph_brush.rs b/crates/bevy_text/src/glyph_brush.rs
index 9b17f09a7b9103..70fea30322e180 100644
--- a/crates/bevy_text/src/glyph_brush.rs
+++ b/crates/bevy_text/src/glyph_brush.rs
@@ -1,6 +1,6 @@
-use ab_glyph::{Font as _, FontArc, Glyph, ScaleFont as _};
+use ab_glyph::{Font as _, FontArc, Glyph, PxScaleFont, ScaleFont as _};
 use bevy_asset::{Assets, Handle};
-use bevy_math::Vec2;
+use bevy_math::{Rect, Vec2};
 use bevy_render::texture::Image;
 use bevy_sprite::TextureAtlas;
 use bevy_utils::tracing::warn;
@@ -84,20 +84,7 @@ impl GlyphBrush {
             })
             .collect::<Result<Vec<_>, _>>()?;
 
-        let mut min_x = std::f32::MAX;
-        let mut min_y = std::f32::MAX;
-        let mut max_y = std::f32::MIN;
-        for sg in &glyphs {
-            let glyph = &sg.glyph;
-
-            let scaled_font = sections_data[sg.section_index].3;
-            min_x = min_x.min(glyph.position.x);
-            min_y = min_y.min(glyph.position.y - scaled_font.ascent());
-            max_y = max_y.max(glyph.position.y - scaled_font.descent());
-        }
-        min_x = min_x.floor();
-        min_y = min_y.floor();
-        max_y = max_y.floor();
+        let text_bounds = compute_text_bounds(&glyphs, |index| &sections_data[index].3);
 
         let mut positioned_glyphs = Vec::new();
         for sg in glyphs {
@@ -136,11 +123,15 @@ impl GlyphBrush {
                 let glyph_rect = texture_atlas.textures[atlas_info.glyph_index];
                 let size = Vec2::new(glyph_rect.width(), glyph_rect.height());
 
-                let x = bounds.min.x + size.x / 2.0 - min_x;
+                let x = bounds.min.x + size.x / 2.0 - text_bounds.min.x;
 
                 let y = match y_axis_orientation {
-                    YAxisOrientation::BottomToTop => max_y - bounds.max.y + size.y / 2.0,
-                    YAxisOrientation::TopToBottom => bounds.min.y + size.y / 2.0 - min_y,
+                    YAxisOrientation::BottomToTop => {
+                        text_bounds.max.y - bounds.max.y + size.y / 2.0
+                    }
+                    YAxisOrientation::TopToBottom => {
+                        bounds.min.y + size.y / 2.0 - text_bounds.min.y
+                    }
                 };
 
                 let position = adjust.position(Vec2::new(x, y));
@@ -209,3 +200,32 @@ impl GlyphPlacementAdjuster {
         Vec2::new(self.0, 0.) + v
     }
 }
+
+/// Computes the minimal bounding rectangle for a block of text.
+/// Ignores empty trailing lines.
+pub(crate) fn compute_text_bounds<'a, T>(
+    section_glyphs: &[SectionGlyph],
+    get_scaled_font: impl Fn(usize) -> &'a PxScaleFont<T>,
+) -> bevy_math::Rect
+where
+    T: ab_glyph::Font + 'a,
+{
+    let mut text_bounds = Rect {
+        min: Vec2::splat(std::f32::MAX),
+        max: Vec2::splat(std::f32::MIN),
+    };
+
+    for sg in section_glyphs {
+        let scaled_font = get_scaled_font(sg.section_index);
+        let glyph = &sg.glyph;
+        text_bounds = text_bounds.union(Rect {
+            min: Vec2::new(glyph.position.x, 0.),
+            max: Vec2::new(
+                glyph.position.x + scaled_font.h_advance(glyph.id),
+                glyph.position.y - scaled_font.descent(),
+            ),
+        });
+    }
+
+    text_bounds
+}
diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index e71e49c030e674..2d16ce03c33565 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -1,4 +1,4 @@
-use ab_glyph::{PxScale, ScaleFont};
+use ab_glyph::PxScale;
 use bevy_asset::{Assets, Handle, HandleId};
 use bevy_ecs::component::Component;
 use bevy_ecs::system::Resource;
@@ -10,8 +10,9 @@ use bevy_utils::HashMap;
 use glyph_brush_layout::{FontId, GlyphPositioner, SectionGeometry, SectionText};
 
 use crate::{
-    error::TextError, glyph_brush::GlyphBrush, scale_value, BreakLineOn, Font, FontAtlasSet,
-    FontAtlasWarning, PositionedGlyph, TextAlignment, TextSection, TextSettings, YAxisOrientation,
+    compute_text_bounds, error::TextError, glyph_brush::GlyphBrush, scale_value, BreakLineOn, Font,
+    FontAtlasSet, FontAtlasWarning, PositionedGlyph, TextAlignment, TextSection, TextSettings,
+    YAxisOrientation,
 };
 
 #[derive(Default, Resource)]
@@ -84,24 +85,7 @@ impl TextPipeline {
             return Ok(TextLayoutInfo::default());
         }
 
-        let mut min_x: f32 = std::f32::MAX;
-        let mut min_y: f32 = std::f32::MAX;
-        let mut max_x: f32 = std::f32::MIN;
-        let mut max_y: f32 = std::f32::MIN;
-
-        for sg in &section_glyphs {
-            let scaled_font = scaled_fonts[sg.section_index];
-            let glyph = &sg.glyph;
-            // The fonts use a coordinate system increasing upwards so ascent is a positive value
-            // and descent is negative, but Bevy UI uses a downwards increasing coordinate system,
-            // so we have to subtract from the baseline position to get the minimum and maximum values.
-            min_x = min_x.min(glyph.position.x);
-            min_y = min_y.min(glyph.position.y - scaled_font.ascent());
-            max_x = max_x.max(glyph.position.x + scaled_font.h_advance(glyph.id));
-            max_y = max_y.max(glyph.position.y - scaled_font.descent());
-        }
-
-        let size = Vec2::new(max_x - min_x, max_y - min_y);
+        let size = compute_text_bounds(&section_glyphs, |index| &scaled_fonts[index]).size();
 
         let glyphs = self.brush.process_glyphs(
             section_glyphs,
@@ -229,24 +213,7 @@ impl TextMeasureInfo {
             .line_breaker(self.linebreak_behaviour)
             .calculate_glyphs(&self.fonts, &geom, sections);
 
-        let mut min_x: f32 = std::f32::MAX;
-        let mut min_y: f32 = std::f32::MAX;
-        let mut max_x: f32 = std::f32::MIN;
-        let mut max_y: f32 = std::f32::MIN;
-
-        for sg in section_glyphs {
-            let scaled_font = &self.scaled_fonts[sg.section_index];
-            let glyph = &sg.glyph;
-            // The fonts use a coordinate system increasing upwards so ascent is a positive value
-            // and descent is negative, but Bevy UI uses a downwards increasing coordinate system,
-            // so we have to subtract from the baseline position to get the minimum and maximum values.
-            min_x = min_x.min(glyph.position.x);
-            min_y = min_y.min(glyph.position.y - scaled_font.ascent());
-            max_x = max_x.max(glyph.position.x + scaled_font.h_advance(glyph.id));
-            max_y = max_y.max(glyph.position.y - scaled_font.descent());
-        }
-
-        Vec2::new(max_x - min_x, max_y - min_y)
+        compute_text_bounds(&section_glyphs, |index| &self.scaled_fonts[index]).size()
     }
 
     pub fn compute_size(&self, bounds: Vec2) -> Vec2 {

From 05a35f6f484862fabd8225fcce2157d7e31c796c Mon Sep 17 00:00:00 2001
From: Patrick Walton <pcwalton@mimiga.net>
Date: Thu, 13 Jul 2023 16:54:59 -0700
Subject: [PATCH 23/30] Add `GltfLoader::new`. (#9120)

# Objective

In my application, I'm manually wrapping the built-in Bevy loaders with
a wrapper loader that stores some metadata before calling into the inner
Bevy loader. This worked for the glTF loader in Bevy 0.10, but in Bevy
0.11 it became impossible to do this because the glTF loader became
unconstructible outside Bevy due to the new private fields within it.
It's now in fact impossible to get a reference to a GltfLoader at all
from outside Bevy, because the only way to construct a GltfLoader is to
add the GltfPlugin to an App, and the GltfPlugin only hands out
references to its GltfLoader to the asset server, which provides no
public access to the loaders it manages.

## Solution

This commit fixes the problem by adding a public `new` method to allow
manual construction of a glTF loader.

---------

Co-authored-by: Carter Anderson <mcanders1@gmail.com>
---
 crates/bevy_gltf/src/loader.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index ff6f96bd21b563..8861bd7e6726f8 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -70,8 +70,8 @@ pub enum GltfError {
 
 /// Loads glTF files with all of their data as their corresponding bevy representations.
 pub struct GltfLoader {
-    pub(crate) supported_compressed_formats: CompressedImageFormats,
-    pub(crate) custom_vertex_attributes: HashMap<String, MeshVertexAttribute>,
+    pub supported_compressed_formats: CompressedImageFormats,
+    pub custom_vertex_attributes: HashMap<String, MeshVertexAttribute>,
 }
 
 impl AssetLoader for GltfLoader {

From ea41a43fae115dcc5615822c01626f792479944d Mon Sep 17 00:00:00 2001
From: Ame <104745335+ameknite@users.noreply.github.com>
Date: Fri, 14 Jul 2023 12:54:44 -0600
Subject: [PATCH 24/30] Clarify that wgpu is based on the webGPU API (#9093)

# Objective

wgpu is not only inspired by Vulkan, so I think it's better to just
mention that it's based on WebGPU

## Solution

- Change the description
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 6a95c928449a9b..de605e96c52ecc 100644
--- a/README.md
+++ b/README.md
@@ -87,7 +87,7 @@ Bevy can be built just fine using default configuration on stable Rust. However
 
 Bevy is only possible because of the hard work put into these foundational technologies:
 
-* [wgpu](https://wgpu.rs/): modern / low-level / cross-platform graphics library inspired by Vulkan
+* [wgpu](https://wgpu.rs/): modern / low-level / cross-platform graphics library based on the [WebGPU](https://gpuweb.github.io/gpuweb/) API.
 * [glam-rs](https://github.com/bitshifter/glam-rs): a simple and fast 3D math library for games and graphics
 * [winit](https://github.com/rust-windowing/winit): cross-platform window creation and management in Rust
 

From ede5848bf442ef7b9534ced03c89b83ad97e6a4d Mon Sep 17 00:00:00 2001
From: fgrust <freezy.gem0918@outlook.com>
Date: Fri, 14 Jul 2023 14:55:15 -0400
Subject: [PATCH 25/30] Put `#[repr(transparent)]` attr to bevy_ptr types
 (#9068)

# Objective

Fix #9064

## Solution

---

## Changelog

Enhanced: bevy_ptr types would be FFI-sefe
---
 crates/bevy_ptr/src/lib.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ptr/src/lib.rs b/crates/bevy_ptr/src/lib.rs
index 6a1ad7747af499..f6212c505ba70d 100644
--- a/crates/bevy_ptr/src/lib.rs
+++ b/crates/bevy_ptr/src/lib.rs
@@ -8,11 +8,12 @@ use core::{
     cell::UnsafeCell, marker::PhantomData, mem::ManuallyDrop, num::NonZeroUsize, ptr::NonNull,
 };
 
-#[derive(Copy, Clone)]
 /// Used as a type argument to [`Ptr`], [`PtrMut`] and [`OwningPtr`] to specify that the pointer is aligned.
-pub struct Aligned;
 #[derive(Copy, Clone)]
+pub struct Aligned;
+
 /// Used as a type argument to [`Ptr`], [`PtrMut`] and [`OwningPtr`] to specify that the pointer is not aligned.
+#[derive(Copy, Clone)]
 pub struct Unaligned;
 
 /// Trait that is only implemented for [`Aligned`] and [`Unaligned`] to work around the lack of ability
@@ -38,6 +39,7 @@ mod sealed {
 /// It may be helpful to think of this type as similar to `&'a dyn Any` but without
 /// the metadata and able to point to data that does not correspond to a Rust type.
 #[derive(Copy, Clone)]
+#[repr(transparent)]
 pub struct Ptr<'a, A: IsAligned = Aligned>(NonNull<u8>, PhantomData<(&'a u8, A)>);
 
 /// Type-erased mutable borrow of some unknown type chosen when constructing this type.
@@ -51,6 +53,7 @@ pub struct Ptr<'a, A: IsAligned = Aligned>(NonNull<u8>, PhantomData<(&'a u8, A)>
 ///
 /// It may be helpful to think of this type as similar to `&'a mut dyn Any` but without
 /// the metadata and able to point to data that does not correspond to a Rust type.
+#[repr(transparent)]
 pub struct PtrMut<'a, A: IsAligned = Aligned>(NonNull<u8>, PhantomData<(&'a mut u8, A)>);
 
 /// Type-erased Box-like pointer to some unknown type chosen when constructing this type.
@@ -68,6 +71,7 @@ pub struct PtrMut<'a, A: IsAligned = Aligned>(NonNull<u8>, PhantomData<(&'a mut
 ///
 /// It may be helpful to think of this type as similar to `&'a mut ManuallyDrop<dyn Any>` but
 /// without the metadata and able to point to data that does not correspond to a Rust type.
+#[repr(transparent)]
 pub struct OwningPtr<'a, A: IsAligned = Aligned>(NonNull<u8>, PhantomData<(&'a mut u8, A)>);
 
 macro_rules! impl_ptr {

From 94b574ad16850af1118ecffe8e9b03b04e7db6ff Mon Sep 17 00:00:00 2001
From: Arnav Mummineni <45217840+RCoder01@users.noreply.github.com>
Date: Sat, 15 Jul 2023 17:10:39 -0400
Subject: [PATCH 26/30] Rename bevy_math::rects conversion methods (#9159)

# Objective

Some of the conversion methods on the new rect types introduced in #7984
have misleading names.

## Solution

Rename all methods returning an `IRect` to `as_irect` and all methods
returning a `URect` to `as_urect`.

## Migration Guide

Replace uses of the old method names with the new method names.
---
 crates/bevy_math/src/rects/rect.rs  | 4 ++--
 crates/bevy_math/src/rects/urect.rs | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_math/src/rects/rect.rs b/crates/bevy_math/src/rects/rect.rs
index e06440f08cf499..a5c456f4621212 100644
--- a/crates/bevy_math/src/rects/rect.rs
+++ b/crates/bevy_math/src/rects/rect.rs
@@ -311,13 +311,13 @@ impl Rect {
 
     /// Returns self as [`IRect`] (i32)
     #[inline]
-    pub fn as_urect(&self) -> IRect {
+    pub fn as_irect(&self) -> IRect {
         IRect::from_corners(self.min.as_ivec2(), self.max.as_ivec2())
     }
 
     /// Returns self as [`URect`] (u32)
     #[inline]
-    pub fn as_rect(&self) -> URect {
+    pub fn as_urect(&self) -> URect {
         URect::from_corners(self.min.as_uvec2(), self.max.as_uvec2())
     }
 }
diff --git a/crates/bevy_math/src/rects/urect.rs b/crates/bevy_math/src/rects/urect.rs
index e68b5f161502f6..1f04882d16c350 100644
--- a/crates/bevy_math/src/rects/urect.rs
+++ b/crates/bevy_math/src/rects/urect.rs
@@ -332,7 +332,7 @@ impl URect {
 
     /// Returns self as [`IRect`] (i32)
     #[inline]
-    pub fn as_urect(&self) -> IRect {
+    pub fn as_irect(&self) -> IRect {
         IRect::from_corners(self.min.as_ivec2(), self.max.as_ivec2())
     }
 }

From 701767a6175c1ebf929a6c030e74b03f5b24efac Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Sch=C3=A4fer?= <j.wielicki@sotecware.net>
Date: Sat, 15 Jul 2023 23:11:07 +0200
Subject: [PATCH 27/30] Fix doc typo (#9162)

# Objective

- Fix a minor doc typo

## Solution

- Fix the typo!
---
 crates/bevy_render/src/mesh/morph.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_render/src/mesh/morph.rs b/crates/bevy_render/src/mesh/morph.rs
index c6eba94b477e11..be52d1f59b495c 100644
--- a/crates/bevy_render/src/mesh/morph.rs
+++ b/crates/bevy_render/src/mesh/morph.rs
@@ -104,7 +104,7 @@ impl MorphTargetImage {
 }
 
 /// Controls the [morph targets] for all child [`Handle<Mesh>`] entities. In most cases, [`MorphWeights`] should be considered
-/// the "source o[f truth" when writing morph targets for meshes. However you can choose to write child [`MeshMorphWeights`]
+/// the "source of truth" when writing morph targets for meshes. However you can choose to write child [`MeshMorphWeights`]
 /// if your situation requires more granularity. Just note that if you set [`MorphWeights`], it will overwrite child
 /// [`MeshMorphWeights`] values.
 ///

From 73457665badc6d197a5e101b2607d7e0d4584343 Mon Sep 17 00:00:00 2001
From: ira <JustTheCoolDude@gmail.com>
Date: Sat, 15 Jul 2023 23:18:13 +0200
Subject: [PATCH 28/30] Fix gizmo draw order in 2D (#9129)

# Objective

Gizmos are intended to draw over everything but for some reason I set
the sort key to `0` during #8427 :v

I didn't catch this mistake because it still draws over sprites with a Z
translation of `0`.

## Solution

Set the sort key to `f32::INFINITY`.
---
 crates/bevy_gizmos/src/pipeline_2d.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_gizmos/src/pipeline_2d.rs b/crates/bevy_gizmos/src/pipeline_2d.rs
index be983becec9f6c..06f21138d8a551 100644
--- a/crates/bevy_gizmos/src/pipeline_2d.rs
+++ b/crates/bevy_gizmos/src/pipeline_2d.rs
@@ -166,7 +166,7 @@ fn queue_line_gizmos_2d(
                 entity,
                 draw_function,
                 pipeline,
-                sort_key: FloatOrd(0.),
+                sort_key: FloatOrd(f32::INFINITY),
                 batch_range: None,
             });
         }

From 7154b59438459b6a5c48119a0e43c4679502cd8f Mon Sep 17 00:00:00 2001
From: Ame <104745335+ameknite@users.noreply.github.com>
Date: Sat, 15 Jul 2023 15:25:22 -0600
Subject: [PATCH 29/30] Return URect instead of (UVec2, UVec2) in
 Camera::physical_viewport_rect (#9085)

# Objective

Continue #7867 now that we have URect #7984
- Return `URect` instead of `(UVec2, UVec2)` in
`Camera::physical_viewport_rect`
 - Add `URect` and `IRect` to prelude

## Changelog

- Changed `Camera::physical_viewport_rect` return type from `(UVec2,
UVec2)` to `URect`
- `URect` and `IRect` were added to prelude

## Migration Guide

Before:

```rust
fn view_physical_camera_rect(camera_query: Query<&Camera>) {
    let camera = camera_query.single();
    let Some((min, max)) = camera.physical_viewport_rect() else { return };
    dbg!(min, max);
}
```

After:

```rust
fn view_physical_camera_rect(camera_query: Query<&Camera>) {
    let camera = camera_query.single();
    let Some(URect { min, max }) = camera.physical_viewport_rect() else { return };
    dbg!(min, max);
}
```
---
 .../bevy_core_pipeline/src/bloom/settings.rs  |  4 ++--
 crates/bevy_math/src/lib.rs                   |  4 ++--
 crates/bevy_render/src/camera/camera.rs       | 19 +++++++++++++------
 crates/bevy_ui/src/render/mod.rs              | 11 +++++++++--
 4 files changed, 26 insertions(+), 12 deletions(-)

diff --git a/crates/bevy_core_pipeline/src/bloom/settings.rs b/crates/bevy_core_pipeline/src/bloom/settings.rs
index 6d5cc2fe035020..61468d9f413b3d 100644
--- a/crates/bevy_core_pipeline/src/bloom/settings.rs
+++ b/crates/bevy_core_pipeline/src/bloom/settings.rs
@@ -1,6 +1,6 @@
 use super::downsampling_pipeline::BloomUniforms;
 use bevy_ecs::{prelude::Component, query::QueryItem, reflect::ReflectComponent};
-use bevy_math::{UVec4, Vec4};
+use bevy_math::{URect, UVec4, Vec4};
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_render::{extract_component::ExtractComponent, prelude::Camera};
 
@@ -196,7 +196,7 @@ impl ExtractComponent for BloomSettings {
             camera.is_active,
             camera.hdr,
         ) {
-            (Some((origin, _)), Some(size), Some(target_size), true, true) => {
+            (Some(URect { min: origin, .. }), Some(size), Some(target_size), true, true) => {
                 let threshold = settings.prefilter_settings.threshold;
                 let threshold_softness = settings.prefilter_settings.threshold_softness;
                 let knee = threshold * threshold_softness.clamp(0.0, 1.0);
diff --git a/crates/bevy_math/src/lib.rs b/crates/bevy_math/src/lib.rs
index f42a0b946d2358..b1b6144dbb2e7b 100644
--- a/crates/bevy_math/src/lib.rs
+++ b/crates/bevy_math/src/lib.rs
@@ -19,8 +19,8 @@ pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
         cubic_splines::{BSpline, Bezier, CardinalSpline, CubicGenerator, CubicSegment, Hermite},
-        BVec2, BVec3, BVec4, EulerRot, IVec2, IVec3, IVec4, Mat2, Mat3, Mat4, Quat, Ray, Rect,
-        UVec2, UVec3, UVec4, Vec2, Vec3, Vec4,
+        BVec2, BVec3, BVec4, EulerRot, IRect, IVec2, IVec3, IVec4, Mat2, Mat3, Mat4, Quat, Ray,
+        Rect, URect, UVec2, UVec3, UVec4, Vec2, Vec3, Vec4,
     };
 }
 
diff --git a/crates/bevy_render/src/camera/camera.rs b/crates/bevy_render/src/camera/camera.rs
index 9c174169605dec..76514019702348 100644
--- a/crates/bevy_render/src/camera/camera.rs
+++ b/crates/bevy_render/src/camera/camera.rs
@@ -19,7 +19,7 @@ use bevy_ecs::{
     system::{Commands, Query, Res, ResMut, Resource},
 };
 use bevy_log::warn;
-use bevy_math::{Mat4, Ray, Rect, UVec2, UVec4, Vec2, Vec3};
+use bevy_math::{Mat4, Ray, Rect, URect, UVec2, UVec4, Vec2, Vec3};
 use bevy_reflect::prelude::*;
 use bevy_transform::components::GlobalTransform;
 use bevy_utils::{HashMap, HashSet};
@@ -138,18 +138,18 @@ impl Camera {
         Some((physical_size.as_dvec2() / scale).as_vec2())
     }
 
-    /// The rendered physical bounds (minimum, maximum) of the camera. If the `viewport` field is
+    /// The rendered physical bounds [`URect`] of the camera. If the `viewport` field is
     /// set to [`Some`], this will be the rect of that custom viewport. Otherwise it will default to
     /// the full physical rect of the current [`RenderTarget`].
     #[inline]
-    pub fn physical_viewport_rect(&self) -> Option<(UVec2, UVec2)> {
+    pub fn physical_viewport_rect(&self) -> Option<URect> {
         let min = self
             .viewport
             .as_ref()
             .map(|v| v.physical_position)
             .unwrap_or(UVec2::ZERO);
         let max = min + self.physical_viewport_size()?;
-        Some((min, max))
+        Some(URect { min, max })
     }
 
     /// The rendered logical bounds [`Rect`] of the camera. If the `viewport` field is set to
@@ -157,7 +157,7 @@ impl Camera {
     /// full logical rect of the current [`RenderTarget`].
     #[inline]
     pub fn logical_viewport_rect(&self) -> Option<Rect> {
-        let (min, max) = self.physical_viewport_rect()?;
+        let URect { min, max } = self.physical_viewport_rect()?;
         Some(Rect {
             min: self.to_logical(min)?,
             max: self.to_logical(max)?,
@@ -636,7 +636,14 @@ pub fn extract_cameras(
             continue;
         }
 
-        if let (Some((viewport_origin, _)), Some(viewport_size), Some(target_size)) = (
+        if let (
+            Some(URect {
+                min: viewport_origin,
+                ..
+            }),
+            Some(viewport_size),
+            Some(target_size),
+        ) = (
             camera.physical_viewport_rect(),
             camera.physical_viewport_size(),
             camera.physical_target_size(),
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 743611f97f920a..fba6ba1af15334 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -16,7 +16,7 @@ use crate::{
 use bevy_app::prelude::*;
 use bevy_asset::{load_internal_asset, AssetEvent, Assets, Handle, HandleUntyped};
 use bevy_ecs::prelude::*;
-use bevy_math::{Mat4, Rect, UVec4, Vec2, Vec3, Vec4Swizzles};
+use bevy_math::{Mat4, Rect, URect, UVec4, Vec2, Vec3, Vec4Swizzles};
 use bevy_reflect::TypeUuid;
 use bevy_render::texture::DEFAULT_IMAGE_HANDLE;
 use bevy_render::{
@@ -453,7 +453,14 @@ pub fn extract_default_ui_camera_view<T: Component>(
         if matches!(camera_ui, Some(&UiCameraConfig { show_ui: false, .. })) {
             continue;
         }
-        if let (Some(logical_size), Some((physical_origin, _)), Some(physical_size)) = (
+        if let (
+            Some(logical_size),
+            Some(URect {
+                min: physical_origin,
+                ..
+            }),
+            Some(physical_size),
+        ) = (
             camera.logical_viewport_size(),
             camera.physical_viewport_rect(),
             camera.physical_viewport_size(),

From a30da0001ea3479fda32ac286e1a6647c791e5c1 Mon Sep 17 00:00:00 2001
From: Tristan Guichaoua <33934311+tguichaoua@users.noreply.github.com>
Date: Sat, 15 Jul 2023 23:32:17 +0200
Subject: [PATCH 30/30] impl `From<&AssetPath>` for `HandleId` (#9132)

# Objective

In
[`AssetLoader::load()`](https://docs.rs/bevy/0.11.0/bevy/asset/trait.AssetLoader.html#tymethod.load),
I have an
[`AssetPath`](https://docs.rs/bevy/0.11.0/bevy/asset/struct.AssetPath.html)
to a dependency asset.
I get a handle to this dependency asset using
[`LoadContext::get_handle()`](https://docs.rs/bevy/0.11.0/bevy/asset/struct.LoadContext.html#method.get_handle)
passing the `AssetPath`. But I also need to pass this `AssetPath` to
[`LoadedAsset::with_dependency()`](https://docs.rs/bevy/0.11.0/bevy/asset/struct.LoadedAsset.html#method.with_dependency)
later.


The current solution for this problem is either use `clone()`, but
`AssetPath` may contains owned data.
```rust
let dependency_path: AssetPath = _;
let dependency = load_context.get_handle(dependency_path.clone());
// ...
load_context.set_default_asset(LoadedAsset::new(my_asset).with_dependency(dependency_path));
```

Or to use `AssetPathId::from(&path)` which is a bit verbose.
```rust
let dependency_path: AssetPath = _;
let dependency = load_context.get_handle(AssetPathId::from(&dependency_path));
// ...
load_context.set_default_asset(LoadedAsset::new(my_asset).with_dependency(dependency_path));
```

Ideal solution (introduced by this PR) is to pass a reference to
`get_handle()`.
```rust
let dependency_path: AssetPath = _;
let dependency = load_context.get_handle(&dependency_path);
// ...
load_context.set_default_asset(LoadedAsset::new(my_asset).with_dependency(dependency_path));
```

## Solution

Implement `From<&AssetPath>` for `HandleId`

---

## Changelog

- Added: `HandleId` can be build from a reference to `AssetPath`.
---
 crates/bevy_asset/src/handle.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/crates/bevy_asset/src/handle.rs b/crates/bevy_asset/src/handle.rs
index b8e15c83232c59..b0da1df00d45ca 100644
--- a/crates/bevy_asset/src/handle.rs
+++ b/crates/bevy_asset/src/handle.rs
@@ -40,6 +40,12 @@ impl<'a> From<AssetPath<'a>> for HandleId {
     }
 }
 
+impl<'a, 'b> From<&'a AssetPath<'b>> for HandleId {
+    fn from(value: &'a AssetPath<'b>) -> Self {
+        HandleId::AssetPathId(AssetPathId::from(value))
+    }
+}
+
 impl HandleId {
     /// Creates a random id for an asset of type `T`.
     #[inline]