diff --git a/.cargo/config_fast_builds.toml b/.cargo/config_fast_builds.toml
index 4ee56c480c157..2d82ca39a89c0 100644
--- a/.cargo/config_fast_builds.toml
+++ b/.cargo/config_fast_builds.toml
@@ -30,7 +30,7 @@ rustflags = [
 [target.x86_64-pc-windows-msvc]
 linker = "rust-lld.exe" # Use LLD Linker
 rustflags = [
-  "-Zshare-generics=n",
+  "-Zshare-generics=n", # (Nightly)
   "-Zthreads=0",        # (Nightly) Use improved multithreading with the recommended amount of threads.
 ]
 
diff --git a/.github/contributing/engine_style_guide.md b/.github/contributing/engine_style_guide.md
index 5ccc1c59a2586..ff656373fdb4d 100644
--- a/.github/contributing/engine_style_guide.md
+++ b/.github/contributing/engine_style_guide.md
@@ -14,6 +14,7 @@ For more advice on contributing to the engine, see the [relevant section](../../
    4. Use \`variable_name\` code blocks in comments to signify that you're referring to specific types and variables.
    5. Start comments with capital letters. End them with a period if they are sentence-like.
 3. Use comments to organize long and complex stretches of code that can't sensibly be refactored into separate functions.
+4. When using [Bevy error codes](https://bevyengine.org/learn/errors/) include a link to the relevant error on the Bevy website in the returned error message `... See: https://bevyengine.org/learn/errors/#b0003`.
 
 ## Rust API guidelines
 
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 58685510aced3..d1d0909cac009 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -144,8 +144,6 @@ jobs:
           target: wasm32-unknown-unknown
       - name: Check wasm
         run: cargo check --target wasm32-unknown-unknown
-        env:
-          RUSTFLAGS: --cfg=web_sys_unstable_apis
 
   markdownlint:
     runs-on: ubuntu-latest
@@ -191,7 +189,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Check for typos
-        uses: crate-ci/typos@v1.18.2
+        uses: crate-ci/typos@v1.19.0
       - name: Typos info
         if: failure()
         run: |
diff --git a/Cargo.toml b/Cargo.toml
index 4d77987d6184b..6de2dccefc702 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -155,6 +155,9 @@ bevy_winit = ["bevy_internal/bevy_winit"]
 # Adds support for rendering gizmos
 bevy_gizmos = ["bevy_internal/bevy_gizmos", "bevy_color"]
 
+# Provides a collection of developer tools
+bevy_dev_tools = ["bevy_internal/bevy_dev_tools"]
+
 # Tracing support, saving a file in Chrome Tracing format
 trace_chrome = ["trace", "bevy_internal/trace_chrome"]
 
@@ -303,7 +306,7 @@ pbr_transmission_textures = ["bevy_internal/pbr_transmission_textures"]
 # Enable some limitations to be able to use WebGL2. Please refer to the [WebGL2 and WebGPU](https://github.com/bevyengine/bevy/tree/latest/examples#webgl2-and-webgpu) section of the examples README for more information on how to run Wasm builds with WebGPU.
 webgl2 = ["bevy_internal/webgl"]
 
-# Enable support for WebGPU in Wasm. When enabled, this feature will override the `webgl2` feature and you won't be able to run Wasm builds with WebGL2, only with WebGPU. Requires the `RUSTFLAGS` environment variable to be set to `--cfg=web_sys_unstable_apis` when building.
+# Enable support for WebGPU in Wasm. When enabled, this feature will override the `webgl2` feature and you won't be able to run Wasm builds with WebGL2, only with WebGPU.
 webgpu = ["bevy_internal/webgpu"]
 
 # Enables the built-in asset processor for processed assets.
@@ -318,6 +321,9 @@ embedded_watcher = ["bevy_internal/embedded_watcher"]
 # Enable stepping-based debugging of Bevy systems
 bevy_debug_stepping = ["bevy_internal/bevy_debug_stepping"]
 
+# Enable support for the ios_simulator by downgrading some rendering capabilities
+ios_simulator = ["bevy_internal/ios_simulator"]
+
 [dependencies]
 bevy_dylib = { path = "crates/bevy_dylib", version = "0.14.0-dev", default-features = false, optional = true }
 bevy_internal = { path = "crates/bevy_internal", version = "0.14.0-dev", default-features = false }
@@ -332,6 +338,7 @@ bytemuck = "1.7"
 futures-lite = "2.0.1"
 crossbeam-channel = "0.5.0"
 argh = "0.1.12"
+thiserror = "1.0"
 
 [[example]]
 name = "hello_world"
@@ -1105,6 +1112,16 @@ description = "Illustrate how to add custom log layers"
 category = "Application"
 wasm = false
 
+[[example]]
+name = "log_layers_ecs"
+path = "examples/app/log_layers_ecs.rs"
+
+[package.metadata.example.log_layers_ecs]
+name = "Advanced log layers"
+description = "Illustrate how to transfer data between log layers and Bevy's ECS"
+category = "Application"
+wasm = false
+
 [[example]]
 name = "plugin"
 path = "examples/app/plugin.rs"
@@ -1227,6 +1244,17 @@ description = "Embed an asset in the application binary and load it"
 category = "Assets"
 wasm = true
 
+[[example]]
+name = "extra_asset_source"
+path = "examples/asset/extra_source.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.extra_asset_source]
+name = "Extra asset source"
+description = "Load an asset from a non-standard asset source"
+category = "Assets"
+wasm = true
+
 [[example]]
 name = "hot_asset_reloading"
 path = "examples/asset/hot_asset_reloading.rs"
@@ -1678,6 +1706,17 @@ description = "Displays each contributor as a bouncy bevy-ball!"
 category = "Games"
 wasm = true
 
+[[example]]
+name = "desk_toy"
+path = "examples/games/desk_toy.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.desk_toy]
+name = "Desk Toy"
+description = "Bevy logo as a desk toy using transparent windows! Now with Googly Eyes!"
+category = "Games"
+wasm = false
+
 [[example]]
 name = "game_menu"
 path = "examples/games/game_menu.rs"
@@ -2500,6 +2539,17 @@ description = "Illustrates how to use 9 Slicing in UI"
 category = "UI (User Interface)"
 wasm = true
 
+[[example]]
+name = "ui_texture_atlas_slice"
+path = "examples/ui/ui_texture_atlas_slice.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.ui_texture_atlas_slice]
+name = "UI Texture Atlas Slice"
+description = "Illustrates how to use 9 Slicing for TextureAtlases in UI"
+category = "UI (User Interface)"
+wasm = true
+
 [[example]]
 name = "viewport_debug"
 path = "examples/ui/viewport_debug.rs"
@@ -2680,6 +2730,28 @@ description = "A scene showcasing 3D gizmos"
 category = "Gizmos"
 wasm = true
 
+[[example]]
+name = "axes"
+path = "examples/gizmos/axes.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.axes]
+name = "Axes"
+description = "Demonstrates the function of axes gizmos"
+category = "Gizmos"
+wasm = true
+
+[[example]]
+name = "light_gizmos"
+path = "examples/gizmos/light_gizmos.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.light_gizmos]
+name = "Light Gizmos"
+description = "A scene showcasing light gizmos"
+category = "Gizmos"
+wasm = true
+
 [profile.wasm-release]
 inherits = "release"
 opt-level = "z"
diff --git a/assets/textures/fantasy_ui_borders/border_sheet.png b/assets/textures/fantasy_ui_borders/border_sheet.png
new file mode 100644
index 0000000000000..8ee2d2a9b2d34
Binary files /dev/null and b/assets/textures/fantasy_ui_borders/border_sheet.png differ
diff --git a/benches/benches/bevy_ecs/world/commands.rs b/benches/benches/bevy_ecs/world/commands.rs
index 70cf1351acfcb..2b3d84195aff8 100644
--- a/benches/benches/bevy_ecs/world/commands.rs
+++ b/benches/benches/bevy_ecs/world/commands.rs
@@ -1,8 +1,8 @@
 use bevy_ecs::{
     component::Component,
     entity::Entity,
-    system::{Command, CommandQueue, Commands},
-    world::World,
+    system::Commands,
+    world::{Command, CommandQueue, World},
 };
 use criterion::{black_box, Criterion};
 
diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index eb8f48c12179b..e47fefb987848 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -13,7 +13,6 @@ keywords = ["bevy"]
 bevy_app = { path = "../bevy_app", version = "0.14.0-dev" }
 bevy_asset = { path = "../bevy_asset", version = "0.14.0-dev" }
 bevy_core = { path = "../bevy_core", version = "0.14.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.14.0-dev" }
 bevy_math = { path = "../bevy_math", version = "0.14.0-dev" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.14.0-dev", features = [
   "bevy",
@@ -27,7 +26,7 @@ bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.14.0-dev" }
 
 # other
 sha1_smol = { version = "1.0" }
-uuid = { version = "1.7", features = ["v5"] }
+uuid = { version = "1.7", features = ["v4"] }
 
 [lints]
 workspace = true
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index bef6c87157c30..08f10a167dfd2 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -14,15 +14,15 @@ use bevy_core::Name;
 use bevy_ecs::entity::MapEntities;
 use bevy_ecs::prelude::*;
 use bevy_ecs::reflect::ReflectMapEntities;
-use bevy_log::error;
 use bevy_math::{FloatExt, Quat, Vec3};
 use bevy_reflect::Reflect;
 use bevy_render::mesh::morph::MorphWeights;
 use bevy_time::Time;
 use bevy_transform::{prelude::Transform, TransformSystem};
 use bevy_utils::hashbrown::HashMap;
-use bevy_utils::{NoOpHash, Uuid};
+use bevy_utils::{tracing::error, NoOpHash};
 use sha1_smol::Sha1;
+use uuid::Uuid;
 
 #[allow(missing_docs)]
 pub mod prelude {
@@ -688,10 +688,6 @@ impl Plugin for AnimationPlugin {
         app.init_asset::<AnimationClip>()
             .register_asset_reflect::<AnimationClip>()
             .register_type::<AnimationPlayer>()
-            .register_type::<VariableCurve>()
-            .register_type::<Vec<VariableCurve>>()
-            .register_type::<Interpolation>()
-            .register_type::<Keyframes>()
             .register_type::<AnimationTarget>()
             .add_systems(
                 PostUpdate,
diff --git a/crates/bevy_app/Cargo.toml b/crates/bevy_app/Cargo.toml
index 020245b6449dc..e4f7649325776 100644
--- a/crates/bevy_app/Cargo.toml
+++ b/crates/bevy_app/Cargo.toml
@@ -10,7 +10,6 @@ keywords = ["bevy"]
 
 [features]
 trace = []
-bevy_ci_testing = ["serde", "ron"]
 bevy_debug_stepping = []
 default = ["bevy_reflect", "bevy_debug_stepping"]
 bevy_reflect = ["dep:bevy_reflect", "bevy_ecs/bevy_reflect"]
@@ -27,7 +26,7 @@ bevy_tasks = { path = "../bevy_tasks", version = "0.14.0-dev" }
 serde = { version = "1.0", features = ["derive"], optional = true }
 ron = { version = "0.8.0", optional = true }
 downcast-rs = "1.2.0"
-
+thiserror = "1.0"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 wasm-bindgen = { version = "0.2" }
diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs
index f08a3e73bd788..10f567f2f211c 100644
--- a/crates/bevy_app/src/app.rs
+++ b/crates/bevy_app/src/app.rs
@@ -7,11 +7,12 @@ use bevy_ecs::{
         InternedScheduleLabel, ScheduleBuildSettings, ScheduleLabel,
     },
 };
-use bevy_utils::{intern::Interned, thiserror::Error, tracing::debug, HashMap, HashSet};
+use bevy_utils::{intern::Interned, tracing::debug, HashMap, HashSet};
 use std::{
     fmt::Debug,
     panic::{catch_unwind, resume_unwind, AssertUnwindSafe},
 };
+use thiserror::Error;
 
 #[cfg(feature = "trace")]
 use bevy_utils::tracing::info_span;
@@ -188,11 +189,6 @@ impl Default for App {
 
         app.add_event::<AppExit>();
 
-        #[cfg(feature = "bevy_ci_testing")]
-        {
-            crate::ci_testing::setup_app(&mut app);
-        }
-
         app
     }
 }
diff --git a/crates/bevy_app/src/lib.rs b/crates/bevy_app/src/lib.rs
index 8f6ba7972f272..721cf1618a724 100644
--- a/crates/bevy_app/src/lib.rs
+++ b/crates/bevy_app/src/lib.rs
@@ -6,9 +6,6 @@ mod plugin;
 mod plugin_group;
 mod schedule_runner;
 
-#[cfg(feature = "bevy_ci_testing")]
-pub mod ci_testing;
-
 pub use app::*;
 pub use bevy_derive::DynamicPlugin;
 pub use main_schedule::*;
diff --git a/crates/bevy_app/src/plugin.rs b/crates/bevy_app/src/plugin.rs
index 2609c9e5042fa..3dfb28b428ab7 100644
--- a/crates/bevy_app/src/plugin.rs
+++ b/crates/bevy_app/src/plugin.rs
@@ -115,8 +115,7 @@ pub trait Plugins<Marker>: sealed::Plugins<Marker> {}
 impl<Marker, T> Plugins<Marker> for T where T: sealed::Plugins<Marker> {}
 
 mod sealed {
-
-    use bevy_ecs::all_tuples;
+    use bevy_utils::all_tuples;
 
     use crate::{App, AppError, Plugin, PluginGroup};
 
diff --git a/crates/bevy_asset/Cargo.toml b/crates/bevy_asset/Cargo.toml
index 49534ba2a5c1d..ddec0a6b6a59b 100644
--- a/crates/bevy_asset/Cargo.toml
+++ b/crates/bevy_asset/Cargo.toml
@@ -21,8 +21,9 @@ watch = []
 bevy_app = { path = "../bevy_app", version = "0.14.0-dev" }
 bevy_asset_macros = { path = "macros", version = "0.14.0-dev" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.14.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.14.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.14.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.14.0-dev", features = [
+  "uuid",
+] }
 bevy_tasks = { path = "../bevy_tasks", version = "0.14.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.14.0-dev" }
 
@@ -38,6 +39,7 @@ parking_lot = { version = "0.12", features = ["arc_lock", "send_guard"] }
 ron = "0.8"
 serde = { version = "1", features = ["derive"] }
 thiserror = "1.0"
+uuid = { version = "1.0", features = ["v4"] }
 
 [target.'cfg(target_os = "android")'.dependencies]
 bevy_winit = { path = "../bevy_winit", version = "0.14.0-dev" }
@@ -53,6 +55,7 @@ notify-debouncer-full = { version = "0.3.1", optional = true }
 
 [dev-dependencies]
 bevy_core = { path = "../bevy_core", version = "0.14.0-dev" }
+bevy_log = { path = "../bevy_log", version = "0.14.0-dev" }
 
 [lints]
 workspace = true
diff --git a/crates/bevy_asset/src/assets.rs b/crates/bevy_asset/src/assets.rs
index c0f76d90c117d..9cf1b4e5386b7 100644
--- a/crates/bevy_asset/src/assets.rs
+++ b/crates/bevy_asset/src/assets.rs
@@ -7,7 +7,7 @@ use bevy_ecs::{
     system::{Res, ResMut, Resource},
 };
 use bevy_reflect::{Reflect, TypePath};
-use bevy_utils::{HashMap, Uuid};
+use bevy_utils::HashMap;
 use crossbeam_channel::{Receiver, Sender};
 use serde::{Deserialize, Serialize};
 use std::{
@@ -17,6 +17,7 @@ use std::{
     sync::{atomic::AtomicU32, Arc},
 };
 use thiserror::Error;
+use uuid::Uuid;
 
 /// A generational runtime-only identifier for a specific [`Asset`] stored in [`Assets`]. This is optimized for efficient runtime
 /// usage and is not suitable for identifying assets across app runs.
diff --git a/crates/bevy_asset/src/handle.rs b/crates/bevy_asset/src/handle.rs
index c89bf4b656a53..d14c325973c77 100644
--- a/crates/bevy_asset/src/handle.rs
+++ b/crates/bevy_asset/src/handle.rs
@@ -3,8 +3,8 @@ use crate::{
     UntypedAssetId,
 };
 use bevy_ecs::prelude::*;
-use bevy_reflect::{Reflect, TypePath};
-use bevy_utils::{get_short_name, Uuid};
+use bevy_reflect::{std_traits::ReflectDefault, Reflect, TypePath};
+use bevy_utils::get_short_name;
 use crossbeam_channel::{Receiver, Sender};
 use std::{
     any::TypeId,
@@ -12,6 +12,7 @@ use std::{
     sync::Arc,
 };
 use thiserror::Error;
+use uuid::Uuid;
 
 /// Provides [`Handle`] and [`UntypedHandle`] _for a specific asset type_.
 /// This should _only_ be used for one specific asset type.
@@ -122,7 +123,7 @@ impl std::fmt::Debug for StrongHandle {
 ///
 /// [`Handle::Strong`] also provides access to useful [`Asset`] metadata, such as the [`AssetPath`] (if it exists).
 #[derive(Component, Reflect)]
-#[reflect(Component)]
+#[reflect(Default, Component, Debug, Hash, PartialEq)]
 pub enum Handle<A: Asset> {
     /// A "strong" reference to a live (or loading) [`Asset`]. If a [`Handle`] is [`Handle::Strong`], the [`Asset`] will be kept
     /// alive until the [`Handle`] is dropped. Strong handles also provide access to additional asset metadata.
diff --git a/crates/bevy_asset/src/id.rs b/crates/bevy_asset/src/id.rs
index 1efc61bacc1af..fc98902786315 100644
--- a/crates/bevy_asset/src/id.rs
+++ b/crates/bevy_asset/src/id.rs
@@ -1,6 +1,6 @@
 use crate::{Asset, AssetIndex};
 use bevy_reflect::Reflect;
-use bevy_utils::Uuid;
+use uuid::Uuid;
 
 use std::{
     any::TypeId,
diff --git a/crates/bevy_asset/src/io/android.rs b/crates/bevy_asset/src/io/android.rs
index f792a72b00383..38791b35e0071 100644
--- a/crates/bevy_asset/src/io/android.rs
+++ b/crates/bevy_asset/src/io/android.rs
@@ -1,7 +1,7 @@
 use crate::io::{
     get_meta_path, AssetReader, AssetReaderError, EmptyPathStream, PathStream, Reader, VecReader,
 };
-use bevy_log::error;
+use bevy_utils::tracing::error;
 use bevy_utils::BoxedFuture;
 use std::{ffi::CString, path::Path};
 
diff --git a/crates/bevy_asset/src/io/embedded/embedded_watcher.rs b/crates/bevy_asset/src/io/embedded/embedded_watcher.rs
index 1e7f3057bbfd2..485593599c489 100644
--- a/crates/bevy_asset/src/io/embedded/embedded_watcher.rs
+++ b/crates/bevy_asset/src/io/embedded/embedded_watcher.rs
@@ -3,7 +3,7 @@ use crate::io::{
     memory::Dir,
     AssetSourceEvent, AssetWatcher,
 };
-use bevy_log::warn;
+use bevy_utils::tracing::warn;
 use bevy_utils::{Duration, HashMap};
 use notify_debouncer_full::{notify::RecommendedWatcher, Debouncer, FileIdMap};
 use parking_lot::RwLock;
diff --git a/crates/bevy_asset/src/io/file/file_watcher.rs b/crates/bevy_asset/src/io/file/file_watcher.rs
index 720adb7ed965b..fbed3f8a0ecbe 100644
--- a/crates/bevy_asset/src/io/file/file_watcher.rs
+++ b/crates/bevy_asset/src/io/file/file_watcher.rs
@@ -1,6 +1,6 @@
 use crate::io::{AssetSourceEvent, AssetWatcher};
 use crate::path::normalize_path;
-use bevy_log::error;
+use bevy_utils::tracing::error;
 use bevy_utils::Duration;
 use crossbeam_channel::Sender;
 use notify_debouncer_full::{
diff --git a/crates/bevy_asset/src/io/file/mod.rs b/crates/bevy_asset/src/io/file/mod.rs
index 25bd1e5175f22..19a9ffb0cdae8 100644
--- a/crates/bevy_asset/src/io/file/mod.rs
+++ b/crates/bevy_asset/src/io/file/mod.rs
@@ -6,7 +6,7 @@ mod file_asset;
 #[cfg(not(feature = "multi-threaded"))]
 mod sync_file_asset;
 
-use bevy_log::error;
+use bevy_utils::tracing::error;
 #[cfg(feature = "file_watcher")]
 pub use file_watcher::*;
 
diff --git a/crates/bevy_asset/src/io/processor_gated.rs b/crates/bevy_asset/src/io/processor_gated.rs
index ed5aacb0a911f..b86460f04b6fd 100644
--- a/crates/bevy_asset/src/io/processor_gated.rs
+++ b/crates/bevy_asset/src/io/processor_gated.rs
@@ -4,7 +4,7 @@ use crate::{
     AssetPath,
 };
 use async_lock::RwLockReadGuardArc;
-use bevy_log::trace;
+use bevy_utils::tracing::trace;
 use bevy_utils::BoxedFuture;
 use futures_io::AsyncRead;
 use std::{path::Path, pin::Pin, sync::Arc};
diff --git a/crates/bevy_asset/src/io/source.rs b/crates/bevy_asset/src/io/source.rs
index 690eee2da1d2f..7293a73bea418 100644
--- a/crates/bevy_asset/src/io/source.rs
+++ b/crates/bevy_asset/src/io/source.rs
@@ -6,7 +6,7 @@ use crate::{
     processor::AssetProcessorData,
 };
 use bevy_ecs::system::Resource;
-use bevy_log::{error, warn};
+use bevy_utils::tracing::{error, warn};
 use bevy_utils::{CowArc, Duration, HashMap};
 use std::{fmt::Display, hash::Hash, sync::Arc};
 use thiserror::Error;
diff --git a/crates/bevy_asset/src/io/wasm.rs b/crates/bevy_asset/src/io/wasm.rs
index 7ee60ecfdb8c9..aab497ddfa7cc 100644
--- a/crates/bevy_asset/src/io/wasm.rs
+++ b/crates/bevy_asset/src/io/wasm.rs
@@ -1,7 +1,7 @@
 use crate::io::{
     get_meta_path, AssetReader, AssetReaderError, EmptyPathStream, PathStream, Reader, VecReader,
 };
-use bevy_log::error;
+use bevy_utils::tracing::error;
 use bevy_utils::BoxedFuture;
 use js_sys::{Uint8Array, JSON};
 use std::path::{Path, PathBuf};
diff --git a/crates/bevy_asset/src/lib.rs b/crates/bevy_asset/src/lib.rs
index 9fa056e3bced7..803f76c6e3590 100644
--- a/crates/bevy_asset/src/lib.rs
+++ b/crates/bevy_asset/src/lib.rs
@@ -55,9 +55,8 @@ use bevy_ecs::{
     system::Resource,
     world::FromWorld,
 };
-use bevy_log::error;
 use bevy_reflect::{FromReflect, GetTypeRegistration, Reflect, TypePath};
-use bevy_utils::HashSet;
+use bevy_utils::{tracing::error, HashSet};
 use std::{any::TypeId, sync::Arc};
 
 #[cfg(all(feature = "file_watcher", not(feature = "multi-threaded")))]
@@ -379,7 +378,6 @@ impl AssetApp for App {
             .add_event::<AssetEvent<A>>()
             .add_event::<AssetLoadFailedEvent<A>>()
             .register_type::<Handle<A>>()
-            .register_type::<AssetId<A>>()
             .add_systems(
                 First,
                 Assets::<A>::asset_events
diff --git a/crates/bevy_asset/src/meta.rs b/crates/bevy_asset/src/meta.rs
index e8758999f7d7e..f20e0c2e32288 100644
--- a/crates/bevy_asset/src/meta.rs
+++ b/crates/bevy_asset/src/meta.rs
@@ -1,6 +1,6 @@
 use crate::{self as bevy_asset, DeserializeMetaError, VisitAssetDependencies};
 use crate::{loader::AssetLoader, processor::Process, Asset, AssetPath};
-use bevy_log::error;
+use bevy_utils::tracing::error;
 use downcast_rs::{impl_downcast, Downcast};
 use ron::ser::PrettyConfig;
 use serde::{Deserialize, Serialize};
diff --git a/crates/bevy_asset/src/path.rs b/crates/bevy_asset/src/path.rs
index b9247cf04518f..e49db629362f0 100644
--- a/crates/bevy_asset/src/path.rs
+++ b/crates/bevy_asset/src/path.rs
@@ -381,7 +381,7 @@ impl<'a> AssetPath<'a> {
 
     /// Resolves an embedded asset path via concatenation. The result will be an `AssetPath` which
     /// is resolved relative to this path. This is similar in operation to `resolve`, except that
-    /// the the 'file' portion of the base path (that is, any characters after the last '/')
+    /// the 'file' portion of the base path (that is, any characters after the last '/')
     /// is removed before concatenation, in accordance with the behavior specified in
     /// IETF RFC 1808 "Relative URIs".
     ///
diff --git a/crates/bevy_asset/src/processor/log.rs b/crates/bevy_asset/src/processor/log.rs
index 642de9b127142..64207295e751b 100644
--- a/crates/bevy_asset/src/processor/log.rs
+++ b/crates/bevy_asset/src/processor/log.rs
@@ -1,6 +1,6 @@
 use crate::AssetPath;
 use async_fs::File;
-use bevy_log::error;
+use bevy_utils::tracing::error;
 use bevy_utils::HashSet;
 use futures_lite::{AsyncReadExt, AsyncWriteExt};
 use std::path::PathBuf;
diff --git a/crates/bevy_asset/src/processor/mod.rs b/crates/bevy_asset/src/processor/mod.rs
index 625a484330078..ace12c8f7301b 100644
--- a/crates/bevy_asset/src/processor/mod.rs
+++ b/crates/bevy_asset/src/processor/mod.rs
@@ -17,8 +17,8 @@ use crate::{
     MissingAssetLoaderForExtensionError,
 };
 use bevy_ecs::prelude::*;
-use bevy_log::{debug, error, trace, warn};
 use bevy_tasks::IoTaskPool;
+use bevy_utils::tracing::{debug, error, trace, warn};
 use bevy_utils::{BoxedFuture, HashMap, HashSet};
 use futures_io::ErrorKind;
 use futures_lite::{AsyncReadExt, AsyncWriteExt, StreamExt};
diff --git a/crates/bevy_asset/src/server/info.rs b/crates/bevy_asset/src/server/info.rs
index 6e9b758fa77ca..dd967a9b92a03 100644
--- a/crates/bevy_asset/src/server/info.rs
+++ b/crates/bevy_asset/src/server/info.rs
@@ -5,7 +5,7 @@ use crate::{
     UntypedAssetId, UntypedHandle,
 };
 use bevy_ecs::world::World;
-use bevy_log::warn;
+use bevy_utils::tracing::warn;
 use bevy_utils::{Entry, HashMap, HashSet, TypeIdMap};
 use crossbeam_channel::Sender;
 use std::{
@@ -205,7 +205,7 @@ impl AssetInfos {
             .ok_or(GetOrCreateHandleInternalError::HandleMissingButTypeIdNotSpecified)?;
 
         match handles.entry(type_id) {
-            bevy_utils::hashbrown::hash_map::Entry::Occupied(entry) => {
+            Entry::Occupied(entry) => {
                 let id = *entry.get();
                 // if there is a path_to_id entry, info always exists
                 let info = self.infos.get_mut(&id).unwrap();
@@ -246,7 +246,7 @@ impl AssetInfos {
                 }
             }
             // The entry does not exist, so this is a "fresh" asset load. We must create a new handle
-            bevy_utils::hashbrown::hash_map::Entry::Vacant(entry) => {
+            Entry::Vacant(entry) => {
                 let should_load = match loading_mode {
                     HandleLoadingMode::NotLoading => false,
                     HandleLoadingMode::Request | HandleLoadingMode::Force => true,
diff --git a/crates/bevy_asset/src/server/loaders.rs b/crates/bevy_asset/src/server/loaders.rs
index 65f21d6b9b52f..98cc3bce9d28f 100644
--- a/crates/bevy_asset/src/server/loaders.rs
+++ b/crates/bevy_asset/src/server/loaders.rs
@@ -3,8 +3,8 @@ use crate::{
     path::AssetPath,
 };
 use async_broadcast::RecvError;
-use bevy_log::{error, warn};
 use bevy_tasks::IoTaskPool;
+use bevy_utils::tracing::{error, warn};
 use bevy_utils::{HashMap, TypeIdMap};
 use std::{any::TypeId, sync::Arc};
 use thiserror::Error;
diff --git a/crates/bevy_asset/src/server/mod.rs b/crates/bevy_asset/src/server/mod.rs
index cc0825d3aaa57..2be2848aece48 100644
--- a/crates/bevy_asset/src/server/mod.rs
+++ b/crates/bevy_asset/src/server/mod.rs
@@ -18,8 +18,8 @@ use crate::{
     UntypedAssetLoadFailedEvent, UntypedHandle,
 };
 use bevy_ecs::prelude::*;
-use bevy_log::{error, info};
 use bevy_tasks::IoTaskPool;
+use bevy_utils::tracing::{error, info};
 use bevy_utils::{CowArc, HashSet};
 use crossbeam_channel::{Receiver, Sender};
 use futures_lite::StreamExt;
diff --git a/crates/bevy_audio/Cargo.toml b/crates/bevy_audio/Cargo.toml
index eec6b282234b3..4b0470caa82e6 100644
--- a/crates/bevy_audio/Cargo.toml
+++ b/crates/bevy_audio/Cargo.toml
@@ -25,7 +25,7 @@ bevy_utils = { path = "../bevy_utils", version = "0.14.0-dev" }
 rodio = { version = "0.17", default-features = false }
 
 [target.'cfg(target_os = "android")'.dependencies]
-oboe = { version = "0.5", optional = true }
+cpal = { version = "0.15", optional = true }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 rodio = { version = "0.17", default-features = false, features = [
@@ -45,7 +45,7 @@ symphonia-isomp4 = ["rodio/symphonia-isomp4"]
 symphonia-vorbis = ["rodio/symphonia-vorbis"]
 symphonia-wav = ["rodio/symphonia-wav"]
 # Enable using a shared stdlib for cxx on Android.
-android_shared_stdcxx = ["oboe/shared-stdcxx"]
+android_shared_stdcxx = ["cpal/oboe-shared-stdcxx"]
 
 [lints]
 workspace = true
diff --git a/crates/bevy_color/Cargo.toml b/crates/bevy_color/Cargo.toml
index e23bdddc48817..29bd0218ad1f3 100644
--- a/crates/bevy_color/Cargo.toml
+++ b/crates/bevy_color/Cargo.toml
@@ -16,7 +16,7 @@ bevy_reflect = { path = "../bevy_reflect", version = "0.14.0-dev", features = [
 bytemuck = "1"
 serde = "1.0"
 thiserror = "1.0"
-wgpu = { version = "0.19.1", default-features = false }
+wgpu = { version = "0.19.3", default-features = false }
 encase = { version = "0.7", default-features = false }
 
 [lints]
diff --git a/crates/bevy_color/src/palettes/basic.rs b/crates/bevy_color/src/palettes/basic.rs
index 80b9d28e8c11a..b877505340e33 100644
--- a/crates/bevy_color/src/palettes/basic.rs
+++ b/crates/bevy_color/src/palettes/basic.rs
@@ -1,39 +1,39 @@
 //! Named colors from the CSS1 specification, also known as
 //! [basic colors](https://en.wikipedia.org/wiki/Web_colors#Basic_colors).
 //! This is the same set of colors used in the
-//! [VGA graphcs standard](https://en.wikipedia.org/wiki/Video_Graphics_Array).
+//! [VGA graphics standard](https://en.wikipedia.org/wiki/Video_Graphics_Array).
 
 use crate::Srgba;
 
-/// <div style="background-color:rgb(0%, 0%, 0%); width: 10px; padding: 10px; border: 1px solid;"></div>
-pub const BLACK: Srgba = Srgba::new(0.0, 0.0, 0.0, 1.0);
-/// <div style="background-color:rgb(0%, 0%, 100%); width: 10px; padding: 10px; border: 1px solid;"></div>
-pub const BLUE: Srgba = Srgba::new(0.0, 0.0, 1.0, 1.0);
-/// <div style="background-color:rgb(0%, 100%, 100%); width: 10px; padding: 10px; border: 1px solid;"></div>
-pub const CYAN: Srgba = Srgba::new(0.0, 1.0, 1.0, 1.0);
-/// <div style="background-color:rgb(100%, 0%, 100%); width: 10px; padding: 10px; border: 1px solid;"></div>
-pub const FUCHSIA: Srgba = Srgba::new(1.0, 0.0, 1.0, 1.0);
-/// <div style="background-color:rgb(50%, 50%, 50%); width: 10px; padding: 10px; border: 1px solid;"></div>
-pub const GRAY: Srgba = Srgba::new(0.5, 0.5, 0.5, 1.0);
-/// <div style="background-color:rgb(0%, 50%, 0%); width: 10px; padding: 10px; border: 1px solid;"></div>
-pub const GREEN: Srgba = Srgba::new(0.0, 0.5, 0.0, 1.0);
-/// <div style="background-color:rgb(0%, 100%, 0%); width: 10px; padding: 10px; border: 1px solid;"></div>
-pub const LIME: Srgba = Srgba::new(0.0, 1.0, 0.0, 1.0);
-/// <div style="background-color:rgb(50%, 0%, 0%); width: 10px; padding: 10px; border: 1px solid;"></div>
-pub const MAROON: Srgba = Srgba::new(0.5, 0.0, 0.0, 1.0);
-/// <div style="background-color:rgb(0%, 0%, 50%); width: 10px; padding: 10px; border: 1px solid;"></div>
-pub const NAVY: Srgba = Srgba::new(0.0, 0.0, 0.5, 1.0);
-/// <div style="background-color:rgb(50%, 50%, 0%); width: 10px; padding: 10px; border: 1px solid;"></div>
-pub const OLIVE: Srgba = Srgba::new(0.5, 0.5, 0.0, 1.0);
-/// <div style="background-color:rgb(50%, 0%, 50%); width: 10px; padding: 10px; border: 1px solid;"></div>
-pub const PURPLE: Srgba = Srgba::new(0.5, 0.0, 0.5, 1.0);
-/// <div style="background-color:rgb(100%, 0%, 0%); width: 10px; padding: 10px; border: 1px solid;"></div>
-pub const RED: Srgba = Srgba::new(1.0, 0.0, 0.0, 1.0);
-/// <div style="background-color:rgb(75%, 75%, 75%); width: 10px; padding: 10px; border: 1px solid;"></div>
-pub const SILVER: Srgba = Srgba::new(0.75, 0.75, 0.75, 1.0);
-/// <div style="background-color:rgb(0%, 50%, 50%); width: 10px; padding: 10px; border: 1px solid;"></div>
-pub const TEAL: Srgba = Srgba::new(0.0, 0.5, 0.5, 1.0);
-/// <div style="background-color:rgb(100%, 100%, 100%); width: 10px; padding: 10px; border: 1px solid;"></div>
-pub const WHITE: Srgba = Srgba::new(1.0, 1.0, 1.0, 1.0);
-/// <div style="background-color:rgb(100%, 100%, 0%); width: 10px; padding: 10px; border: 1px solid;"></div>
-pub const YELLOW: Srgba = Srgba::new(1.0, 1.0, 0.0, 1.0);
+/// <div style="background-color: #00FFFF; width: 10px; padding: 10px; border: 1px solid;"></div>
+pub const AQUA: Srgba = Srgba::rgb(0.0, 1.0, 1.0);
+/// <div style="background-color: #000000; width: 10px; padding: 10px; border: 1px solid;"></div>
+pub const BLACK: Srgba = Srgba::rgb(0.0, 0.0, 0.0);
+/// <div style="background-color: #0000FF; width: 10px; padding: 10px; border: 1px solid;"></div>
+pub const BLUE: Srgba = Srgba::rgb(0.0, 0.0, 1.0);
+/// <div style="background-color: #FF00FF; width: 10px; padding: 10px; border: 1px solid;"></div>
+pub const FUCHSIA: Srgba = Srgba::rgb(1.0, 0.0, 1.0);
+/// <div style="background-color: #808080; width: 10px; padding: 10px; border: 1px solid;"></div>
+pub const GRAY: Srgba = Srgba::rgb(0.5019608, 0.5019608, 0.5019608);
+/// <div style="background-color: #008000; width: 10px; padding: 10px; border: 1px solid;"></div>
+pub const GREEN: Srgba = Srgba::rgb(0.0, 0.5019608, 0.0);
+/// <div style="background-color: #00FF00; width: 10px; padding: 10px; border: 1px solid;"></div>
+pub const LIME: Srgba = Srgba::rgb(0.0, 1.0, 0.0);
+/// <div style="background-color: #800000; width: 10px; padding: 10px; border: 1px solid;"></div>
+pub const MAROON: Srgba = Srgba::rgb(0.5019608, 0.0, 0.0);
+/// <div style="background-color: #000080; width: 10px; padding: 10px; border: 1px solid;"></div>
+pub const NAVY: Srgba = Srgba::rgb(0.0, 0.0, 0.5019608);
+/// <div style="background-color: #808000; width: 10px; padding: 10px; border: 1px solid;"></div>
+pub const OLIVE: Srgba = Srgba::rgb(0.5019608, 0.5019608, 0.0);
+/// <div style="background-color: #800080; width: 10px; padding: 10px; border: 1px solid;"></div>
+pub const PURPLE: Srgba = Srgba::rgb(0.5019608, 0.0, 0.5019608);
+/// <div style="background-color: #FF0000; width: 10px; padding: 10px; border: 1px solid;"></div>
+pub const RED: Srgba = Srgba::rgb(1.0, 0.0, 0.0);
+/// <div style="background-color: #C0C0C0; width: 10px; padding: 10px; border: 1px solid;"></div>
+pub const SILVER: Srgba = Srgba::rgb(0.7529412, 0.7529412, 0.7529412);
+/// <div style="background-color: #008080; width: 10px; padding: 10px; border: 1px solid;"></div>
+pub const TEAL: Srgba = Srgba::rgb(0.0, 0.5019608, 0.5019608);
+/// <div style="background-color: #FFFFFF; width: 10px; padding: 10px; border: 1px solid;"></div>
+pub const WHITE: Srgba = Srgba::rgb(1.0, 1.0, 1.0);
+/// <div style="background-color: #FFFF00; width: 10px; padding: 10px; border: 1px solid;"></div>
+pub const YELLOW: Srgba = Srgba::rgb(1.0, 1.0, 0.0);
diff --git a/crates/bevy_color/src/palettes/css.rs b/crates/bevy_color/src/palettes/css.rs
index 88391fac3db21..0c1e073bec4b6 100644
--- a/crates/bevy_color/src/palettes/css.rs
+++ b/crates/bevy_color/src/palettes/css.rs
@@ -106,8 +106,6 @@ pub const GOLD: Srgba = Srgba::new(1.0, 0.843, 0.0, 1.0);
 /// <div style="background-color:rgb(85.5%, 64.7%, 12.5%); width: 10px; padding: 10px; border: 1px solid;"></div>
 pub const GOLDENROD: Srgba = Srgba::new(0.855, 0.647, 0.125, 1.0);
 /// <div style="background-color:rgb(0.0%, 50.2%, 0.0%); width: 10px; padding: 10px; border: 1px solid;"></div>
-pub const GREEN: Srgba = Srgba::new(0.0, 0.502, 0.0, 1.0);
-/// <div style="background-color:rgb(67.80000000000001%, 100.0%, 18.4%); width: 10px; padding: 10px; border: 1px solid;"></div>
 pub const GREEN_YELLOW: Srgba = Srgba::new(0.678, 1.0, 0.184, 1.0);
 /// <div style="background-color:rgb(50.2%, 50.2%, 50.2%); width: 10px; padding: 10px; border: 1px solid;"></div>
 pub const GREY: Srgba = Srgba::new(0.502, 0.502, 0.502, 1.0);
diff --git a/crates/bevy_color/src/srgba.rs b/crates/bevy_color/src/srgba.rs
index e23beea2181f3..8479af4781daa 100644
--- a/crates/bevy_color/src/srgba.rs
+++ b/crates/bevy_color/src/srgba.rs
@@ -1,3 +1,5 @@
+use std::ops::{Div, Mul};
+
 use crate::color_difference::EuclideanDistance;
 use crate::{Alpha, LinearRgba, Luminance, Mix, StandardColor, Xyza};
 use bevy_math::Vec4;
@@ -369,6 +371,48 @@ pub enum HexColorError {
     Char(char),
 }
 
+/// All color channels are scaled directly,
+/// but alpha is unchanged.
+///
+/// Values are not clamped.
+impl Mul<f32> for Srgba {
+    type Output = Self;
+
+    fn mul(self, rhs: f32) -> Self {
+        Self {
+            red: self.red * rhs,
+            green: self.green * rhs,
+            blue: self.blue * rhs,
+            alpha: self.alpha,
+        }
+    }
+}
+
+impl Mul<Srgba> for f32 {
+    type Output = Srgba;
+
+    fn mul(self, rhs: Srgba) -> Srgba {
+        rhs * self
+    }
+}
+
+/// All color channels are scaled directly,
+/// but alpha is unchanged.
+///
+/// Values are not clamped.
+impl Div<f32> for Srgba {
+    type Output = Self;
+
+    fn div(self, rhs: f32) -> Self {
+        Self {
+            red: self.red / rhs,
+            green: self.green / rhs,
+            blue: self.blue / rhs,
+            alpha: self.alpha,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::testing::assert_approx_eq;
diff --git a/crates/bevy_core/Cargo.toml b/crates/bevy_core/Cargo.toml
index 5a9ab295991cf..0c0c804bf7a26 100644
--- a/crates/bevy_core/Cargo.toml
+++ b/crates/bevy_core/Cargo.toml
@@ -17,7 +17,6 @@ bevy_app = { path = "../bevy_app", version = "0.14.0-dev", features = [
 bevy_ecs = { path = "../bevy_ecs", version = "0.14.0-dev", features = [
   "bevy_reflect",
 ] }
-bevy_math = { path = "../bevy_math", version = "0.14.0-dev" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.14.0-dev", features = [
   "bevy",
 ] }
@@ -25,8 +24,8 @@ bevy_tasks = { path = "../bevy_tasks", version = "0.14.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.14.0-dev" }
 
 # other
-bytemuck = "1.5"
 serde = { version = "1.0", optional = true }
+uuid = "1.0"
 
 [features]
 serialize = ["dep:serde"]
diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index 7cf8da08b6809..c88ec31be09bf 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -6,7 +6,6 @@ mod serde;
 mod task_pool_options;
 
 use bevy_ecs::system::Resource;
-pub use bytemuck::{bytes_of, cast_slice, Pod, Zeroable};
 pub use name::*;
 pub use task_pool_options::*;
 
@@ -19,17 +18,9 @@ pub mod prelude {
 }
 
 use bevy_app::prelude::*;
-use bevy_ecs::component::{ComponentId, ComponentTicks, Tick};
 use bevy_ecs::prelude::*;
-use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
-use bevy_utils::{Duration, HashSet, Instant, Uuid};
-use std::borrow::Cow;
-use std::ffi::OsString;
 use std::marker::PhantomData;
-use std::ops::Range;
-use std::path::{Path, PathBuf};
 
-#[cfg(not(target_arch = "wasm32"))]
 #[cfg(not(target_arch = "wasm32"))]
 use bevy_tasks::tick_global_task_pools_on_main_thread;
 
@@ -40,78 +31,9 @@ pub struct TypeRegistrationPlugin;
 impl Plugin for TypeRegistrationPlugin {
     fn build(&self, app: &mut App) {
         app.register_type::<Name>();
-
-        register_ecs_types(app);
-        register_rust_types(app);
-        register_math_types(app);
     }
 }
 
-fn register_ecs_types(app: &mut App) {
-    app.register_type::<Entity>()
-        .register_type::<ComponentId>()
-        .register_type::<Tick>()
-        .register_type::<ComponentTicks>();
-}
-
-fn register_rust_types(app: &mut App) {
-    app.register_type::<Range<f32>>()
-        .register_type_data::<Range<f32>, ReflectSerialize>()
-        .register_type_data::<Range<f32>, ReflectDeserialize>()
-        .register_type::<String>()
-        .register_type::<PathBuf>()
-        .register_type::<OsString>()
-        .register_type::<HashSet<String>>()
-        .register_type::<Option<String>>()
-        .register_type::<Option<bool>>()
-        .register_type::<Option<f32>>()
-        .register_type::<Option<f64>>()
-        .register_type::<Vec<f32>>()
-        .register_type::<Cow<'static, str>>()
-        .register_type::<Cow<'static, Path>>()
-        .register_type::<Duration>()
-        .register_type::<Instant>()
-        .register_type::<Uuid>();
-}
-
-fn register_math_types(app: &mut App) {
-    app.register_type::<bevy_math::IVec2>()
-        .register_type::<bevy_math::IVec3>()
-        .register_type::<bevy_math::IVec4>()
-        .register_type::<bevy_math::UVec2>()
-        .register_type::<bevy_math::UVec3>()
-        .register_type::<bevy_math::UVec4>()
-        .register_type::<bevy_math::DVec2>()
-        .register_type::<Option<bevy_math::DVec2>>()
-        .register_type::<bevy_math::DVec3>()
-        .register_type::<bevy_math::DVec4>()
-        .register_type::<bevy_math::BVec2>()
-        .register_type::<bevy_math::BVec3>()
-        .register_type::<bevy_math::BVec3A>()
-        .register_type::<bevy_math::BVec4>()
-        .register_type::<bevy_math::BVec4A>()
-        .register_type::<bevy_math::Vec2>()
-        .register_type::<bevy_math::Vec3>()
-        .register_type::<bevy_math::Vec3A>()
-        .register_type::<bevy_math::Vec4>()
-        .register_type::<bevy_math::DAffine2>()
-        .register_type::<bevy_math::DAffine3>()
-        .register_type::<bevy_math::Affine2>()
-        .register_type::<bevy_math::Affine3A>()
-        .register_type::<bevy_math::DMat2>()
-        .register_type::<bevy_math::DMat3>()
-        .register_type::<bevy_math::DMat4>()
-        .register_type::<bevy_math::Mat2>()
-        .register_type::<bevy_math::Mat3>()
-        .register_type::<bevy_math::Mat3A>()
-        .register_type::<bevy_math::Mat4>()
-        .register_type::<bevy_math::DQuat>()
-        .register_type::<bevy_math::Quat>()
-        .register_type::<bevy_math::Rect>()
-        .register_type::<Vec<bevy_math::Quat>>()
-        .register_type::<Vec<bevy_math::Vec3>>();
-}
-
 /// Setup of default task pools: [`AsyncComputeTaskPool`](bevy_tasks::AsyncComputeTaskPool),
 /// [`ComputeTaskPool`](bevy_tasks::ComputeTaskPool), [`IoTaskPool`](bevy_tasks::IoTaskPool).
 #[derive(Default)]
diff --git a/crates/bevy_core_pipeline/Cargo.toml b/crates/bevy_core_pipeline/Cargo.toml
index 7b7aaee4aff32..1b28c00f649c5 100644
--- a/crates/bevy_core_pipeline/Cargo.toml
+++ b/crates/bevy_core_pipeline/Cargo.toml
@@ -27,7 +27,6 @@ bevy_core = { path = "../bevy_core", version = "0.14.0-dev" }
 bevy_color = { path = "../bevy_color", version = "0.14.0-dev" }
 bevy_derive = { path = "../bevy_derive", version = "0.14.0-dev" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.14.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.14.0-dev" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.14.0-dev" }
 bevy_render = { path = "../bevy_render", version = "0.14.0-dev" }
 bevy_transform = { path = "../bevy_transform", version = "0.14.0-dev" }
@@ -37,6 +36,7 @@ bevy_utils = { path = "../bevy_utils", version = "0.14.0-dev" }
 serde = { version = "1", features = ["derive"] }
 bitflags = "2.3"
 radsort = "0.1"
+nonmax = "0.5"
 
 [lints]
 workspace = true
diff --git a/crates/bevy_core_pipeline/src/bloom/settings.rs b/crates/bevy_core_pipeline/src/bloom/settings.rs
index 69c789933c686..d42cc412f262d 100644
--- a/crates/bevy_core_pipeline/src/bloom/settings.rs
+++ b/crates/bevy_core_pipeline/src/bloom/settings.rs
@@ -106,6 +106,8 @@ pub struct BloomSettings {
 
 impl BloomSettings {
     /// The default bloom preset.
+    ///
+    /// This uses the [`EnergyConserving`](BloomCompositeMode::EnergyConserving) composite mode.
     pub const NATURAL: Self = Self {
         intensity: 0.15,
         low_frequency_boost: 0.7,
diff --git a/crates/bevy_core_pipeline/src/core_2d/mod.rs b/crates/bevy_core_pipeline/src/core_2d/mod.rs
index e2684e1553f2c..5dc0a5558662b 100644
--- a/crates/bevy_core_pipeline/src/core_2d/mod.rs
+++ b/crates/bevy_core_pipeline/src/core_2d/mod.rs
@@ -42,7 +42,8 @@ use bevy_render::{
     render_resource::CachedRenderPipelineId,
     Extract, ExtractSchedule, Render, RenderApp, RenderSet,
 };
-use bevy_utils::{nonmax::NonMaxU32, FloatOrd};
+use bevy_utils::FloatOrd;
+use nonmax::NonMaxU32;
 
 use crate::{tonemapping::TonemappingNode, upscaling::UpscalingNode};
 
diff --git a/crates/bevy_core_pipeline/src/core_3d/mod.rs b/crates/bevy_core_pipeline/src/core_3d/mod.rs
index ece71016219d0..1e6dafa4ccb7e 100644
--- a/crates/bevy_core_pipeline/src/core_3d/mod.rs
+++ b/crates/bevy_core_pipeline/src/core_3d/mod.rs
@@ -67,7 +67,8 @@ use bevy_render::{
     view::{ExtractedView, ViewDepthTexture, ViewTarget},
     Extract, ExtractSchedule, Render, RenderApp, RenderSet,
 };
-use bevy_utils::{nonmax::NonMaxU32, tracing::warn, FloatOrd, HashMap};
+use bevy_utils::{tracing::warn, FloatOrd, HashMap};
+use nonmax::NonMaxU32;
 
 use crate::{
     core_3d::main_transmissive_pass_3d_node::MainTransmissivePass3dNode,
@@ -93,8 +94,6 @@ pub struct Core3dPlugin;
 impl Plugin for Core3dPlugin {
     fn build(&self, app: &mut App) {
         app.register_type::<Camera3d>()
-            .register_type::<Camera3dDepthLoadOp>()
-            .register_type::<Camera3dDepthTextureUsage>()
             .register_type::<ScreenSpaceTransmissionQuality>()
             .add_plugins((SkyboxPlugin, ExtractComponentPlugin::<Camera3d>::default()))
             .add_systems(PostUpdate, check_msaa);
diff --git a/crates/bevy_core_pipeline/src/deferred/mod.rs b/crates/bevy_core_pipeline/src/deferred/mod.rs
index fd8ca0966d8ea..a6b659fdbe391 100644
--- a/crates/bevy_core_pipeline/src/deferred/mod.rs
+++ b/crates/bevy_core_pipeline/src/deferred/mod.rs
@@ -10,7 +10,7 @@ use bevy_render::{
     render_phase::{CachedRenderPipelinePhaseItem, DrawFunctionId, PhaseItem},
     render_resource::{CachedRenderPipelineId, TextureFormat},
 };
-use bevy_utils::nonmax::NonMaxU32;
+use nonmax::NonMaxU32;
 
 pub const DEFERRED_PREPASS_FORMAT: TextureFormat = TextureFormat::Rgba32Uint;
 pub const DEFERRED_LIGHTING_PASS_ID_FORMAT: TextureFormat = TextureFormat::R8Uint;
diff --git a/crates/bevy_core_pipeline/src/fxaa/mod.rs b/crates/bevy_core_pipeline/src/fxaa/mod.rs
index bae09b4467c15..f1442910850eb 100644
--- a/crates/bevy_core_pipeline/src/fxaa/mod.rs
+++ b/crates/bevy_core_pipeline/src/fxaa/mod.rs
@@ -86,7 +86,7 @@ impl Plugin for FxaaPlugin {
     fn build(&self, app: &mut App) {
         load_internal_asset!(app, FXAA_SHADER_HANDLE, "fxaa.wgsl", Shader::from_wgsl);
 
-        app.register_type::<Fxaa>().register_type::<Sensitivity>();
+        app.register_type::<Fxaa>();
         app.add_plugins(ExtractComponentPlugin::<Fxaa>::default());
 
         let Ok(render_app) = app.get_sub_app_mut(RenderApp) else {
diff --git a/crates/bevy_core_pipeline/src/prepass/mod.rs b/crates/bevy_core_pipeline/src/prepass/mod.rs
index c250985ffc2f8..348419336ff59 100644
--- a/crates/bevy_core_pipeline/src/prepass/mod.rs
+++ b/crates/bevy_core_pipeline/src/prepass/mod.rs
@@ -38,7 +38,7 @@ use bevy_render::{
     render_resource::{CachedRenderPipelineId, Extent3d, TextureFormat, TextureView},
     texture::ColorAttachment,
 };
-use bevy_utils::nonmax::NonMaxU32;
+use nonmax::NonMaxU32;
 
 pub const NORMAL_PREPASS_FORMAT: TextureFormat = TextureFormat::Rgb10a2Unorm;
 pub const MOTION_VECTOR_PREPASS_FORMAT: TextureFormat = TextureFormat::Rg16Float;
diff --git a/crates/bevy_core_pipeline/src/tonemapping/mod.rs b/crates/bevy_core_pipeline/src/tonemapping/mod.rs
index 0045d9e05047e..7726ff1e36a15 100644
--- a/crates/bevy_core_pipeline/src/tonemapping/mod.rs
+++ b/crates/bevy_core_pipeline/src/tonemapping/mod.rs
@@ -14,6 +14,8 @@ use bevy_render::renderer::RenderDevice;
 use bevy_render::texture::{CompressedImageFormats, Image, ImageSampler, ImageType};
 use bevy_render::view::{ViewTarget, ViewUniform};
 use bevy_render::{render_resource::*, Render, RenderApp, RenderSet};
+#[cfg(not(feature = "tonemapping_luts"))]
+use bevy_utils::tracing::error;
 
 mod node;
 
@@ -199,7 +201,7 @@ impl SpecializedRenderPipeline for TonemappingPipeline {
             Tonemapping::AcesFitted => shader_defs.push("TONEMAP_METHOD_ACES_FITTED".into()),
             Tonemapping::AgX => {
                 #[cfg(not(feature = "tonemapping_luts"))]
-                bevy_log::error!(
+                error!(
                     "AgX tonemapping requires the `tonemapping_luts` feature.
                     Either enable the `tonemapping_luts` feature for bevy in `Cargo.toml` (recommended),
                     or use a different `Tonemapping` method in your `Camera2dBundle`/`Camera3dBundle`."
@@ -211,7 +213,7 @@ impl SpecializedRenderPipeline for TonemappingPipeline {
             }
             Tonemapping::TonyMcMapface => {
                 #[cfg(not(feature = "tonemapping_luts"))]
-                bevy_log::error!(
+                error!(
                     "TonyMcMapFace tonemapping requires the `tonemapping_luts` feature.
                     Either enable the `tonemapping_luts` feature for bevy in `Cargo.toml` (recommended),
                     or use a different `Tonemapping` method in your `Camera2dBundle`/`Camera3dBundle`."
@@ -220,7 +222,7 @@ impl SpecializedRenderPipeline for TonemappingPipeline {
             }
             Tonemapping::BlenderFilmic => {
                 #[cfg(not(feature = "tonemapping_luts"))]
-                bevy_log::error!(
+                error!(
                     "BlenderFilmic tonemapping requires the `tonemapping_luts` feature.
                     Either enable the `tonemapping_luts` feature for bevy in `Cargo.toml` (recommended),
                     or use a different `Tonemapping` method in your `Camera2dBundle`/`Camera3dBundle`."
diff --git a/crates/bevy_dev_tools/Cargo.toml b/crates/bevy_dev_tools/Cargo.toml
new file mode 100644
index 0000000000000..eb6597d8bd7ff
--- /dev/null
+++ b/crates/bevy_dev_tools/Cargo.toml
@@ -0,0 +1,25 @@
+[package]
+name = "bevy_dev_tools"
+version = "0.14.0-dev"
+edition = "2021"
+description = "Collection of developer tools for the Bevy Engine"
+homepage = "https://bevyengine.org"
+repository = "https://github.com/bevyengine/bevy"
+license = "MIT OR Apache-2.0"
+keywords = ["bevy"]
+
+[features]
+bevy_ci_testing = ["serde", "ron"]
+
+[dependencies]
+# bevy
+bevy_app = { path = "../bevy_app", version = "0.14.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.14.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.14.0-dev" }
+
+# other
+serde = { version = "1.0", features = ["derive"], optional = true }
+ron = { version = "0.8.0", optional = true }
+
+[lints]
+workspace = true
diff --git a/crates/bevy_app/src/ci_testing.rs b/crates/bevy_dev_tools/src/ci_testing.rs
similarity index 98%
rename from crates/bevy_app/src/ci_testing.rs
rename to crates/bevy_dev_tools/src/ci_testing.rs
index 3ba0dde78e307..db2d4a14fc70e 100644
--- a/crates/bevy_app/src/ci_testing.rs
+++ b/crates/bevy_dev_tools/src/ci_testing.rs
@@ -1,6 +1,6 @@
 //! Utilities for testing in CI environments.
 
-use crate::{app::AppExit, App, Update};
+use bevy_app::{App, AppExit, Update};
 use serde::Deserialize;
 
 use bevy_ecs::prelude::Resource;
diff --git a/crates/bevy_dev_tools/src/lib.rs b/crates/bevy_dev_tools/src/lib.rs
new file mode 100644
index 0000000000000..b025539ebbb57
--- /dev/null
+++ b/crates/bevy_dev_tools/src/lib.rs
@@ -0,0 +1,44 @@
+//! This crate provides additional utilities for the [Bevy game engine](https://bevyengine.org),
+//! focused on improving developer experience.
+
+use bevy_app::prelude::*;
+#[cfg(feature = "bevy_ci_testing")]
+pub mod ci_testing;
+
+/// Enables developer tools in an [`App`]. This plugin is added automatically with `bevy_dev_tools`
+/// feature.
+///
+/// Warning: It is not recommended to enable this in final shipped games or applications.
+/// Dev tools provide a high level of access to the internals of your application,
+/// and may interfere with ordinary use and gameplay.
+///
+/// To enable developer tools, you can either:
+///
+/// - Create a custom crate feature (e.g "`dev_mode`"), which enables the `bevy_dev_tools` feature
+/// along with any other development tools you might be using:
+///
+/// ```toml
+/// [feature]
+/// dev_mode = ["bevy/bevy_dev_tools", "other_dev_tools"]
+/// ```
+///
+/// - Use `--feature bevy/bevy_dev_tools` flag when using the `cargo run` command:
+///
+/// `cargo run --features bevy/bevy_dev_tools`
+///
+/// - Add the `bevy_dev_tools` feature to the bevy dependency in your `Cargo.toml` file:
+///
+/// `features = ["bevy_dev_tools"]`
+///
+///  Note: The third method is not recommended, as it requires you to remove the feature before
+///  creating a build for release to the public.
+pub struct DevToolsPlugin;
+
+impl Plugin for DevToolsPlugin {
+    fn build(&self, _app: &mut App) {
+        #[cfg(feature = "bevy_ci_testing")]
+        {
+            ci_testing::setup_app(_app);
+        }
+    }
+}
diff --git a/crates/bevy_diagnostic/Cargo.toml b/crates/bevy_diagnostic/Cargo.toml
index 0ba362ab71d8d..f0a3ade496ce4 100644
--- a/crates/bevy_diagnostic/Cargo.toml
+++ b/crates/bevy_diagnostic/Cargo.toml
@@ -19,7 +19,6 @@ features = []
 bevy_app = { path = "../bevy_app", version = "0.14.0-dev" }
 bevy_core = { path = "../bevy_core", version = "0.14.0-dev" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.14.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.14.0-dev" }
 bevy_time = { path = "../bevy_time", version = "0.14.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.14.0-dev" }
 
diff --git a/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs b/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs
index f3f57683086c1..2f007edcaaf50 100644
--- a/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs
+++ b/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs
@@ -1,8 +1,8 @@
 use super::{Diagnostic, DiagnosticPath, DiagnosticsStore};
 use bevy_app::prelude::*;
 use bevy_ecs::prelude::*;
-use bevy_log::{debug, info};
 use bevy_time::{Real, Time, Timer, TimerMode};
+use bevy_utils::tracing::{debug, info};
 use bevy_utils::Duration;
 
 /// An App Plugin that logs diagnostics to the console.
diff --git a/crates/bevy_diagnostic/src/system_information_diagnostics_plugin.rs b/crates/bevy_diagnostic/src/system_information_diagnostics_plugin.rs
index 1fe0f62148508..0ffe3d479b2af 100644
--- a/crates/bevy_diagnostic/src/system_information_diagnostics_plugin.rs
+++ b/crates/bevy_diagnostic/src/system_information_diagnostics_plugin.rs
@@ -40,7 +40,7 @@ impl SystemInformationDiagnosticsPlugin {
 ))]
 pub mod internal {
     use bevy_ecs::{prelude::ResMut, system::Local};
-    use bevy_log::info;
+    use bevy_utils::tracing::info;
     use sysinfo::{CpuRefreshKind, MemoryRefreshKind, RefreshKind, System};
 
     use crate::{Diagnostic, Diagnostics, DiagnosticsStore};
@@ -136,7 +136,7 @@ pub mod internal {
 )))]
 pub mod internal {
     pub(crate) fn setup_system() {
-        bevy_log::warn!("This platform and/or configuration is not supported!");
+        bevy_utils::tracing::warn!("This platform and/or configuration is not supported!");
     }
 
     pub(crate) fn diagnostic_system() {
diff --git a/crates/bevy_ecs/Cargo.toml b/crates/bevy_ecs/Cargo.toml
index b3372469694d0..27edd72384157 100644
--- a/crates/bevy_ecs/Cargo.toml
+++ b/crates/bevy_ecs/Cargo.toml
@@ -21,6 +21,7 @@ bevy_reflect = { path = "../bevy_reflect", version = "0.14.0-dev", optional = tr
 bevy_tasks = { path = "../bevy_tasks", version = "0.14.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.14.0-dev" }
 bevy_ecs_macros = { path = "macros", version = "0.14.0-dev" }
+petgraph = "0.6"
 
 bitflags = "2.3"
 concurrent-queue = "2.4.0"
@@ -28,6 +29,7 @@ fixedbitset = "0.4.2"
 rustc-hash = "1.1"
 serde = "1"
 thiserror = "1.0"
+nonmax = "0.5"
 
 [dev-dependencies]
 rand = "0.8"
diff --git a/crates/bevy_ecs/macros/src/component.rs b/crates/bevy_ecs/macros/src/component.rs
index db10910e0c508..b7b7e1582c8b3 100644
--- a/crates/bevy_ecs/macros/src/component.rs
+++ b/crates/bevy_ecs/macros/src/component.rs
@@ -60,7 +60,7 @@ pub fn derive_component(input: TokenStream) -> TokenStream {
 
     TokenStream::from(quote! {
         impl #impl_generics #bevy_ecs_path::component::Component for #struct_name #type_generics #where_clause {
-            type Storage = #storage;
+            const STORAGE_TYPE: #bevy_ecs_path::component::StorageType = #storage;
         }
     })
 }
@@ -110,10 +110,10 @@ fn parse_component_attr(ast: &DeriveInput) -> Result<Attrs> {
 }
 
 fn storage_path(bevy_ecs_path: &Path, ty: StorageTy) -> TokenStream2 {
-    let typename = match ty {
-        StorageTy::Table => Ident::new("TableStorage", Span::call_site()),
-        StorageTy::SparseSet => Ident::new("SparseStorage", Span::call_site()),
+    let storage_type = match ty {
+        StorageTy::Table => Ident::new("Table", Span::call_site()),
+        StorageTy::SparseSet => Ident::new("SparseSet", Span::call_site()),
     };
 
-    quote! { #bevy_ecs_path::component::#typename }
+    quote! { #bevy_ecs_path::component::StorageType::#storage_type }
 }
diff --git a/crates/bevy_ecs/src/bundle.rs b/crates/bevy_ecs/src/bundle.rs
index f6af2e9be024d..f3d42a66ef29b 100644
--- a/crates/bevy_ecs/src/bundle.rs
+++ b/crates/bevy_ecs/src/bundle.rs
@@ -10,16 +10,17 @@ use crate::{
         AddBundle, Archetype, ArchetypeId, Archetypes, BundleComponentStatus, ComponentStatus,
         SpawnBundleStatus,
     },
-    component::{Component, ComponentId, ComponentStorage, Components, StorageType, Tick},
+    component::{Component, ComponentId, Components, StorageType, Tick},
     entity::{Entities, Entity, EntityLocation},
     prelude::World,
     query::DebugCheckedUnwrap,
     storage::{SparseSetIndex, SparseSets, Storages, Table, TableRow},
-    world::{unsafe_world_cell::UnsafeWorldCell, DeferredWorld},
+    world::unsafe_world_cell::UnsafeWorldCell,
 };
-use bevy_ptr::OwningPtr;
+use bevy_ptr::{ConstNonNull, OwningPtr};
 use bevy_utils::all_tuples;
 use std::any::TypeId;
+use std::ptr::NonNull;
 
 /// The `Bundle` trait enables insertion and removal of [`Component`]s from an entity.
 ///
@@ -203,7 +204,7 @@ unsafe impl<C: Component> Bundle for C {
 impl<C: Component> DynamicBundle for C {
     #[inline]
     fn get_components(self, func: &mut impl FnMut(StorageType, OwningPtr<'_>)) {
-        OwningPtr::make(self, |ptr| func(C::Storage::STORAGE_TYPE, ptr));
+        OwningPtr::make(self, |ptr| func(C::STORAGE_TYPE, ptr));
     }
 }
 
@@ -348,7 +349,7 @@ impl BundleInfo {
         &self.component_ids
     }
 
-    /// Returns an iterator over the the [ID](ComponentId) of each component stored in this bundle.
+    /// Returns an iterator over the [ID](ComponentId) of each component stored in this bundle.
     #[inline]
     pub fn iter_components(&self) -> impl Iterator<Item = ComponentId> + '_ {
         self.component_ids.iter().cloned()
@@ -510,10 +511,10 @@ impl BundleInfo {
 // SAFETY: We have exclusive world access so our pointers can't be invalidated externally
 pub(crate) struct BundleInserter<'w> {
     world: UnsafeWorldCell<'w>,
-    bundle_info: *const BundleInfo,
-    add_bundle: *const AddBundle,
-    table: *mut Table,
-    archetype: *mut Archetype,
+    bundle_info: ConstNonNull<BundleInfo>,
+    add_bundle: ConstNonNull<AddBundle>,
+    table: NonNull<Table>,
+    archetype: NonNull<Archetype>,
     result: InsertBundleResult,
     change_tick: Tick,
 }
@@ -521,11 +522,11 @@ pub(crate) struct BundleInserter<'w> {
 pub(crate) enum InsertBundleResult {
     SameArchetype,
     NewArchetypeSameTable {
-        new_archetype: *mut Archetype,
+        new_archetype: NonNull<Archetype>,
     },
     NewArchetypeNewTable {
-        new_archetype: *mut Archetype,
-        new_table: *mut Table,
+        new_archetype: NonNull<Archetype>,
+        new_table: NonNull<Table>,
     },
 }
 
@@ -546,7 +547,7 @@ impl<'w> BundleInserter<'w> {
     /// Creates a new [`BundleInserter`].
     ///
     /// # Safety
-    /// Caller must ensure that `bundle_id` exists in `world.bundles`
+    /// - Caller must ensure that `bundle_id` exists in `world.bundles`.
     #[inline]
     pub(crate) unsafe fn new_with_id(
         world: &'w mut World,
@@ -575,10 +576,10 @@ impl<'w> BundleInserter<'w> {
             let table_id = archetype.table_id();
             let table = &mut world.storages.tables[table_id];
             Self {
-                add_bundle,
-                archetype,
-                bundle_info,
-                table,
+                add_bundle: add_bundle.into(),
+                archetype: archetype.into(),
+                bundle_info: bundle_info.into(),
+                table: table.into(),
                 result: InsertBundleResult::SameArchetype,
                 change_tick,
                 world: world.as_unsafe_world_cell(),
@@ -598,24 +599,26 @@ impl<'w> BundleInserter<'w> {
             if table_id == new_table_id {
                 let table = &mut world.storages.tables[table_id];
                 Self {
-                    add_bundle,
-                    archetype,
-                    bundle_info,
-                    table,
-                    result: InsertBundleResult::NewArchetypeSameTable { new_archetype },
+                    add_bundle: add_bundle.into(),
+                    archetype: archetype.into(),
+                    bundle_info: bundle_info.into(),
+                    table: table.into(),
+                    result: InsertBundleResult::NewArchetypeSameTable {
+                        new_archetype: new_archetype.into(),
+                    },
                     change_tick,
                     world: world.as_unsafe_world_cell(),
                 }
             } else {
                 let (table, new_table) = world.storages.tables.get_2_mut(table_id, new_table_id);
                 Self {
-                    add_bundle,
-                    archetype,
-                    bundle_info,
-                    table,
+                    add_bundle: add_bundle.into(),
+                    archetype: archetype.into(),
+                    bundle_info: bundle_info.into(),
+                    table: table.into(),
                     result: InsertBundleResult::NewArchetypeNewTable {
-                        new_archetype,
-                        new_table,
+                        new_archetype: new_archetype.into(),
+                        new_table: new_table.into(),
                     },
                     change_tick,
                     world: world.as_unsafe_world_cell(),
@@ -623,6 +626,7 @@ impl<'w> BundleInserter<'w> {
             }
         }
     }
+
     /// # Safety
     /// `entity` must currently exist in the source archetype for this inserter. `location`
     /// must be `entity`'s location in the archetype. `T` must match this [`BundleInfo`]'s type
@@ -633,191 +637,174 @@ impl<'w> BundleInserter<'w> {
         location: EntityLocation,
         bundle: T,
     ) -> EntityLocation {
-        // SAFETY: We do not make any structural changes to the archetype graph through self.world so these pointers always remain valid
-        let trigger_hooks = |archetype: &Archetype, mut world: DeferredWorld| {
-            let bundle_info = &*self.bundle_info;
-            let add_bundle = &*self.add_bundle;
+        let bundle_info = self.bundle_info.as_ref();
+        let add_bundle = self.add_bundle.as_ref();
+        let table = self.table.as_mut();
+        let archetype = self.archetype.as_mut();
+
+        let (new_archetype, new_location) = match &mut self.result {
+            InsertBundleResult::SameArchetype => {
+                // SAFETY: Mutable references do not alias and will be dropped after this block
+                let sparse_sets = {
+                    let world = self.world.world_mut();
+                    &mut world.storages.sparse_sets
+                };
 
-            if archetype.has_on_add() {
-                world.trigger_on_add(
+                bundle_info.write_components(
+                    table,
+                    sparse_sets,
+                    add_bundle,
                     entity,
-                    bundle_info
-                        .iter_components()
-                        .zip(add_bundle.bundle_status.iter())
-                        .filter(|(_, &status)| status == ComponentStatus::Added)
-                        .map(|(id, _)| id),
+                    location.table_row,
+                    self.change_tick,
+                    bundle,
                 );
-            }
-            if archetype.has_on_insert() {
-                world.trigger_on_insert(entity, bundle_info.iter_components());
-            }
-        };
-        match &mut self.result {
-            InsertBundleResult::SameArchetype => {
-                {
-                    // SAFETY: Mutable references do not alias and will be dropped after this block
-                    let sparse_sets = {
-                        let world = self.world.world_mut();
-                        &mut world.storages.sparse_sets
-                    };
-                    let table = &mut *self.table;
-                    let bundle_info = &*self.bundle_info;
-                    let add_bundle = &*self.add_bundle;
-
-                    bundle_info.write_components(
-                        table,
-                        sparse_sets,
-                        add_bundle,
-                        entity,
-                        location.table_row,
-                        self.change_tick,
-                        bundle,
-                    );
-                }
-                // SAFETY: We have no outstanding mutable references to world as they were dropped
-                unsafe {
-                    let archetype = &*self.archetype;
-                    trigger_hooks(archetype, self.world.into_deferred());
-                }
-                location
+
+                (archetype, location)
             }
             InsertBundleResult::NewArchetypeSameTable { new_archetype } => {
-                let new_location = {
-                    // SAFETY: Mutable references do not alias and will be dropped after this block
-                    let (sparse_sets, entities) = {
-                        let world = self.world.world_mut();
-                        (&mut world.storages.sparse_sets, &mut world.entities)
-                    };
-                    let table = &mut *self.table;
-                    let archetype = &mut *self.archetype;
-                    let new_archetype = &mut **new_archetype;
-
-                    let result = archetype.swap_remove(location.archetype_row);
-                    if let Some(swapped_entity) = result.swapped_entity {
-                        let swapped_location =
-                            // SAFETY: If the swap was successful, swapped_entity must be valid.
-                            unsafe { entities.get(swapped_entity).debug_checked_unwrap() };
-                        entities.set(
-                            swapped_entity.index(),
-                            EntityLocation {
-                                archetype_id: swapped_location.archetype_id,
-                                archetype_row: location.archetype_row,
-                                table_id: swapped_location.table_id,
-                                table_row: swapped_location.table_row,
-                            },
-                        );
-                    }
-                    let new_location = new_archetype.allocate(entity, result.table_row);
-                    entities.set(entity.index(), new_location);
-
-                    let bundle_info = &*self.bundle_info;
-                    let add_bundle = &*self.add_bundle;
-                    bundle_info.write_components(
-                        table,
-                        sparse_sets,
-                        add_bundle,
-                        entity,
-                        result.table_row,
-                        self.change_tick,
-                        bundle,
-                    );
-                    new_location
+                let new_archetype = new_archetype.as_mut();
+
+                // SAFETY: Mutable references do not alias and will be dropped after this block
+                let (sparse_sets, entities) = {
+                    let world = self.world.world_mut();
+                    (&mut world.storages.sparse_sets, &mut world.entities)
                 };
 
-                // SAFETY: We have no outstanding mutable references to world as they were dropped
-                unsafe { trigger_hooks(&**new_archetype, self.world.into_deferred()) };
+                let result = archetype.swap_remove(location.archetype_row);
+                if let Some(swapped_entity) = result.swapped_entity {
+                    let swapped_location =
+                        // SAFETY: If the swap was successful, swapped_entity must be valid.
+                        unsafe { entities.get(swapped_entity).debug_checked_unwrap() };
+                    entities.set(
+                        swapped_entity.index(),
+                        EntityLocation {
+                            archetype_id: swapped_location.archetype_id,
+                            archetype_row: location.archetype_row,
+                            table_id: swapped_location.table_id,
+                            table_row: swapped_location.table_row,
+                        },
+                    );
+                }
+                let new_location = new_archetype.allocate(entity, result.table_row);
+                entities.set(entity.index(), new_location);
+                bundle_info.write_components(
+                    table,
+                    sparse_sets,
+                    add_bundle,
+                    entity,
+                    result.table_row,
+                    self.change_tick,
+                    bundle,
+                );
 
-                new_location
+                (new_archetype, new_location)
             }
             InsertBundleResult::NewArchetypeNewTable {
                 new_archetype,
                 new_table,
             } => {
-                let new_location = {
-                    // SAFETY: Mutable references do not alias and will be dropped after this block
-                    let (archetypes_ptr, sparse_sets, entities) = {
-                        let world = self.world.world_mut();
-                        let archetype_ptr: *mut Archetype =
-                            world.archetypes.archetypes.as_mut_ptr();
-                        (
-                            archetype_ptr,
-                            &mut world.storages.sparse_sets,
-                            &mut world.entities,
-                        )
-                    };
-                    let table = &mut *self.table;
-                    let new_table = &mut **new_table;
-                    let archetype = &mut *self.archetype;
-                    let new_archetype = &mut **new_archetype;
-                    let result = archetype.swap_remove(location.archetype_row);
-                    if let Some(swapped_entity) = result.swapped_entity {
-                        let swapped_location =
-                            // SAFETY: If the swap was successful, swapped_entity must be valid.
-                            unsafe { entities.get(swapped_entity).debug_checked_unwrap() };
-                        entities.set(
-                            swapped_entity.index(),
-                            EntityLocation {
-                                archetype_id: swapped_location.archetype_id,
-                                archetype_row: location.archetype_row,
-                                table_id: swapped_location.table_id,
-                                table_row: swapped_location.table_row,
-                            },
-                        );
-                    }
-                    // PERF: store "non bundle" components in edge, then just move those to avoid
-                    // redundant copies
-                    let move_result = table.move_to_superset_unchecked(result.table_row, new_table);
-                    let new_location = new_archetype.allocate(entity, move_result.new_row);
-                    entities.set(entity.index(), new_location);
-
-                    // if an entity was moved into this entity's table spot, update its table row
-                    if let Some(swapped_entity) = move_result.swapped_entity {
-                        let swapped_location =
-                            // SAFETY: If the swap was successful, swapped_entity must be valid.
-                            unsafe { entities.get(swapped_entity).debug_checked_unwrap() };
-                        let swapped_archetype = if archetype.id() == swapped_location.archetype_id {
-                            archetype
-                        } else if new_archetype.id() == swapped_location.archetype_id {
-                            new_archetype
-                        } else {
-                            // SAFETY: the only two borrowed archetypes are above and we just did collision checks
-                            &mut *archetypes_ptr.add(swapped_location.archetype_id.index())
-                        };
-
-                        entities.set(
-                            swapped_entity.index(),
-                            EntityLocation {
-                                archetype_id: swapped_location.archetype_id,
-                                archetype_row: swapped_location.archetype_row,
-                                table_id: swapped_location.table_id,
-                                table_row: result.table_row,
-                            },
-                        );
-                        swapped_archetype
+                let new_table = new_table.as_mut();
+                let new_archetype = new_archetype.as_mut();
+
+                // SAFETY: Mutable references do not alias and will be dropped after this block
+                let (archetypes_ptr, sparse_sets, entities) = {
+                    let world = self.world.world_mut();
+                    let archetype_ptr: *mut Archetype = world.archetypes.archetypes.as_mut_ptr();
+                    (
+                        archetype_ptr,
+                        &mut world.storages.sparse_sets,
+                        &mut world.entities,
+                    )
+                };
+                let result = archetype.swap_remove(location.archetype_row);
+                if let Some(swapped_entity) = result.swapped_entity {
+                    let swapped_location =
+                        // SAFETY: If the swap was successful, swapped_entity must be valid.
+                        unsafe { entities.get(swapped_entity).debug_checked_unwrap() };
+                    entities.set(
+                        swapped_entity.index(),
+                        EntityLocation {
+                            archetype_id: swapped_location.archetype_id,
+                            archetype_row: location.archetype_row,
+                            table_id: swapped_location.table_id,
+                            table_row: swapped_location.table_row,
+                        },
+                    );
+                }
+                // PERF: store "non bundle" components in edge, then just move those to avoid
+                // redundant copies
+                let move_result = table.move_to_superset_unchecked(result.table_row, new_table);
+                let new_location = new_archetype.allocate(entity, move_result.new_row);
+                entities.set(entity.index(), new_location);
+
+                // if an entity was moved into this entity's table spot, update its table row
+                if let Some(swapped_entity) = move_result.swapped_entity {
+                    let swapped_location =
+                        // SAFETY: If the swap was successful, swapped_entity must be valid.
+                        unsafe { entities.get(swapped_entity).debug_checked_unwrap() };
+
+                    entities.set(
+                        swapped_entity.index(),
+                        EntityLocation {
+                            archetype_id: swapped_location.archetype_id,
+                            archetype_row: swapped_location.archetype_row,
+                            table_id: swapped_location.table_id,
+                            table_row: result.table_row,
+                        },
+                    );
+
+                    if archetype.id() == swapped_location.archetype_id {
+                        archetype
+                            .set_entity_table_row(swapped_location.archetype_row, result.table_row);
+                    } else if new_archetype.id() == swapped_location.archetype_id {
+                        new_archetype
+                            .set_entity_table_row(swapped_location.archetype_row, result.table_row);
+                    } else {
+                        // SAFETY: the only two borrowed archetypes are above and we just did collision checks
+                        (*archetypes_ptr.add(swapped_location.archetype_id.index()))
                             .set_entity_table_row(swapped_location.archetype_row, result.table_row);
                     }
+                }
 
-                    let bundle_info = &*self.bundle_info;
-                    let add_bundle = &*self.add_bundle;
-                    bundle_info.write_components(
-                        new_table,
-                        sparse_sets,
-                        add_bundle,
-                        entity,
-                        move_result.new_row,
-                        self.change_tick,
-                        bundle,
-                    );
+                bundle_info.write_components(
+                    new_table,
+                    sparse_sets,
+                    add_bundle,
+                    entity,
+                    move_result.new_row,
+                    self.change_tick,
+                    bundle,
+                );
 
-                    new_location
-                };
+                (new_archetype, new_location)
+            }
+        };
 
-                // SAFETY: We have no outstanding mutable references to world as they were dropped
-                unsafe { trigger_hooks(&**new_archetype, self.world.into_deferred()) };
+        // SAFETY: We have no outstanding mutable references to world as they were dropped
+        let mut deferred_world = unsafe { self.world.into_deferred() };
 
-                new_location
+        if new_archetype.has_on_add() {
+            // SAFETY: All components in the bundle are guaranteed to exist in the World
+            // as they must be initialized before creating the BundleInfo.
+            unsafe {
+                deferred_world.trigger_on_add(
+                    entity,
+                    bundle_info
+                        .iter_components()
+                        .zip(add_bundle.bundle_status.iter())
+                        .filter(|(_, &status)| status == ComponentStatus::Added)
+                        .map(|(id, _)| id),
+                );
             }
         }
+        if new_archetype.has_on_insert() {
+            // SAFETY: All components in the bundle are guaranteed to exist in the World
+            // as they must be initialized before creating the BundleInfo.
+            unsafe { deferred_world.trigger_on_insert(entity, bundle_info.iter_components()) }
+        }
+
+        new_location
     }
 
     #[inline]
@@ -830,9 +817,9 @@ impl<'w> BundleInserter<'w> {
 // SAFETY: We have exclusive world access so our pointers can't be invalidated externally
 pub(crate) struct BundleSpawner<'w> {
     world: UnsafeWorldCell<'w>,
-    bundle_info: *const BundleInfo,
-    table: *mut Table,
-    archetype: *mut Archetype,
+    bundle_info: ConstNonNull<BundleInfo>,
+    table: NonNull<Table>,
+    archetype: NonNull<Archetype>,
     change_tick: Tick,
 }
 
@@ -866,9 +853,9 @@ impl<'w> BundleSpawner<'w> {
         let archetype = &mut world.archetypes[new_archetype_id];
         let table = &mut world.storages.tables[archetype.table_id()];
         Self {
-            bundle_info,
-            table,
-            archetype,
+            bundle_info: bundle_info.into(),
+            table: table.into(),
+            archetype: archetype.into(),
             change_tick,
             world: world.as_unsafe_world_cell(),
         }
@@ -877,7 +864,7 @@ impl<'w> BundleSpawner<'w> {
     #[inline]
     pub fn reserve_storage(&mut self, additional: usize) {
         // SAFETY: There are no outstanding world references
-        let (archetype, table) = unsafe { (&mut *self.archetype, &mut *self.table) };
+        let (archetype, table) = unsafe { (self.archetype.as_mut(), self.table.as_mut()) };
         archetype.reserve(additional);
         table.reserve(additional);
     }
@@ -890,6 +877,10 @@ impl<'w> BundleSpawner<'w> {
         entity: Entity,
         bundle: T,
     ) -> EntityLocation {
+        let table = self.table.as_mut();
+        let archetype = self.archetype.as_mut();
+        let bundle_info = self.bundle_info.as_ref();
+
         // SAFETY: We do not make any structural changes to the archetype graph through self.world so this pointer always remain valid
         let location = {
             // SAFETY: Mutable references do not alias and will be dropped after this block
@@ -897,11 +888,8 @@ impl<'w> BundleSpawner<'w> {
                 let world = self.world.world_mut();
                 (&mut world.storages.sparse_sets, &mut world.entities)
             };
-            let table = &mut *self.table;
-            let archetype = &mut *self.archetype;
             let table_row = table.allocate(entity);
             let location = archetype.allocate(entity, table_row);
-            let bundle_info = &*self.bundle_info;
             bundle_info.write_components(
                 table,
                 sparse_sets,
@@ -916,16 +904,16 @@ impl<'w> BundleSpawner<'w> {
         };
 
         // SAFETY: We have no outstanding mutable references to world as they were dropped
-        unsafe {
-            let archetype = &*self.archetype;
-            let bundle_info = &*self.bundle_info;
-            let mut world = self.world.into_deferred();
-            if archetype.has_on_add() {
-                world.trigger_on_add(entity, bundle_info.iter_components());
-            }
-            if archetype.has_on_insert() {
-                world.trigger_on_insert(entity, bundle_info.iter_components());
-            }
+        let mut deferred_world = unsafe { self.world.into_deferred() };
+        if archetype.has_on_add() {
+            // SAFETY: All components in the bundle are guaranteed to exist in the World
+            // as they must be initialized before creating the BundleInfo.
+            unsafe { deferred_world.trigger_on_add(entity, bundle_info.iter_components()) };
+        }
+        if archetype.has_on_insert() {
+            // SAFETY: All components in the bundle are guaranteed to exist in the World
+            // as they must be initialized before creating the BundleInfo.
+            unsafe { deferred_world.trigger_on_insert(entity, bundle_info.iter_components()) };
         }
 
         location
diff --git a/crates/bevy_ecs/src/component.rs b/crates/bevy_ecs/src/component.rs
index a65599bf7a043..808fb148b5f73 100644
--- a/crates/bevy_ecs/src/component.rs
+++ b/crates/bevy_ecs/src/component.rs
@@ -151,41 +151,11 @@ use std::{
 /// [`SyncCell`]: bevy_utils::synccell::SyncCell
 /// [`Exclusive`]: https://doc.rust-lang.org/nightly/std/sync/struct.Exclusive.html
 pub trait Component: Send + Sync + 'static {
-    /// A marker type indicating the storage type used for this component.
-    /// This must be either [`TableStorage`] or [`SparseStorage`].
-    type Storage: ComponentStorage;
-
-    /// Called when registering this component, allowing mutable access to it's [`ComponentInfo`].
-    /// This is currently used for registering hooks.
-    fn init_component_info(_info: &mut ComponentInfo) {}
-}
-
-/// Marker type for components stored in a [`Table`](crate::storage::Table).
-pub struct TableStorage;
-
-/// Marker type for components stored in a [`ComponentSparseSet`](crate::storage::ComponentSparseSet).
-pub struct SparseStorage;
-
-/// Types used to specify the storage strategy for a component.
-///
-/// This trait is implemented for [`TableStorage`] and [`SparseStorage`].
-/// Custom implementations are forbidden.
-pub trait ComponentStorage: sealed::Sealed {
-    /// A value indicating the storage strategy specified by this type.
+    /// A constant indicating the storage type used for this component.
     const STORAGE_TYPE: StorageType;
-}
-
-impl ComponentStorage for TableStorage {
-    const STORAGE_TYPE: StorageType = StorageType::Table;
-}
-impl ComponentStorage for SparseStorage {
-    const STORAGE_TYPE: StorageType = StorageType::SparseSet;
-}
 
-mod sealed {
-    pub trait Sealed {}
-    impl Sealed for super::TableStorage {}
-    impl Sealed for super::SparseStorage {}
+    /// Called when registering this component, allowing mutable access to it's [`ComponentHooks`].
+    fn register_component_hooks(_hooks: &mut ComponentHooks) {}
 }
 
 /// The storage used for a specific component type.
@@ -222,7 +192,8 @@ pub struct ComponentHooks {
 
 impl ComponentHooks {
     /// Register a [`ComponentHook`] that will be run when this component is added to an entity.
-    /// An `on_add` hook will always be followed by `on_insert`.
+    /// An `on_add` hook will always run before `on_insert` hooks. Spawning an entity counts as
+    /// adding all of it's components.
     ///
     /// Will panic if the component already has an `on_add` hook
     pub fn on_add(&mut self, hook: ComponentHook) -> &mut Self {
@@ -230,9 +201,9 @@ impl ComponentHooks {
             .expect("Component id: {:?}, already has an on_add hook")
     }
 
-    /// Register a [`ComponentHook`] that will be run when this component is added or set by `.insert`
-    /// An `on_insert` hook will run even if the entity already has the component unlike `on_add`,
-    /// `on_insert` also always runs after any `on_add` hooks.
+    /// Register a [`ComponentHook`] that will be run when this component is added (with `.insert`)
+    /// or replaced. The hook won't run if the component is already present and is only mutated.
+    /// An `on_insert` hook always runs after any `on_add` hooks (if the entity didn't already have the component).
     ///
     /// Will panic if the component already has an `on_insert` hook
     pub fn on_insert(&mut self, hook: ComponentHook) -> &mut Self {
@@ -472,7 +443,7 @@ impl ComponentDescriptor {
     pub fn new<T: Component>() -> Self {
         Self {
             name: Cow::Borrowed(std::any::type_name::<T>()),
-            storage_type: T::Storage::STORAGE_TYPE,
+            storage_type: T::STORAGE_TYPE,
             is_send_and_sync: true,
             type_id: Some(TypeId::of::<T>()),
             layout: Layout::new::<T>(),
@@ -503,7 +474,7 @@ impl ComponentDescriptor {
 
     /// Create a new `ComponentDescriptor` for a resource.
     ///
-    /// The [`StorageType`] for resources is always [`TableStorage`].
+    /// The [`StorageType`] for resources is always [`StorageType::Table`].
     pub fn new_resource<T: Resource>() -> Self {
         Self {
             name: Cow::Borrowed(std::any::type_name::<T>()),
@@ -580,7 +551,7 @@ impl Components {
                 storages,
                 ComponentDescriptor::new::<T>(),
             );
-            T::init_component_info(&mut components[index.index()]);
+            T::register_component_hooks(&mut components[index.index()].hooks);
             index
         })
     }
diff --git a/crates/bevy_ecs/src/entity/mod.rs b/crates/bevy_ecs/src/entity/mod.rs
index 3f397cf3dd5f5..9dbc26ac1a8cc 100644
--- a/crates/bevy_ecs/src/entity/mod.rs
+++ b/crates/bevy_ecs/src/entity/mod.rs
@@ -81,6 +81,17 @@ type IdCursor = isize;
 ///
 /// [generational index]: https://lucassardois.medium.com/generational-indices-guide-8e3c5f7fd594
 ///
+/// # Stability warning
+/// For all intents and purposes, `Entity` should be treated as an opaque identifier. The internal bit
+/// representation is liable to change from release to release as are the behaviors or performance
+/// characteristics of any of its trait implementations (i.e. `Ord`, `Hash`, etc.). This means that changes in
+/// `Entity`'s representation, though made readable through various functions on the type, are not considered
+/// breaking changes under [SemVer].
+///
+/// In particular, directly serializing with `Serialize` and `Deserialize` make zero guarantee of long
+/// term wire format compatibility. Changes in behavior will cause serialized `Entity` values persisted
+/// to long term storage (i.e. disk, databases, etc.) will fail to deserialize upon being updated.
+///
 /// # Usage
 ///
 /// This data type is returned by iterating a `Query` that has `Entity` as part of its query fetch type parameter ([learn more]).
@@ -127,6 +138,7 @@ type IdCursor = isize;
 /// [`EntityCommands`]: crate::system::EntityCommands
 /// [`Query::get`]: crate::system::Query::get
 /// [`World`]: crate::world::World
+/// [SemVer]: https://semver.org/
 #[derive(Clone, Copy)]
 #[cfg_attr(feature = "bevy_reflect", derive(Reflect))]
 #[cfg_attr(
diff --git a/crates/bevy_ecs/src/lib.rs b/crates/bevy_ecs/src/lib.rs
index 1f3464997bb04..4f2e00f5f747b 100644
--- a/crates/bevy_ecs/src/lib.rs
+++ b/crates/bevy_ecs/src/lib.rs
@@ -52,8 +52,6 @@ pub mod prelude {
     };
 }
 
-pub use bevy_utils::all_tuples;
-
 #[cfg(test)]
 mod tests {
     use crate as bevy_ecs;
diff --git a/crates/bevy_ecs/src/query/builder.rs b/crates/bevy_ecs/src/query/builder.rs
index 160999e9e84b4..b19c5a6b516d8 100644
--- a/crates/bevy_ecs/src/query/builder.rs
+++ b/crates/bevy_ecs/src/query/builder.rs
@@ -204,7 +204,7 @@ impl<'w, D: QueryData, F: QueryFilter> QueryBuilder<'w, D, F> {
         self
     }
 
-    /// Returns a reference to the the [`FilteredAccess`] that will be provided to the built [`Query`].
+    /// Returns a reference to the [`FilteredAccess`] that will be provided to the built [`Query`].
     pub fn access(&self) -> &FilteredAccess<ComponentId> {
         &self.access
     }
diff --git a/crates/bevy_ecs/src/query/fetch.rs b/crates/bevy_ecs/src/query/fetch.rs
index 4fb9f8a111367..7f249f4a36660 100644
--- a/crates/bevy_ecs/src/query/fetch.rs
+++ b/crates/bevy_ecs/src/query/fetch.rs
@@ -1,7 +1,7 @@
 use crate::{
     archetype::Archetype,
     change_detection::{Ticks, TicksMut},
-    component::{Component, ComponentId, ComponentStorage, StorageType, Tick},
+    component::{Component, ComponentId, StorageType, Tick},
     entity::Entity,
     query::{Access, DebugCheckedUnwrap, FilteredAccess, WorldQuery},
     storage::{ComponentSparseSet, Table, TableRow},
@@ -711,9 +711,9 @@ unsafe impl<'a> QueryData for FilteredEntityMut<'a> {
 
 #[doc(hidden)]
 pub struct ReadFetch<'w, T> {
-    // T::Storage = TableStorage
+    // T::STORAGE_TYPE = StorageType::Table
     table_components: Option<ThinSlicePtr<'w, UnsafeCell<T>>>,
-    // T::Storage = SparseStorage
+    // T::STORAGE_TYPE = StorageType::SparseSet
     sparse_set: Option<&'w ComponentSparseSet>,
 }
 
@@ -747,7 +747,7 @@ unsafe impl<T: Component> WorldQuery for &T {
     ) -> ReadFetch<'w, T> {
         ReadFetch {
             table_components: None,
-            sparse_set: (T::Storage::STORAGE_TYPE == StorageType::SparseSet).then(|| {
+            sparse_set: (T::STORAGE_TYPE == StorageType::SparseSet).then(|| {
                 // SAFETY: The underlying type associated with `component_id` is `T`,
                 // which we are allowed to access since we registered it in `update_archetype_component_access`.
                 // Note that we do not actually access any components in this function, we just get a shared
@@ -764,7 +764,7 @@ unsafe impl<T: Component> WorldQuery for &T {
     }
 
     const IS_DENSE: bool = {
-        match T::Storage::STORAGE_TYPE {
+        match T::STORAGE_TYPE {
             StorageType::Table => true,
             StorageType::SparseSet => false,
         }
@@ -806,7 +806,7 @@ unsafe impl<T: Component> WorldQuery for &T {
         entity: Entity,
         table_row: TableRow,
     ) -> Self::Item<'w> {
-        match T::Storage::STORAGE_TYPE {
+        match T::STORAGE_TYPE {
             StorageType::Table => {
                 // SAFETY: STORAGE_TYPE = Table
                 let table = unsafe { fetch.table_components.debug_checked_unwrap() };
@@ -862,13 +862,13 @@ unsafe impl<T: Component> ReadOnlyQueryData for &T {}
 
 #[doc(hidden)]
 pub struct RefFetch<'w, T> {
-    // T::Storage = TableStorage
+    // T::STORAGE_TYPE = StorageType::Table
     table_data: Option<(
         ThinSlicePtr<'w, UnsafeCell<T>>,
         ThinSlicePtr<'w, UnsafeCell<Tick>>,
         ThinSlicePtr<'w, UnsafeCell<Tick>>,
     )>,
-    // T::Storage = SparseStorage
+    // T::STORAGE_TYPE = StorageType::SparseSet
     sparse_set: Option<&'w ComponentSparseSet>,
 
     last_run: Tick,
@@ -905,7 +905,7 @@ unsafe impl<'__w, T: Component> WorldQuery for Ref<'__w, T> {
     ) -> RefFetch<'w, T> {
         RefFetch {
             table_data: None,
-            sparse_set: (T::Storage::STORAGE_TYPE == StorageType::SparseSet).then(|| {
+            sparse_set: (T::STORAGE_TYPE == StorageType::SparseSet).then(|| {
                 // SAFETY: The underlying type associated with `component_id` is `T`,
                 // which we are allowed to access since we registered it in `update_archetype_component_access`.
                 // Note that we do not actually access any components in this function, we just get a shared
@@ -924,7 +924,7 @@ unsafe impl<'__w, T: Component> WorldQuery for Ref<'__w, T> {
     }
 
     const IS_DENSE: bool = {
-        match T::Storage::STORAGE_TYPE {
+        match T::STORAGE_TYPE {
             StorageType::Table => true,
             StorageType::SparseSet => false,
         }
@@ -965,7 +965,7 @@ unsafe impl<'__w, T: Component> WorldQuery for Ref<'__w, T> {
         entity: Entity,
         table_row: TableRow,
     ) -> Self::Item<'w> {
-        match T::Storage::STORAGE_TYPE {
+        match T::STORAGE_TYPE {
             StorageType::Table => {
                 // SAFETY: STORAGE_TYPE = Table
                 let (table_components, added_ticks, changed_ticks) =
@@ -1045,13 +1045,13 @@ unsafe impl<'__w, T: Component> ReadOnlyQueryData for Ref<'__w, T> {}
 
 #[doc(hidden)]
 pub struct WriteFetch<'w, T> {
-    // T::Storage = TableStorage
+    // T::STORAGE_TYPE = StorageType::Table
     table_data: Option<(
         ThinSlicePtr<'w, UnsafeCell<T>>,
         ThinSlicePtr<'w, UnsafeCell<Tick>>,
         ThinSlicePtr<'w, UnsafeCell<Tick>>,
     )>,
-    // T::Storage = SparseStorage
+    // T::STORAGE_TYPE = StorageType::SparseSet
     sparse_set: Option<&'w ComponentSparseSet>,
 
     last_run: Tick,
@@ -1088,7 +1088,7 @@ unsafe impl<'__w, T: Component> WorldQuery for &'__w mut T {
     ) -> WriteFetch<'w, T> {
         WriteFetch {
             table_data: None,
-            sparse_set: (T::Storage::STORAGE_TYPE == StorageType::SparseSet).then(|| {
+            sparse_set: (T::STORAGE_TYPE == StorageType::SparseSet).then(|| {
                 // SAFETY: The underlying type associated with `component_id` is `T`,
                 // which we are allowed to access since we registered it in `update_archetype_component_access`.
                 // Note that we do not actually access any components in this function, we just get a shared
@@ -1107,7 +1107,7 @@ unsafe impl<'__w, T: Component> WorldQuery for &'__w mut T {
     }
 
     const IS_DENSE: bool = {
-        match T::Storage::STORAGE_TYPE {
+        match T::STORAGE_TYPE {
             StorageType::Table => true,
             StorageType::SparseSet => false,
         }
@@ -1148,7 +1148,7 @@ unsafe impl<'__w, T: Component> WorldQuery for &'__w mut T {
         entity: Entity,
         table_row: TableRow,
     ) -> Self::Item<'w> {
-        match T::Storage::STORAGE_TYPE {
+        match T::STORAGE_TYPE {
             StorageType::Table => {
                 // SAFETY: STORAGE_TYPE = Table
                 let (table_components, added_ticks, changed_ticks) =
@@ -1433,7 +1433,7 @@ unsafe impl<T: Component> WorldQuery for Has<T> {
     }
 
     const IS_DENSE: bool = {
-        match T::Storage::STORAGE_TYPE {
+        match T::STORAGE_TYPE {
             StorageType::Table => true,
             StorageType::SparseSet => false,
         }
diff --git a/crates/bevy_ecs/src/query/filter.rs b/crates/bevy_ecs/src/query/filter.rs
index e88293e227120..cb581b58b82d6 100644
--- a/crates/bevy_ecs/src/query/filter.rs
+++ b/crates/bevy_ecs/src/query/filter.rs
@@ -1,6 +1,6 @@
 use crate::{
     archetype::Archetype,
-    component::{Component, ComponentId, ComponentStorage, StorageType, Tick},
+    component::{Component, ComponentId, StorageType, Tick},
     entity::Entity,
     query::{DebugCheckedUnwrap, FilteredAccess, WorldQuery},
     storage::{Column, ComponentSparseSet, Table, TableRow},
@@ -142,7 +142,7 @@ unsafe impl<T: Component> WorldQuery for With<T> {
     }
 
     const IS_DENSE: bool = {
-        match T::Storage::STORAGE_TYPE {
+        match T::STORAGE_TYPE {
             StorageType::Table => true,
             StorageType::SparseSet => false,
         }
@@ -250,7 +250,7 @@ unsafe impl<T: Component> WorldQuery for Without<T> {
     }
 
     const IS_DENSE: bool = {
-        match T::Storage::STORAGE_TYPE {
+        match T::STORAGE_TYPE {
             StorageType::Table => true,
             StorageType::SparseSet => false,
         }
@@ -604,7 +604,7 @@ unsafe impl<T: Component> WorldQuery for Added<T> {
     ) -> Self::Fetch<'w> {
         Self::Fetch::<'w> {
             table_ticks: None,
-            sparse_set: (T::Storage::STORAGE_TYPE == StorageType::SparseSet)
+            sparse_set: (T::STORAGE_TYPE == StorageType::SparseSet)
                 .then(|| world.storages().sparse_sets.get(id).debug_checked_unwrap()),
             last_run,
             this_run,
@@ -612,7 +612,7 @@ unsafe impl<T: Component> WorldQuery for Added<T> {
     }
 
     const IS_DENSE: bool = {
-        match T::Storage::STORAGE_TYPE {
+        match T::STORAGE_TYPE {
             StorageType::Table => true,
             StorageType::SparseSet => false,
         }
@@ -651,7 +651,7 @@ unsafe impl<T: Component> WorldQuery for Added<T> {
         entity: Entity,
         table_row: TableRow,
     ) -> Self::Item<'w> {
-        match T::Storage::STORAGE_TYPE {
+        match T::STORAGE_TYPE {
             StorageType::Table => {
                 // SAFETY: STORAGE_TYPE = Table
                 let table = unsafe { fetch.table_ticks.debug_checked_unwrap() };
@@ -813,7 +813,7 @@ unsafe impl<T: Component> WorldQuery for Changed<T> {
     ) -> Self::Fetch<'w> {
         Self::Fetch::<'w> {
             table_ticks: None,
-            sparse_set: (T::Storage::STORAGE_TYPE == StorageType::SparseSet)
+            sparse_set: (T::STORAGE_TYPE == StorageType::SparseSet)
                 .then(|| world.storages().sparse_sets.get(id).debug_checked_unwrap()),
             last_run,
             this_run,
@@ -821,7 +821,7 @@ unsafe impl<T: Component> WorldQuery for Changed<T> {
     }
 
     const IS_DENSE: bool = {
-        match T::Storage::STORAGE_TYPE {
+        match T::STORAGE_TYPE {
             StorageType::Table => true,
             StorageType::SparseSet => false,
         }
@@ -860,7 +860,7 @@ unsafe impl<T: Component> WorldQuery for Changed<T> {
         entity: Entity,
         table_row: TableRow,
     ) -> Self::Item<'w> {
-        match T::Storage::STORAGE_TYPE {
+        match T::STORAGE_TYPE {
             StorageType::Table => {
                 // SAFETY: STORAGE_TYPE = Table
                 let table = unsafe { fetch.table_ticks.debug_checked_unwrap() };
diff --git a/crates/bevy_ecs/src/reflect/entity_commands.rs b/crates/bevy_ecs/src/reflect/entity_commands.rs
index 7f69130d801c3..8545b346bd15a 100644
--- a/crates/bevy_ecs/src/reflect/entity_commands.rs
+++ b/crates/bevy_ecs/src/reflect/entity_commands.rs
@@ -1,6 +1,7 @@
 use crate::prelude::Mut;
 use crate::reflect::AppTypeRegistry;
-use crate::system::{Command, EntityCommands, Resource};
+use crate::system::{EntityCommands, Resource};
+use crate::world::Command;
 use crate::{entity::Entity, reflect::ReflectComponent, world::World};
 use bevy_reflect::{Reflect, TypeRegistry};
 use std::borrow::Cow;
diff --git a/crates/bevy_ecs/src/schedule/executor/mod.rs b/crates/bevy_ecs/src/schedule/executor/mod.rs
index b293506342ccc..cc61c6969936c 100644
--- a/crates/bevy_ecs/src/schedule/executor/mod.rs
+++ b/crates/bevy_ecs/src/schedule/executor/mod.rs
@@ -93,9 +93,20 @@ impl SystemSchedule {
 }
 
 /// Instructs the executor to call [`System::apply_deferred`](crate::system::System::apply_deferred)
-/// on the systems that have run but not applied their [`Deferred`](crate::system::Deferred) system parameters (like [`Commands`](crate::prelude::Commands)) or other system buffers.
+/// on the systems that have run but not applied their [`Deferred`](crate::system::Deferred) system parameters
+/// (like [`Commands`](crate::prelude::Commands)) or other system buffers.
 ///
-/// **Notes**
+/// ## Scheduling
+///
+/// `apply_deferred` systems are scheduled *by default*
+/// - later in the same schedule run (for example, if a system with `Commands` param
+///   is scheduled in `Update`, all the changes will be visible in `PostUpdate`)
+/// - between systems with dependencies if the dependency
+///   [has deferred buffers](crate::system::System::has_deferred)
+///   (if system `bar` directly or indirectly depends on `foo`, and `foo` uses `Commands` param,
+///   changes to the world in `foo` will be visible in `bar`)
+///
+/// ## Notes
 /// - This function (currently) does nothing if it's called manually or wrapped inside a [`PipeSystem`](crate::system::PipeSystem).
 /// - Modifying a [`Schedule`](super::Schedule) may change the order buffers are applied.
 #[doc(alias = "apply_system_buffers")]
diff --git a/crates/bevy_ecs/src/schedule/graph_utils.rs b/crates/bevy_ecs/src/schedule/graph_utils.rs
index 04fb9a9ddda92..b5d10b08e1e2a 100644
--- a/crates/bevy_ecs/src/schedule/graph_utils.rs
+++ b/crates/bevy_ecs/src/schedule/graph_utils.rs
@@ -1,10 +1,8 @@
 use std::fmt::Debug;
 
-use bevy_utils::{
-    petgraph::{algo::TarjanScc, graphmap::NodeTrait, prelude::*},
-    HashMap, HashSet,
-};
+use bevy_utils::{HashMap, HashSet};
 use fixedbitset::FixedBitSet;
+use petgraph::{algo::TarjanScc, graphmap::NodeTrait, prelude::*};
 
 use crate::schedule::set::*;
 
diff --git a/crates/bevy_ecs/src/schedule/schedule.rs b/crates/bevy_ecs/src/schedule/schedule.rs
index 2244fffd09931..408fae9b1d615 100644
--- a/crates/bevy_ecs/src/schedule/schedule.rs
+++ b/crates/bevy_ecs/src/schedule/schedule.rs
@@ -7,13 +7,12 @@ use std::{
 use bevy_utils::tracing::info_span;
 use bevy_utils::{default, tracing::info};
 use bevy_utils::{
-    petgraph::{algo::TarjanScc, prelude::*},
-    thiserror::Error,
     tracing::{error, warn},
     HashMap, HashSet,
 };
-
 use fixedbitset::FixedBitSet;
+use petgraph::{algo::TarjanScc, prelude::*};
+use thiserror::Error;
 
 use crate::{
     self as bevy_ecs,
diff --git a/crates/bevy_ecs/src/schedule/stepping.rs b/crates/bevy_ecs/src/schedule/stepping.rs
index b82fd6da76468..eb8b4699eb2b6 100644
--- a/crates/bevy_ecs/src/schedule/stepping.rs
+++ b/crates/bevy_ecs/src/schedule/stepping.rs
@@ -7,10 +7,10 @@ use crate::{
     system::{IntoSystem, ResMut, Resource},
 };
 use bevy_utils::{
-    thiserror::Error,
     tracing::{error, info, warn},
     TypeIdMap,
 };
+use thiserror::Error;
 
 #[cfg(test)]
 use bevy_utils::tracing::debug;
diff --git a/crates/bevy_ecs/src/storage/sparse_set.rs b/crates/bevy_ecs/src/storage/sparse_set.rs
index dfb03f88681d2..dffdb71db961e 100644
--- a/crates/bevy_ecs/src/storage/sparse_set.rs
+++ b/crates/bevy_ecs/src/storage/sparse_set.rs
@@ -4,6 +4,7 @@ use crate::{
     storage::{Column, TableRow},
 };
 use bevy_ptr::{OwningPtr, Ptr};
+use nonmax::NonMaxUsize;
 use std::{cell::UnsafeCell, hash::Hash, marker::PhantomData};
 
 type EntityIndex = u32;
@@ -335,7 +336,7 @@ impl ComponentSparseSet {
 pub struct SparseSet<I, V: 'static> {
     dense: Vec<V>,
     indices: Vec<I>,
-    sparse: SparseArray<I, usize>,
+    sparse: SparseArray<I, NonMaxUsize>,
 }
 
 /// A space-optimized version of [`SparseSet`] that cannot be changed
@@ -344,7 +345,7 @@ pub struct SparseSet<I, V: 'static> {
 pub(crate) struct ImmutableSparseSet<I, V: 'static> {
     dense: Box<[V]>,
     indices: Box<[I]>,
-    sparse: ImmutableSparseArray<I, usize>,
+    sparse: ImmutableSparseArray<I, NonMaxUsize>,
 }
 
 macro_rules! impl_sparse_set {
@@ -368,7 +369,7 @@ macro_rules! impl_sparse_set {
             pub fn get(&self, index: I) -> Option<&V> {
                 self.sparse.get(index).map(|dense_index| {
                     // SAFETY: if the sparse index points to something in the dense vec, it exists
-                    unsafe { self.dense.get_unchecked(*dense_index) }
+                    unsafe { self.dense.get_unchecked(dense_index.get()) }
                 })
             }
 
@@ -379,7 +380,7 @@ macro_rules! impl_sparse_set {
                 let dense = &mut self.dense;
                 self.sparse.get(index).map(move |dense_index| {
                     // SAFETY: if the sparse index points to something in the dense vec, it exists
-                    unsafe { dense.get_unchecked_mut(*dense_index) }
+                    unsafe { dense.get_unchecked_mut(dense_index.get()) }
                 })
             }
 
@@ -454,10 +455,11 @@ impl<I: SparseSetIndex, V> SparseSet<I, V> {
         if let Some(dense_index) = self.sparse.get(index.clone()).cloned() {
             // SAFETY: dense indices stored in self.sparse always exist
             unsafe {
-                *self.dense.get_unchecked_mut(dense_index) = value;
+                *self.dense.get_unchecked_mut(dense_index.get()) = value;
             }
         } else {
-            self.sparse.insert(index.clone(), self.dense.len());
+            self.sparse
+                .insert(index.clone(), NonMaxUsize::new(self.dense.len()).unwrap());
             self.indices.push(index);
             self.dense.push(value);
         }
@@ -468,11 +470,12 @@ impl<I: SparseSetIndex, V> SparseSet<I, V> {
     pub fn get_or_insert_with(&mut self, index: I, func: impl FnOnce() -> V) -> &mut V {
         if let Some(dense_index) = self.sparse.get(index.clone()).cloned() {
             // SAFETY: dense indices stored in self.sparse always exist
-            unsafe { self.dense.get_unchecked_mut(dense_index) }
+            unsafe { self.dense.get_unchecked_mut(dense_index.get()) }
         } else {
             let value = func();
             let dense_index = self.dense.len();
-            self.sparse.insert(index.clone(), dense_index);
+            self.sparse
+                .insert(index.clone(), NonMaxUsize::new(dense_index).unwrap());
             self.indices.push(index);
             self.dense.push(value);
             // SAFETY: dense index was just populated above
@@ -491,11 +494,12 @@ impl<I: SparseSetIndex, V> SparseSet<I, V> {
     /// Returns `None` if `index` does not have a value in the sparse set.
     pub fn remove(&mut self, index: I) -> Option<V> {
         self.sparse.remove(index).map(|dense_index| {
-            let is_last = dense_index == self.dense.len() - 1;
-            let value = self.dense.swap_remove(dense_index);
-            self.indices.swap_remove(dense_index);
+            let index = dense_index.get();
+            let is_last = index == self.dense.len() - 1;
+            let value = self.dense.swap_remove(index);
+            self.indices.swap_remove(index);
             if !is_last {
-                let swapped_index = self.indices[dense_index].clone();
+                let swapped_index = self.indices[index].clone();
                 *self.sparse.get_mut(swapped_index).unwrap() = dense_index;
             }
             value
diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 65fa06ed7c6a7..a8d7fe9cc3116 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -1,66 +1,23 @@
-mod command_queue;
 mod parallel_scope;
 
+use super::{Deferred, Resource};
 use crate::{
     self as bevy_ecs,
     bundle::Bundle,
     entity::{Entities, Entity},
     system::{RunSystemWithInput, SystemId},
-    world::{EntityWorldMut, FromWorld, World},
+    world::{Command, CommandQueue, EntityWorldMut, FromWorld, World},
 };
 use bevy_ecs_macros::SystemParam;
 use bevy_utils::tracing::{error, info};
-pub use command_queue::CommandQueue;
 pub use parallel_scope::*;
 use std::marker::PhantomData;
 
-use super::{Deferred, Resource, SystemBuffer, SystemMeta};
-
-/// A [`World`] mutation.
-///
-/// Should be used with [`Commands::add`].
-///
-/// # Usage
-///
-/// ```
-/// # use bevy_ecs::prelude::*;
-/// # use bevy_ecs::system::Command;
-/// // Our world resource
-/// #[derive(Resource, Default)]
-/// struct Counter(u64);
-///
-/// // Our custom command
-/// struct AddToCounter(u64);
-///
-/// impl Command for AddToCounter {
-///     fn apply(self, world: &mut World) {
-///         let mut counter = world.get_resource_or_insert_with(Counter::default);
-///         counter.0 += self.0;
-///     }
-/// }
-///
-/// fn some_system(mut commands: Commands) {
-///     commands.add(AddToCounter(42));
-/// }
-/// ```
-pub trait Command: Send + 'static {
-    /// Applies this command, causing it to mutate the provided `world`.
-    ///
-    /// This method is used to define what a command "does" when it is ultimately applied.
-    /// Because this method takes `self`, you can store data or settings on the type that implements this trait.
-    /// This data is set by the system or other source of the command, and then ultimately read in this method.
-    fn apply(self, world: &mut World);
-}
-
 /// A [`Command`] queue to perform structural changes to the [`World`].
 ///
 /// Since each command requires exclusive access to the `World`,
 /// all queued commands are automatically applied in sequence
-/// when the [`apply_deferred`] system runs.
-///
-/// The command queue of an individual system can also be manually applied
-/// by calling [`System::apply_deferred`].
-/// Similarly, the command queue of a schedule can be manually applied via [`Schedule::apply_deferred`].
+/// when the `apply_deferred` system runs (see [`apply_deferred`] documentation for more details).
 ///
 /// Each command can be used to modify the [`World`] in arbitrary ways:
 /// * spawning or despawning entities
@@ -106,24 +63,13 @@ pub trait Command: Send + 'static {
 /// # }
 /// ```
 ///
-/// [`System::apply_deferred`]: crate::system::System::apply_deferred
 /// [`apply_deferred`]: crate::schedule::apply_deferred
-/// [`Schedule::apply_deferred`]: crate::schedule::Schedule::apply_deferred
 #[derive(SystemParam)]
 pub struct Commands<'w, 's> {
     queue: Deferred<'s, CommandQueue>,
     entities: &'w Entities,
 }
 
-impl SystemBuffer for CommandQueue {
-    #[inline]
-    fn apply(&mut self, _system_meta: &SystemMeta, world: &mut World) {
-        #[cfg(feature = "trace")]
-        let _span_guard = _system_meta.commands_span.enter();
-        self.apply(world);
-    }
-}
-
 impl<'w, 's> Commands<'w, 's> {
     /// Returns a new `Commands` instance from a [`CommandQueue`] and a [`World`].
     ///
@@ -581,7 +527,7 @@ impl<'w, 's> Commands<'w, 's> {
     /// # Example
     ///
     /// ```
-    /// # use bevy_ecs::{system::Command, prelude::*};
+    /// # use bevy_ecs::{world::Command, prelude::*};
     /// #[derive(Resource, Default)]
     /// struct Counter(u64);
     ///
@@ -1138,8 +1084,8 @@ mod tests {
     use crate::{
         self as bevy_ecs,
         component::Component,
-        system::{CommandQueue, Commands, Resource},
-        world::World,
+        system::{Commands, Resource},
+        world::{CommandQueue, World},
     };
     use std::sync::{
         atomic::{AtomicUsize, Ordering},
diff --git a/crates/bevy_ecs/src/system/system_param.rs b/crates/bevy_ecs/src/system/system_param.rs
index e5b3016f5c222..f9ecc9aaf62d6 100644
--- a/crates/bevy_ecs/src/system/system_param.rs
+++ b/crates/bevy_ecs/src/system/system_param.rs
@@ -442,7 +442,9 @@ unsafe impl<'a, T: Resource> SystemParam for Res<'a, T> {
     type Item<'w, 's> = Res<'w, T>;
 
     fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State {
-        let component_id = world.initialize_resource::<T>();
+        let component_id = world.components.init_resource::<T>();
+        world.initialize_resource_internal(component_id);
+
         let combined_access = system_meta.component_access_set.combined_access();
         assert!(
             !combined_access.has_write(component_id),
@@ -532,7 +534,9 @@ unsafe impl<'a, T: Resource> SystemParam for ResMut<'a, T> {
     type Item<'w, 's> = ResMut<'w, T>;
 
     fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State {
-        let component_id = world.initialize_resource::<T>();
+        let component_id = world.components.init_resource::<T>();
+        world.initialize_resource_internal(component_id);
+
         let combined_access = system_meta.component_access_set.combined_access();
         if combined_access.has_write(component_id) {
             panic!(
@@ -1027,7 +1031,9 @@ unsafe impl<'a, T: 'static> SystemParam for NonSend<'a, T> {
     fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State {
         system_meta.set_non_send();
 
-        let component_id = world.initialize_non_send_resource::<T>();
+        let component_id = world.components.init_non_send::<T>();
+        world.initialize_non_send_internal(component_id);
+
         let combined_access = system_meta.component_access_set.combined_access();
         assert!(
             !combined_access.has_write(component_id),
@@ -1114,7 +1120,9 @@ unsafe impl<'a, T: 'static> SystemParam for NonSendMut<'a, T> {
     fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State {
         system_meta.set_non_send();
 
-        let component_id = world.initialize_non_send_resource::<T>();
+        let component_id = world.components.init_non_send::<T>();
+        world.initialize_non_send_internal(component_id);
+
         let combined_access = system_meta.component_access_set.combined_access();
         if combined_access.has_write(component_id) {
             panic!(
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index f4722f1511a4b..fa0dd6c4c821d 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -1,6 +1,6 @@
 use crate::entity::Entity;
-use crate::system::{BoxedSystem, Command, IntoSystem};
-use crate::world::World;
+use crate::system::{BoxedSystem, IntoSystem};
+use crate::world::{Command, World};
 use crate::{self as bevy_ecs};
 use bevy_ecs_macros::Component;
 use thiserror::Error;
@@ -164,12 +164,9 @@ impl World {
     ///
     /// ```
     /// # use bevy_ecs::prelude::*;
-    /// #[derive(Resource, Default)]
-    /// struct Counter(u8);
-    ///
-    /// fn increment(mut counter: Local<Counter>) {
-    ///    counter.0 += 1;
-    ///    println!("{}", counter.0);
+    /// fn increment(mut counter: Local<u8>) {
+    ///    *counter += 1;
+    ///    println!("{}", *counter);
     /// }
     ///
     /// let mut world = World::default();
@@ -255,20 +252,17 @@ impl World {
     ///
     /// ```
     /// # use bevy_ecs::prelude::*;
-    /// #[derive(Resource, Default)]
-    /// struct Counter(u8);
-    ///
-    /// fn increment(In(increment_by): In<u8>, mut counter: Local<Counter>) {
-    ///    counter.0 += increment_by;
-    ///    println!("{}", counter.0);
+    /// fn increment(In(increment_by): In<u8>, mut counter: Local<u8>) -> u8 {
+    ///   *counter += increment_by;
+    ///   *counter
     /// }
     ///
     /// let mut world = World::default();
     /// let counter_one = world.register_system(increment);
     /// let counter_two = world.register_system(increment);
-    /// world.run_system_with_input(counter_one, 1); // -> 1
-    /// world.run_system_with_input(counter_one, 20); // -> 21
-    /// world.run_system_with_input(counter_two, 30); // -> 51
+    /// assert_eq!(world.run_system_with_input(counter_one, 1).unwrap(), 1);
+    /// assert_eq!(world.run_system_with_input(counter_one, 20).unwrap(), 21);
+    /// assert_eq!(world.run_system_with_input(counter_two, 30).unwrap(), 30);
     /// ```
     ///
     /// See [`World::run_system`] for more examples.
diff --git a/crates/bevy_ecs/src/system/commands/command_queue.rs b/crates/bevy_ecs/src/world/command_queue.rs
similarity index 97%
rename from crates/bevy_ecs/src/system/commands/command_queue.rs
rename to crates/bevy_ecs/src/world/command_queue.rs
index a9dcd6f965de2..3103e3486ce2d 100644
--- a/crates/bevy_ecs/src/system/commands/command_queue.rs
+++ b/crates/bevy_ecs/src/world/command_queue.rs
@@ -1,10 +1,11 @@
+use crate::system::{SystemBuffer, SystemMeta};
+
 use std::{fmt::Debug, mem::MaybeUninit};
 
 use bevy_ptr::{OwningPtr, Unaligned};
 use bevy_utils::tracing::warn;
 
-use super::Command;
-use crate::world::World;
+use crate::world::{Command, World};
 
 struct CommandMeta {
     /// SAFETY: The `value` must point to a value of type `T: Command`,
@@ -234,6 +235,15 @@ impl Drop for CommandQueue {
     }
 }
 
+impl SystemBuffer for CommandQueue {
+    #[inline]
+    fn apply(&mut self, _system_meta: &SystemMeta, world: &mut World) {
+        #[cfg(feature = "trace")]
+        let _span_guard = _system_meta.commands_span.enter();
+        self.apply(world);
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
diff --git a/crates/bevy_ecs/src/world/deferred_world.rs b/crates/bevy_ecs/src/world/deferred_world.rs
index 81352445a9047..f9d5fc53a6b84 100644
--- a/crates/bevy_ecs/src/world/deferred_world.rs
+++ b/crates/bevy_ecs/src/world/deferred_world.rs
@@ -165,7 +165,7 @@ impl<'w> DeferredWorld<'w> {
             None => panic!(
                 "Requested non-send resource {} does not exist in the `World`. 
                 Did you forget to add it using `app.insert_non_send_resource` / `app.init_non_send_resource`? 
-                Non-send resources can also be be added by plugins.",
+                Non-send resources can also be added by plugins.",
                 std::any::type_name::<R>()
             ),
         }
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
index 81691f6a6a70c..74c7ffb7f5cdb 100644
--- a/crates/bevy_ecs/src/world/mod.rs
+++ b/crates/bevy_ecs/src/world/mod.rs
@@ -1,5 +1,6 @@
 //! Defines the [`World`] and APIs for accessing it directly.
 
+mod command_queue;
 mod deferred_world;
 mod entity_ref;
 pub mod error;
@@ -8,6 +9,7 @@ pub mod unsafe_world_cell;
 mod world_cell;
 
 pub use crate::change_detection::{Mut, Ref, CHECK_TICK_THRESHOLD};
+pub use crate::world::command_queue::CommandQueue;
 pub use deferred_world::DeferredWorld;
 pub use entity_ref::{
     EntityMut, EntityRef, EntityWorldMut, Entry, FilteredEntityMut, FilteredEntityRef,
@@ -30,7 +32,7 @@ use crate::{
     removal_detection::RemovedComponentEvents,
     schedule::{Schedule, ScheduleLabel, Schedules},
     storage::{ResourceData, Storages},
-    system::{CommandQueue, Commands, Res, Resource},
+    system::{Commands, Res, Resource},
     world::error::TryRunScheduleError,
 };
 use bevy_ptr::{OwningPtr, Ptr};
@@ -43,9 +45,44 @@ use std::{
 };
 mod identifier;
 
+use self::unsafe_world_cell::{UnsafeEntityCell, UnsafeWorldCell};
 pub use identifier::WorldId;
 
-use self::unsafe_world_cell::{UnsafeEntityCell, UnsafeWorldCell};
+/// A [`World`] mutation.
+///
+/// Should be used with [`Commands::add`].
+///
+/// # Usage
+///
+/// ```
+/// # use bevy_ecs::prelude::*;
+/// # use bevy_ecs::world::Command;
+/// // Our world resource
+/// #[derive(Resource, Default)]
+/// struct Counter(u64);
+///
+/// // Our custom command
+/// struct AddToCounter(u64);
+///
+/// impl Command for AddToCounter {
+///     fn apply(self, world: &mut World) {
+///         let mut counter = world.get_resource_or_insert_with(Counter::default);
+///         counter.0 += self.0;
+///     }
+/// }
+///
+/// fn some_system(mut commands: Commands) {
+///     commands.add(AddToCounter(42));
+/// }
+/// ```
+pub trait Command: Send + 'static {
+    /// Applies this command, causing it to mutate the provided `world`.
+    ///
+    /// This method is used to define what a command "does" when it is ultimately applied.
+    /// Because this method takes `self`, you can store data or settings on the type that implements this trait.
+    /// This data is set by the system or other source of the command, and then ultimately read in this method.
+    fn apply(self, world: &mut World);
+}
 
 /// Stores and exposes operations on [entities](Entity), [components](Component), resources,
 /// and their associated metadata.
@@ -1447,7 +1484,7 @@ impl World {
             None => panic!(
                 "Requested non-send resource {} does not exist in the `World`.
                 Did you forget to add it using `app.insert_non_send_resource` / `app.init_non_send_resource`?
-                Non-send resources can also be be added by plugins.",
+                Non-send resources can also be added by plugins.",
                 std::any::type_name::<R>()
             ),
         }
@@ -1469,7 +1506,7 @@ impl World {
             None => panic!(
                 "Requested non-send resource {} does not exist in the `World`.
                 Did you forget to add it using `app.insert_non_send_resource` / `app.init_non_send_resource`?
-                Non-send resources can also be be added by plugins.",
+                Non-send resources can also be added by plugins.",
                 std::any::type_name::<R>()
             ),
         }
@@ -1798,7 +1835,7 @@ impl World {
     /// # Panics
     /// Panics if `component_id` is not registered as a `Send` component type in this `World`
     #[inline]
-    fn initialize_resource_internal(
+    pub(crate) fn initialize_resource_internal(
         &mut self,
         component_id: ComponentId,
     ) -> &mut ResourceData<true> {
@@ -1813,7 +1850,7 @@ impl World {
     /// # Panics
     /// panics if `component_id` is not registered in this world
     #[inline]
-    fn initialize_non_send_internal(
+    pub(crate) fn initialize_non_send_internal(
         &mut self,
         component_id: ComponentId,
     ) -> &mut ResourceData<false> {
@@ -1825,18 +1862,6 @@ impl World {
             })
     }
 
-    pub(crate) fn initialize_resource<R: Resource>(&mut self) -> ComponentId {
-        let component_id = self.components.init_resource::<R>();
-        self.initialize_resource_internal(component_id);
-        component_id
-    }
-
-    pub(crate) fn initialize_non_send_resource<R: 'static>(&mut self) -> ComponentId {
-        let component_id = self.components.init_non_send::<R>();
-        self.initialize_non_send_internal(component_id);
-        component_id
-    }
-
     /// Empties queued entities and adds them to the empty [`Archetype`](crate::archetype::Archetype).
     /// This should be called before doing operations that might operate on queued entities,
     /// such as inserting a [`Component`].
diff --git a/crates/bevy_ecs/src/world/unsafe_world_cell.rs b/crates/bevy_ecs/src/world/unsafe_world_cell.rs
index b786a3cfb4425..9fbb6e52de668 100644
--- a/crates/bevy_ecs/src/world/unsafe_world_cell.rs
+++ b/crates/bevy_ecs/src/world/unsafe_world_cell.rs
@@ -2,19 +2,17 @@
 
 #![warn(unsafe_op_in_unsafe_fn)]
 
-use super::{Mut, Ref, World, WorldId};
+use super::{command_queue::CommandQueue, Mut, Ref, World, WorldId};
 use crate::{
     archetype::{Archetype, ArchetypeComponentId, Archetypes},
     bundle::Bundles,
     change_detection::{MutUntyped, Ticks, TicksMut},
-    component::{
-        ComponentId, ComponentStorage, ComponentTicks, Components, StorageType, Tick, TickCells,
-    },
+    component::{ComponentId, ComponentTicks, Components, StorageType, Tick, TickCells},
     entity::{Entities, Entity, EntityLocation},
     prelude::Component,
     removal_detection::RemovedComponentEvents,
     storage::{Column, ComponentSparseSet, Storages},
-    system::{CommandQueue, Res, Resource},
+    system::{Res, Resource},
 };
 use bevy_ptr::Ptr;
 use std::{any::TypeId, cell::UnsafeCell, fmt::Debug, marker::PhantomData, ptr, ptr::addr_of_mut};
@@ -713,7 +711,7 @@ impl<'w> UnsafeEntityCell<'w> {
             get_component(
                 self.world,
                 component_id,
-                T::Storage::STORAGE_TYPE,
+                T::STORAGE_TYPE,
                 self.entity,
                 self.location,
             )
@@ -740,7 +738,7 @@ impl<'w> UnsafeEntityCell<'w> {
             get_component_and_ticks(
                 self.world,
                 component_id,
-                T::Storage::STORAGE_TYPE,
+                T::STORAGE_TYPE,
                 self.entity,
                 self.location,
             )
@@ -770,7 +768,7 @@ impl<'w> UnsafeEntityCell<'w> {
             get_ticks(
                 self.world,
                 component_id,
-                T::Storage::STORAGE_TYPE,
+                T::STORAGE_TYPE,
                 self.entity,
                 self.location,
             )
@@ -839,7 +837,7 @@ impl<'w> UnsafeEntityCell<'w> {
             get_component_and_ticks(
                 self.world,
                 component_id,
-                T::Storage::STORAGE_TYPE,
+                T::STORAGE_TYPE,
                 self.entity,
                 self.location,
             )
diff --git a/crates/bevy_ecs/src/world/world_cell.rs b/crates/bevy_ecs/src/world/world_cell.rs
index 852858ba607b3..2ae79b32306e6 100644
--- a/crates/bevy_ecs/src/world/world_cell.rs
+++ b/crates/bevy_ecs/src/world/world_cell.rs
@@ -296,7 +296,7 @@ impl<'w> WorldCell<'w> {
             None => panic!(
                 "Requested non-send resource {} does not exist in the `World`. 
                 Did you forget to add it using `app.insert_non_send_resource` / `app.init_non_send_resource`? 
-                Non-send resources can also be be added by plugins.",
+                Non-send resources can also be added by plugins.",
                 std::any::type_name::<T>()
             ),
         }
@@ -330,7 +330,7 @@ impl<'w> WorldCell<'w> {
             None => panic!(
                 "Requested non-send resource {} does not exist in the `World`. 
                 Did you forget to add it using `app.insert_non_send_resource` / `app.init_non_send_resource`? 
-                Non-send resources can also be be added by plugins.",
+                Non-send resources can also be added by plugins.",
                 std::any::type_name::<T>()
             ),
         }
diff --git a/crates/bevy_gilrs/Cargo.toml b/crates/bevy_gilrs/Cargo.toml
index 000d8692265c2..bf0bd644abd26 100644
--- a/crates/bevy_gilrs/Cargo.toml
+++ b/crates/bevy_gilrs/Cargo.toml
@@ -13,7 +13,6 @@ keywords = ["bevy"]
 bevy_app = { path = "../bevy_app", version = "0.14.0-dev" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.14.0-dev" }
 bevy_input = { path = "../bevy_input", version = "0.14.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.14.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.14.0-dev" }
 bevy_time = { path = "../bevy_time", version = "0.14.0-dev" }
 
diff --git a/crates/bevy_gilrs/src/rumble.rs b/crates/bevy_gilrs/src/rumble.rs
index c982a52ce2fa5..b59abef9a066f 100644
--- a/crates/bevy_gilrs/src/rumble.rs
+++ b/crates/bevy_gilrs/src/rumble.rs
@@ -4,8 +4,8 @@ use bevy_ecs::prelude::{EventReader, Res, ResMut, Resource};
 #[cfg(target_arch = "wasm32")]
 use bevy_ecs::system::NonSendMut;
 use bevy_input::gamepad::{GamepadRumbleIntensity, GamepadRumbleRequest};
-use bevy_log::{debug, warn};
 use bevy_time::{Real, Time};
+use bevy_utils::tracing::{debug, warn};
 use bevy_utils::{synccell::SyncCell, Duration, HashMap};
 use gilrs::{
     ff::{self, BaseEffect, BaseEffectType, Repeat, Replay},
diff --git a/crates/bevy_gizmos/Cargo.toml b/crates/bevy_gizmos/Cargo.toml
index b573c5d6d921d..a7ecaddaf0b8b 100644
--- a/crates/bevy_gizmos/Cargo.toml
+++ b/crates/bevy_gizmos/Cargo.toml
@@ -23,12 +23,12 @@ bevy_math = { path = "../bevy_math", version = "0.14.0-dev" }
 bevy_asset = { path = "../bevy_asset", version = "0.14.0-dev" }
 bevy_render = { path = "../bevy_render", version = "0.14.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.14.0-dev" }
-bevy_core = { path = "../bevy_core", version = "0.14.0-dev" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.14.0-dev" }
 bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.14.0-dev" }
 bevy_transform = { path = "../bevy_transform", version = "0.14.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.14.0-dev" }
 bevy_gizmos_macros = { path = "macros", version = "0.14.0-dev" }
 
+bytemuck = "1.0"
+
 [lints]
 workspace = true
diff --git a/crates/bevy_gizmos/src/lib.rs b/crates/bevy_gizmos/src/lib.rs
index dc0db0cbfa96a..a27b91192a2a3 100644
--- a/crates/bevy_gizmos/src/lib.rs
+++ b/crates/bevy_gizmos/src/lib.rs
@@ -14,7 +14,7 @@
 //!
 //! See the documentation on [Gizmos](crate::gizmos::Gizmos) for more examples.
 
-/// Label for the the render systems handling the
+/// System set label for the systems handling the rendering of gizmos.
 #[derive(SystemSet, Clone, Debug, Hash, PartialEq, Eq)]
 pub enum GizmoRenderSystem {
     /// Adds gizmos to the [`Transparent2d`](bevy_core_pipeline::core_2d::Transparent2d) render phase
@@ -32,6 +32,7 @@ pub mod circles;
 pub mod config;
 pub mod gizmos;
 pub mod grid;
+pub mod light;
 pub mod primitives;
 
 #[cfg(feature = "bevy_sprite")]
@@ -46,6 +47,7 @@ pub mod prelude {
         aabb::{AabbGizmoConfigGroup, ShowAabbGizmo},
         config::{DefaultGizmoConfigGroup, GizmoConfig, GizmoConfigGroup, GizmoConfigStore},
         gizmos::Gizmos,
+        light::{LightGizmoColor, LightGizmoConfigGroup, ShowLightGizmo},
         primitives::{dim2::GizmoPrimitive2d, dim3::GizmoPrimitive3d},
         AppGizmoBuilder,
     };
@@ -55,7 +57,6 @@ use aabb::AabbGizmoPlugin;
 use bevy_app::{App, Last, Plugin};
 use bevy_asset::{load_internal_asset, Asset, AssetApp, Assets, Handle};
 use bevy_color::LinearRgba;
-use bevy_core::cast_slice;
 use bevy_ecs::{
     component::Component,
     query::ROQueryItem,
@@ -81,10 +82,12 @@ use bevy_render::{
     Extract, ExtractSchedule, Render, RenderApp, RenderSet,
 };
 use bevy_utils::TypeIdMap;
+use bytemuck::cast_slice;
 use config::{
     DefaultGizmoConfigGroup, GizmoConfig, GizmoConfigGroup, GizmoConfigStore, GizmoMeshConfig,
 };
 use gizmos::GizmoStorage;
+use light::LightGizmoPlugin;
 use std::{any::TypeId, mem};
 
 const LINE_SHADER_HANDLE: Handle<Shader> = Handle::weak_from_u128(7414812689238026784);
@@ -96,7 +99,9 @@ impl Plugin for GizmoPlugin {
     fn build(&self, app: &mut bevy_app::App) {
         // Gizmos cannot work without either a 3D or 2D renderer.
         #[cfg(all(not(feature = "bevy_pbr"), not(feature = "bevy_sprite")))]
-        bevy_log::error!("bevy_gizmos requires either bevy_pbr or bevy_sprite. Please enable one.");
+        bevy_utils::tracing::error!(
+            "bevy_gizmos requires either bevy_pbr or bevy_sprite. Please enable one."
+        );
 
         load_internal_asset!(app, LINE_SHADER_HANDLE, "lines.wgsl", Shader::from_wgsl);
 
@@ -108,7 +113,8 @@ impl Plugin for GizmoPlugin {
             .init_resource::<LineGizmoHandles>()
             // We insert the Resource GizmoConfigStore into the world implicitly here if it does not exist.
             .init_gizmo_group::<DefaultGizmoConfigGroup>()
-            .add_plugins(AabbGizmoPlugin);
+            .add_plugins(AabbGizmoPlugin)
+            .add_plugins(LightGizmoPlugin);
 
         let Ok(render_app) = app.get_sub_app_mut(RenderApp) else {
             return;
diff --git a/crates/bevy_gizmos/src/light.rs b/crates/bevy_gizmos/src/light.rs
new file mode 100644
index 0000000000000..52d69a400cdbb
--- /dev/null
+++ b/crates/bevy_gizmos/src/light.rs
@@ -0,0 +1,324 @@
+//! A module adding debug visualization of [`PointLight`]s, [`SpotLight`]s and [`DirectionalLight`]s.
+
+use std::f32::consts::PI;
+
+use crate::{self as bevy_gizmos, primitives::dim3::GizmoPrimitive3d};
+
+use bevy_app::{Plugin, PostUpdate};
+use bevy_color::{
+    palettes::basic::{BLUE, GREEN, RED},
+    Color, Oklcha,
+};
+use bevy_ecs::{
+    component::Component,
+    entity::Entity,
+    query::Without,
+    reflect::ReflectComponent,
+    schedule::IntoSystemConfigs,
+    system::{Query, Res},
+};
+use bevy_math::{
+    primitives::{Cone, Sphere},
+    Quat, Vec3,
+};
+use bevy_pbr::{DirectionalLight, PointLight, SpotLight};
+use bevy_reflect::{std_traits::ReflectDefault, Reflect};
+use bevy_transform::{components::GlobalTransform, TransformSystem};
+
+use crate::{
+    config::{GizmoConfigGroup, GizmoConfigStore},
+    gizmos::Gizmos,
+    AppGizmoBuilder,
+};
+
+/// Draws a standard sphere for the radius and an axis sphere for the range.
+fn point_light_gizmo(
+    transform: &GlobalTransform,
+    point_light: &PointLight,
+    color: Color,
+    gizmos: &mut Gizmos<LightGizmoConfigGroup>,
+) {
+    let position = transform.translation();
+    gizmos
+        .primitive_3d(
+            Sphere {
+                radius: point_light.radius,
+            },
+            position,
+            Quat::IDENTITY,
+            color,
+        )
+        .segments(16);
+    gizmos
+        .sphere(position, Quat::IDENTITY, point_light.range, color)
+        .circle_segments(32);
+}
+
+/// Draws a sphere for the radius, two cones for the inner and outer angles, plus two 3d arcs crossing the
+/// farthest point of effect of the spot light along its direction.
+fn spot_light_gizmo(
+    transform: &GlobalTransform,
+    spot_light: &SpotLight,
+    color: Color,
+    gizmos: &mut Gizmos<LightGizmoConfigGroup>,
+) {
+    let (_, rotation, translation) = transform.to_scale_rotation_translation();
+    gizmos
+        .primitive_3d(
+            Sphere {
+                radius: spot_light.radius,
+            },
+            translation,
+            Quat::IDENTITY,
+            color,
+        )
+        .segments(16);
+
+    // Offset the tip of the cone to the light position.
+    for angle in [spot_light.inner_angle, spot_light.outer_angle] {
+        let height = spot_light.range * angle.cos();
+        let position = translation + rotation * Vec3::NEG_Z * height / 2.0;
+        gizmos
+            .primitive_3d(
+                Cone {
+                    radius: spot_light.range * angle.sin(),
+                    height,
+                },
+                position,
+                rotation * Quat::from_rotation_x(PI / 2.0),
+                color,
+            )
+            .height_segments(4)
+            .base_segments(32);
+    }
+
+    for arc_rotation in [
+        Quat::from_rotation_y(PI / 2.0 - spot_light.outer_angle),
+        Quat::from_euler(
+            bevy_math::EulerRot::XZY,
+            0.0,
+            PI / 2.0,
+            PI / 2.0 - spot_light.outer_angle,
+        ),
+    ] {
+        gizmos
+            .arc_3d(
+                2.0 * spot_light.outer_angle,
+                spot_light.range,
+                translation,
+                rotation * arc_rotation,
+                color,
+            )
+            .segments(16);
+    }
+}
+
+/// Draws an arrow alongside the directional light direction.
+fn directional_light_gizmo(
+    transform: &GlobalTransform,
+    color: Color,
+    gizmos: &mut Gizmos<LightGizmoConfigGroup>,
+) {
+    let (_, rotation, translation) = transform.to_scale_rotation_translation();
+    gizmos
+        .arrow(translation, translation + rotation * Vec3::NEG_Z, color)
+        .with_tip_length(0.3);
+}
+
+/// A [`Plugin`] that provides visualization of [`PointLight`]s, [`SpotLight`]s
+/// and [`DirectionalLight`]s for debugging.
+pub struct LightGizmoPlugin;
+
+impl Plugin for LightGizmoPlugin {
+    fn build(&self, app: &mut bevy_app::App) {
+        app.register_type::<LightGizmoConfigGroup>()
+            .init_gizmo_group::<LightGizmoConfigGroup>()
+            .add_systems(
+                PostUpdate,
+                (
+                    draw_lights,
+                    draw_all_lights.run_if(|config: Res<GizmoConfigStore>| {
+                        config.config::<LightGizmoConfigGroup>().1.draw_all
+                    }),
+                )
+                    .after(TransformSystem::TransformPropagate),
+            );
+    }
+}
+
+/// Configures how a color is attributed to a light gizmo.
+#[derive(Debug, Clone, Copy, Default, Reflect)]
+pub enum LightGizmoColor {
+    /// User-specified color.
+    Manual(Color),
+    /// Random color derived from the light's [`Entity`].
+    Varied,
+    /// Take the color of the represented light.
+    #[default]
+    MatchLightColor,
+    /// Take the color provided by [`LightGizmoConfigGroup`] depending on the light kind.
+    ByLightType,
+}
+
+/// The [`GizmoConfigGroup`] used to configure the visualization of lights.
+#[derive(Clone, Reflect, GizmoConfigGroup)]
+pub struct LightGizmoConfigGroup {
+    /// Draw a gizmo for all lights if true.
+    ///
+    /// Defaults to `false`.
+    pub draw_all: bool,
+    /// Default color strategy for all light gizmos.
+    ///
+    /// Defaults to [`LightGizmoColor::MatchLightColor`].
+    pub color: LightGizmoColor,
+    /// [`Color`] to use for drawing a [`PointLight`] gizmo when [`LightGizmoColor::ByLightType`] is used.
+    ///
+    /// Defaults to [`RED`].
+    pub point_light_color: Color,
+    /// [`Color`] to use for drawing a [`SpotLight`] gizmo when [`LightGizmoColor::ByLightType`] is used.
+    ///
+    /// Defaults to [`GREEN`].
+    pub spot_light_color: Color,
+    /// [`Color`] to use for drawing a [`DirectionalLight`] gizmo when [`LightGizmoColor::ByLightType`] is used.
+    ///
+    /// Defaults to [`BLUE`].
+    pub directional_light_color: Color,
+}
+
+impl Default for LightGizmoConfigGroup {
+    fn default() -> Self {
+        Self {
+            draw_all: false,
+            color: LightGizmoColor::MatchLightColor,
+            point_light_color: RED.into(),
+            spot_light_color: GREEN.into(),
+            directional_light_color: BLUE.into(),
+        }
+    }
+}
+
+/// Add this [`Component`] to an entity to draw any of its lights components
+/// ([`PointLight`], [`SpotLight`] and [`DirectionalLight`]).
+#[derive(Component, Reflect, Default, Debug)]
+#[reflect(Component, Default)]
+pub struct ShowLightGizmo {
+    /// Default color strategy for this light gizmo. if [`None`], use the one provided by [`LightGizmoConfigGroup`].
+    ///
+    /// Defaults to [`None`].
+    pub color: Option<LightGizmoColor>,
+}
+
+fn draw_lights(
+    point_query: Query<(Entity, &PointLight, &GlobalTransform, &ShowLightGizmo)>,
+    spot_query: Query<(Entity, &SpotLight, &GlobalTransform, &ShowLightGizmo)>,
+    directional_query: Query<(Entity, &DirectionalLight, &GlobalTransform, &ShowLightGizmo)>,
+    mut gizmos: Gizmos<LightGizmoConfigGroup>,
+) {
+    let color = |entity: Entity, gizmo_color: Option<LightGizmoColor>, light_color, type_color| {
+        match gizmo_color.unwrap_or(gizmos.config_ext.color) {
+            LightGizmoColor::Manual(color) => color,
+            LightGizmoColor::Varied => Oklcha::sequential_dispersed(entity.index()).into(),
+            LightGizmoColor::MatchLightColor => light_color,
+            LightGizmoColor::ByLightType => type_color,
+        }
+    };
+    for (entity, light, transform, light_gizmo) in &point_query {
+        let color = color(
+            entity,
+            light_gizmo.color,
+            light.color,
+            gizmos.config_ext.point_light_color,
+        );
+        point_light_gizmo(transform, light, color, &mut gizmos);
+    }
+    for (entity, light, transform, light_gizmo) in &spot_query {
+        let color = color(
+            entity,
+            light_gizmo.color,
+            light.color,
+            gizmos.config_ext.spot_light_color,
+        );
+        spot_light_gizmo(transform, light, color, &mut gizmos);
+    }
+    for (entity, light, transform, light_gizmo) in &directional_query {
+        let color = color(
+            entity,
+            light_gizmo.color,
+            light.color,
+            gizmos.config_ext.directional_light_color,
+        );
+        directional_light_gizmo(transform, color, &mut gizmos);
+    }
+}
+
+fn draw_all_lights(
+    point_query: Query<(Entity, &PointLight, &GlobalTransform), Without<ShowLightGizmo>>,
+    spot_query: Query<(Entity, &SpotLight, &GlobalTransform), Without<ShowLightGizmo>>,
+    directional_query: Query<
+        (Entity, &DirectionalLight, &GlobalTransform),
+        Without<ShowLightGizmo>,
+    >,
+    mut gizmos: Gizmos<LightGizmoConfigGroup>,
+) {
+    match gizmos.config_ext.color {
+        LightGizmoColor::Manual(color) => {
+            for (_, light, transform) in &point_query {
+                point_light_gizmo(transform, light, color, &mut gizmos);
+            }
+            for (_, light, transform) in &spot_query {
+                spot_light_gizmo(transform, light, color, &mut gizmos);
+            }
+            for (_, _, transform) in &directional_query {
+                directional_light_gizmo(transform, color, &mut gizmos);
+            }
+        }
+        LightGizmoColor::Varied => {
+            let color = |entity: Entity| Oklcha::sequential_dispersed(entity.index()).into();
+            for (entity, light, transform) in &point_query {
+                point_light_gizmo(transform, light, color(entity), &mut gizmos);
+            }
+            for (entity, light, transform) in &spot_query {
+                spot_light_gizmo(transform, light, color(entity), &mut gizmos);
+            }
+            for (entity, _, transform) in &directional_query {
+                directional_light_gizmo(transform, color(entity), &mut gizmos);
+            }
+        }
+        LightGizmoColor::MatchLightColor => {
+            for (_, light, transform) in &point_query {
+                point_light_gizmo(transform, light, light.color, &mut gizmos);
+            }
+            for (_, light, transform) in &spot_query {
+                spot_light_gizmo(transform, light, light.color, &mut gizmos);
+            }
+            for (_, light, transform) in &directional_query {
+                directional_light_gizmo(transform, light.color, &mut gizmos);
+            }
+        }
+        LightGizmoColor::ByLightType => {
+            for (_, light, transform) in &point_query {
+                point_light_gizmo(
+                    transform,
+                    light,
+                    gizmos.config_ext.point_light_color,
+                    &mut gizmos,
+                );
+            }
+            for (_, light, transform) in &spot_query {
+                spot_light_gizmo(
+                    transform,
+                    light,
+                    gizmos.config_ext.spot_light_color,
+                    &mut gizmos,
+                );
+            }
+            for (_, _, transform) in &directional_query {
+                directional_light_gizmo(
+                    transform,
+                    gizmos.config_ext.directional_light_color,
+                    &mut gizmos,
+                );
+            }
+        }
+    }
+}
diff --git a/crates/bevy_gizmos/src/primitives/dim3.rs b/crates/bevy_gizmos/src/primitives/dim3.rs
index 6359517a68f66..eae53b1fcf3b4 100644
--- a/crates/bevy_gizmos/src/primitives/dim3.rs
+++ b/crates/bevy_gizmos/src/primitives/dim3.rs
@@ -609,14 +609,36 @@ pub struct Cone3dBuilder<'a, 'w, 's, T: GizmoConfigGroup> {
     // Color of the cone
     color: Color,
 
-    // Number of segments used to approximate the cone geometry
-    segments: usize,
+    // Number of segments used to approximate the cone base geometry
+    base_segments: usize,
+
+    // Number of segments used to approximate the cone height geometry
+    height_segments: usize,
 }
 
 impl<T: GizmoConfigGroup> Cone3dBuilder<'_, '_, '_, T> {
-    /// Set the number of segments used to approximate the cone geometry.
+    /// Set the number of segments used to approximate the cone geometry for its base and height.
     pub fn segments(mut self, segments: usize) -> Self {
-        self.segments = segments;
+        self.base_segments = segments;
+        self.height_segments = segments;
+        self
+    }
+
+    /// Set the number of segments to approximate the height of the cone geometry.
+    ///
+    /// `segments` should be a multiple of the value passed to [`Self::height_segments`]
+    /// for the height to connect properly with the base.
+    pub fn base_segments(mut self, segments: usize) -> Self {
+        self.base_segments = segments;
+        self
+    }
+
+    /// Set the number of segments to approximate the height of the cone geometry.
+    ///
+    /// `segments` should be a divisor of the value passed to [`Self::base_segments`]
+    /// for the height to connect properly with the base.
+    pub fn height_segments(mut self, segments: usize) -> Self {
+        self.height_segments = segments;
         self
     }
 }
@@ -638,7 +660,8 @@ impl<'w, 's, T: GizmoConfigGroup> GizmoPrimitive3d<Cone> for Gizmos<'w, 's, T> {
             position,
             rotation,
             color,
-            segments: DEFAULT_NUMBER_SEGMENTS,
+            base_segments: DEFAULT_NUMBER_SEGMENTS,
+            height_segments: DEFAULT_NUMBER_SEGMENTS,
         }
     }
 }
@@ -656,7 +679,8 @@ impl<T: GizmoConfigGroup> Drop for Cone3dBuilder<'_, '_, '_, T> {
             position,
             rotation,
             color,
-            segments,
+            base_segments,
+            height_segments,
         } = self;
 
         let half_height = *height * 0.5;
@@ -665,7 +689,7 @@ impl<T: GizmoConfigGroup> Drop for Cone3dBuilder<'_, '_, '_, T> {
         draw_circle_3d(
             gizmos,
             *radius,
-            *segments,
+            *base_segments,
             *rotation,
             *position - *rotation * Vec3::Y * half_height,
             *color,
@@ -673,7 +697,7 @@ impl<T: GizmoConfigGroup> Drop for Cone3dBuilder<'_, '_, '_, T> {
 
         // connect the base circle with the tip of the cone
         let end = Vec3::Y * half_height;
-        circle_coordinates(*radius, *segments)
+        circle_coordinates(*radius, *height_segments)
             .map(|p| Vec3::new(p.x, -half_height, p.y))
             .map(move |p| [p, end])
             .map(|ps| ps.map(rotate_then_translate_3d(*rotation, *position)))
diff --git a/crates/bevy_gltf/Cargo.toml b/crates/bevy_gltf/Cargo.toml
index 2d7817f6f4572..22c5f49450f76 100644
--- a/crates/bevy_gltf/Cargo.toml
+++ b/crates/bevy_gltf/Cargo.toml
@@ -22,7 +22,6 @@ bevy_core = { path = "../bevy_core", version = "0.14.0-dev" }
 bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.14.0-dev" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.14.0-dev" }
 bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.14.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.14.0-dev" }
 bevy_math = { path = "../bevy_math", version = "0.14.0-dev" }
 bevy_pbr = { path = "../bevy_pbr", version = "0.14.0-dev" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.14.0-dev", features = [
@@ -55,6 +54,7 @@ base64 = "0.21.5"
 percent-encoding = "2.1"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1"
+smallvec = "1.11"
 
 [lints]
 workspace = true
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index ca6a309684e95..b59d6eaf1fff5 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -9,7 +9,6 @@ use bevy_core_pipeline::prelude::Camera3dBundle;
 use bevy_ecs::entity::EntityHashMap;
 use bevy_ecs::{entity::Entity, world::World};
 use bevy_hierarchy::{BuildWorldChildren, WorldChildBuilder};
-use bevy_log::{error, info_span, warn};
 use bevy_math::{Affine2, Mat4, Vec3};
 use bevy_pbr::{
     DirectionalLight, DirectionalLightBundle, PbrBundle, PointLight, PointLightBundle, SpotLight,
@@ -36,10 +35,8 @@ use bevy_scene::Scene;
 #[cfg(not(target_arch = "wasm32"))]
 use bevy_tasks::IoTaskPool;
 use bevy_transform::components::Transform;
-use bevy_utils::{
-    smallvec::{smallvec, SmallVec},
-    HashMap, HashSet,
-};
+use bevy_utils::tracing::{error, info_span, warn};
+use bevy_utils::{HashMap, HashSet};
 use gltf::{
     accessor::Iter,
     mesh::{util::ReadIndices, Mode},
@@ -47,6 +44,7 @@ use gltf::{
     Material, Node, Primitive, Semantic,
 };
 use serde::{Deserialize, Serialize};
+use smallvec::{smallvec, SmallVec};
 use std::io::Error;
 use std::{
     collections::VecDeque,
@@ -474,9 +472,9 @@ async fn load_gltf<'a, 'b, 'c>(
                 let vertex_count_after = mesh.count_vertices();
 
                 if vertex_count_before != vertex_count_after {
-                    bevy_log::debug!("Missing vertex normals in indexed geometry, computing them as flat. Vertex count increased from {} to {}", vertex_count_before, vertex_count_after);
+                    bevy_utils::tracing::debug!("Missing vertex normals in indexed geometry, computing them as flat. Vertex count increased from {} to {}", vertex_count_before, vertex_count_after);
                 } else {
-                    bevy_log::debug!(
+                    bevy_utils::tracing::debug!(
                         "Missing vertex normals in indexed geometry, computing them as flat."
                     );
                 }
@@ -490,7 +488,7 @@ async fn load_gltf<'a, 'b, 'c>(
             } else if mesh.attribute(Mesh::ATTRIBUTE_NORMAL).is_some()
                 && primitive.material().normal_texture().is_some()
             {
-                bevy_log::debug!(
+                bevy_utils::tracing::debug!(
                     "Missing vertex tangents for {}, computing them using the mikktspace algorithm. Consider using a tool such as Blender to pre-compute the tangents.", file_name
                 );
 
diff --git a/crates/bevy_hierarchy/Cargo.toml b/crates/bevy_hierarchy/Cargo.toml
index 96ffbbf08ac05..342126e3f1976 100644
--- a/crates/bevy_hierarchy/Cargo.toml
+++ b/crates/bevy_hierarchy/Cargo.toml
@@ -11,7 +11,7 @@ keywords = ["bevy"]
 [features]
 default = ["bevy_app"]
 trace = []
-bevy_app = ["reflect", "dep:bevy_app", "bevy_core", "bevy_log"]
+bevy_app = ["reflect", "dep:bevy_app", "bevy_core"]
 reflect = ["bevy_ecs/bevy_reflect", "bevy_reflect"]
 
 [dependencies]
@@ -19,11 +19,13 @@ reflect = ["bevy_ecs/bevy_reflect", "bevy_reflect"]
 bevy_app = { path = "../bevy_app", version = "0.14.0-dev", optional = true }
 bevy_core = { path = "../bevy_core", version = "0.14.0-dev", optional = true }
 bevy_ecs = { path = "../bevy_ecs", version = "0.14.0-dev", default-features = false }
-bevy_log = { path = "../bevy_log", version = "0.14.0-dev", optional = true }
 bevy_reflect = { path = "../bevy_reflect", version = "0.14.0-dev", features = [
   "bevy",
+  "smallvec",
 ], optional = true }
 bevy_utils = { path = "../bevy_utils", version = "0.14.0-dev" }
 
+smallvec = { version = "1.11", features = ["union", "const_generics"] }
+
 [lints]
 workspace = true
diff --git a/crates/bevy_hierarchy/src/child_builder.rs b/crates/bevy_hierarchy/src/child_builder.rs
index d119afe95ee70..f8d206dee5580 100644
--- a/crates/bevy_hierarchy/src/child_builder.rs
+++ b/crates/bevy_hierarchy/src/child_builder.rs
@@ -3,10 +3,10 @@ use bevy_ecs::{
     bundle::Bundle,
     entity::Entity,
     prelude::Events,
-    system::{Command, Commands, EntityCommands},
-    world::{EntityWorldMut, World},
+    system::{Commands, EntityCommands},
+    world::{Command, EntityWorldMut, World},
 };
-use bevy_utils::smallvec::{smallvec, SmallVec};
+use smallvec::{smallvec, SmallVec};
 
 // Do not use `world.send_event_batch` as it prints error message when the Events are not available in the world,
 // even though it's a valid use case to execute commands on a world without events. Loading a GLTF file for example
@@ -696,14 +696,14 @@ mod tests {
         components::{Children, Parent},
         HierarchyEvent::{self, ChildAdded, ChildMoved, ChildRemoved},
     };
-    use bevy_utils::smallvec::{smallvec, SmallVec};
+    use smallvec::{smallvec, SmallVec};
 
     use bevy_ecs::{
         component::Component,
         entity::Entity,
         event::Events,
-        system::{CommandQueue, Commands},
-        world::World,
+        system::Commands,
+        world::{CommandQueue, World},
     };
 
     /// Assert the (non)existence and state of the child's [`Parent`] component.
diff --git a/crates/bevy_hierarchy/src/components/children.rs b/crates/bevy_hierarchy/src/components/children.rs
index d980289abca79..5a53462d82c58 100644
--- a/crates/bevy_hierarchy/src/components/children.rs
+++ b/crates/bevy_hierarchy/src/components/children.rs
@@ -6,8 +6,8 @@ use bevy_ecs::{
     prelude::FromWorld,
     world::World,
 };
-use bevy_utils::smallvec::SmallVec;
 use core::slice;
+use smallvec::SmallVec;
 use std::ops::Deref;
 
 /// Contains references to the child entities of this entity.
diff --git a/crates/bevy_hierarchy/src/hierarchy.rs b/crates/bevy_hierarchy/src/hierarchy.rs
index d707be839c76f..26f26233a0fe5 100644
--- a/crates/bevy_hierarchy/src/hierarchy.rs
+++ b/crates/bevy_hierarchy/src/hierarchy.rs
@@ -1,8 +1,8 @@
 use crate::components::{Children, Parent};
 use bevy_ecs::{
     entity::Entity,
-    system::{Command, EntityCommands},
-    world::{EntityWorldMut, World},
+    system::EntityCommands,
+    world::{Command, EntityWorldMut, World},
 };
 use bevy_utils::tracing::debug;
 
@@ -139,8 +139,8 @@ impl<'w> DespawnRecursiveExt for EntityWorldMut<'w> {
 mod tests {
     use bevy_ecs::{
         component::Component,
-        system::{CommandQueue, Commands},
-        world::World,
+        system::Commands,
+        world::{CommandQueue, World},
     };
 
     use super::DespawnRecursiveExt;
diff --git a/crates/bevy_hierarchy/src/lib.rs b/crates/bevy_hierarchy/src/lib.rs
index 83c0a10569ea3..5e1ad9e9ad4ef 100644
--- a/crates/bevy_hierarchy/src/lib.rs
+++ b/crates/bevy_hierarchy/src/lib.rs
@@ -84,13 +84,10 @@ use bevy_app::prelude::*;
 #[derive(Default)]
 pub struct HierarchyPlugin;
 
-#[cfg(feature = "bevy_app")]
-use bevy_utils::smallvec::SmallVec;
 impl Plugin for HierarchyPlugin {
     fn build(&self, app: &mut App) {
         app.register_type::<Children>()
             .register_type::<Parent>()
-            .register_type::<SmallVec<[bevy_ecs::entity::Entity; 8]>>()
             .add_event::<HierarchyEvent>();
     }
 }
diff --git a/crates/bevy_hierarchy/src/valid_parent_check_plugin.rs b/crates/bevy_hierarchy/src/valid_parent_check_plugin.rs
index d5d0783c1e328..c3d766bcde7d6 100644
--- a/crates/bevy_hierarchy/src/valid_parent_check_plugin.rs
+++ b/crates/bevy_hierarchy/src/valid_parent_check_plugin.rs
@@ -64,7 +64,7 @@ pub fn check_hierarchy_component_has_valid_parent<T: Component>(
         let parent = parent.get();
         if !component_query.contains(parent) && !already_diagnosed.contains(&entity) {
             already_diagnosed.insert(entity);
-            bevy_log::warn!(
+            bevy_utils::tracing::warn!(
                 "warning[B0004]: {name} with the {ty_name} component has a parent without {ty_name}.\n\
                 This will cause inconsistent behaviors! See: https://bevyengine.org/learn/errors/#b0004",
                 ty_name = get_short_name(std::any::type_name::<T>()),
diff --git a/crates/bevy_input/src/keyboard.rs b/crates/bevy_input/src/keyboard.rs
index a7999b47c4b1e..72fc2cfd430a7 100644
--- a/crates/bevy_input/src/keyboard.rs
+++ b/crates/bevy_input/src/keyboard.rs
@@ -86,7 +86,7 @@ use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
 /// ## Usage
 ///
 /// The event is consumed inside of the [`keyboard_input_system`]
-/// to update the [`Input<KeyCode>`](ButtonInput<KeyCode>) resource.
+/// to update the [`ButtonInput<KeyCode>`](ButtonInput<KeyCode>) resource.
 #[derive(Event, Debug, Clone, PartialEq, Eq, Reflect)]
 #[reflect(Debug, PartialEq)]
 #[cfg_attr(
@@ -162,7 +162,7 @@ pub enum NativeKeyCode {
 ///
 /// ## Usage
 ///
-/// It is used as the generic `T` value of an [`ButtonInput`] to create a `Res<Input<KeyCode>>`.
+/// It is used as the generic `T` value of an [`ButtonInput`] to create a `Res<ButtonInput<KeyCode>>`.
 ///
 /// Code representing the location of a physical key
 /// This mostly conforms to the UI Events Specification's [`KeyboardEvent.code`] with a few
diff --git a/crates/bevy_input/src/lib.rs b/crates/bevy_input/src/lib.rs
index e6841ace81636..6513f174c1d29 100644
--- a/crates/bevy_input/src/lib.rs
+++ b/crates/bevy_input/src/lib.rs
@@ -34,19 +34,15 @@ pub mod prelude {
 use bevy_app::prelude::*;
 use bevy_ecs::prelude::*;
 use bevy_reflect::Reflect;
-use keyboard::{keyboard_input_system, Key, KeyCode, KeyboardInput, NativeKey, NativeKeyCode};
-use mouse::{
-    mouse_button_input_system, MouseButton, MouseButtonInput, MouseMotion, MouseScrollUnit,
-    MouseWheel,
-};
-use touch::{touch_screen_input_system, ForceTouch, TouchInput, TouchPhase, Touches};
+use keyboard::{keyboard_input_system, KeyCode, KeyboardInput};
+use mouse::{mouse_button_input_system, MouseButton, MouseButtonInput, MouseMotion, MouseWheel};
+use touch::{touch_screen_input_system, TouchInput, Touches};
 use touchpad::{TouchpadMagnify, TouchpadRotate};
 
 use gamepad::{
     gamepad_axis_event_system, gamepad_button_event_system, gamepad_connection_system,
-    gamepad_event_system, AxisSettings, ButtonAxisSettings, ButtonSettings, Gamepad, GamepadAxis,
-    GamepadAxisChangedEvent, GamepadAxisType, GamepadButton, GamepadButtonChangedEvent,
-    GamepadButtonInput, GamepadButtonType, GamepadConnection, GamepadConnectionEvent, GamepadEvent,
+    gamepad_event_system, GamepadAxis, GamepadAxisChangedEvent, GamepadButton,
+    GamepadButtonChangedEvent, GamepadButtonInput, GamepadConnectionEvent, GamepadEvent,
     GamepadRumbleRequest, GamepadSettings, Gamepads,
 };
 
@@ -108,43 +104,15 @@ impl Plugin for InputPlugin {
             .add_systems(PreUpdate, touch_screen_input_system.in_set(InputSystem));
 
         // Register common types
-        app.register_type::<ButtonState>();
-
-        // Register keyboard types
-        app.register_type::<KeyboardInput>()
-            .register_type::<KeyCode>()
-            .register_type::<NativeKeyCode>()
-            .register_type::<Key>()
-            .register_type::<NativeKey>();
-
-        // Register mouse types
-        app.register_type::<MouseButtonInput>()
-            .register_type::<MouseButton>()
-            .register_type::<MouseMotion>()
-            .register_type::<MouseScrollUnit>()
-            .register_type::<MouseWheel>();
-
-        // Register touchpad types
-        app.register_type::<TouchpadMagnify>()
-            .register_type::<TouchpadRotate>();
-
-        // Register touch types
-        app.register_type::<TouchInput>()
-            .register_type::<ForceTouch>()
-            .register_type::<TouchPhase>();
-
-        // Register gamepad types
-        app.register_type::<Gamepad>()
-            .register_type::<GamepadConnection>()
-            .register_type::<GamepadButtonType>()
-            .register_type::<GamepadButton>()
+        app.register_type::<ButtonState>()
+            .register_type::<KeyboardInput>()
+            .register_type::<MouseButtonInput>()
+            .register_type::<TouchpadMagnify>()
+            .register_type::<TouchpadRotate>()
+            .register_type::<TouchInput>()
+            .register_type::<GamepadEvent>()
             .register_type::<GamepadButtonInput>()
-            .register_type::<GamepadAxisType>()
-            .register_type::<GamepadAxis>()
-            .register_type::<GamepadSettings>()
-            .register_type::<ButtonSettings>()
-            .register_type::<AxisSettings>()
-            .register_type::<ButtonAxisSettings>();
+            .register_type::<GamepadSettings>();
     }
 }
 
diff --git a/crates/bevy_internal/Cargo.toml b/crates/bevy_internal/Cargo.toml
index ee0469e651e22..0ea6362ee3fd5 100644
--- a/crates/bevy_internal/Cargo.toml
+++ b/crates/bevy_internal/Cargo.toml
@@ -68,6 +68,7 @@ serialize = [
   "bevy_input/serialize",
   "bevy_time/serialize",
   "bevy_window/serialize",
+  "bevy_winit?/serialize",
   "bevy_transform/serialize",
   "bevy_math/serialize",
   "bevy_scene?/serialize",
@@ -113,7 +114,7 @@ webgpu = [
 
 # enable systems that allow for automated testing on CI
 bevy_ci_testing = [
-  "bevy_app/bevy_ci_testing",
+  "bevy_dev_tools/bevy_ci_testing",
   "bevy_time/bevy_ci_testing",
   "bevy_render?/bevy_ci_testing",
   "bevy_render?/ci_limits",
@@ -162,6 +163,12 @@ bevy_debug_stepping = [
   "bevy_app/bevy_debug_stepping",
 ]
 
+# Provides a collection of developer tools
+bevy_dev_tools = ["dep:bevy_dev_tools"]
+
+# Enable support for the ios_simulator by downgrading some rendering capabilities
+ios_simulator = ["bevy_pbr?/ios_simulator", "bevy_render?/ios_simulator"]
+
 [dependencies]
 # bevy
 bevy_a11y = { path = "../bevy_a11y", version = "0.14.0-dev" }
@@ -200,6 +207,7 @@ bevy_ui = { path = "../bevy_ui", optional = true, version = "0.14.0-dev" }
 bevy_winit = { path = "../bevy_winit", optional = true, version = "0.14.0-dev" }
 bevy_gilrs = { path = "../bevy_gilrs", optional = true, version = "0.14.0-dev" }
 bevy_gizmos = { path = "../bevy_gizmos", optional = true, version = "0.14.0-dev", default-features = false }
+bevy_dev_tools = { path = "../bevy_dev_tools/", optional = true, version = "0.14.0-dev" }
 
 [lints]
 workspace = true
diff --git a/crates/bevy_internal/src/default_plugins.rs b/crates/bevy_internal/src/default_plugins.rs
index c0869a24909f2..08d68b0fdcff1 100644
--- a/crates/bevy_internal/src/default_plugins.rs
+++ b/crates/bevy_internal/src/default_plugins.rs
@@ -27,6 +27,7 @@ use bevy_app::{Plugin, PluginGroup, PluginGroupBuilder};
 /// * [`AudioPlugin`](crate::audio::AudioPlugin) - with feature `bevy_audio`
 /// * [`GilrsPlugin`](crate::gilrs::GilrsPlugin) - with feature `bevy_gilrs`
 /// * [`AnimationPlugin`](crate::animation::AnimationPlugin) - with feature `bevy_animation`
+/// * [`DevToolsPlugin`](crate::dev_tools::DevToolsPlugin) - with feature `bevy_dev_tools`
 ///
 /// [`DefaultPlugins`] obeys *Cargo* *feature* flags. Users may exert control over this plugin group
 /// by disabling `default-features` in their `Cargo.toml` and enabling only those features
@@ -134,6 +135,11 @@ impl PluginGroup for DefaultPlugins {
             group = group.add(bevy_gizmos::GizmoPlugin);
         }
 
+        #[cfg(feature = "bevy_dev_tools")]
+        {
+            group = group.add(bevy_dev_tools::DevToolsPlugin);
+        }
+
         group = group.add(IgnoreAmbiguitiesPlugin);
 
         group
diff --git a/crates/bevy_internal/src/lib.rs b/crates/bevy_internal/src/lib.rs
index 25a2584c7d83c..896091c404c98 100644
--- a/crates/bevy_internal/src/lib.rs
+++ b/crates/bevy_internal/src/lib.rs
@@ -199,3 +199,9 @@ pub mod dynamic_plugin {
     //! Dynamic linking of plugins
     pub use bevy_dynamic_plugin::*;
 }
+
+#[cfg(feature = "bevy_dev_tools")]
+pub mod dev_tools {
+    //! Collection of developer tools
+    pub use bevy_dev_tools::*;
+}
diff --git a/crates/bevy_log/src/lib.rs b/crates/bevy_log/src/lib.rs
index 4815418640ca1..601b10198f919 100644
--- a/crates/bevy_log/src/lib.rs
+++ b/crates/bevy_log/src/lib.rs
@@ -106,9 +106,12 @@ pub struct LogPlugin {
     /// This can be further filtered using the `filter` setting.
     pub level: Level,
 
-    /// Optionally apply extra transformations to the tracing subscriber.
-    /// For example add [`Layers`](tracing_subscriber::layer::Layer)
-    pub update_subscriber: Option<fn(BoxedSubscriber) -> BoxedSubscriber>,
+    /// Optionally apply extra transformations to the tracing subscriber,
+    /// such as adding [`Layer`](tracing_subscriber::layer::Layer)s.
+    ///
+    /// Access to [`App`] is also provided to allow for communication between the [`Subscriber`]
+    /// and the [`App`].
+    pub update_subscriber: Option<fn(&mut App, BoxedSubscriber) -> BoxedSubscriber>,
 }
 
 /// Alias for a boxed [`Subscriber`].
@@ -193,7 +196,7 @@ impl Plugin for LogPlugin {
             let subscriber = subscriber.with(tracy_layer);
 
             if let Some(update_subscriber) = self.update_subscriber {
-                finished_subscriber = update_subscriber(Box::new(subscriber));
+                finished_subscriber = update_subscriber(app, Box::new(subscriber));
             } else {
                 finished_subscriber = Box::new(subscriber);
             }
diff --git a/crates/bevy_math/src/bounding/bounded2d/mod.rs b/crates/bevy_math/src/bounding/bounded2d/mod.rs
index 237dda02c20da..26ccd39b94652 100644
--- a/crates/bevy_math/src/bounding/bounded2d/mod.rs
+++ b/crates/bevy_math/src/bounding/bounded2d/mod.rs
@@ -93,11 +93,12 @@ impl Aabb2d {
 }
 
 impl BoundingVolume for Aabb2d {
-    type Position = Vec2;
+    type Translation = Vec2;
+    type Rotation = f32;
     type HalfSize = Vec2;
 
     #[inline(always)]
-    fn center(&self) -> Self::Position {
+    fn center(&self) -> Self::Translation {
         (self.min + self.max) / 2.
     }
 
@@ -147,6 +148,66 @@ impl BoundingVolume for Aabb2d {
         debug_assert!(b.min.x <= b.max.x && b.min.y <= b.max.y);
         b
     }
+
+    /// Transforms the bounding volume by first rotating it around the origin and then applying a translation.
+    ///
+    /// The result is an Axis-Aligned Bounding Box that encompasses the rotated shape.
+    ///
+    /// Note that the result may not be as tightly fitting as the original, and repeated rotations
+    /// can cause the AABB to grow indefinitely. Avoid applying multiple rotations to the same AABB,
+    /// and consider storing the original AABB and rotating that every time instead.
+    #[inline(always)]
+    fn transformed_by(mut self, translation: Self::Translation, rotation: Self::Rotation) -> Self {
+        self.transform_by(translation, rotation);
+        self
+    }
+
+    /// Transforms the bounding volume by first rotating it around the origin and then applying a translation.
+    ///
+    /// The result is an Axis-Aligned Bounding Box that encompasses the rotated shape.
+    ///
+    /// Note that the result may not be as tightly fitting as the original, and repeated rotations
+    /// can cause the AABB to grow indefinitely. Avoid applying multiple rotations to the same AABB,
+    /// and consider storing the original AABB and rotating that every time instead.
+    #[inline(always)]
+    fn transform_by(&mut self, translation: Self::Translation, rotation: Self::Rotation) {
+        self.rotate_by(rotation);
+        self.translate_by(translation);
+    }
+
+    #[inline(always)]
+    fn translate_by(&mut self, translation: Self::Translation) {
+        self.min += translation;
+        self.max += translation;
+    }
+
+    /// Rotates the bounding volume around the origin by the given rotation.
+    ///
+    /// The result is an Axis-Aligned Bounding Box that encompasses the rotated shape.
+    ///
+    /// Note that the result may not be as tightly fitting as the original, and repeated rotations
+    /// can cause the AABB to grow indefinitely. Avoid applying multiple rotations to the same AABB,
+    /// and consider storing the original AABB and rotating that every time instead.
+    #[inline(always)]
+    fn rotated_by(mut self, rotation: Self::Rotation) -> Self {
+        self.rotate_by(rotation);
+        self
+    }
+
+    /// Rotates the bounding volume around the origin by the given rotation.
+    ///
+    /// The result is an Axis-Aligned Bounding Box that encompasses the rotated shape.
+    ///
+    /// Note that the result may not be as tightly fitting as the original, and repeated rotations
+    /// can cause the AABB to grow indefinitely. Avoid applying multiple rotations to the same AABB,
+    /// and consider storing the original AABB and rotating that every time instead.
+    #[inline(always)]
+    fn rotate_by(&mut self, rotation: Self::Rotation) {
+        let rot_mat = Mat2::from_angle(rotation);
+        let abs_rot_mat = Mat2::from_cols(rot_mat.x_axis.abs(), rot_mat.y_axis.abs());
+        let half_size = abs_rot_mat * self.half_size();
+        *self = Self::new(rot_mat * self.center(), half_size);
+    }
 }
 
 impl IntersectsVolume<Self> for Aabb2d {
@@ -277,6 +338,24 @@ mod aabb2d_tests {
         assert!(!shrunk.contains(&a));
     }
 
+    #[test]
+    fn transform() {
+        let a = Aabb2d {
+            min: Vec2::new(-2.0, -2.0),
+            max: Vec2::new(2.0, 2.0),
+        };
+        let transformed = a.transformed_by(Vec2::new(2.0, -2.0), std::f32::consts::FRAC_PI_4);
+        let half_length = 2_f32.hypot(2.0);
+        assert_eq!(
+            transformed.min,
+            Vec2::new(2.0 - half_length, -half_length - 2.0)
+        );
+        assert_eq!(
+            transformed.max,
+            Vec2::new(2.0 + half_length, half_length - 2.0)
+        );
+    }
+
     #[test]
     fn closest_point() {
         let aabb = Aabb2d {
@@ -396,11 +475,12 @@ impl BoundingCircle {
 }
 
 impl BoundingVolume for BoundingCircle {
-    type Position = Vec2;
+    type Translation = Vec2;
+    type Rotation = f32;
     type HalfSize = f32;
 
     #[inline(always)]
-    fn center(&self) -> Self::Position {
+    fn center(&self) -> Self::Translation {
         self.center
     }
 
@@ -449,6 +529,16 @@ impl BoundingVolume for BoundingCircle {
         debug_assert!(self.radius() >= amount);
         Self::new(self.center, self.radius() - amount)
     }
+
+    #[inline(always)]
+    fn translate_by(&mut self, translation: Vec2) {
+        self.center += translation;
+    }
+
+    #[inline(always)]
+    fn rotate_by(&mut self, rotation: f32) {
+        self.center = Mat2::from_angle(rotation) * self.center;
+    }
 }
 
 impl IntersectsVolume<Self> for BoundingCircle {
@@ -551,6 +641,17 @@ mod bounding_circle_tests {
         assert!(!shrunk.contains(&a));
     }
 
+    #[test]
+    fn transform() {
+        let a = BoundingCircle::new(Vec2::ONE, 5.0);
+        let transformed = a.transformed_by(Vec2::new(2.0, -2.0), std::f32::consts::FRAC_PI_4);
+        assert_eq!(
+            transformed.center,
+            Vec2::new(2.0, std::f32::consts::SQRT_2 - 2.0)
+        );
+        assert_eq!(transformed.radius(), 5.0);
+    }
+
     #[test]
     fn closest_point() {
         let circle = BoundingCircle::new(Vec2::ZERO, 1.0);
diff --git a/crates/bevy_math/src/bounding/bounded3d/mod.rs b/crates/bevy_math/src/bounding/bounded3d/mod.rs
index fff2b900dea04..53597d2c4bb64 100644
--- a/crates/bevy_math/src/bounding/bounded3d/mod.rs
+++ b/crates/bevy_math/src/bounding/bounded3d/mod.rs
@@ -1,5 +1,7 @@
 mod primitive_impls;
 
+use glam::Mat3;
+
 use super::{BoundingVolume, IntersectsVolume};
 use crate::prelude::{Quat, Vec3};
 
@@ -87,11 +89,12 @@ impl Aabb3d {
 }
 
 impl BoundingVolume for Aabb3d {
-    type Position = Vec3;
+    type Translation = Vec3;
+    type Rotation = Quat;
     type HalfSize = Vec3;
 
     #[inline(always)]
-    fn center(&self) -> Self::Position {
+    fn center(&self) -> Self::Translation {
         (self.min + self.max) / 2.
     }
 
@@ -143,6 +146,70 @@ impl BoundingVolume for Aabb3d {
         debug_assert!(b.min.x <= b.max.x && b.min.y <= b.max.y && b.min.z <= b.max.z);
         b
     }
+
+    /// Transforms the bounding volume by first rotating it around the origin and then applying a translation.
+    ///
+    /// The result is an Axis-Aligned Bounding Box that encompasses the rotated shape.
+    ///
+    /// Note that the result may not be as tightly fitting as the original, and repeated rotations
+    /// can cause the AABB to grow indefinitely. Avoid applying multiple rotations to the same AABB,
+    /// and consider storing the original AABB and rotating that every time instead.
+    #[inline(always)]
+    fn transformed_by(mut self, translation: Self::Translation, rotation: Self::Rotation) -> Self {
+        self.transform_by(translation, rotation);
+        self
+    }
+
+    /// Transforms the bounding volume by first rotating it around the origin and then applying a translation.
+    ///
+    /// The result is an Axis-Aligned Bounding Box that encompasses the rotated shape.
+    ///
+    /// Note that the result may not be as tightly fitting as the original, and repeated rotations
+    /// can cause the AABB to grow indefinitely. Avoid applying multiple rotations to the same AABB,
+    /// and consider storing the original AABB and rotating that every time instead.
+    #[inline(always)]
+    fn transform_by(&mut self, translation: Self::Translation, rotation: Self::Rotation) {
+        self.rotate_by(rotation);
+        self.translate_by(translation);
+    }
+
+    #[inline(always)]
+    fn translate_by(&mut self, translation: Self::Translation) {
+        self.min += translation;
+        self.max += translation;
+    }
+
+    /// Rotates the bounding volume around the origin by the given rotation.
+    ///
+    /// The result is an Axis-Aligned Bounding Box that encompasses the rotated shape.
+    ///
+    /// Note that the result may not be as tightly fitting as the original, and repeated rotations
+    /// can cause the AABB to grow indefinitely. Avoid applying multiple rotations to the same AABB,
+    /// and consider storing the original AABB and rotating that every time instead.
+    #[inline(always)]
+    fn rotated_by(mut self, rotation: Self::Rotation) -> Self {
+        self.rotate_by(rotation);
+        self
+    }
+
+    /// Rotates the bounding volume around the origin by the given rotation.
+    ///
+    /// The result is an Axis-Aligned Bounding Box that encompasses the rotated shape.
+    ///
+    /// Note that the result may not be as tightly fitting as the original, and repeated rotations
+    /// can cause the AABB to grow indefinitely. Avoid applying multiple rotations to the same AABB,
+    /// and consider storing the original AABB and rotating that every time instead.
+    #[inline(always)]
+    fn rotate_by(&mut self, rotation: Self::Rotation) {
+        let rot_mat = Mat3::from_quat(rotation);
+        let abs_rot_mat = Mat3::from_cols(
+            rot_mat.x_axis.abs(),
+            rot_mat.y_axis.abs(),
+            rot_mat.z_axis.abs(),
+        );
+        let half_size = abs_rot_mat * self.half_size();
+        *self = Self::new(rot_mat * self.center(), half_size);
+    }
 }
 
 impl IntersectsVolume<Self> for Aabb3d {
@@ -170,7 +237,7 @@ mod aabb3d_tests {
     use super::Aabb3d;
     use crate::{
         bounding::{BoundingSphere, BoundingVolume, IntersectsVolume},
-        Vec3,
+        Quat, Vec3,
     };
 
     #[test]
@@ -273,6 +340,27 @@ mod aabb3d_tests {
         assert!(!shrunk.contains(&a));
     }
 
+    #[test]
+    fn transform() {
+        let a = Aabb3d {
+            min: Vec3::new(-2.0, -2.0, -2.0),
+            max: Vec3::new(2.0, 2.0, 2.0),
+        };
+        let transformed = a.transformed_by(
+            Vec3::new(2.0, -2.0, 4.0),
+            Quat::from_rotation_z(std::f32::consts::FRAC_PI_4),
+        );
+        let half_length = 2_f32.hypot(2.0);
+        assert_eq!(
+            transformed.min,
+            Vec3::new(2.0 - half_length, -half_length - 2.0, 2.0)
+        );
+        assert_eq!(
+            transformed.max,
+            Vec3::new(2.0 + half_length, half_length - 2.0, 6.0)
+        );
+    }
+
     #[test]
     fn closest_point() {
         let aabb = Aabb3d {
@@ -388,11 +476,12 @@ impl BoundingSphere {
 }
 
 impl BoundingVolume for BoundingSphere {
-    type Position = Vec3;
+    type Translation = Vec3;
+    type Rotation = Quat;
     type HalfSize = f32;
 
     #[inline(always)]
-    fn center(&self) -> Self::Position {
+    fn center(&self) -> Self::Translation {
         self.center
     }
 
@@ -451,6 +540,16 @@ impl BoundingVolume for BoundingSphere {
             },
         }
     }
+
+    #[inline(always)]
+    fn translate_by(&mut self, translation: Vec3) {
+        self.center += translation;
+    }
+
+    #[inline(always)]
+    fn rotate_by(&mut self, rotation: Quat) {
+        self.center = rotation * self.center;
+    }
 }
 
 impl IntersectsVolume<Self> for BoundingSphere {
@@ -471,10 +570,12 @@ impl IntersectsVolume<Aabb3d> for BoundingSphere {
 
 #[cfg(test)]
 mod bounding_sphere_tests {
+    use approx::assert_relative_eq;
+
     use super::BoundingSphere;
     use crate::{
         bounding::{BoundingVolume, IntersectsVolume},
-        Vec3,
+        Quat, Vec3,
     };
 
     #[test]
@@ -553,6 +654,20 @@ mod bounding_sphere_tests {
         assert!(!shrunk.contains(&a));
     }
 
+    #[test]
+    fn transform() {
+        let a = BoundingSphere::new(Vec3::ONE, 5.0);
+        let transformed = a.transformed_by(
+            Vec3::new(2.0, -2.0, 4.0),
+            Quat::from_rotation_z(std::f32::consts::FRAC_PI_4),
+        );
+        assert_relative_eq!(
+            transformed.center,
+            Vec3::new(2.0, std::f32::consts::SQRT_2 - 2.0, 5.0)
+        );
+        assert_eq!(transformed.radius(), 5.0);
+    }
+
     #[test]
     fn closest_point() {
         let sphere = BoundingSphere::new(Vec3::ZERO, 1.0);
diff --git a/crates/bevy_math/src/bounding/mod.rs b/crates/bevy_math/src/bounding/mod.rs
index caadf7eb520ce..3fcda1d7069ee 100644
--- a/crates/bevy_math/src/bounding/mod.rs
+++ b/crates/bevy_math/src/bounding/mod.rs
@@ -10,16 +10,20 @@
 /// overlapping elements or finding intersections.
 ///
 /// This trait supports both 2D and 3D bounding shapes.
-pub trait BoundingVolume {
+pub trait BoundingVolume: Sized {
     /// The position type used for the volume. This should be `Vec2` for 2D and `Vec3` for 3D.
-    type Position: Clone + Copy + PartialEq;
+    type Translation: Clone + Copy + PartialEq;
+
+    /// The rotation type used for the volume. This should be `f32` for 2D and `Quat` for 3D.
+    type Rotation: Clone + Copy + PartialEq;
+
     /// The type used for the size of the bounding volume. Usually a half size. For example an
     /// `f32` radius for a circle, or a `Vec3` with half sizes for x, y and z for a 3D axis-aligned
     /// bounding box
     type HalfSize;
 
     /// Returns the center of the bounding volume.
-    fn center(&self) -> Self::Position;
+    fn center(&self) -> Self::Translation;
 
     /// Returns the half size of the bounding volume.
     fn half_size(&self) -> Self::HalfSize;
@@ -38,11 +42,47 @@ pub trait BoundingVolume {
     /// Computes the smallest bounding volume that contains both `self` and `other`.
     fn merge(&self, other: &Self) -> Self;
 
-    /// Increase the size of the bounding volume in each direction by the given amount
+    /// Increases the size of the bounding volume in each direction by the given amount.
     fn grow(&self, amount: Self::HalfSize) -> Self;
 
-    /// Decrease the size of the bounding volume in each direction by the given amount
+    /// Decreases the size of the bounding volume in each direction by the given amount.
     fn shrink(&self, amount: Self::HalfSize) -> Self;
+
+    /// Transforms the bounding volume by first rotating it around the origin and then applying a translation.
+    fn transformed_by(mut self, translation: Self::Translation, rotation: Self::Rotation) -> Self {
+        self.transform_by(translation, rotation);
+        self
+    }
+
+    /// Transforms the bounding volume by first rotating it around the origin and then applying a translation.
+    fn transform_by(&mut self, translation: Self::Translation, rotation: Self::Rotation) {
+        self.rotate_by(rotation);
+        self.translate_by(translation);
+    }
+
+    /// Translates the bounding volume by the given translation.
+    fn translated_by(mut self, translation: Self::Translation) -> Self {
+        self.translate_by(translation);
+        self
+    }
+
+    /// Translates the bounding volume by the given translation.
+    fn translate_by(&mut self, translation: Self::Translation);
+
+    /// Rotates the bounding volume around the origin by the given rotation.
+    ///
+    /// The result is a combination of the original volume and the rotated volume,
+    /// so it is guaranteed to be either the same size or larger than the original.
+    fn rotated_by(mut self, rotation: Self::Rotation) -> Self {
+        self.rotate_by(rotation);
+        self
+    }
+
+    /// Rotates the bounding volume around the origin by the given rotation.
+    ///
+    /// The result is a combination of the original volume and the rotated volume,
+    /// so it is guaranteed to be either the same size or larger than the original.
+    fn rotate_by(&mut self, rotation: Self::Rotation);
 }
 
 /// A trait that generalizes intersection tests against a volume.
diff --git a/crates/bevy_math/src/direction.rs b/crates/bevy_math/src/direction.rs
index 8ac785878f6af..05a600a4f876f 100644
--- a/crates/bevy_math/src/direction.rs
+++ b/crates/bevy_math/src/direction.rs
@@ -38,6 +38,30 @@ impl std::fmt::Display for InvalidDirectionError {
     }
 }
 
+/// Checks that a vector with the given squared length is normalized.
+///
+/// Warns for small error with a length threshold of approximately `1e-4`,
+/// and panics for large error with a length threshold of approximately `1e-2`.
+///
+/// The format used for the logged warning is `"Warning: {warning} The length is {length}`,
+/// and similarly for the error.
+#[cfg(debug_assertions)]
+fn assert_is_normalized(message: &str, length_squared: f32) {
+    let length_error_squared = (length_squared - 1.0).abs();
+
+    // Panic for large error and warn for slight error.
+    if length_error_squared > 2e-2 || length_error_squared.is_nan() {
+        // Length error is approximately 1e-2 or more.
+        panic!("Error: {message} The length is {}.", length_squared.sqrt());
+    } else if length_error_squared > 2e-4 {
+        // Length error is approximately 1e-4 or more.
+        eprintln!(
+            "Warning: {message} The length is {}.",
+            length_squared.sqrt()
+        );
+    }
+}
+
 /// A normalized vector pointing in a direction in 2D space
 #[deprecated(
     since = "0.14.0",
@@ -81,9 +105,13 @@ impl Dir2 {
     ///
     /// # Warning
     ///
-    /// `value` must be normalized, i.e it's length must be `1.0`.
+    /// `value` must be normalized, i.e its length must be `1.0`.
     pub fn new_unchecked(value: Vec2) -> Self {
-        debug_assert!(value.is_normalized());
+        #[cfg(debug_assertions)]
+        assert_is_normalized(
+            "The vector given to `Dir2::new_unchecked` is not normalized.",
+            value.length_squared(),
+        );
 
         Self(value)
     }
@@ -132,6 +160,20 @@ impl std::ops::Neg for Dir2 {
     }
 }
 
+impl std::ops::Mul<f32> for Dir2 {
+    type Output = Vec2;
+    fn mul(self, rhs: f32) -> Self::Output {
+        self.0 * rhs
+    }
+}
+
+impl std::ops::Mul<Dir2> for f32 {
+    type Output = Vec2;
+    fn mul(self, rhs: Dir2) -> Self::Output {
+        self * rhs.0
+    }
+}
+
 #[cfg(feature = "approx")]
 impl approx::AbsDiffEq for Dir2 {
     type Epsilon = f32;
@@ -197,9 +239,13 @@ impl Dir3 {
     ///
     /// # Warning
     ///
-    /// `value` must be normalized, i.e it's length must be `1.0`.
+    /// `value` must be normalized, i.e its length must be `1.0`.
     pub fn new_unchecked(value: Vec3) -> Self {
-        debug_assert!(value.is_normalized());
+        #[cfg(debug_assertions)]
+        assert_is_normalized(
+            "The vector given to `Dir3::new_unchecked` is not normalized.",
+            value.length_squared(),
+        );
 
         Self(value)
     }
@@ -261,6 +307,13 @@ impl std::ops::Mul<f32> for Dir3 {
     }
 }
 
+impl std::ops::Mul<Dir3> for f32 {
+    type Output = Vec3;
+    fn mul(self, rhs: Dir3) -> Self::Output {
+        self * rhs.0
+    }
+}
+
 impl std::ops::Mul<Dir3> for Quat {
     type Output = Dir3;
 
@@ -268,11 +321,13 @@ impl std::ops::Mul<Dir3> for Quat {
     fn mul(self, direction: Dir3) -> Self::Output {
         let rotated = self * *direction;
 
-        // Make sure the result is normalized.
-        // This can fail for non-unit quaternions.
-        debug_assert!(rotated.is_normalized());
+        #[cfg(debug_assertions)]
+        assert_is_normalized(
+            "`Dir3` is denormalized after rotation.",
+            rotated.length_squared(),
+        );
 
-        Dir3::new_unchecked(rotated)
+        Dir3(rotated)
     }
 }
 
@@ -344,9 +399,13 @@ impl Dir3A {
     ///
     /// # Warning
     ///
-    /// `value` must be normalized, i.e it's length must be `1.0`.
+    /// `value` must be normalized, i.e its length must be `1.0`.
     pub fn new_unchecked(value: Vec3A) -> Self {
-        debug_assert!(value.is_normalized());
+        #[cfg(debug_assertions)]
+        assert_is_normalized(
+            "The vector given to `Dir3A::new_unchecked` is not normalized.",
+            value.length_squared(),
+        );
 
         Self(value)
     }
@@ -408,6 +467,13 @@ impl std::ops::Mul<f32> for Dir3A {
     }
 }
 
+impl std::ops::Mul<Dir3A> for f32 {
+    type Output = Vec3A;
+    fn mul(self, rhs: Dir3A) -> Self::Output {
+        self * rhs.0
+    }
+}
+
 impl std::ops::Mul<Dir3A> for Quat {
     type Output = Dir3A;
 
@@ -415,11 +481,13 @@ impl std::ops::Mul<Dir3A> for Quat {
     fn mul(self, direction: Dir3A) -> Self::Output {
         let rotated = self * *direction;
 
-        // Make sure the result is normalized.
-        // This can fail for non-unit quaternions.
-        debug_assert!(rotated.is_normalized());
+        #[cfg(debug_assertions)]
+        assert_is_normalized(
+            "`Dir3A` is denormalized after rotation.",
+            rotated.length_squared(),
+        );
 
-        Dir3A::new_unchecked(rotated)
+        Dir3A(rotated)
     }
 }
 
diff --git a/crates/bevy_pbr/Cargo.toml b/crates/bevy_pbr/Cargo.toml
index 1e05323c85ca3..28e24aab94c70 100644
--- a/crates/bevy_pbr/Cargo.toml
+++ b/crates/bevy_pbr/Cargo.toml
@@ -40,6 +40,7 @@ fixedbitset = "0.4"
 bytemuck = { version = "1", features = ["derive"] }
 radsort = "0.1"
 smallvec = "1.6"
+nonmax = "0.5"
 
 [lints]
 workspace = true
diff --git a/crates/bevy_pbr/src/lib.rs b/crates/bevy_pbr/src/lib.rs
index bc06f4d34d775..9258cf9f91ab8 100644
--- a/crates/bevy_pbr/src/lib.rs
+++ b/crates/bevy_pbr/src/lib.rs
@@ -234,13 +234,9 @@ impl Plugin for PbrPlugin {
 
         app.register_asset_reflect::<StandardMaterial>()
             .register_type::<AmbientLight>()
-            .register_type::<Cascade>()
             .register_type::<CascadeShadowConfig>()
-            .register_type::<Cascades>()
             .register_type::<CascadesVisibleEntities>()
             .register_type::<ClusterConfig>()
-            .register_type::<ClusterFarZMode>()
-            .register_type::<ClusterZConfig>()
             .register_type::<CubemapVisibleEntities>()
             .register_type::<DirectionalLight>()
             .register_type::<DirectionalLightShadowMap>()
@@ -250,10 +246,7 @@ impl Plugin for PbrPlugin {
             .register_type::<PointLightShadowMap>()
             .register_type::<SpotLight>()
             .register_type::<FogSettings>()
-            .register_type::<FogFalloff>()
             .register_type::<ShadowFilteringMethod>()
-            .register_type::<ParallaxMappingMethod>()
-            .register_type::<OpaqueRendererMethod>()
             .init_resource::<AmbientLight>()
             .init_resource::<GlobalVisiblePointLights>()
             .init_resource::<DirectionalLightShadowMap>()
diff --git a/crates/bevy_pbr/src/light.rs b/crates/bevy_pbr/src/light.rs
index ac94689bc3089..e131d92d2c3ca 100644
--- a/crates/bevy_pbr/src/light.rs
+++ b/crates/bevy_pbr/src/light.rs
@@ -589,7 +589,7 @@ fn calculate_cascade(
 
     // It is critical for `world_to_cascade` to be stable. So rather than forming `cascade_to_world`
     // and inverting it, which risks instability due to numerical precision, we directly form
-    // `world_to_cascde` as the reference material suggests.
+    // `world_to_cascade` as the reference material suggests.
     let light_to_world_transpose = light_to_world.transpose();
     let world_to_cascade = Mat4::from_cols(
         light_to_world_transpose.x_axis,
diff --git a/crates/bevy_pbr/src/pbr_material.rs b/crates/bevy_pbr/src/pbr_material.rs
index a83509267d2ec..3231cb8df5d6d 100644
--- a/crates/bevy_pbr/src/pbr_material.rs
+++ b/crates/bevy_pbr/src/pbr_material.rs
@@ -59,7 +59,16 @@ pub struct StandardMaterial {
     ///
     /// The default emissive color is [`Color::BLACK`], which doesn't add anything to the material color.
     ///
-    /// Note that **an emissive material won't light up surrounding areas like a light source**,
+    /// To increase emissive strength, channel values for `emissive`
+    /// colors can exceed `1.0`. For instance, a `base_color` of
+    /// `Color::linear_rgb(1.0, 0.0, 0.0)` represents the brightest
+    /// red for objects that reflect light, but an emissive color
+    /// like `Color::linear_rgb(1000.0, 0.0, 0.0)` can be used to create
+    /// intensely bright red emissive effects.
+    ///
+    /// Increasing the emissive strength of the color will impact visual effects
+    /// like bloom, but it's important to note that **an emissive material won't
+    /// light up surrounding areas like a light source**,
     /// it just adds a value to the color seen on screen.
     pub emissive: Color,
 
@@ -727,7 +736,9 @@ impl AsBindGroupShaderType<StandardMaterialUniform> for StandardMaterial {
             thickness: self.thickness,
             ior: self.ior,
             attenuation_distance: self.attenuation_distance,
-            attenuation_color: LinearRgba::from(self.base_color).to_f32_array().into(),
+            attenuation_color: LinearRgba::from(self.attenuation_color)
+                .to_f32_array()
+                .into(),
             flags: flags.bits(),
             alpha_cutoff,
             parallax_depth_scale: self.parallax_depth_scale,
diff --git a/crates/bevy_pbr/src/render/light.rs b/crates/bevy_pbr/src/render/light.rs
index 54eec9411159a..061c34a8b2f3b 100644
--- a/crates/bevy_pbr/src/render/light.rs
+++ b/crates/bevy_pbr/src/render/light.rs
@@ -5,7 +5,7 @@ use bevy_math::{Mat4, UVec3, UVec4, Vec2, Vec3, Vec3Swizzles, Vec4, Vec4Swizzles
 use bevy_render::{
     camera::Camera,
     mesh::Mesh,
-    primitives::{CascadesFrusta, CubemapFrusta, Frustum},
+    primitives::{CascadesFrusta, CubemapFrusta, Frustum, HalfSpace},
     render_asset::RenderAssets,
     render_graph::{Node, NodeRunError, RenderGraphContext},
     render_phase::*,
@@ -18,10 +18,8 @@ use bevy_render::{
 use bevy_transform::{components::GlobalTransform, prelude::Transform};
 #[cfg(feature = "trace")]
 use bevy_utils::tracing::info_span;
-use bevy_utils::{
-    nonmax::NonMaxU32,
-    tracing::{error, warn},
-};
+use bevy_utils::tracing::{error, warn};
+use nonmax::NonMaxU32;
 use std::{hash::Hash, num::NonZeroU64, ops::Range};
 
 use crate::*;
@@ -1144,7 +1142,7 @@ pub fn prepare_lights(
                 .unwrap()
                 .iter()
                 .take(MAX_CASCADES_PER_LIGHT);
-            for (cascade_index, ((cascade, frusta), bound)) in cascades
+            for (cascade_index, ((cascade, frustum), bound)) in cascades
                 .zip(frusta)
                 .zip(&light.cascade_shadow_config.bounds)
                 .enumerate()
@@ -1171,6 +1169,11 @@ pub fn prepare_lights(
                         });
                 directional_depth_texture_array_index += 1;
 
+                let mut frustum = *frustum;
+                // Push the near clip plane out to infinity for directional lights
+                frustum.half_spaces[4] =
+                    HalfSpace::new(frustum.half_spaces[4].normal().extend(f32::INFINITY));
+
                 let view_light_entity = commands
                     .spawn((
                         ShadowView {
@@ -1191,7 +1194,7 @@ pub fn prepare_lights(
                             hdr: false,
                             color_grading: Default::default(),
                         },
-                       *frusta,
+                        frustum,
                         RenderPhase::<Shadow>::default(),
                         LightEntity::Directional {
                             light_entity,
diff --git a/crates/bevy_ptr/src/lib.rs b/crates/bevy_ptr/src/lib.rs
index d26cc1fcb2a5e..d6c0322461528 100644
--- a/crates/bevy_ptr/src/lib.rs
+++ b/crates/bevy_ptr/src/lib.rs
@@ -26,6 +26,119 @@ mod sealed {
     impl Sealed for super::Unaligned {}
 }
 
+/// A newtype around [`NonNull`] that only allows conversion to read-only borrows or pointers.
+///
+/// This type can be thought of as the `*const T` to [`NonNull<T>`]'s `*mut T`.
+#[repr(transparent)]
+pub struct ConstNonNull<T: ?Sized>(NonNull<T>);
+
+impl<T: ?Sized> ConstNonNull<T> {
+    /// Creates a new `ConstNonNull` if `ptr` is non-null.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bevy_ptr::ConstNonNull;
+    ///
+    /// let x = 0u32;
+    /// let ptr = ConstNonNull::<u32>::new(&x as *const _).expect("ptr is null!");
+    ///
+    /// if let Some(ptr) = ConstNonNull::<u32>::new(std::ptr::null()) {
+    ///     unreachable!();
+    /// }
+    /// ```
+    pub fn new(ptr: *const T) -> Option<Self> {
+        NonNull::new(ptr.cast_mut()).map(Self)
+    }
+
+    /// Creates a new `ConstNonNull`.
+    ///
+    /// # Safety
+    ///
+    /// `ptr` must be non-null.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bevy_ptr::ConstNonNull;
+    ///
+    /// let x = 0u32;
+    /// let ptr = unsafe { ConstNonNull::new_unchecked(&x as *const _) };
+    /// ```
+    ///
+    /// *Incorrect* usage of this function:
+    ///
+    /// ```rust,no_run
+    /// use bevy_ptr::ConstNonNull;
+    ///
+    /// // NEVER DO THAT!!! This is undefined behavior. ⚠️
+    /// let ptr = unsafe { ConstNonNull::<u32>::new_unchecked(std::ptr::null()) };
+    /// ```
+    pub const unsafe fn new_unchecked(ptr: *const T) -> Self {
+        // SAFETY: This function's safety invariants are identical to `NonNull::new_unchecked`
+        // The caller must satisfy all of them.
+        unsafe { Self(NonNull::new_unchecked(ptr.cast_mut())) }
+    }
+
+    /// Returns a shared reference to the value.
+    ///
+    /// # Safety
+    ///
+    /// When calling this method, you have to ensure that all of the following is true:
+    ///
+    /// * The pointer must be properly aligned.
+    ///
+    /// * It must be "dereferenceable" in the sense defined in [the module documentation].
+    ///
+    /// * The pointer must point to an initialized instance of `T`.
+    ///
+    /// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is
+    ///   arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.
+    ///   In particular, while this reference exists, the memory the pointer points to must
+    ///   not get mutated (except inside `UnsafeCell`).
+    ///
+    /// This applies even if the result of this method is unused!
+    /// (The part about being initialized is not yet fully decided, but until
+    /// it is, the only safe approach is to ensure that they are indeed initialized.)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bevy_ptr::ConstNonNull;
+    ///
+    /// let mut x = 0u32;
+    /// let ptr = ConstNonNull::new(&mut x as *mut _).expect("ptr is null!");
+    ///
+    /// let ref_x = unsafe { ptr.as_ref() };
+    /// println!("{ref_x}");
+    /// ```
+    ///
+    /// [the module documentation]: core::ptr#safety
+    #[inline]
+    pub unsafe fn as_ref<'a>(&self) -> &'a T {
+        // SAFETY: This function's safety invariants are identical to `NonNull::as_ref`
+        // The caller must satisfy all of them.
+        unsafe { self.0.as_ref() }
+    }
+}
+
+impl<T: ?Sized> From<NonNull<T>> for ConstNonNull<T> {
+    fn from(value: NonNull<T>) -> ConstNonNull<T> {
+        ConstNonNull(value)
+    }
+}
+
+impl<'a, T: ?Sized> From<&'a T> for ConstNonNull<T> {
+    fn from(value: &'a T) -> ConstNonNull<T> {
+        ConstNonNull(NonNull::from(value))
+    }
+}
+
+impl<'a, T: ?Sized> From<&'a mut T> for ConstNonNull<T> {
+    fn from(value: &'a mut T) -> ConstNonNull<T> {
+        ConstNonNull(NonNull::from(value))
+    }
+}
 /// Type-erased borrow of some unknown type chosen when constructing this type.
 ///
 /// This type tries to act "borrow-like" which means that:
@@ -280,6 +393,7 @@ impl<'a> OwningPtr<'a> {
         f(unsafe { PtrMut::from(&mut *temp).promote() })
     }
 }
+
 impl<'a, A: IsAligned> OwningPtr<'a, A> {
     /// Creates a new instance from a raw pointer.
     ///
@@ -346,6 +460,7 @@ impl<'a, A: IsAligned> OwningPtr<'a, A> {
         unsafe { PtrMut::new(self.0) }
     }
 }
+
 impl<'a> OwningPtr<'a, Unaligned> {
     /// Consumes the [`OwningPtr`] to obtain ownership of the underlying data of type `T`.
     ///
diff --git a/crates/bevy_reflect/Cargo.toml b/crates/bevy_reflect/Cargo.toml
index fccab4f5cca03..3a197c692c4d9 100644
--- a/crates/bevy_reflect/Cargo.toml
+++ b/crates/bevy_reflect/Cargo.toml
@@ -10,12 +10,13 @@ keywords = ["bevy"]
 readme = "README.md"
 
 [features]
-default = []
+default = ["smallvec"]
 # When enabled, provides Bevy-related reflection implementations
 bevy = ["smallvec", "bevy_math", "smol_str"]
 glam = ["dep:glam"]
 bevy_math = ["glam", "dep:bevy_math"]
-smallvec = []
+smallvec = ["dep:smallvec"]
+uuid = ["dep:uuid"]
 # When enabled, allows documentation comments to be accessed via reflection
 documentation = ["bevy_reflect_derive/documentation"]
 
@@ -33,9 +34,11 @@ erased-serde = "0.4"
 downcast-rs = "1.2"
 thiserror = "1.0"
 serde = "1"
+smallvec = { version = "1.11", optional = true }
 
 glam = { version = "0.25", features = ["serde"], optional = true }
 smol_str = { version = "0.2.0", optional = true }
+uuid = { version = "1.0", optional = true, features = ["v4", "serde"] }
 
 [dev-dependencies]
 ron = "0.8.0"
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 869ca861328c3..48625ec3ca283 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/derive_data.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/derive_data.rs
@@ -470,7 +470,12 @@ impl<'a> ReflectMeta<'a> {
         &self,
         where_clause_options: &WhereClauseOptions,
     ) -> proc_macro2::TokenStream {
-        crate::registration::impl_get_type_registration(self, where_clause_options, None)
+        crate::registration::impl_get_type_registration(
+            self,
+            where_clause_options,
+            None,
+            Option::<std::iter::Empty<&Type>>::None,
+        )
     }
 
     /// The collection of docstrings for this type, if any.
@@ -502,6 +507,7 @@ impl<'a> ReflectStruct<'a> {
             self.meta(),
             where_clause_options,
             self.serialization_data(),
+            Some(self.active_types().iter()),
         )
     }
 
@@ -512,22 +518,21 @@ impl<'a> ReflectStruct<'a> {
             .collect()
     }
 
-    /// Get an iterator of fields which are exposed to the reflection API
+    /// Get an iterator of fields which are exposed to the reflection API.
     pub fn active_fields(&self) -> impl Iterator<Item = &StructField<'a>> {
-        self.fields
+        self.fields()
             .iter()
             .filter(|field| field.attrs.ignore.is_active())
     }
 
     /// Get an iterator of fields which are ignored by the reflection API
     pub fn ignored_fields(&self) -> impl Iterator<Item = &StructField<'a>> {
-        self.fields
+        self.fields()
             .iter()
             .filter(|field| field.attrs.ignore.is_ignored())
     }
 
     /// The complete set of fields in this struct.
-    #[allow(dead_code)]
     pub fn fields(&self) -> &[StructField<'a>] {
         &self.fields
     }
@@ -573,6 +578,21 @@ impl<'a> ReflectEnum<'a> {
     pub fn where_clause_options(&self) -> WhereClauseOptions {
         WhereClauseOptions::new_with_fields(self.meta(), self.active_types().into_boxed_slice())
     }
+
+    /// Returns the `GetTypeRegistration` impl as a `TokenStream`.
+    ///
+    /// Returns a specific implementation for enums and this method should be preferred over the generic [`get_type_registration`](crate::ReflectMeta) method
+    pub fn get_type_registration(
+        &self,
+        where_clause_options: &WhereClauseOptions,
+    ) -> proc_macro2::TokenStream {
+        crate::registration::impl_get_type_registration(
+            self.meta(),
+            where_clause_options,
+            None,
+            Some(self.active_fields().map(|field| &field.data.ty)),
+        )
+    }
 }
 
 impl<'a> EnumVariant<'a> {
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/impls/enums.rs b/crates/bevy_reflect/bevy_reflect_derive/src/impls/enums.rs
index 65aea76b9627d..056a293ec91be 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/impls/enums.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/impls/enums.rs
@@ -84,9 +84,7 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
 
     let type_path_impl = impl_type_path(reflect_enum.meta());
 
-    let get_type_registration_impl = reflect_enum
-        .meta()
-        .get_type_registration(&where_clause_options);
+    let get_type_registration_impl = reflect_enum.get_type_registration(&where_clause_options);
 
     let (impl_generics, ty_generics, where_clause) =
         reflect_enum.meta().type_path().generics().split_for_impl();
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/registration.rs b/crates/bevy_reflect/bevy_reflect_derive/src/registration.rs
index 04189073a3886..d277d823c59f9 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/registration.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/registration.rs
@@ -4,17 +4,29 @@ use crate::derive_data::ReflectMeta;
 use crate::serialization::SerializationDataDef;
 use crate::utility::WhereClauseOptions;
 use quote::quote;
+use syn::Type;
 
 /// Creates the `GetTypeRegistration` impl for the given type data.
 #[allow(clippy::too_many_arguments)]
-pub(crate) fn impl_get_type_registration(
+pub(crate) fn impl_get_type_registration<'a>(
     meta: &ReflectMeta,
     where_clause_options: &WhereClauseOptions,
     serialization_data: Option<&SerializationDataDef>,
+    type_dependencies: Option<impl Iterator<Item = &'a Type>>,
 ) -> proc_macro2::TokenStream {
     let type_path = meta.type_path();
     let bevy_reflect_path = meta.bevy_reflect_path();
     let registration_data = meta.attrs().idents();
+
+    let type_deps_fn = type_dependencies.map(|deps| {
+        quote! {
+            #[inline(never)]
+            fn register_type_dependencies(registry: &mut #bevy_reflect_path::TypeRegistry) {
+                #(<#deps as #bevy_reflect_path::__macro_exports::RegisterForReflection>::__register(registry);)*
+            }
+        }
+    });
+
     let (impl_generics, ty_generics, where_clause) = type_path.generics().split_for_impl();
     let where_reflect_clause = where_clause_options.extend_where_clause(where_clause);
 
@@ -44,6 +56,8 @@ pub(crate) fn impl_get_type_registration(
                 #(registration.insert::<#registration_data>(#bevy_reflect_path::FromType::<Self>::from_type());)*
                 registration
             }
+
+            #type_deps_fn
         }
     }
 }
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/utility.rs b/crates/bevy_reflect/bevy_reflect_derive/src/utility.rs
index 5e619cf1ade45..a32fcabeea640 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/utility.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/utility.rs
@@ -217,11 +217,15 @@ impl<'a, 'b> WhereClauseOptions<'a, 'b> {
 
             // `TypePath` is always required for active fields since they are used to
             // construct `NamedField` and `UnnamedField` instances for the `Typed` impl.
-            Some(
-                self.active_fields
-                    .iter()
-                    .map(move |ty| quote!(#ty : #reflect_bound + #bevy_reflect_path::TypePath)),
-            )
+            // Likewise, `GetTypeRegistration` is always required for active fields since
+            // they are used to register the type's dependencies.
+            Some(self.active_fields.iter().map(move |ty| {
+                quote!(
+                    #ty : #reflect_bound
+                        + #bevy_reflect_path::TypePath
+                        + #bevy_reflect_path::__macro_exports::RegisterForReflection
+                )
+            }))
         }
     }
 
diff --git a/crates/bevy_reflect/src/impls/smallvec.rs b/crates/bevy_reflect/src/impls/smallvec.rs
index a911b3b2fdc0e..b27c7a1e1ae9f 100644
--- a/crates/bevy_reflect/src/impls/smallvec.rs
+++ b/crates/bevy_reflect/src/impls/smallvec.rs
@@ -1,5 +1,4 @@
 use bevy_reflect_derive::impl_type_path;
-use bevy_utils::smallvec;
 use smallvec::SmallVec;
 
 use std::any::Any;
@@ -154,7 +153,7 @@ where
     }
 }
 
-impl_type_path!(::bevy_utils::smallvec::SmallVec<T: smallvec::Array>);
+impl_type_path!(::smallvec::SmallVec<T: smallvec::Array>);
 
 impl<T: smallvec::Array + TypePath + Send + Sync> FromReflect for SmallVec<T>
 where
diff --git a/crates/bevy_reflect/src/impls/std.rs b/crates/bevy_reflect/src/impls/std.rs
index 07500814d0263..578879091bfcc 100644
--- a/crates/bevy_reflect/src/impls/std.rs
+++ b/crates/bevy_reflect/src/impls/std.rs
@@ -1,5 +1,5 @@
 use crate::std_traits::ReflectDefault;
-use crate::{self as bevy_reflect, ReflectFromPtr, ReflectFromReflect, ReflectOwned};
+use crate::{self as bevy_reflect, ReflectFromPtr, ReflectFromReflect, ReflectOwned, TypeRegistry};
 use crate::{
     impl_type_path, map_apply, map_partial_eq, Array, ArrayInfo, ArrayIter, DynamicEnum,
     DynamicMap, Enum, EnumInfo, FromReflect, FromType, GetTypeRegistration, List, ListInfo,
@@ -221,7 +221,7 @@ impl_reflect_value!(::std::ffi::OsString(Debug, Hash, PartialEq));
 
 macro_rules! impl_reflect_for_veclike {
     ($ty:path, $insert:expr, $remove:expr, $push:expr, $pop:expr, $sub:ty) => {
-        impl<T: FromReflect + TypePath> List for $ty {
+        impl<T: FromReflect + TypePath + GetTypeRegistration> List for $ty {
             #[inline]
             fn get(&self, index: usize) -> Option<&dyn Reflect> {
                 <$sub>::get(self, index).map(|value| value as &dyn Reflect)
@@ -280,7 +280,7 @@ macro_rules! impl_reflect_for_veclike {
             }
         }
 
-        impl<T: FromReflect + TypePath> Reflect for $ty {
+        impl<T: FromReflect + TypePath + GetTypeRegistration> Reflect for $ty {
             fn get_represented_type_info(&self) -> Option<&'static TypeInfo> {
                 Some(<Self as Typed>::type_info())
             }
@@ -347,7 +347,7 @@ macro_rules! impl_reflect_for_veclike {
             }
         }
 
-        impl<T: FromReflect + TypePath> Typed for $ty {
+        impl<T: FromReflect + TypePath + GetTypeRegistration> Typed for $ty {
             fn type_info() -> &'static TypeInfo {
                 static CELL: GenericTypeInfoCell = GenericTypeInfoCell::new();
                 CELL.get_or_insert::<Self, _>(|| TypeInfo::List(ListInfo::new::<Self, T>()))
@@ -356,15 +356,19 @@ macro_rules! impl_reflect_for_veclike {
 
         impl_type_path!($ty);
 
-        impl<T: FromReflect + TypePath> GetTypeRegistration for $ty {
+        impl<T: FromReflect + TypePath + GetTypeRegistration> GetTypeRegistration for $ty {
             fn get_type_registration() -> TypeRegistration {
                 let mut registration = TypeRegistration::of::<$ty>();
                 registration.insert::<ReflectFromPtr>(FromType::<$ty>::from_type());
                 registration
             }
+
+            fn register_type_dependencies(registry: &mut TypeRegistry) {
+                registry.register::<T>();
+            }
         }
 
-        impl<T: FromReflect + TypePath> FromReflect for $ty {
+        impl<T: FromReflect + TypePath + GetTypeRegistration> FromReflect for $ty {
             fn from_reflect(reflect: &dyn Reflect) -> Option<Self> {
                 if let ReflectRef::List(ref_list) = reflect.reflect_ref() {
                     let mut new_list = Self::with_capacity(ref_list.len());
@@ -401,8 +405,8 @@ macro_rules! impl_reflect_for_hashmap {
     ($ty:path) => {
         impl<K, V, S> Map for $ty
         where
-            K: FromReflect + TypePath + Eq + Hash,
-            V: FromReflect + TypePath,
+            K: FromReflect + TypePath + GetTypeRegistration + Eq + Hash,
+            V: FromReflect + TypePath + GetTypeRegistration,
             S: TypePath + BuildHasher + Send + Sync,
         {
             fn get(&self, key: &dyn Reflect) -> Option<&dyn Reflect> {
@@ -498,8 +502,8 @@ macro_rules! impl_reflect_for_hashmap {
 
         impl<K, V, S> Reflect for $ty
         where
-            K: FromReflect + TypePath + Eq + Hash,
-            V: FromReflect + TypePath,
+            K: FromReflect + TypePath + GetTypeRegistration + Eq + Hash,
+            V: FromReflect + TypePath + GetTypeRegistration,
             S: TypePath + BuildHasher + Send + Sync,
         {
             fn get_represented_type_info(&self) -> Option<&'static TypeInfo> {
@@ -567,8 +571,8 @@ macro_rules! impl_reflect_for_hashmap {
 
         impl<K, V, S> Typed for $ty
         where
-            K: FromReflect + TypePath + Eq + Hash,
-            V: FromReflect + TypePath,
+            K: FromReflect + TypePath + GetTypeRegistration + Eq + Hash,
+            V: FromReflect + TypePath + GetTypeRegistration,
             S: TypePath + BuildHasher + Send + Sync,
         {
             fn type_info() -> &'static TypeInfo {
@@ -579,8 +583,8 @@ macro_rules! impl_reflect_for_hashmap {
 
         impl<K, V, S> GetTypeRegistration for $ty
         where
-            K: FromReflect + TypePath + Eq + Hash,
-            V: FromReflect + TypePath,
+            K: FromReflect + TypePath + GetTypeRegistration + Eq + Hash,
+            V: FromReflect + TypePath + GetTypeRegistration,
             S: TypePath + BuildHasher + Send + Sync,
         {
             fn get_type_registration() -> TypeRegistration {
@@ -588,12 +592,17 @@ macro_rules! impl_reflect_for_hashmap {
                 registration.insert::<ReflectFromPtr>(FromType::<Self>::from_type());
                 registration
             }
+
+            fn register_type_dependencies(registry: &mut TypeRegistry) {
+                registry.register::<K>();
+                registry.register::<V>();
+            }
         }
 
         impl<K, V, S> FromReflect for $ty
         where
-            K: FromReflect + TypePath + Eq + Hash,
-            V: FromReflect + TypePath,
+            K: FromReflect + TypePath + GetTypeRegistration + Eq + Hash,
+            V: FromReflect + TypePath + GetTypeRegistration,
             S: TypePath + BuildHasher + Default + Send + Sync,
         {
             fn from_reflect(reflect: &dyn Reflect) -> Option<Self> {
@@ -624,8 +633,8 @@ impl_type_path!(::bevy_utils::hashbrown::HashMap<K, V, S>);
 
 impl<K, V> Map for ::std::collections::BTreeMap<K, V>
 where
-    K: FromReflect + TypePath + Eq + Ord,
-    V: FromReflect + TypePath,
+    K: FromReflect + TypePath + GetTypeRegistration + Eq + Ord,
+    V: FromReflect + TypePath + GetTypeRegistration,
 {
     fn get(&self, key: &dyn Reflect) -> Option<&dyn Reflect> {
         key.downcast_ref::<K>()
@@ -720,8 +729,8 @@ where
 
 impl<K, V> Reflect for ::std::collections::BTreeMap<K, V>
 where
-    K: FromReflect + TypePath + Eq + Ord,
-    V: FromReflect + TypePath,
+    K: FromReflect + TypePath + GetTypeRegistration + Eq + Ord,
+    V: FromReflect + TypePath + GetTypeRegistration,
 {
     fn get_represented_type_info(&self) -> Option<&'static TypeInfo> {
         Some(<Self as Typed>::type_info())
@@ -788,8 +797,8 @@ where
 
 impl<K, V> Typed for ::std::collections::BTreeMap<K, V>
 where
-    K: FromReflect + TypePath + Eq + Ord,
-    V: FromReflect + TypePath,
+    K: FromReflect + TypePath + GetTypeRegistration + Eq + Ord,
+    V: FromReflect + TypePath + GetTypeRegistration,
 {
     fn type_info() -> &'static TypeInfo {
         static CELL: GenericTypeInfoCell = GenericTypeInfoCell::new();
@@ -799,8 +808,8 @@ where
 
 impl<K, V> GetTypeRegistration for ::std::collections::BTreeMap<K, V>
 where
-    K: FromReflect + TypePath + Eq + Ord,
-    V: FromReflect + TypePath,
+    K: FromReflect + TypePath + GetTypeRegistration + Eq + Ord,
+    V: FromReflect + TypePath + GetTypeRegistration,
 {
     fn get_type_registration() -> TypeRegistration {
         let mut registration = TypeRegistration::of::<Self>();
@@ -811,8 +820,8 @@ where
 
 impl<K, V> FromReflect for ::std::collections::BTreeMap<K, V>
 where
-    K: FromReflect + TypePath + Eq + Ord,
-    V: FromReflect + TypePath,
+    K: FromReflect + TypePath + GetTypeRegistration + Eq + Ord,
+    V: FromReflect + TypePath + GetTypeRegistration,
 {
     fn from_reflect(reflect: &dyn Reflect) -> Option<Self> {
         if let ReflectRef::Map(ref_map) = reflect.reflect_ref() {
@@ -831,7 +840,7 @@ where
 
 impl_type_path!(::std::collections::BTreeMap<K, V>);
 
-impl<T: Reflect + TypePath, const N: usize> Array for [T; N] {
+impl<T: Reflect + TypePath + GetTypeRegistration, const N: usize> Array for [T; N] {
     #[inline]
     fn get(&self, index: usize) -> Option<&dyn Reflect> {
         <[T]>::get(self, index).map(|value| value as &dyn Reflect)
@@ -860,7 +869,7 @@ impl<T: Reflect + TypePath, const N: usize> Array for [T; N] {
     }
 }
 
-impl<T: Reflect + TypePath, const N: usize> Reflect for [T; N] {
+impl<T: Reflect + TypePath + GetTypeRegistration, const N: usize> Reflect for [T; N] {
     fn get_represented_type_info(&self) -> Option<&'static TypeInfo> {
         Some(<Self as Typed>::type_info())
     }
@@ -942,7 +951,7 @@ impl<T: Reflect + TypePath, const N: usize> Reflect for [T; N] {
     }
 }
 
-impl<T: FromReflect + TypePath, const N: usize> FromReflect for [T; N] {
+impl<T: FromReflect + TypePath + GetTypeRegistration, const N: usize> FromReflect for [T; N] {
     fn from_reflect(reflect: &dyn Reflect) -> Option<Self> {
         if let ReflectRef::Array(ref_array) = reflect.reflect_ref() {
             let mut temp_vec = Vec::with_capacity(ref_array.len());
@@ -956,7 +965,7 @@ impl<T: FromReflect + TypePath, const N: usize> FromReflect for [T; N] {
     }
 }
 
-impl<T: Reflect + TypePath, const N: usize> Typed for [T; N] {
+impl<T: Reflect + TypePath + GetTypeRegistration, const N: usize> Typed for [T; N] {
     fn type_info() -> &'static TypeInfo {
         static CELL: GenericTypeInfoCell = GenericTypeInfoCell::new();
         CELL.get_or_insert::<Self, _>(|| TypeInfo::Array(ArrayInfo::new::<Self, T>(N)))
@@ -975,37 +984,27 @@ impl<T: TypePath, const N: usize> TypePath for [T; N] {
     }
 }
 
-// TODO:
-// `FromType::from_type` requires `Deserialize<'de>` to be implemented for `T`.
-// Currently serde only supports `Deserialize<'de>` for arrays up to size 32.
-// This can be changed to use const generics once serde utilizes const generics for arrays.
-// Tracking issue: https://github.com/serde-rs/serde/issues/1937
-macro_rules! impl_array_get_type_registration {
-    ($($N:expr)+) => {
-        $(
-            impl<T: Reflect + TypePath> GetTypeRegistration for [T; $N] {
-                fn get_type_registration() -> TypeRegistration {
-                    TypeRegistration::of::<[T; $N]>()
-                }
-            }
-        )+
-    };
-}
+impl<T: Reflect + TypePath + GetTypeRegistration, const N: usize> GetTypeRegistration for [T; N] {
+    fn get_type_registration() -> TypeRegistration {
+        TypeRegistration::of::<[T; N]>()
+    }
 
-impl_array_get_type_registration! {
-     0  1  2  3  4  5  6  7  8  9
-    10 11 12 13 14 15 16 17 18 19
-    20 21 22 23 24 25 26 27 28 29
-    30 31 32
+    fn register_type_dependencies(registry: &mut TypeRegistry) {
+        registry.register::<T>();
+    }
 }
 
-impl<T: FromReflect + TypePath> GetTypeRegistration for Option<T> {
+impl<T: FromReflect + TypePath + GetTypeRegistration> GetTypeRegistration for Option<T> {
     fn get_type_registration() -> TypeRegistration {
         TypeRegistration::of::<Option<T>>()
     }
+
+    fn register_type_dependencies(registry: &mut TypeRegistry) {
+        registry.register::<T>();
+    }
 }
 
-impl<T: FromReflect + TypePath> Enum for Option<T> {
+impl<T: FromReflect + TypePath + GetTypeRegistration> Enum for Option<T> {
     fn field(&self, _name: &str) -> Option<&dyn Reflect> {
         None
     }
@@ -1076,7 +1075,7 @@ impl<T: FromReflect + TypePath> Enum for Option<T> {
     }
 }
 
-impl<T: FromReflect + TypePath> Reflect for Option<T> {
+impl<T: FromReflect + TypePath + GetTypeRegistration> Reflect for Option<T> {
     #[inline]
     fn get_represented_type_info(&self) -> Option<&'static TypeInfo> {
         Some(<Self as Typed>::type_info())
@@ -1189,7 +1188,7 @@ impl<T: FromReflect + TypePath> Reflect for Option<T> {
     }
 }
 
-impl<T: FromReflect + TypePath> FromReflect for Option<T> {
+impl<T: FromReflect + TypePath + GetTypeRegistration> FromReflect for Option<T> {
     fn from_reflect(reflect: &dyn Reflect) -> Option<Self> {
         if let ReflectRef::Enum(dyn_enum) = reflect.reflect_ref() {
             match dyn_enum.variant_name() {
@@ -1227,7 +1226,7 @@ impl<T: FromReflect + TypePath> FromReflect for Option<T> {
     }
 }
 
-impl<T: FromReflect + TypePath> Typed for Option<T> {
+impl<T: FromReflect + TypePath + GetTypeRegistration> Typed for Option<T> {
     fn type_info() -> &'static TypeInfo {
         static CELL: GenericTypeInfoCell = GenericTypeInfoCell::new();
         CELL.get_or_insert::<Self, _>(|| {
@@ -1392,7 +1391,7 @@ where
     }
 }
 
-impl<T: FromReflect + Clone + TypePath> List for Cow<'static, [T]> {
+impl<T: FromReflect + Clone + TypePath + GetTypeRegistration> List for Cow<'static, [T]> {
     fn get(&self, index: usize) -> Option<&dyn Reflect> {
         self.as_ref().get(index).map(|x| x as &dyn Reflect)
     }
@@ -1451,7 +1450,7 @@ impl<T: FromReflect + Clone + TypePath> List for Cow<'static, [T]> {
     }
 }
 
-impl<T: FromReflect + Clone + TypePath> Reflect for Cow<'static, [T]> {
+impl<T: FromReflect + Clone + TypePath + GetTypeRegistration> Reflect for Cow<'static, [T]> {
     fn get_represented_type_info(&self) -> Option<&'static TypeInfo> {
         Some(<Self as Typed>::type_info())
     }
@@ -1518,20 +1517,26 @@ impl<T: FromReflect + Clone + TypePath> Reflect for Cow<'static, [T]> {
     }
 }
 
-impl<T: FromReflect + Clone + TypePath> Typed for Cow<'static, [T]> {
+impl<T: FromReflect + Clone + TypePath + GetTypeRegistration> Typed for Cow<'static, [T]> {
     fn type_info() -> &'static TypeInfo {
         static CELL: GenericTypeInfoCell = GenericTypeInfoCell::new();
         CELL.get_or_insert::<Self, _>(|| TypeInfo::List(ListInfo::new::<Self, T>()))
     }
 }
 
-impl<T: FromReflect + Clone + TypePath> GetTypeRegistration for Cow<'static, [T]> {
+impl<T: FromReflect + Clone + TypePath + GetTypeRegistration> GetTypeRegistration
+    for Cow<'static, [T]>
+{
     fn get_type_registration() -> TypeRegistration {
         TypeRegistration::of::<Cow<'static, [T]>>()
     }
+
+    fn register_type_dependencies(registry: &mut TypeRegistry) {
+        registry.register::<T>();
+    }
 }
 
-impl<T: FromReflect + Clone + TypePath> FromReflect for Cow<'static, [T]> {
+impl<T: FromReflect + Clone + TypePath + GetTypeRegistration> FromReflect for Cow<'static, [T]> {
     fn from_reflect(reflect: &dyn Reflect) -> Option<Self> {
         if let ReflectRef::List(ref_list) = reflect.reflect_ref() {
             let mut temp_vec = Vec::with_capacity(ref_list.len());
diff --git a/crates/bevy_reflect/src/impls/uuid.rs b/crates/bevy_reflect/src/impls/uuid.rs
index 27a1af41a4fc3..f845dda798c15 100644
--- a/crates/bevy_reflect/src/impls/uuid.rs
+++ b/crates/bevy_reflect/src/impls/uuid.rs
@@ -3,7 +3,7 @@ use crate as bevy_reflect;
 use crate::{std_traits::ReflectDefault, ReflectDeserialize, ReflectSerialize};
 use bevy_reflect_derive::impl_reflect_value;
 
-impl_reflect_value!(::bevy_utils::Uuid(
+impl_reflect_value!(::uuid::Uuid(
     Serialize,
     Deserialize,
     Default,
diff --git a/crates/bevy_reflect/src/lib.rs b/crates/bevy_reflect/src/lib.rs
index ab7b2d0a0adb1..2add0144f0d04 100644
--- a/crates/bevy_reflect/src/lib.rs
+++ b/crates/bevy_reflect/src/lib.rs
@@ -481,9 +481,11 @@ mod tuple_struct;
 mod type_info;
 mod type_path;
 mod type_registry;
+
 mod impls {
     #[cfg(feature = "glam")]
     mod glam;
+
     #[cfg(feature = "bevy_math")]
     mod math {
         mod direction;
@@ -491,12 +493,14 @@ mod impls {
         mod primitives3d;
         mod rect;
     }
+
     #[cfg(feature = "smallvec")]
     mod smallvec;
     #[cfg(feature = "smol_str")]
     mod smol_str;
 
     mod std;
+    #[cfg(feature = "uuid")]
     mod uuid;
 }
 
@@ -535,9 +539,48 @@ pub use erased_serde;
 
 extern crate alloc;
 
+/// Exports used by the reflection macros.
+///
+/// These are not meant to be used directly and are subject to breaking changes.
 #[doc(hidden)]
 pub mod __macro_exports {
-    pub use bevy_utils::uuid::generate_composite_uuid;
+    use crate::{
+        DynamicArray, DynamicEnum, DynamicList, DynamicMap, DynamicStruct, DynamicTuple,
+        DynamicTupleStruct, GetTypeRegistration, TypeRegistry,
+    };
+
+    /// A wrapper trait around [`GetTypeRegistration`].
+    ///
+    /// This trait is used by the derive macro to recursively register all type dependencies.
+    /// It's used instead of `GetTypeRegistration` directly to avoid making dynamic types also
+    /// implement `GetTypeRegistration` in order to be used as active fields.
+    ///
+    /// This trait has a blanket implementation for all types that implement `GetTypeRegistration`
+    /// and manual implementations for all dynamic types (which simply do nothing).
+    pub trait RegisterForReflection {
+        #[allow(unused_variables)]
+        fn __register(registry: &mut TypeRegistry) {}
+    }
+
+    impl<T: GetTypeRegistration> RegisterForReflection for T {
+        fn __register(registry: &mut TypeRegistry) {
+            registry.register::<T>();
+        }
+    }
+
+    impl RegisterForReflection for DynamicEnum {}
+
+    impl RegisterForReflection for DynamicTupleStruct {}
+
+    impl RegisterForReflection for DynamicStruct {}
+
+    impl RegisterForReflection for DynamicMap {}
+
+    impl RegisterForReflection for DynamicList {}
+
+    impl RegisterForReflection for DynamicArray {}
+
+    impl RegisterForReflection for DynamicTuple {}
 }
 
 #[cfg(test)]
@@ -1002,6 +1045,124 @@ mod tests {
         assert_eq!(new_foo, expected_new_foo);
     }
 
+    #[test]
+    fn should_auto_register_fields() {
+        #[derive(Reflect)]
+        struct Foo {
+            bar: Bar,
+        }
+
+        #[derive(Reflect)]
+        enum Bar {
+            Variant(Baz),
+        }
+
+        #[derive(Reflect)]
+        struct Baz(usize);
+
+        // === Basic === //
+        let mut registry = TypeRegistry::empty();
+        registry.register::<Foo>();
+
+        assert!(
+            registry.contains(TypeId::of::<Bar>()),
+            "registry should contain auto-registered `Bar` from `Foo`"
+        );
+
+        // === Option === //
+        let mut registry = TypeRegistry::empty();
+        registry.register::<Option<Foo>>();
+
+        assert!(
+            registry.contains(TypeId::of::<Bar>()),
+            "registry should contain auto-registered `Bar` from `Option<Foo>`"
+        );
+
+        // === Tuple === //
+        let mut registry = TypeRegistry::empty();
+        registry.register::<(Foo, Foo)>();
+
+        assert!(
+            registry.contains(TypeId::of::<Bar>()),
+            "registry should contain auto-registered `Bar` from `(Foo, Foo)`"
+        );
+
+        // === Array === //
+        let mut registry = TypeRegistry::empty();
+        registry.register::<[Foo; 3]>();
+
+        assert!(
+            registry.contains(TypeId::of::<Bar>()),
+            "registry should contain auto-registered `Bar` from `[Foo; 3]`"
+        );
+
+        // === Vec === //
+        let mut registry = TypeRegistry::empty();
+        registry.register::<Vec<Foo>>();
+
+        assert!(
+            registry.contains(TypeId::of::<Bar>()),
+            "registry should contain auto-registered `Bar` from `Vec<Foo>`"
+        );
+
+        // === HashMap === //
+        let mut registry = TypeRegistry::empty();
+        registry.register::<HashMap<i32, Foo>>();
+
+        assert!(
+            registry.contains(TypeId::of::<Bar>()),
+            "registry should contain auto-registered `Bar` from `HashMap<i32, Foo>`"
+        );
+    }
+
+    #[test]
+    fn should_allow_dynamic_fields() {
+        #[derive(Reflect)]
+        #[reflect(from_reflect = false)]
+        struct MyStruct(
+            DynamicEnum,
+            DynamicTupleStruct,
+            DynamicStruct,
+            DynamicMap,
+            DynamicList,
+            DynamicArray,
+            DynamicTuple,
+            i32,
+        );
+
+        assert_impl_all!(MyStruct: Reflect, GetTypeRegistration);
+
+        let mut registry = TypeRegistry::empty();
+        registry.register::<MyStruct>();
+
+        assert_eq!(2, registry.iter().count());
+        assert!(registry.contains(TypeId::of::<MyStruct>()));
+        assert!(registry.contains(TypeId::of::<i32>()));
+    }
+
+    #[test]
+    fn should_not_auto_register_existing_types() {
+        #[derive(Reflect)]
+        struct Foo {
+            bar: Bar,
+        }
+
+        #[derive(Reflect, Default)]
+        struct Bar(usize);
+
+        let mut registry = TypeRegistry::empty();
+        registry.register::<Bar>();
+        registry.register_type_data::<Bar, ReflectDefault>();
+        registry.register::<Foo>();
+
+        assert!(
+            registry
+                .get_type_data::<ReflectDefault>(TypeId::of::<Bar>())
+                .is_some(),
+            "registry should contain existing registration for `Bar`"
+        );
+    }
+
     #[test]
     fn reflect_serialize() {
         #[derive(Reflect)]
@@ -1387,7 +1548,6 @@ mod tests {
         // List (SmallVec)
         #[cfg(feature = "smallvec")]
         {
-            use bevy_utils::smallvec;
             type MySmallVec = smallvec::SmallVec<[String; 2]>;
 
             let info = MySmallVec::type_info();
@@ -1981,6 +2141,39 @@ bevy_reflect::tests::Test {
         let _ = <RecurseB as TypePath>::type_path();
     }
 
+    #[test]
+    fn recursive_registration_does_not_hang() {
+        #[derive(Reflect)]
+        struct Recurse<T>(T);
+
+        let mut registry = TypeRegistry::empty();
+
+        registry.register::<Recurse<Recurse<()>>>();
+
+        #[derive(Reflect)]
+        #[reflect(no_field_bounds)]
+        struct SelfRecurse {
+            recurse: Vec<SelfRecurse>,
+        }
+
+        registry.register::<SelfRecurse>();
+
+        #[derive(Reflect)]
+        #[reflect(no_field_bounds)]
+        enum RecurseA {
+            Recurse(RecurseB),
+        }
+
+        #[derive(Reflect)]
+        struct RecurseB {
+            vector: Vec<RecurseA>,
+        }
+
+        registry.register::<RecurseA>();
+        assert!(registry.contains(TypeId::of::<RecurseA>()));
+        assert!(registry.contains(TypeId::of::<RecurseB>()));
+    }
+
     #[test]
     fn can_opt_out_type_path() {
         #[derive(Reflect)]
diff --git a/crates/bevy_reflect/src/tuple.rs b/crates/bevy_reflect/src/tuple.rs
index 78d78e1a42ea2..de6af437df4bb 100644
--- a/crates/bevy_reflect/src/tuple.rs
+++ b/crates/bevy_reflect/src/tuple.rs
@@ -3,8 +3,8 @@ use bevy_utils::all_tuples;
 
 use crate::{
     self as bevy_reflect, utility::GenericTypePathCell, FromReflect, GetTypeRegistration, Reflect,
-    ReflectMut, ReflectOwned, ReflectRef, TypeInfo, TypePath, TypeRegistration, Typed,
-    UnnamedField,
+    ReflectMut, ReflectOwned, ReflectRef, TypeInfo, TypePath, TypeRegistration, TypeRegistry,
+    Typed, UnnamedField,
 };
 use crate::{ReflectKind, TypePathTable};
 use std::any::{Any, TypeId};
@@ -461,7 +461,7 @@ pub fn tuple_debug(dyn_tuple: &dyn Tuple, f: &mut Formatter<'_>) -> std::fmt::Re
 
 macro_rules! impl_reflect_tuple {
     {$($index:tt : $name:tt),*} => {
-        impl<$($name: Reflect + TypePath),*> Tuple for ($($name,)*) {
+        impl<$($name: Reflect + TypePath + GetTypeRegistration),*> Tuple for ($($name,)*) {
             #[inline]
             fn field(&self, index: usize) -> Option<&dyn Reflect> {
                 match index {
@@ -512,7 +512,7 @@ macro_rules! impl_reflect_tuple {
             }
         }
 
-        impl<$($name: Reflect + TypePath),*> Reflect for ($($name,)*) {
+        impl<$($name: Reflect + TypePath + GetTypeRegistration),*> Reflect for ($($name,)*) {
             fn get_represented_type_info(&self) -> Option<&'static TypeInfo> {
                 Some(<Self as Typed>::type_info())
             }
@@ -575,7 +575,7 @@ macro_rules! impl_reflect_tuple {
             }
         }
 
-        impl <$($name: Reflect + TypePath),*> Typed for ($($name,)*) {
+        impl <$($name: Reflect + TypePath + GetTypeRegistration),*> Typed for ($($name,)*) {
             fn type_info() -> &'static TypeInfo {
                 static CELL: $crate::utility::GenericTypeInfoCell = $crate::utility::GenericTypeInfoCell::new();
                 CELL.get_or_insert::<Self, _>(|| {
@@ -588,14 +588,17 @@ macro_rules! impl_reflect_tuple {
             }
         }
 
-
-        impl<$($name: Reflect + TypePath),*> GetTypeRegistration for ($($name,)*) {
+        impl<$($name: Reflect + TypePath + GetTypeRegistration),*> GetTypeRegistration for ($($name,)*) {
             fn get_type_registration() -> TypeRegistration {
                 TypeRegistration::of::<($($name,)*)>()
             }
+
+            fn register_type_dependencies(_registry: &mut TypeRegistry) {
+                $(_registry.register::<$name>();)*
+            }
         }
 
-        impl<$($name: FromReflect + TypePath),*> FromReflect for ($($name,)*)
+        impl<$($name: FromReflect + TypePath + GetTypeRegistration),*> FromReflect for ($($name,)*)
         {
             fn from_reflect(reflect: &dyn Reflect) -> Option<Self> {
                 if let ReflectRef::Tuple(_ref_tuple) = reflect.reflect_ref() {
diff --git a/crates/bevy_reflect/src/type_registry.rs b/crates/bevy_reflect/src/type_registry.rs
index 8fc39297f3d5a..2846781f47792 100644
--- a/crates/bevy_reflect/src/type_registry.rs
+++ b/crates/bevy_reflect/src/type_registry.rs
@@ -56,8 +56,15 @@ impl Debug for TypeRegistryArc {
 /// See the [crate-level documentation] for more information on type registration.
 ///
 /// [crate-level documentation]: crate
-pub trait GetTypeRegistration {
+pub trait GetTypeRegistration: 'static {
+    /// Returns the default [`TypeRegistration`] for this type.
     fn get_type_registration() -> TypeRegistration;
+    /// Registers other types needed by this type.
+    ///
+    /// This method is called by [`TypeRegistry::register`] to register any other required types.
+    /// Often, this is done for fields of structs and enum variants to ensure all types are properly registered.
+    #[allow(unused_variables)]
+    fn register_type_dependencies(registry: &mut TypeRegistry) {}
 }
 
 impl Default for TypeRegistry {
@@ -100,39 +107,132 @@ impl TypeRegistry {
         registry
     }
 
-    /// Registers the type `T`, adding reflect data as specified in the [`Reflect`] derive:
-    /// ```ignore (Neither bevy_ecs nor serde "derive" are available.)
-    /// #[derive(Component, serde::Serialize, serde::Deserialize, Reflect)]
-    /// #[reflect(Component, Serialize, Deserialize)] // will register ReflectComponent, ReflectSerialize, ReflectDeserialize
+    /// Attempts to register the type `T` if it has not yet been registered already.
+    ///
+    /// This will also recursively register any type dependencies as specified by [`GetTypeRegistration::register_type_dependencies`].
+    /// When deriving `Reflect`, this will generally be all the fields of the struct or enum variant.
+    /// As with any type registration, these type dependencies will not be registered more than once.
+    ///
+    /// If the registration for type `T` already exists, it will not be registered again and neither will its type dependencies.
+    /// To register the type, overwriting any existing registration, use [register](Self::overwrite_registration) instead.
+    ///
+    /// Additionally, this will add any reflect [type data](TypeData) as specified in the [`Reflect`] derive.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use std::any::TypeId;
+    /// # use bevy_reflect::{Reflect, TypeRegistry, std_traits::ReflectDefault};
+    /// #[derive(Reflect, Default)]
+    /// #[reflect(Default)]
+    /// struct Foo {
+    ///   name: Option<String>,
+    ///   value: i32
+    /// }
+    ///
+    /// let mut type_registry = TypeRegistry::default();
+    ///
+    /// type_registry.register::<Foo>();
+    ///
+    /// // The main type
+    /// assert!(type_registry.contains(TypeId::of::<Foo>()));
+    ///
+    /// // Its type dependencies
+    /// assert!(type_registry.contains(TypeId::of::<Option<String>>()));
+    /// assert!(type_registry.contains(TypeId::of::<i32>()));
+    ///
+    /// // Its type data
+    /// assert!(type_registry.get_type_data::<ReflectDefault>(TypeId::of::<Foo>()).is_some());
     /// ```
     pub fn register<T>(&mut self)
     where
         T: GetTypeRegistration,
     {
-        self.add_registration(T::get_type_registration());
+        if self.register_internal(TypeId::of::<T>(), T::get_type_registration) {
+            T::register_type_dependencies(self);
+        }
+    }
+
+    /// Attempts to register the type described by `registration`.
+    ///
+    /// If the registration for the type already exists, it will not be registered again.
+    ///
+    /// To forcibly register the type, overwriting any existing registration, use the
+    /// [`overwrite_registration`](Self::overwrite_registration) method instead.
+    ///
+    /// This method will _not_ register type dependencies.
+    /// Use [`register`](Self::register) to register a type with its dependencies.
+    ///
+    /// Returns `true` if the registration was added and `false` if it already exists.
+    pub fn add_registration(&mut self, registration: TypeRegistration) -> bool {
+        let type_id = registration.type_id();
+        self.register_internal(type_id, || registration)
     }
 
     /// Registers the type described by `registration`.
-    pub fn add_registration(&mut self, registration: TypeRegistration) {
-        if self.registrations.contains_key(&registration.type_id()) {
-            return;
+    ///
+    /// If the registration for the type already exists, it will be overwritten.
+    ///
+    /// To avoid overwriting existing registrations, it's recommended to use the
+    /// [`register`](Self::register) or [`add_registration`](Self::add_registration) methods instead.
+    ///
+    /// This method will _not_ register type dependencies.
+    /// Use [`register`](Self::register) to register a type with its dependencies.
+    pub fn overwrite_registration(&mut self, registration: TypeRegistration) {
+        Self::update_registration_indices(
+            &registration,
+            &mut self.short_path_to_id,
+            &mut self.type_path_to_id,
+            &mut self.ambiguous_names,
+        );
+        self.registrations
+            .insert(registration.type_id(), registration);
+    }
+
+    /// Internal method to register a type with a given [`TypeId`] and [`TypeRegistration`].
+    ///
+    /// By using this method, we are able to reduce the number of `TypeId` hashes and lookups needed
+    /// to register a type.
+    ///
+    /// This method is internal to prevent users from accidentally registering a type with a `TypeId`
+    /// that does not match the type in the `TypeRegistration`.
+    fn register_internal(
+        &mut self,
+        type_id: TypeId,
+        get_registration: impl FnOnce() -> TypeRegistration,
+    ) -> bool {
+        match self.registrations.entry(type_id) {
+            bevy_utils::Entry::Occupied(_) => false,
+            bevy_utils::Entry::Vacant(entry) => {
+                let registration = get_registration();
+                Self::update_registration_indices(
+                    &registration,
+                    &mut self.short_path_to_id,
+                    &mut self.type_path_to_id,
+                    &mut self.ambiguous_names,
+                );
+                entry.insert(registration);
+                true
+            }
         }
+    }
 
+    /// Internal method to register additional lookups for a given [`TypeRegistration`].
+    fn update_registration_indices(
+        registration: &TypeRegistration,
+        short_path_to_id: &mut HashMap<&'static str, TypeId>,
+        type_path_to_id: &mut HashMap<&'static str, TypeId>,
+        ambiguous_names: &mut HashSet<&'static str>,
+    ) {
         let short_name = registration.type_info().type_path_table().short_path();
-        if self.short_path_to_id.contains_key(short_name)
-            || self.ambiguous_names.contains(short_name)
-        {
+        if short_path_to_id.contains_key(short_name) || ambiguous_names.contains(short_name) {
             // name is ambiguous. fall back to long names for all ambiguous types
-            self.short_path_to_id.remove(short_name);
-            self.ambiguous_names.insert(short_name);
+            short_path_to_id.remove(short_name);
+            ambiguous_names.insert(short_name);
         } else {
-            self.short_path_to_id
-                .insert(short_name, registration.type_id());
+            short_path_to_id.insert(short_name, registration.type_id());
         }
-        self.type_path_to_id
-            .insert(registration.type_info().type_path(), registration.type_id());
-        self.registrations
-            .insert(registration.type_id(), registration);
+        type_path_to_id.insert(registration.type_info().type_path(), registration.type_id());
     }
 
     /// Registers the type data `D` for type `T`.
@@ -162,6 +262,10 @@ impl TypeRegistry {
         data.insert(D::from_type());
     }
 
+    pub fn contains(&self, type_id: TypeId) -> bool {
+        self.registrations.contains_key(&type_id)
+    }
+
     /// Returns a reference to the [`TypeRegistration`] of the type with the
     /// given [`TypeId`].
     ///
diff --git a/crates/bevy_reflect_compile_fail_tests/tests/reflect_derive/generics.fail.rs b/crates/bevy_reflect_compile_fail_tests/tests/reflect_derive/generics.fail.rs
index c3693d06310db..5788063757ce3 100644
--- a/crates/bevy_reflect_compile_fail_tests/tests/reflect_derive/generics.fail.rs
+++ b/crates/bevy_reflect_compile_fail_tests/tests/reflect_derive/generics.fail.rs
@@ -1,4 +1,4 @@
-use bevy_reflect::{Reflect, TypePath};
+use bevy_reflect::{GetField, Reflect, Struct, TypePath};
 
 #[derive(Reflect)]
 #[reflect(from_reflect = false)]
@@ -11,7 +11,7 @@ struct Foo<T> {
 struct NoReflect(f32);
 
 fn main() {
-    let mut foo: Box<dyn Reflect> = Box::new(Foo::<NoReflect> { a: NoReflect(42.0) });
+    let mut foo: Box<dyn Struct> = Box::new(Foo::<NoReflect> { a: NoReflect(42.0) });
     // foo doesn't implement Reflect because NoReflect doesn't implement Reflect
     foo.get_field::<NoReflect>("a").unwrap();
 }
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 40d36dcf977ae..22a6cc8d53ccf 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
@@ -1,16 +1,34 @@
-error[E0599]: no method named `get_field` found for struct `Box<(dyn Reflect + 'static)>` in the current scope
-  --> tests/reflect_derive/generics.fail.rs:16:9
-   |
-16 |     foo.get_field::<NoReflect>("a").unwrap();
-   |         ^^^^^^^^^ method not found in `Box<dyn Reflect>`
-
 error[E0277]: the trait bound `NoReflect: Reflect` is not satisfied
-  --> tests/reflect_derive/generics.fail.rs:14:37
+   --> tests/reflect_derive/generics.fail.rs:16:21
+    |
+16  |     foo.get_field::<NoReflect>("a").unwrap();
+    |         ---------   ^^^^^^^^^ the trait `Reflect` is not implemented for `NoReflect`
+    |         |
+    |         required by a bound introduced by this call
+    |
+    = help: the following other types implement trait `Reflect`:
+              bool
+              char
+              isize
+              i8
+              i16
+              i32
+              i64
+              i128
+            and $N others
+note: required by a bound in `bevy_reflect::GetField::get_field`
+   --> /home/runner/work/bevy/bevy/crates/bevy_reflect/src/struct_trait.rs:242:21
+    |
+242 |     fn get_field<T: Reflect>(&self, name: &str) -> Option<&T>;
+    |                     ^^^^^^^ required by this bound in `GetField::get_field`
+
+error[E0277]: the trait bound `NoReflect: GetTypeRegistration` is not satisfied
+  --> tests/reflect_derive/generics.fail.rs:14:36
    |
-14 |     let mut foo: Box<dyn Reflect> = Box::new(Foo::<NoReflect> { a: NoReflect(42.0) });
-   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Reflect` is not implemented for `NoReflect`
+14 |     let mut foo: Box<dyn Struct> = Box::new(Foo::<NoReflect> { a: NoReflect(42.0) });
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `GetTypeRegistration` is not implemented for `NoReflect`
    |
-   = help: the following other types implement trait `Reflect`:
+   = help: the following other types implement trait `GetTypeRegistration`:
              bool
              char
              isize
@@ -20,7 +38,8 @@ error[E0277]: the trait bound `NoReflect: Reflect` is not satisfied
              i64
              i128
            and $N others
-note: required for `Foo<NoReflect>` to implement `Reflect`
+   = note: required for `NoReflect` to implement `RegisterForReflection`
+note: required for `Foo<NoReflect>` to implement `bevy_reflect::Struct`
   --> tests/reflect_derive/generics.fail.rs:3:10
    |
 3  | #[derive(Reflect)]
@@ -28,5 +47,5 @@ note: required for `Foo<NoReflect>` to implement `Reflect`
 4  | #[reflect(from_reflect = false)]
 5  | struct Foo<T> {
    |        ^^^^^^
-   = note: required for the cast from `Box<Foo<NoReflect>>` to `Box<(dyn Reflect + 'static)>`
+   = note: required for the cast from `Box<Foo<NoReflect>>` to `Box<(dyn bevy_reflect::Struct + '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_render/Cargo.toml b/crates/bevy_render/Cargo.toml
index 7903dd8d08bea..ca51b826c46c1 100644
--- a/crates/bevy_render/Cargo.toml
+++ b/crates/bevy_render/Cargo.toml
@@ -19,7 +19,7 @@ webp = ["image/webp"]
 dds = ["ddsfile"]
 pnm = ["image/pnm"]
 multi-threaded = ["bevy_tasks/multi-threaded"]
-bevy_ci_testing = ["bevy_app/bevy_ci_testing"]
+bevy_ci_testing = ["bevy_dev_tools/bevy_ci_testing"]
 
 shader_format_glsl = ["naga/glsl-in", "naga/wgsl-out", "naga_oil/glsl"]
 shader_format_spirv = ["wgpu/spirv", "naga/spv-in", "naga/spv-out"]
@@ -46,7 +46,6 @@ bevy_derive = { path = "../bevy_derive", version = "0.14.0-dev" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.14.0-dev" }
 bevy_encase_derive = { path = "../bevy_encase_derive", version = "0.14.0-dev" }
 bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.14.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.14.0-dev" }
 bevy_math = { path = "../bevy_math", version = "0.14.0-dev" }
 bevy_mikktspace = { path = "../bevy_mikktspace", version = "0.14.0-dev" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.14.0-dev", features = [
@@ -58,6 +57,7 @@ bevy_transform = { path = "../bevy_transform", version = "0.14.0-dev" }
 bevy_window = { path = "../bevy_window", version = "0.14.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.14.0-dev" }
 bevy_tasks = { path = "../bevy_tasks", version = "0.14.0-dev" }
+bevy_dev_tools = { path = "../bevy_dev_tools", version = "0.14.0-dev", optional = true }
 
 # rendering
 image = { version = "0.24", default-features = false }
@@ -66,7 +66,7 @@ image = { version = "0.24", default-features = false }
 codespan-reporting = "0.11.0"
 # `fragile-send-sync-non-atomic-wasm` feature means we can't use WASM threads for rendering
 # It is enabled for now to avoid having to do a significant overhaul of the renderer just for wasm
-wgpu = { version = "0.19.1", default-features = false, features = [
+wgpu = { version = "0.19.3", default-features = false, features = [
   "wgsl",
   "dx12",
   "metal",
@@ -96,7 +96,8 @@ profiling = { version = "1", features = [
   "profile-with-tracing",
 ], optional = true }
 async-channel = "2.2.0"
-
+nonmax = "0.5"
+smallvec = "1.11"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 # Omit the `glsl` feature in non-WebAssembly by default.
@@ -107,9 +108,7 @@ naga_oil = { version = "0.13", default-features = false, features = [
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 naga_oil = "0.13"
 js-sys = "0.3"
-# web-sys doesn't follow semver for the WebGPU APIs as they are unstable
-# Make sure that WebGPU builds work when changing this!
-web-sys = { version = "=0.3.67", features = [
+web-sys = { version = "0.3.67", features = [
   'Blob',
   'Document',
   'Element',
diff --git a/crates/bevy_render/src/batching/mod.rs b/crates/bevy_render/src/batching/mod.rs
index 859d56e98deb5..54b0573081f67 100644
--- a/crates/bevy_render/src/batching/mod.rs
+++ b/crates/bevy_render/src/batching/mod.rs
@@ -4,7 +4,7 @@ use bevy_ecs::{
     prelude::Res,
     system::{Query, ResMut, StaticSystemParam, SystemParam, SystemParamItem},
 };
-use bevy_utils::nonmax::NonMaxU32;
+use nonmax::NonMaxU32;
 
 use crate::{
     render_phase::{CachedRenderPipelinePhaseItem, DrawFunctionId, RenderPhase},
@@ -88,7 +88,7 @@ pub fn batch_and_prepare_render_phase<I: CachedRenderPipelinePhaseItem, F: GetBa
         let (buffer_data, compare_data) = F::get_batch_data(&system_param_item, item.entity())?;
         let buffer_index = gpu_array_buffer.push(buffer_data);
 
-        let index = buffer_index.index.get();
+        let index = buffer_index.index;
         *item.batch_range_mut() = index..index + 1;
         *item.dynamic_offset_mut() = buffer_index.dynamic_offset;
 
diff --git a/crates/bevy_render/src/camera/camera.rs b/crates/bevy_render/src/camera/camera.rs
index 8fa1c722f1307..ca22a773dc767 100644
--- a/crates/bevy_render/src/camera/camera.rs
+++ b/crates/bevy_render/src/camera/camera.rs
@@ -20,11 +20,11 @@ use bevy_ecs::{
     reflect::ReflectComponent,
     system::{Commands, Query, Res, ResMut, Resource},
 };
-use bevy_log::warn;
 use bevy_math::{vec2, Dir3, Mat4, Ray3d, Rect, URect, UVec2, UVec4, Vec2, Vec3};
 use bevy_reflect::prelude::*;
 use bevy_render_macros::ExtractComponent;
 use bevy_transform::components::GlobalTransform;
+use bevy_utils::tracing::warn;
 use bevy_utils::{HashMap, HashSet};
 use bevy_window::{
     NormalizedWindowRef, PrimaryWindow, Window, WindowCreated, WindowRef, WindowResized,
@@ -628,10 +628,7 @@ impl NormalizedRenderTarget {
                 .into_iter()
                 .find(|(entity, _)| *entity == window_ref.entity())
                 .map(|(_, window)| RenderTargetInfo {
-                    physical_size: UVec2::new(
-                        window.resolution.physical_width(),
-                        window.resolution.physical_height(),
-                    ),
+                    physical_size: window.physical_size(),
                     scale_factor: window.resolution.scale_factor(),
                 }),
             NormalizedRenderTarget::Image(image_handle) => {
diff --git a/crates/bevy_render/src/camera/mod.rs b/crates/bevy_render/src/camera/mod.rs
index a1e02be219857..579129bb0f014 100644
--- a/crates/bevy_render/src/camera/mod.rs
+++ b/crates/bevy_render/src/camera/mod.rs
@@ -24,12 +24,7 @@ pub struct CameraPlugin;
 impl Plugin for CameraPlugin {
     fn build(&self, app: &mut App) {
         app.register_type::<Camera>()
-            .register_type::<Viewport>()
-            .register_type::<Option<Viewport>>()
-            .register_type::<ScalingMode>()
-            .register_type::<RenderTarget>()
             .register_type::<ClearColor>()
-            .register_type::<ClearColorConfig>()
             .register_type::<CameraRenderGraph>()
             .register_type::<CameraMainTextureUsages>()
             .register_type::<Exposure>()
diff --git a/crates/bevy_render/src/extract_resource.rs b/crates/bevy_render/src/extract_resource.rs
index 7a928bd291570..038a612fe21f6 100644
--- a/crates/bevy_render/src/extract_resource.rs
+++ b/crates/bevy_render/src/extract_resource.rs
@@ -51,7 +51,7 @@ pub fn extract_resource<R: ExtractResource>(
         } else {
             #[cfg(debug_assertions)]
             if !main_resource.is_added() {
-                bevy_log::warn_once!(
+                bevy_utils::warn_once!(
                     "Removing resource {} from render world not expected, adding using `Commands`.
                 This may decrease performance",
                     std::any::type_name::<R>()
diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index d972356b02a7e..3227bd00137bd 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -329,17 +329,7 @@ impl Plugin for RenderPlugin {
 
         app.register_type::<alpha::AlphaMode>()
             // These types cannot be registered in bevy_color, as it does not depend on the rest of Bevy
-            // BLOCKED: once https://github.com/bevyengine/bevy/pull/5781 lands, we can remove all but the Color registration
             .register_type::<bevy_color::Color>()
-            .register_type::<bevy_color::Srgba>()
-            .register_type::<bevy_color::LinearRgba>()
-            .register_type::<bevy_color::Hsla>()
-            .register_type::<bevy_color::Hsva>()
-            .register_type::<bevy_color::Hwba>()
-            .register_type::<bevy_color::Laba>()
-            .register_type::<bevy_color::Lcha>()
-            .register_type::<bevy_color::Xyza>()
-            .register_type::<bevy_color::Oklaba>()
             .register_type::<primitives::Aabb>()
             .register_type::<primitives::CascadesFrusta>()
             .register_type::<primitives::CubemapFrusta>()
diff --git a/crates/bevy_render/src/mesh/mesh/mod.rs b/crates/bevy_render/src/mesh/mesh/mod.rs
index 33a21e62d6b58..dc4549cd040b5 100644
--- a/crates/bevy_render/src/mesh/mesh/mod.rs
+++ b/crates/bevy_render/src/mesh/mesh/mod.rs
@@ -11,16 +11,15 @@ use crate::{
     renderer::RenderDevice,
 };
 use bevy_asset::{Asset, Handle};
-use bevy_core::cast_slice;
 use bevy_derive::EnumVariantMeta;
 use bevy_ecs::system::{
     lifetimeless::{SRes, SResMut},
     SystemParamItem,
 };
-use bevy_log::warn;
 use bevy_math::*;
 use bevy_reflect::Reflect;
-use bevy_utils::tracing::error;
+use bevy_utils::tracing::{error, warn};
+use bytemuck::cast_slice;
 use std::{collections::BTreeMap, hash::Hash, iter::FusedIterator};
 use thiserror::Error;
 use wgpu::{
diff --git a/crates/bevy_render/src/mesh/mod.rs b/crates/bevy_render/src/mesh/mod.rs
index a6d67e960fe4d..7748a5a1eaeb5 100644
--- a/crates/bevy_render/src/mesh/mod.rs
+++ b/crates/bevy_render/src/mesh/mod.rs
@@ -13,7 +13,7 @@ use std::{
 
 use crate::{prelude::Image, render_asset::RenderAssetPlugin, RenderApp};
 use bevy_app::{App, Plugin};
-use bevy_asset::{AssetApp, Handle};
+use bevy_asset::AssetApp;
 use bevy_ecs::{entity::Entity, system::Resource};
 
 /// Adds the [`Mesh`] as an asset and makes sure that they are extracted and prepared for the GPU.
@@ -24,10 +24,6 @@ impl Plugin for MeshPlugin {
         app.init_asset::<Mesh>()
             .init_asset::<skinning::SkinnedMeshInverseBindposes>()
             .register_asset_reflect::<Mesh>()
-            .register_type::<Option<Handle<Image>>>()
-            .register_type::<Option<Vec<String>>>()
-            .register_type::<Option<Indices>>()
-            .register_type::<Indices>()
             .register_type::<skinning::SkinnedMesh>()
             .register_type::<Vec<Entity>>()
             // 'Mesh' must be prepared after 'Image' as meshes rely on the morph target image being ready
diff --git a/crates/bevy_render/src/render_asset.rs b/crates/bevy_render/src/render_asset.rs
index ebb3e717e1654..0b1686fbce641 100644
--- a/crates/bevy_render/src/render_asset.rs
+++ b/crates/bevy_render/src/render_asset.rs
@@ -7,14 +7,17 @@ use bevy_ecs::{
     system::{StaticSystemParam, SystemParam, SystemParamItem, SystemState},
     world::{FromWorld, Mut},
 };
+use bevy_reflect::std_traits::ReflectDefault;
 use bevy_reflect::{
     utility::{reflect_hasher, NonGenericTypeInfoCell},
-    FromReflect, Reflect, ReflectKind, ReflectMut, ReflectOwned, ReflectRef, TypeInfo, TypePath,
-    Typed, ValueInfo,
+    FromReflect, FromType, GetTypeRegistration, Reflect, ReflectDeserialize, ReflectFromPtr,
+    ReflectFromReflect, ReflectKind, ReflectMut, ReflectOwned, ReflectRef, ReflectSerialize,
+    TypeInfo, TypePath, TypeRegistration, Typed, ValueInfo,
 };
-use bevy_utils::{thiserror::Error, HashMap, HashSet};
+use bevy_utils::{HashMap, HashSet};
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
+use thiserror::Error;
 
 #[derive(Debug, Error)]
 pub enum PrepareAssetError<E: Send + Sync + 'static> {
@@ -162,6 +165,18 @@ impl Reflect for RenderAssetUsages {
     }
 }
 
+impl GetTypeRegistration for RenderAssetUsages {
+    fn get_type_registration() -> TypeRegistration {
+        let mut registration = TypeRegistration::of::<Self>();
+        registration.insert::<ReflectSerialize>(FromType::<Self>::from_type());
+        registration.insert::<ReflectDeserialize>(FromType::<Self>::from_type());
+        registration.insert::<ReflectDefault>(FromType::<Self>::from_type());
+        registration.insert::<ReflectFromReflect>(FromType::<Self>::from_type());
+        registration.insert::<ReflectFromPtr>(FromType::<Self>::from_type());
+        registration
+    }
+}
+
 impl FromReflect for RenderAssetUsages {
     fn from_reflect(reflect: &dyn Reflect) -> Option<Self> {
         let raw_value = *reflect.as_any().downcast_ref::<u8>()?;
diff --git a/crates/bevy_render/src/render_graph/app.rs b/crates/bevy_render/src/render_graph/app.rs
index 97ababa312b73..94082590aa86b 100644
--- a/crates/bevy_render/src/render_graph/app.rs
+++ b/crates/bevy_render/src/render_graph/app.rs
@@ -1,6 +1,6 @@
 use bevy_app::App;
 use bevy_ecs::world::FromWorld;
-use bevy_log::warn;
+use bevy_utils::tracing::warn;
 
 use super::{IntoRenderNodeArray, Node, RenderGraph, RenderLabel, RenderSubGraph};
 
diff --git a/crates/bevy_render/src/render_phase/mod.rs b/crates/bevy_render/src/render_phase/mod.rs
index e66698fc371d9..1a3a544b464f4 100644
--- a/crates/bevy_render/src/render_phase/mod.rs
+++ b/crates/bevy_render/src/render_phase/mod.rs
@@ -29,9 +29,9 @@ mod draw;
 mod draw_state;
 mod rangefinder;
 
-use bevy_utils::nonmax::NonMaxU32;
 pub use draw::*;
 pub use draw_state::*;
+use nonmax::NonMaxU32;
 pub use rangefinder::*;
 
 use crate::render_resource::{CachedRenderPipelineId, PipelineCache};
diff --git a/crates/bevy_render/src/render_resource/batched_uniform_buffer.rs b/crates/bevy_render/src/render_resource/batched_uniform_buffer.rs
index 59d47849a3abb..d92c7a3897e06 100644
--- a/crates/bevy_render/src/render_resource/batched_uniform_buffer.rs
+++ b/crates/bevy_render/src/render_resource/batched_uniform_buffer.rs
@@ -3,11 +3,11 @@ use crate::{
     render_resource::DynamicUniformBuffer,
     renderer::{RenderDevice, RenderQueue},
 };
-use bevy_utils::nonmax::NonMaxU32;
 use encase::{
     private::{ArrayMetadata, BufferMut, Metadata, RuntimeSizedArray, WriteInto, Writer},
     ShaderType,
 };
+use nonmax::NonMaxU32;
 use std::{marker::PhantomData, num::NonZeroU64};
 use wgpu::{BindingResource, Limits};
 
@@ -81,7 +81,7 @@ impl<T: GpuArrayBufferable> BatchedUniformBuffer<T> {
 
     pub fn push(&mut self, component: T) -> GpuArrayBufferIndex<T> {
         let result = GpuArrayBufferIndex {
-            index: NonMaxU32::new(self.temp.0.len() as u32).unwrap(),
+            index: self.temp.0.len() as u32,
             dynamic_offset: NonMaxU32::new(self.current_offset),
             element_type: PhantomData,
         };
diff --git a/crates/bevy_render/src/render_resource/bind_group.rs b/crates/bevy_render/src/render_resource/bind_group.rs
index 4e6898b7cb1c4..96f885f8e9c1d 100644
--- a/crates/bevy_render/src/render_resource/bind_group.rs
+++ b/crates/bevy_render/src/render_resource/bind_group.rs
@@ -7,9 +7,9 @@ use crate::{
     texture::FallbackImage,
 };
 pub use bevy_render_macros::AsBindGroup;
-use bevy_utils::thiserror::Error;
 use encase::ShaderType;
 use std::ops::Deref;
+use thiserror::Error;
 use wgpu::{BindGroupEntry, BindGroupLayoutEntry, BindingResource};
 
 define_atomic_id!(BindGroupId);
diff --git a/crates/bevy_render/src/render_resource/bind_group_layout_entries.rs b/crates/bevy_render/src/render_resource/bind_group_layout_entries.rs
index b877d38c027e1..7bb9ff1cafd21 100644
--- a/crates/bevy_render/src/render_resource/bind_group_layout_entries.rs
+++ b/crates/bevy_render/src/render_resource/bind_group_layout_entries.rs
@@ -222,7 +222,7 @@ impl IntoBindGroupLayoutEntryBuilder for BindingType {
 impl IntoBindGroupLayoutEntryBuilder for BindGroupLayoutEntry {
     fn into_bind_group_layout_entry_builder(self) -> BindGroupLayoutEntryBuilder {
         if self.binding != u32::MAX {
-            bevy_log::warn!("The BindGroupLayoutEntries api ignores the binding index when converting a raw wgpu::BindGroupLayoutEntry. You can ignore this warning by setting it to u32::MAX.");
+            bevy_utils::tracing::warn!("The BindGroupLayoutEntries api ignores the binding index when converting a raw wgpu::BindGroupLayoutEntry. You can ignore this warning by setting it to u32::MAX.");
         }
         BindGroupLayoutEntryBuilder {
             ty: self.ty,
diff --git a/crates/bevy_render/src/render_resource/buffer_vec.rs b/crates/bevy_render/src/render_resource/buffer_vec.rs
index cae1ef4f05381..26656c58ed983 100644
--- a/crates/bevy_render/src/render_resource/buffer_vec.rs
+++ b/crates/bevy_render/src/render_resource/buffer_vec.rs
@@ -2,7 +2,7 @@ use crate::{
     render_resource::Buffer,
     renderer::{RenderDevice, RenderQueue},
 };
-use bevy_core::{cast_slice, Pod};
+use bytemuck::{cast_slice, Pod};
 use wgpu::BufferUsages;
 
 /// A structure for storing raw bytes that have already been properly formatted
diff --git a/crates/bevy_render/src/render_resource/gpu_array_buffer.rs b/crates/bevy_render/src/render_resource/gpu_array_buffer.rs
index dbfe6a5962231..60d8cc68e400c 100644
--- a/crates/bevy_render/src/render_resource/gpu_array_buffer.rs
+++ b/crates/bevy_render/src/render_resource/gpu_array_buffer.rs
@@ -7,8 +7,8 @@ use crate::{
     renderer::{RenderDevice, RenderQueue},
 };
 use bevy_ecs::{prelude::Component, system::Resource};
-use bevy_utils::nonmax::NonMaxU32;
 use encase::{private::WriteInto, ShaderSize, ShaderType};
+use nonmax::NonMaxU32;
 use std::marker::PhantomData;
 use wgpu::BindingResource;
 
@@ -57,7 +57,7 @@ impl<T: GpuArrayBufferable> GpuArrayBuffer<T> {
             GpuArrayBuffer::Uniform(buffer) => buffer.push(value),
             GpuArrayBuffer::Storage(buffer) => {
                 let buffer = buffer.get_mut();
-                let index = NonMaxU32::new(buffer.len() as u32).unwrap();
+                let index = buffer.len() as u32;
                 buffer.push(value);
                 GpuArrayBufferIndex {
                     index,
@@ -109,7 +109,7 @@ impl<T: GpuArrayBufferable> GpuArrayBuffer<T> {
 #[derive(Component, Clone)]
 pub struct GpuArrayBufferIndex<T: GpuArrayBufferable> {
     /// The index to use in a shader into the array.
-    pub index: NonMaxU32,
+    pub index: u32,
     /// The dynamic offset to use when setting the bind group in a pass.
     /// Only used on platforms that don't support storage buffers.
     pub dynamic_offset: Option<NonMaxU32>,
diff --git a/crates/bevy_render/src/renderer/graph_runner.rs b/crates/bevy_render/src/renderer/graph_runner.rs
index 3db56919b1247..c155f4027da46 100644
--- a/crates/bevy_render/src/renderer/graph_runner.rs
+++ b/crates/bevy_render/src/renderer/graph_runner.rs
@@ -1,11 +1,9 @@
 use bevy_ecs::{prelude::Entity, world::World};
 #[cfg(feature = "trace")]
 use bevy_utils::tracing::info_span;
-use bevy_utils::{
-    smallvec::{smallvec, SmallVec},
-    HashMap,
-};
+use bevy_utils::HashMap;
 
+use smallvec::{smallvec, SmallVec};
 use std::{borrow::Cow, collections::VecDeque};
 use thiserror::Error;
 
diff --git a/crates/bevy_render/src/texture/image_texture_conversion.rs b/crates/bevy_render/src/texture/image_texture_conversion.rs
index 41090adfc0d0d..d5bbed5ee6c87 100644
--- a/crates/bevy_render/src/texture/image_texture_conversion.rs
+++ b/crates/bevy_render/src/texture/image_texture_conversion.rs
@@ -13,7 +13,7 @@ impl Image {
         is_srgb: bool,
         asset_usage: RenderAssetUsages,
     ) -> Image {
-        use bevy_core::cast_slice;
+        use bytemuck::cast_slice;
         let width;
         let height;
 
diff --git a/crates/bevy_render/src/texture/mod.rs b/crates/bevy_render/src/texture/mod.rs
index 866cbc928c68e..986ae7d104ea4 100644
--- a/crates/bevy_render/src/texture/mod.rs
+++ b/crates/bevy_render/src/texture/mod.rs
@@ -118,6 +118,8 @@ impl Plugin for ImagePlugin {
             feature = "bmp",
             feature = "basis-universal",
             feature = "ktx2",
+            feature = "webp",
+            feature = "pnm"
         ))]
         app.preregister_asset_loader::<ImageLoader>(IMG_FILE_EXTENSIONS);
     }
@@ -131,6 +133,8 @@ impl Plugin for ImagePlugin {
             feature = "bmp",
             feature = "basis-universal",
             feature = "ktx2",
+            feature = "webp",
+            feature = "pnm"
         ))]
         {
             app.init_asset_loader::<ImageLoader>();
diff --git a/crates/bevy_render/src/view/window/mod.rs b/crates/bevy_render/src/view/window/mod.rs
index 6bca35efdea2d..64d089cee0f7c 100644
--- a/crates/bevy_render/src/view/window/mod.rs
+++ b/crates/bevy_render/src/view/window/mod.rs
@@ -276,7 +276,7 @@ pub fn prepare_windows(
                 format!("MSAA {}x", fallback.samples())
             };
 
-            bevy_log::warn!(
+            bevy_utils::tracing::warn!(
                 "MSAA {}x is not supported on this device. Falling back to {}.",
                 msaa.samples(),
                 fallback_str,
diff --git a/crates/bevy_render/src/view/window/screenshot.rs b/crates/bevy_render/src/view/window/screenshot.rs
index c13a60f88524c..b51c4f479770a 100644
--- a/crates/bevy_render/src/view/window/screenshot.rs
+++ b/crates/bevy_render/src/view/window/screenshot.rs
@@ -3,8 +3,8 @@ use std::{borrow::Cow, path::Path, sync::PoisonError};
 use bevy_app::Plugin;
 use bevy_asset::{load_internal_asset, Handle};
 use bevy_ecs::{entity::EntityHashMap, prelude::*};
-use bevy_log::{error, info, info_span};
 use bevy_tasks::AsyncComputeTaskPool;
+use bevy_utils::tracing::{error, info, info_span};
 use std::sync::Mutex;
 use thiserror::Error;
 use wgpu::{
@@ -144,7 +144,7 @@ impl Plugin for ScreenshotPlugin {
         #[cfg(feature = "bevy_ci_testing")]
         if app
             .world
-            .contains_resource::<bevy_app::ci_testing::CiTestingConfig>()
+            .contains_resource::<bevy_dev_tools::ci_testing::CiTestingConfig>()
         {
             app.add_systems(bevy_app::Update, ci_testing_screenshot_at);
         }
@@ -154,7 +154,7 @@ impl Plugin for ScreenshotPlugin {
 #[cfg(feature = "bevy_ci_testing")]
 fn ci_testing_screenshot_at(
     mut current_frame: Local<u32>,
-    ci_testing_config: Res<bevy_app::ci_testing::CiTestingConfig>,
+    ci_testing_config: Res<bevy_dev_tools::ci_testing::CiTestingConfig>,
     mut screenshot_manager: ResMut<ScreenshotManager>,
     main_window: Query<Entity, With<bevy_window::PrimaryWindow>>,
 ) {
diff --git a/crates/bevy_scene/src/dynamic_scene.rs b/crates/bevy_scene/src/dynamic_scene.rs
index 2cf9a190e1fd4..ac2f98ffae8bb 100644
--- a/crates/bevy_scene/src/dynamic_scene.rs
+++ b/crates/bevy_scene/src/dynamic_scene.rs
@@ -193,7 +193,7 @@ where
 #[cfg(test)]
 mod tests {
     use bevy_ecs::entity::EntityHashMap;
-    use bevy_ecs::{reflect::AppTypeRegistry, system::Command, world::World};
+    use bevy_ecs::{reflect::AppTypeRegistry, world::Command, world::World};
     use bevy_hierarchy::{Parent, PushChild};
 
     use crate::dynamic_scene_builder::DynamicSceneBuilder;
diff --git a/crates/bevy_scene/src/scene_spawner.rs b/crates/bevy_scene/src/scene_spawner.rs
index d8e0ea63acb5a..86c0c30d9a3d9 100644
--- a/crates/bevy_scene/src/scene_spawner.rs
+++ b/crates/bevy_scene/src/scene_spawner.rs
@@ -5,8 +5,8 @@ use bevy_ecs::{
     entity::Entity,
     event::{Event, Events, ManualEventReader},
     reflect::AppTypeRegistry,
-    system::{Command, Resource},
-    world::{Mut, World},
+    system::Resource,
+    world::{Command, Mut, World},
 };
 use bevy_hierarchy::{Parent, PushChild};
 use bevy_utils::{tracing::error, HashMap, HashSet};
diff --git a/crates/bevy_sprite/Cargo.toml b/crates/bevy_sprite/Cargo.toml
index ce8c402de2e08..01fea40918265 100644
--- a/crates/bevy_sprite/Cargo.toml
+++ b/crates/bevy_sprite/Cargo.toml
@@ -19,7 +19,6 @@ bevy_asset = { path = "../bevy_asset", version = "0.14.0-dev" }
 bevy_color = { path = "../bevy_color", version = "0.14.0-dev" }
 bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.14.0-dev" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.14.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.14.0-dev" }
 bevy_math = { path = "../bevy_math", version = "0.14.0-dev" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.14.0-dev", features = [
   "bevy",
diff --git a/crates/bevy_sprite/src/bundle.rs b/crates/bevy_sprite/src/bundle.rs
index cf0c1e968328f..0ad06f6afc696 100644
--- a/crates/bevy_sprite/src/bundle.rs
+++ b/crates/bevy_sprite/src/bundle.rs
@@ -1,3 +1,5 @@
+#![allow(deprecated)]
+
 use crate::{Sprite, TextureAtlas};
 use bevy_asset::Handle;
 use bevy_ecs::bundle::Bundle;
@@ -11,9 +13,9 @@ use bevy_transform::components::{GlobalTransform, Transform};
 ///
 /// # Extra behaviours
 ///
-/// You may add the following components to enable additional behaviours
+/// You may add one or both of the following components to enable additional behaviours:
 /// - [`ImageScaleMode`](crate::ImageScaleMode) to enable either slicing or tiling of the texture
-/// - [`TextureAtlas`] to draw specific sections of a sprite sheet, (See [`SpriteSheetBundle`])
+/// - [`TextureAtlas`] to draw a specific section of the texture
 #[derive(Bundle, Clone, Debug, Default)]
 pub struct SpriteBundle {
     /// Specifies the rendering properties of the sprite, such as color tint and flip.
@@ -41,6 +43,10 @@ pub struct SpriteBundle {
 /// Check the following examples for usage:
 /// - [`animated sprite sheet example`](https://github.com/bevyengine/bevy/blob/latest/examples/2d/sprite_sheet.rs)
 /// - [`texture atlas example`](https://github.com/bevyengine/bevy/blob/latest/examples/2d/texture_atlas.rs)
+#[deprecated(
+    since = "0.14.0",
+    note = "Use `TextureAtlas` alongside a `SpriteBundle` instead"
+)]
 #[derive(Bundle, Clone, Debug, Default)]
 pub struct SpriteSheetBundle {
     /// Specifies the rendering properties of the sprite, such as color tint and flip.
diff --git a/crates/bevy_sprite/src/lib.rs b/crates/bevy_sprite/src/lib.rs
index 2b7ed84a41a83..685ecb0d4b54a 100644
--- a/crates/bevy_sprite/src/lib.rs
+++ b/crates/bevy_sprite/src/lib.rs
@@ -12,9 +12,13 @@ mod texture_atlas_builder;
 mod texture_slice;
 
 pub mod prelude {
+    #[allow(deprecated)]
+    #[doc(hidden)]
+    pub use crate::bundle::SpriteSheetBundle;
+
     #[doc(hidden)]
     pub use crate::{
-        bundle::{SpriteBundle, SpriteSheetBundle},
+        bundle::SpriteBundle,
         sprite::{ImageScaleMode, Sprite},
         texture_atlas::{TextureAtlas, TextureAtlasLayout},
         texture_slice::{BorderRect, SliceScaleMode, TextureSlice, TextureSlicer},
diff --git a/crates/bevy_sprite/src/mesh2d/material.rs b/crates/bevy_sprite/src/mesh2d/material.rs
index a8588c73f80e3..2b5772c686559 100644
--- a/crates/bevy_sprite/src/mesh2d/material.rs
+++ b/crates/bevy_sprite/src/mesh2d/material.rs
@@ -10,7 +10,6 @@ use bevy_ecs::{
     prelude::*,
     system::{lifetimeless::SRes, SystemParamItem},
 };
-use bevy_log::error;
 use bevy_render::{
     mesh::{Mesh, MeshVertexBufferLayoutRef},
     prelude::Image,
@@ -30,6 +29,7 @@ use bevy_render::{
     Extract, ExtractSchedule, Render, RenderApp, RenderSet,
 };
 use bevy_transform::components::{GlobalTransform, Transform};
+use bevy_utils::tracing::error;
 use bevy_utils::{FloatOrd, HashMap, HashSet};
 use std::hash::Hash;
 use std::marker::PhantomData;
diff --git a/crates/bevy_sprite/src/mesh2d/mesh.rs b/crates/bevy_sprite/src/mesh2d/mesh.rs
index 045c1e2ca2594..5cd5fcb894374 100644
--- a/crates/bevy_sprite/src/mesh2d/mesh.rs
+++ b/crates/bevy_sprite/src/mesh2d/mesh.rs
@@ -10,7 +10,7 @@ use bevy_ecs::{
     system::{lifetimeless::*, SystemParamItem, SystemState},
 };
 use bevy_math::{Affine3, Vec4};
-use bevy_reflect::Reflect;
+use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_render::mesh::MeshVertexBufferLayoutRef;
 use bevy_render::{
     batching::{
@@ -39,7 +39,7 @@ use crate::Material2dBindGroupId;
 ///
 /// It wraps a [`Handle<Mesh>`] to differentiate from the 3d pipelines which use the handles directly as components
 #[derive(Default, Clone, Component, Debug, Reflect, PartialEq, Eq)]
-#[reflect(Component)]
+#[reflect(Default, Component)]
 pub struct Mesh2dHandle(pub Handle<Mesh>);
 
 impl From<Handle<Mesh>> for Mesh2dHandle {
diff --git a/crates/bevy_sprite/src/sprite.rs b/crates/bevy_sprite/src/sprite.rs
index 40d0dd5f3ca68..ae57eb760c091 100644
--- a/crates/bevy_sprite/src/sprite.rs
+++ b/crates/bevy_sprite/src/sprite.rs
@@ -32,8 +32,6 @@ pub struct Sprite {
 }
 
 /// Controls how the image is altered when scaled.
-///
-/// Note: This is not yet compatible with texture atlases
 #[derive(Component, Debug, Clone, Reflect)]
 #[reflect(Component)]
 pub enum ImageScaleMode {
diff --git a/crates/bevy_sprite/src/texture_atlas_builder.rs b/crates/bevy_sprite/src/texture_atlas_builder.rs
index 23327db5e9947..32d923b681c11 100644
--- a/crates/bevy_sprite/src/texture_atlas_builder.rs
+++ b/crates/bevy_sprite/src/texture_atlas_builder.rs
@@ -1,11 +1,11 @@
 use bevy_asset::AssetId;
-use bevy_log::{debug, error, warn};
 use bevy_math::{URect, UVec2};
 use bevy_render::{
     render_asset::RenderAssetUsages,
     render_resource::{Extent3d, TextureDimension, TextureFormat},
     texture::{Image, TextureFormatPixelInfo},
 };
+use bevy_utils::tracing::{debug, error, warn};
 use bevy_utils::HashMap;
 use rectangle_pack::{
     contains_smallest_box, pack_rects, volume_heuristic, GroupedRectsToPlace, PackedLocation,
@@ -173,14 +173,10 @@ impl<'a> TextureAtlasBuilder<'a> {
     ///     let texture = textures.add(texture);
     ///     let layout = layouts.add(atlas_layout);
     ///     // Spawn your sprite
-    ///     commands.spawn(SpriteSheetBundle {
-    ///        texture,
-    ///        atlas: TextureAtlas {
-    ///             layout,
-    ///             index: 0
-    ///         },
-    ///       ..Default::default()
-    ///     });
+    ///     commands.spawn((
+    ///         SpriteBundle { texture, ..Default::default() },
+    ///         TextureAtlas::from(layout),
+    ///     ));
     /// }
     /// ```
     ///
diff --git a/crates/bevy_sprite/src/texture_slice/computed_slices.rs b/crates/bevy_sprite/src/texture_slice/computed_slices.rs
index cbc5a370b43f9..1f08e9a817d49 100644
--- a/crates/bevy_sprite/src/texture_slice/computed_slices.rs
+++ b/crates/bevy_sprite/src/texture_slice/computed_slices.rs
@@ -1,4 +1,4 @@
-use crate::{ExtractedSprite, ImageScaleMode, Sprite};
+use crate::{ExtractedSprite, ImageScaleMode, Sprite, TextureAtlas, TextureAtlasLayout};
 
 use super::TextureSlice;
 use bevy_asset::{AssetEvent, Assets, Handle};
@@ -63,37 +63,55 @@ impl ComputedTextureSlices {
 /// will be computed according to the `image_handle` dimensions or the sprite rect.
 ///
 /// Returns `None` if the image asset is not loaded
+///
+/// # Arguments
+///
+/// * `sprite` - The sprite component, will be used to find the draw area size
+/// * `scale_mode` - The image scaling component
+/// * `image_handle` - The texture to slice or tile
+/// * `images` - The image assets, use to retrieve the image dimensions
+/// * `atlas` - Optional texture atlas, if set the slicing will happen on the matching sub section
+/// of the texture
+/// * `atlas_layouts` - The atlas layout assets, used to retrieve the texture atlas section rect
 #[must_use]
 fn compute_sprite_slices(
     sprite: &Sprite,
     scale_mode: &ImageScaleMode,
     image_handle: &Handle<Image>,
     images: &Assets<Image>,
+    atlas: Option<&TextureAtlas>,
+    atlas_layouts: &Assets<TextureAtlasLayout>,
 ) -> Option<ComputedTextureSlices> {
-    let image_size = images.get(image_handle).map(|i| {
-        Vec2::new(
-            i.texture_descriptor.size.width as f32,
-            i.texture_descriptor.size.height as f32,
-        )
-    })?;
-    let slices = match scale_mode {
-        ImageScaleMode::Sliced(slicer) => slicer.compute_slices(
-            sprite.rect.unwrap_or(Rect {
+    let (image_size, texture_rect) = match atlas {
+        Some(a) => {
+            let layout = atlas_layouts.get(&a.layout)?;
+            (
+                layout.size.as_vec2(),
+                layout.textures.get(a.index)?.as_rect(),
+            )
+        }
+        None => {
+            let image = images.get(image_handle)?;
+            let size = Vec2::new(
+                image.texture_descriptor.size.width as f32,
+                image.texture_descriptor.size.height as f32,
+            );
+            let rect = sprite.rect.unwrap_or(Rect {
                 min: Vec2::ZERO,
-                max: image_size,
-            }),
-            sprite.custom_size,
-        ),
+                max: size,
+            });
+            (size, rect)
+        }
+    };
+    let slices = match scale_mode {
+        ImageScaleMode::Sliced(slicer) => slicer.compute_slices(texture_rect, sprite.custom_size),
         ImageScaleMode::Tiled {
             tile_x,
             tile_y,
             stretch_value,
         } => {
             let slice = TextureSlice {
-                texture_rect: sprite.rect.unwrap_or(Rect {
-                    min: Vec2::ZERO,
-                    max: image_size,
-                }),
+                texture_rect,
                 draw_size: sprite.custom_size.unwrap_or(image_size),
                 offset: Vec2::ZERO,
             };
@@ -109,7 +127,14 @@ pub(crate) fn compute_slices_on_asset_event(
     mut commands: Commands,
     mut events: EventReader<AssetEvent<Image>>,
     images: Res<Assets<Image>>,
-    sprites: Query<(Entity, &ImageScaleMode, &Sprite, &Handle<Image>)>,
+    atlas_layouts: Res<Assets<TextureAtlasLayout>>,
+    sprites: Query<(
+        Entity,
+        &ImageScaleMode,
+        &Sprite,
+        &Handle<Image>,
+        Option<&TextureAtlas>,
+    )>,
 ) {
     // We store the asset ids of added/modified image assets
     let added_handles: HashSet<_> = events
@@ -123,11 +148,18 @@ pub(crate) fn compute_slices_on_asset_event(
         return;
     }
     // We recompute the sprite slices for sprite entities with a matching asset handle id
-    for (entity, scale_mode, sprite, image_handle) in &sprites {
+    for (entity, scale_mode, sprite, image_handle, atlas) in &sprites {
         if !added_handles.contains(&image_handle.id()) {
             continue;
         }
-        if let Some(slices) = compute_sprite_slices(sprite, scale_mode, image_handle, &images) {
+        if let Some(slices) = compute_sprite_slices(
+            sprite,
+            scale_mode,
+            image_handle,
+            &images,
+            atlas,
+            &atlas_layouts,
+        ) {
             commands.entity(entity).insert(slices);
         }
     }
@@ -138,17 +170,32 @@ pub(crate) fn compute_slices_on_asset_event(
 pub(crate) fn compute_slices_on_sprite_change(
     mut commands: Commands,
     images: Res<Assets<Image>>,
+    atlas_layouts: Res<Assets<TextureAtlasLayout>>,
     changed_sprites: Query<
-        (Entity, &ImageScaleMode, &Sprite, &Handle<Image>),
+        (
+            Entity,
+            &ImageScaleMode,
+            &Sprite,
+            &Handle<Image>,
+            Option<&TextureAtlas>,
+        ),
         Or<(
             Changed<ImageScaleMode>,
             Changed<Handle<Image>>,
             Changed<Sprite>,
+            Changed<TextureAtlas>,
         )>,
     >,
 ) {
-    for (entity, scale_mode, sprite, image_handle) in &changed_sprites {
-        if let Some(slices) = compute_sprite_slices(sprite, scale_mode, image_handle, &images) {
+    for (entity, scale_mode, sprite, image_handle, atlas) in &changed_sprites {
+        if let Some(slices) = compute_sprite_slices(
+            sprite,
+            scale_mode,
+            image_handle,
+            &images,
+            atlas,
+            &atlas_layouts,
+        ) {
             commands.entity(entity).insert(slices);
         }
     }
diff --git a/crates/bevy_sprite/src/texture_slice/mod.rs b/crates/bevy_sprite/src/texture_slice/mod.rs
index d617634acd3bd..516f025ca6676 100644
--- a/crates/bevy_sprite/src/texture_slice/mod.rs
+++ b/crates/bevy_sprite/src/texture_slice/mod.rs
@@ -86,7 +86,7 @@ impl TextureSlice {
             remaining_columns -= size_y;
         }
         if slices.len() > 1_000 {
-            bevy_log::warn!("One of your tiled textures has generated {} slices. You might want to use higher stretch values to avoid a great performance cost", slices.len());
+            bevy_utils::tracing::warn!("One of your tiled textures has generated {} slices. You might want to use higher stretch values to avoid a great performance cost", slices.len());
         }
         slices
     }
diff --git a/crates/bevy_sprite/src/texture_slice/slicer.rs b/crates/bevy_sprite/src/texture_slice/slicer.rs
index f048d6d880a53..d930aab705d12 100644
--- a/crates/bevy_sprite/src/texture_slice/slicer.rs
+++ b/crates/bevy_sprite/src/texture_slice/slicer.rs
@@ -72,7 +72,7 @@ impl TextureSlicer {
             TextureSlice {
                 texture_rect: Rect {
                     min: vec2(base_rect.max.x - right, base_rect.min.y),
-                    max: vec2(base_rect.max.x, top),
+                    max: vec2(base_rect.max.x, base_rect.min.y + top),
                 },
                 draw_size: vec2(right, top) * min_coef,
                 offset: vec2(
@@ -198,6 +198,9 @@ impl TextureSlicer {
     ///
     /// * `rect` - The section of the texture to slice in 9 parts
     /// * `render_size` - The optional draw size of the texture. If not set the `rect` size will be used.
+    //
+    // TODO: Support `URect` and `UVec2` instead (See `https://github.com/bevyengine/bevy/pull/11698`)
+    //
     #[must_use]
     pub fn compute_slices(&self, rect: Rect, render_size: Option<Vec2>) -> Vec<TextureSlice> {
         let render_size = render_size.unwrap_or_else(|| rect.size());
@@ -207,7 +210,7 @@ impl TextureSlicer {
             || self.border.top >= rect_size.y
             || self.border.bottom >= rect_size.y
         {
-            bevy_log::error!(
+            bevy_utils::tracing::error!(
                 "TextureSlicer::border has out of bounds values. No slicing will be applied"
             );
             return vec![TextureSlice {
diff --git a/crates/bevy_tasks/src/thread_executor.rs b/crates/bevy_tasks/src/thread_executor.rs
index dc989f902c12d..cc6b272efb4ff 100644
--- a/crates/bevy_tasks/src/thread_executor.rs
+++ b/crates/bevy_tasks/src/thread_executor.rs
@@ -106,7 +106,7 @@ impl<'task, 'ticker> ThreadExecutorTicker<'task, 'ticker> {
     }
 
     /// Synchronously try to tick a task on the executor.
-    /// Returns false if if does not find a task to tick.
+    /// Returns false if does not find a task to tick.
     pub fn try_tick(&self) -> bool {
         self.executor.executor.try_tick()
     }
diff --git a/crates/bevy_text/src/lib.rs b/crates/bevy_text/src/lib.rs
index 3ad31358ccf44..e0824cf9e3671 100644
--- a/crates/bevy_text/src/lib.rs
+++ b/crates/bevy_text/src/lib.rs
@@ -77,11 +77,6 @@ impl Plugin for TextPlugin {
         app.init_asset::<Font>()
             .register_type::<Text>()
             .register_type::<Text2dBounds>()
-            .register_type::<TextSection>()
-            .register_type::<Vec<TextSection>>()
-            .register_type::<TextStyle>()
-            .register_type::<JustifyText>()
-            .register_type::<BreakLineOn>()
             .init_asset_loader::<FontLoader>()
             .init_resource::<TextSettings>()
             .init_resource::<FontAtlasSets>()
diff --git a/crates/bevy_time/Cargo.toml b/crates/bevy_time/Cargo.toml
index beb9d0db56108..5b586ebab3d03 100644
--- a/crates/bevy_time/Cargo.toml
+++ b/crates/bevy_time/Cargo.toml
@@ -11,7 +11,7 @@ keywords = ["bevy"]
 [features]
 default = []
 serialize = ["serde"]
-bevy_ci_testing = ["bevy_app/bevy_ci_testing"]
+bevy_ci_testing = ["bevy_dev_tools/bevy_ci_testing"]
 
 [dependencies]
 # bevy
@@ -23,6 +23,7 @@ bevy_reflect = { path = "../bevy_reflect", version = "0.14.0-dev", features = [
   "bevy",
 ] }
 bevy_utils = { path = "../bevy_utils", version = "0.14.0-dev" }
+bevy_dev_tools = { path = "../bevy_dev_tools", version = "0.14.0-dev", optional = true }
 
 # other
 crossbeam-channel = "0.5.0"
diff --git a/crates/bevy_time/src/lib.rs b/crates/bevy_time/src/lib.rs
index 98c075e9985ff..c94e6f46db0ba 100644
--- a/crates/bevy_time/src/lib.rs
+++ b/crates/bevy_time/src/lib.rs
@@ -51,7 +51,6 @@ impl Plugin for TimePlugin {
             .register_type::<Time<Virtual>>()
             .register_type::<Time<Fixed>>()
             .register_type::<Timer>()
-            .register_type::<Stopwatch>()
             .add_systems(
                 First,
                 (time_system, virtual_time_system.after(time_system)).in_set(TimeSystem),
@@ -69,7 +68,7 @@ impl Plugin for TimePlugin {
         #[cfg(feature = "bevy_ci_testing")]
         if let Some(ci_testing_config) = app
             .world
-            .get_resource::<bevy_app::ci_testing::CiTestingConfig>()
+            .get_resource::<bevy_dev_tools::ci_testing::CiTestingConfig>()
         {
             if let Some(frame_time) = ci_testing_config.frame_time {
                 app.world
diff --git a/crates/bevy_transform/src/commands.rs b/crates/bevy_transform/src/commands.rs
index 1a2f0d4c8abfb..8cbad487ba5e9 100644
--- a/crates/bevy_transform/src/commands.rs
+++ b/crates/bevy_transform/src/commands.rs
@@ -1,7 +1,7 @@
 //! Extension to [`EntityCommands`] to modify `bevy_hierarchy` hierarchies
 //! while preserving [`GlobalTransform`].
 
-use bevy_ecs::{prelude::Entity, system::Command, system::EntityCommands, world::World};
+use bevy_ecs::{prelude::Entity, system::EntityCommands, world::Command, world::World};
 use bevy_hierarchy::{PushChild, RemoveParent};
 
 use crate::{GlobalTransform, Transform};
diff --git a/crates/bevy_transform/src/systems.rs b/crates/bevy_transform/src/systems.rs
index 8f6bac916a739..bdbce91e941bb 100644
--- a/crates/bevy_transform/src/systems.rs
+++ b/crates/bevy_transform/src/systems.rs
@@ -182,7 +182,7 @@ unsafe fn propagate_recursive(
 mod test {
     use bevy_app::prelude::*;
     use bevy_ecs::prelude::*;
-    use bevy_ecs::system::CommandQueue;
+    use bevy_ecs::world::CommandQueue;
     use bevy_math::{vec3, Vec3};
     use bevy_tasks::{ComputeTaskPool, TaskPool};
 
diff --git a/crates/bevy_ui/Cargo.toml b/crates/bevy_ui/Cargo.toml
index 3f2649257755f..b83a227e99d8d 100644
--- a/crates/bevy_ui/Cargo.toml
+++ b/crates/bevy_ui/Cargo.toml
@@ -19,7 +19,6 @@ bevy_derive = { path = "../bevy_derive", version = "0.14.0-dev" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.14.0-dev" }
 bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.14.0-dev" }
 bevy_input = { path = "../bevy_input", version = "0.14.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.14.0-dev" }
 bevy_math = { path = "../bevy_math", version = "0.14.0-dev" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.14.0-dev", features = [
   "bevy",
@@ -36,9 +35,11 @@ taffy = { version = "0.3.10" }
 serde = { version = "1", features = ["derive"], optional = true }
 bytemuck = { version = "1.5", features = ["derive"] }
 thiserror = "1.0.0"
+nonmax = "0.5"
+smallvec = "1.11"
 
 [features]
-serialize = ["serde"]
+serialize = ["serde", "smallvec/serde"]
 
 [lints]
 workspace = true
diff --git a/crates/bevy_ui/src/focus.rs b/crates/bevy_ui/src/focus.rs
index 6becec74be2cc..08d488de34bb9 100644
--- a/crates/bevy_ui/src/focus.rs
+++ b/crates/bevy_ui/src/focus.rs
@@ -12,10 +12,11 @@ use bevy_math::{Rect, Vec2};
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_render::{camera::NormalizedRenderTarget, prelude::Camera, view::ViewVisibility};
 use bevy_transform::components::GlobalTransform;
-
-use bevy_utils::{smallvec::SmallVec, HashMap};
+use bevy_utils::HashMap;
 use bevy_window::{PrimaryWindow, Window};
 
+use smallvec::SmallVec;
+
 #[cfg(feature = "serialize")]
 use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
 
diff --git a/crates/bevy_ui/src/layout/debug.rs b/crates/bevy_ui/src/layout/debug.rs
index 37fb5c2b88845..8d5f27e169eca 100644
--- a/crates/bevy_ui/src/layout/debug.rs
+++ b/crates/bevy_ui/src/layout/debug.rs
@@ -25,7 +25,7 @@ pub fn print_ui_layout_tree(ui_surface: &UiSurface) {
                 &mut out,
             );
         }
-        bevy_log::info!("Layout tree for camera entity: {entity:?}\n{out}");
+        bevy_utils::tracing::info!("Layout tree for camera entity: {entity:?}\n{out}");
     }
 }
 
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index df3ac93372bb6..6b7940e1484ec 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -2,21 +2,20 @@ mod convert;
 pub mod debug;
 
 use crate::{ContentSize, DefaultUiCamera, Node, Outline, Style, TargetCamera, UiScale};
-use bevy_ecs::entity::EntityHashMap;
 use bevy_ecs::{
     change_detection::{DetectChanges, DetectChangesMut},
-    entity::Entity,
+    entity::{Entity, EntityHashMap},
     event::EventReader,
     query::{With, Without},
     removal_detection::RemovedComponents,
-    system::{Query, Res, ResMut, Resource},
+    system::{Query, Res, ResMut, Resource, SystemParam},
     world::Ref,
 };
 use bevy_hierarchy::{Children, Parent};
-use bevy_log::warn;
 use bevy_math::{UVec2, Vec2};
 use bevy_render::camera::{Camera, NormalizedRenderTarget};
 use bevy_transform::components::Transform;
+use bevy_utils::tracing::warn;
 use bevy_utils::{default, HashMap, HashSet};
 use bevy_window::{PrimaryWindow, Window, WindowScaleFactorChanged};
 use std::fmt;
@@ -53,6 +52,7 @@ struct RootNodePair {
 #[derive(Resource)]
 pub struct UiSurface {
     entity_to_taffy: EntityHashMap<taffy::node::Node>,
+    camera_entity_to_taffy: EntityHashMap<taffy::node::Node>,
     camera_roots: EntityHashMap<Vec<RootNodePair>>,
     taffy: Taffy,
 }
@@ -79,6 +79,7 @@ impl Default for UiSurface {
         taffy.disable_rounding();
         Self {
             entity_to_taffy: Default::default(),
+            camera_entity_to_taffy: Default::default(),
             camera_roots: Default::default(),
             taffy,
         }
@@ -167,6 +168,10 @@ without UI components as a child of an entity with UI components, results may be
             ..default()
         };
 
+        let camera_node = *self
+            .camera_entity_to_taffy
+            .entry(camera_id)
+            .or_insert_with(|| self.taffy.new_leaf(viewport_style.clone()).unwrap());
         let existing_roots = self.camera_roots.entry(camera_id).or_default();
         let mut new_roots = Vec::new();
         for entity in children {
@@ -181,24 +186,16 @@ without UI components as a child of an entity with UI components, results may be
                         self.taffy.remove_child(previous_parent, node).unwrap();
                     }
 
+                    self.taffy.add_child(camera_node, node).unwrap();
+
                     RootNodePair {
-                        implicit_viewport_node: self
-                            .taffy
-                            .new_with_children(viewport_style.clone(), &[node])
-                            .unwrap(),
+                        implicit_viewport_node: camera_node,
                         user_root_node: node,
                     }
                 });
             new_roots.push(root_node);
         }
 
-        // Cleanup the implicit root nodes of any user root nodes that have been removed
-        for old_root in existing_roots {
-            if !new_roots.contains(old_root) {
-                self.taffy.remove(old_root.implicit_viewport_node).unwrap();
-            }
-        }
-
         self.camera_roots.insert(camera_id, new_roots);
     }
 
@@ -219,6 +216,15 @@ without UI components as a child of an entity with UI components, results may be
         }
     }
 
+    /// Removes each camera entity from the internal map and then removes their associated node from taffy
+    pub fn remove_camera_entities(&mut self, entities: impl IntoIterator<Item = Entity>) {
+        for entity in entities {
+            if let Some(node) = self.camera_entity_to_taffy.remove(&entity) {
+                self.taffy.remove(node).unwrap();
+            }
+        }
+    }
+
     /// Removes each entity from the internal map and then removes their associated node from taffy
     pub fn remove_entities(&mut self, entities: impl IntoIterator<Item = Entity>) {
         for entity in entities {
@@ -253,6 +259,14 @@ pub enum LayoutError {
     TaffyError(#[from] taffy::error::TaffyError),
 }
 
+#[derive(SystemParam)]
+pub struct UiLayoutSystemRemovedComponentParam<'w, 's> {
+    removed_cameras: RemovedComponents<'w, 's, Camera>,
+    removed_children: RemovedComponents<'w, 's, Children>,
+    removed_content_sizes: RemovedComponents<'w, 's, ContentSize>,
+    removed_nodes: RemovedComponents<'w, 's, Node>,
+}
+
 /// Updates the UI's layout tree, computes the new layout geometry and then updates the sizes and transforms of all the UI nodes.
 #[allow(clippy::too_many_arguments)]
 pub fn ui_layout_system(
@@ -268,9 +282,7 @@ pub fn ui_layout_system(
     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 removed_nodes: RemovedComponents<Node>,
+    mut removed_components: UiLayoutSystemRemovedComponentParam,
     mut node_transform_query: Query<(&mut Node, &mut Transform)>,
 ) {
     struct CameraLayoutInfo {
@@ -357,7 +369,7 @@ pub fn ui_layout_system(
     scale_factor_events.clear();
 
     // When a `ContentSize` component is removed from an entity, we need to remove the measure from the corresponding taffy node.
-    for entity in removed_content_sizes.read() {
+    for entity in removed_components.removed_content_sizes.read() {
         ui_surface.try_remove_measure(entity);
     }
     for (entity, mut content_size) in &mut measure_query {
@@ -367,15 +379,24 @@ pub fn ui_layout_system(
     }
 
     // clean up removed nodes
-    ui_surface.remove_entities(removed_nodes.read());
+    ui_surface.remove_entities(removed_components.removed_nodes.read());
+
+    // clean up removed cameras
+    ui_surface.remove_camera_entities(removed_components.removed_cameras.read());
 
     // update camera children
-    for (camera_id, CameraLayoutInfo { root_nodes, .. }) in &camera_layout_info {
-        ui_surface.set_camera_children(*camera_id, root_nodes.iter().cloned());
+    for (camera_id, _) in cameras.iter() {
+        let root_nodes =
+            if let Some(CameraLayoutInfo { root_nodes, .. }) = camera_layout_info.get(&camera_id) {
+                root_nodes.iter().cloned()
+            } else {
+                [].iter().cloned()
+            };
+        ui_surface.set_camera_children(camera_id, root_nodes);
     }
 
     // update and remove children
-    for entity in removed_children.read() {
+    for entity in removed_components.removed_children.read() {
         ui_surface.try_remove_children(entity);
     }
     for (entity, children) in &children_query {
@@ -460,7 +481,7 @@ pub fn resolve_outlines_system(
 ) {
     let viewport_size = primary_window
         .get_single()
-        .map(|window| Vec2::new(window.resolution.width(), window.resolution.height()))
+        .map(|window| window.size())
         .unwrap_or(Vec2::ZERO)
         / ui_scale.0;
 
@@ -521,17 +542,20 @@ mod tests {
     use bevy_core_pipeline::core_2d::Camera2dBundle;
     use bevy_ecs::entity::Entity;
     use bevy_ecs::event::Events;
+    use bevy_ecs::prelude::{Commands, Component, In, Query, With};
     use bevy_ecs::schedule::apply_deferred;
     use bevy_ecs::schedule::IntoSystemConfigs;
     use bevy_ecs::schedule::Schedule;
+    use bevy_ecs::system::RunSystemOnce;
     use bevy_ecs::world::World;
     use bevy_hierarchy::despawn_with_children_recursive;
     use bevy_hierarchy::BuildWorldChildren;
     use bevy_hierarchy::Children;
-    use bevy_math::vec2;
     use bevy_math::Vec2;
+    use bevy_math::{vec2, UVec2};
     use bevy_render::camera::ManualTextureViews;
     use bevy_render::camera::OrthographicProjection;
+    use bevy_render::prelude::Camera;
     use bevy_render::texture::Image;
     use bevy_utils::prelude::default;
     use bevy_utils::HashMap;
@@ -657,6 +681,54 @@ mod tests {
         assert!(ui_surface.entity_to_taffy.is_empty());
     }
 
+    #[test]
+    fn ui_surface_tracks_camera_entities() {
+        let (mut world, mut ui_schedule) = setup_ui_test_world();
+
+        // despawn all cameras so we can reset ui_surface back to a fresh state
+        let camera_entities = world
+            .query_filtered::<Entity, With<Camera>>()
+            .iter(&world)
+            .collect::<Vec<_>>();
+        for camera_entity in camera_entities {
+            world.despawn(camera_entity);
+        }
+
+        ui_schedule.run(&mut world);
+
+        // no UI entities in world, none in UiSurface
+        let ui_surface = world.resource::<UiSurface>();
+        assert!(ui_surface.camera_entity_to_taffy.is_empty());
+
+        // respawn camera
+        let camera_entity = world.spawn(Camera2dBundle::default()).id();
+
+        let ui_entity = world
+            .spawn((NodeBundle::default(), TargetCamera(camera_entity)))
+            .id();
+
+        // `ui_layout_system` should map `camera_entity` to a ui node in `UiSurface::camera_entity_to_taffy`
+        ui_schedule.run(&mut world);
+
+        let ui_surface = world.resource::<UiSurface>();
+        assert!(ui_surface
+            .camera_entity_to_taffy
+            .contains_key(&camera_entity));
+        assert_eq!(ui_surface.camera_entity_to_taffy.len(), 1);
+
+        world.despawn(ui_entity);
+        world.despawn(camera_entity);
+
+        // `ui_layout_system` should remove `camera_entity` from `UiSurface::camera_entity_to_taffy`
+        ui_schedule.run(&mut world);
+
+        let ui_surface = world.resource::<UiSurface>();
+        assert!(!ui_surface
+            .camera_entity_to_taffy
+            .contains_key(&camera_entity));
+        assert!(ui_surface.camera_entity_to_taffy.is_empty());
+    }
+
     #[test]
     #[should_panic]
     fn despawning_a_ui_entity_should_remove_its_corresponding_ui_node() {
@@ -785,6 +857,149 @@ mod tests {
         assert!(ui_surface.entity_to_taffy.is_empty());
     }
 
+    #[test]
+    fn ui_node_should_properly_update_when_changing_target_camera() {
+        #[derive(Component)]
+        struct MovingUiNode;
+
+        fn update_camera_viewports(
+            primary_window_query: Query<&Window, With<PrimaryWindow>>,
+            mut cameras: Query<&mut Camera>,
+        ) {
+            let primary_window = primary_window_query
+                .get_single()
+                .expect("missing primary window");
+            let camera_count = cameras.iter().len();
+            for (camera_index, mut camera) in cameras.iter_mut().enumerate() {
+                let viewport_width =
+                    primary_window.resolution.physical_width() / camera_count as u32;
+                let viewport_height = primary_window.resolution.physical_height();
+                let physical_position = UVec2::new(viewport_width * camera_index as u32, 0);
+                let physical_size = UVec2::new(viewport_width, viewport_height);
+                camera.viewport = Some(bevy_render::camera::Viewport {
+                    physical_position,
+                    physical_size,
+                    ..default()
+                });
+            }
+        }
+
+        fn move_ui_node(
+            In(pos): In<Vec2>,
+            mut commands: Commands,
+            cameras: Query<(Entity, &Camera)>,
+            moving_ui_query: Query<Entity, With<MovingUiNode>>,
+        ) {
+            let (target_camera_entity, _) = cameras
+                .iter()
+                .find(|(_, camera)| {
+                    let Some(logical_viewport_rect) = camera.logical_viewport_rect() else {
+                        panic!("missing logical viewport")
+                    };
+                    // make sure cursor is in viewport and that viewport has at least 1px of size
+                    logical_viewport_rect.contains(pos)
+                        && logical_viewport_rect.max.cmpge(Vec2::splat(0.)).any()
+                })
+                .expect("cursor position outside of camera viewport");
+            for moving_ui_entity in moving_ui_query.iter() {
+                commands
+                    .entity(moving_ui_entity)
+                    .insert(TargetCamera(target_camera_entity))
+                    .insert(Style {
+                        position_type: PositionType::Absolute,
+                        top: Val::Px(pos.y),
+                        left: Val::Px(pos.x),
+                        ..default()
+                    });
+            }
+        }
+
+        fn do_move_and_test(
+            world: &mut World,
+            ui_schedule: &mut Schedule,
+            new_pos: Vec2,
+            expected_camera_entity: &Entity,
+        ) {
+            world.run_system_once_with(new_pos, move_ui_node);
+            ui_schedule.run(world);
+            let (ui_node_entity, TargetCamera(target_camera_entity)) = world
+                .query_filtered::<(Entity, &TargetCamera), With<MovingUiNode>>()
+                .get_single(world)
+                .expect("missing MovingUiNode");
+            assert_eq!(expected_camera_entity, target_camera_entity);
+            let ui_surface = world.resource::<UiSurface>();
+
+            let layout = ui_surface
+                .get_layout(ui_node_entity)
+                .expect("failed to get layout");
+
+            // negative test for #12255
+            assert_eq!(Vec2::new(layout.location.x, layout.location.y), new_pos);
+        }
+
+        fn get_taffy_node_count(world: &World) -> usize {
+            world.resource::<UiSurface>().taffy.total_node_count()
+        }
+
+        let (mut world, mut ui_schedule) = setup_ui_test_world();
+
+        world.spawn(Camera2dBundle {
+            camera: Camera {
+                order: 1,
+                ..default()
+            },
+            ..default()
+        });
+
+        world.spawn((
+            NodeBundle {
+                style: Style {
+                    position_type: PositionType::Absolute,
+                    top: Val::Px(0.),
+                    left: Val::Px(0.),
+                    ..default()
+                },
+                ..default()
+            },
+            MovingUiNode,
+        ));
+
+        ui_schedule.run(&mut world);
+
+        let pos_inc = Vec2::splat(1.);
+        let total_cameras = world.query::<&Camera>().iter(&world).len();
+        // add total cameras - 1 (the assumed default) to get an idea for how many nodes we should expect
+        let expected_max_taffy_node_count = get_taffy_node_count(&world) + total_cameras - 1;
+
+        world.run_system_once(update_camera_viewports);
+
+        ui_schedule.run(&mut world);
+
+        let viewport_rects = world
+            .query::<(Entity, &Camera)>()
+            .iter(&world)
+            .map(|(e, c)| (e, c.logical_viewport_rect().expect("missing viewport")))
+            .collect::<Vec<_>>();
+
+        for (camera_entity, viewport) in viewport_rects.iter() {
+            let target_pos = viewport.min + pos_inc;
+            do_move_and_test(&mut world, &mut ui_schedule, target_pos, camera_entity);
+        }
+
+        // reverse direction
+        let mut viewport_rects = viewport_rects.clone();
+        viewport_rects.reverse();
+        for (camera_entity, viewport) in viewport_rects.iter() {
+            let target_pos = viewport.max - pos_inc;
+            do_move_and_test(&mut world, &mut ui_schedule, target_pos, camera_entity);
+        }
+
+        let current_taffy_node_count = get_taffy_node_count(&world);
+        if current_taffy_node_count > expected_max_taffy_node_count {
+            panic!("extra taffy nodes detected: current: {current_taffy_node_count} max expected: {expected_max_taffy_node_count}");
+        }
+    }
+
     #[test]
     fn ui_node_should_be_set_to_its_content_size() {
         let (mut world, mut ui_schedule) = setup_ui_test_world();
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 2e4306ee598c0..17daf47fb1c74 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -97,37 +97,19 @@ impl Plugin for UiPlugin {
         app.init_resource::<UiSurface>()
             .init_resource::<UiScale>()
             .init_resource::<UiStack>()
-            .register_type::<AlignContent>()
-            .register_type::<AlignItems>()
-            .register_type::<AlignSelf>()
             .register_type::<BackgroundColor>()
             .register_type::<CalculatedClip>()
             .register_type::<ContentSize>()
-            .register_type::<Direction>()
-            .register_type::<Display>()
-            .register_type::<FlexDirection>()
-            .register_type::<FlexWrap>()
             .register_type::<FocusPolicy>()
-            .register_type::<GridAutoFlow>()
-            .register_type::<GridPlacement>()
-            .register_type::<GridTrack>()
             .register_type::<Interaction>()
-            .register_type::<JustifyContent>()
-            .register_type::<JustifyItems>()
-            .register_type::<JustifySelf>()
             .register_type::<Node>()
-            .register_type::<Overflow>()
-            .register_type::<OverflowAxis>()
-            .register_type::<PositionType>()
             .register_type::<RelativeCursorPosition>()
-            .register_type::<RepeatedGridTrack>()
             .register_type::<Style>()
             .register_type::<TargetCamera>()
             .register_type::<UiImage>()
             .register_type::<UiImageSize>()
             .register_type::<UiRect>()
             .register_type::<UiScale>()
-            .register_type::<Val>()
             .register_type::<BorderColor>()
             .register_type::<widget::Button>()
             .register_type::<widget::Label>()
diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index 0a2a81e3d48ec..57b2bb4857d22 100644
--- a/crates/bevy_ui/src/node_bundles.rs
+++ b/crates/bevy_ui/src/node_bundles.rs
@@ -1,3 +1,5 @@
+#![allow(deprecated)]
+
 //! This module contains basic node bundles used to build UIs
 
 #[cfg(feature = "bevy_text")]
@@ -77,8 +79,9 @@ impl Default for NodeBundle {
 ///
 /// # Extra behaviours
 ///
-/// You may add the following components to enable additional behaviours
+/// You may add one or both of the following components to enable additional behaviours:
 /// - [`ImageScaleMode`](bevy_sprite::ImageScaleMode) to enable either slicing or tiling of the texture
+/// - [`TextureAtlas`] to draw a specific section of the texture
 #[derive(Bundle, Debug, Default)]
 pub struct ImageBundle {
     /// Describes the logical size of the node
@@ -88,10 +91,6 @@ pub struct ImageBundle {
     pub style: Style,
     /// The calculated size based on the given image
     pub calculated_size: ContentSize,
-    /// The background color, which serves as a "fill" for this node
-    ///
-    /// Combines with `UiImage` to tint the provided image.
-    pub background_color: BackgroundColor,
     /// The image of the node
     pub image: UiImage,
     /// The size of the image in pixels
@@ -121,7 +120,16 @@ pub struct ImageBundle {
 
 /// A UI node that is a texture atlas sprite
 ///
+/// # Extra behaviours
+///
+/// You may add the following components to enable additional behaviours
+/// - [`ImageScaleMode`](bevy_sprite::ImageScaleMode) to enable either slicing or tiling of the texture
+///
 /// This bundle is identical to [`ImageBundle`] with an additional [`TextureAtlas`] component.
+#[deprecated(
+    since = "0.14.0",
+    note = "Use `TextureAtlas` alongside `ImageBundle` instead"
+)]
 #[derive(Bundle, Debug, Default)]
 pub struct AtlasImageBundle {
     /// Describes the logical size of the node
@@ -131,10 +139,6 @@ pub struct AtlasImageBundle {
     pub style: Style,
     /// The calculated size based on the given image
     pub calculated_size: ContentSize,
-    /// The background color, which serves as a "fill" for this node
-    ///
-    /// Combines with `UiImage` to tint the provided image.
-    pub background_color: BackgroundColor,
     /// The image of the node
     pub image: UiImage,
     /// A handle to the texture atlas to use for this Ui Node
@@ -292,8 +296,9 @@ where
 ///
 /// # Extra behaviours
 ///
-/// You may add the following components to enable additional behaviours
+/// You may add one or both of the following components to enable additional behaviours:
 /// - [`ImageScaleMode`](bevy_sprite::ImageScaleMode) to enable either slicing or tiling of the texture
+/// - [`TextureAtlas`] to draw a specific section of the texture
 #[derive(Bundle, Clone, Debug)]
 pub struct ButtonBundle {
     /// Describes the logical size of the node
@@ -307,10 +312,6 @@ pub struct ButtonBundle {
     pub interaction: Interaction,
     /// Whether this node should block interaction with lower nodes
     pub focus_policy: FocusPolicy,
-    /// The background color, which serves as a "fill" for this node
-    ///
-    /// When combined with `UiImage`, tints the provided image.
-    pub background_color: BackgroundColor,
     /// The color of the Node's border
     pub border_color: BorderColor,
     /// The image of the node
@@ -337,13 +338,12 @@ pub struct ButtonBundle {
 impl Default for ButtonBundle {
     fn default() -> Self {
         Self {
-            focus_policy: FocusPolicy::Block,
             node: Default::default(),
             button: Default::default(),
             style: Default::default(),
-            border_color: BorderColor(Color::NONE),
             interaction: Default::default(),
-            background_color: Default::default(),
+            focus_policy: FocusPolicy::Block,
+            border_color: BorderColor(Color::NONE),
             image: Default::default(),
             transform: Default::default(),
             global_transform: Default::default(),
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 7c00c854cd257..f2fa85a71f3d5 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -59,7 +59,10 @@ pub const UI_SHADER_HANDLE: Handle<Shader> = Handle::weak_from_u128(130128470471
 
 #[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
 pub enum RenderUiSystem {
-    ExtractNode,
+    ExtractBackgrounds,
+    ExtractImages,
+    ExtractBorders,
+    ExtractText,
 }
 
 pub fn build_ui_render(app: &mut App) {
@@ -77,16 +80,27 @@ pub fn build_ui_render(app: &mut App) {
         .allow_ambiguous_resource::<ExtractedUiNodes>()
         .init_resource::<DrawFunctions<TransparentUi>>()
         .add_render_command::<TransparentUi, DrawUi>()
+        .configure_sets(
+            ExtractSchedule,
+            (
+                RenderUiSystem::ExtractBackgrounds,
+                RenderUiSystem::ExtractImages,
+                RenderUiSystem::ExtractBorders,
+                RenderUiSystem::ExtractText,
+            )
+                .chain(),
+        )
         .add_systems(
             ExtractSchedule,
             (
                 extract_default_ui_camera_view::<Camera2d>,
                 extract_default_ui_camera_view::<Camera3d>,
-                extract_uinodes.in_set(RenderUiSystem::ExtractNode),
-                extract_uinode_borders,
+                extract_uinode_background_colors.in_set(RenderUiSystem::ExtractBackgrounds),
+                extract_uinode_images.in_set(RenderUiSystem::ExtractImages),
+                extract_uinode_borders.in_set(RenderUiSystem::ExtractBorders),
+                extract_uinode_outlines.in_set(RenderUiSystem::ExtractBorders),
                 #[cfg(feature = "bevy_text")]
-                extract_text_uinodes,
-                extract_uinode_outlines,
+                extract_uinode_text.in_set(RenderUiSystem::ExtractText),
             ),
         )
         .add_systems(
@@ -148,6 +162,134 @@ pub struct ExtractedUiNodes {
     pub uinodes: EntityHashMap<ExtractedUiNode>,
 }
 
+pub fn extract_uinode_background_colors(
+    mut extracted_uinodes: ResMut<ExtractedUiNodes>,
+    default_ui_camera: Extract<DefaultUiCamera>,
+    uinode_query: Extract<
+        Query<(
+            Entity,
+            &Node,
+            &GlobalTransform,
+            &ViewVisibility,
+            Option<&CalculatedClip>,
+            Option<&TargetCamera>,
+            &BackgroundColor,
+        )>,
+    >,
+) {
+    for (entity, uinode, transform, view_visibility, clip, camera, background_color) in
+        &uinode_query
+    {
+        let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_ui_camera.get())
+        else {
+            continue;
+        };
+
+        // Skip invisible backgrounds
+        if !view_visibility.get() || background_color.0.is_fully_transparent() {
+            continue;
+        }
+
+        extracted_uinodes.uinodes.insert(
+            entity,
+            ExtractedUiNode {
+                stack_index: uinode.stack_index,
+                transform: transform.compute_matrix(),
+                color: background_color.0.into(),
+                rect: Rect {
+                    min: Vec2::ZERO,
+                    max: uinode.calculated_size,
+                },
+                clip: clip.map(|clip| clip.clip),
+                image: AssetId::default(),
+                atlas_size: None,
+                flip_x: false,
+                flip_y: false,
+                camera_entity,
+            },
+        );
+    }
+}
+
+pub fn extract_uinode_images(
+    mut commands: Commands,
+    mut extracted_uinodes: ResMut<ExtractedUiNodes>,
+    texture_atlases: Extract<Res<Assets<TextureAtlasLayout>>>,
+    default_ui_camera: Extract<DefaultUiCamera>,
+    uinode_query: Extract<
+        Query<(
+            &Node,
+            &GlobalTransform,
+            &ViewVisibility,
+            Option<&CalculatedClip>,
+            Option<&TargetCamera>,
+            &UiImage,
+            Option<&TextureAtlas>,
+            Option<&ComputedTextureSlices>,
+        )>,
+    >,
+) {
+    for (uinode, transform, view_visibility, clip, camera, image, atlas, slices) in &uinode_query {
+        let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_ui_camera.get())
+        else {
+            continue;
+        };
+
+        // Skip invisible images
+        if !view_visibility.get() || image.color.is_fully_transparent() {
+            continue;
+        }
+
+        if let Some(slices) = slices {
+            extracted_uinodes.uinodes.extend(
+                slices
+                    .extract_ui_nodes(transform, uinode, image, clip, camera_entity)
+                    .map(|e| (commands.spawn_empty().id(), e)),
+            );
+            continue;
+        }
+
+        let (rect, atlas_size) = match atlas {
+            Some(atlas) => {
+                let Some(layout) = texture_atlases.get(&atlas.layout) else {
+                    // Atlas not present in assets resource (should this warn the user?)
+                    continue;
+                };
+                let mut atlas_rect = layout.textures[atlas.index].as_rect();
+                let mut atlas_size = layout.size.as_vec2();
+                let scale = uinode.size() / atlas_rect.size();
+                atlas_rect.min *= scale;
+                atlas_rect.max *= scale;
+                atlas_size *= scale;
+                (atlas_rect, Some(atlas_size))
+            }
+            None => (
+                Rect {
+                    min: Vec2::ZERO,
+                    max: uinode.calculated_size,
+                },
+                None,
+            ),
+        };
+
+        extracted_uinodes.uinodes.insert(
+            commands.spawn_empty().id(),
+            ExtractedUiNode {
+                stack_index: uinode.stack_index,
+                transform: transform.compute_matrix(),
+                color: image.color.into(),
+                rect,
+                clip: clip.map(|clip| clip.clip),
+                image: image.texture.id(),
+                atlas_size,
+                flip_x: image.flip_x,
+                flip_y: image.flip_y,
+                camera_entity,
+            },
+        );
+    }
+}
+
 pub(crate) fn resolve_border_thickness(value: Val, parent_width: f32, viewport_size: Vec2) -> f32 {
     match value {
         Val::Auto => 0.,
@@ -171,12 +313,12 @@ pub fn extract_uinode_borders(
             (
                 &Node,
                 &GlobalTransform,
-                &Style,
-                &BorderColor,
-                Option<&Parent>,
                 &ViewVisibility,
                 Option<&CalculatedClip>,
                 Option<&TargetCamera>,
+                Option<&Parent>,
+                &Style,
+                &BorderColor,
             ),
             Without<ContentSize>,
         >,
@@ -185,13 +327,14 @@ pub fn extract_uinode_borders(
 ) {
     let image = AssetId::<Image>::default();
 
-    for (node, global_transform, style, border_color, parent, view_visibility, clip, camera) in
+    for (node, global_transform, view_visibility, clip, camera, parent, style, border_color) in
         &uinode_query
     {
         let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_ui_camera.get())
         else {
             continue;
         };
+
         // Skip invisible borders
         if !view_visibility.get()
             || border_color.0.is_fully_transparent()
@@ -290,19 +433,20 @@ pub fn extract_uinode_outlines(
         Query<(
             &Node,
             &GlobalTransform,
-            &Outline,
             &ViewVisibility,
             Option<&CalculatedClip>,
             Option<&TargetCamera>,
+            &Outline,
         )>,
     >,
 ) {
     let image = AssetId::<Image>::default();
-    for (node, global_transform, outline, view_visibility, maybe_clip, camera) in &uinode_query {
+    for (node, global_transform, view_visibility, maybe_clip, camera, outline) in &uinode_query {
         let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_ui_camera.get())
         else {
             continue;
         };
+
         // Skip invisible outlines
         if !view_visibility.get()
             || outline.color.is_fully_transparent()
@@ -373,104 +517,6 @@ pub fn extract_uinode_outlines(
     }
 }
 
-pub fn extract_uinodes(
-    mut commands: Commands,
-    mut extracted_uinodes: ResMut<ExtractedUiNodes>,
-    texture_atlases: Extract<Res<Assets<TextureAtlasLayout>>>,
-    default_ui_camera: Extract<DefaultUiCamera>,
-    uinode_query: Extract<
-        Query<(
-            Entity,
-            &Node,
-            &GlobalTransform,
-            &BackgroundColor,
-            Option<&UiImage>,
-            &ViewVisibility,
-            Option<&CalculatedClip>,
-            Option<&TextureAtlas>,
-            Option<&TargetCamera>,
-            Option<&ComputedTextureSlices>,
-        )>,
-    >,
-) {
-    for (
-        entity,
-        uinode,
-        transform,
-        color,
-        maybe_image,
-        view_visibility,
-        clip,
-        atlas,
-        camera,
-        slices,
-    ) in uinode_query.iter()
-    {
-        let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_ui_camera.get())
-        else {
-            continue;
-        };
-        // Skip invisible and completely transparent nodes
-        if !view_visibility.get() || color.0.is_fully_transparent() {
-            continue;
-        }
-
-        if let Some((image, slices)) = maybe_image.zip(slices) {
-            extracted_uinodes.uinodes.extend(
-                slices
-                    .extract_ui_nodes(transform, uinode, color, image, clip, camera_entity)
-                    .map(|e| (commands.spawn_empty().id(), e)),
-            );
-            continue;
-        }
-
-        let (image, flip_x, flip_y) = if let Some(image) = maybe_image {
-            (image.texture.id(), image.flip_x, image.flip_y)
-        } else {
-            (AssetId::default(), false, false)
-        };
-
-        let (rect, atlas_size) = match atlas {
-            Some(atlas) => {
-                let Some(layout) = texture_atlases.get(&atlas.layout) else {
-                    // Atlas not present in assets resource (should this warn the user?)
-                    continue;
-                };
-                let mut atlas_rect = layout.textures[atlas.index].as_rect();
-                let mut atlas_size = layout.size.as_vec2();
-                let scale = uinode.size() / atlas_rect.size();
-                atlas_rect.min *= scale;
-                atlas_rect.max *= scale;
-                atlas_size *= scale;
-                (atlas_rect, Some(atlas_size))
-            }
-            None => (
-                Rect {
-                    min: Vec2::ZERO,
-                    max: uinode.calculated_size,
-                },
-                None,
-            ),
-        };
-
-        extracted_uinodes.uinodes.insert(
-            entity,
-            ExtractedUiNode {
-                stack_index: uinode.stack_index,
-                transform: transform.compute_matrix(),
-                color: color.0.into(),
-                rect,
-                clip: clip.map(|clip| clip.clip),
-                image,
-                atlas_size,
-                flip_x,
-                flip_y,
-                camera_entity,
-            },
-        );
-    }
-}
-
 /// The UI camera is "moved back" by this many units (plus the [`UI_CAMERA_TRANSFORM_OFFSET`]) and also has a view
 /// distance of this many units. This ensures that with a left-handed projection,
 /// as ui elements are "stacked on top of each other", they are within the camera's view
@@ -546,7 +592,7 @@ pub fn extract_default_ui_camera_view<T: Component>(
 }
 
 #[cfg(feature = "bevy_text")]
-pub fn extract_text_uinodes(
+pub fn extract_uinode_text(
     mut commands: Commands,
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
     camera_query: Extract<Query<(Entity, &Camera)>>,
@@ -557,21 +603,22 @@ pub fn extract_text_uinodes(
         Query<(
             &Node,
             &GlobalTransform,
-            &Text,
-            &TextLayoutInfo,
             &ViewVisibility,
             Option<&CalculatedClip>,
             Option<&TargetCamera>,
+            &Text,
+            &TextLayoutInfo,
         )>,
     >,
 ) {
-    for (uinode, global_transform, text, text_layout_info, view_visibility, clip, camera) in
-        uinode_query.iter()
+    for (uinode, global_transform, view_visibility, clip, camera, text, text_layout_info) in
+        &uinode_query
     {
         let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_ui_camera.get())
         else {
             continue;
         };
+
         // Skip if not visible or if size is set to zero (e.g. when a parent is set to `Display::None`)
         if !view_visibility.get() || uinode.size().x == 0. || uinode.size().y == 0. {
             continue;
diff --git a/crates/bevy_ui/src/render/render_pass.rs b/crates/bevy_ui/src/render/render_pass.rs
index e0119509d7b27..1f3ffb0d20dea 100644
--- a/crates/bevy_ui/src/render/render_pass.rs
+++ b/crates/bevy_ui/src/render/render_pass.rs
@@ -14,7 +14,8 @@ use bevy_render::{
     renderer::*,
     view::*,
 };
-use bevy_utils::{nonmax::NonMaxU32, FloatOrd};
+use bevy_utils::FloatOrd;
+use nonmax::NonMaxU32;
 
 pub struct UiPassNode {
     ui_view_query: QueryState<
diff --git a/crates/bevy_ui/src/render/ui_material_pipeline.rs b/crates/bevy_ui/src/render/ui_material_pipeline.rs
index 422410642bacd..171cd04d958ea 100644
--- a/crates/bevy_ui/src/render/ui_material_pipeline.rs
+++ b/crates/bevy_ui/src/render/ui_material_pipeline.rs
@@ -74,7 +74,7 @@ where
                     ExtractSchedule,
                     (
                         extract_ui_materials::<M>,
-                        extract_ui_material_nodes::<M>.in_set(RenderUiSystem::ExtractNode),
+                        extract_ui_material_nodes::<M>.in_set(RenderUiSystem::ExtractBackgrounds),
                     ),
                 )
                 .add_systems(
@@ -383,7 +383,7 @@ pub fn extract_ui_material_nodes<M: UiMaterial>(
 ) {
     let ui_logical_viewport_size = windows
         .get_single()
-        .map(|window| Vec2::new(window.resolution.width(), window.resolution.height()))
+        .map(|window| window.size())
         .unwrap_or(Vec2::ZERO)
         // 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.
diff --git a/crates/bevy_ui/src/stack.rs b/crates/bevy_ui/src/stack.rs
index ec389daa59144..6acc994b6f71e 100644
--- a/crates/bevy_ui/src/stack.rs
+++ b/crates/bevy_ui/src/stack.rs
@@ -126,8 +126,8 @@ mod tests {
     use bevy_ecs::{
         component::Component,
         schedule::Schedule,
-        system::{CommandQueue, Commands},
-        world::World,
+        system::Commands,
+        world::{CommandQueue, World},
     };
     use bevy_hierarchy::BuildChildren;
 
diff --git a/crates/bevy_ui/src/texture_slice.rs b/crates/bevy_ui/src/texture_slice.rs
index 52a9112d8b14c..c0836a3b870bb 100644
--- a/crates/bevy_ui/src/texture_slice.rs
+++ b/crates/bevy_ui/src/texture_slice.rs
@@ -6,11 +6,11 @@ use bevy_asset::{AssetEvent, Assets};
 use bevy_ecs::prelude::*;
 use bevy_math::{Rect, Vec2};
 use bevy_render::texture::Image;
-use bevy_sprite::{ImageScaleMode, TextureSlice};
+use bevy_sprite::{ImageScaleMode, TextureAtlas, TextureAtlasLayout, TextureSlice};
 use bevy_transform::prelude::*;
 use bevy_utils::HashSet;
 
-use crate::{BackgroundColor, CalculatedClip, ExtractedUiNode, Node, UiImage};
+use crate::{CalculatedClip, ExtractedUiNode, Node, UiImage};
 
 /// Component storing texture slices for image nodes entities with a tiled or sliced  [`ImageScaleMode`]
 ///
@@ -35,7 +35,6 @@ impl ComputedTextureSlices {
         &'a self,
         transform: &'a GlobalTransform,
         node: &'a Node,
-        background_color: &'a BackgroundColor,
         image: &'a UiImage,
         clip: Option<&'a CalculatedClip>,
         camera_entity: Entity,
@@ -60,7 +59,7 @@ impl ComputedTextureSlices {
             let atlas_size = Some(self.image_size * scale);
             ExtractedUiNode {
                 stack_index: node.stack_index,
-                color: background_color.0.into(),
+                color: image.color.into(),
                 transform: transform.compute_matrix(),
                 rect,
                 flip_x,
@@ -75,25 +74,48 @@ impl ComputedTextureSlices {
 }
 
 /// Generates sprite slices for a `sprite` given a `scale_mode`. The slices
-/// will be computed according to the `image_handle` dimensions or the sprite rect.
+/// will be computed according to the `image_handle` dimensions.
 ///
 /// Returns `None` if the image asset is not loaded
+///
+/// # Arguments
+///
+/// * `draw_area` - The size of the drawing area the slices will have to fit into
+/// * `scale_mode` - The image scaling component
+/// * `image_handle` - The texture to slice or tile
+/// * `images` - The image assets, use to retrieve the image dimensions
+/// * `atlas` - Optional texture atlas, if set the slicing will happen on the matching sub section
+/// of the texture
+/// * `atlas_layouts` - The atlas layout assets, used to retrieve the texture atlas section rect
 #[must_use]
 fn compute_texture_slices(
     draw_area: Vec2,
     scale_mode: &ImageScaleMode,
     image_handle: &UiImage,
     images: &Assets<Image>,
+    atlas: Option<&TextureAtlas>,
+    atlas_layouts: &Assets<TextureAtlasLayout>,
 ) -> Option<ComputedTextureSlices> {
-    let image_size = images.get(&image_handle.texture).map(|i| {
-        Vec2::new(
-            i.texture_descriptor.size.width as f32,
-            i.texture_descriptor.size.height as f32,
-        )
-    })?;
-    let texture_rect = Rect {
-        min: Vec2::ZERO,
-        max: image_size,
+    let (image_size, texture_rect) = match atlas {
+        Some(a) => {
+            let layout = atlas_layouts.get(&a.layout)?;
+            (
+                layout.size.as_vec2(),
+                layout.textures.get(a.index)?.as_rect(),
+            )
+        }
+        None => {
+            let image = images.get(&image_handle.texture)?;
+            let size = Vec2::new(
+                image.texture_descriptor.size.width as f32,
+                image.texture_descriptor.size.height as f32,
+            );
+            let rect = Rect {
+                min: Vec2::ZERO,
+                max: size,
+            };
+            (size, rect)
+        }
     };
     let slices = match scale_mode {
         ImageScaleMode::Sliced(slicer) => slicer.compute_slices(texture_rect, Some(draw_area)),
@@ -119,7 +141,14 @@ pub(crate) fn compute_slices_on_asset_event(
     mut commands: Commands,
     mut events: EventReader<AssetEvent<Image>>,
     images: Res<Assets<Image>>,
-    ui_nodes: Query<(Entity, &ImageScaleMode, &Node, &UiImage)>,
+    atlas_layouts: Res<Assets<TextureAtlasLayout>>,
+    ui_nodes: Query<(
+        Entity,
+        &ImageScaleMode,
+        &Node,
+        &UiImage,
+        Option<&TextureAtlas>,
+    )>,
 ) {
     // We store the asset ids of added/modified image assets
     let added_handles: HashSet<_> = events
@@ -133,11 +162,18 @@ pub(crate) fn compute_slices_on_asset_event(
         return;
     }
     // We recompute the sprite slices for sprite entities with a matching asset handle id
-    for (entity, scale_mode, ui_node, image) in &ui_nodes {
+    for (entity, scale_mode, ui_node, image, atlas) in &ui_nodes {
         if !added_handles.contains(&image.texture.id()) {
             continue;
         }
-        if let Some(slices) = compute_texture_slices(ui_node.size(), scale_mode, image, &images) {
+        if let Some(slices) = compute_texture_slices(
+            ui_node.size(),
+            scale_mode,
+            image,
+            &images,
+            atlas,
+            &atlas_layouts,
+        ) {
             commands.entity(entity).insert(slices);
         }
     }
@@ -148,13 +184,32 @@ pub(crate) fn compute_slices_on_asset_event(
 pub(crate) fn compute_slices_on_image_change(
     mut commands: Commands,
     images: Res<Assets<Image>>,
+    atlas_layouts: Res<Assets<TextureAtlasLayout>>,
     changed_nodes: Query<
-        (Entity, &ImageScaleMode, &Node, &UiImage),
-        Or<(Changed<ImageScaleMode>, Changed<UiImage>, Changed<Node>)>,
+        (
+            Entity,
+            &ImageScaleMode,
+            &Node,
+            &UiImage,
+            Option<&TextureAtlas>,
+        ),
+        Or<(
+            Changed<ImageScaleMode>,
+            Changed<UiImage>,
+            Changed<Node>,
+            Changed<TextureAtlas>,
+        )>,
     >,
 ) {
-    for (entity, scale_mode, ui_node, image) in &changed_nodes {
-        if let Some(slices) = compute_texture_slices(ui_node.size(), scale_mode, image, &images) {
+    for (entity, scale_mode, ui_node, image, atlas) in &changed_nodes {
+        if let Some(slices) = compute_texture_slices(
+            ui_node.size(),
+            scale_mode,
+            image,
+            &images,
+            atlas,
+            &atlas_layouts,
+        ) {
             commands.entity(entity).insert(slices);
         }
     }
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index 3be256fe1efd9..36db16ca60614 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -9,8 +9,9 @@ use bevy_render::{
     texture::Image,
 };
 use bevy_transform::prelude::GlobalTransform;
-use bevy_utils::{smallvec::SmallVec, warn_once};
+use bevy_utils::warn_once;
 use bevy_window::{PrimaryWindow, WindowRef};
+use smallvec::SmallVec;
 use std::num::{NonZeroI16, NonZeroU16};
 use thiserror::Error;
 
@@ -1589,7 +1590,6 @@ pub enum GridPlacementError {
 /// The background color of the node
 ///
 /// This serves as the "fill" color.
-/// When combined with [`UiImage`], tints the provided texture.
 #[derive(Component, Copy, Clone, Debug, Reflect)]
 #[reflect(Component, Default)]
 #[cfg_attr(
@@ -1729,6 +1729,8 @@ impl Outline {
 #[derive(Component, Clone, Debug, Reflect, Default)]
 #[reflect(Component, Default)]
 pub struct UiImage {
+    /// The tint color used to draw the image
+    pub color: Color,
     /// Handle to the texture
     pub texture: Handle<Image>,
     /// Whether the image should be flipped along its x-axis
@@ -1745,6 +1747,13 @@ impl UiImage {
         }
     }
 
+    /// Set the color tint
+    #[must_use]
+    pub const fn with_color(mut self, color: Color) -> Self {
+        self.color = color;
+        self
+    }
+
     /// Flip the image along its x-axis
     #[must_use]
     pub const fn with_flip_x(mut self) -> Self {
diff --git a/crates/bevy_utils/Cargo.toml b/crates/bevy_utils/Cargo.toml
index d9165cb5bb927..88fe6dc0a574c 100644
--- a/crates/bevy_utils/Cargo.toml
+++ b/crates/bevy_utils/Cargo.toml
@@ -15,14 +15,9 @@ detailed_trace = []
 ahash = "0.8.7"
 tracing = { version = "0.1", default-features = false, features = ["std"] }
 web-time = { version = "0.2" }
-uuid = { version = "1.1", features = ["v4", "serde"] }
 hashbrown = { version = "0.14", features = ["serde"] }
 bevy_utils_proc_macros = { version = "0.14.0-dev", path = "macros" }
-petgraph = "0.6"
-thiserror = "1.0"
 thread_local = "1.0"
-nonmax = "0.5"
-smallvec = { version = "1.11", features = ["serde", "union", "const_generics"] }
 
 [dev-dependencies]
 static_assertions = "1.1.0"
diff --git a/crates/bevy_utils/src/lib.rs b/crates/bevy_utils/src/lib.rs
index ffd4f330efd21..33f5312171041 100644
--- a/crates/bevy_utils/src/lib.rs
+++ b/crates/bevy_utils/src/lib.rs
@@ -15,8 +15,6 @@ pub use short_names::get_short_name;
 pub mod synccell;
 pub mod syncunsafecell;
 
-pub mod uuid;
-
 mod cow_arc;
 mod default;
 mod float_ord;
@@ -24,7 +22,6 @@ pub mod intern;
 mod once;
 mod parallel_queue;
 
-pub use crate::uuid::Uuid;
 pub use ahash::{AHasher, RandomState};
 pub use bevy_utils_proc_macros::*;
 pub use cow_arc::*;
@@ -32,17 +29,9 @@ pub use default::default;
 pub use float_ord::*;
 pub use hashbrown;
 pub use parallel_queue::*;
-pub use petgraph;
-pub use smallvec;
-pub use thiserror;
 pub use tracing;
 pub use web_time::{Duration, Instant, SystemTime, SystemTimeError, TryFromFloatSecsError};
 
-#[allow(missing_docs)]
-pub mod nonmax {
-    pub use nonmax::*;
-}
-
 use hashbrown::hash_map::RawEntryMut;
 use std::{
     any::TypeId,
@@ -64,7 +53,7 @@ pub type BoxedFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;
 pub type BoxedFuture<'a, T> = Pin<Box<dyn Future<Output = T> + 'a>>;
 
 /// A shortcut alias for [`hashbrown::hash_map::Entry`].
-pub type Entry<'a, K, V> = hashbrown::hash_map::Entry<'a, K, V, BuildHasherDefault<AHasher>>;
+pub type Entry<'a, K, V, S = BuildHasherDefault<AHasher>> = hashbrown::hash_map::Entry<'a, K, V, S>;
 
 /// A hasher builder that will create a fixed hasher.
 #[derive(Debug, Clone, Default)]
diff --git a/crates/bevy_utils/src/uuid.rs b/crates/bevy_utils/src/uuid.rs
deleted file mode 100644
index 3542c9411eee0..0000000000000
--- a/crates/bevy_utils/src/uuid.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//! UUID utilities.
-//!
-//! This module re-exports the [`Uuid`] type from the [`uuid`] crate,
-//! and provides additional utility functions.
-//!
-//! [`uuid`]: uuid
-
-pub use ::uuid::Uuid;
-
-/// Generates a new UUID from the given UUIDs `a` and `b`,
-/// where the bytes are generated by a bitwise `a ^ b.rotate_right(1)`.
-///
-/// The generated UUID will be a `UUIDv4`
-/// (meaning that the bytes should be random, not e.g. derived from the system time).
-#[allow(clippy::unusual_byte_groupings)] // unusual byte grouping is meant to signal the relevant bits
-pub const fn generate_composite_uuid(a: Uuid, b: Uuid) -> Uuid {
-    let mut new = [0; 16];
-    let mut i = 0;
-    while i < new.len() {
-        // rotating ensures different uuids for A<B<C>> and B<A<C>> because: A ^ (B ^ C) = B ^ (A ^ C)
-        // notice that you have to rotate the second parameter: A.rr ^ (B.rr ^ C) = B.rr ^ (A.rr ^ C)
-        // Solution: A ^ (B ^ C.rr).rr != B ^ (A ^ C.rr).rr
-        new[i] = a.as_bytes()[i] ^ b.as_bytes()[i].rotate_right(1);
-
-        i += 1;
-    }
-
-    // Version: the most significant 4 bits in the 6th byte: 11110000
-    new[6] = new[6] & 0b0000_1111 | 0b0100_0000; // set version to v4
-
-    // Variant: the most significant 3 bits in the 8th byte: 11100000
-    new[8] = new[8] & 0b000_11111 | 0b100_00000; // set variant to rfc4122
-
-    Uuid::from_bytes(new)
-}
diff --git a/crates/bevy_window/src/lib.rs b/crates/bevy_window/src/lib.rs
index 0c7eb48e8dc50..227f7b598cf55 100644
--- a/crates/bevy_window/src/lib.rs
+++ b/crates/bevy_window/src/lib.rs
@@ -31,7 +31,6 @@ pub mod prelude {
 }
 
 use bevy_app::prelude::*;
-use std::path::PathBuf;
 
 impl Default for WindowPlugin {
     fn default() -> Self {
@@ -147,24 +146,7 @@ impl Plugin for WindowPlugin {
 
         // Register window descriptor and related types
         app.register_type::<Window>()
-            .register_type::<PrimaryWindow>()
-            .register_type::<Cursor>()
-            .register_type::<CursorIcon>()
-            .register_type::<CursorGrabMode>()
-            .register_type::<CompositeAlphaMode>()
-            .register_type::<WindowResolution>()
-            .register_type::<WindowPosition>()
-            .register_type::<WindowMode>()
-            .register_type::<WindowLevel>()
-            .register_type::<PresentMode>()
-            .register_type::<InternalWindowState>()
-            .register_type::<MonitorSelection>()
-            .register_type::<WindowResizeConstraints>()
-            .register_type::<WindowTheme>()
-            .register_type::<EnabledButtons>();
-
-        // Register `PathBuf` as it's used by `FileDragAndDrop`
-        app.register_type::<PathBuf>();
+            .register_type::<PrimaryWindow>();
     }
 }
 
diff --git a/crates/bevy_window/src/window.rs b/crates/bevy_window/src/window.rs
index b141d388fe128..c241c9b71330a 100644
--- a/crates/bevy_window/src/window.rs
+++ b/crates/bevy_window/src/window.rs
@@ -2,7 +2,7 @@ use bevy_ecs::{
     entity::{Entity, EntityMapper, MapEntities},
     prelude::{Component, ReflectComponent},
 };
-use bevy_math::{DVec2, IVec2, Vec2};
+use bevy_math::{DVec2, IVec2, UVec2, Vec2};
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 
 #[cfg(feature = "serialize")]
@@ -206,6 +206,14 @@ pub struct Window {
     ///
     /// This value has no effect on non-web platforms.
     pub canvas: Option<String>,
+    /// Whether or not to fit the canvas element's size to its parent element's size.
+    ///
+    /// **Warning**: this will not behave as expected for parents that set their size according to the size of their
+    /// children. This creates a "feedback loop" that will result in the canvas growing on each resize. When using this
+    /// feature, ensure the parent's size is not affected by its children.
+    ///
+    /// This value has no effect on non-web platforms.
+    pub fit_canvas_to_parent: bool,
     /// Whether or not to stop events from propagating out of the canvas element
     ///
     ///  When `true`, this will prevent common browser hotkeys like F5, F12, Ctrl+R, tab, etc.
@@ -274,6 +282,7 @@ impl Default for Window {
             transparent: false,
             focused: true,
             window_level: Default::default(),
+            fit_canvas_to_parent: false,
             prevent_default_event_handling: true,
             canvas: None,
             window_theme: None,
@@ -313,6 +322,14 @@ impl Window {
         self.resolution.height()
     }
 
+    /// The window's client size in logical pixels
+    ///
+    /// See [`WindowResolution`] for an explanation about logical/physical sizes.
+    #[inline]
+    pub fn size(&self) -> Vec2 {
+        self.resolution.size()
+    }
+
     /// The window's client area width in physical pixels.
     ///
     /// See [`WindowResolution`] for an explanation about logical/physical sizes.
@@ -329,6 +346,14 @@ impl Window {
         self.resolution.physical_height()
     }
 
+    /// The window's client size in physical pixels
+    ///
+    /// See [`WindowResolution`] for an explanation about logical/physical sizes.
+    #[inline]
+    pub fn physical_size(&self) -> bevy_math::UVec2 {
+        self.resolution.physical_size()
+    }
+
     /// The window's scale factor.
     ///
     /// Ratio of physical size to logical size, see [`WindowResolution`].
@@ -648,7 +673,7 @@ impl WindowResolution {
 
     /// Builder method for adding a scale factor override to the resolution.
     pub fn with_scale_factor_override(mut self, scale_factor_override: f32) -> Self {
-        self.scale_factor_override = Some(scale_factor_override);
+        self.set_scale_factor_override(Some(scale_factor_override));
         self
     }
 
@@ -664,6 +689,12 @@ impl WindowResolution {
         self.physical_height() as f32 / self.scale_factor()
     }
 
+    /// The window's client size in logical pixels
+    #[inline]
+    pub fn size(&self) -> Vec2 {
+        Vec2::new(self.width(), self.height())
+    }
+
     /// The window's client area width in physical pixels.
     #[inline]
     pub fn physical_width(&self) -> u32 {
@@ -676,6 +707,12 @@ impl WindowResolution {
         self.physical_height
     }
 
+    /// The window's client size in physical pixels
+    #[inline]
+    pub fn physical_size(&self) -> UVec2 {
+        UVec2::new(self.physical_width, self.physical_height)
+    }
+
     /// The ratio of physical pixels to logical pixels.
     ///
     /// `physical_pixels = logical_pixels * scale_factor`
diff --git a/crates/bevy_winit/Cargo.toml b/crates/bevy_winit/Cargo.toml
index 6477c90db6dd5..652ccaf3e919f 100644
--- a/crates/bevy_winit/Cargo.toml
+++ b/crates/bevy_winit/Cargo.toml
@@ -13,6 +13,7 @@ trace = []
 wayland = ["winit/wayland", "winit/wayland-csd-adwaita"]
 x11 = ["winit/x11"]
 accesskit_unix = ["accesskit_winit/accesskit_unix", "accesskit_winit/async-io"]
+serialize = ["serde"]
 
 [dependencies]
 # bevy
@@ -23,6 +24,7 @@ bevy_ecs = { path = "../bevy_ecs", version = "0.14.0-dev" }
 bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.14.0-dev" }
 bevy_input = { path = "../bevy_input", version = "0.14.0-dev" }
 bevy_math = { path = "../bevy_math", version = "0.14.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.14.0-dev" }
 bevy_window = { path = "../bevy_window", version = "0.14.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.14.0-dev" }
 bevy_tasks = { path = "../bevy_tasks", version = "0.14.0-dev" }
@@ -35,6 +37,7 @@ accesskit_winit = { version = "0.17", default-features = false, features = [
 ] }
 approx = { version = "0.5", default-features = false }
 raw-window-handle = "0.6"
+serde = { version = "1.0", features = ["derive"], optional = true }
 
 [target.'cfg(target_os = "android")'.dependencies]
 winit = { version = "0.29", default-features = false, features = [
@@ -45,7 +48,6 @@ winit = { version = "0.29", default-features = false, features = [
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 wasm-bindgen = { version = "0.2" }
 web-sys = "0.3"
-
 crossbeam-channel = "0.5"
 
 [package.metadata.docs.rs]
diff --git a/crates/bevy_winit/src/lib.rs b/crates/bevy_winit/src/lib.rs
index c485f50954afa..b0ea7533fba15 100644
--- a/crates/bevy_winit/src/lib.rs
+++ b/crates/bevy_winit/src/lib.rs
@@ -9,14 +9,16 @@ pub mod accessibility;
 mod converters;
 mod system;
 mod winit_config;
+pub mod winit_event;
 mod winit_windows;
 
 use approx::relative_eq;
 use bevy_a11y::AccessibilityRequested;
-use bevy_utils::{Duration, Instant};
+use bevy_utils::Instant;
 use system::{changed_windows, create_windows, despawn_windows, CachedWindow};
 use winit::dpi::{LogicalSize, PhysicalSize};
 pub use winit_config::*;
+pub use winit_event::*;
 pub use winit_windows::*;
 
 use bevy_app::{App, AppExit, Last, Plugin, PluginsState};
@@ -44,6 +46,7 @@ use bevy_window::{PrimaryWindow, RawHandleWrapper};
 #[cfg(target_os = "android")]
 pub use winit::platform::android::activity as android_activity;
 
+use winit::event::StartCause;
 use winit::{
     event::{self, DeviceEvent, Event, WindowEvent},
     event_loop::{ControlFlow, EventLoop, EventLoopBuilder, EventLoopWindowTarget},
@@ -81,7 +84,7 @@ pub struct WinitPlugin {
 
 impl Plugin for WinitPlugin {
     fn build(&self, app: &mut App) {
-        let mut event_loop_builder = EventLoopBuilder::<()>::with_user_event();
+        let mut event_loop_builder = EventLoopBuilder::<UserEvent>::with_user_event();
 
         // linux check is needed because x11 might be enabled on other platforms.
         #[cfg(all(target_os = "linux", feature = "x11"))]
@@ -117,6 +120,7 @@ impl Plugin for WinitPlugin {
 
         app.init_non_send_resource::<WinitWindows>()
             .init_resource::<WinitSettings>()
+            .add_event::<WinitEvent>()
             .set_runner(winit_runner)
             .add_systems(
                 Last,
@@ -158,11 +162,11 @@ impl Plugin for WinitPlugin {
 }
 
 trait AppSendEvent {
-    fn send_event<E: bevy_ecs::event::Event>(&mut self, event: E);
+    fn send(&mut self, event: impl Into<WinitEvent>);
 }
-impl AppSendEvent for App {
-    fn send_event<E: bevy_ecs::event::Event>(&mut self, event: E) {
-        self.world.send_event(event);
+impl AppSendEvent for Vec<WinitEvent> {
+    fn send(&mut self, event: impl Into<WinitEvent>) {
+        self.push(Into::<WinitEvent>::into(event));
     }
 }
 
@@ -181,8 +185,6 @@ struct WinitAppRunnerState {
     wait_elapsed: bool,
     /// The time the last update started.
     last_update: Instant,
-    /// The time the next update is scheduled to start.
-    scheduled_update: Option<Instant>,
     /// Number of "forced" updates to trigger on application start
     startup_forced_updates: u32,
 }
@@ -223,7 +225,6 @@ impl Default for WinitAppRunnerState {
             redraw_requested: false,
             wait_elapsed: false,
             last_update: Instant::now(),
-            scheduled_update: None,
             // 3 seems to be enough, 5 is a safe margin
             startup_forced_updates: 5,
         }
@@ -240,6 +241,15 @@ type CreateWindowParams<'w, 's, F = ()> = (
     Res<'w, AccessibilityRequested>,
 );
 
+/// The [`winit::event_loop::EventLoopProxy`] with the specific [`winit::event::Event::UserEvent`] used in the [`winit_runner`].
+///
+/// The `EventLoopProxy` can be used to request a redraw from outside bevy.
+///
+/// Use `NonSend<EventLoopProxy>` to receive this resource.
+pub type EventLoopProxy = winit::event_loop::EventLoopProxy<UserEvent>;
+
+type UserEvent = RequestRedraw;
+
 /// The default [`App::runner`] for the [`WinitPlugin`] plugin.
 ///
 /// Overriding the app's [runner](bevy_app::App::runner) while using `WinitPlugin` will bypass the
@@ -252,7 +262,7 @@ pub fn winit_runner(mut app: App) {
 
     let event_loop = app
         .world
-        .remove_non_send_resource::<EventLoop<()>>()
+        .remove_non_send_resource::<EventLoop<UserEvent>>()
         .unwrap();
 
     app.world
@@ -276,8 +286,9 @@ pub fn winit_runner(mut app: App) {
 
     let mut create_window =
         SystemState::<CreateWindowParams<Added<Window>>>::from_world(&mut app.world);
+    let mut winit_events = Vec::default();
     // set up the event loop
-    let event_handler = move |event, event_loop: &EventLoopWindowTarget<()>| {
+    let event_handler = move |event, event_loop: &EventLoopWindowTarget<UserEvent>| {
         handle_winit_event(
             &mut app,
             &mut app_exit_event_reader,
@@ -286,6 +297,7 @@ pub fn winit_runner(mut app: App) {
             &mut event_writer_system_state,
             &mut focused_windows_state,
             &mut redraw_event_reader,
+            &mut winit_events,
             event,
             event_loop,
         );
@@ -312,8 +324,9 @@ fn handle_winit_event(
     )>,
     focused_windows_state: &mut SystemState<(Res<WinitSettings>, Query<&Window>)>,
     redraw_event_reader: &mut ManualEventReader<RequestRedraw>,
-    event: Event<()>,
-    event_loop: &EventLoopWindowTarget<()>,
+    winit_events: &mut Vec<WinitEvent>,
+    event: Event<UserEvent>,
+    event_loop: &EventLoopWindowTarget<UserEvent>,
 ) {
     #[cfg(feature = "trace")]
     let _span = bevy_utils::tracing::info_span!("winit event_handler").entered();
@@ -388,6 +401,7 @@ fn handle_winit_event(
                         create_window,
                         app_exit_event_reader,
                         redraw_event_reader,
+                        winit_events,
                     );
                     if runner_state.active != ActiveState::Suspended {
                         event_loop.set_control_flow(ControlFlow::Poll);
@@ -395,12 +409,14 @@ fn handle_winit_event(
                 }
             }
         }
-        Event::NewEvents(_) => {
-            if let Some(t) = runner_state.scheduled_update {
-                let now = Instant::now();
-                let remaining = t.checked_duration_since(now).unwrap_or(Duration::ZERO);
-                runner_state.wait_elapsed = remaining.is_zero();
-            }
+        Event::NewEvents(cause) => {
+            runner_state.wait_elapsed = match cause {
+                StartCause::WaitCancelled {
+                    requested_resume: Some(resume),
+                    ..
+                } => resume >= Instant::now(),
+                _ => true,
+            };
         }
         Event::WindowEvent {
             event, window_id, ..
@@ -432,15 +448,15 @@ fn handle_winit_event(
                 WindowEvent::Resized(size) => {
                     react_to_resize(&mut win, size, &mut window_resized, window);
                 }
-                WindowEvent::CloseRequested => app.send_event(WindowCloseRequested { window }),
+                WindowEvent::CloseRequested => winit_events.send(WindowCloseRequested { window }),
                 WindowEvent::KeyboardInput { ref event, .. } => {
                     if event.state.is_pressed() {
                         if let Some(char) = &event.text {
                             let char = char.clone();
-                            app.send_event(ReceivedCharacter { window, char });
+                            winit_events.send(ReceivedCharacter { window, char });
                         }
                     }
-                    app.send_event(converters::convert_keyboard_input(event, window));
+                    winit_events.send(converters::convert_keyboard_input(event, window));
                 }
                 WindowEvent::CursorMoved { position, .. } => {
                     let physical_position = DVec2::new(position.x, position.y);
@@ -453,35 +469,35 @@ fn handle_winit_event(
                     win.set_physical_cursor_position(Some(physical_position));
                     let position =
                         (physical_position / win.resolution.scale_factor() as f64).as_vec2();
-                    app.send_event(CursorMoved {
+                    winit_events.send(CursorMoved {
                         window,
                         position,
                         delta,
                     });
                 }
                 WindowEvent::CursorEntered { .. } => {
-                    app.send_event(CursorEntered { window });
+                    winit_events.send(CursorEntered { window });
                 }
                 WindowEvent::CursorLeft { .. } => {
                     win.set_physical_cursor_position(None);
-                    app.send_event(CursorLeft { window });
+                    winit_events.send(CursorLeft { window });
                 }
                 WindowEvent::MouseInput { state, button, .. } => {
-                    app.send_event(MouseButtonInput {
+                    winit_events.send(MouseButtonInput {
                         button: converters::convert_mouse_button(button),
                         state: converters::convert_element_state(state),
                         window,
                     });
                 }
                 WindowEvent::TouchpadMagnify { delta, .. } => {
-                    app.send_event(TouchpadMagnify(delta as f32));
+                    winit_events.send(TouchpadMagnify(delta as f32));
                 }
                 WindowEvent::TouchpadRotate { delta, .. } => {
-                    app.send_event(TouchpadRotate(delta));
+                    winit_events.send(TouchpadRotate(delta));
                 }
                 WindowEvent::MouseWheel { delta, .. } => match delta {
                     event::MouseScrollDelta::LineDelta(x, y) => {
-                        app.send_event(MouseWheel {
+                        winit_events.send(MouseWheel {
                             unit: MouseScrollUnit::Line,
                             x,
                             y,
@@ -489,7 +505,7 @@ fn handle_winit_event(
                         });
                     }
                     event::MouseScrollDelta::PixelDelta(p) => {
-                        app.send_event(MouseWheel {
+                        winit_events.send(MouseWheel {
                             unit: MouseScrollUnit::Pixel,
                             x: p.x as f32,
                             y: p.y as f32,
@@ -501,7 +517,7 @@ fn handle_winit_event(
                     let location = touch
                         .location
                         .to_logical(win.resolution.scale_factor() as f64);
-                    app.send_event(converters::convert_touch_input(touch, location, window));
+                    winit_events.send(converters::convert_touch_input(touch, location, window));
                 }
                 WindowEvent::ScaleFactorChanged {
                     scale_factor,
@@ -536,19 +552,19 @@ fn handle_winit_event(
                     win.resolution
                         .set_physical_resolution(new_inner_size.width, new_inner_size.height);
 
-                    app.send_event(WindowBackendScaleFactorChanged {
+                    winit_events.send(WindowBackendScaleFactorChanged {
                         window,
                         scale_factor,
                     });
                     if scale_factor_override.is_none() && !relative_eq!(new_factor, prior_factor) {
-                        app.send_event(WindowScaleFactorChanged {
+                        winit_events.send(WindowScaleFactorChanged {
                             window,
                             scale_factor,
                         });
                     }
 
                     if !width_equal || !height_equal {
-                        app.send_event(WindowResized {
+                        winit_events.send(WindowResized {
                             window,
                             width: new_logical_width,
                             height: new_logical_height,
@@ -557,51 +573,51 @@ fn handle_winit_event(
                 }
                 WindowEvent::Focused(focused) => {
                     win.focused = focused;
-                    app.send_event(WindowFocused { window, focused });
+                    winit_events.send(WindowFocused { window, focused });
                 }
                 WindowEvent::Occluded(occluded) => {
-                    app.send_event(WindowOccluded { window, occluded });
+                    winit_events.send(WindowOccluded { window, occluded });
                 }
                 WindowEvent::DroppedFile(path_buf) => {
-                    app.send_event(FileDragAndDrop::DroppedFile { window, path_buf });
+                    winit_events.send(FileDragAndDrop::DroppedFile { window, path_buf });
                 }
                 WindowEvent::HoveredFile(path_buf) => {
-                    app.send_event(FileDragAndDrop::HoveredFile { window, path_buf });
+                    winit_events.send(FileDragAndDrop::HoveredFile { window, path_buf });
                 }
                 WindowEvent::HoveredFileCancelled => {
-                    app.send_event(FileDragAndDrop::HoveredFileCanceled { window });
+                    winit_events.send(FileDragAndDrop::HoveredFileCanceled { window });
                 }
                 WindowEvent::Moved(position) => {
                     let position = ivec2(position.x, position.y);
                     win.position.set(position);
-                    app.send_event(WindowMoved { window, position });
+                    winit_events.send(WindowMoved { window, position });
                 }
                 WindowEvent::Ime(event) => match event {
                     event::Ime::Preedit(value, cursor) => {
-                        app.send_event(Ime::Preedit {
+                        winit_events.send(Ime::Preedit {
                             window,
                             value,
                             cursor,
                         });
                     }
                     event::Ime::Commit(value) => {
-                        app.send_event(Ime::Commit { window, value });
+                        winit_events.send(Ime::Commit { window, value });
                     }
                     event::Ime::Enabled => {
-                        app.send_event(Ime::Enabled { window });
+                        winit_events.send(Ime::Enabled { window });
                     }
                     event::Ime::Disabled => {
-                        app.send_event(Ime::Disabled { window });
+                        winit_events.send(Ime::Disabled { window });
                     }
                 },
                 WindowEvent::ThemeChanged(theme) => {
-                    app.send_event(WindowThemeChanged {
+                    winit_events.send(WindowThemeChanged {
                         window,
                         theme: convert_winit_theme(theme),
                     });
                 }
                 WindowEvent::Destroyed => {
-                    app.send_event(WindowDestroyed { window });
+                    winit_events.send(WindowDestroyed { window });
                 }
                 WindowEvent::RedrawRequested => {
                     run_app_update_if_should(
@@ -612,6 +628,7 @@ fn handle_winit_event(
                         create_window,
                         app_exit_event_reader,
                         redraw_event_reader,
+                        winit_events,
                     );
                 }
                 _ => {}
@@ -628,11 +645,11 @@ fn handle_winit_event(
             runner_state.device_event_received = true;
             if let DeviceEvent::MouseMotion { delta: (x, y) } = event {
                 let delta = Vec2::new(x as f32, y as f32);
-                app.send_event(MouseMotion { delta });
+                winit_events.send(MouseMotion { delta });
             }
         }
         Event::Suspended => {
-            app.send_event(ApplicationLifetime::Suspended);
+            winit_events.send(ApplicationLifetime::Suspended);
             // Mark the state as `WillSuspend`. This will let the schedule run one last time
             // before actually suspending to let the application react
             runner_state.active = ActiveState::WillSuspend;
@@ -647,8 +664,8 @@ fn handle_winit_event(
             }
 
             match runner_state.active {
-                ActiveState::NotYetStarted => app.send_event(ApplicationLifetime::Started),
-                _ => app.send_event(ApplicationLifetime::Resumed),
+                ActiveState::NotYetStarted => winit_events.send(ApplicationLifetime::Started),
+                _ => winit_events.send(ApplicationLifetime::Resumed),
             }
             runner_state.active = ActiveState::Active;
             runner_state.redraw_requested = true;
@@ -690,24 +707,37 @@ fn handle_winit_event(
                 event_loop.set_control_flow(ControlFlow::Wait);
             }
         }
+        Event::UserEvent(RequestRedraw) => {
+            runner_state.redraw_requested = true;
+        }
         _ => (),
     }
+
+    // We drain events after every received winit event in addition to on app update to ensure
+    // the work of pushing events into event queues is spread out over time in case the app becomes
+    // dormant for a long stretch.
+    forward_winit_events(winit_events, app);
 }
 
+#[allow(clippy::too_many_arguments)]
 fn run_app_update_if_should(
     runner_state: &mut WinitAppRunnerState,
     app: &mut App,
     focused_windows_state: &mut SystemState<(Res<WinitSettings>, Query<&Window>)>,
-    event_loop: &EventLoopWindowTarget<()>,
+    event_loop: &EventLoopWindowTarget<UserEvent>,
     create_window: &mut SystemState<CreateWindowParams<Added<Window>>>,
     app_exit_event_reader: &mut ManualEventReader<AppExit>,
     redraw_event_reader: &mut ManualEventReader<RequestRedraw>,
+    winit_events: &mut Vec<WinitEvent>,
 ) {
     runner_state.reset_on_update();
 
     if !runner_state.active.should_run() {
         return;
     }
+
+    forward_winit_events(winit_events, app);
+
     if runner_state.active == ActiveState::WillSuspend {
         runner_state.active = ActiveState::Suspended;
         #[cfg(target_os = "android")]
@@ -732,6 +762,7 @@ fn run_app_update_if_should(
         match config.update_mode(focused) {
             UpdateMode::Continuous => {
                 runner_state.redraw_requested = true;
+                event_loop.set_control_flow(ControlFlow::Wait);
             }
             UpdateMode::Reactive { wait } | UpdateMode::ReactiveLowPower { wait } => {
                 // TODO(bug): this is unexpected behavior.
@@ -740,10 +771,8 @@ fn run_app_update_if_should(
                 // Need to verify the plateform specifics (whether this can occur in
                 // rare-but-possible cases) and replace this with a panic or a log warn!
                 if let Some(next) = runner_state.last_update.checked_add(*wait) {
-                    runner_state.scheduled_update = Some(next);
                     event_loop.set_control_flow(ControlFlow::WaitUntil(next));
                 } else {
-                    runner_state.scheduled_update = None;
                     event_loop.set_control_flow(ControlFlow::Wait);
                 }
             }
diff --git a/crates/bevy_winit/src/system.rs b/crates/bevy_winit/src/system.rs
index b027461075970..0000c45369d44 100644
--- a/crates/bevy_winit/src/system.rs
+++ b/crates/bevy_winit/src/system.rs
@@ -17,6 +17,9 @@ use winit::{
     event_loop::EventLoopWindowTarget,
 };
 
+#[cfg(target_arch = "wasm32")]
+use winit::platform::web::WindowExtWebSys;
+
 use crate::{
     converters::{
         self, convert_enabled_buttons, convert_window_level, convert_window_theme,
@@ -32,7 +35,7 @@ use crate::{
 /// default values.
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn create_windows<F: QueryFilter + 'static>(
-    event_loop: &EventLoopWindowTarget<()>,
+    event_loop: &EventLoopWindowTarget<crate::UserEvent>,
     (
         mut commands,
         mut created_windows,
@@ -80,6 +83,17 @@ pub(crate) fn create_windows<F: QueryFilter + 'static>(
                 window: window.clone(),
             });
 
+        #[cfg(target_arch = "wasm32")]
+        {
+            if window.fit_canvas_to_parent {
+                let canvas = winit_window
+                    .canvas()
+                    .expect("window.canvas() can only be called in main thread.");
+                let style = canvas.style();
+                style.set_property("width", "100%").unwrap();
+                style.set_property("height", "100%").unwrap();
+            }
+        }
         window_created_events.send(WindowCreated { window: entity });
     }
 }
diff --git a/crates/bevy_winit/src/winit_config.rs b/crates/bevy_winit/src/winit_config.rs
index 78168309093fb..f2cb424ec5f44 100644
--- a/crates/bevy_winit/src/winit_config.rs
+++ b/crates/bevy_winit/src/winit_config.rs
@@ -28,6 +28,8 @@ impl WinitSettings {
     ///
     /// [`Reactive`](UpdateMode::Reactive) if windows have focus,
     /// [`ReactiveLowPower`](UpdateMode::ReactiveLowPower) otherwise.
+    ///
+    /// Use the [`EventLoopProxy`](crate::EventLoopProxy) to request a redraw from outside bevy.
     pub fn desktop_app() -> Self {
         WinitSettings {
             focused_mode: UpdateMode::Reactive {
@@ -72,6 +74,7 @@ pub enum UpdateMode {
     /// - a redraw has been requested by [`RequestRedraw`](bevy_window::RequestRedraw)
     /// - new [window](`winit::event::WindowEvent`) or [raw input](`winit::event::DeviceEvent`)
     /// events have appeared
+    /// - a redraw has been requested with the [`EventLoopProxy`](crate::EventLoopProxy)
     Reactive {
         /// The approximate time from the start of one update to the next.
         ///
@@ -84,6 +87,7 @@ pub enum UpdateMode {
     /// - `wait` time has elapsed since the previous update
     /// - a redraw has been requested by [`RequestRedraw`](bevy_window::RequestRedraw)
     /// - new [window events](`winit::event::WindowEvent`) have appeared
+    /// - a redraw has been requested with the [`EventLoopProxy`](crate::EventLoopProxy)
     ///
     /// **Note:** Unlike [`Reactive`](`UpdateMode::Reactive`), this mode will ignore events that
     /// don't come from interacting with a window, like [`MouseMotion`](winit::event::DeviceEvent::MouseMotion).
diff --git a/crates/bevy_winit/src/winit_event.rs b/crates/bevy_winit/src/winit_event.rs
new file mode 100644
index 0000000000000..9592a5e12b7f0
--- /dev/null
+++ b/crates/bevy_winit/src/winit_event.rs
@@ -0,0 +1,279 @@
+#![allow(missing_docs)]
+
+use bevy_app::App;
+use bevy_ecs::prelude::*;
+use bevy_input::keyboard::KeyboardInput;
+use bevy_input::touch::TouchInput;
+use bevy_input::{
+    mouse::{MouseButtonInput, MouseMotion, MouseWheel},
+    touchpad::{TouchpadMagnify, TouchpadRotate},
+};
+use bevy_reflect::Reflect;
+#[cfg(feature = "serialize")]
+use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
+use bevy_window::{
+    ApplicationLifetime, CursorEntered, CursorLeft, CursorMoved, FileDragAndDrop, Ime,
+    ReceivedCharacter, RequestRedraw, WindowBackendScaleFactorChanged, WindowCloseRequested,
+    WindowCreated, WindowDestroyed, WindowFocused, WindowMoved, WindowOccluded, WindowResized,
+    WindowScaleFactorChanged, WindowThemeChanged,
+};
+
+/// Wraps all `bevy_window` events in a common enum.
+///
+/// Read these events with `EventReader<WinitEvent>` if you need to
+/// access window events in the order they were received from `winit`.
+/// Otherwise, the event types are individually readable with
+/// `EventReader<E>` (e.g. `EventReader<KeyboardInput>`).
+#[derive(Event, Debug, Clone, PartialEq, Reflect)]
+#[reflect(Debug, PartialEq)]
+#[cfg_attr(
+    feature = "serialize",
+    derive(serde::Serialize, serde::Deserialize),
+    reflect(Serialize, Deserialize)
+)]
+pub enum WinitEvent {
+    ApplicationLifetime(ApplicationLifetime),
+    CursorEntered(CursorEntered),
+    CursorLeft(CursorLeft),
+    CursorMoved(CursorMoved),
+    FileDragAndDrop(FileDragAndDrop),
+    Ime(Ime),
+    ReceivedCharacter(ReceivedCharacter),
+    RequestRedraw(RequestRedraw),
+    WindowBackendScaleFactorChanged(WindowBackendScaleFactorChanged),
+    WindowCloseRequested(WindowCloseRequested),
+    WindowCreated(WindowCreated),
+    WindowDestroyed(WindowDestroyed),
+    WindowFocused(WindowFocused),
+    WindowMoved(WindowMoved),
+    WindowOccluded(WindowOccluded),
+    WindowResized(WindowResized),
+    WindowScaleFactorChanged(WindowScaleFactorChanged),
+    WindowThemeChanged(WindowThemeChanged),
+
+    MouseButtonInput(MouseButtonInput),
+    MouseMotion(MouseMotion),
+    MouseWheel(MouseWheel),
+
+    TouchpadMagnify(TouchpadMagnify),
+    TouchpadRotate(TouchpadRotate),
+
+    TouchInput(TouchInput),
+
+    KeyboardInput(KeyboardInput),
+}
+
+impl From<ApplicationLifetime> for WinitEvent {
+    fn from(e: ApplicationLifetime) -> Self {
+        Self::ApplicationLifetime(e)
+    }
+}
+impl From<CursorEntered> for WinitEvent {
+    fn from(e: CursorEntered) -> Self {
+        Self::CursorEntered(e)
+    }
+}
+impl From<CursorLeft> for WinitEvent {
+    fn from(e: CursorLeft) -> Self {
+        Self::CursorLeft(e)
+    }
+}
+impl From<CursorMoved> for WinitEvent {
+    fn from(e: CursorMoved) -> Self {
+        Self::CursorMoved(e)
+    }
+}
+impl From<FileDragAndDrop> for WinitEvent {
+    fn from(e: FileDragAndDrop) -> Self {
+        Self::FileDragAndDrop(e)
+    }
+}
+impl From<Ime> for WinitEvent {
+    fn from(e: Ime) -> Self {
+        Self::Ime(e)
+    }
+}
+impl From<ReceivedCharacter> for WinitEvent {
+    fn from(e: ReceivedCharacter) -> Self {
+        Self::ReceivedCharacter(e)
+    }
+}
+impl From<RequestRedraw> for WinitEvent {
+    fn from(e: RequestRedraw) -> Self {
+        Self::RequestRedraw(e)
+    }
+}
+impl From<WindowBackendScaleFactorChanged> for WinitEvent {
+    fn from(e: WindowBackendScaleFactorChanged) -> Self {
+        Self::WindowBackendScaleFactorChanged(e)
+    }
+}
+impl From<WindowCloseRequested> for WinitEvent {
+    fn from(e: WindowCloseRequested) -> Self {
+        Self::WindowCloseRequested(e)
+    }
+}
+impl From<WindowCreated> for WinitEvent {
+    fn from(e: WindowCreated) -> Self {
+        Self::WindowCreated(e)
+    }
+}
+impl From<WindowDestroyed> for WinitEvent {
+    fn from(e: WindowDestroyed) -> Self {
+        Self::WindowDestroyed(e)
+    }
+}
+impl From<WindowFocused> for WinitEvent {
+    fn from(e: WindowFocused) -> Self {
+        Self::WindowFocused(e)
+    }
+}
+impl From<WindowMoved> for WinitEvent {
+    fn from(e: WindowMoved) -> Self {
+        Self::WindowMoved(e)
+    }
+}
+impl From<WindowOccluded> for WinitEvent {
+    fn from(e: WindowOccluded) -> Self {
+        Self::WindowOccluded(e)
+    }
+}
+impl From<WindowResized> for WinitEvent {
+    fn from(e: WindowResized) -> Self {
+        Self::WindowResized(e)
+    }
+}
+impl From<WindowScaleFactorChanged> for WinitEvent {
+    fn from(e: WindowScaleFactorChanged) -> Self {
+        Self::WindowScaleFactorChanged(e)
+    }
+}
+impl From<WindowThemeChanged> for WinitEvent {
+    fn from(e: WindowThemeChanged) -> Self {
+        Self::WindowThemeChanged(e)
+    }
+}
+impl From<MouseButtonInput> for WinitEvent {
+    fn from(e: MouseButtonInput) -> Self {
+        Self::MouseButtonInput(e)
+    }
+}
+impl From<MouseMotion> for WinitEvent {
+    fn from(e: MouseMotion) -> Self {
+        Self::MouseMotion(e)
+    }
+}
+impl From<MouseWheel> for WinitEvent {
+    fn from(e: MouseWheel) -> Self {
+        Self::MouseWheel(e)
+    }
+}
+impl From<TouchpadMagnify> for WinitEvent {
+    fn from(e: TouchpadMagnify) -> Self {
+        Self::TouchpadMagnify(e)
+    }
+}
+impl From<TouchpadRotate> for WinitEvent {
+    fn from(e: TouchpadRotate) -> Self {
+        Self::TouchpadRotate(e)
+    }
+}
+impl From<TouchInput> for WinitEvent {
+    fn from(e: TouchInput) -> Self {
+        Self::TouchInput(e)
+    }
+}
+impl From<KeyboardInput> for WinitEvent {
+    fn from(e: KeyboardInput) -> Self {
+        Self::KeyboardInput(e)
+    }
+}
+
+/// Forwards buffered [`WinitEvent`] events to the app.
+pub(crate) fn forward_winit_events(buffered_events: &mut Vec<WinitEvent>, app: &mut App) {
+    if buffered_events.is_empty() {
+        return;
+    }
+    for winit_event in buffered_events.iter() {
+        match winit_event.clone() {
+            WinitEvent::ApplicationLifetime(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::CursorEntered(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::CursorLeft(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::CursorMoved(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::FileDragAndDrop(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::Ime(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::ReceivedCharacter(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::RequestRedraw(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::WindowBackendScaleFactorChanged(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::WindowCloseRequested(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::WindowCreated(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::WindowDestroyed(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::WindowFocused(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::WindowMoved(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::WindowOccluded(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::WindowResized(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::WindowScaleFactorChanged(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::WindowThemeChanged(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::MouseButtonInput(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::MouseMotion(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::MouseWheel(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::TouchpadMagnify(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::TouchpadRotate(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::TouchInput(e) => {
+                app.world.send_event(e);
+            }
+            WinitEvent::KeyboardInput(e) => {
+                app.world.send_event(e);
+            }
+        }
+    }
+    app.world
+        .resource_mut::<Events<WinitEvent>>()
+        .send_batch(buffered_events.drain(..));
+}
diff --git a/crates/bevy_winit/src/winit_windows.rs b/crates/bevy_winit/src/winit_windows.rs
index 3188ac2714fdf..4375e7c277744 100644
--- a/crates/bevy_winit/src/winit_windows.rs
+++ b/crates/bevy_winit/src/winit_windows.rs
@@ -39,7 +39,7 @@ impl WinitWindows {
     /// Creates a `winit` window and associates it with our entity.
     pub fn create_window(
         &mut self,
-        event_loop: &winit::event_loop::EventLoopWindowTarget<()>,
+        event_loop: &winit::event_loop::EventLoopWindowTarget<crate::UserEvent>,
         entity: Entity,
         window: &Window,
         adapters: &mut AccessKitAdapters,
diff --git a/deny.toml b/deny.toml
index 261c37590d688..1d72763947337 100644
--- a/deny.toml
+++ b/deny.toml
@@ -74,15 +74,6 @@ deny = [
   { name = "glam", deny-multiple-versions = true },
   { name = "raw-window-handle", deny-multiple-versions = true },
 ]
-# To avoid https://github.com/bevyengine/bevy/issues/11917
-# = raw-window-handle v0.5.2
-#       └── ndk v0.7.0
-#           ├── cpal v0.15.2`
-#           │   └── rodio v0.17.3
-#           │       └── bevy_audio v0.14.0-dev
-skip-tree = [
-  { crate = "cpal@0.15.2", reason = "Waiting for new releases: https://github.com/bevyengine/bevy/issues/11917#issuecomment-1953629729" },
-]
 
 [sources]
 unknown-registry = "deny"
diff --git a/docs-template/EXAMPLE_README.md.tpl b/docs-template/EXAMPLE_README.md.tpl
index 56a300b66ce52..9d4a009d0e4d0 100644
--- a/docs-template/EXAMPLE_README.md.tpl
+++ b/docs-template/EXAMPLE_README.md.tpl
@@ -239,13 +239,6 @@ ruby -run -ehttpd examples/wasm
 Bevy support for WebGPU is being worked on, but is currently experimental.
 
 To build for WebGPU, you'll need to enable the `webgpu` feature. This will override the `webgl2` feature, and builds with the `webgpu` feature enabled won't be able to run on browsers that don't support WebGPU.
-WebGPU depends on unstable APIs so you will also need to pass the `web_sys_unstable_apis` flag to your builds. For example:
-
-```sh
-RUSTFLAGS=--cfg=web_sys_unstable_apis cargo build ...
-```
-
-Check `wasm-bindgen` [docs on Unstable APIs](https://rustwasm.github.io/wasm-bindgen/web-sys/unstable-apis.html) for more details.
 
 Bevy has an helper to build its examples:
 
diff --git a/docs/cargo_features.md b/docs/cargo_features.md
index 051c1fc3638d2..c5bf29bd20c84 100644
--- a/docs/cargo_features.md
+++ b/docs/cargo_features.md
@@ -50,6 +50,7 @@ The default feature set enables most of the expected features of a game engine,
 |async-io|Use async-io's implementation of block_on instead of futures-lite's implementation. This is preferred if your application uses async-io.|
 |basis-universal|Basis Universal compressed texture support|
 |bevy_ci_testing|Enable systems that allow for automated testing on CI|
+|bevy_dev_tools|Provides a collection of developer tools|
 |bevy_dynamic_plugin|Plugin for dynamic loading (using [libloading](https://crates.io/crates/libloading))|
 |bmp|BMP image format support|
 |dds|DDS compressed texture support|
@@ -61,6 +62,7 @@ The default feature set enables most of the expected features of a game engine,
 |file_watcher|Enables watching the filesystem for Bevy Asset hot-reloading|
 |flac|FLAC audio format support|
 |glam_assert|Enable assertions to check the validity of parameters passed to glam|
+|ios_simulator|Enable support for the ios_simulator by downgrading some rendering capabilities|
 |jpeg|JPEG image format support|
 |minimp3|MP3 audio format support (through minimp3)|
 |mp3|MP3 audio format support|
@@ -83,7 +85,7 @@ The default feature set enables most of the expected features of a game engine,
 |trace_tracy_memory|Tracing support, with memory profiling, exposing a port for Tracy|
 |wav|WAV audio format support|
 |wayland|Wayland display server support|
-|webgpu|Enable support for WebGPU in Wasm. When enabled, this feature will override the `webgl2` feature and you won't be able to run Wasm builds with WebGL2, only with WebGPU. Requires the `RUSTFLAGS` environment variable to be set to `--cfg=web_sys_unstable_apis` when building.|
+|webgpu|Enable support for WebGPU in Wasm. When enabled, this feature will override the `webgl2` feature and you won't be able to run Wasm builds with WebGL2, only with WebGPU.|
 |webp|WebP image format support|
 |wgpu_trace|Save a trace of all wgpu calls|
 |zlib|For KTX2 supercompression|
diff --git a/examples/2d/bounding_2d.rs b/examples/2d/bounding_2d.rs
index acac69bac6a94..a360dfb6c0bf4 100644
--- a/examples/2d/bounding_2d.rs
+++ b/examples/2d/bounding_2d.rs
@@ -177,7 +177,7 @@ fn update_volumes(
 
 fn render_volumes(mut gizmos: Gizmos, query: Query<(&CurrentVolume, &Intersects)>) {
     for (volume, intersects) in query.iter() {
-        let color = if **intersects { CYAN } else { ORANGE_RED };
+        let color = if **intersects { AQUA } else { ORANGE_RED };
         match volume {
             CurrentVolume::Aabb(a) => {
                 gizmos.rect_2d(a.center(), 0., a.half_size() * 2., color);
@@ -324,11 +324,7 @@ fn ray_cast_system(
         **intersects = toi.is_some();
         if let Some(toi) = toi {
             for r in [1., 2., 3.] {
-                gizmos.circle_2d(
-                    ray_cast.ray.origin + *ray_cast.ray.direction * toi,
-                    r,
-                    GREEN,
-                );
+                gizmos.circle_2d(ray_cast.ray.origin + *ray_cast.ray.direction * toi, r, LIME);
             }
         }
     }
@@ -359,7 +355,7 @@ fn aabb_cast_system(
                     + aabb_cast.aabb.center(),
                 0.,
                 aabb_cast.aabb.half_size() * 2.,
-                GREEN,
+                LIME,
             );
         }
     }
@@ -389,7 +385,7 @@ fn bounding_circle_cast_system(
                     + *circle_cast.ray.ray.direction * toi
                     + circle_cast.circle.center(),
                 circle_cast.circle.radius(),
-                GREEN,
+                LIME,
             );
         }
     }
diff --git a/examples/2d/sprite_sheet.rs b/examples/2d/sprite_sheet.rs
index 5a39367d31cd8..c1c55914b78f3 100644
--- a/examples/2d/sprite_sheet.rs
+++ b/examples/2d/sprite_sheet.rs
@@ -48,15 +48,15 @@ fn setup(
     let animation_indices = AnimationIndices { first: 1, last: 6 };
     commands.spawn(Camera2dBundle::default());
     commands.spawn((
-        SpriteSheetBundle {
-            texture,
-            atlas: TextureAtlas {
-                layout: texture_atlas_layout,
-                index: animation_indices.first,
-            },
+        SpriteBundle {
             transform: Transform::from_scale(Vec3::splat(6.0)),
+            texture,
             ..default()
         },
+        TextureAtlas {
+            layout: texture_atlas_layout,
+            index: animation_indices.first,
+        },
         animation_indices,
         AnimationTimer(Timer::from_seconds(0.1, TimerMode::Repeating)),
     ));
diff --git a/examples/2d/text2d.rs b/examples/2d/text2d.rs
index a0229545bd691..bb7325ac1f895 100644
--- a/examples/2d/text2d.rs
+++ b/examples/2d/text2d.rs
@@ -141,7 +141,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
 
     for (text_anchor, color) in [
         (Anchor::TopLeft, Color::Srgba(RED)),
-        (Anchor::TopRight, Color::Srgba(GREEN)),
+        (Anchor::TopRight, Color::Srgba(LIME)),
         (Anchor::BottomRight, Color::Srgba(BLUE)),
         (Anchor::BottomLeft, Color::Srgba(YELLOW)),
     ] {
diff --git a/examples/2d/texture_atlas.rs b/examples/2d/texture_atlas.rs
index 6b5e4eab57529..b772583dcad1a 100644
--- a/examples/2d/texture_atlas.rs
+++ b/examples/2d/texture_atlas.rs
@@ -240,19 +240,21 @@ fn create_sprite_from_atlas(
     atlas_handle: Handle<TextureAtlasLayout>,
     texture: Handle<Image>,
 ) {
-    commands.spawn(SpriteSheetBundle {
-        transform: Transform {
-            translation: Vec3::new(translation.0, translation.1, translation.2),
-            scale: Vec3::splat(3.0),
+    commands.spawn((
+        SpriteBundle {
+            transform: Transform {
+                translation: Vec3::new(translation.0, translation.1, translation.2),
+                scale: Vec3::splat(3.0),
+                ..default()
+            },
+            texture,
             ..default()
         },
-        texture,
-        atlas: TextureAtlas {
-            index: sprite_index,
+        TextureAtlas {
             layout: atlas_handle,
+            index: sprite_index,
         },
-        ..default()
-    });
+    ));
 }
 
 /// Create and spawn a label (text)
diff --git a/examples/3d/bloom_3d.rs b/examples/3d/bloom_3d.rs
index 34101d35ffd55..b2fd467942997 100644
--- a/examples/3d/bloom_3d.rs
+++ b/examples/3d/bloom_3d.rs
@@ -36,19 +36,20 @@ fn setup_scene(
             transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
             ..default()
         },
-        BloomSettings::default(), // 3. Enable bloom for the camera
+        // 3. Enable bloom for the camera
+        BloomSettings::NATURAL,
     ));
 
     let material_emissive1 = materials.add(StandardMaterial {
-        emissive: Color::linear_rgb(2300.0, 900.0, 300.0), // 4. Put something bright in a dark environment to see the effect
+        emissive: Color::linear_rgb(23000.0, 9000.0, 3000.0), // 4. Put something bright in a dark environment to see the effect
         ..default()
     });
     let material_emissive2 = materials.add(StandardMaterial {
-        emissive: Color::linear_rgb(300.0, 2300.0, 900.0),
+        emissive: Color::linear_rgb(3000.0, 23000.0, 9000.0),
         ..default()
     });
     let material_emissive3 = materials.add(StandardMaterial {
-        emissive: Color::linear_rgb(900.0, 300.0, 2300.0),
+        emissive: Color::linear_rgb(9000.0, 3000.0, 23000.0),
         ..default()
     });
     let material_non_emissive = materials.add(StandardMaterial {
@@ -60,6 +61,8 @@ fn setup_scene(
 
     for x in -5..5 {
         for z in -5..5 {
+            // This generates a pseudo-random integer between `[0, 6)`, but deterministically so
+            // the same spheres are always the same colors.
             let mut hasher = DefaultHasher::new();
             (x, z).hash(&mut hasher);
             let rand = (hasher.finish() - 2) % 6;
@@ -90,7 +93,7 @@ fn setup_scene(
             "",
             TextStyle {
                 font_size: 20.0,
-                color: Color::BLACK,
+                color: Color::WHITE,
                 ..default()
             },
         )
@@ -219,7 +222,7 @@ fn update_bloom_settings(
             *text = "Bloom: Off (Toggle: Space)".to_string();
 
             if keycode.just_pressed(KeyCode::Space) {
-                commands.entity(entity).insert(BloomSettings::default());
+                commands.entity(entity).insert(BloomSettings::NATURAL);
             }
         }
     }
diff --git a/examples/3d/lighting.rs b/examples/3d/lighting.rs
index 31e736ca873cc..59aadd61dbfc8 100644
--- a/examples/3d/lighting.rs
+++ b/examples/3d/lighting.rs
@@ -159,7 +159,7 @@ fn setup(
                 .looking_at(Vec3::new(-1.0, 0.0, 0.0), Vec3::Z),
             spot_light: SpotLight {
                 intensity: 100_000.0,
-                color: GREEN.into(),
+                color: LIME.into(),
                 shadows_enabled: true,
                 inner_angle: 0.6,
                 outer_angle: 0.8,
@@ -172,7 +172,7 @@ fn setup(
                 transform: Transform::from_rotation(Quat::from_rotation_x(PI / 2.0)),
                 mesh: meshes.add(Capsule3d::new(0.1, 0.125)),
                 material: materials.add(StandardMaterial {
-                    base_color: GREEN.into(),
+                    base_color: LIME.into(),
                     emissive: Color::linear_rgba(0.0, 7.13, 0.0, 0.0),
                     ..default()
                 }),
diff --git a/examples/3d/lightmaps.rs b/examples/3d/lightmaps.rs
index cd08712436a5d..fe7f2a8c59f2a 100644
--- a/examples/3d/lightmaps.rs
+++ b/examples/3d/lightmaps.rs
@@ -36,8 +36,7 @@ fn add_lightmaps_to_meshes(
     let exposure = 250.0;
     for (entity, name, material) in meshes.iter() {
         if &**name == "Light" {
-            materials.get_mut(material).unwrap().emissive =
-                Color::LinearRgba(LinearRgba::WHITE * exposure);
+            materials.get_mut(material).unwrap().emissive = Color::Srgba(Srgba::WHITE * exposure);
             continue;
         }
 
diff --git a/examples/3d/shadow_caster_receiver.rs b/examples/3d/shadow_caster_receiver.rs
index 56296301b2eeb..97426737d925f 100644
--- a/examples/3d/shadow_caster_receiver.rs
+++ b/examples/3d/shadow_caster_receiver.rs
@@ -3,7 +3,7 @@
 use std::f32::consts::PI;
 
 use bevy::{
-    color::palettes::basic::{BLUE, GREEN, RED},
+    color::palettes::basic::{BLUE, LIME, RED},
     pbr::{light_consts, CascadeShadowConfigBuilder, NotShadowCaster, NotShadowReceiver},
     prelude::*,
 };
@@ -62,7 +62,7 @@ fn setup(
     commands.spawn((
         PbrBundle {
             mesh: meshes.add(Plane3d::default().mesh().size(20.0, 20.0)),
-            material: materials.add(Color::from(GREEN)),
+            material: materials.add(Color::from(LIME)),
             transform: Transform::from_xyz(0.0, 1.0, -10.0),
             ..default()
         },
diff --git a/examples/3d/split_screen.rs b/examples/3d/split_screen.rs
index 35b88ae424683..7d78b59ccbf99 100644
--- a/examples/3d/split_screen.rs
+++ b/examples/3d/split_screen.rs
@@ -3,8 +3,7 @@
 use std::f32::consts::PI;
 
 use bevy::{
-    color::palettes::css::DARK_GRAY, pbr::CascadeShadowConfigBuilder, prelude::*,
-    render::camera::Viewport, window::WindowResized,
+    pbr::CascadeShadowConfigBuilder, prelude::*, render::camera::Viewport, window::WindowResized,
 };
 
 fn main() {
@@ -147,7 +146,7 @@ fn setup(
                         ..default()
                     },
                     border_color: Color::WHITE.into(),
-                    background_color: DARK_GRAY.into(),
+                    image: UiImage::default().with_color(Color::srgb(0.25, 0.25, 0.25)),
                     ..default()
                 },
             ))
@@ -186,7 +185,7 @@ fn set_camera_viewports(
     // A resize_event is sent when the window is first created, allowing us to reuse this system for initial setup.
     for resize_event in resize_events.read() {
         let window = windows.get(resize_event.window).unwrap();
-        let size = UVec2::new(window.physical_width(), window.physical_height()) / 2;
+        let size = window.physical_size() / 2;
 
         for (camera_position, mut camera) in &mut query {
             camera.viewport = Some(Viewport {
diff --git a/examples/3d/transmission.rs b/examples/3d/transmission.rs
index 8aa1e766884e5..e2cf9481ecb9c 100644
--- a/examples/3d/transmission.rs
+++ b/examples/3d/transmission.rs
@@ -213,7 +213,7 @@ fn setup(
         PbrBundle {
             mesh: icosphere_mesh.clone(),
             material: materials.add(StandardMaterial {
-                base_color: GREEN.into(),
+                base_color: LIME.into(),
                 specular_transmission: 0.9,
                 diffuse_transmission: 1.0,
                 thickness: 1.8,
diff --git a/examples/3d/wireframe.rs b/examples/3d/wireframe.rs
index 3d22de808c289..aaeb42393b318 100644
--- a/examples/3d/wireframe.rs
+++ b/examples/3d/wireframe.rs
@@ -82,16 +82,14 @@ fn setup(
     commands.spawn((
         PbrBundle {
             mesh: meshes.add(Cuboid::default()),
-            material: materials.add(Color::from(GREEN)),
+            material: materials.add(Color::from(LIME)),
             transform: Transform::from_xyz(1.0, 0.5, 1.0),
             ..default()
         },
         Wireframe,
         // This lets you configure the wireframe color of this entity.
         // If not set, this will use the color in `WireframeConfig`
-        WireframeColor {
-            color: GREEN.into(),
-        },
+        WireframeColor { color: LIME.into() },
     ));
 
     // light
@@ -157,10 +155,10 @@ Color: {:?}
     // Toggle the color of a wireframe using WireframeColor and not the global color
     if keyboard_input.just_pressed(KeyCode::KeyC) {
         for mut color in &mut wireframe_colors {
-            color.color = if color.color == GREEN.into() {
+            color.color = if color.color == LIME.into() {
                 RED.into()
             } else {
-                GREEN.into()
+                LIME.into()
             };
         }
     }
diff --git a/examples/README.md b/examples/README.md
index b8f0b0f4ed6b8..fcad85d7cd8ff 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -172,6 +172,7 @@ Example | Description
 
 Example | Description
 --- | ---
+[Advanced log layers](../examples/app/log_layers_ecs.rs) | Illustrate how to transfer data between log layers and Bevy's ECS
 [Custom Loop](../examples/app/custom_loop.rs) | Demonstrates how to create a custom runner (to update an app manually)
 [Drag and Drop](../examples/app/drag_and_drop.rs) | An example that shows how to handle drag and drop in an app
 [Empty](../examples/app/empty.rs) | An empty application (does nothing)
@@ -196,6 +197,7 @@ Example | Description
 [Custom Asset](../examples/asset/custom_asset.rs) | Implements a custom asset loader
 [Custom Asset IO](../examples/asset/custom_asset_reader.rs) | Implements a custom AssetReader
 [Embedded Asset](../examples/asset/embedded_asset.rs) | Embed an asset in the application binary and load it
+[Extra asset source](../examples/asset/extra_source.rs) | Load an asset from a non-standard asset source
 [Hot Reloading of Assets](../examples/asset/hot_asset_reloading.rs) | Demonstrates automatic reloading of assets when modified on disk
 
 ## Async Tasks
@@ -258,6 +260,7 @@ Example | Description
 [Alien Cake Addict](../examples/games/alien_cake_addict.rs) | Eat the cakes. Eat them all. An example 3D game
 [Breakout](../examples/games/breakout.rs) | An implementation of the classic game "Breakout"
 [Contributors](../examples/games/contributors.rs) | Displays each contributor as a bouncy bevy-ball!
+[Desk Toy](../examples/games/desk_toy.rs) | Bevy logo as a desk toy using transparent windows! Now with Googly Eyes!
 [Game Menu](../examples/games/game_menu.rs) | A simple game menu
 
 ## Gizmos
@@ -266,6 +269,8 @@ Example | Description
 --- | ---
 [2D Gizmos](../examples/gizmos/2d_gizmos.rs) | A scene showcasing 2D gizmos
 [3D Gizmos](../examples/gizmos/3d_gizmos.rs) | A scene showcasing 3D gizmos
+[Axes](../examples/gizmos/axes.rs) | Demonstrates the function of axes gizmos
+[Light Gizmos](../examples/gizmos/light_gizmos.rs) | A scene showcasing light gizmos
 
 ## Input
 
@@ -402,6 +407,7 @@ Example | Description
 [UI Material](../examples/ui/ui_material.rs) | Demonstrates creating and using custom Ui materials
 [UI Scaling](../examples/ui/ui_scaling.rs) | Illustrates how to scale the UI
 [UI Texture Atlas](../examples/ui/ui_texture_atlas.rs) | Illustrates how to use TextureAtlases in UI
+[UI Texture Atlas Slice](../examples/ui/ui_texture_atlas_slice.rs) | Illustrates how to use 9 Slicing for TextureAtlases in UI
 [UI Texture Slice](../examples/ui/ui_texture_slice.rs) | Illustrates how to use 9 Slicing in UI
 [UI Z-Index](../examples/ui/z_index.rs) | Demonstrates how to control the relative depth (z-position) of UI elements
 [Viewport Debug](../examples/ui/viewport_debug.rs) | An example for debugging viewport coordinates
@@ -583,13 +589,6 @@ ruby -run -ehttpd examples/wasm
 Bevy support for WebGPU is being worked on, but is currently experimental.
 
 To build for WebGPU, you'll need to enable the `webgpu` feature. This will override the `webgl2` feature, and builds with the `webgpu` feature enabled won't be able to run on browsers that don't support WebGPU.
-WebGPU depends on unstable APIs so you will also need to pass the `web_sys_unstable_apis` flag to your builds. For example:
-
-```sh
-RUSTFLAGS=--cfg=web_sys_unstable_apis cargo build ...
-```
-
-Check `wasm-bindgen` [docs on Unstable APIs](https://rustwasm.github.io/wasm-bindgen/web-sys/unstable-apis.html) for more details.
 
 Bevy has an helper to build its examples:
 
diff --git a/examples/app/log_layers.rs b/examples/app/log_layers.rs
index 144fac28bd741..10b090d988dd0 100644
--- a/examples/app/log_layers.rs
+++ b/examples/app/log_layers.rs
@@ -22,7 +22,9 @@ impl<S: Subscriber> Layer<S> for CustomLayer {
     }
 }
 
-fn update_subscriber(subscriber: BoxedSubscriber) -> BoxedSubscriber {
+// We don't need App for this example, as we are just printing log information.
+// For an example that uses App, see log_layers_ecs.
+fn update_subscriber(_: &mut App, subscriber: BoxedSubscriber) -> BoxedSubscriber {
     Box::new(subscriber.with(CustomLayer))
 }
 
@@ -30,6 +32,14 @@ fn main() {
     App::new()
         .add_plugins(DefaultPlugins.set(bevy::log::LogPlugin {
             update_subscriber: Some(update_subscriber),
+            // You can chain multiple subscriber updates like this:
+            //
+            // update_subscriber: Some(|app, subscriber| {
+            //     let subscriber = update_subscriber_a(app, subscriber);
+            //     let subscriber = update_subscriber_b(app, subscriber);
+            //
+            //     update_subscriber_c(app, subscriber)
+            // }),
             ..default()
         }))
         .add_systems(Update, log_system)
@@ -37,7 +47,7 @@ fn main() {
 }
 
 fn log_system() {
-    // here is how you write new logs at each "log level" (in "most import" to
+    // here is how you write new logs at each "log level" (in "most important" to
     // "least important" order)
     error!("something failed");
     warn!("something bad happened that isn't a failure, but thats worth calling out");
diff --git a/examples/app/log_layers_ecs.rs b/examples/app/log_layers_ecs.rs
new file mode 100644
index 0000000000000..9c4ad4ee6e134
--- /dev/null
+++ b/examples/app/log_layers_ecs.rs
@@ -0,0 +1,151 @@
+//! This example illustrates how to transfer log events from the [`Layer`] to Bevy's ECS.
+//!
+//! The way we will do this is via a [`mpsc`] channel. [`mpsc`] channels allow 2 unrelated
+//! parts of the program to communicate (in this case, [`Layer`]s and Bevy's ECS).
+//!
+//! Inside the [`update_subscriber`] function we will create a [`mpsc::Sender`] and a [`mpsc::Receiver`] from a
+//! [`mpsc::channel`]. The [`Sender`](mpsc::Sender) will go into the [`AdvancedLayer`] and the [`Receiver`](mpsc::Receiver) will
+//! go into a non-send resource called [`LogEvents`] (It has to be non-send because [`Receiver`](mpsc::Receiver) is [`!Sync`](Sync)).
+//! From there we will use [`transfer_log_events`] to transfer log events from [`LogEvents`] to an ECS event called [`LogEvent`].
+//!
+//! Finally, after all that we can access the [`LogEvent`] event from our systems and use it.
+//! In this example we build a simple log viewer.
+
+use std::sync::mpsc;
+
+use bevy::{
+    log::tracing_subscriber::{self, layer::SubscriberExt, Layer},
+    log::BoxedSubscriber,
+    prelude::*,
+    utils::tracing,
+    utils::tracing::Subscriber,
+};
+
+/// A basic message. This is what we will be sending from the [`CaptureLayer`] to [`CapturedLogEvents`] non-send resource.
+#[derive(Debug, Event)]
+struct LogEvent {
+    message: String,
+}
+
+/// This non-send resource temporarily stores [`LogEvent`]s before they are
+/// written to [`Events<LogEvent>`] by [`transfer_log_events`].
+#[derive(Deref, DerefMut)]
+struct CapturedLogEvents(mpsc::Receiver<LogEvent>);
+
+/// Transfers information from the [`LogEvents`] resource to [`Events<LogEvent>`](LogEvent).
+fn transfer_log_events(
+    receiver: NonSend<CapturedLogEvents>,
+    mut log_events: EventWriter<LogEvent>,
+) {
+    // Make sure to use `try_iter()` and not `iter()` to prevent blocking.
+    log_events.send_batch(receiver.try_iter());
+}
+
+/// This is the [`Layer`] that we will use to capture log events and then send them to Bevy's
+/// ECS via it's [`mpsc::Sender`].
+struct CaptureLayer {
+    sender: mpsc::Sender<LogEvent>,
+}
+impl<S: Subscriber> Layer<S> for CaptureLayer {
+    fn on_event(
+        &self,
+        event: &tracing::Event<'_>,
+        _ctx: tracing_subscriber::layer::Context<'_, S>,
+    ) {
+        // In order to obtain the log message, we have to create a struct that implements
+        // Visit and holds a reference to our string. Then we use the `record` method and
+        // the struct to modify the reference to hold the message string.
+        let mut message = None;
+        event.record(&mut CaptureLayerVisitor(&mut message));
+        if let Some(message) = message {
+            // You can obtain metadata like this, but we wont use it for this example.
+            let _metadata = event.metadata();
+            self.sender
+                .send(LogEvent { message })
+                .expect("LogEvents resource no longer exists!");
+        }
+    }
+}
+
+/// A [`Visit`](tracing::field::Visit)or that records log messages that are transferred to [`CaptureLayer`].
+struct CaptureLayerVisitor<'a>(&'a mut Option<String>);
+impl tracing::field::Visit for CaptureLayerVisitor<'_> {
+    fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
+        // This if statement filters out unneeded events sometimes show up
+        if field.name() == "message" {
+            *self.0 = Some(format!("{value:?}"));
+        }
+    }
+}
+fn update_subscriber(app: &mut App, subscriber: BoxedSubscriber) -> BoxedSubscriber {
+    let (sender, receiver) = mpsc::channel();
+
+    let layer = CaptureLayer { sender };
+    let resource = CapturedLogEvents(receiver);
+
+    app.insert_non_send_resource(resource);
+    app.add_event::<LogEvent>();
+    app.add_systems(Update, transfer_log_events);
+
+    Box::new(subscriber.with(layer))
+}
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins.set(bevy::log::LogPlugin {
+            update_subscriber: Some(update_subscriber),
+            ..default()
+        }))
+        .add_systems(Startup, (log_system, setup))
+        .add_systems(Update, print_logs)
+        .run();
+}
+
+fn log_system() {
+    // here is how you write new logs at each "log level" (in "most important" to
+    // "least important" order)
+    error!("something failed");
+    warn!("something bad happened that isn't a failure, but thats worth calling out");
+    info!("helpful information that is worth printing by default");
+    debug!("helpful for debugging");
+    trace!("very noisy");
+}
+
+#[derive(Component)]
+struct LogViewerRoot;
+
+fn setup(mut commands: Commands) {
+    commands.spawn(Camera2dBundle::default());
+
+    commands.spawn((
+        NodeBundle {
+            style: Style {
+                width: Val::Vw(100.0),
+                height: Val::Vh(100.0),
+                flex_direction: FlexDirection::Column,
+                ..default()
+            },
+            ..default()
+        },
+        LogViewerRoot,
+    ));
+}
+
+// This is how we can read our LogEvents.
+// In this example we are reading the LogEvents and inserting them as text into our log viewer.
+fn print_logs(
+    mut events: EventReader<LogEvent>,
+    mut commands: Commands,
+    log_viewer_root: Query<Entity, With<LogViewerRoot>>,
+) {
+    let root_entity = log_viewer_root.single();
+
+    commands.entity(root_entity).with_children(|child| {
+        for event in events.read() {
+            child.spawn(TextBundle::from_section(
+                &event.message,
+                TextStyle::default(),
+            ));
+        }
+    });
+}
diff --git a/examples/asset/asset_decompression.rs b/examples/asset/asset_decompression.rs
index 1c72521b0eb7a..cd17a38a89a9e 100644
--- a/examples/asset/asset_decompression.rs
+++ b/examples/asset/asset_decompression.rs
@@ -1,6 +1,5 @@
 //! Implements loader for a Gzip compressed asset.
 
-use bevy::utils::thiserror;
 use bevy::{
     asset::{
         io::{Reader, VecReader},
diff --git a/examples/asset/custom_asset.rs b/examples/asset/custom_asset.rs
index f54a1d3a19e55..c10e297c380bd 100644
--- a/examples/asset/custom_asset.rs
+++ b/examples/asset/custom_asset.rs
@@ -1,6 +1,5 @@
 //! Implements loader for a custom asset type.
 
-use bevy::utils::thiserror;
 use bevy::{
     asset::{io::Reader, ron, AssetLoader, AsyncReadExt, LoadContext},
     prelude::*,
diff --git a/examples/asset/embedded_asset.rs b/examples/asset/embedded_asset.rs
index af865b6007f5e..9066bfaba72d6 100644
--- a/examples/asset/embedded_asset.rs
+++ b/examples/asset/embedded_asset.rs
@@ -20,7 +20,7 @@ impl Plugin for EmbeddedAssetPlugin {
         let omit_prefix = "examples/asset";
         // Path to asset must be relative to this file, because that's how
         // include_bytes! works.
-        embedded_asset!(app, omit_prefix, "bevy_pixel_light.png");
+        embedded_asset!(app, omit_prefix, "files/bevy_pixel_light.png");
     }
 }
 
@@ -31,11 +31,11 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     let crate_name = "embedded_asset";
 
     // The actual file path relative to workspace root is
-    // "examples/asset/bevy_pixel_light.png".
+    // "examples/asset/files/bevy_pixel_light.png".
     //
     // We omit the "examples/asset" from the embedded_asset! call and replace it
     // with the crate name.
-    let path = Path::new(crate_name).join("bevy_pixel_light.png");
+    let path = Path::new(crate_name).join("files/bevy_pixel_light.png");
     let source = AssetSourceId::from("embedded");
     let asset_path = AssetPath::from_path(&path).with_source(source);
 
@@ -43,7 +43,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     // path.
     assert_eq!(
         asset_path,
-        "embedded://embedded_asset/bevy_pixel_light.png".into()
+        "embedded://embedded_asset/files/bevy_pixel_light.png".into()
     );
 
     commands.spawn(SpriteBundle {
diff --git a/examples/asset/extra_source.rs b/examples/asset/extra_source.rs
new file mode 100644
index 0000000000000..04d860d7af115
--- /dev/null
+++ b/examples/asset/extra_source.rs
@@ -0,0 +1,47 @@
+//! An example of registering an extra asset source, and loading assets from it.
+//! This asset source exists in addition to the default asset source.
+
+use bevy::asset::{
+    io::{AssetSourceBuilder, AssetSourceId},
+    AssetPath,
+};
+use bevy::prelude::*;
+use std::path::Path;
+
+fn main() {
+    App::new()
+        // Add an extra asset source with the name "example_files" to
+        // AssetSourceBuilders.
+        //
+        // This must be done before AssetPlugin finalizes building assets.
+        .register_asset_source(
+            "example_files",
+            AssetSourceBuilder::platform_default("examples/asset/files", None),
+        )
+        // DefaultPlugins contains AssetPlugin so it must be added to our App
+        // after inserting our new asset source.
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, setup)
+        .run();
+}
+
+fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
+    commands.spawn(Camera2dBundle::default());
+
+    // Now we can load the asset using our new asset source.
+    //
+    // The actual file path relative to workspace root is
+    // "examples/asset/files/bevy_pixel_light.png".
+    let path = Path::new("bevy_pixel_light.png");
+    let source = AssetSourceId::from("example_files");
+    let asset_path = AssetPath::from_path(path).with_source(source);
+
+    // You could also parse this URL-like string representation for the asset
+    // path.
+    assert_eq!(asset_path, "example_files://bevy_pixel_light.png".into());
+
+    commands.spawn(SpriteBundle {
+        texture: asset_server.load(asset_path),
+        ..default()
+    });
+}
diff --git a/examples/asset/bevy_pixel_light.png b/examples/asset/files/bevy_pixel_light.png
similarity index 100%
rename from examples/asset/bevy_pixel_light.png
rename to examples/asset/files/bevy_pixel_light.png
diff --git a/examples/asset/processing/asset_processing.rs b/examples/asset/processing/asset_processing.rs
index 640d0cdabf369..3f660ef85f500 100644
--- a/examples/asset/processing/asset_processing.rs
+++ b/examples/asset/processing/asset_processing.rs
@@ -12,7 +12,7 @@ use bevy::{
     },
     prelude::*,
     reflect::TypePath,
-    utils::{thiserror, BoxedFuture},
+    utils::BoxedFuture,
 };
 use serde::{Deserialize, Serialize};
 use std::convert::Infallible;
diff --git a/examples/async_tasks/async_compute.rs b/examples/async_tasks/async_compute.rs
index 0227c2841b41a..bf4b8a26ec807 100644
--- a/examples/async_tasks/async_compute.rs
+++ b/examples/async_tasks/async_compute.rs
@@ -2,7 +2,8 @@
 //! to spawn, poll, and complete tasks across systems and system ticks.
 
 use bevy::{
-    ecs::system::{CommandQueue, SystemState},
+    ecs::system::SystemState,
+    ecs::world::CommandQueue,
     prelude::*,
     tasks::{block_on, futures_lite::future, AsyncComputeTaskPool, Task},
 };
diff --git a/examples/audio/spatial_audio_2d.rs b/examples/audio/spatial_audio_2d.rs
index 143ff11582379..c17776b5c2bee 100644
--- a/examples/audio/spatial_audio_2d.rs
+++ b/examples/audio/spatial_audio_2d.rs
@@ -65,7 +65,7 @@ fn setup(
             // right ear
             parent.spawn(SpriteBundle {
                 sprite: Sprite {
-                    color: GREEN.into(),
+                    color: LIME.into(),
                     custom_size: Some(Vec2::splat(20.0)),
                     ..default()
                 },
diff --git a/examples/audio/spatial_audio_3d.rs b/examples/audio/spatial_audio_3d.rs
index 1841f250a4cf1..87722733d4906 100644
--- a/examples/audio/spatial_audio_3d.rs
+++ b/examples/audio/spatial_audio_3d.rs
@@ -1,6 +1,6 @@
 //! This example illustrates how to load and play an audio file, and control where the sounds seems to come from.
 use bevy::{
-    color::palettes::basic::{BLUE, GREEN, RED},
+    color::palettes::basic::{BLUE, LIME, RED},
     prelude::*,
 };
 
@@ -52,7 +52,7 @@ fn setup(
             // right ear indicator
             parent.spawn(PbrBundle {
                 mesh: meshes.add(Cuboid::new(0.2, 0.2, 0.2)),
-                material: materials.add(Color::from(GREEN)),
+                material: materials.add(Color::from(LIME)),
                 transform: Transform::from_translation(listener.right_ear_offset),
                 ..default()
             });
diff --git a/examples/ecs/component_hooks.rs b/examples/ecs/component_hooks.rs
index 7794ca84a8c3f..ae0acfefdded6 100644
--- a/examples/ecs/component_hooks.rs
+++ b/examples/ecs/component_hooks.rs
@@ -1,6 +1,19 @@
-//! This examples illustrates the different ways you can employ component lifecycle hooks
+//! This example illustrates the different ways you can employ component lifecycle hooks.
+//!
+//! Whenever possible, prefer using Bevy's change detection or Events for reacting to component changes.
+//! Events generally offer better performance and more flexible integration into Bevy's systems.
+//! Hooks are useful to enforce correctness but have limitations (only one hook per component,
+//! less ergonomic than events).
+//!
+//! Here are some cases where components hooks might be necessary:
+//!
+//! - Maintaining indexes: If you need to keep custom data structures (like a spatial index) in
+//! sync with the addition/removal of components.
+//!
+//! - Enforcing structural rules: When you have systems that depend on specific relationships
+//! between components (like hierarchies or parent-child links) and need to maintain correctness.
 
-use bevy::ecs::component::{ComponentInfo, TableStorage};
+use bevy::ecs::component::{ComponentHooks, StorageType};
 use bevy::prelude::*;
 use std::collections::HashMap;
 
@@ -8,11 +21,11 @@ use std::collections::HashMap;
 struct MyComponent(KeyCode);
 
 impl Component for MyComponent {
-    type Storage = TableStorage;
+    const STORAGE_TYPE: StorageType = StorageType::Table;
 
     /// Hooks can also be registered during component initialisation by
-    /// implementing `init_component_info`
-    fn init_component_info(_info: &mut ComponentInfo) {
+    /// implementing `register_component_hooks`
+    fn register_component_hooks(_hooks: &mut ComponentHooks) {
         // Register hooks...
     }
 }
@@ -35,7 +48,7 @@ fn main() {
 
 fn setup(world: &mut World) {
     // In order to register component hooks the component must:
-    // - not belong to any created archetypes
+    // - not be currently in use by any entities in the world
     // - not already have a hook of that kind registered
     // This is to prevent overriding hooks defined in plugins and other crates as well as keeping things fast
     world
diff --git a/examples/ecs/hierarchy.rs b/examples/ecs/hierarchy.rs
index 7faa0bab087f0..b61f21f24ae94 100644
--- a/examples/ecs/hierarchy.rs
+++ b/examples/ecs/hierarchy.rs
@@ -47,7 +47,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
             transform: Transform::from_xyz(0.0, 250.0, 0.0).with_scale(Vec3::splat(0.75)),
             texture,
             sprite: Sprite {
-                color: GREEN.into(),
+                color: LIME.into(),
                 ..default()
             },
             ..default()
diff --git a/examples/ecs/state.rs b/examples/ecs/state.rs
index fb906a0c957c2..c2acde35be438 100644
--- a/examples/ecs/state.rs
+++ b/examples/ecs/state.rs
@@ -74,7 +74,7 @@ fn setup_menu(mut commands: Commands) {
                         align_items: AlignItems::Center,
                         ..default()
                     },
-                    background_color: NORMAL_BUTTON.into(),
+                    image: UiImage::default().with_color(NORMAL_BUTTON),
                     ..default()
                 })
                 .with_children(|parent| {
@@ -95,21 +95,21 @@ fn setup_menu(mut commands: Commands) {
 fn menu(
     mut next_state: ResMut<NextState<AppState>>,
     mut interaction_query: Query<
-        (&Interaction, &mut BackgroundColor),
+        (&Interaction, &mut UiImage),
         (Changed<Interaction>, With<Button>),
     >,
 ) {
-    for (interaction, mut color) in &mut interaction_query {
+    for (interaction, mut image) in &mut interaction_query {
         match *interaction {
             Interaction::Pressed => {
-                *color = PRESSED_BUTTON.into();
+                image.color = PRESSED_BUTTON;
                 next_state.set(AppState::InGame);
             }
             Interaction::Hovered => {
-                *color = HOVERED_BUTTON.into();
+                image.color = HOVERED_BUTTON;
             }
             Interaction::None => {
-                *color = NORMAL_BUTTON.into();
+                image.color = NORMAL_BUTTON;
             }
         }
     }
diff --git a/examples/games/contributors.rs b/examples/games/contributors.rs
index 226d09df4958a..067f0bdf58b20 100644
--- a/examples/games/contributors.rs
+++ b/examples/games/contributors.rs
@@ -1,10 +1,6 @@
 //! This example displays each contributor to the bevy source code as a bouncing bevy-ball.
 
-use bevy::{
-    math::bounding::Aabb2d,
-    prelude::*,
-    utils::{thiserror, HashMap},
-};
+use bevy::{math::bounding::Aabb2d, prelude::*, utils::HashMap};
 use rand::{prelude::SliceRandom, Rng};
 use std::{
     env::VarError,
@@ -242,7 +238,7 @@ fn collisions(
     mut query: Query<(&mut Velocity, &mut Transform), With<Contributor>>,
 ) {
     let window = windows.single();
-    let window_size = Vec2::new(window.width(), window.height());
+    let window_size = window.size();
 
     let collision_area = Aabb2d::new(Vec2::ZERO, (window_size - SPRITE_SIZE) / 2.);
 
diff --git a/examples/games/desk_toy.rs b/examples/games/desk_toy.rs
new file mode 100644
index 0000000000000..c79eacd7a91bf
--- /dev/null
+++ b/examples/games/desk_toy.rs
@@ -0,0 +1,397 @@
+//! Bevy logo as a desk toy using transparent windows! Now with Googly Eyes!
+//!
+//! This example demonstrates:
+//! - Transparent windows that can be clicked through.
+//! - Drag-and-drop operations in 2D.
+//! - Using entity hierarchy and [`SpatialBundle`]s to create simple animations.
+//! - Creating simple 2D meshes based on shape primitives.
+
+use bevy::{
+    app::AppExit,
+    input::common_conditions::{input_just_pressed, input_just_released},
+    prelude::*,
+    sprite::{MaterialMesh2dBundle, Mesh2dHandle},
+    window::{PrimaryWindow, WindowLevel},
+};
+
+#[cfg(target_os = "macos")]
+use bevy::window::CompositeAlphaMode;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins.set(WindowPlugin {
+            primary_window: Some(Window {
+                title: "Bevy Desk Toy".into(),
+                transparent: true,
+                #[cfg(target_os = "macos")]
+                composite_alpha_mode: CompositeAlphaMode::PostMultiplied,
+                ..default()
+            }),
+            ..default()
+        }))
+        .insert_resource(ClearColor(WINDOW_CLEAR_COLOR))
+        .insert_resource(WindowTransparency(false))
+        .insert_resource(CursorWorldPos(None))
+        .add_systems(Startup, setup)
+        .add_systems(
+            Update,
+            (
+                get_cursor_world_pos,
+                update_cursor_hit_test,
+                (
+                    start_drag.run_if(input_just_pressed(MouseButton::Left)),
+                    end_drag.run_if(input_just_released(MouseButton::Left)),
+                    drag.run_if(resource_exists::<DragOperation>),
+                    quit.run_if(input_just_pressed(MouseButton::Right)),
+                    toggle_transparency.run_if(input_just_pressed(KeyCode::Space)),
+                    move_pupils.after(drag),
+                ),
+            )
+                .chain(),
+        )
+        .run();
+}
+
+/// Whether the window is transparent
+#[derive(Resource)]
+struct WindowTransparency(bool);
+
+/// The projected 2D world coordinates of the cursor (if it's within primary window bounds).
+#[derive(Resource)]
+struct CursorWorldPos(Option<Vec2>);
+
+/// The current drag operation including the offset with which we grabbed the Bevy logo.
+#[derive(Resource)]
+struct DragOperation(Vec2);
+
+/// Marker component for the instructions text entity.
+#[derive(Component)]
+struct InstructionsText;
+
+/// Marker component for the Bevy logo entity.
+#[derive(Component)]
+struct BevyLogo;
+
+/// Component for the moving pupil entity (the moving part of the googly eye).
+#[derive(Component)]
+struct Pupil {
+    /// Radius of the eye containing the pupil.
+    eye_radius: f32,
+    /// Radius of the pupil.
+    pupil_radius: f32,
+    /// Current velocity of the pupil.
+    velocity: Vec2,
+}
+
+// Dimensions are based on: assets/branding/icon.png
+// Bevy logo radius
+const BEVY_LOGO_RADIUS: f32 = 128.0;
+// Birds' eyes x y (offset from the origin) and radius
+// These values are manually determined from the logo image
+const BIRDS_EYES: [(f32, f32, f32); 3] = [
+    (145.0 - 128.0, -(56.0 - 128.0), 12.0),
+    (198.0 - 128.0, -(87.0 - 128.0), 10.0),
+    (222.0 - 128.0, -(140.0 - 128.0), 8.0),
+];
+
+const WINDOW_CLEAR_COLOR: Color = Color::srgb(0.2, 0.2, 0.2);
+
+/// Spawn the scene
+fn setup(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+    // Spawn a 2D camera
+    commands.spawn(Camera2dBundle::default());
+
+    // Spawn the text instructions
+    let font = asset_server.load("fonts/FiraSans-Bold.ttf");
+    let text_style = TextStyle {
+        font: font.clone(),
+        font_size: 30.0,
+        color: Color::WHITE,
+    };
+    commands.spawn((
+        Text2dBundle {
+            text: Text::from_section(
+                "Press Space to play on your desktop! Press it again to return.\nRight click Bevy logo to exit.",
+                text_style.clone(),
+            ),
+            transform: Transform::from_xyz(0.0, -300.0, 100.0),
+            ..default()
+        },
+        InstructionsText,
+    ));
+
+    // Create a circle mesh. We will reuse this mesh for all our circles.
+    let circle = Mesh2dHandle(meshes.add(Circle { radius: 1.0 }));
+    // Create the different materials we will use for each part of the eyes. For this demo they are basic [`ColorMaterial`]s.
+    let outline_material = materials.add(Color::BLACK);
+    let sclera_material = materials.add(Color::WHITE);
+    let pupil_material = materials.add(Color::srgb(0.2, 0.2, 0.2));
+    let pupil_highlight_material = materials.add(Color::srgba(1.0, 1.0, 1.0, 0.2));
+
+    // Spawn the Bevy logo sprite
+    commands
+        .spawn((
+            SpriteBundle {
+                texture: asset_server.load("branding/icon.png"),
+                ..default()
+            },
+            BevyLogo,
+        ))
+        .with_children(|commands| {
+            // For each bird eye
+            for (x, y, radius) in BIRDS_EYES {
+                // eye outline
+                commands.spawn(MaterialMesh2dBundle {
+                    mesh: circle.clone(),
+                    material: outline_material.clone(),
+                    transform: Transform::from_xyz(x, y - 1.0, 1.0)
+                        .with_scale(Vec2::splat(radius + 2.0).extend(1.0)),
+                    ..default()
+                });
+
+                // sclera
+                commands
+                    .spawn(SpatialBundle::from_transform(Transform::from_xyz(
+                        x, y, 2.0,
+                    )))
+                    .with_children(|commands| {
+                        // sclera
+                        commands.spawn(MaterialMesh2dBundle {
+                            mesh: circle.clone(),
+                            material: sclera_material.clone(),
+                            transform: Transform::from_scale(Vec3::new(radius, radius, 0.0)),
+                            ..default()
+                        });
+
+                        let pupil_radius = radius * 0.6;
+                        let pupil_highlight_radius = radius * 0.3;
+                        let pupil_highlight_offset = radius * 0.3;
+                        // pupil
+                        commands
+                            .spawn((
+                                SpatialBundle::from_transform(Transform::from_xyz(0.0, 0.0, 1.0)),
+                                Pupil {
+                                    eye_radius: radius,
+                                    pupil_radius,
+                                    velocity: Vec2::ZERO,
+                                },
+                            ))
+                            .with_children(|commands| {
+                                // pupil main
+                                commands.spawn(MaterialMesh2dBundle {
+                                    mesh: circle.clone(),
+                                    material: pupil_material.clone(),
+                                    transform: Transform::from_xyz(0.0, 0.0, 0.0)
+                                        .with_scale(Vec3::new(pupil_radius, pupil_radius, 1.0)),
+                                    ..default()
+                                });
+
+                                // pupil highlight
+                                commands.spawn(MaterialMesh2dBundle {
+                                    mesh: circle.clone(),
+                                    material: pupil_highlight_material.clone(),
+                                    transform: Transform::from_xyz(
+                                        -pupil_highlight_offset,
+                                        pupil_highlight_offset,
+                                        1.0,
+                                    )
+                                    .with_scale(Vec3::new(
+                                        pupil_highlight_radius,
+                                        pupil_highlight_radius,
+                                        1.0,
+                                    )),
+                                    ..default()
+                                });
+                            });
+                    });
+            }
+        });
+}
+
+/// Project the cursor into the world coordinates and store it in a resource for easy use
+fn get_cursor_world_pos(
+    mut cursor_world_pos: ResMut<CursorWorldPos>,
+    q_primary_window: Query<&Window, With<PrimaryWindow>>,
+    q_camera: Query<(&Camera, &GlobalTransform)>,
+) {
+    let primary_window = q_primary_window.single();
+    let (main_camera, main_camera_transform) = q_camera.single();
+    // Get the cursor position in the world
+    cursor_world_pos.0 = primary_window
+        .cursor_position()
+        .and_then(|cursor_pos| main_camera.viewport_to_world_2d(main_camera_transform, cursor_pos));
+}
+
+/// Update whether the window is clickable or not
+fn update_cursor_hit_test(
+    cursor_world_pos: Res<CursorWorldPos>,
+    mut q_primary_window: Query<&mut Window, With<PrimaryWindow>>,
+    q_bevy_logo: Query<&Transform, With<BevyLogo>>,
+) {
+    let mut primary_window = q_primary_window.single_mut();
+
+    // If the window has decorations (e.g. a border) then it should be clickable
+    if primary_window.decorations {
+        primary_window.cursor.hit_test = true;
+        return;
+    }
+
+    // If the cursor is not within the window we don't need to update whether the window is clickable or not
+    let Some(cursor_world_pos) = cursor_world_pos.0 else {
+        return;
+    };
+
+    // If the cursor is within the radius of the Bevy logo make the window clickable otherwise the window is not clickable
+    let bevy_logo_transform = q_bevy_logo.single();
+    primary_window.cursor.hit_test = bevy_logo_transform
+        .translation
+        .truncate()
+        .distance(cursor_world_pos)
+        < BEVY_LOGO_RADIUS;
+}
+
+/// Start the drag operation and record the offset we started dragging from
+fn start_drag(
+    mut commands: Commands,
+    cursor_world_pos: Res<CursorWorldPos>,
+    q_bevy_logo: Query<&Transform, With<BevyLogo>>,
+) {
+    // If the cursor is not within the primary window skip this system
+    let Some(cursor_world_pos) = cursor_world_pos.0 else {
+        return;
+    };
+
+    // Get the offset from the cursor to the Bevy logo sprite
+    let bevy_logo_transform = q_bevy_logo.single();
+    let drag_offset = bevy_logo_transform.translation.truncate() - cursor_world_pos;
+
+    // If the cursor is within the Bevy logo radius start the drag operation and remember the offset of the cursor from the origin
+    if drag_offset.length() < BEVY_LOGO_RADIUS {
+        commands.insert_resource(DragOperation(drag_offset));
+    }
+}
+
+/// Stop the current drag operation
+fn end_drag(mut commands: Commands) {
+    commands.remove_resource::<DragOperation>();
+}
+
+/// Drag the Bevy logo
+fn drag(
+    drag_offset: Res<DragOperation>,
+    cursor_world_pos: Res<CursorWorldPos>,
+    time: Res<Time>,
+    mut q_bevy_logo: Query<&mut Transform, With<BevyLogo>>,
+    mut q_pupils: Query<&mut Pupil>,
+) {
+    // If the cursor is not within the primary window skip this system
+    let Some(cursor_world_pos) = cursor_world_pos.0 else {
+        return;
+    };
+
+    // Get the current Bevy logo transform
+    let mut bevy_transform = q_bevy_logo.single_mut();
+
+    // Calculate the new translation of the Bevy logo based on cursor and drag offset
+    let new_translation = cursor_world_pos + drag_offset.0;
+
+    // Calculate how fast we are dragging the Bevy logo (unit/second)
+    let drag_velocity =
+        (new_translation - bevy_transform.translation.truncate()) / time.delta_seconds();
+
+    // Update the translation of Bevy logo transform to new translation
+    bevy_transform.translation = new_translation.extend(bevy_transform.translation.z);
+
+    // Add the cursor drag velocity in the opposite direction to each pupil.
+    // Remember pupils are using local coordinates to move. So when the Bevy logo moves right they need to move left to
+    // simulate inertia, otherwise they will move fixed to the parent.
+    for mut pupil in &mut q_pupils {
+        pupil.velocity -= drag_velocity;
+    }
+}
+
+/// Quit when the user right clicks the Bevy logo
+fn quit(
+    cursor_world_pos: Res<CursorWorldPos>,
+    mut app_exit: EventWriter<AppExit>,
+    q_bevy_logo: Query<&Transform, With<BevyLogo>>,
+) {
+    // If the cursor is not within the primary window skip this system
+    let Some(cursor_world_pos) = cursor_world_pos.0 else {
+        return;
+    };
+
+    // If the cursor is within the Bevy logo radius send the [`AppExit`] event to quit the app
+    let bevy_logo_transform = q_bevy_logo.single();
+    if bevy_logo_transform
+        .translation
+        .truncate()
+        .distance(cursor_world_pos)
+        < BEVY_LOGO_RADIUS
+    {
+        app_exit.send(AppExit);
+    }
+}
+
+/// Enable transparency for the window and make it on top
+fn toggle_transparency(
+    mut commands: Commands,
+    mut window_transparency: ResMut<WindowTransparency>,
+    mut q_instructions_text: Query<&mut Visibility, With<InstructionsText>>,
+    mut q_primary_window: Query<&mut Window, With<PrimaryWindow>>,
+) {
+    // Toggle the window transparency resource
+    window_transparency.0 = !window_transparency.0;
+
+    // Show or hide the instructions text
+    for mut visibility in &mut q_instructions_text {
+        *visibility = if window_transparency.0 {
+            Visibility::Hidden
+        } else {
+            Visibility::Visible
+        };
+    }
+
+    // Remove the primary window's decorations (e.g. borders), make it always on top of other desktop windows, and set the clear color to transparent
+    // only if window transparency is enabled
+    let mut window = q_primary_window.single_mut();
+    let clear_color;
+    (window.decorations, window.window_level, clear_color) = if window_transparency.0 {
+        (false, WindowLevel::AlwaysOnTop, Color::NONE)
+    } else {
+        (true, WindowLevel::Normal, WINDOW_CLEAR_COLOR)
+    };
+
+    // Set the clear color
+    commands.insert_resource(ClearColor(clear_color));
+}
+
+/// Move the pupils and bounce them around
+fn move_pupils(time: Res<Time>, mut q_pupils: Query<(&mut Pupil, &mut Transform)>) {
+    for (mut pupil, mut transform) in &mut q_pupils {
+        // The wiggle radius is how much the pupil can move within the eye
+        let wiggle_radius = pupil.eye_radius - pupil.pupil_radius;
+        // Store the Z component
+        let z = transform.translation.z;
+        // Truncate the Z component to make the calculations be on [`Vec2`]
+        let mut translation = transform.translation.truncate();
+        // Decay the pupil velocity
+        pupil.velocity *= (0.04f32).powf(time.delta_seconds());
+        // Move the pupil
+        translation += pupil.velocity * time.delta_seconds();
+        // If the pupil hit the outside border of the eye, limit the translation to be within the wiggle radius and invert the velocity.
+        // This is not physically accurate but it's good enough for the googly eyes effect.
+        if translation.length() > wiggle_radius {
+            translation = translation.normalize() * wiggle_radius;
+            // Invert and decrease the velocity of the pupil when it bounces
+            pupil.velocity *= -0.75;
+        }
+        // Update the entity transform with the new translation after reading the Z component
+        transform.translation = translation.extend(z);
+    }
+}
diff --git a/examples/games/game_menu.rs b/examples/games/game_menu.rs
index 59833c19decbf..b6f1f533de8bc 100644
--- a/examples/games/game_menu.rs
+++ b/examples/games/game_menu.rs
@@ -116,7 +116,7 @@ mod splash {
 
 mod game {
     use bevy::{
-        color::palettes::basic::{BLUE, GREEN},
+        color::palettes::basic::{BLUE, LIME},
         prelude::*,
     };
 
@@ -211,7 +211,7 @@ mod game {
                                     format!("volume: {:?}", *volume),
                                     TextStyle {
                                         font_size: 60.0,
-                                        color: GREEN.into(),
+                                        color: LIME.into(),
                                         ..default()
                                     },
                                 ),
@@ -345,16 +345,16 @@ mod menu {
     // This system handles changing all buttons color based on mouse interaction
     fn button_system(
         mut interaction_query: Query<
-            (&Interaction, &mut BackgroundColor, Option<&SelectedOption>),
+            (&Interaction, &mut UiImage, Option<&SelectedOption>),
             (Changed<Interaction>, With<Button>),
         >,
     ) {
-        for (interaction, mut color, selected) in &mut interaction_query {
-            *color = match (*interaction, selected) {
-                (Interaction::Pressed, _) | (Interaction::None, Some(_)) => PRESSED_BUTTON.into(),
-                (Interaction::Hovered, Some(_)) => HOVERED_PRESSED_BUTTON.into(),
-                (Interaction::Hovered, None) => HOVERED_BUTTON.into(),
-                (Interaction::None, None) => NORMAL_BUTTON.into(),
+        for (interaction, mut image, selected) in &mut interaction_query {
+            image.color = match (*interaction, selected) {
+                (Interaction::Pressed, _) | (Interaction::None, Some(_)) => PRESSED_BUTTON,
+                (Interaction::Hovered, Some(_)) => HOVERED_PRESSED_BUTTON,
+                (Interaction::Hovered, None) => HOVERED_BUTTON,
+                (Interaction::None, None) => NORMAL_BUTTON,
             }
         }
     }
@@ -363,14 +363,14 @@ mod menu {
     // the button as the one currently selected
     fn setting_button<T: Resource + Component + PartialEq + Copy>(
         interaction_query: Query<(&Interaction, &T, Entity), (Changed<Interaction>, With<Button>)>,
-        mut selected_query: Query<(Entity, &mut BackgroundColor), With<SelectedOption>>,
+        mut selected_query: Query<(Entity, &mut UiImage), With<SelectedOption>>,
         mut commands: Commands,
         mut setting: ResMut<T>,
     ) {
         for (interaction, button_setting, entity) in &interaction_query {
             if *interaction == Interaction::Pressed && *setting != *button_setting {
-                let (previous_button, mut previous_color) = selected_query.single_mut();
-                *previous_color = NORMAL_BUTTON.into();
+                let (previous_button, mut previous_image) = selected_query.single_mut();
+                previous_image.color = NORMAL_BUTTON;
                 commands.entity(previous_button).remove::<SelectedOption>();
                 commands.entity(entity).insert(SelectedOption);
                 *setting = *button_setting;
@@ -456,7 +456,7 @@ mod menu {
                             .spawn((
                                 ButtonBundle {
                                     style: button_style.clone(),
-                                    background_color: NORMAL_BUTTON.into(),
+                                    image: UiImage::default().with_color(NORMAL_BUTTON),
                                     ..default()
                                 },
                                 MenuButtonAction::Play,
@@ -477,7 +477,7 @@ mod menu {
                             .spawn((
                                 ButtonBundle {
                                     style: button_style.clone(),
-                                    background_color: NORMAL_BUTTON.into(),
+                                    image: UiImage::default().with_color(NORMAL_BUTTON),
                                     ..default()
                                 },
                                 MenuButtonAction::Settings,
@@ -498,7 +498,7 @@ mod menu {
                             .spawn((
                                 ButtonBundle {
                                     style: button_style,
-                                    background_color: NORMAL_BUTTON.into(),
+                                    image: UiImage::default().with_color(NORMAL_BUTTON),
                                     ..default()
                                 },
                                 MenuButtonAction::Quit,
@@ -567,7 +567,7 @@ mod menu {
                                 .spawn((
                                     ButtonBundle {
                                         style: button_style.clone(),
-                                        background_color: NORMAL_BUTTON.into(),
+                                        image: UiImage::default().with_color(NORMAL_BUTTON),
                                         ..default()
                                     },
                                     action,
@@ -654,7 +654,7 @@ mod menu {
                                                 height: Val::Px(65.0),
                                                 ..button_style.clone()
                                             },
-                                            background_color: NORMAL_BUTTON.into(),
+                                            image: UiImage::default().with_color(NORMAL_BUTTON),
                                             ..default()
                                         },
                                         quality_setting,
@@ -675,7 +675,7 @@ mod menu {
                             .spawn((
                                 ButtonBundle {
                                     style: button_style,
-                                    background_color: NORMAL_BUTTON.into(),
+                                    image: UiImage::default().with_color(NORMAL_BUTTON),
                                     ..default()
                                 },
                                 MenuButtonAction::BackToSettings,
@@ -750,7 +750,7 @@ mod menu {
                                                 height: Val::Px(65.0),
                                                 ..button_style.clone()
                                             },
-                                            background_color: NORMAL_BUTTON.into(),
+                                            image: UiImage::default().with_color(NORMAL_BUTTON),
                                             ..default()
                                         },
                                         Volume(volume_setting),
@@ -764,7 +764,7 @@ mod menu {
                             .spawn((
                                 ButtonBundle {
                                     style: button_style,
-                                    background_color: NORMAL_BUTTON.into(),
+                                    image: UiImage::default().with_color(NORMAL_BUTTON),
                                     ..default()
                                 },
                                 MenuButtonAction::BackToSettings,
diff --git a/examples/gizmos/2d_gizmos.rs b/examples/gizmos/2d_gizmos.rs
index 3a2b757fd8781..2a747ee781fd0 100644
--- a/examples/gizmos/2d_gizmos.rs
+++ b/examples/gizmos/2d_gizmos.rs
@@ -39,7 +39,7 @@ fn draw_example_collection(
 ) {
     let sin = time.elapsed_seconds().sin() * 50.;
     gizmos.line_2d(Vec2::Y * -sin, Vec2::splat(-80.), RED);
-    gizmos.ray_2d(Vec2::Y * sin, Vec2::splat(80.), GREEN);
+    gizmos.ray_2d(Vec2::Y * sin, Vec2::splat(80.), LIME);
 
     gizmos
         .grid_2d(
@@ -56,7 +56,7 @@ fn draw_example_collection(
     gizmos.linestrip_gradient_2d([
         (Vec2::Y * 300., BLUE),
         (Vec2::new(-255., -155.), RED),
-        (Vec2::new(255., -155.), GREEN),
+        (Vec2::new(255., -155.), LIME),
         (Vec2::Y * 300., BLUE),
     ]);
 
diff --git a/examples/gizmos/3d_gizmos.rs b/examples/gizmos/3d_gizmos.rs
index aa48689be95dd..5595a1d60eafe 100644
--- a/examples/gizmos/3d_gizmos.rs
+++ b/examples/gizmos/3d_gizmos.rs
@@ -103,7 +103,7 @@ fn draw_example_collection(
         Vec3::new(time.elapsed_seconds().cos() * 2.5, 1., 0.),
         Quat::from_rotation_y(PI / 2.),
         Vec2::splat(2.),
-        GREEN,
+        LIME,
     );
 
     my_gizmos.sphere(Vec3::new(1., 0.5, 0.), Quat::IDENTITY, 0.5, RED);
diff --git a/examples/gizmos/axes.rs b/examples/gizmos/axes.rs
new file mode 100644
index 0000000000000..224d419b87827
--- /dev/null
+++ b/examples/gizmos/axes.rs
@@ -0,0 +1,211 @@
+//! This example demonstrates the implementation and behavior of the axes gizmo.
+use bevy::prelude::*;
+use bevy::render::primitives::Aabb;
+use rand::random;
+use std::f32::consts::PI;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, setup)
+        .add_systems(Update, (move_cubes, draw_axes))
+        .run();
+}
+
+/// The `ShowAxes` component is attached to an entity to get the `draw_axes` system to
+/// display axes according to its Transform component.
+#[derive(Component)]
+struct ShowAxes;
+
+/// The `TransformTracking` component keeps track of the data we need to interpolate
+/// between two transforms in our example.
+#[derive(Component)]
+struct TransformTracking {
+    /// The initial transform of the cube during the move
+    initial_transform: Transform,
+
+    /// The target transform of the cube during the move
+    target_transform: Transform,
+
+    /// The progress of the cube during the move in percentage points
+    progress: u16,
+}
+
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // Lights...
+    commands.spawn(PointLightBundle {
+        point_light: PointLight {
+            shadows_enabled: true,
+            ..default()
+        },
+        transform: Transform::from_xyz(2., 6., 0.),
+        ..default()
+    });
+
+    // Camera...
+    commands.spawn(Camera3dBundle {
+        transform: Transform::from_xyz(0., 1.5, -8.).looking_at(Vec3::new(0., -0.5, 0.), Vec3::Y),
+        ..default()
+    });
+
+    // Action! (Our cubes that are going to move)
+    commands.spawn((
+        PbrBundle {
+            mesh: meshes.add(Cuboid::new(1., 1., 1.)),
+            material: materials.add(Color::srgb(0.8, 0.7, 0.6)),
+            ..default()
+        },
+        ShowAxes,
+        TransformTracking {
+            initial_transform: default(),
+            target_transform: random_transform(),
+            progress: 0,
+        },
+    ));
+
+    commands.spawn((
+        PbrBundle {
+            mesh: meshes.add(Cuboid::new(0.5, 0.5, 0.5)),
+            material: materials.add(Color::srgb(0.6, 0.7, 0.8)),
+            ..default()
+        },
+        ShowAxes,
+        TransformTracking {
+            initial_transform: default(),
+            target_transform: random_transform(),
+            progress: 0,
+        },
+    ));
+
+    // A plane to give a sense of place
+    commands.spawn(PbrBundle {
+        mesh: meshes.add(Plane3d::default().mesh().size(20., 20.)),
+        material: materials.add(Color::srgb(0.1, 0.1, 0.1)),
+        transform: Transform::from_xyz(0., -2., 0.),
+        ..default()
+    });
+}
+
+// This system draws the axes based on the cube's transform, with length based on the size of
+// the entity's axis-aligned bounding box (AABB).
+fn draw_axes(mut gizmos: Gizmos, query: Query<(&Transform, &Aabb), With<ShowAxes>>) {
+    for (&transform, &aabb) in &query {
+        let length = aabb.half_extents.length();
+        gizmos.axes(transform, length);
+    }
+}
+
+// This system changes the cubes' transforms to interpolate between random transforms
+fn move_cubes(mut query: Query<(&mut Transform, &mut TransformTracking)>) {
+    for (mut transform, mut tracking) in &mut query {
+        let t = tracking.progress as f32 / 100.;
+
+        *transform =
+            interpolate_transforms(tracking.initial_transform, tracking.target_transform, t);
+
+        if tracking.progress < 100 {
+            tracking.progress += 1;
+        } else {
+            tracking.initial_transform = *transform;
+            tracking.target_transform = random_transform();
+            tracking.progress = 0;
+        }
+    }
+}
+
+// Helper functions for random transforms and interpolation:
+
+const TRANSLATION_BOUND_LOWER_X: f32 = -5.;
+const TRANSLATION_BOUND_UPPER_X: f32 = 5.;
+const TRANSLATION_BOUND_LOWER_Y: f32 = -1.;
+const TRANSLATION_BOUND_UPPER_Y: f32 = 1.;
+const TRANSLATION_BOUND_LOWER_Z: f32 = -2.;
+const TRANSLATION_BOUND_UPPER_Z: f32 = 6.;
+
+const SCALING_BOUND_LOWER_LOG: f32 = -1.2;
+const SCALING_BOUND_UPPER_LOG: f32 = 1.2;
+
+fn random_transform() -> Transform {
+    Transform {
+        translation: random_translation(),
+        rotation: random_rotation(),
+        scale: random_scale(),
+    }
+}
+
+fn random_translation() -> Vec3 {
+    let x = random::<f32>() * (TRANSLATION_BOUND_UPPER_X - TRANSLATION_BOUND_LOWER_X)
+        + TRANSLATION_BOUND_LOWER_X;
+    let y = random::<f32>() * (TRANSLATION_BOUND_UPPER_Y - TRANSLATION_BOUND_LOWER_Y)
+        + TRANSLATION_BOUND_LOWER_Y;
+    let z = random::<f32>() * (TRANSLATION_BOUND_UPPER_Z - TRANSLATION_BOUND_LOWER_Z)
+        + TRANSLATION_BOUND_LOWER_Z;
+
+    Vec3::new(x, y, z)
+}
+
+fn random_scale() -> Vec3 {
+    let x_factor_log = random::<f32>() * (SCALING_BOUND_UPPER_LOG - SCALING_BOUND_LOWER_LOG)
+        + SCALING_BOUND_LOWER_LOG;
+    let y_factor_log = random::<f32>() * (SCALING_BOUND_UPPER_LOG - SCALING_BOUND_LOWER_LOG)
+        + SCALING_BOUND_LOWER_LOG;
+    let z_factor_log = random::<f32>() * (SCALING_BOUND_UPPER_LOG - SCALING_BOUND_LOWER_LOG)
+        + SCALING_BOUND_LOWER_LOG;
+
+    Vec3::new(
+        x_factor_log.exp2(),
+        y_factor_log.exp2(),
+        z_factor_log.exp2(),
+    )
+}
+
+fn elerp(v1: Vec3, v2: Vec3, t: f32) -> Vec3 {
+    let x_factor_log = (1. - t) * v1.x.log2() + t * v2.x.log2();
+    let y_factor_log = (1. - t) * v1.y.log2() + t * v2.y.log2();
+    let z_factor_log = (1. - t) * v1.z.log2() + t * v2.z.log2();
+
+    Vec3::new(
+        x_factor_log.exp2(),
+        y_factor_log.exp2(),
+        z_factor_log.exp2(),
+    )
+}
+
+fn random_rotation() -> Quat {
+    let dir = random_direction();
+    let angle = random::<f32>() * 2. * PI;
+
+    Quat::from_axis_angle(dir, angle)
+}
+
+fn random_direction() -> Vec3 {
+    let height = random::<f32>() * 2. - 1.;
+    let theta = random::<f32>() * 2. * PI;
+
+    build_direction(height, theta)
+}
+
+fn build_direction(height: f32, theta: f32) -> Vec3 {
+    let z = height;
+    let m = f32::acos(z).sin();
+    let x = theta.cos() * m;
+    let y = theta.sin() * m;
+
+    Vec3::new(x, y, z)
+}
+
+fn interpolate_transforms(t1: Transform, t2: Transform, t: f32) -> Transform {
+    let translation = t1.translation.lerp(t2.translation, t);
+    let rotation = t1.rotation.slerp(t2.rotation, t);
+    let scale = elerp(t1.scale, t2.scale, t);
+
+    Transform {
+        translation,
+        rotation,
+        scale,
+    }
+}
diff --git a/examples/gizmos/light_gizmos.rs b/examples/gizmos/light_gizmos.rs
new file mode 100644
index 0000000000000..e06b6c0e8dedd
--- /dev/null
+++ b/examples/gizmos/light_gizmos.rs
@@ -0,0 +1,190 @@
+//! This example demonstrates how to visualize lights properties through the gizmo API.
+
+use std::f32::consts::{FRAC_PI_2, PI};
+
+use bevy::{
+    color::palettes::css::{DARK_CYAN, GOLD, GRAY, PURPLE},
+    gizmos::light::{LightGizmoColor, LightGizmoConfigGroup},
+    prelude::*,
+};
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, setup)
+        .add_systems(Update, rotate_camera)
+        .add_systems(Update, update_config)
+        .run();
+}
+
+#[derive(Component)]
+struct GizmoColorText;
+
+fn gizmo_color_text(config: &LightGizmoConfigGroup) -> String {
+    match config.color {
+        LightGizmoColor::Manual(color) => format!("Manual {}", Srgba::from(color).to_hex()),
+        LightGizmoColor::Varied => "Random from entity".to_owned(),
+        LightGizmoColor::MatchLightColor => "Match light color".to_owned(),
+        LightGizmoColor::ByLightType => {
+            format!(
+                "Point {}, Spot {}, Directional {}",
+                Srgba::from(config.point_light_color).to_hex(),
+                Srgba::from(config.spot_light_color).to_hex(),
+                Srgba::from(config.directional_light_color).to_hex()
+            )
+        }
+    }
+}
+
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    mut config_store: ResMut<GizmoConfigStore>,
+) {
+    // Circular base.
+    commands.spawn(PbrBundle {
+        mesh: meshes.add(Circle::new(4.0)),
+        material: materials.add(Color::WHITE),
+        transform: Transform::from_rotation(Quat::from_rotation_x(-FRAC_PI_2)),
+        ..default()
+    });
+
+    // Cubes.
+    {
+        let mesh = meshes.add(Cuboid::new(1.0, 1.0, 1.0));
+        let material = materials.add(Color::srgb_u8(124, 144, 255));
+        for x in [-2.0, 0.0, 2.0] {
+            commands.spawn(PbrBundle {
+                mesh: mesh.clone(),
+                material: material.clone(),
+                transform: Transform::from_xyz(x, 0.5, 0.0),
+                ..default()
+            });
+        }
+    }
+
+    // Lights.
+    {
+        commands.spawn(PointLightBundle {
+            point_light: PointLight {
+                shadows_enabled: true,
+                range: 2.0,
+                color: DARK_CYAN.into(),
+                ..default()
+            },
+            transform: Transform::from_xyz(0.0, 1.5, 0.0),
+            ..default()
+        });
+        commands.spawn(SpotLightBundle {
+            spot_light: SpotLight {
+                shadows_enabled: true,
+                range: 3.5,
+                color: PURPLE.into(),
+                outer_angle: PI / 4.0,
+                inner_angle: PI / 4.0 * 0.8,
+                ..default()
+            },
+            transform: Transform::from_xyz(4.0, 2.0, 0.0).looking_at(Vec3::X * 1.5, Vec3::Y),
+            ..default()
+        });
+        commands.spawn(DirectionalLightBundle {
+            directional_light: DirectionalLight {
+                color: GOLD.into(),
+                illuminance: DirectionalLight::default().illuminance * 0.05,
+                shadows_enabled: true,
+                ..default()
+            },
+            transform: Transform::from_xyz(-4.0, 2.0, 0.0).looking_at(Vec3::NEG_X * 1.5, Vec3::Y),
+            ..default()
+        });
+    }
+
+    // Camera.
+    commands.spawn(Camera3dBundle {
+        transform: Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
+        ..default()
+    });
+
+    // Example instructions and gizmo config.
+    {
+        let text_style = TextStyle {
+            font_size: 20.0,
+            ..default()
+        };
+        commands.spawn(
+            TextBundle::from_section(
+                "Press 'D' to toggle drawing gizmos on top of everything else in the scene\n\
+            Hold 'Left' or 'Right' to change the line width of the gizmos\n\
+            Press 'A' to toggle drawing of the light gizmos\n\
+            Press 'C' to cycle between the light gizmos coloring modes",
+                text_style.clone(),
+            )
+            .with_style(Style {
+                position_type: PositionType::Absolute,
+                top: Val::Px(12.0),
+                left: Val::Px(12.0),
+                ..default()
+            }),
+        );
+
+        let (_, light_config) = config_store.config_mut::<LightGizmoConfigGroup>();
+        light_config.draw_all = true;
+        light_config.color = LightGizmoColor::MatchLightColor;
+
+        commands.spawn((
+            TextBundle::from_sections([
+                TextSection::new("Gizmo color mode: ", text_style.clone()),
+                TextSection::new(gizmo_color_text(light_config), text_style),
+            ])
+            .with_style(Style {
+                position_type: PositionType::Absolute,
+                bottom: Val::Px(12.0),
+                left: Val::Px(12.0),
+                ..default()
+            }),
+            GizmoColorText,
+        ));
+    }
+}
+
+fn rotate_camera(mut query: Query<&mut Transform, With<Camera>>, time: Res<Time>) {
+    let mut transform = query.single_mut();
+
+    transform.rotate_around(Vec3::ZERO, Quat::from_rotation_y(time.delta_seconds() / 2.));
+}
+
+fn update_config(
+    mut config_store: ResMut<GizmoConfigStore>,
+    keyboard: Res<ButtonInput<KeyCode>>,
+    time: Res<Time>,
+    mut color_text_query: Query<&mut Text, With<GizmoColorText>>,
+) {
+    if keyboard.just_pressed(KeyCode::KeyD) {
+        for (_, config, _) in config_store.iter_mut() {
+            config.depth_bias = if config.depth_bias == 0. { -1. } else { 0. };
+        }
+    }
+
+    let (config, light_config) = config_store.config_mut::<LightGizmoConfigGroup>();
+    if keyboard.pressed(KeyCode::ArrowRight) {
+        config.line_width += 5. * time.delta_seconds();
+        config.line_width = config.line_width.clamp(0., 50.);
+    }
+    if keyboard.pressed(KeyCode::ArrowLeft) {
+        config.line_width -= 5. * time.delta_seconds();
+        config.line_width = config.line_width.clamp(0., 50.);
+    }
+    if keyboard.just_pressed(KeyCode::KeyA) {
+        config.enabled ^= true;
+    }
+    if keyboard.just_pressed(KeyCode::KeyC) {
+        light_config.color = match light_config.color {
+            LightGizmoColor::Manual(_) => LightGizmoColor::Varied,
+            LightGizmoColor::Varied => LightGizmoColor::MatchLightColor,
+            LightGizmoColor::MatchLightColor => LightGizmoColor::ByLightType,
+            LightGizmoColor::ByLightType => LightGizmoColor::Manual(GRAY.into()),
+        };
+        color_text_query.single_mut().sections[1].value = gizmo_color_text(light_config);
+    }
+}
diff --git a/examples/mobile/.cargo/config.toml b/examples/mobile/.cargo/config.toml
deleted file mode 100644
index 27767cc6e1561..0000000000000
--- a/examples/mobile/.cargo/config.toml
+++ /dev/null
@@ -1,5 +0,0 @@
-# Flag to notify the compiler we're building for the iOS simulator from an Apple silicon mac
-# This needs some workarounds for now
-# See https://github.com/bevyengine/bevy/pull/10178 - remove if it's not needed anymore.
-[target.aarch64-apple-ios-sim]
-features = ["bevy_render/ios_simulator"]
diff --git a/examples/mobile/Cargo.toml b/examples/mobile/Cargo.toml
index 194970d0728c9..e1e768a2fcc75 100644
--- a/examples/mobile/Cargo.toml
+++ b/examples/mobile/Cargo.toml
@@ -13,6 +13,9 @@ crate-type = ["staticlib", "cdylib"]
 [dependencies]
 bevy = { path = "../../" }
 
+[target.aarch64-apple-ios-sim.dependencies]
+bevy = { path = "../../", features = ["ios_simulator"] }
+
 [package.metadata.android]
 package = "org.bevyengine.example"
 apk_name = "bevyexample"
diff --git a/examples/reflection/generic_reflection.rs b/examples/reflection/generic_reflection.rs
index 409d814c327d0..7a3d3917adae8 100644
--- a/examples/reflection/generic_reflection.rs
+++ b/examples/reflection/generic_reflection.rs
@@ -12,8 +12,10 @@ fn main() {
         .run();
 }
 
+/// The `#[derive(Reflect)]` macro will automatically add any required bounds to `T`,
+/// such as `Reflect` and `GetTypeRegistration`.
 #[derive(Reflect)]
-struct MyType<T: Reflect> {
+struct MyType<T> {
     value: T,
 }
 
diff --git a/examples/reflection/reflection.rs b/examples/reflection/reflection.rs
index 6033b41396f08..eef610e966f0f 100644
--- a/examples/reflection/reflection.rs
+++ b/examples/reflection/reflection.rs
@@ -16,8 +16,8 @@ use serde::de::DeserializeSeed;
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
+        // Bar will be automatically registered as it's a dependency of Foo
         .register_type::<Foo>()
-        .register_type::<Bar>()
         .add_systems(Startup, setup)
         .run();
 }
diff --git a/examples/stress_tests/bevymark.rs b/examples/stress_tests/bevymark.rs
index 3d40e6086ec30..f47065e5bd605 100644
--- a/examples/stress_tests/bevymark.rs
+++ b/examples/stress_tests/bevymark.rs
@@ -253,14 +253,14 @@ fn setup(
         .with_children(|c| {
             c.spawn((
                 TextBundle::from_sections([
-                    text_section(GREEN, "Bird Count: "),
-                    text_section(CYAN, ""),
-                    text_section(GREEN, "\nFPS (raw): "),
-                    text_section(CYAN, ""),
-                    text_section(GREEN, "\nFPS (SMA): "),
-                    text_section(CYAN, ""),
-                    text_section(GREEN, "\nFPS (EMA): "),
-                    text_section(CYAN, ""),
+                    text_section(LIME, "Bird Count: "),
+                    text_section(AQUA, ""),
+                    text_section(LIME, "\nFPS (raw): "),
+                    text_section(AQUA, ""),
+                    text_section(LIME, "\nFPS (SMA): "),
+                    text_section(AQUA, ""),
+                    text_section(LIME, "\nFPS (EMA): "),
+                    text_section(AQUA, ""),
                 ]),
                 StatsText,
             ));
@@ -368,11 +368,7 @@ fn spawn_birds(
     let bird_x = (primary_window_resolution.width() / -2.) + HALF_BIRD_SIZE;
     let bird_y = (primary_window_resolution.height() / 2.) - HALF_BIRD_SIZE;
 
-    let half_extents = 0.5
-        * Vec2::new(
-            primary_window_resolution.width(),
-            primary_window_resolution.height(),
-        );
+    let half_extents = 0.5 * primary_window_resolution.size();
 
     let color = counter.color;
     let current_count = counter.count;
@@ -509,7 +505,7 @@ fn handle_collision(half_extents: Vec2, translation: &Vec3, velocity: &mut Vec3)
 fn collision_system(windows: Query<&Window>, mut bird_query: Query<(&mut Bird, &Transform)>) {
     let window = windows.single();
 
-    let half_extents = 0.5 * Vec2::new(window.width(), window.height());
+    let half_extents = 0.5 * window.size();
 
     for (mut bird, transform) in &mut bird_query {
         handle_collision(half_extents, &transform.translation, &mut bird.velocity);
diff --git a/examples/stress_tests/many_animated_sprites.rs b/examples/stress_tests/many_animated_sprites.rs
index 3472e79b00be1..91f2e122d51a7 100644
--- a/examples/stress_tests/many_animated_sprites.rs
+++ b/examples/stress_tests/many_animated_sprites.rs
@@ -84,12 +84,8 @@ fn setup(
             timer.set_elapsed(Duration::from_secs_f32(rng.gen::<f32>()));
 
             commands.spawn((
-                SpriteSheetBundle {
+                SpriteBundle {
                     texture: texture_handle.clone(),
-                    atlas: TextureAtlas {
-                        layout: texture_atlas_handle.clone(),
-                        ..Default::default()
-                    },
                     transform: Transform {
                         translation,
                         rotation,
@@ -101,6 +97,7 @@ fn setup(
                     },
                     ..default()
                 },
+                TextureAtlas::from(texture_atlas_handle.clone()),
                 AnimationTimer(timer),
             ));
         }
diff --git a/examples/stress_tests/many_buttons.rs b/examples/stress_tests/many_buttons.rs
index abb314c657bb7..ae4d8c47e001a 100644
--- a/examples/stress_tests/many_buttons.rs
+++ b/examples/stress_tests/many_buttons.rs
@@ -97,18 +97,15 @@ fn main() {
 }
 
 #[derive(Component)]
-struct IdleColor(BackgroundColor);
+struct IdleColor(Color);
 
 fn button_system(
-    mut interaction_query: Query<
-        (&Interaction, &mut BackgroundColor, &IdleColor),
-        Changed<Interaction>,
-    >,
+    mut interaction_query: Query<(&Interaction, &mut UiImage, &IdleColor), Changed<Interaction>>,
 ) {
-    for (interaction, mut button_color, IdleColor(idle_color)) in interaction_query.iter_mut() {
-        *button_color = match interaction {
+    for (interaction, mut image, &IdleColor(idle_color)) in interaction_query.iter_mut() {
+        image.color = match interaction {
             Interaction::Hovered => ORANGE_RED.into(),
-            _ => *idle_color,
+            _ => idle_color,
         };
     }
 }
@@ -148,7 +145,7 @@ fn setup_flex(mut commands: Commands, asset_server: Res<AssetServer>, args: Res<
                     .spawn(NodeBundle::default())
                     .with_children(|commands| {
                         for row in 0..args.buttons {
-                            let color = as_rainbow(row % column.max(1)).into();
+                            let color = as_rainbow(row % column.max(1));
                             let border_color = Color::WHITE.with_alpha(0.5).into();
                             spawn_button(
                                 commands,
@@ -202,7 +199,7 @@ fn setup_grid(mut commands: Commands, asset_server: Res<AssetServer>, args: Res<
         .with_children(|commands| {
             for column in 0..args.buttons {
                 for row in 0..args.buttons {
-                    let color = as_rainbow(row % column.max(1)).into();
+                    let color = as_rainbow(row % column.max(1));
                     let border_color = Color::WHITE.with_alpha(0.5).into();
                     spawn_button(
                         commands,
@@ -226,7 +223,7 @@ fn setup_grid(mut commands: Commands, asset_server: Res<AssetServer>, args: Res<
 #[allow(clippy::too_many_arguments)]
 fn spawn_button(
     commands: &mut ChildBuilder,
-    background_color: BackgroundColor,
+    background_color: Color,
     buttons: f32,
     column: usize,
     row: usize,
@@ -249,7 +246,7 @@ fn spawn_button(
                 border,
                 ..default()
             },
-            background_color,
+            image: UiImage::default().with_color(background_color),
             border_color,
             ..default()
         },
diff --git a/examples/time/virtual_time.rs b/examples/time/virtual_time.rs
index 0e5fddd7d9f51..52cec835f8f95 100644
--- a/examples/time/virtual_time.rs
+++ b/examples/time/virtual_time.rs
@@ -146,7 +146,7 @@ fn move_real_time_sprites(
     for mut transform in sprite_query.iter_mut() {
         // move roughly half the screen in a `Real` second
         // when the time is scaled the speed is going to change
-        // and the sprite will stay still the the time is paused
+        // and the sprite will stay still the time is paused
         transform.translation.x = get_sprite_translation_x(time.elapsed_seconds());
     }
 }
diff --git a/examples/ui/borders.rs b/examples/ui/borders.rs
index b3654a4973a1c..3c8b49743eadf 100644
--- a/examples/ui/borders.rs
+++ b/examples/ui/borders.rs
@@ -23,7 +23,7 @@ fn setup(mut commands: Commands) {
                 align_content: AlignContent::FlexStart,
                 ..Default::default()
             },
-            background_color: DARK_GRAY.into(),
+            background_color: Color::srgb(0.25, 0.25, 0.25).into(),
             ..Default::default()
         })
         .id();
diff --git a/examples/ui/button.rs b/examples/ui/button.rs
index ef9c318fc2df3..c64a00ccbead9 100644
--- a/examples/ui/button.rs
+++ b/examples/ui/button.rs
@@ -19,33 +19,28 @@ const PRESSED_BUTTON: Color = Color::srgb(0.35, 0.75, 0.35);
 
 fn button_system(
     mut interaction_query: Query<
-        (
-            &Interaction,
-            &mut BackgroundColor,
-            &mut BorderColor,
-            &Children,
-        ),
+        (&Interaction, &mut UiImage, &mut BorderColor, &Children),
         (Changed<Interaction>, With<Button>),
     >,
     mut text_query: Query<&mut Text>,
 ) {
-    for (interaction, mut color, mut border_color, children) in &mut interaction_query {
+    for (interaction, mut image, mut border_color, children) in &mut interaction_query {
         let mut text = text_query.get_mut(children[0]).unwrap();
         match *interaction {
             Interaction::Pressed => {
                 text.sections[0].value = "Press".to_string();
-                *color = PRESSED_BUTTON.into();
+                image.color = PRESSED_BUTTON;
                 border_color.0 = RED.into();
             }
             Interaction::Hovered => {
                 text.sections[0].value = "Hover".to_string();
-                *color = HOVERED_BUTTON.into();
-                border_color.0 = WHITE.into();
+                image.color = HOVERED_BUTTON;
+                border_color.0 = Color::WHITE;
             }
             Interaction::None => {
                 text.sections[0].value = "Button".to_string();
-                *color = NORMAL_BUTTON.into();
-                border_color.0 = BLACK.into();
+                image.color = NORMAL_BUTTON;
+                border_color.0 = Color::BLACK;
             }
         }
     }
@@ -79,7 +74,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                         ..default()
                     },
                     border_color: BorderColor(Color::BLACK),
-                    background_color: NORMAL_BUTTON.into(),
+                    image: UiImage::default().with_color(NORMAL_BUTTON),
                     ..default()
                 })
                 .with_children(|parent| {
diff --git a/examples/ui/display_and_visibility.rs b/examples/ui/display_and_visibility.rs
index e481d46331948..d95e7b8c56cc2 100644
--- a/examples/ui/display_and_visibility.rs
+++ b/examples/ui/display_and_visibility.rs
@@ -417,7 +417,7 @@ where
                     padding: UiRect::axes(Val::Px(5.), Val::Px(1.)),
                     ..Default::default()
                 },
-                background_color: BackgroundColor(Color::BLACK.with_alpha(0.5)),
+                image: UiImage::default().with_color(Color::BLACK.with_alpha(0.5)),
                 ..Default::default()
             },
             Target::<T>::new(target),
@@ -461,13 +461,13 @@ fn buttons_handler<T>(
 }
 
 fn text_hover(
-    mut button_query: Query<(&Interaction, &mut BackgroundColor, &Children), Changed<Interaction>>,
+    mut button_query: Query<(&Interaction, &mut UiImage, &Children), Changed<Interaction>>,
     mut text_query: Query<&mut Text>,
 ) {
-    for (interaction, mut background_color, children) in button_query.iter_mut() {
+    for (interaction, mut image, children) in button_query.iter_mut() {
         match interaction {
             Interaction::Hovered => {
-                *background_color = BackgroundColor(Color::BLACK.with_alpha(0.6));
+                image.color = Color::BLACK.with_alpha(0.6);
                 for &child in children {
                     if let Ok(mut text) = text_query.get_mut(child) {
                         // Bypass change detection to avoid recomputation of the text when only changing the color
@@ -476,7 +476,7 @@ fn text_hover(
                 }
             }
             _ => {
-                *background_color = BackgroundColor(Color::BLACK.with_alpha(0.5));
+                image.color = Color::BLACK.with_alpha(0.5);
                 for &child in children {
                     if let Ok(mut text) = text_query.get_mut(child) {
                         text.bypass_change_detection().sections[0].style.color =
diff --git a/examples/ui/flex_layout.rs b/examples/ui/flex_layout.rs
index 650a5d1e1f5fc..8fff77b2d4e14 100644
--- a/examples/ui/flex_layout.rs
+++ b/examples/ui/flex_layout.rs
@@ -1,5 +1,5 @@
 //! Demonstrates how the `AlignItems` and `JustifyContent` properties can be composed to layout text.
-use bevy::{color::palettes::css::DARK_GRAY, prelude::*};
+use bevy::prelude::*;
 
 const ALIGN_ITEMS_COLOR: Color = Color::srgb(1., 0.066, 0.349);
 const JUSTIFY_CONTENT_COLOR: Color = Color::srgb(0.102, 0.522, 1.);
@@ -134,7 +134,7 @@ fn spawn_child_node(
                 height: Val::Percent(100.),
                 ..Default::default()
             },
-            background_color: BackgroundColor(DARK_GRAY.into()),
+            background_color: BackgroundColor(Color::srgb(0.25, 0.25, 0.25)),
             ..Default::default()
         })
         .with_children(|builder| {
diff --git a/examples/ui/grid.rs b/examples/ui/grid.rs
index 3d6d3895795f8..201912647bdf9 100644
--- a/examples/ui/grid.rs
+++ b/examples/ui/grid.rs
@@ -87,7 +87,7 @@ fn spawn_layout(mut commands: Commands, asset_server: Res<AssetServer>) {
                         column_gap: Val::Px(12.0),
                         ..default()
                     },
-                    background_color: BackgroundColor(DARK_GRAY.into()),
+                    background_color: BackgroundColor(Color::srgb(0.25, 0.25, 0.25)),
                     ..default()
                 })
                 .with_children(|builder| {
@@ -100,15 +100,15 @@ fn spawn_layout(mut commands: Commands, asset_server: Res<AssetServer>) {
                     item_rect(builder, BISQUE);
                     item_rect(builder, BLUE);
                     item_rect(builder, CRIMSON);
-        item_rect(builder, CYAN);
+                    item_rect(builder, AQUA);
                     item_rect(builder, ORANGE_RED);
                     item_rect(builder, DARK_GREEN);
                     item_rect(builder, FUCHSIA);
-        item_rect(builder, TEAL);
+                    item_rect(builder, TEAL);
                     item_rect(builder, ALICE_BLUE);
                     item_rect(builder, CRIMSON);
                     item_rect(builder, ANTIQUE_WHITE);
-        item_rect(builder, YELLOW);
+                    item_rect(builder, YELLOW);
                     item_rect(builder, PINK);
                     item_rect(builder, YELLOW_GREEN);
                     item_rect(builder, SALMON);
diff --git a/examples/ui/overflow.rs b/examples/ui/overflow.rs
index c58b39a04aa25..ca71f5a7f222f 100644
--- a/examples/ui/overflow.rs
+++ b/examples/ui/overflow.rs
@@ -61,7 +61,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                                     margin: UiRect::bottom(Val::Px(25.)),
                                     ..Default::default()
                                 },
-                                background_color: DARK_GRAY.into(),
+                                background_color: Color::srgb(0.25, 0.25, 0.25).into(),
                                 ..Default::default()
                             })
                             .with_children(|parent| {
@@ -95,8 +95,6 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                                             min_height: Val::Px(100.),
                                             ..Default::default()
                                         },
-                                        background_color: Color::WHITE.into(),
-
                                         ..Default::default()
                                     },
                                     Interaction::default(),
diff --git a/examples/ui/overflow_debug.rs b/examples/ui/overflow_debug.rs
index c9d5e4bb7431d..c0815962842ca 100644
--- a/examples/ui/overflow_debug.rs
+++ b/examples/ui/overflow_debug.rs
@@ -1,7 +1,5 @@
 //! Tests how different transforms behave when clipped with `Overflow::Hidden`
-use bevy::{
-    color::palettes::css::DARK_GRAY, input::common_conditions::input_just_pressed, prelude::*,
-};
+use bevy::{input::common_conditions::input_just_pressed, prelude::*};
 use std::f32::consts::{FRAC_PI_2, PI, TAU};
 
 const CONTAINER_SIZE: f32 = 150.0;
@@ -198,7 +196,7 @@ fn spawn_container(
                     overflow: Overflow::clip(),
                     ..default()
                 },
-                background_color: DARK_GRAY.into(),
+                background_color: Color::srgb(0.25, 0.25, 0.25).into(),
                 ..default()
             },
             Container(0),
diff --git a/examples/ui/size_constraints.rs b/examples/ui/size_constraints.rs
index 29e798a7a59d7..d32fe9734c698 100644
--- a/examples/ui/size_constraints.rs
+++ b/examples/ui/size_constraints.rs
@@ -245,12 +245,11 @@ fn spawn_button(
                     margin: UiRect::horizontal(Val::Px(2.)),
                     ..Default::default()
                 },
-                background_color: if active {
+                image: UiImage::default().with_color(if active {
                     ACTIVE_BORDER_COLOR
                 } else {
                     INACTIVE_BORDER_COLOR
-                }
-                .into(),
+                }),
                 ..Default::default()
             },
             constraint,
@@ -359,6 +358,7 @@ fn update_buttons(
 fn update_radio_buttons_colors(
     mut event_reader: EventReader<ButtonActivatedEvent>,
     button_query: Query<(Entity, &Constraint, &Interaction)>,
+    mut image_query: Query<&mut UiImage>,
     mut color_query: Query<&mut BackgroundColor>,
     mut text_query: Query<&mut Text>,
     children_query: Query<&Children>,
@@ -381,16 +381,12 @@ fn update_radio_buttons_colors(
                     )
                 };
 
-                color_query.get_mut(id).unwrap().0 = border_color;
-                if let Ok(children) = children_query.get(id) {
-                    for &child in children {
-                        color_query.get_mut(child).unwrap().0 = inner_color;
-                        if let Ok(grand_children) = children_query.get(child) {
-                            for &grandchild in grand_children {
-                                if let Ok(mut text) = text_query.get_mut(grandchild) {
-                                    text.sections[0].style.color = text_color;
-                                }
-                            }
+                image_query.get_mut(id).unwrap().color = border_color;
+                for &child in children_query.get(id).into_iter().flatten() {
+                    color_query.get_mut(child).unwrap().0 = inner_color;
+                    for &grandchild in children_query.get(child).into_iter().flatten() {
+                        if let Ok(mut text) = text_query.get_mut(grandchild) {
+                            text.sections[0].style.color = text_color;
                         }
                     }
                 }
diff --git a/examples/ui/text_debug.rs b/examples/ui/text_debug.rs
index 9ddc0d08bdfb3..c8f06d91c188f 100644
--- a/examples/ui/text_debug.rs
+++ b/examples/ui/text_debug.rs
@@ -170,7 +170,7 @@ fn infotext_system(mut commands: Commands, asset_server: Res<AssetServer>) {
                 TextSection::from_style(TextStyle {
                     font: font.clone(),
                     font_size: 25.0,
-                    color: GREEN.into(),
+                    color: LIME.into(),
                 }),
                 TextSection::new(
                     " ms/frame",
diff --git a/examples/ui/transparency_ui.rs b/examples/ui/transparency_ui.rs
index f83d2ba215c84..92c27059d5fc5 100644
--- a/examples/ui/transparency_ui.rs
+++ b/examples/ui/transparency_ui.rs
@@ -37,7 +37,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                         align_items: AlignItems::Center,
                         ..default()
                     },
-                    background_color: Color::srgb(0.1, 0.5, 0.1).into(),
+                    image: UiImage::default().with_color(Color::srgb(0.1, 0.5, 0.1)),
                     ..default()
                 })
                 .with_children(|parent| {
@@ -63,7 +63,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                         align_items: AlignItems::Center,
                         ..default()
                     },
-                    background_color: Color::srgb(0.5, 0.1, 0.5).into(),
+                    image: UiImage::default().with_color(Color::srgb(0.5, 0.1, 0.5)),
                     ..default()
                 })
                 .with_children(|parent| {
diff --git a/examples/ui/ui.rs b/examples/ui/ui.rs
index 14f541da67cba..3a314237af2a7 100644
--- a/examples/ui/ui.rs
+++ b/examples/ui/ui.rs
@@ -5,7 +5,7 @@ use bevy::{
         accesskit::{NodeBuilder, Role},
         AccessibilityNode,
     },
-    color::palettes::basic::GREEN,
+    color::palettes::basic::LIME,
     input::mouse::{MouseScrollUnit, MouseWheel},
     prelude::*,
     winit::WinitSettings,
@@ -166,7 +166,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                         border: UiRect::all(Val::Px(20.)),
                         ..default()
                     },
-                    border_color: GREEN.into(),
+                    border_color: LIME.into(),
                     background_color: Color::srgb(0.4, 0.4, 1.).into(),
                     ..default()
                 })
@@ -283,8 +283,6 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                                     margin: UiRect::top(Val::VMin(5.)),
                                     ..default()
                                 },
-                                // a `NodeBundle` is transparent by default, so to see the image we have to its color to `WHITE`
-                                background_color: Color::WHITE.into(),
                                 ..default()
                             },
                             UiImage::new(asset_server.load("branding/bevy_logo_dark_big.png")),
diff --git a/examples/ui/ui_texture_atlas.rs b/examples/ui/ui_texture_atlas.rs
index 1671b85c03ae5..a441b93364376 100644
--- a/examples/ui/ui_texture_atlas.rs
+++ b/examples/ui/ui_texture_atlas.rs
@@ -1,6 +1,6 @@
 //! This example illustrates how to use `TextureAtlases` within ui
 
-use bevy::{color::palettes::basic::YELLOW, prelude::*, winit::WinitSettings};
+use bevy::{color::palettes::css::*, prelude::*, winit::WinitSettings};
 
 fn main() {
     App::new()
@@ -49,16 +49,20 @@ fn setup(
             ..default()
         })
         .with_children(|parent| {
-            parent.spawn(AtlasImageBundle {
-                style: Style {
-                    width: Val::Px(256.),
-                    height: Val::Px(256.),
+            parent.spawn((
+                ImageBundle {
+                    style: Style {
+                        width: Val::Px(256.),
+                        height: Val::Px(256.),
+                        ..default()
+                    },
+                    image: UiImage::new(texture_handle),
                     ..default()
                 },
-                texture_atlas: texture_atlas_handle.into(),
-                image: UiImage::new(texture_handle),
-                ..default()
-            });
+                TextureAtlas::from(texture_atlas_handle),
+                BackgroundColor(ANTIQUE_WHITE.into()),
+                Outline::new(Val::Px(8.0), Val::ZERO, CRIMSON.into()),
+            ));
             parent.spawn(TextBundle::from_sections([
                 TextSection::new("press ".to_string(), text_style.clone()),
                 TextSection::new(
diff --git a/examples/ui/ui_texture_atlas_slice.rs b/examples/ui/ui_texture_atlas_slice.rs
new file mode 100644
index 0000000000000..77901211b7ed0
--- /dev/null
+++ b/examples/ui/ui_texture_atlas_slice.rs
@@ -0,0 +1,115 @@
+//! This example illustrates how to create buttons with their texture atlases sliced
+//! and kept in proportion instead of being stretched by the button dimensions
+
+use bevy::{
+    color::palettes::css::{GOLD, ORANGE},
+    prelude::*,
+    winit::WinitSettings,
+};
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        // Only run the app when there is user input. This will significantly reduce CPU/GPU use.
+        .insert_resource(WinitSettings::desktop_app())
+        .add_systems(Startup, setup)
+        .add_systems(Update, button_system)
+        .run();
+}
+
+fn button_system(
+    mut interaction_query: Query<
+        (&Interaction, &mut TextureAtlas, &Children, &mut UiImage),
+        (Changed<Interaction>, With<Button>),
+    >,
+    mut text_query: Query<&mut Text>,
+) {
+    for (interaction, mut atlas, children, mut image) in &mut interaction_query {
+        let mut text = text_query.get_mut(children[0]).unwrap();
+        match *interaction {
+            Interaction::Pressed => {
+                text.sections[0].value = "Press".to_string();
+                atlas.index = (atlas.index + 1) % 30;
+                image.color = GOLD.into();
+            }
+            Interaction::Hovered => {
+                text.sections[0].value = "Hover".to_string();
+                image.color = ORANGE.into();
+            }
+            Interaction::None => {
+                text.sections[0].value = "Button".to_string();
+                image.color = Color::WHITE;
+            }
+        }
+    }
+}
+
+fn setup(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut texture_atlases: ResMut<Assets<TextureAtlasLayout>>,
+) {
+    let texture_handle = asset_server.load("textures/fantasy_ui_borders/border_sheet.png");
+    let atlas_layout = TextureAtlasLayout::from_grid(UVec2::new(50, 50), 6, 6, None, None);
+    let atlas_layout_handle = texture_atlases.add(atlas_layout);
+
+    let slicer = TextureSlicer {
+        border: BorderRect::square(22.0),
+        center_scale_mode: SliceScaleMode::Stretch,
+        sides_scale_mode: SliceScaleMode::Stretch,
+        max_corner_scale: 1.0,
+    };
+    // ui camera
+    commands.spawn(Camera2dBundle::default());
+    commands
+        .spawn(NodeBundle {
+            style: Style {
+                width: Val::Percent(100.0),
+                height: Val::Percent(100.0),
+                align_items: AlignItems::Center,
+                justify_content: JustifyContent::Center,
+                ..default()
+            },
+            ..default()
+        })
+        .with_children(|parent| {
+            for (idx, [w, h]) in [
+                (0, [150.0, 150.0]),
+                (7, [300.0, 150.0]),
+                (13, [150.0, 300.0]),
+            ] {
+                parent
+                    .spawn((
+                        ButtonBundle {
+                            style: Style {
+                                width: Val::Px(w),
+                                height: Val::Px(h),
+                                // horizontally center child text
+                                justify_content: JustifyContent::Center,
+                                // vertically center child text
+                                align_items: AlignItems::Center,
+                                margin: UiRect::all(Val::Px(20.0)),
+                                ..default()
+                            },
+                            image: texture_handle.clone().into(),
+                            ..default()
+                        },
+                        ImageScaleMode::Sliced(slicer.clone()),
+                        TextureAtlas {
+                            index: idx,
+                            layout: atlas_layout_handle.clone(),
+                        },
+                    ))
+                    .with_children(|parent| {
+                        parent.spawn(TextBundle::from_section(
+                            "Button",
+                            TextStyle {
+                                font: asset_server.load("fonts/FiraSans-Bold.ttf"),
+                                font_size: 40.0,
+                                color: Color::srgb(0.9, 0.9, 0.9),
+                            },
+                        ));
+                    });
+            }
+        });
+}
diff --git a/examples/ui/ui_texture_slice.rs b/examples/ui/ui_texture_slice.rs
index 249602ff3db14..1f48a63b7c3e2 100644
--- a/examples/ui/ui_texture_slice.rs
+++ b/examples/ui/ui_texture_slice.rs
@@ -1,4 +1,4 @@
-//! This example illustrates how to create a button that has its image sliced
+//! This example illustrates how to create buttons with their textures sliced
 //! and kept in proportion instead of being stretched by the button dimensions
 
 use bevy::{
@@ -19,25 +19,25 @@ fn main() {
 
 fn button_system(
     mut interaction_query: Query<
-        (&Interaction, &Children, &mut BackgroundColor),
+        (&Interaction, &Children, &mut UiImage),
         (Changed<Interaction>, With<Button>),
     >,
     mut text_query: Query<&mut Text>,
 ) {
-    for (interaction, children, mut color) in &mut interaction_query {
+    for (interaction, children, mut image) in &mut interaction_query {
         let mut text = text_query.get_mut(children[0]).unwrap();
         match *interaction {
             Interaction::Pressed => {
                 text.sections[0].value = "Press".to_string();
-                color.0 = GOLD.into();
+                image.color = GOLD.into();
             }
             Interaction::Hovered => {
                 text.sections[0].value = "Hover".to_string();
-                color.0 = ORANGE.into();
+                image.color = ORANGE.into();
             }
             Interaction::None => {
                 text.sections[0].value = "Button".to_string();
-                color.0 = Color::WHITE;
+                image.color = Color::WHITE;
             }
         }
     }
@@ -81,8 +81,6 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                                 ..default()
                             },
                             image: image.clone().into(),
-                            // When combined with an image, this tints the image.
-                            background_color: Color::WHITE.into(),
                             ..default()
                         },
                         ImageScaleMode::Sliced(slicer.clone()),
diff --git a/examples/ui/viewport_debug.rs b/examples/ui/viewport_debug.rs
index 1a9271fb064a9..2c8a27167085f 100644
--- a/examples/ui/viewport_debug.rs
+++ b/examples/ui/viewport_debug.rs
@@ -7,7 +7,7 @@
 use bevy::{color::palettes::css::*, prelude::*};
 
 const PALETTE: [Srgba; 10] = [
-    RED, YELLOW, WHITE, BEIGE, CYAN, CRIMSON, NAVY, AZURE, GREEN, BLACK,
+    RED, YELLOW, WHITE, BEIGE, AQUA, CRIMSON, NAVY, AZURE, LIME, BLACK,
 ];
 
 #[derive(Component, Default, PartialEq)]
diff --git a/examples/ui/z_index.rs b/examples/ui/z_index.rs
index ac1239ef9265c..475af2d27c493 100644
--- a/examples/ui/z_index.rs
+++ b/examples/ui/z_index.rs
@@ -4,7 +4,7 @@
 //! depth of nodes compared to their siblings, but also compared to the entire UI.
 
 use bevy::{
-    color::palettes::basic::{BLUE, GRAY, GREEN, PURPLE, RED, YELLOW},
+    color::palettes::basic::{BLUE, GRAY, LIME, PURPLE, RED, YELLOW},
     prelude::*,
 };
 
@@ -79,7 +79,7 @@ fn setup(mut commands: Commands) {
                     // it will show under other nodes in the gray container.
                     parent.spawn(NodeBundle {
                         z_index: ZIndex::Local(-1),
-                        background_color: GREEN.into(),
+                        background_color: LIME.into(),
                         style: Style {
                             position_type: PositionType::Absolute,
                             left: Val::Px(70.0),
diff --git a/examples/wasm/index.html b/examples/wasm/index.html
index 0fa46de41877f..1688962669241 100644
--- a/examples/wasm/index.html
+++ b/examples/wasm/index.html
@@ -15,8 +15,6 @@
         background-size: 20px 20px;
       }
       canvas {
-        width: 100%;
-        height: 100%;
         background-color: white;
       }
     </style>
diff --git a/examples/window/low_power.rs b/examples/window/low_power.rs
index ace3e2fe5a1bc..f175167130399 100644
--- a/examples/window/low_power.rs
+++ b/examples/window/low_power.rs
@@ -93,7 +93,7 @@ fn update_winit(
 pub(crate) mod test_setup {
     use crate::ExampleMode;
     use bevy::{
-        color::palettes::basic::{GREEN, YELLOW},
+        color::palettes::basic::{LIME, YELLOW},
         prelude::*,
         window::RequestRedraw,
     };
@@ -181,7 +181,7 @@ pub(crate) mod test_setup {
                 ),
                 TextSection::from_style(TextStyle {
                     font_size: 50.0,
-                    color: GREEN.into(),
+                    color: LIME.into(),
                     ..default()
                 }),
                 TextSection::new(
diff --git a/examples/window/window_settings.rs b/examples/window/window_settings.rs
index 31ea347e64db6..2e509e2fba7eb 100644
--- a/examples/window/window_settings.rs
+++ b/examples/window/window_settings.rs
@@ -17,6 +17,8 @@ fn main() {
                     name: Some("bevy.app".into()),
                     resolution: (500., 300.).into(),
                     present_mode: PresentMode::AutoVsync,
+                    // Tells wasm to resize the window according to the available canvas
+                    fit_canvas_to_parent: true,
                     // Tells wasm not to override default event handling, like F5, Ctrl+R etc.
                     prevent_default_event_handling: false,
                     window_theme: Some(WindowTheme::Dark),
diff --git a/tools/build-wasm-example/src/main.rs b/tools/build-wasm-example/src/main.rs
index f121bd63c6d48..5ae1827db0c72 100644
--- a/tools/build-wasm-example/src/main.rs
+++ b/tools/build-wasm-example/src/main.rs
@@ -73,13 +73,10 @@ fn main() {
             parameters.push("--features");
             parameters.push(&features_string);
         }
-        let mut cmd = cmd!(
+        let cmd = cmd!(
             sh,
             "cargo build {parameters...} --profile release --target wasm32-unknown-unknown --example {example}"
         );
-        if matches!(cli.api, WebApi::Webgpu) {
-            cmd = cmd.env("RUSTFLAGS", "--cfg=web_sys_unstable_apis");
-        }
         cmd.run().expect("Error building example");
 
         cmd!(
diff --git a/tools/ci/src/main.rs b/tools/ci/src/main.rs
index 4f6886ad61cb0..617f96f7f7da8 100644
--- a/tools/ci/src/main.rs
+++ b/tools/ci/src/main.rs
@@ -1,11 +1,12 @@
 //! CI script used for Bevy.
 
-use xshell::{cmd, Shell};
-
 use bitflags::bitflags;
+use core::panic;
+use std::collections::BTreeMap;
+use xshell::{cmd, Cmd, Shell};
 
 bitflags! {
-    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
     struct Check: u32 {
         const FORMAT = 0b00000001;
         const CLIPPY = 0b00000010;
@@ -20,6 +21,29 @@ bitflags! {
     }
 }
 
+bitflags! {
+    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+    struct Flag: u32 {
+        const KEEP_GOING = 0b00000001;
+    }
+}
+
+// None of the CI tests require any information at runtime other than the options that have been set,
+// which is why all of these are 'static; we could easily update this to use more flexible types.
+struct CITest<'a> {
+    /// The command to execute
+    command: Cmd<'a>,
+
+    /// The message to display if the test command fails
+    failure_message: &'static str,
+
+    /// The subdirectory path to run the test command within
+    subdir: Option<&'static str>,
+
+    /// Environment variables that need to be set before the test runs
+    env_vars: Vec<(&'static str, &'static str)>,
+}
+
 fn main() {
     // When run locally, results may differ from actual CI runs triggered by
     // .github/workflows/ci.yml
@@ -44,125 +68,300 @@ fn main() {
         ("doc-test", Check::DOC_TEST),
     ];
 
-    let what_to_run = if let Some(arg) = std::env::args().nth(1).as_deref() {
-        if let Some((_, check)) = arguments.iter().find(|(str, _)| *str == arg) {
-            *check
-        } else {
-            println!(
-                "Invalid argument: {arg:?}.\nEnter one of: {}.",
-                arguments[1..]
-                    .iter()
-                    .map(|(s, _)| s)
-                    .fold(arguments[0].0.to_owned(), |c, v| c + ", " + v)
-            );
-            return;
+    let flag_arguments = [("--keep-going", Flag::KEEP_GOING)];
+
+    // Parameters are parsed disregarding their order. Note that the first arg is generally the name of
+    // the executable, so it is ignored. Any parameter may either be a flag or the name of a battery of tests
+    // to include.
+    let (mut checks, mut flags) = (Check::empty(), Flag::empty());
+    for arg in std::env::args().skip(1) {
+        if let Some((_, flag)) = flag_arguments.iter().find(|(flag_arg, _)| *flag_arg == arg) {
+            flags.insert(*flag);
+            continue;
         }
-    } else {
-        Check::all()
-    };
+        if let Some((_, check)) = arguments.iter().find(|(check_arg, _)| *check_arg == arg) {
+            // Note that this actually adds all of the constituent checks to the test suite.
+            checks.insert(*check);
+            continue;
+        }
+        // We encountered an invalid parameter:
+        println!(
+            "Invalid argument: {arg:?}.\n\
+            Valid parameters: {}.",
+            arguments[1..]
+                .iter()
+                .map(|(s, _)| s)
+                .chain(flag_arguments.iter().map(|(s, _)| s))
+                .fold(arguments[0].0.to_owned(), |c, v| c + ", " + v)
+        );
+        return;
+    }
+
+    // If no checks are specified, we run every check
+    if checks.is_empty() {
+        checks = Check::all();
+    }
 
     let sh = Shell::new().unwrap();
 
-    if what_to_run.contains(Check::FORMAT) {
+    // Each check contains a 'battery' (vector) that can include more than one command, but almost all of them
+    // just contain a single command.
+    let mut test_suite: BTreeMap<Check, Vec<CITest>> = BTreeMap::new();
+
+    if checks.contains(Check::FORMAT) {
         // See if any code needs to be formatted
-        cmd!(sh, "cargo fmt --all -- --check")
-            .run()
-            .expect("Please run 'cargo fmt --all' to format your code.");
+        test_suite.insert(
+            Check::FORMAT,
+            vec![CITest {
+                command: cmd!(sh, "cargo fmt --all -- --check"),
+                failure_message: "Please run 'cargo fmt --all' to format your code.",
+                subdir: None,
+                env_vars: vec![],
+            }],
+        );
     }
 
-    if what_to_run.contains(Check::CLIPPY) {
+    if checks.contains(Check::CLIPPY) {
         // See if clippy has any complaints.
         // - Type complexity must be ignored because we use huge templates for queries
-        cmd!(
-            sh,
-            "cargo clippy --workspace --all-targets --all-features -- -Dwarnings"
-        )
-        .run()
-        .expect("Please fix clippy errors in output above.");
-    }
-
-    if what_to_run.contains(Check::COMPILE_FAIL) {
-        {
-            // ECS Compile Fail Tests
-            // Run UI tests (they do not get executed with the workspace tests)
-            // - See crates/bevy_ecs_compile_fail_tests/README.md
-            let _subdir = sh.push_dir("crates/bevy_ecs_compile_fail_tests");
-            cmd!(sh, "cargo test --target-dir ../../target")
-                .run()
-                .expect("Compiler errors of the ECS compile fail tests seem to be different than expected! Check locally and compare rust versions.");
-        }
-        {
-            // Reflect Compile Fail Tests
-            // Run tests (they do not get executed with the workspace tests)
-            // - See crates/bevy_reflect_compile_fail_tests/README.md
-            let _subdir = sh.push_dir("crates/bevy_reflect_compile_fail_tests");
-            cmd!(sh, "cargo test --target-dir ../../target")
-                .run()
-                .expect("Compiler errors of the Reflect compile fail tests seem to be different than expected! Check locally and compare rust versions.");
-        }
-        {
-            // Macro Compile Fail Tests
-            // Run tests (they do not get executed with the workspace tests)
-            // - See crates/bevy_macros_compile_fail_tests/README.md
-            let _subdir = sh.push_dir("crates/bevy_macros_compile_fail_tests");
-            cmd!(sh, "cargo test --target-dir ../../target")
-                .run()
-                .expect("Compiler errors of the macros compile fail tests seem to be different than expected! Check locally and compare rust versions.");
+        test_suite.insert(
+            Check::CLIPPY,
+            vec![CITest {
+                command: cmd!(
+                    sh,
+                    "cargo clippy --workspace --all-targets --all-features -- -Dwarnings"
+                ),
+                failure_message: "Please fix clippy errors in output above.",
+                subdir: None,
+                env_vars: vec![],
+            }],
+        );
+    }
+
+    if checks.contains(Check::COMPILE_FAIL) {
+        let mut args = vec!["--target-dir", "../../target"];
+        if flags.contains(Flag::KEEP_GOING) {
+            args.push("--no-fail-fast");
         }
+
+        // ECS Compile Fail Tests
+        // Run UI tests (they do not get executed with the workspace tests)
+        // - See crates/bevy_ecs_compile_fail_tests/README.md
+
+        // (These must be cloned because of move semantics in `cmd!`)
+        let args_clone = args.clone();
+
+        test_suite.insert(Check::COMPILE_FAIL, vec![CITest {
+            command: cmd!(sh, "cargo test {args_clone...}"),
+            failure_message: "Compiler errors of the ECS compile fail tests seem to be different than expected! Check locally and compare rust versions.",
+            subdir: Some("crates/bevy_ecs_compile_fail_tests"),
+            env_vars: vec![],
+        }]);
+
+        // Reflect Compile Fail Tests
+        // Run tests (they do not get executed with the workspace tests)
+        // - See crates/bevy_reflect_compile_fail_tests/README.md
+        let args_clone = args.clone();
+
+        test_suite.entry(Check::COMPILE_FAIL).and_modify(|tests| tests.push( CITest {
+            command: cmd!(sh, "cargo test {args_clone...}"),
+            failure_message: "Compiler errors of the Reflect compile fail tests seem to be different than expected! Check locally and compare rust versions.",
+            subdir: Some("crates/bevy_reflect_compile_fail_tests"),
+            env_vars: vec![],
+        }));
+
+        // Macro Compile Fail Tests
+        // Run tests (they do not get executed with the workspace tests)
+        // - See crates/bevy_macros_compile_fail_tests/README.md
+        let args_clone = args.clone();
+
+        test_suite.entry(Check::COMPILE_FAIL).and_modify(|tests| tests.push( CITest {
+            command: cmd!(sh, "cargo test {args_clone...}"),
+            failure_message: "Compiler errors of the macros compile fail tests seem to be different than expected! Check locally and compare rust versions.",
+            subdir: Some("crates/bevy_macros_compile_fail_tests"),
+            env_vars: vec![],
+        }));
     }
 
-    if what_to_run.contains(Check::TEST) {
+    if checks.contains(Check::TEST) {
         // Run tests (except doc tests and without building examples)
-        cmd!(sh, "cargo test --workspace --lib --bins --tests --benches")
-            .run()
-            .expect("Please fix failing tests in output above.");
+        let mut args = vec!["--workspace", "--lib", "--bins", "--tests", "--benches"];
+        if flags.contains(Flag::KEEP_GOING) {
+            args.push("--no-fail-fast");
+        }
+
+        test_suite.insert(
+            Check::TEST,
+            vec![CITest {
+                command: cmd!(sh, "cargo test {args...}"),
+                failure_message: "Please fix failing tests in output above.",
+                subdir: None,
+                env_vars: vec![],
+            }],
+        );
     }
 
-    if what_to_run.contains(Check::DOC_TEST) {
+    if checks.contains(Check::DOC_TEST) {
         // Run doc tests
-        cmd!(sh, "cargo test --workspace --doc")
-            .run()
-            .expect("Please fix failing doc-tests in output above.");
+        let mut args = vec!["--workspace", "--doc"];
+        if flags.contains(Flag::KEEP_GOING) {
+            args.push("--no-fail-fast");
+        }
+
+        test_suite.insert(
+            Check::DOC_TEST,
+            vec![CITest {
+                command: cmd!(sh, "cargo test {args...}"),
+                failure_message: "Please fix failing doc-tests in output above.",
+                subdir: None,
+                env_vars: vec![],
+            }],
+        );
     }
 
-    if what_to_run.contains(Check::DOC_CHECK) {
+    if checks.contains(Check::DOC_CHECK) {
         // Check that building docs work and does not emit warnings
-        std::env::set_var("RUSTDOCFLAGS", "-D warnings");
-        cmd!(
-            sh,
-            "cargo doc --workspace --all-features --no-deps --document-private-items"
-        )
-        .run()
-        .expect("Please fix doc warnings in output above.");
+        let mut args = vec![
+            "--workspace",
+            "--all-features",
+            "--no-deps",
+            "--document-private-items",
+        ];
+        if flags.contains(Flag::KEEP_GOING) {
+            args.push("--keep-going");
+        }
+
+        test_suite.insert(
+            Check::DOC_CHECK,
+            vec![CITest {
+                command: cmd!(sh, "cargo doc {args...}"),
+                failure_message: "Please fix doc warnings in output above.",
+                subdir: None,
+                env_vars: vec![("RUSTDOCFLAGS", "-D warnings")],
+            }],
+        );
     }
 
-    if what_to_run.contains(Check::BENCH_CHECK) {
-        let _subdir = sh.push_dir("benches");
+    if checks.contains(Check::BENCH_CHECK) {
         // Check that benches are building
-        cmd!(sh, "cargo check --benches --target-dir ../target")
-            .run()
-            .expect("Failed to check the benches.");
+        let mut args = vec!["--benches", "--target-dir", "../target"];
+        if flags.contains(Flag::KEEP_GOING) {
+            args.push("--keep-going");
+        }
+
+        test_suite.insert(
+            Check::BENCH_CHECK,
+            vec![CITest {
+                command: cmd!(sh, "cargo check {args...}"),
+                failure_message: "Failed to check the benches.",
+                subdir: Some("benches"),
+                env_vars: vec![],
+            }],
+        );
     }
 
-    if what_to_run.contains(Check::EXAMPLE_CHECK) {
+    if checks.contains(Check::EXAMPLE_CHECK) {
         // Build examples and check they compile
-        cmd!(sh, "cargo check --workspace --examples")
-            .run()
-            .expect("Please fix compiler errors for examples in output above.");
+        let mut args = vec!["--workspace", "--examples"];
+        if flags.contains(Flag::KEEP_GOING) {
+            args.push("--keep-going");
+        }
+
+        test_suite.insert(
+            Check::EXAMPLE_CHECK,
+            vec![CITest {
+                command: cmd!(sh, "cargo check {args...}"),
+                failure_message: "Please fix compiler errors for examples in output above.",
+                subdir: None,
+                env_vars: vec![],
+            }],
+        );
     }
 
-    if what_to_run.contains(Check::COMPILE_CHECK) {
+    if checks.contains(Check::COMPILE_CHECK) {
         // Build bevy and check that it compiles
-        cmd!(sh, "cargo check --workspace")
-            .run()
-            .expect("Please fix compiler errors in output above.");
+        let mut args = vec!["--workspace"];
+        if flags.contains(Flag::KEEP_GOING) {
+            args.push("--keep-going");
+        }
+
+        test_suite.insert(
+            Check::COMPILE_CHECK,
+            vec![CITest {
+                command: cmd!(sh, "cargo check {args...}"),
+                failure_message: "Please fix compiler errors in output above.",
+                subdir: None,
+                env_vars: vec![],
+            }],
+        );
     }
 
-    if what_to_run.contains(Check::CFG_CHECK) {
+    if checks.contains(Check::CFG_CHECK) {
         // Check cfg and imports
-        std::env::set_var("RUSTFLAGS", "-D warnings");
-        cmd!(sh, "cargo +nightly check -Zcheck-cfg --workspace")
-            .run()
-            .expect("Please fix failing cfg checks in output above.");
+        let mut args = vec!["-Zcheck-cfg", "--workspace"];
+        if flags.contains(Flag::KEEP_GOING) {
+            args.push("--keep-going");
+        }
+
+        test_suite.insert(
+            Check::CFG_CHECK,
+            vec![CITest {
+                command: cmd!(sh, "cargo +nightly check {args...}"),
+                failure_message: "Please fix failing cfg checks in output above.",
+                subdir: None,
+                env_vars: vec![("RUSTFLAGS", "-D warnings")],
+            }],
+        );
+    }
+
+    // Actually run the tests:
+
+    let mut failed_checks: Check = Check::empty();
+    let mut failure_message: String = String::new();
+
+    // In KEEP_GOING-mode, we save all errors until the end; otherwise, we just
+    // panic with the given message for test failure.
+    fn fail(
+        current_check: Check,
+        failure_message: &'static str,
+        failed_checks: &mut Check,
+        existing_fail_message: &mut String,
+        flags: &Flag,
+    ) {
+        if flags.contains(Flag::KEEP_GOING) {
+            failed_checks.insert(current_check);
+            if !existing_fail_message.is_empty() {
+                existing_fail_message.push('\n');
+            }
+            existing_fail_message.push_str(failure_message);
+        } else {
+            panic!("{failure_message}");
+        }
+    }
+
+    for (check, battery) in test_suite {
+        for ci_test in battery {
+            // If the CI test is to be executed in a subdirectory, we move there before running the command
+            let _subdir_hook = ci_test.subdir.map(|path| sh.push_dir(path));
+
+            // Actually run the test, setting environment variables temporarily
+            if ci_test.command.envs(ci_test.env_vars).run().is_err() {
+                fail(
+                    check,
+                    ci_test.failure_message,
+                    &mut failed_checks,
+                    &mut failure_message,
+                    &flags,
+                );
+            }
+            // ^ This must run while `_subdir_hook` is in scope; it is dropped on loop iteration.
+        }
+    }
+
+    if !failed_checks.is_empty() {
+        panic!(
+            "One or more CI checks failed.\n\
+            {failure_message}"
+        );
     }
 }
diff --git a/tools/example-showcase/window-settings-wasm.patch b/tools/example-showcase/window-settings-wasm.patch
index 02e8965901869..5fcb1fba9556c 100644
--- a/tools/example-showcase/window-settings-wasm.patch
+++ b/tools/example-showcase/window-settings-wasm.patch
@@ -1,11 +1,13 @@
 diff --git a/crates/bevy_window/src/window.rs b/crates/bevy_window/src/window.rs
-index 7b5c75d38..8e9404b93 100644
+index 87cdfb050..1d87a0bf5 100644
 --- a/crates/bevy_window/src/window.rs
 +++ b/crates/bevy_window/src/window.rs
-@@ -245,8 +245,8 @@ impl Default for Window {
+@@ -266,9 +266,9 @@ impl Default for Window {
              transparent: false,
              focused: true,
              window_level: Default::default(),
+-            fit_canvas_to_parent: false,
++            fit_canvas_to_parent: true,
              prevent_default_event_handling: true,
 -            canvas: None,
 +            canvas: Some("#bevy".to_string()),
diff --git a/tools/publish.sh b/tools/publish.sh
index 3bb2f9b09cf24..d9b63ddde835b 100644
--- a/tools/publish.sh
+++ b/tools/publish.sh
@@ -41,6 +41,7 @@ crates=(
     bevy_a11y
     bevy_ui
     bevy_winit
+    bevy_dev_tools
     bevy_internal
     bevy_dylib
     bevy_color
diff --git a/typos.toml b/typos.toml
index 4e77918adcdfd..066195a7cf714 100644
--- a/typos.toml
+++ b/typos.toml
@@ -8,7 +8,6 @@ extend-exclude = [
 # and the value is the correct word. If the key and value are the same, the
 # word is treated as always correct. If the value is an empty string, the word
 # is treated as always incorrect.
-# the toi of the mountain
 
 # Match Whole Word - Case Sensitive
 [default.extend-identifiers]