diff --git a/CHANGELOG.md b/CHANGELOG.md
index ade264b8a6473f..f6f433f14e2fd7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,7 +7,689 @@ While we try to keep the `Unreleased` changes updated, it is often behind and do
 all merged pull requests. To see a list of all changes since the latest release, you may compare
 current changes on git with [previous release tags][git_tag_comparison].
 
-[git_tag_comparison]: https://github.com/bevyengine/bevy/compare/v0.9.0...main
+[git_tag_comparison]: https://github.com/bevyengine/bevy/compare/v0.10.0...main
+
+## Version 0.11.0 (2023-07-09)
+
+### Rendering
+
+- [Webgpu support][8336]
+- [improve shader import model][5703]
+- [Screen Space Ambient Occlusion (SSAO) MVP][7402]
+- [Temporal Antialiasing (TAA)][7291]
+- [Immediate Mode Line/Gizmo Drawing][6529]
+- [Make render graph slots optional for most cases][8109]
+- [Split opaque and transparent phases][8090]
+- [Built-in skybox][8275]
+- [Add parallax mapping to bevy PBR][5928]
+- [Add port of AMD's Robust Contrast Adaptive Sharpening][7422]
+- [Add RenderGraphApp to simplify adding render nodes][8007]
+- [Add screenshot api][7163]
+- [Add morph targets][8158]
+- [Screenshots in wasm][8455]
+- [Add ViewNode to simplify render node management][8118]
+- [Bias texture mipmaps][7614]
+- [Instanced line rendering for gizmos based on `bevy_polyline`][8427]
+- [Add `RenderTarget::TextureView`][8042]
+- [Change default tonemapping method][8685]
+- [Allow custom depth texture usage][6815]
+- [Use the prepass normal texture in main pass when possible][8231]
+- [Left-handed y-up cubemap coordinates][8122]
+- [Allow SPIR-V shaders to process when shader defs are present][7772]
+- [Remove unnecesssary values Vec from DynamicUniformBuffer and DynamicStorageBuffer][8299]
+- [Add `MAY_DISCARD` shader def, enabling early depth tests for most cases][6697]
+- [Add `Aabb` calculation for `Sprite`, `TextureAtlasSprite` and `Mesh2d`][7885]
+- [Color::Lcha constructors][8041]
+- [Fix Color::as_rgba_linear for Color::Lcha][8040]
+- [Added Globals struct to prepass shader][8070]
+- [Derive Copy and Clone for Collision][8121]
+- [Fix crash when enabling HDR on 2d cameras][8151]
+- [Dither fix][7977]
+- [Compute `vertex_count` for indexed meshes on `GpuMesh`][8460]
+- [Run update_previous_view_projections in PreUpdate schedule][9024]
+- [Added `WebP` image format support][8220]
+- [Add support for pnm textures][8601]
+- [fix invalid bone weights][8316]
+- [Fix pbr shader breaking on missing UVs][8412]
+- [Fix Plane UVs / texture flip][8878]
+- [Fix look_to resulting in NaN rotations][7817]
+- [Fix look_to variable naming][8627]
+- [Fix segfault with 2d gizmos][8223]
+- [Use RenderGraphApp in more places][8298]
+- [Fix viewport change detection][8323]
+- [Remove capacity fields from all Buffer wrapper types][8301]
+- [Sync pbr_types.wgsl StandardMaterial values][8380]
+- [Avoid spawning gizmo meshes when no gizmos are being drawn][8180]
+- [Use a consistent seed for AABB gizmo colors][9030]
+- [bevy_pbr: Do not cull meshes without Aabbs from cascades][8444]
+- [Handle vertex_uvs if they are present in default prepass fragment shader][8330]
+- [Changed (Vec2, Vec2) to Rect in Camera::logical_viewport_rect][7867]
+- [make glsl and spirv support optional][8491]
+- [fix prepass normal_mapping][8978]
+- [conversions between [u8; 4] and Color][8564]
+- [Add option to disable gizmo rendering for specific cameras][8952]
+- [Fix morph target prepass shader][9013]
+- [Fix bloom wasm support][8631]
+- [Fix black spots appearing due to NANs when SSAO is enabled][8926]
+- [fix normal prepass][8890]
+- [Refs #8975 -- Add return to RenderDevice::poll()][8977]
+- [Fix WebGL mode for Adreno GPUs][8508]
+- [Fix parallax mapping][9003]
+- [Added Vec append to BufferVec - Issue #3531][8575]
+- [Fix CAS shader with explicit FullscreenVertexOutput import][8993]
+- [Make `TextureAtlas::texture_handles` `pub` instead of `pub(crate)` (#8633)][8643]
+- [Make Material2d pipeline systems public][8642]
+- [Fix screenshots on Wayland + Nvidia][8701]
+- [Apply codebase changes in preparation for `StandardMaterial` transmission][8704]
+- [Use ViewNode for TAA][8732]
+- [Change Camera3dBundle::tonemapping to Default][8753]
+- [Remove `Component` derive for AlphaMode][8804]
+- [Make setup of Opaque3dPrepass and AlphaMask3dPrepass phase items consistent with others][8408]
+- [Rename `Plane` struct to `HalfSpace`][8744]
+- [Expand `FallbackImage` to include a `GpuImage` for each possible `TextureViewDimension`][6974]
+- [Cascaded shadow maps: Fix prepass ortho depth clamping][8877]
+- [Fix gizmos in WebGPU][8910]
+- [Fix AsBindGroup derive, texture attribute, visibility flag parsing][8868]
+- [Disable camera on window close][8802]
+- [Reflect `Component` and `Default` of `BloomSettings`][8283]
+- [Add Reflection Macros to TextureAtlasSprite][8428]
+- [Implement Reflect on NoFrustumCulling][8801]
+
+### Audio
+
+- [ECS-based API redesign][8424]
+- [Ability to set a Global Volume][7706]
+- [Expose `AudioSink::empty()`][8145]
+
+### Diagnostics
+
+- [Allow systems using Diagnostics to run in parallel][8677]
+- [add a feature for memory tracing with tracy][8272]
+- [Re-add the "frame" span for tracy comparisons][8362]
+- [log to stderr instead of stdout][8886]
+
+### Scenes
+
+- [bevy_scene: Add SceneFilter][6793]
+- [(De) serialize resources in scenes][6846]
+- [add position to scene errors][8065]
+- [Bugfix: Scene reload fix (nonbreaking)][7951]
+- [avoid panic with parented scenes on deleted entities][8512]
+
+### Transform + Hierarchy
+
+- [Fix transform propagation of orphaned entities][7264]
+
+### Gizmo
+
+- [Add a bounding box gizmo][8468]
+- [Added `arc_2d` function for gizmos][8448]
+- [Use AHash to get color from entity in bevy_gizmos][8960]
+- [do not crash when rendering only one gizmo][8434]
+
+### Reflection
+
+- [reflect: stable type path v2][7184]
+- [bevy_reflect: Better proxies][6971]
+- [bevy_reflect: FromReflect Ergonomics Implementation][6056]
+- [bevy_reflect: Allow `#[reflect(default)]` on enum variant fields][8514]
+- [Add FromReflect where Reflect is used][8776]
+- [Add get_at_mut to bevy_reflect::Map trait][8691]
+- [Reflect now requires DynamicTypePath. Remove Reflect::get_type_path()][8764]
+- [bevy_ui: Add `FromReflect` derives][8495]
+- [Add Reflect and FromReflect for AssetPath][8531]
+- [bevy_reflect: Fix trailing comma breaking derives][8014]
+- [Fix Box dyn Reflect struct with a hashmap in it panicking when clone_value is called on it][8184]
+- [bevy_reflect: Add `ReflectFromReflect` to the prelude][8496]
+- [bevy_reflect: Allow construction of MapIter outside of the bevy_reflect crate.][8723]
+- [bevy_reflect: Disambiguate type bounds in where clauses.][8761]
+- [adding reflection for Cow<'static, [T]>][7454]
+- [Do not require mut on ParsedPath::element_mut][8891]
+- [Reflect UUID][8905]
+- [Don't ignore additional entries in `UntypedReflectDeserializerVisitor`][7112]
+- [Construct Box dyn Reflect from world for ReflectComponent][7407]
+- [reflect: avoid deadlock in GenericTypeCell][8957]
+
+### App
+
+- [Allow tuples and single plugins in `add_plugins`, deprecate `add_plugin`][8097]
+- [Merge ScheduleRunnerSettings into ScheduleRunnerPlugin][8585]
+- [correctly setup everything in the default run_once runner][8740]
+- [Fix `Plugin::build` detection][8103]
+- [Fix not calling App::finish and App::cleanup in `ScheduleRunnerPlugin`][9054]
+- [Relaxed runner type from Fn to FnOnce][8961]
+- [Relax FnMut to FnOnce in app::edit_schedule][8982]
+
+### Windowing + Reflection
+
+- [Register missing types in bevy_window][7993]
+- [bevy_reflect: implement Reflect for SmolStr][8771]
+
+### Hierarchy
+
+- [fix panic when moving child][8346]
+- [Remove `Children` component when calling `despawn_descendants`][8476]
+- [Change `despawn_descendants` to return `&mut Self`][8928]
+
+### Time
+
+- [Fix timer with zero duration][8467]
+
+### Assets
+
+- [Delay asset hot reloading][8503]
+- [Add support for custom glTF vertex attributes.][5370]
+- [Fix panic when using debug_asset_server][8485]
+- [`unused_variables` warning when building with `filesystem_watcher` feature disabled][7938]
+- [bevy_asset: Add `LoadContext::get_handle_untyped`][8470]
+
+### Windowing
+
+- [Move cursor position to internal state][7988]
+- [Set cursor hittest during window creation][7966]
+- [do not set hit test unconditionally on window creation][7996]
+- [Add winit's `wayland-csd-adwaita` feature to Bevy's `wayland` feature][8722]
+- [Support to set window theme and expose system window theme changed event][8593]
+- [Touchpad magnify and rotate events][8791]
+- [Fix windows not being centered properly when system interface is scaled][8903]
+- [Expose WindowDestroyed events][9016]
+
+### Animation
+
+- [Register bevy_animation::PlayingAnimation][9023]
+
+### UI
+
+- [Ui Node Borders][7795]
+- [Add CSS Grid support to `bevy_ui`][8026]
+- [`text_system` split][7779]
+- [Replace the local text queues in the text systems with flags stored in a component][8549]
+- [`NoWrap` `Text` feature][8947]
+- [add a default font][8445]
+- [UI texture atlas support][8822]
+- [Improved UI render batching][8793]
+- [Consistent screen-space coordinates][8306]
+- [`UiImage` helper functions][8199]
+- [Perform text scaling calculations per text, not per glyph][7819]
+- [Fix size of clipped text glyphs.][8197]
+- [Apply scale factor to  `ImageMeasure` sizes][8545]
+- [Fix WebGPU error in "ui_pipeline" by adding a flat interpolate attribute][8933]
+- [Rename Interaction::Clicked -> Interaction::Pressed][9027]
+- [Flatten UI `Style` properties that use `Size` + remove `Size`][8548]
+- [Split UI `Overflow` by axis][8095]
+- [Add methods for calculating the size and postion of UI nodes][7930]
+- [Skip the UV calculations for untextured UI nodes][7809]
+- [Fix text measurement algorithm][8425]
+- [Divide by UiScale when converting UI coordinates from physical to logical][8720]
+- [`MeasureFunc` improvements][8402]
+- [Expose sorting methods in `Children`][8522]
+- [Fix min and max size using size value][7948]
+- [Fix the `Text2d` text anchor's incorrect horizontal alignment][8019]
+- [Remove `Val::Undefined`][7485]
+- [`Val` viewport unit variants][8137]
+- [Remove the corresponding measure from Taffy when a `CalculatedSize` component is removed.][8294]
+- [`UiRect` axes constructor][7656]
+- [Fix the UV calculations for clipped and flipped ImageNodes][8195]
+- [Fix text systems broken when resolving merge conflicts in #8026][8422]
+- [Allow `bevy_ui` crate to compile without the `text` feature enabled][8437]
+- [Fix the double leaf node updates in `flex_node_system`][8264]
+- [also import the default handle when feature disabled][8456]
+- [`measure_text_system` text query fix][8466]
+- [Fix panic in example: text_wrap_debug.rs][8497]
+- [UI layout tree debug print][8521]
+- [Fix `Node::physical_rect` and add a `physical_size` method][8551]
+- [Perform `relative_cursor_position` calculation vectorwise in `ui_focus_system`][8795]
+- [Add `UiRect::px()` and `UiRect::percent()` utils][8866]
+- [Add missing dependencies to `bevy_text` feature][8920]
+- [Remove "bevy_text" feature attributes on imports used by non-text systems][8907]
+- [Growing UI nodes Fix][8931]
+
+### ECS
+
+- [Schedule-First: the new and improved add_systems][8079]
+- [Add OnTransition schedule that is ran between OnExit and OnEnter][7936]
+- [`run_if` for `SystemConfigs` via anonymous system sets][7676]
+- [Remove OnUpdate system set][8260]
+- [Rename apply_system_buffers to apply_deferred][8726]
+- [Rename Command's "write" method to "apply"][8814]
+- [Require `#[derive(Event)]` on all Events][7086]
+- [Implement WorldQuery for EntityRef][6960]
+- [Improve or-with disjoint checks][7085]
+- [Add a method to run read-only systems using `&World`][8849]
+- [Reduce branching when inserting components][8053]
+- [Make `#[system_param(ignore)]` and `#[world_query(ignore)]` unnecessary][8030]
+- [Remove `#[system_param(ignore)]` and `#[world_query(ignore)]`][8265]
+- [Extend the `WorldQuery` macro to tuple structs][8119]
+- [Make state private and only accessible through getter for State resource][8009]
+- [implement `Deref` for `State<S>`][8668]
+- [Inline more ECS functions][8083]
+- [Add a `scope` API for world schedules][8387]
+- [Simplify system piping and make it more flexible][8377]
+- [Add `any_component_removed` condition][8326]
+- [Use `UnsafeWorldCell` to increase code quality for `SystemParam`][8174]
+- [Improve safety for the multi-threaded executor using `UnsafeWorldCell`][8292]
+- [Migrate the rest of the engine to `UnsafeWorldCell`][8833]
+- [Make the `Condition` trait generic][8721]
+- [Add or_else combinator to run_conditions.rs][8714]
+- [Add iter_many_manual QueryState method][8772]
+- [Provide access to world storages via UnsafeWorldCell][8987]
+- [Added Has T WorldQuery type][8844]
+- [Add/fix `track_caller` attribute on panicking entity accessor methods][8951]
+- [Increase type safety and clarity for change detection][7905]
+- [Make `WorldQuery` meta types unnameable][7964]
+- [Add a public constructor for `Mut<T>`][7931]
+- [Remove ChangeTrackers][7902]
+- [Derive Eq, PartialEq for Tick][9020]
+- [Initialize empty schedules when calling `.in_schedule` if they do not already exist][7911]
+- [Replace multiple calls to `add_system` with `add_systems`][8001]
+- [don't panic on unknown ambiguity][7950]
+- [add Clone to common conditions][8060]
+- [Make BundleInfo's fields not pub(crate)][8068]
+- [Pass query change ticks to `QueryParIter` instead of always using change ticks from `World`.][8029]
+- [Remove redundant bounds check in `Entities::get`][8108]
+- [Add World::try_run_schedule][8028]
+- [change not implemation to custom system struct][8105]
+- [Fix name conflicts caused by the `SystemParam` and `WorldQuery` macros][8012]
+- [Check for conflicting accesses in `assert_is_system`][8154]
+- [Fix field visibility for read-only `WorldQuery` types][8163]
+- [`Or<T>` should be a new type of `PhantomData<T>`][8212]
+- [Make standard commands more ergonomic (in niche cases)][8249]
+- [Remove base set error variants of `ScheduleBuildError`][8269]
+- [Replace some unsafe system executor code with safe code][8274]
+- [Update `increment_change_tick` to return a strongly-typed `Tick`][8295]
+- [Move event traces to detailed_trace!][7732]
+- [Only trigger state transitons if `next_state != old_state`][8359]
+- [Fix panics and docs when using World schedules][8364]
+- [Improve warning for Send resources marked as non_send][8000]
+- [Reorganize system modules][8419]
+- [Fix boxed labels][8436]
+- [Simplify world schedule methods][8403]
+- [Just print out name string, not the entire Name struct][8494]
+- [Manually implement common traits for `EventId`][8529]
+- [Replace remaining uses of `&T, Changed<T>` with `Ref` in UI system queries][8567]
+- [Rename `UnsafeWorldCell::read_change_tick`][8588]
+- [Improve encapsulation for commands and add docs][8725]
+- [Fix all_tuples + added docs.][8743]
+- [Add `new` and `map` methods to `Ref`][8797]
+- [Allow unsized types as mapped value in `Ref::map`][8817]
+- [Implement `Clone` for `CombinatorSystem`][8826]
+- [Add get_ref to EntityRef][8818]
+- [Make `QueryParIter::for_each_unchecked` private][8848]
+- [Simplify the `ComponentIdFor` type][8845]
+- [Add last_changed_tick and added_tick to ComponentTicks][8803]
+- [Require read-only queries in `QueryState::par_iter`][8832]
+- [Fix any_component_removed][8939]
+- [Deprecate type aliases for `WorldQuery::Fetch`][8843]
+- [bevy_ecs: add untyped methods for inserting components and bundles][7204]
+- [Move AppTypeRegistry to bevy_ecs][8901]
+- [skip check change tick for apply_deferred systems][8760]
+- [Split the bevy_ecs reflect.rs module][8834]
+- [Make function pointers of ecs Reflect* public][8687]
+
+### Rendering + Reflection + Scenes
+
+- [fix: register Cascade in the TypeRegistry][8088]
+
+### Tasks
+
+- [Add optional single-threaded feature to bevy_ecs/bevy_tasks][6690]
+
+### Math
+
+- [Re-export glam_assert feature][8232]
+- [Fix CubicCurve::iter_samples iteration count][8049]
+- [Add integer equivalents for `Rect`][7984]
+- [Add `CubicCurve::segment_count` + `iter_samples` adjustment][8711]
+
+### Rendering + Assets + Meta
+
+- [Add depending bevy features for higher level one][7855]
+
+### ECS + Scenes
+
+- [Make scene handling of entity references robust][7335]
+- [Rename map_entities and map_specific_entities][7570]
+
+### Util
+
+- [bevy_derive: Add `#[deref]` attribute][8552]
+
+### Input
+
+- [Add gamepad rumble support to bevy_input][8398]
+- [Rename keys like `LAlt` to `AltLeft`][8792]
+- [Add window entity to mouse and keyboard events][8852]
+- [Add get_unclamped to Axis][8871]
+
+### Upgrades
+
+- [Upgrade Taffy requirement to v0.3.5][7959]
+- [Update ruzstd and basis universal][8622]
+- [Updated to wgpu 0.16.0, wgpu-hal 0.16.0 and naga 0.12.0][8446]
+- [Update sysinfo requirement from 0.28.1 to 0.29.0][8650]
+- [Update libloading requirement from 0.7 to 0.8][8649]
+- [update syn, encase, glam and hexasphere][8573]
+- [Update android_log-sys requirement from 0.2.0 to 0.3.0][7925]
+- [update bitflags to 2.3][8728]
+- [Update ruzstd requirement from 0.3.1 to 0.4.0][8755]
+- [Update notify requirement from 5.0.0 to 6.0.0][8757]
+- [Bump hashbrown to 0.14][8904]
+- [update ahash and hashbrown][8623]
+- [Bump accesskit and accesskit_winit][8655]
+
+### Examples
+
+- [new example showcase tool][8561]
+- [Adding a bezier curve example][8194]
+- [Add low level post process example using a custom render pass][6909]
+- [Add example to demonstrate manual generation and UV mapping of 3D mesh (generate_custom_mesh) solve #4922][8909]
+- [Add `overflow_debug` example][8198]
+- [UI text wrapping and `LineBreakOn` example][7761]
+- [Size Constraints Example][7956]
+- [UI Display and Visibility Example][7629]
+
+[5370]: https://github.com/bevyengine/bevy/pull/5370
+[5703]: https://github.com/bevyengine/bevy/pull/5703
+[5928]: https://github.com/bevyengine/bevy/pull/5928
+[6529]: https://github.com/bevyengine/bevy/pull/6529
+[6697]: https://github.com/bevyengine/bevy/pull/6697
+[6815]: https://github.com/bevyengine/bevy/pull/6815
+[6846]: https://github.com/bevyengine/bevy/pull/6846
+[6909]: https://github.com/bevyengine/bevy/pull/6909
+[6960]: https://github.com/bevyengine/bevy/pull/6960
+[6971]: https://github.com/bevyengine/bevy/pull/6971
+[6974]: https://github.com/bevyengine/bevy/pull/6974
+[7085]: https://github.com/bevyengine/bevy/pull/7085
+[7086]: https://github.com/bevyengine/bevy/pull/7086
+[7112]: https://github.com/bevyengine/bevy/pull/7112
+[7163]: https://github.com/bevyengine/bevy/pull/7163
+[7184]: https://github.com/bevyengine/bevy/pull/7184
+[7204]: https://github.com/bevyengine/bevy/pull/7204
+[7264]: https://github.com/bevyengine/bevy/pull/7264
+[7291]: https://github.com/bevyengine/bevy/pull/7291
+[7335]: https://github.com/bevyengine/bevy/pull/7335
+[7402]: https://github.com/bevyengine/bevy/pull/7402
+[7407]: https://github.com/bevyengine/bevy/pull/7407
+[7422]: https://github.com/bevyengine/bevy/pull/7422
+[7454]: https://github.com/bevyengine/bevy/pull/7454
+[7485]: https://github.com/bevyengine/bevy/pull/7485
+[7570]: https://github.com/bevyengine/bevy/pull/7570
+[7614]: https://github.com/bevyengine/bevy/pull/7614
+[7629]: https://github.com/bevyengine/bevy/pull/7629
+[7656]: https://github.com/bevyengine/bevy/pull/7656
+[7676]: https://github.com/bevyengine/bevy/pull/7676
+[7706]: https://github.com/bevyengine/bevy/pull/7706
+[7732]: https://github.com/bevyengine/bevy/pull/7732
+[7761]: https://github.com/bevyengine/bevy/pull/7761
+[7772]: https://github.com/bevyengine/bevy/pull/7772
+[7779]: https://github.com/bevyengine/bevy/pull/7779
+[7795]: https://github.com/bevyengine/bevy/pull/7795
+[7809]: https://github.com/bevyengine/bevy/pull/7809
+[7817]: https://github.com/bevyengine/bevy/pull/7817
+[7819]: https://github.com/bevyengine/bevy/pull/7819
+[7855]: https://github.com/bevyengine/bevy/pull/7855
+[7867]: https://github.com/bevyengine/bevy/pull/7867
+[7885]: https://github.com/bevyengine/bevy/pull/7885
+[7902]: https://github.com/bevyengine/bevy/pull/7902
+[7905]: https://github.com/bevyengine/bevy/pull/7905
+[7911]: https://github.com/bevyengine/bevy/pull/7911
+[7925]: https://github.com/bevyengine/bevy/pull/7925
+[7930]: https://github.com/bevyengine/bevy/pull/7930
+[7931]: https://github.com/bevyengine/bevy/pull/7931
+[7936]: https://github.com/bevyengine/bevy/pull/7936
+[7938]: https://github.com/bevyengine/bevy/pull/7938
+[7948]: https://github.com/bevyengine/bevy/pull/7948
+[7950]: https://github.com/bevyengine/bevy/pull/7950
+[7951]: https://github.com/bevyengine/bevy/pull/7951
+[7956]: https://github.com/bevyengine/bevy/pull/7956
+[7959]: https://github.com/bevyengine/bevy/pull/7959
+[7964]: https://github.com/bevyengine/bevy/pull/7964
+[7966]: https://github.com/bevyengine/bevy/pull/7966
+[7977]: https://github.com/bevyengine/bevy/pull/7977
+[7984]: https://github.com/bevyengine/bevy/pull/7984
+[7988]: https://github.com/bevyengine/bevy/pull/7988
+[7993]: https://github.com/bevyengine/bevy/pull/7993
+[7996]: https://github.com/bevyengine/bevy/pull/7996
+[8000]: https://github.com/bevyengine/bevy/pull/8000
+[8001]: https://github.com/bevyengine/bevy/pull/8001
+[8007]: https://github.com/bevyengine/bevy/pull/8007
+[8009]: https://github.com/bevyengine/bevy/pull/8009
+[8012]: https://github.com/bevyengine/bevy/pull/8012
+[8014]: https://github.com/bevyengine/bevy/pull/8014
+[8019]: https://github.com/bevyengine/bevy/pull/8019
+[8026]: https://github.com/bevyengine/bevy/pull/8026
+[8028]: https://github.com/bevyengine/bevy/pull/8028
+[8029]: https://github.com/bevyengine/bevy/pull/8029
+[8030]: https://github.com/bevyengine/bevy/pull/8030
+[8040]: https://github.com/bevyengine/bevy/pull/8040
+[8041]: https://github.com/bevyengine/bevy/pull/8041
+[8042]: https://github.com/bevyengine/bevy/pull/8042
+[8049]: https://github.com/bevyengine/bevy/pull/8049
+[8053]: https://github.com/bevyengine/bevy/pull/8053
+[8060]: https://github.com/bevyengine/bevy/pull/8060
+[8065]: https://github.com/bevyengine/bevy/pull/8065
+[8068]: https://github.com/bevyengine/bevy/pull/8068
+[8070]: https://github.com/bevyengine/bevy/pull/8070
+[8079]: https://github.com/bevyengine/bevy/pull/8079
+[8083]: https://github.com/bevyengine/bevy/pull/8083
+[8088]: https://github.com/bevyengine/bevy/pull/8088
+[8090]: https://github.com/bevyengine/bevy/pull/8090
+[8095]: https://github.com/bevyengine/bevy/pull/8095
+[8097]: https://github.com/bevyengine/bevy/pull/8097
+[8103]: https://github.com/bevyengine/bevy/pull/8103
+[8105]: https://github.com/bevyengine/bevy/pull/8105
+[8108]: https://github.com/bevyengine/bevy/pull/8108
+[8109]: https://github.com/bevyengine/bevy/pull/8109
+[8118]: https://github.com/bevyengine/bevy/pull/8118
+[8119]: https://github.com/bevyengine/bevy/pull/8119
+[8121]: https://github.com/bevyengine/bevy/pull/8121
+[8122]: https://github.com/bevyengine/bevy/pull/8122
+[8137]: https://github.com/bevyengine/bevy/pull/8137
+[8145]: https://github.com/bevyengine/bevy/pull/8145
+[8151]: https://github.com/bevyengine/bevy/pull/8151
+[8154]: https://github.com/bevyengine/bevy/pull/8154
+[8158]: https://github.com/bevyengine/bevy/pull/8158
+[8163]: https://github.com/bevyengine/bevy/pull/8163
+[8174]: https://github.com/bevyengine/bevy/pull/8174
+[8180]: https://github.com/bevyengine/bevy/pull/8180
+[8184]: https://github.com/bevyengine/bevy/pull/8184
+[8194]: https://github.com/bevyengine/bevy/pull/8194
+[8195]: https://github.com/bevyengine/bevy/pull/8195
+[8197]: https://github.com/bevyengine/bevy/pull/8197
+[8198]: https://github.com/bevyengine/bevy/pull/8198
+[8199]: https://github.com/bevyengine/bevy/pull/8199
+[8212]: https://github.com/bevyengine/bevy/pull/8212
+[8220]: https://github.com/bevyengine/bevy/pull/8220
+[8223]: https://github.com/bevyengine/bevy/pull/8223
+[8231]: https://github.com/bevyengine/bevy/pull/8231
+[8232]: https://github.com/bevyengine/bevy/pull/8232
+[8249]: https://github.com/bevyengine/bevy/pull/8249
+[8260]: https://github.com/bevyengine/bevy/pull/8260
+[8264]: https://github.com/bevyengine/bevy/pull/8264
+[8265]: https://github.com/bevyengine/bevy/pull/8265
+[8269]: https://github.com/bevyengine/bevy/pull/8269
+[8272]: https://github.com/bevyengine/bevy/pull/8272
+[8274]: https://github.com/bevyengine/bevy/pull/8274
+[8275]: https://github.com/bevyengine/bevy/pull/8275
+[8283]: https://github.com/bevyengine/bevy/pull/8283
+[8292]: https://github.com/bevyengine/bevy/pull/8292
+[8294]: https://github.com/bevyengine/bevy/pull/8294
+[8295]: https://github.com/bevyengine/bevy/pull/8295
+[8298]: https://github.com/bevyengine/bevy/pull/8298
+[8299]: https://github.com/bevyengine/bevy/pull/8299
+[8301]: https://github.com/bevyengine/bevy/pull/8301
+[8306]: https://github.com/bevyengine/bevy/pull/8306
+[8316]: https://github.com/bevyengine/bevy/pull/8316
+[8323]: https://github.com/bevyengine/bevy/pull/8323
+[8326]: https://github.com/bevyengine/bevy/pull/8326
+[8330]: https://github.com/bevyengine/bevy/pull/8330
+[8336]: https://github.com/bevyengine/bevy/pull/8336
+[8346]: https://github.com/bevyengine/bevy/pull/8346
+[8359]: https://github.com/bevyengine/bevy/pull/8359
+[8362]: https://github.com/bevyengine/bevy/pull/8362
+[8364]: https://github.com/bevyengine/bevy/pull/8364
+[8377]: https://github.com/bevyengine/bevy/pull/8377
+[8380]: https://github.com/bevyengine/bevy/pull/8380
+[8387]: https://github.com/bevyengine/bevy/pull/8387
+[8398]: https://github.com/bevyengine/bevy/pull/8398
+[8402]: https://github.com/bevyengine/bevy/pull/8402
+[8403]: https://github.com/bevyengine/bevy/pull/8403
+[8408]: https://github.com/bevyengine/bevy/pull/8408
+[8412]: https://github.com/bevyengine/bevy/pull/8412
+[8419]: https://github.com/bevyengine/bevy/pull/8419
+[8422]: https://github.com/bevyengine/bevy/pull/8422
+[8425]: https://github.com/bevyengine/bevy/pull/8425
+[8427]: https://github.com/bevyengine/bevy/pull/8427
+[8428]: https://github.com/bevyengine/bevy/pull/8428
+[8434]: https://github.com/bevyengine/bevy/pull/8434
+[8436]: https://github.com/bevyengine/bevy/pull/8436
+[8437]: https://github.com/bevyengine/bevy/pull/8437
+[8444]: https://github.com/bevyengine/bevy/pull/8444
+[8445]: https://github.com/bevyengine/bevy/pull/8445
+[8446]: https://github.com/bevyengine/bevy/pull/8446
+[8448]: https://github.com/bevyengine/bevy/pull/8448
+[8455]: https://github.com/bevyengine/bevy/pull/8455
+[8456]: https://github.com/bevyengine/bevy/pull/8456
+[8460]: https://github.com/bevyengine/bevy/pull/8460
+[8466]: https://github.com/bevyengine/bevy/pull/8466
+[8467]: https://github.com/bevyengine/bevy/pull/8467
+[8468]: https://github.com/bevyengine/bevy/pull/8468
+[8470]: https://github.com/bevyengine/bevy/pull/8470
+[8476]: https://github.com/bevyengine/bevy/pull/8476
+[8485]: https://github.com/bevyengine/bevy/pull/8485
+[8491]: https://github.com/bevyengine/bevy/pull/8491
+[8494]: https://github.com/bevyengine/bevy/pull/8494
+[8495]: https://github.com/bevyengine/bevy/pull/8495
+[8496]: https://github.com/bevyengine/bevy/pull/8496
+[8497]: https://github.com/bevyengine/bevy/pull/8497
+[8503]: https://github.com/bevyengine/bevy/pull/8503
+[8512]: https://github.com/bevyengine/bevy/pull/8512
+[8514]: https://github.com/bevyengine/bevy/pull/8514
+[8521]: https://github.com/bevyengine/bevy/pull/8521
+[8522]: https://github.com/bevyengine/bevy/pull/8522
+[8529]: https://github.com/bevyengine/bevy/pull/8529
+[8531]: https://github.com/bevyengine/bevy/pull/8531
+[8545]: https://github.com/bevyengine/bevy/pull/8545
+[8548]: https://github.com/bevyengine/bevy/pull/8548
+[8549]: https://github.com/bevyengine/bevy/pull/8549
+[8551]: https://github.com/bevyengine/bevy/pull/8551
+[8552]: https://github.com/bevyengine/bevy/pull/8552
+[8561]: https://github.com/bevyengine/bevy/pull/8561
+[8564]: https://github.com/bevyengine/bevy/pull/8564
+[8567]: https://github.com/bevyengine/bevy/pull/8567
+[8573]: https://github.com/bevyengine/bevy/pull/8573
+[8575]: https://github.com/bevyengine/bevy/pull/8575
+[8585]: https://github.com/bevyengine/bevy/pull/8585
+[8588]: https://github.com/bevyengine/bevy/pull/8588
+[8593]: https://github.com/bevyengine/bevy/pull/8593
+[8601]: https://github.com/bevyengine/bevy/pull/8601
+[8622]: https://github.com/bevyengine/bevy/pull/8622
+[8623]: https://github.com/bevyengine/bevy/pull/8623
+[8627]: https://github.com/bevyengine/bevy/pull/8627
+[8631]: https://github.com/bevyengine/bevy/pull/8631
+[8642]: https://github.com/bevyengine/bevy/pull/8642
+[8643]: https://github.com/bevyengine/bevy/pull/8643
+[8649]: https://github.com/bevyengine/bevy/pull/8649
+[8650]: https://github.com/bevyengine/bevy/pull/8650
+[8668]: https://github.com/bevyengine/bevy/pull/8668
+[8677]: https://github.com/bevyengine/bevy/pull/8677
+[8685]: https://github.com/bevyengine/bevy/pull/8685
+[8687]: https://github.com/bevyengine/bevy/pull/8687
+[8691]: https://github.com/bevyengine/bevy/pull/8691
+[8701]: https://github.com/bevyengine/bevy/pull/8701
+[8704]: https://github.com/bevyengine/bevy/pull/8704
+[8711]: https://github.com/bevyengine/bevy/pull/8711
+[8714]: https://github.com/bevyengine/bevy/pull/8714
+[8721]: https://github.com/bevyengine/bevy/pull/8721
+[8722]: https://github.com/bevyengine/bevy/pull/8722
+[8723]: https://github.com/bevyengine/bevy/pull/8723
+[8725]: https://github.com/bevyengine/bevy/pull/8725
+[8726]: https://github.com/bevyengine/bevy/pull/8726
+[8728]: https://github.com/bevyengine/bevy/pull/8728
+[8732]: https://github.com/bevyengine/bevy/pull/8732
+[8740]: https://github.com/bevyengine/bevy/pull/8740
+[8743]: https://github.com/bevyengine/bevy/pull/8743
+[8744]: https://github.com/bevyengine/bevy/pull/8744
+[8753]: https://github.com/bevyengine/bevy/pull/8753
+[8755]: https://github.com/bevyengine/bevy/pull/8755
+[8757]: https://github.com/bevyengine/bevy/pull/8757
+[8760]: https://github.com/bevyengine/bevy/pull/8760
+[8761]: https://github.com/bevyengine/bevy/pull/8761
+[8764]: https://github.com/bevyengine/bevy/pull/8764
+[8771]: https://github.com/bevyengine/bevy/pull/8771
+[8772]: https://github.com/bevyengine/bevy/pull/8772
+[8776]: https://github.com/bevyengine/bevy/pull/8776
+[8791]: https://github.com/bevyengine/bevy/pull/8791
+[8792]: https://github.com/bevyengine/bevy/pull/8792
+[8793]: https://github.com/bevyengine/bevy/pull/8793
+[8795]: https://github.com/bevyengine/bevy/pull/8795
+[8797]: https://github.com/bevyengine/bevy/pull/8797
+[8801]: https://github.com/bevyengine/bevy/pull/8801
+[8802]: https://github.com/bevyengine/bevy/pull/8802
+[8803]: https://github.com/bevyengine/bevy/pull/8803
+[8804]: https://github.com/bevyengine/bevy/pull/8804
+[8814]: https://github.com/bevyengine/bevy/pull/8814
+[8817]: https://github.com/bevyengine/bevy/pull/8817
+[8818]: https://github.com/bevyengine/bevy/pull/8818
+[8822]: https://github.com/bevyengine/bevy/pull/8822
+[8826]: https://github.com/bevyengine/bevy/pull/8826
+[8832]: https://github.com/bevyengine/bevy/pull/8832
+[8833]: https://github.com/bevyengine/bevy/pull/8833
+[8834]: https://github.com/bevyengine/bevy/pull/8834
+[8843]: https://github.com/bevyengine/bevy/pull/8843
+[8844]: https://github.com/bevyengine/bevy/pull/8844
+[8845]: https://github.com/bevyengine/bevy/pull/8845
+[8848]: https://github.com/bevyengine/bevy/pull/8848
+[8849]: https://github.com/bevyengine/bevy/pull/8849
+[8852]: https://github.com/bevyengine/bevy/pull/8852
+[8866]: https://github.com/bevyengine/bevy/pull/8866
+[8868]: https://github.com/bevyengine/bevy/pull/8868
+[8871]: https://github.com/bevyengine/bevy/pull/8871
+[8877]: https://github.com/bevyengine/bevy/pull/8877
+[8878]: https://github.com/bevyengine/bevy/pull/8878
+[8886]: https://github.com/bevyengine/bevy/pull/8886
+[8890]: https://github.com/bevyengine/bevy/pull/8890
+[8891]: https://github.com/bevyengine/bevy/pull/8891
+[8901]: https://github.com/bevyengine/bevy/pull/8901
+[8903]: https://github.com/bevyengine/bevy/pull/8903
+[8904]: https://github.com/bevyengine/bevy/pull/8904
+[8905]: https://github.com/bevyengine/bevy/pull/8905
+[8907]: https://github.com/bevyengine/bevy/pull/8907
+[8909]: https://github.com/bevyengine/bevy/pull/8909
+[8910]: https://github.com/bevyengine/bevy/pull/8910
+[8920]: https://github.com/bevyengine/bevy/pull/8920
+[8928]: https://github.com/bevyengine/bevy/pull/8928
+[8933]: https://github.com/bevyengine/bevy/pull/8933
+[8939]: https://github.com/bevyengine/bevy/pull/8939
+[8947]: https://github.com/bevyengine/bevy/pull/8947
+[8951]: https://github.com/bevyengine/bevy/pull/8951
+[8960]: https://github.com/bevyengine/bevy/pull/8960
+[8957]: https://github.com/bevyengine/bevy/pull/8957
+[9054]: https://github.com/bevyengine/bevy/pull/9054
+[6690]: https://github.com/bevyengine/bevy/pull/6690
+[8424]: https://github.com/bevyengine/bevy/pull/8424
+[8655]: https://github.com/bevyengine/bevy/pull/8655
+[6793]: https://github.com/bevyengine/bevy/pull/6793
+[8720]: https://github.com/bevyengine/bevy/pull/8720
+[9024]: https://github.com/bevyengine/bevy/pull/9024
+[9027]: https://github.com/bevyengine/bevy/pull/9027
+[9016]: https://github.com/bevyengine/bevy/pull/9016
+[9023]: https://github.com/bevyengine/bevy/pull/9023
+[9020]: https://github.com/bevyengine/bevy/pull/9020
+[9030]: https://github.com/bevyengine/bevy/pull/9030
+[9013]: https://github.com/bevyengine/bevy/pull/9013
+[8926]: https://github.com/bevyengine/bevy/pull/8926
+[9003]: https://github.com/bevyengine/bevy/pull/9003
+[8993]: https://github.com/bevyengine/bevy/pull/8993
+[8508]: https://github.com/bevyengine/bevy/pull/8508
+[6056]: https://github.com/bevyengine/bevy/pull/6056
+[8987]: https://github.com/bevyengine/bevy/pull/8987
+[8952]: https://github.com/bevyengine/bevy/pull/8952
+[8961]: https://github.com/bevyengine/bevy/pull/8961
+[8978]: https://github.com/bevyengine/bevy/pull/8978
+[8982]: https://github.com/bevyengine/bevy/pull/8982
+[8977]: https://github.com/bevyengine/bevy/pull/8977
+[8931]: https://github.com/bevyengine/bevy/pull/8931
 
 ## Version 0.10.0 (2023-03-06)
 
diff --git a/Cargo.toml b/Cargo.toml
index 8e8f2f4997a655..8bb4836745adc2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 categories = ["game-engines", "graphics", "gui", "rendering"]
 description = "A refreshingly simple data-driven game engine and app framework"
@@ -44,6 +44,7 @@ default = [
   "bevy_sprite",
   "bevy_text",
   "bevy_ui",
+  "multi-threaded",
   "png",
   "hdr",
   "ktx2",
@@ -199,6 +200,9 @@ filesystem_watcher = ["bevy_internal/filesystem_watcher"]
 # Enable serialization support through serde
 serialize = ["bevy_internal/serialize"]
 
+# Enables multithreaded parallelism in the engine. Disabling it forces all engine tasks to run on a single thread.
+multi-threaded = ["bevy_internal/multi-threaded"]
+
 # Wayland display server support
 wayland = ["bevy_internal/wayland"]
 
@@ -245,8 +249,8 @@ shader_format_spirv = ["bevy_internal/shader_format_spirv"]
 webgl2 = ["bevy_internal/webgl"]
 
 [dependencies]
-bevy_dylib = { path = "crates/bevy_dylib", version = "0.11.0-dev", default-features = false, optional = true }
-bevy_internal = { path = "crates/bevy_internal", version = "0.11.0-dev", default-features = false }
+bevy_dylib = { path = "crates/bevy_dylib", version = "0.12.0-dev", default-features = false, optional = true }
+bevy_internal = { path = "crates/bevy_internal", version = "0.12.0-dev", default-features = false }
 
 [dev-dependencies]
 anyhow = "1.0.4"
diff --git a/README.md b/README.md
index 6a95c928449a9b..de605e96c52ecc 100644
--- a/README.md
+++ b/README.md
@@ -87,7 +87,7 @@ Bevy can be built just fine using default configuration on stable Rust. However
 
 Bevy is only possible because of the hard work put into these foundational technologies:
 
-* [wgpu](https://wgpu.rs/): modern / low-level / cross-platform graphics library inspired by Vulkan
+* [wgpu](https://wgpu.rs/): modern / low-level / cross-platform graphics library based on the [WebGPU](https://gpuweb.github.io/gpuweb/) API.
 * [glam-rs](https://github.com/bitshifter/glam-rs): a simple and fast 3D math library for games and graphics
 * [winit](https://github.com/rust-windowing/winit): cross-platform window creation and management in Rust
 
diff --git a/crates/bevy_a11y/Cargo.toml b/crates/bevy_a11y/Cargo.toml
index d4957d89c80de3..6a35a0e661a0e9 100644
--- a/crates/bevy_a11y/Cargo.toml
+++ b/crates/bevy_a11y/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_a11y"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides accessibility support for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,8 +10,8 @@ keywords = ["bevy", "accessibility", "a11y"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
 
-accesskit = "0.10"
+accesskit = "0.11"
diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index c888d51bb9cb7b..8e529b5171e20c 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_animation"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides animation functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,14 +10,14 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_core = { path = "../bevy_core", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_render = { path = "../bevy_render", version = "0.11.0-dev" }
-bevy_time = { path = "../bevy_time", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_core = { path = "../bevy_core", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_render = { path = "../bevy_render", version = "0.12.0-dev" }
+bevy_time = { path = "../bevy_time", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.12.0-dev" }
diff --git a/crates/bevy_app/Cargo.toml b/crates/bevy_app/Cargo.toml
index 89eec840c98e4c..27c866dba4b377 100644
--- a/crates/bevy_app/Cargo.toml
+++ b/crates/bevy_app/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_app"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides core App functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -16,11 +16,11 @@ bevy_reflect = ["dep:bevy_reflect", "bevy_ecs/bevy_reflect"]
 
 [dependencies]
 # bevy
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev", default-features = false }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", optional = true }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev", default-features = false }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", optional = true }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.12.0-dev" }
 
 # other
 serde = { version = "1.0", features = ["derive"], optional = true }
diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs
index a761eb151eb301..9b20116ad59138 100644
--- a/crates/bevy_app/src/app.rs
+++ b/crates/bevy_app/src/app.rs
@@ -1,4 +1,4 @@
-use crate::{First, Main, MainSchedulePlugin, Plugin, Plugins, Startup, StateTransition, Update};
+use crate::{First, Main, MainSchedulePlugin, Plugin, Plugins, StateTransition};
 pub use bevy_derive::AppLabel;
 use bevy_ecs::{
     prelude::*,
@@ -328,7 +328,7 @@ impl App {
 
     /// Adds [`State<S>`] and [`NextState<S>`] resources, [`OnEnter`] and [`OnExit`] schedules
     /// for each state variant (if they don't already exist), an instance of [`apply_state_transition::<S>`] in
-    /// [`StateTransition`] so that transitions happen before [`Update`] and
+    /// [`StateTransition`] so that transitions happen before [`Update`](crate::Update) and
     /// a instance of [`run_enter_schedule::<S>`] in [`StateTransition`] with a
     /// [`run_once`](`run_once_condition`) condition to run the on enter schedule of the
     /// initial state.
@@ -357,30 +357,6 @@ impl App {
         self
     }
 
-    /// Adds a system to the default system set and schedule of the app's [`Schedules`].
-    ///
-    /// Refer to the [system module documentation](bevy_ecs::system) to see how a system
-    /// can be defined.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use bevy_app::prelude::*;
-    /// # use bevy_ecs::prelude::*;
-    /// #
-    /// # fn my_system() {}
-    /// # let mut app = App::new();
-    /// #
-    /// app.add_system(my_system);
-    /// ```
-    #[deprecated(
-        since = "0.11.0",
-        note = "Please use `add_systems` instead. If you didn't change the default base set, you should use `add_systems(Update, your_system).`"
-    )]
-    pub fn add_system<M>(&mut self, system: impl IntoSystemConfigs<M>) -> &mut Self {
-        self.add_systems(Update, system)
-    }
-
     /// Adds a system to the given schedule in this app's [`Schedules`].
     ///
     /// # Examples
@@ -416,59 +392,6 @@ impl App {
         self
     }
 
-    /// Adds a system to [`Startup`].
-    ///
-    /// These systems will run exactly once, at the start of the [`App`]'s lifecycle.
-    /// To add a system that runs every frame, see [`add_system`](Self::add_system).
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use bevy_app::prelude::*;
-    /// # use bevy_ecs::prelude::*;
-    /// #
-    /// fn my_startup_system(_commands: Commands) {
-    ///     println!("My startup system");
-    /// }
-    ///
-    /// App::new()
-    ///     .add_systems(Startup, my_startup_system);
-    /// ```
-    #[deprecated(
-        since = "0.11.0",
-        note = "Please use `add_systems` instead. If you didn't change the default base set, you should use `add_systems(Startup, your_system).`"
-    )]
-    pub fn add_startup_system<M>(&mut self, system: impl IntoSystemConfigs<M>) -> &mut Self {
-        self.add_systems(Startup, system)
-    }
-
-    /// Adds a collection of systems to [`Startup`].
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use bevy_app::prelude::*;
-    /// # use bevy_ecs::prelude::*;
-    /// #
-    /// # let mut app = App::new();
-    /// # fn startup_system_a() {}
-    /// # fn startup_system_b() {}
-    /// # fn startup_system_c() {}
-    /// #
-    /// app.add_systems(Startup, (
-    ///     startup_system_a,
-    ///     startup_system_b,
-    ///     startup_system_c,
-    /// ));
-    /// ```
-    #[deprecated(
-        since = "0.11.0",
-        note = "Please use `add_systems` instead. If you didn't change the default base set, you should use `add_systems(Startup, your_system).`"
-    )]
-    pub fn add_startup_systems<M>(&mut self, systems: impl IntoSystemConfigs<M>) -> &mut Self {
-        self.add_systems(Startup, systems.into_configs())
-    }
-
     /// Configures a system set in the default schedule, adding the set if it does not exist.
     pub fn configure_set(
         &mut self,
@@ -656,43 +579,7 @@ impl App {
         self
     }
 
-    /// Adds a single [`Plugin`].
-    ///
-    /// One of Bevy's core principles is modularity. All Bevy engine features are implemented
-    /// as [`Plugin`]s. This includes internal features like the renderer.
-    ///
-    /// Bevy also provides a few sets of default [`Plugin`]s. See [`add_plugins`](Self::add_plugins).
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use bevy_app::prelude::*;
-    /// #
-    /// # // Dummies created to avoid using `bevy_log`,
-    /// # // which pulls in too many dependencies and breaks rust-analyzer
-    /// # pub mod bevy_log {
-    /// #     use bevy_app::prelude::*;
-    /// #     #[derive(Default)]
-    /// #     pub struct LogPlugin;
-    /// #     impl Plugin for LogPlugin{
-    /// #        fn build(&self, app: &mut App) {}
-    /// #     }
-    /// # }
-    /// App::new().add_plugin(bevy_log::LogPlugin::default());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// Panics if the plugin was already added to the application.
-    #[deprecated(since = "0.11.0", note = "Please use `add_plugins` instead.")]
-    pub fn add_plugin<T>(&mut self, plugin: T) -> &mut Self
-    where
-        T: Plugin,
-    {
-        self.add_plugins(plugin)
-    }
-
-    /// Boxed variant of [`add_plugin`](App::add_plugin) that can be used from a
+    /// Boxed variant of [`add_plugins`](App::add_plugins) that can be used from a
     /// [`PluginGroup`](super::PluginGroup)
     pub(crate) fn add_boxed_plugin(
         &mut self,
diff --git a/crates/bevy_app/src/main_schedule.rs b/crates/bevy_app/src/main_schedule.rs
index c940fda5337b97..194185c366ae7a 100644
--- a/crates/bevy_app/src/main_schedule.rs
+++ b/crates/bevy_app/src/main_schedule.rs
@@ -48,7 +48,7 @@ pub struct First;
 
 /// The schedule that contains logic that must run before [`Update`]. For example, a system that reads raw keyboard
 /// input OS events into an `Events` resource. This enables systems in [`Update`] to consume the events from the `Events`
-/// resource without actually knowing about (or taking a direct scheduler dependency on) the "os-level keyboard event sytsem".
+/// resource without actually knowing about (or taking a direct scheduler dependency on) the "os-level keyboard event system".
 ///
 /// [`PreUpdate`] exists to do "engine/plugin preparation work" that ensures the APIs consumed in [`Update`] are "ready".
 /// [`PreUpdate`] abstracts out "pre work implementation details".
diff --git a/crates/bevy_app/src/schedule_runner.rs b/crates/bevy_app/src/schedule_runner.rs
index c143f75c42f532..d303769f926960 100644
--- a/crates/bevy_app/src/schedule_runner.rs
+++ b/crates/bevy_app/src/schedule_runner.rs
@@ -71,6 +71,13 @@ impl Plugin for ScheduleRunnerPlugin {
     fn build(&self, app: &mut App) {
         let run_mode = self.run_mode;
         app.set_runner(move |mut app: App| {
+            while !app.ready() {
+                #[cfg(not(target_arch = "wasm32"))]
+                bevy_tasks::tick_global_task_pools_on_main_thread();
+            }
+            app.finish();
+            app.cleanup();
+
             let mut app_exit_event_reader = ManualEventReader::<AppExit>::default();
             match run_mode {
                 RunMode::Once => {
diff --git a/crates/bevy_asset/Cargo.toml b/crates/bevy_asset/Cargo.toml
index 995f974b1d957e..59c2b48aa58664 100644
--- a/crates/bevy_asset/Cargo.toml
+++ b/crates/bevy_asset/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_asset"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides asset functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -15,13 +15,13 @@ debug_asset_server = ["filesystem_watcher"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_diagnostic = { path = "../bevy_diagnostic", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_diagnostic = { path = "../bevy_diagnostic", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_log = { path = "../bevy_log", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_tasks = { path = "../bevy_tasks", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 
 # other
 serde = { version = "1", features = ["derive"] }
@@ -34,7 +34,7 @@ notify = { version = "6.0.0", optional = true }
 parking_lot = "0.12.1"
 
 [target.'cfg(target_os = "android")'.dependencies]
-bevy_winit = { path = "../bevy_winit", version = "0.11.0-dev" }
+bevy_winit = { path = "../bevy_winit", version = "0.12.0-dev" }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 wasm-bindgen = { version = "0.2" }
@@ -45,4 +45,4 @@ js-sys = "0.3"
 [dev-dependencies]
 futures-lite = "1.4.0"
 tempfile = "3.2.0"
-bevy_core = { path = "../bevy_core", version = "0.11.0-dev" }
+bevy_core = { path = "../bevy_core", version = "0.12.0-dev" }
diff --git a/crates/bevy_asset/src/assets.rs b/crates/bevy_asset/src/assets.rs
index b0587e95f32bf4..6669d9bc596329 100644
--- a/crates/bevy_asset/src/assets.rs
+++ b/crates/bevy_asset/src/assets.rs
@@ -559,7 +559,7 @@ mod tests {
         let mut app = App::new();
         app.add_plugins((
             bevy_core::TaskPoolPlugin::default(),
-            bevy_core::TypeRegistrationPlugin::default(),
+            bevy_core::TypeRegistrationPlugin,
             crate::AssetPlugin::default(),
         ));
         app.add_asset::<MyAsset>();
diff --git a/crates/bevy_asset/src/handle.rs b/crates/bevy_asset/src/handle.rs
index 035885862d7220..b0da1df00d45ca 100644
--- a/crates/bevy_asset/src/handle.rs
+++ b/crates/bevy_asset/src/handle.rs
@@ -40,6 +40,12 @@ impl<'a> From<AssetPath<'a>> for HandleId {
     }
 }
 
+impl<'a, 'b> From<&'a AssetPath<'b>> for HandleId {
+    fn from(value: &'a AssetPath<'b>) -> Self {
+        HandleId::AssetPathId(AssetPathId::from(value))
+    }
+}
+
 impl HandleId {
     /// Creates a random id for an asset of type `T`.
     #[inline]
@@ -390,7 +396,7 @@ impl HandleUntyped {
         Handle {
             handle_type,
             id: self.id,
-            marker: PhantomData::default(),
+            marker: PhantomData,
         }
     }
 }
diff --git a/crates/bevy_asset/src/loader.rs b/crates/bevy_asset/src/loader.rs
index a494fd0a2cc01f..6853ebf228df66 100644
--- a/crates/bevy_asset/src/loader.rs
+++ b/crates/bevy_asset/src/loader.rs
@@ -34,14 +34,16 @@ pub trait AssetLoader: Send + Sync + 'static {
 /// and scripts. In Bevy, an asset is any struct that has an unique type id, as shown below:
 ///
 /// ```rust
-/// use bevy_reflect::TypeUuid;
+/// use bevy_reflect::{TypePath, TypeUuid};
 /// use serde::Deserialize;
 ///
-/// #[derive(Debug, Deserialize, TypeUuid)]
+/// #[derive(Debug, Deserialize, TypeUuid, TypePath)]
 /// #[uuid = "39cadc56-aa9c-4543-8640-a018b74b5052"]
 /// pub struct CustomAsset {
 ///     pub value: i32,
 /// }
+/// # fn is_asset<T: bevy_asset::Asset>() {}
+/// # is_asset::<CustomAsset>();
 /// ```
 ///
 /// See the `assets/custom_asset.rs` example in the repository for more details.
diff --git a/crates/bevy_audio/Cargo.toml b/crates/bevy_audio/Cargo.toml
index 1c7e918640c0eb..53f3764777bb09 100644
--- a/crates/bevy_audio/Cargo.toml
+++ b/crates/bevy_audio/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_audio"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides audio functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,14 +10,14 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 
 # other
 anyhow = "1.0.4"
diff --git a/crates/bevy_audio/src/audio.rs b/crates/bevy_audio/src/audio.rs
index 0e17168f9b6a65..546e158e3f9061 100644
--- a/crates/bevy_audio/src/audio.rs
+++ b/crates/bevy_audio/src/audio.rs
@@ -1,256 +1,9 @@
-use crate::{AudioSink, AudioSource, Decodable, SpatialAudioSink};
-use bevy_asset::{Asset, Handle, HandleId};
+use crate::{AudioSource, Decodable};
+use bevy_asset::{Asset, Handle};
 use bevy_derive::{Deref, DerefMut};
-use bevy_ecs::system::Resource;
+use bevy_ecs::prelude::*;
 use bevy_math::Vec3;
 use bevy_transform::prelude::Transform;
-use parking_lot::RwLock;
-use std::{collections::VecDeque, fmt};
-
-/// Use this [`Resource`] to play audio.
-///
-/// ```
-/// # use bevy_ecs::system::Res;
-/// # use bevy_asset::AssetServer;
-/// # use bevy_audio::Audio;
-/// fn play_audio_system(asset_server: Res<AssetServer>, audio: Res<Audio>) {
-///     audio.play(asset_server.load("my_sound.ogg"));
-/// }
-/// ```
-#[derive(Resource)]
-pub struct Audio<Source = AudioSource>
-where
-    Source: Asset + Decodable,
-{
-    /// Queue for playing audio from asset handles
-    pub(crate) queue: RwLock<VecDeque<AudioToPlay<Source>>>,
-}
-
-impl<Source: Asset> fmt::Debug for Audio<Source>
-where
-    Source: Decodable,
-{
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("Audio").field("queue", &self.queue).finish()
-    }
-}
-
-impl<Source> Default for Audio<Source>
-where
-    Source: Asset + Decodable,
-{
-    fn default() -> Self {
-        Self {
-            queue: Default::default(),
-        }
-    }
-}
-
-impl<Source> Audio<Source>
-where
-    Source: Asset + Decodable,
-{
-    /// Play audio from a [`Handle`] to the audio source
-    ///
-    /// ```
-    /// # use bevy_ecs::system::Res;
-    /// # use bevy_asset::AssetServer;
-    /// # use bevy_audio::Audio;
-    /// fn play_audio_system(asset_server: Res<AssetServer>, audio: Res<Audio>) {
-    ///     audio.play(asset_server.load("my_sound.ogg"));
-    /// }
-    /// ```
-    ///
-    /// Returns a weak [`Handle`] to the [`AudioSink`]. If this handle isn't changed to a
-    /// strong one, the sink will be detached and the sound will continue playing. Changing it
-    /// to a strong handle allows you to control the playback through the [`AudioSink`] asset.
-    ///
-    /// ```
-    /// # use bevy_ecs::system::Res;
-    /// # use bevy_asset::{AssetServer, Assets};
-    /// # use bevy_audio::{Audio, AudioSink};
-    /// fn play_audio_system(
-    ///     asset_server: Res<AssetServer>,
-    ///     audio: Res<Audio>,
-    ///     audio_sinks: Res<Assets<AudioSink>>,
-    /// ) {
-    ///     // This is a weak handle, and can't be used to control playback.
-    ///     let weak_handle = audio.play(asset_server.load("my_sound.ogg"));
-    ///     // This is now a strong handle, and can be used to control playback.
-    ///     let strong_handle = audio_sinks.get_handle(weak_handle);
-    /// }
-    /// ```
-    pub fn play(&self, audio_source: Handle<Source>) -> Handle<AudioSink> {
-        let id = HandleId::random::<AudioSink>();
-        let config = AudioToPlay {
-            settings: PlaybackSettings::ONCE,
-            sink_handle: id,
-            source_handle: audio_source,
-            spatial: None,
-        };
-        self.queue.write().push_back(config);
-        Handle::<AudioSink>::weak(id)
-    }
-
-    /// Play audio from a [`Handle`] to the audio source with [`PlaybackSettings`] that
-    /// allows looping or changing volume from the start.
-    ///
-    /// ```
-    /// # use bevy_ecs::system::Res;
-    /// # use bevy_asset::AssetServer;
-    /// # use bevy_audio::{Audio, Volume};
-    /// # use bevy_audio::PlaybackSettings;
-    /// fn play_audio_system(asset_server: Res<AssetServer>, audio: Res<Audio>) {
-    ///     audio.play_with_settings(
-    ///         asset_server.load("my_sound.ogg"),
-    ///         PlaybackSettings::LOOP.with_volume(Volume::new_relative(0.75)),
-    ///     );
-    /// }
-    /// ```
-    ///
-    /// See [`Self::play`] on how to control playback once it's started.
-    pub fn play_with_settings(
-        &self,
-        audio_source: Handle<Source>,
-        settings: PlaybackSettings,
-    ) -> Handle<AudioSink> {
-        let id = HandleId::random::<AudioSink>();
-        let config = AudioToPlay {
-            settings,
-            sink_handle: id,
-            source_handle: audio_source,
-            spatial: None,
-        };
-        self.queue.write().push_back(config);
-        Handle::<AudioSink>::weak(id)
-    }
-
-    /// Play audio from a [`Handle`] to the audio source, placing the listener at the given
-    /// transform, an ear on each side separated by `gap`. The audio emitter will placed at
-    /// `emitter`.
-    ///
-    /// `bevy_audio` is not using HRTF for spatial audio, but is transforming the sound to a mono
-    /// track, and then changing the level of each stereo channel according to the distance between
-    /// the emitter and each ear by amplifying the difference between what the two ears hear.
-    ///
-    /// ```
-    /// # use bevy_ecs::system::Res;
-    /// # use bevy_asset::AssetServer;
-    /// # use bevy_audio::Audio;
-    /// # use bevy_math::Vec3;
-    /// # use bevy_transform::prelude::Transform;
-    /// fn play_spatial_audio_system(asset_server: Res<AssetServer>, audio: Res<Audio>) {
-    ///     // Sound will be to the left and behind the listener
-    ///     audio.play_spatial(
-    ///         asset_server.load("my_sound.ogg"),
-    ///         Transform::IDENTITY,
-    ///         1.0,
-    ///         Vec3::new(-2.0, 0.0, 1.0),
-    ///     );
-    /// }
-    /// ```
-    ///
-    /// Returns a weak [`Handle`] to the [`SpatialAudioSink`]. If this handle isn't changed to a
-    /// strong one, the sink will be detached and the sound will continue playing. Changing it
-    /// to a strong handle allows you to control the playback, or move the listener and emitter
-    /// through the [`SpatialAudioSink`] asset.
-    ///
-    /// ```
-    /// # use bevy_ecs::system::Res;
-    /// # use bevy_asset::{AssetServer, Assets};
-    /// # use bevy_audio::{Audio, SpatialAudioSink};
-    /// # use bevy_math::Vec3;
-    /// # use bevy_transform::prelude::Transform;
-    /// fn play_spatial_audio_system(
-    ///     asset_server: Res<AssetServer>,
-    ///     audio: Res<Audio>,
-    ///     spatial_audio_sinks: Res<Assets<SpatialAudioSink>>,
-    /// ) {
-    ///     // This is a weak handle, and can't be used to control playback.
-    ///     let weak_handle = audio.play_spatial(
-    ///         asset_server.load("my_sound.ogg"),
-    ///         Transform::IDENTITY,
-    ///         1.0,
-    ///         Vec3::new(-2.0, 0.0, 1.0),
-    ///     );
-    ///     // This is now a strong handle, and can be used to control playback, or move the emitter.
-    ///     let strong_handle = spatial_audio_sinks.get_handle(weak_handle);
-    /// }
-    /// ```
-    pub fn play_spatial(
-        &self,
-        audio_source: Handle<Source>,
-        listener: Transform,
-        gap: f32,
-        emitter: Vec3,
-    ) -> Handle<SpatialAudioSink> {
-        let id = HandleId::random::<SpatialAudioSink>();
-        let config = AudioToPlay {
-            settings: PlaybackSettings::ONCE,
-            sink_handle: id,
-            source_handle: audio_source,
-            spatial: Some(SpatialSettings {
-                left_ear: (listener.translation + listener.left() * gap / 2.0).to_array(),
-                right_ear: (listener.translation + listener.right() * gap / 2.0).to_array(),
-                emitter: emitter.to_array(),
-            }),
-        };
-        self.queue.write().push_back(config);
-        Handle::<SpatialAudioSink>::weak(id)
-    }
-
-    /// Play spatial audio from a [`Handle`] to the audio source with [`PlaybackSettings`] that
-    /// allows looping or changing volume from the start. The listener is placed at the given
-    /// transform, an ear on each side separated by `gap`. The audio emitter is placed at
-    /// `emitter`.
-    ///
-    /// `bevy_audio` is not using HRTF for spatial audio, but is transforming the sound to a mono
-    /// track, and then changing the level of each stereo channel according to the distance between
-    /// the emitter and each ear by amplifying the difference between what the two ears hear.
-    ///
-    /// ```
-    /// # use bevy_ecs::system::Res;
-    /// # use bevy_asset::AssetServer;
-    /// # use bevy_audio::{Audio, Volume};
-    /// # use bevy_audio::PlaybackSettings;
-    /// # use bevy_math::Vec3;
-    /// # use bevy_transform::prelude::Transform;
-    /// fn play_spatial_audio_system(asset_server: Res<AssetServer>, audio: Res<Audio>) {
-    ///     audio.play_spatial_with_settings(
-    ///         asset_server.load("my_sound.ogg"),
-    ///         PlaybackSettings::LOOP.with_volume(Volume::new_relative(0.75)),
-    ///         Transform::IDENTITY,
-    ///         1.0,
-    ///         Vec3::new(-2.0, 0.0, 1.0),
-    ///     );
-    /// }
-    /// ```
-    ///
-    /// See [`Self::play_spatial`] on how to control playback once it's started, or how to move
-    /// the listener or the emitter.
-    pub fn play_spatial_with_settings(
-        &self,
-        audio_source: Handle<Source>,
-        settings: PlaybackSettings,
-        listener: Transform,
-        gap: f32,
-        emitter: Vec3,
-    ) -> Handle<SpatialAudioSink> {
-        let id = HandleId::random::<SpatialAudioSink>();
-        let config = AudioToPlay {
-            settings,
-            sink_handle: id,
-            source_handle: audio_source,
-            spatial: Some(SpatialSettings {
-                left_ear: (listener.translation + listener.left() * gap / 2.0).to_array(),
-                right_ear: (listener.translation + listener.right() * gap / 2.0).to_array(),
-                emitter: emitter.to_array(),
-            }),
-        };
-        self.queue.write().push_back(config);
-        Handle::<SpatialAudioSink>::weak(id)
-    }
-}
 
 /// Defines the volume to play an audio source at.
 #[derive(Clone, Copy, Debug)]
@@ -278,7 +31,7 @@ impl Volume {
     }
 }
 
-/// A volume level equivalent to a positive only float.
+/// A volume level equivalent to a non-negative float.
 #[derive(Clone, Copy, Deref, DerefMut, Debug)]
 pub struct VolumeLevel(pub(crate) f32);
 
@@ -300,38 +53,83 @@ impl VolumeLevel {
     }
 }
 
-/// Settings to control playback from the start.
-#[derive(Clone, Copy, Debug)]
+/// How should Bevy manage the sound playback?
+#[derive(Debug, Clone, Copy)]
+pub enum PlaybackMode {
+    /// Play the sound once. Do nothing when it ends.
+    Once,
+    /// Repeat the sound forever.
+    Loop,
+    /// Despawn the entity when the sound finishes playing.
+    Despawn,
+    /// Remove the audio components from the entity, when the sound finishes playing.
+    Remove,
+}
+
+/// Initial settings to be used when audio starts playing.
+/// If you would like to control the audio while it is playing, query for the
+/// [`AudioSink`][crate::AudioSink] or [`SpatialAudioSink`][crate::SpatialAudioSink]
+/// components. Changes to this component will *not* be applied to already-playing audio.
+#[derive(Component, Clone, Copy, Debug)]
 pub struct PlaybackSettings {
-    /// Play in repeat
-    pub repeat: bool,
+    /// The desired playback behavior.
+    pub mode: PlaybackMode,
     /// Volume to play at.
     pub volume: Volume,
     /// Speed to play at.
     pub speed: f32,
+    /// Create the sink in paused state.
+    /// Useful for "deferred playback", if you want to prepare
+    /// the entity, but hear the sound later.
+    pub paused: bool,
 }
 
 impl Default for PlaybackSettings {
     fn default() -> Self {
+        // TODO: what should the default be: ONCE/DESPAWN/REMOVE?
         Self::ONCE
     }
 }
 
 impl PlaybackSettings {
-    /// Will play the associate audio source once.
+    /// Will play the associated audio source once.
     pub const ONCE: PlaybackSettings = PlaybackSettings {
-        repeat: false,
+        mode: PlaybackMode::Once,
         volume: Volume::Relative(VolumeLevel(1.0)),
         speed: 1.0,
+        paused: false,
     };
 
-    /// Will play the associate audio source in a loop.
+    /// Will play the associated audio source in a loop.
     pub const LOOP: PlaybackSettings = PlaybackSettings {
-        repeat: true,
+        mode: PlaybackMode::Loop,
         volume: Volume::Relative(VolumeLevel(1.0)),
         speed: 1.0,
+        paused: false,
     };
 
+    /// Will play the associated audio source once and despawn the entity afterwards.
+    pub const DESPAWN: PlaybackSettings = PlaybackSettings {
+        mode: PlaybackMode::Despawn,
+        volume: Volume::Relative(VolumeLevel(1.0)),
+        speed: 1.0,
+        paused: false,
+    };
+
+    /// Will play the associated audio source once and remove the audio components afterwards.
+    pub const REMOVE: PlaybackSettings = PlaybackSettings {
+        mode: PlaybackMode::Remove,
+        volume: Volume::Relative(VolumeLevel(1.0)),
+        speed: 1.0,
+        paused: false,
+    };
+
+    /// Helper to start in a paused state.
+    pub const fn paused(mut self) -> Self {
+        self.paused = true;
+        self
+    }
+
     /// Helper to set the volume from start of playback.
     pub const fn with_volume(mut self, volume: Volume) -> Self {
         self.volume = volume;
@@ -345,40 +143,35 @@ impl PlaybackSettings {
     }
 }
 
-#[derive(Clone)]
-pub(crate) struct SpatialSettings {
+/// Settings for playing spatial audio.
+///
+/// Note: Bevy does not currently support HRTF or any other high-quality 3D sound rendering
+/// features. Spatial audio is implemented via simple left-right stereo panning.
+#[derive(Component, Clone, Debug)]
+pub struct SpatialSettings {
     pub(crate) left_ear: [f32; 3],
     pub(crate) right_ear: [f32; 3],
     pub(crate) emitter: [f32; 3],
 }
 
-#[derive(Clone)]
-pub(crate) struct AudioToPlay<Source>
-where
-    Source: Asset + Decodable,
-{
-    pub(crate) sink_handle: HandleId,
-    pub(crate) source_handle: Handle<Source>,
-    pub(crate) settings: PlaybackSettings,
-    pub(crate) spatial: Option<SpatialSettings>,
-}
-
-impl<Source> fmt::Debug for AudioToPlay<Source>
-where
-    Source: Asset + Decodable,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("AudioToPlay")
-            .field("sink_handle", &self.sink_handle)
-            .field("source_handle", &self.source_handle)
-            .field("settings", &self.settings)
-            .finish()
+impl SpatialSettings {
+    /// Configure spatial audio coming from the `emitter` position and heard by a `listener`.
+    ///
+    /// The `listener` transform provides the position and rotation where the sound is to be
+    /// heard from. `gap` is the distance between the left and right "ears" of the listener.
+    /// `emitter` is the position where the sound comes from.
+    pub fn new(listener: Transform, gap: f32, emitter: Vec3) -> Self {
+        SpatialSettings {
+            left_ear: (listener.translation + listener.left() * gap / 2.0).to_array(),
+            right_ear: (listener.translation + listener.right() * gap / 2.0).to_array(),
+            emitter: emitter.to_array(),
+        }
     }
 }
 
 /// Use this [`Resource`] to control the global volume of all audio with a [`Volume::Relative`] volume.
 ///
-/// Keep in mind that changing this value will not affect already playing audio.
+/// Note: changing this value will not affect already playing audio.
 #[derive(Resource, Default, Clone, Copy)]
 pub struct GlobalVolume {
     /// The global volume of all audio.
@@ -393,3 +186,67 @@ impl GlobalVolume {
         }
     }
 }
+
+/// Bundle for playing a standard bevy audio asset
+pub type AudioBundle = AudioSourceBundle<AudioSource>;
+
+/// Bundle for playing a standard bevy audio asset with a 3D position
+pub type SpatialAudioBundle = SpatialAudioSourceBundle<AudioSource>;
+
+/// Bundle for playing a sound.
+///
+/// Insert this bundle onto an entity to trigger a sound source to begin playing.
+///
+/// If the handle refers to an unavailable asset (such as if it has not finished loading yet),
+/// the audio will not begin playing immediately. The audio will play when the asset is ready.
+///
+/// When Bevy begins the audio playback, an [`AudioSink`][crate::AudioSink] component will be
+/// added to the entity. You can use that component to control the audio settings during playback.
+#[derive(Bundle)]
+pub struct AudioSourceBundle<Source = AudioSource>
+where
+    Source: Asset + Decodable,
+{
+    /// Asset containing the audio data to play.
+    pub source: Handle<Source>,
+    /// Initial settings that the audio starts playing with.
+    /// If you would like to control the audio while it is playing,
+    /// query for the [`AudioSink`][crate::AudioSink] component.
+    /// Changes to this component will *not* be applied to already-playing audio.
+    pub settings: PlaybackSettings,
+}
+
+impl<T: Decodable + Asset> Default for AudioSourceBundle<T> {
+    fn default() -> Self {
+        Self {
+            source: Default::default(),
+            settings: Default::default(),
+        }
+    }
+}
+
+/// Bundle for playing a sound with a 3D position.
+///
+/// Insert this bundle onto an entity to trigger a sound source to begin playing.
+///
+/// If the handle refers to an unavailable asset (such as if it has not finished loading yet),
+/// the audio will not begin playing immediately. The audio will play when the asset is ready.
+///
+/// When Bevy begins the audio playback, a [`SpatialAudioSink`][crate::SpatialAudioSink]
+/// component will be added to the entity. You can use that component to control the audio
+/// settings during playback.
+#[derive(Bundle)]
+pub struct SpatialAudioSourceBundle<Source = AudioSource>
+where
+    Source: Asset + Decodable,
+{
+    /// Asset containing the audio data to play.
+    pub source: Handle<Source>,
+    /// Initial settings that the audio starts playing with.
+    /// If you would like to control the audio while it is playing,
+    /// query for the [`SpatialAudioSink`][crate::SpatialAudioSink] component.
+    /// Changes to this component will *not* be applied to already-playing audio.
+    pub settings: PlaybackSettings,
+    /// Spatial audio configuration. Specifies the positions of the source and listener.
+    pub spatial: SpatialSettings,
+}
diff --git a/crates/bevy_audio/src/audio_output.rs b/crates/bevy_audio/src/audio_output.rs
index a133f1fb0e1bd8..fd2173f6726d38 100644
--- a/crates/bevy_audio/src/audio_output.rs
+++ b/crates/bevy_audio/src/audio_output.rs
@@ -1,11 +1,11 @@
 use crate::{
-    Audio, AudioSource, Decodable, GlobalVolume, SpatialAudioSink, SpatialSettings, Volume,
+    AudioSourceBundle, Decodable, GlobalVolume, PlaybackMode, PlaybackSettings, SpatialAudioSink,
+    SpatialAudioSourceBundle, SpatialSettings, Volume,
 };
-use bevy_asset::{Asset, Assets};
-use bevy_ecs::system::{Res, ResMut, Resource};
+use bevy_asset::{Asset, Assets, Handle};
+use bevy_ecs::prelude::*;
 use bevy_utils::tracing::warn;
 use rodio::{OutputStream, OutputStreamHandle, Sink, Source, SpatialSink};
-use std::marker::PhantomData;
 
 use crate::AudioSink;
 
@@ -22,157 +22,227 @@ use crate::AudioSink;
 /// since the memory cost will be the same.
 /// However, repeatedly inserting this resource into the app will **leak more memory**.
 #[derive(Resource)]
-pub struct AudioOutput<Source = AudioSource>
-where
-    Source: Decodable,
-{
+pub(crate) struct AudioOutput {
     stream_handle: Option<OutputStreamHandle>,
-    phantom: PhantomData<Source>,
 }
 
-impl<Source> Default for AudioOutput<Source>
-where
-    Source: Decodable,
-{
+impl Default for AudioOutput {
     fn default() -> Self {
         if let Ok((stream, stream_handle)) = OutputStream::try_default() {
             // We leak `OutputStream` to prevent the audio from stopping.
             std::mem::forget(stream);
             Self {
                 stream_handle: Some(stream_handle),
-                phantom: PhantomData,
             }
         } else {
             warn!("No audio device found.");
             Self {
                 stream_handle: None,
-                phantom: PhantomData,
             }
         }
     }
 }
 
-impl<Source> AudioOutput<Source>
-where
-    Source: Asset + Decodable,
+/// Marker for internal use, to despawn entities when playback finishes.
+#[derive(Component)]
+pub struct PlaybackDespawnMarker;
+
+/// Marker for internal use, to remove audio components when playback finishes.
+#[derive(Component)]
+pub struct PlaybackRemoveMarker;
+
+/// Plays "queued" audio through the [`AudioOutput`] resource.
+///
+/// "Queued" audio is any audio entity (with the components from
+/// [`AudioBundle`][crate::AudioBundle] or [`SpatialAudioBundle`][crate::SpatialAudioBundle])
+/// that does not have an [`AudioSink`]/[`SpatialAudioSink`] component.
+///
+/// This system detects such entities, checks if their source asset
+/// data is available, and creates/inserts the sink.
+pub(crate) fn play_queued_audio_system<Source: Asset + Decodable>(
+    audio_output: Res<AudioOutput>,
+    audio_sources: Res<Assets<Source>>,
+    global_volume: Res<GlobalVolume>,
+    query_nonplaying: Query<
+        (
+            Entity,
+            &Handle<Source>,
+            &PlaybackSettings,
+            Option<&SpatialSettings>,
+        ),
+        (Without<AudioSink>, Without<SpatialAudioSink>),
+    >,
+    mut commands: Commands,
+) where
     f32: rodio::cpal::FromSample<Source::DecoderItem>,
 {
-    fn play_source(&self, audio_source: &Source, repeat: bool) -> Option<Sink> {
-        self.stream_handle
-            .as_ref()
-            .and_then(|stream_handle| match Sink::try_new(stream_handle) {
-                Ok(sink) => {
-                    if repeat {
-                        sink.append(audio_source.decoder().repeat_infinite());
-                    } else {
-                        sink.append(audio_source.decoder());
-                    }
-                    Some(sink)
-                }
-                Err(err) => {
-                    warn!("Error playing sound: {err:?}");
-                    None
-                }
-            })
-    }
+    let Some(stream_handle) = audio_output.stream_handle.as_ref() else {
+        // audio output unavailable; cannot play sound
+        return;
+    };
 
-    fn play_spatial_source(
-        &self,
-        audio_source: &Source,
-        repeat: bool,
-        spatial: SpatialSettings,
-    ) -> Option<SpatialSink> {
-        self.stream_handle.as_ref().and_then(|stream_handle| {
-            match SpatialSink::try_new(
-                stream_handle,
-                spatial.emitter,
-                spatial.left_ear,
-                spatial.right_ear,
-            ) {
-                Ok(sink) => {
-                    if repeat {
-                        sink.append(audio_source.decoder().repeat_infinite());
-                    } else {
-                        sink.append(audio_source.decoder());
+    for (entity, source_handle, settings, spatial) in &query_nonplaying {
+        if let Some(audio_source) = audio_sources.get(source_handle) {
+            // audio data is available (has loaded), begin playback and insert sink component
+            if let Some(spatial) = spatial {
+                match SpatialSink::try_new(
+                    stream_handle,
+                    spatial.emitter,
+                    spatial.left_ear,
+                    spatial.right_ear,
+                ) {
+                    Ok(sink) => {
+                        sink.set_speed(settings.speed);
+                        match settings.volume {
+                            Volume::Relative(vol) => {
+                                sink.set_volume(vol.0 * global_volume.volume.0);
+                            }
+                            Volume::Absolute(vol) => sink.set_volume(vol.0),
+                        }
+                        if settings.paused {
+                            sink.pause();
+                        }
+                        match settings.mode {
+                            PlaybackMode::Loop => {
+                                sink.append(audio_source.decoder().repeat_infinite());
+                                commands
+                                    .entity(entity)
+                                    .insert(SpatialAudioSink { sink: Some(sink) });
+                            }
+                            PlaybackMode::Once => {
+                                sink.append(audio_source.decoder());
+                                commands
+                                    .entity(entity)
+                                    .insert(SpatialAudioSink { sink: Some(sink) });
+                            }
+                            PlaybackMode::Despawn => {
+                                sink.append(audio_source.decoder());
+                                commands
+                                    .entity(entity)
+                                    // PERF: insert as bundle to reduce archetype moves
+                                    .insert((
+                                        SpatialAudioSink { sink: Some(sink) },
+                                        PlaybackDespawnMarker,
+                                    ));
+                            }
+                            PlaybackMode::Remove => {
+                                sink.append(audio_source.decoder());
+                                commands
+                                    .entity(entity)
+                                    // PERF: insert as bundle to reduce archetype moves
+                                    .insert((
+                                        SpatialAudioSink { sink: Some(sink) },
+                                        PlaybackRemoveMarker,
+                                    ));
+                            }
+                        };
+                    }
+                    Err(err) => {
+                        warn!("Error playing spatial sound: {err:?}");
                     }
-                    Some(sink)
-                }
-                Err(err) => {
-                    warn!("Error playing spatial sound: {err:?}");
-                    None
                 }
-            }
-        })
-    }
-
-    fn try_play_queued(
-        &self,
-        audio_sources: &Assets<Source>,
-        audio: &mut Audio<Source>,
-        sinks: &mut Assets<AudioSink>,
-        spatial_sinks: &mut Assets<SpatialAudioSink>,
-        global_volume: &GlobalVolume,
-    ) {
-        let mut queue = audio.queue.write();
-        let len = queue.len();
-        let mut i = 0;
-        while i < len {
-            let config = queue.pop_front().unwrap();
-            if let Some(audio_source) = audio_sources.get(&config.source_handle) {
-                if let Some(spatial) = config.spatial {
-                    if let Some(sink) =
-                        self.play_spatial_source(audio_source, config.settings.repeat, spatial)
-                    {
-                        sink.set_speed(config.settings.speed);
-                        match config.settings.volume {
+            } else {
+                match Sink::try_new(stream_handle) {
+                    Ok(sink) => {
+                        sink.set_speed(settings.speed);
+                        match settings.volume {
                             Volume::Relative(vol) => {
                                 sink.set_volume(vol.0 * global_volume.volume.0);
                             }
                             Volume::Absolute(vol) => sink.set_volume(vol.0),
                         }
-
-                        // don't keep the strong handle. there is no way to return it to the user here as it is async
-                        let _ = spatial_sinks
-                            .set(config.sink_handle, SpatialAudioSink { sink: Some(sink) });
+                        if settings.paused {
+                            sink.pause();
+                        }
+                        match settings.mode {
+                            PlaybackMode::Loop => {
+                                sink.append(audio_source.decoder().repeat_infinite());
+                                commands
+                                    .entity(entity)
+                                    .insert(AudioSink { sink: Some(sink) });
+                            }
+                            PlaybackMode::Once => {
+                                sink.append(audio_source.decoder());
+                                commands
+                                    .entity(entity)
+                                    .insert(AudioSink { sink: Some(sink) });
+                            }
+                            PlaybackMode::Despawn => {
+                                sink.append(audio_source.decoder());
+                                commands
+                                    .entity(entity)
+                                    // PERF: insert as bundle to reduce archetype moves
+                                    .insert((
+                                        AudioSink { sink: Some(sink) },
+                                        PlaybackDespawnMarker,
+                                    ));
+                            }
+                            PlaybackMode::Remove => {
+                                sink.append(audio_source.decoder());
+                                commands
+                                    .entity(entity)
+                                    // PERF: insert as bundle to reduce archetype moves
+                                    .insert((AudioSink { sink: Some(sink) }, PlaybackRemoveMarker));
+                            }
+                        };
                     }
-                } else if let Some(sink) = self.play_source(audio_source, config.settings.repeat) {
-                    sink.set_speed(config.settings.speed);
-
-                    match config.settings.volume {
-                        Volume::Relative(vol) => sink.set_volume(vol.0 * global_volume.volume.0),
-                        Volume::Absolute(vol) => sink.set_volume(vol.0),
+                    Err(err) => {
+                        warn!("Error playing sound: {err:?}");
                     }
-
-                    // don't keep the strong handle. there is no way to return it to the user here as it is async
-                    let _ = sinks.set(config.sink_handle, AudioSink { sink: Some(sink) });
                 }
-            } else {
-                // audio source hasn't loaded yet. add it back to the queue
-                queue.push_back(config);
             }
-            i += 1;
         }
     }
 }
 
-/// Plays audio currently queued in the [`Audio`] resource through the [`AudioOutput`] resource
-pub fn play_queued_audio_system<Source: Asset + Decodable>(
-    audio_output: Res<AudioOutput<Source>>,
-    audio_sources: Option<Res<Assets<Source>>>,
-    global_volume: Res<GlobalVolume>,
-    mut audio: ResMut<Audio<Source>>,
-    mut sinks: ResMut<Assets<AudioSink>>,
-    mut spatial_sinks: ResMut<Assets<SpatialAudioSink>>,
-) where
-    f32: rodio::cpal::FromSample<Source::DecoderItem>,
-{
-    if let Some(audio_sources) = audio_sources {
-        audio_output.try_play_queued(
-            &*audio_sources,
-            &mut *audio,
-            &mut sinks,
-            &mut spatial_sinks,
-            &global_volume,
-        );
-    };
+pub(crate) fn cleanup_finished_audio<T: Decodable + Asset>(
+    mut commands: Commands,
+    query_nonspatial_despawn: Query<
+        (Entity, &AudioSink),
+        (With<PlaybackDespawnMarker>, With<Handle<T>>),
+    >,
+    query_spatial_despawn: Query<
+        (Entity, &SpatialAudioSink),
+        (With<PlaybackDespawnMarker>, With<Handle<T>>),
+    >,
+    query_nonspatial_remove: Query<
+        (Entity, &AudioSink),
+        (With<PlaybackRemoveMarker>, With<Handle<T>>),
+    >,
+    query_spatial_remove: Query<
+        (Entity, &SpatialAudioSink),
+        (With<PlaybackRemoveMarker>, With<Handle<T>>),
+    >,
+) {
+    for (entity, sink) in &query_nonspatial_despawn {
+        if sink.sink.as_ref().unwrap().empty() {
+            commands.entity(entity).despawn();
+        }
+    }
+    for (entity, sink) in &query_spatial_despawn {
+        if sink.sink.as_ref().unwrap().empty() {
+            commands.entity(entity).despawn();
+        }
+    }
+    for (entity, sink) in &query_nonspatial_remove {
+        if sink.sink.as_ref().unwrap().empty() {
+            commands
+                .entity(entity)
+                .remove::<(AudioSourceBundle<T>, AudioSink, PlaybackRemoveMarker)>();
+        }
+    }
+    for (entity, sink) in &query_spatial_remove {
+        if sink.sink.as_ref().unwrap().empty() {
+            commands.entity(entity).remove::<(
+                SpatialAudioSourceBundle<T>,
+                SpatialAudioSink,
+                PlaybackRemoveMarker,
+            )>();
+        }
+    }
+}
+
+/// Run Condition to only play audio if the audio output is available
+pub(crate) fn audio_output_available(audio_output: Res<AudioOutput>) -> bool {
+    audio_output.stream_handle.is_some()
 }
diff --git a/crates/bevy_audio/src/lib.rs b/crates/bevy_audio/src/lib.rs
index 6544c789698fcc..11b3699096b394 100644
--- a/crates/bevy_audio/src/lib.rs
+++ b/crates/bevy_audio/src/lib.rs
@@ -1,8 +1,8 @@
 //! Audio support for the game engine Bevy
 //!
 //! ```no_run
-//! # use bevy_ecs::{system::Res, event::EventWriter};
-//! # use bevy_audio::{Audio, AudioPlugin};
+//! # use bevy_ecs::prelude::*;
+//! # use bevy_audio::{AudioBundle, AudioPlugin, PlaybackSettings};
 //! # use bevy_asset::{AssetPlugin, AssetServer};
 //! # use bevy_app::{App, AppExit, NoopPluginGroup as MinimalPlugins, Startup};
 //! fn main() {
@@ -12,8 +12,11 @@
 //!         .run();
 //! }
 //!
-//! fn play_background_audio(asset_server: Res<AssetServer>, audio: Res<Audio>) {
-//!     audio.play(asset_server.load("background_audio.ogg"));
+//! fn play_background_audio(asset_server: Res<AssetServer>, mut commands: Commands) {
+//!     commands.spawn(AudioBundle {
+//!         source: asset_server.load("background_audio.ogg"),
+//!         settings: PlaybackSettings::LOOP,
+//!     });
 //! }
 //! ```
 
@@ -30,13 +33,13 @@ mod sinks;
 pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
-        Audio, AudioOutput, AudioSink, AudioSinkPlayback, AudioSource, Decodable, GlobalVolume,
-        PlaybackSettings, SpatialAudioSink,
+        AudioBundle, AudioSink, AudioSinkPlayback, AudioSource, AudioSourceBundle, Decodable,
+        GlobalVolume, PlaybackSettings, SpatialAudioBundle, SpatialAudioSink,
+        SpatialAudioSourceBundle, SpatialSettings,
     };
 }
 
 pub use audio::*;
-pub use audio_output::*;
 pub use audio_source::*;
 
 pub use rodio::cpal::Sample as CpalSample;
@@ -46,28 +49,34 @@ pub use sinks::*;
 
 use bevy_app::prelude::*;
 use bevy_asset::{AddAsset, Asset};
+use bevy_ecs::prelude::*;
+
+use audio_output::*;
+
+/// Set for the audio playback systems, so they can share a run condition
+#[derive(SystemSet, Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
+struct AudioPlaySet;
 
 /// Adds support for audio playback to a Bevy Application
 ///
-/// Use the [`Audio`] resource to play audio.
+/// Insert an [`AudioBundle`] or [`SpatialAudioBundle`] onto your entities to play audio.
 #[derive(Default)]
 pub struct AudioPlugin {
-    /// The global volume for all audio sources with a [`Volume::Relative`] volume.
+    /// The global volume for all audio entities with a [`Volume::Relative`] volume.
     pub global_volume: GlobalVolume,
 }
 
 impl Plugin for AudioPlugin {
     fn build(&self, app: &mut App) {
-        app.init_resource::<AudioOutput<AudioSource>>()
-            .add_asset::<AudioSource>()
-            .add_asset::<AudioSink>()
-            .add_asset::<SpatialAudioSink>()
-            .init_resource::<Audio<AudioSource>>()
-            .insert_resource(self.global_volume)
-            .add_systems(PostUpdate, play_queued_audio_system::<AudioSource>);
+        app.insert_resource(self.global_volume)
+            .configure_set(PostUpdate, AudioPlaySet.run_if(audio_output_available))
+            .init_resource::<AudioOutput>();
 
         #[cfg(any(feature = "mp3", feature = "flac", feature = "wav", feature = "vorbis"))]
-        app.init_asset_loader::<AudioLoader>();
+        {
+            app.add_audio_source::<AudioSource>();
+            app.init_asset_loader::<AudioLoader>();
+        }
     }
 }
 
@@ -77,9 +86,11 @@ impl AddAudioSource for App {
         T: Decodable + Asset,
         f32: rodio::cpal::FromSample<T::DecoderItem>,
     {
-        self.add_asset::<T>()
-            .init_resource::<Audio<T>>()
-            .init_resource::<AudioOutput<T>>()
-            .add_systems(PostUpdate, play_queued_audio_system::<T>)
+        self.add_asset::<T>().add_systems(
+            PostUpdate,
+            play_queued_audio_system::<T>.in_set(AudioPlaySet),
+        );
+        self.add_systems(PostUpdate, cleanup_finished_audio::<T>.in_set(AudioPlaySet));
+        self
     }
 }
diff --git a/crates/bevy_audio/src/sinks.rs b/crates/bevy_audio/src/sinks.rs
index 2746eaf195da27..2f5cf4c29c238a 100644
--- a/crates/bevy_audio/src/sinks.rs
+++ b/crates/bevy_audio/src/sinks.rs
@@ -1,5 +1,5 @@
+use bevy_ecs::component::Component;
 use bevy_math::Vec3;
-use bevy_reflect::{TypePath, TypeUuid};
 use bevy_transform::prelude::Transform;
 use rodio::{Sink, SpatialSink};
 
@@ -65,30 +65,13 @@ pub trait AudioSinkPlayback {
     fn empty(&self) -> bool;
 }
 
-/// Asset controlling the playback of a sound
+/// Used to control audio during playback.
 ///
-/// ```
-/// # use bevy_ecs::system::{Local, Res};
-/// # use bevy_asset::{Assets, Handle};
-/// # use bevy_audio::{AudioSink, AudioSinkPlayback};
-/// // Execution of this system should be controlled by a state or input,
-/// // otherwise it would just toggle between play and pause every frame.
-/// fn pause(
-///     audio_sinks: Res<Assets<AudioSink>>,
-///     music_controller: Local<Handle<AudioSink>>,
-/// ) {
-///     if let Some(sink) = audio_sinks.get(&*music_controller) {
-///         if sink.is_paused() {
-///             sink.play()
-///         } else {
-///             sink.pause()
-///         }
-///     }
-/// }
-/// ```
+/// Bevy inserts this component onto your entities when it begins playing an audio source.
+/// Use [`AudioBundle`][crate::AudioBundle] to trigger that to happen.
 ///
-#[derive(TypePath, TypeUuid)]
-#[uuid = "8BEE570C-57C2-4FC0-8CFB-983A22F7D981"]
+/// You can use this component to modify the playback settings while the audio is playing.
+#[derive(Component)]
 pub struct AudioSink {
     // This field is an Option in order to allow us to have a safe drop that will detach the sink.
     // It will never be None during its life
@@ -139,27 +122,13 @@ impl AudioSinkPlayback for AudioSink {
     }
 }
 
-/// Asset controlling the playback of a sound, or the locations of its listener and emitter.
+/// Used to control spatial audio during playback.
 ///
-/// ```
-/// # use bevy_ecs::system::{Local, Res};
-/// # use bevy_asset::{Assets, Handle};
-/// # use bevy_audio::SpatialAudioSink;
-/// # use bevy_math::Vec3;
-/// // Execution of this system should be controlled by a state or input,
-/// // otherwise it would just trigger every frame.
-/// fn pause(
-///     spatial_audio_sinks: Res<Assets<SpatialAudioSink>>,
-///     audio_controller: Local<Handle<SpatialAudioSink>>,
-/// ) {
-///     if let Some(spatial_sink) = spatial_audio_sinks.get(&*audio_controller) {
-///         spatial_sink.set_emitter_position(Vec3::new(1.0, 0.5, 1.0));
-///     }
-/// }
-/// ```
+/// Bevy inserts this component onto your entities when it begins playing an audio source.
+/// Use [`SpatialAudioBundle`][crate::SpatialAudioBundle] to trigger that to happen.
 ///
-#[derive(TypePath, TypeUuid)]
-#[uuid = "F3CA4C47-595E-453B-96A7-31C3DDF2A177"]
+/// You can use this component to modify the playback settings while the audio is playing.
+#[derive(Component)]
 pub struct SpatialAudioSink {
     // This field is an Option in order to allow us to have a safe drop that will detach the sink.
     // It will never be None during its life
diff --git a/crates/bevy_core/Cargo.toml b/crates/bevy_core/Cargo.toml
index 9910209ca89872..c4ecb40dce5f12 100644
--- a/crates/bevy_core/Cargo.toml
+++ b/crates/bevy_core/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_core"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides core functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -11,12 +11,12 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev", features = ["bevy_reflect"] }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev", features = ["bevy_reflect"] }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev", features = ["bevy_reflect"] }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev", features = ["bevy_reflect"] }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_tasks = { path = "../bevy_tasks", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 
 # other
 bytemuck = "1.5"
diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index a9b10b1e81f2b3..977f01489f2869 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -165,7 +165,7 @@ mod tests {
     #[test]
     fn runs_spawn_local_tasks() {
         let mut app = App::new();
-        app.add_plugins((TaskPoolPlugin::default(), TypeRegistrationPlugin::default()));
+        app.add_plugins((TaskPoolPlugin::default(), TypeRegistrationPlugin));
 
         let (async_tx, async_rx) = crossbeam_channel::unbounded();
         AsyncComputeTaskPool::get()
@@ -200,8 +200,8 @@ mod tests {
         let mut app = App::new();
         app.add_plugins((
             TaskPoolPlugin::default(),
-            TypeRegistrationPlugin::default(),
-            FrameCountPlugin::default(),
+            TypeRegistrationPlugin,
+            FrameCountPlugin,
         ));
         app.update();
 
diff --git a/crates/bevy_core_pipeline/Cargo.toml b/crates/bevy_core_pipeline/Cargo.toml
index d2af8d00b1716f..27825880d3473f 100644
--- a/crates/bevy_core_pipeline/Cargo.toml
+++ b/crates/bevy_core_pipeline/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_core_pipeline"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -19,16 +19,16 @@ tonemapping_luts = []
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_core = { path = "../bevy_core", version = "0.11.0-dev" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev" }
-bevy_render = { path = "../bevy_render", version = "0.11.0-dev" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_core = { path = "../bevy_core", version = "0.12.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev" }
+bevy_render = { path = "../bevy_render", version = "0.12.0-dev" }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 
 serde = { version = "1", features = ["derive"] }
 bitflags = "2.3"
diff --git a/crates/bevy_core_pipeline/src/bloom/settings.rs b/crates/bevy_core_pipeline/src/bloom/settings.rs
index 553fa75c6cc0ca..61468d9f413b3d 100644
--- a/crates/bevy_core_pipeline/src/bloom/settings.rs
+++ b/crates/bevy_core_pipeline/src/bloom/settings.rs
@@ -1,6 +1,6 @@
 use super::downsampling_pipeline::BloomUniforms;
 use bevy_ecs::{prelude::Component, query::QueryItem, reflect::ReflectComponent};
-use bevy_math::{UVec4, Vec4};
+use bevy_math::{URect, UVec4, Vec4};
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_render::{extract_component::ExtractComponent, prelude::Camera};
 
@@ -119,7 +119,7 @@ impl BloomSettings {
         composite_mode: BloomCompositeMode::EnergyConserving,
     };
 
-    /// A preset that's similiar to how older games did bloom.
+    /// A preset that's similar to how older games did bloom.
     pub const OLD_SCHOOL: Self = Self {
         intensity: 0.05,
         low_frequency_boost: 0.7,
@@ -159,7 +159,7 @@ impl Default for BloomSettings {
 /// # Considerations
 /// * Changing these settings creates a physically inaccurate image
 /// * Changing these settings makes it easy to make the final result look worse
-/// * Non-default prefilter settings should be used in conjuction with [`BloomCompositeMode::Additive`]
+/// * Non-default prefilter settings should be used in conjunction with [`BloomCompositeMode::Additive`]
 #[derive(Default, Clone, Reflect)]
 pub struct BloomPrefilterSettings {
     /// Baseline of the quadratic threshold curve (default: 0.0).
@@ -196,7 +196,7 @@ impl ExtractComponent for BloomSettings {
             camera.is_active,
             camera.hdr,
         ) {
-            (Some((origin, _)), Some(size), Some(target_size), true, true) => {
+            (Some(URect { min: origin, .. }), Some(size), Some(target_size), true, true) => {
                 let threshold = settings.prefilter_settings.threshold;
                 let threshold_softness = settings.prefilter_settings.threshold_softness;
                 let knee = threshold * threshold_softness.clamp(0.0, 1.0);
diff --git a/crates/bevy_core_pipeline/src/taa/mod.rs b/crates/bevy_core_pipeline/src/taa/mod.rs
index 746f22ded9d66e..01e75ddd15f50d 100644
--- a/crates/bevy_core_pipeline/src/taa/mod.rs
+++ b/crates/bevy_core_pipeline/src/taa/mod.rs
@@ -148,7 +148,7 @@ pub struct TemporalAntiAliasSettings {
     /// Set to true to delete the saved temporal history (past frames).
     ///
     /// Useful for preventing ghosting when the history is no longer
-    /// representive of the current frame, such as in sudden camera cuts.
+    /// representative of the current frame, such as in sudden camera cuts.
     ///
     /// After setting this to true, it will automatically be toggled
     /// back to false after one frame.
diff --git a/crates/bevy_derive/Cargo.toml b/crates/bevy_derive/Cargo.toml
index f0e9688f2115b4..b200c175469df9 100644
--- a/crates/bevy_derive/Cargo.toml
+++ b/crates/bevy_derive/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_derive"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides derive implementations for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -12,7 +12,7 @@ keywords = ["bevy"]
 proc-macro = true
 
 [dependencies]
-bevy_macro_utils = { path = "../bevy_macro_utils", version = "0.11.0-dev" }
+bevy_macro_utils = { path = "../bevy_macro_utils", version = "0.12.0-dev" }
 
 quote = "1.0"
 syn = { version = "2.0", features = ["full"] }
diff --git a/crates/bevy_diagnostic/Cargo.toml b/crates/bevy_diagnostic/Cargo.toml
index 461efa78197288..52e3b1b86f15c8 100644
--- a/crates/bevy_diagnostic/Cargo.toml
+++ b/crates/bevy_diagnostic/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_diagnostic"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides diagnostic functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -14,12 +14,12 @@ dynamic_linking = []
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_core = { path = "../bevy_core", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.11.0-dev" }
-bevy_time = { path = "../bevy_time", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_core = { path = "../bevy_core", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_log = { path = "../bevy_log", version = "0.12.0-dev" }
+bevy_time = { path = "../bevy_time", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 
 # MacOS
 [target.'cfg(all(target_os="macos"))'.dependencies]
diff --git a/crates/bevy_dylib/Cargo.toml b/crates/bevy_dylib/Cargo.toml
index 286f7cf62afd09..f8f40ea5fe3612 100644
--- a/crates/bevy_dylib/Cargo.toml
+++ b/crates/bevy_dylib/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_dylib"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Force the Bevy Engine to be dynamically linked for faster linking"
 homepage = "https://bevyengine.org"
@@ -12,4 +12,4 @@ keywords = ["bevy"]
 crate-type = ["dylib"]
 
 [dependencies]
-bevy_internal = { path = "../bevy_internal", version = "0.11.0-dev", default-features = false }
+bevy_internal = { path = "../bevy_internal", version = "0.12.0-dev", default-features = false }
diff --git a/crates/bevy_dynamic_plugin/Cargo.toml b/crates/bevy_dynamic_plugin/Cargo.toml
index c735c69e2a30b0..22507f0007f542 100644
--- a/crates/bevy_dynamic_plugin/Cargo.toml
+++ b/crates/bevy_dynamic_plugin/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_dynamic_plugin"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides dynamic plugin loading capabilities for non-wasm platforms"
 homepage = "https://bevyengine.org"
@@ -10,7 +10,7 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
 
 # other
 libloading = { version = "0.8" }
diff --git a/crates/bevy_ecs/Cargo.toml b/crates/bevy_ecs/Cargo.toml
index c19073b2c97ae1..dc13ba8ee05e0e 100644
--- a/crates/bevy_ecs/Cargo.toml
+++ b/crates/bevy_ecs/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_ecs"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Bevy Engine's entity component system"
 homepage = "https://bevyengine.org"
@@ -11,14 +11,15 @@ categories = ["game-engines", "data-structures"]
 
 [features]
 trace = []
-default = ["bevy_reflect"]
+multi-threaded = ["bevy_tasks/multi-threaded"]
+default = ["bevy_reflect", "multi-threaded"]
 
 [dependencies]
-bevy_ptr = { path = "../bevy_ptr", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", optional = true }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_ecs_macros = { path = "macros", version = "0.11.0-dev" }
+bevy_ptr = { path = "../bevy_ptr", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", optional = true }
+bevy_tasks = { path = "../bevy_tasks", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_ecs_macros = { path = "macros", version = "0.12.0-dev" }
 
 async-channel = "1.4"
 event-listener = "2.5"
diff --git a/crates/bevy_ecs/macros/Cargo.toml b/crates/bevy_ecs/macros/Cargo.toml
index 9675f105944924..45529ce2019fe0 100644
--- a/crates/bevy_ecs/macros/Cargo.toml
+++ b/crates/bevy_ecs/macros/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_ecs_macros"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 description = "Bevy ECS Macros"
 edition = "2021"
 license = "MIT OR Apache-2.0"
@@ -9,7 +9,7 @@ license = "MIT OR Apache-2.0"
 proc-macro = true
 
 [dependencies]
-bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.11.0-dev" }
+bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.12.0-dev" }
 
 syn = "2.0"
 quote = "1.0"
diff --git a/crates/bevy_ecs/macros/src/component.rs b/crates/bevy_ecs/macros/src/component.rs
index 65d26a0bf01020..db10910e0c5084 100644
--- a/crates/bevy_ecs/macros/src/component.rs
+++ b/crates/bevy_ecs/macros/src/component.rs
@@ -101,7 +101,7 @@ fn parse_component_attr(ast: &DeriveInput) -> Result<Attrs> {
                 };
                 Ok(())
             } else {
-                Err(nested.error("Unsuported attribute"))
+                Err(nested.error("Unsupported attribute"))
             }
         })?;
     }
diff --git a/crates/bevy_ecs/src/entity/mod.rs b/crates/bevy_ecs/src/entity/mod.rs
index a9a4f14759cb0a..99dd7fe791a30a 100644
--- a/crates/bevy_ecs/src/entity/mod.rs
+++ b/crates/bevy_ecs/src/entity/mod.rs
@@ -905,7 +905,7 @@ mod tests {
 
         assert!(entities.reserve_generations(entity.index, GENERATIONS));
 
-        // The very next entitiy allocated should be a further generation on the same index
+        // The very next entity allocated should be a further generation on the same index
         let next_entity = entities.alloc();
         assert_eq!(next_entity.index(), entity.index());
         assert!(next_entity.generation > entity.generation + GENERATIONS);
diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index 9c762edc6bcf66..98f1d9f9b9ca4e 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -1038,10 +1038,7 @@ mod tests {
         events.send_default();
 
         let mut reader = events.get_reader();
-        assert_eq!(
-            get_events(&events, &mut reader),
-            vec![EmptyTestEvent::default()]
-        );
+        assert_eq!(get_events(&events, &mut reader), vec![EmptyTestEvent]);
     }
 
     #[test]
diff --git a/crates/bevy_ecs/src/query/fetch.rs b/crates/bevy_ecs/src/query/fetch.rs
index e207c6f9623c5e..0e11d42f6b6b2d 100644
--- a/crates/bevy_ecs/src/query/fetch.rs
+++ b/crates/bevy_ecs/src/query/fetch.rs
@@ -460,13 +460,6 @@ pub type QueryItem<'w, Q> = <Q as WorldQuery>::Item<'w>;
 /// The read-only variant of the item type returned when a [`WorldQuery`] is iterated over immutably
 pub type ROQueryItem<'w, Q> = QueryItem<'w, <Q as WorldQuery>::ReadOnly>;
 
-/// The `Fetch` of a [`WorldQuery`], which is used to store state for each archetype/table.
-#[deprecated = "use <Q as WorldQuery>::Fetch<'w> instead"]
-pub type QueryFetch<'w, Q> = <Q as WorldQuery>::Fetch<'w>;
-/// The read-only `Fetch` of a [`WorldQuery`], which is used to store state for each archetype/table.
-#[deprecated = "use <<Q as WorldQuery>::ReadOnly as WorldQuery>::Fetch<'w> instead"]
-pub type ROQueryFetch<'w, Q> = <<Q as WorldQuery>::ReadOnly as WorldQuery>::Fetch<'w>;
-
 /// SAFETY: no component or archetype access
 unsafe impl WorldQuery for Entity {
     type Fetch<'w> = ();
diff --git a/crates/bevy_ecs/src/query/par_iter.rs b/crates/bevy_ecs/src/query/par_iter.rs
index 426858b89abb63..6df124848adde9 100644
--- a/crates/bevy_ecs/src/query/par_iter.rs
+++ b/crates/bevy_ecs/src/query/par_iter.rs
@@ -1,5 +1,4 @@
 use crate::{component::Tick, world::unsafe_world_cell::UnsafeWorldCell};
-use bevy_tasks::ComputeTaskPool;
 use std::ops::Range;
 
 use super::{QueryItem, QueryState, ROQueryItem, ReadOnlyWorldQuery, WorldQuery};
@@ -34,6 +33,8 @@ pub struct BatchingStrategy {
     /// increase the scheduling overhead for the iteration.
     ///
     /// Defaults to 1.
+    ///
+    /// [`ComputeTaskPool`]: bevy_tasks::ComputeTaskPool
     pub batches_per_thread: usize,
 }
 
@@ -148,23 +149,36 @@ impl<'w, 's, Q: WorldQuery, F: ReadOnlyWorldQuery> QueryParIter<'w, 's, Q, F> {
     /// [`ComputeTaskPool`]: bevy_tasks::ComputeTaskPool
     #[inline]
     unsafe fn for_each_unchecked<FN: Fn(QueryItem<'w, Q>) + Send + Sync + Clone>(&self, func: FN) {
-        let thread_count = ComputeTaskPool::get().thread_num();
-        if thread_count <= 1 {
+        #[cfg(any(target = "wasm32", not(feature = "multi-threaded")))]
+        {
             self.state
                 .for_each_unchecked_manual(self.world, func, self.last_run, self.this_run);
-        } else {
-            // Need a batch size of at least 1.
-            let batch_size = self.get_batch_size(thread_count).max(1);
-            self.state.par_for_each_unchecked_manual(
-                self.world,
-                batch_size,
-                func,
-                self.last_run,
-                self.this_run,
-            );
+        }
+        #[cfg(all(not(target = "wasm32"), feature = "multi-threaded"))]
+        {
+            let thread_count = bevy_tasks::ComputeTaskPool::get().thread_num();
+            if thread_count <= 1 {
+                self.state.for_each_unchecked_manual(
+                    self.world,
+                    func,
+                    self.last_run,
+                    self.this_run,
+                );
+            } else {
+                // Need a batch size of at least 1.
+                let batch_size = self.get_batch_size(thread_count).max(1);
+                self.state.par_for_each_unchecked_manual(
+                    self.world,
+                    batch_size,
+                    func,
+                    self.last_run,
+                    self.this_run,
+                );
+            }
         }
     }
 
+    #[cfg(all(not(target = "wasm32"), feature = "multi-threaded"))]
     fn get_batch_size(&self, thread_count: usize) -> usize {
         if self.batching_strategy.batch_size_limits.is_empty() {
             return self.batching_strategy.batch_size_limits.start;
diff --git a/crates/bevy_ecs/src/query/state.rs b/crates/bevy_ecs/src/query/state.rs
index aee797ccf662af..ef01805937ad87 100644
--- a/crates/bevy_ecs/src/query/state.rs
+++ b/crates/bevy_ecs/src/query/state.rs
@@ -10,7 +10,6 @@ use crate::{
     storage::{TableId, TableRow},
     world::{unsafe_world_cell::UnsafeWorldCell, World, WorldId},
 };
-use bevy_tasks::ComputeTaskPool;
 #[cfg(feature = "trace")]
 use bevy_utils::tracing::Instrument;
 use fixedbitset::FixedBitSet;
@@ -1031,6 +1030,9 @@ impl<Q: WorldQuery, F: ReadOnlyWorldQuery> QueryState<Q, F> {
     /// have unique access to the components they query.
     /// This does not validate that `world.id()` matches `self.world_id`. Calling this on a `world`
     /// with a mismatched [`WorldId`] is unsound.
+    ///
+    /// [`ComputeTaskPool`]: bevy_tasks::ComputeTaskPool
+    #[cfg(all(not(target = "wasm32"), feature = "multi-threaded"))]
     pub(crate) unsafe fn par_for_each_unchecked_manual<
         'w,
         FN: Fn(Q::Item<'w>) + Send + Sync + Clone,
@@ -1044,7 +1046,7 @@ impl<Q: WorldQuery, F: ReadOnlyWorldQuery> QueryState<Q, F> {
     ) {
         // NOTE: If you are changing query iteration code, remember to update the following places, where relevant:
         // QueryIter, QueryIterationCursor, QueryManyIter, QueryCombinationIter, QueryState::for_each_unchecked_manual, QueryState::par_for_each_unchecked_manual
-        ComputeTaskPool::get().scope(|scope| {
+        bevy_tasks::ComputeTaskPool::get().scope(|scope| {
             if Q::IS_DENSE && F::IS_DENSE {
                 // SAFETY: We only access table data that has been registered in `self.archetype_component_access`.
                 let tables = &world.storages().tables;
diff --git a/crates/bevy_ecs/src/reflect/map_entities.rs b/crates/bevy_ecs/src/reflect/map_entities.rs
index fe02e4794fce2e..bd09bd97b64ade 100644
--- a/crates/bevy_ecs/src/reflect/map_entities.rs
+++ b/crates/bevy_ecs/src/reflect/map_entities.rs
@@ -6,7 +6,7 @@ use crate::{
 use bevy_reflect::FromType;
 
 /// For a specific type of component, this maps any fields with values of type [`Entity`] to a new world.
-/// Since a given `Entity` ID is only valid for the world it came frome, when performing deserialization
+/// Since a given `Entity` ID is only valid for the world it came from, when performing deserialization
 /// any stored IDs need to be re-allocated in the destination world.
 ///
 /// See [`MapEntities`] for more information.
diff --git a/crates/bevy_ecs/src/schedule/condition.rs b/crates/bevy_ecs/src/schedule/condition.rs
index 5f361f931d72a2..abaf9bbf62c2d6 100644
--- a/crates/bevy_ecs/src/schedule/condition.rs
+++ b/crates/bevy_ecs/src/schedule/condition.rs
@@ -246,7 +246,7 @@ pub mod common_conditions {
     /// # let mut app = Schedule::new();
     /// # let mut world = World::new();
     /// app.add_systems(
-    ///     // `resource_exsists` will only return true if the given resource exsists in the world
+    ///     // `resource_exists` will only return true if the given resource exists in the world
     ///     my_system.run_if(resource_exists::<Counter>()),
     /// );
     ///
@@ -324,7 +324,7 @@ pub mod common_conditions {
     /// # let mut world = World::new();
     /// app.add_systems(
     ///     // `resource_exists_and_equals` will only return true
-    ///     // if the given resource exsists and equals the given value
+    ///     // if the given resource exists and equals the given value
     ///     my_system.run_if(resource_exists_and_equals(Counter(0))),
     /// );
     ///
@@ -422,7 +422,7 @@ pub mod common_conditions {
     ///     my_system.run_if(
     ///         resource_changed::<Counter>()
     ///         // By default detecting changes will also trigger if the resource was
-    ///         // just added, this won't work with my example so I will addd a second
+    ///         // just added, this won't work with my example so I will add a second
     ///         // condition to make sure the resource wasn't just added
     ///         .and_then(not(resource_added::<Counter>()))
     ///     ),
@@ -471,11 +471,11 @@ pub mod common_conditions {
     /// # let mut world = World::new();
     /// app.add_systems(
     ///     // `resource_exists_and_changed` will only return true if the
-    ///     // given resource exsists and was just changed (or added)
+    ///     // given resource exists and was just changed (or added)
     ///     my_system.run_if(
     ///         resource_exists_and_changed::<Counter>()
     ///         // By default detecting changes will also trigger if the resource was
-    ///         // just added, this won't work with my example so I will addd a second
+    ///         // just added, this won't work with my example so I will add a second
     ///         // condition to make sure the resource wasn't just added
     ///         .and_then(not(resource_added::<Counter>()))
     ///     ),
@@ -537,7 +537,7 @@ pub mod common_conditions {
     ///     my_system.run_if(
     ///         resource_changed_or_removed::<Counter>()
     ///         // By default detecting changes will also trigger if the resource was
-    ///         // just added, this won't work with my example so I will addd a second
+    ///         // just added, this won't work with my example so I will add a second
     ///         // condition to make sure the resource wasn't just added
     ///         .and_then(not(resource_added::<Counter>()))
     ///     ),
@@ -665,7 +665,7 @@ pub mod common_conditions {
     ///
     /// app.add_systems(
     ///     // `state_exists` will only return true if the
-    ///     // given state exsists
+    ///     // given state exists
     ///     my_system.run_if(state_exists::<GameState>()),
     /// );
     ///
@@ -764,7 +764,7 @@ pub mod common_conditions {
     ///
     /// app.add_systems((
     ///     // `state_exists_and_equals` will only return true if the
-    ///     // given state exsists and equals the given value
+    ///     // given state exists and equals the given value
     ///     play_system.run_if(state_exists_and_equals(GameState::Playing)),
     ///     pause_system.run_if(state_exists_and_equals(GameState::Paused)),
     /// ));
diff --git a/crates/bevy_ecs/src/schedule/config.rs b/crates/bevy_ecs/src/schedule/config.rs
index bc9a687811cfab..708661035ed55d 100644
--- a/crates/bevy_ecs/src/schedule/config.rs
+++ b/crates/bevy_ecs/src/schedule/config.rs
@@ -5,7 +5,6 @@ use crate::{
         condition::{BoxedCondition, Condition},
         graph_utils::{Ambiguity, Dependency, DependencyKind, GraphInfo},
         set::{BoxedSystemSet, IntoSystemSet, SystemSet},
-        ScheduleLabel,
     },
     system::{BoxedSystem, IntoSystem, System},
 };
@@ -294,35 +293,6 @@ where
     fn chain(self) -> SystemConfigs {
         self.into_configs().chain()
     }
-
-    /// This used to add the system to `CoreSchedule::Startup`.
-    /// This was a shorthand for `self.in_schedule(CoreSchedule::Startup)`.
-    ///
-    /// # Panics
-    ///
-    /// Always panics. Please migrate to the new `App::add_systems` with the `Startup` schedule:
-    /// Ex: `app.add_system(foo.on_startup())` -> `app.add_systems(Startup, foo)`
-    #[deprecated(
-        since = "0.11.0",
-        note = "`app.add_system(foo.on_startup())` has been deprecated in favor of `app.add_systems(Startup, foo)`. Please migrate to that API."
-    )]
-    fn on_startup(self) -> SystemConfigs {
-        panic!("`app.add_system(foo.on_startup())` has been deprecated in favor of `app.add_systems(Startup, foo)`. Please migrate to that API.");
-    }
-
-    /// This used to add the system to the provided `schedule`.
-    ///
-    /// # Panics
-    ///
-    /// Always panics. Please migrate to the new `App::add_systems`:
-    /// Ex: `app.add_system(foo.in_schedule(SomeSchedule))` -> `app.add_systems(SomeSchedule, foo)`
-    #[deprecated(
-        since = "0.11.0",
-        note = "`app.add_system(foo.in_schedule(SomeSchedule))` has been deprecated in favor of `app.add_systems(SomeSchedule, foo)`. Please migrate to that API."
-    )]
-    fn in_schedule(self, _schedule: impl ScheduleLabel) -> SystemConfigs {
-        panic!("`app.add_system(foo.in_schedule(SomeSchedule))` has been deprecated in favor of `app.add_systems(SomeSchedule, foo)`. Please migrate to that API.");
-    }
 }
 
 impl IntoSystemConfigs<()> for SystemConfigs {
@@ -471,35 +441,6 @@ pub trait IntoSystemSetConfig: Sized {
     fn ambiguous_with_all(self) -> SystemSetConfig {
         self.into_config().ambiguous_with_all()
     }
-
-    /// This used to configure the set in the `CoreSchedule::Startup` schedule.
-    /// This was a shorthand for `self.in_schedule(CoreSchedule::Startup)`.
-    ///
-    /// # Panics
-    ///
-    /// Always panics. Please migrate to the new `App::configure_set` with the `Startup` schedule:
-    /// Ex: `app.configure_set(MySet.on_startup())` -> `app.configure_set(Startup, MySet)`
-    #[deprecated(
-        since = "0.11.0",
-        note = "`app.configure_set(MySet.on_startup())` has been deprecated in favor of `app.configure_set(Startup, MySet)`. Please migrate to that API."
-    )]
-    fn on_startup(self) -> SystemSetConfigs {
-        panic!("`app.configure_set(MySet.on_startup())` has been deprecated in favor of `app.configure_set(Startup, MySet)`. Please migrate to that API.");
-    }
-
-    /// This used to configure the set in the provided `schedule`.
-    ///
-    /// # Panics
-    ///
-    /// Always panics. Please migrate to the new `App::configure_set`:
-    /// Ex: `app.configure_set(MySet.in_schedule(SomeSchedule))` -> `app.configure_set(SomeSchedule, MySet)`
-    #[deprecated(
-        since = "0.11.0",
-        note = "`app.configure_set(MySet.in_schedule(SomeSchedule))` has been deprecated in favor of `app.configure_set(SomeSchedule, MySet)`. Please migrate to that API."
-    )]
-    fn in_schedule(self, _schedule: impl ScheduleLabel) -> SystemSetConfigs {
-        panic!("`app.configure_set(MySet.in_schedule(SomeSchedule))` has been deprecated in favor of `app.configure_set(SomeSchedule, MySet)`. Please migrate to that API.");
-    }
 }
 
 impl<S: SystemSet> IntoSystemSetConfig for S {
@@ -611,35 +552,6 @@ where
     fn chain(self) -> SystemSetConfigs {
         self.into_configs().chain()
     }
-
-    /// This used to configure the sets in the `CoreSchedule::Startup` schedule.
-    /// This was a shorthand for `self.in_schedule(CoreSchedule::Startup)`.
-    ///
-    /// # Panics
-    ///
-    /// Always panics. Please migrate to the new `App::configure_sets` with the `Startup` schedule:
-    /// Ex: `app.configure_sets((A, B).on_startup())` -> `app.configure_sets(Startup, (A, B))`
-    #[deprecated(
-        since = "0.11.0",
-        note = "`app.configure_sets((A, B).on_startup())` has been deprecated in favor of `app.configure_sets(Startup, (A, B))`. Please migrate to that API."
-    )]
-    fn on_startup(self) -> SystemSetConfigs {
-        panic!("`app.configure_sets((A, B).on_startup())` has been deprecated in favor of `app.configure_sets(Startup, (A, B))`. Please migrate to that API.");
-    }
-
-    /// This used to configure the sets in the provided `schedule`.
-    ///
-    /// # Panics
-    ///
-    /// Always panics. Please migrate to the new `App::configure_set`:
-    /// Ex: `app.configure_sets((A, B).in_schedule(SomeSchedule))` -> `app.configure_sets(SomeSchedule, (A, B))`
-    #[deprecated(
-        since = "0.11.0",
-        note = "`app.configure_sets((A, B).in_schedule(SomeSchedule))` has been deprecated in favor of `app.configure_sets(SomeSchedule, (A, B))`. Please migrate to that API."
-    )]
-    fn in_schedule(self, _schedule: impl ScheduleLabel) -> SystemSetConfigs {
-        panic!("`app.configure_sets((A, B).in_schedule(SomeSchedule))` has been deprecated in favor of `app.configure_sets(SomeSchedule, (A, B))`. Please migrate to that API.");
-    }
 }
 
 impl IntoSystemSetConfigs for SystemSetConfigs {
diff --git a/crates/bevy_ecs/src/schedule/executor/mod.rs b/crates/bevy_ecs/src/schedule/executor/mod.rs
index ffc4ca1bd78f25..2b2a6c139e46b9 100644
--- a/crates/bevy_ecs/src/schedule/executor/mod.rs
+++ b/crates/bevy_ecs/src/schedule/executor/mod.rs
@@ -33,13 +33,13 @@ pub enum ExecutorKind {
     ///
     /// Useful if you're dealing with a single-threaded environment, saving your threads for
     /// other things, or just trying minimize overhead.
-    #[cfg_attr(target_arch = "wasm32", default)]
+    #[cfg_attr(any(target_arch = "wasm32", not(feature = "multi-threaded")), default)]
     SingleThreaded,
     /// Like [`SingleThreaded`](ExecutorKind::SingleThreaded) but calls [`apply_deferred`](crate::system::System::apply_deferred)
     /// immediately after running each system.
     Simple,
     /// Runs the schedule using a thread pool. Non-conflicting systems can run in parallel.
-    #[cfg_attr(not(target_arch = "wasm32"), default)]
+    #[cfg_attr(all(not(target_arch = "wasm32"), feature = "multi-threaded"), default)]
     MultiThreaded,
 }
 
diff --git a/crates/bevy_ecs/src/schedule/executor/multi_threaded.rs b/crates/bevy_ecs/src/schedule/executor/multi_threaded.rs
index e046e9d1ace8e7..8f6a3133c5966e 100644
--- a/crates/bevy_ecs/src/schedule/executor/multi_threaded.rs
+++ b/crates/bevy_ecs/src/schedule/executor/multi_threaded.rs
@@ -476,7 +476,7 @@ impl MultiThreadedExecutor {
     /// - `world` must have permission to access the world data
     ///   used by the specified system.
     /// - `update_archetype_component_access` must have been called with `world`
-    ///   on the system assocaited with `system_index`.
+    ///   on the system associated with `system_index`.
     unsafe fn spawn_system_task<'scope>(
         &mut self,
         scope: &Scope<'_, 'scope, ()>,
diff --git a/crates/bevy_ecs/src/schedule/mod.rs b/crates/bevy_ecs/src/schedule/mod.rs
index 7bb8ef7f660c89..c585fb508fb72b 100644
--- a/crates/bevy_ecs/src/schedule/mod.rs
+++ b/crates/bevy_ecs/src/schedule/mod.rs
@@ -239,7 +239,7 @@ mod tests {
                 partially_ordered == [8, 9, 10] || partially_ordered == [10, 8, 9],
                 "partially_ordered must be [8, 9, 10] or [10, 8, 9]"
             );
-            assert!(order.len() == 11, "must have exacty 11 order entries");
+            assert!(order.len() == 11, "must have exactly 11 order entries");
         }
     }
 
diff --git a/crates/bevy_ecs/src/schedule/schedule.rs b/crates/bevy_ecs/src/schedule/schedule.rs
index 4f848a003276cc..701e13ff4578f7 100644
--- a/crates/bevy_ecs/src/schedule/schedule.rs
+++ b/crates/bevy_ecs/src/schedule/schedule.rs
@@ -174,13 +174,6 @@ impl Schedule {
         }
     }
 
-    /// Add a system to the schedule.
-    #[deprecated(since = "0.11.0", note = "please use `add_systems` instead")]
-    pub fn add_system<M>(&mut self, system: impl IntoSystemConfigs<M>) -> &mut Self {
-        self.graph.add_systems_inner(system.into_configs(), false);
-        self
-    }
-
     /// Add a collection of systems to the schedule.
     pub fn add_systems<M>(&mut self, systems: impl IntoSystemConfigs<M>) -> &mut Self {
         self.graph.add_systems_inner(systems.into_configs(), false);
diff --git a/crates/bevy_ecs/src/storage/table.rs b/crates/bevy_ecs/src/storage/table.rs
index bae50e86c22a47..c30ee6ce1248b2 100644
--- a/crates/bevy_ecs/src/storage/table.rs
+++ b/crates/bevy_ecs/src/storage/table.rs
@@ -94,7 +94,7 @@ impl TableRow {
     }
 }
 
-/// A type-erased contiguous container for data of a homogenous type.
+/// A type-erased contiguous container for data of a homogeneous type.
 ///
 /// Conceptually, a [`Column`] is very similar to a type-erased `Vec<T>`.
 /// It also stores the change detection ticks for its components, kept in two separate
diff --git a/crates/bevy_ecs/src/system/query.rs b/crates/bevy_ecs/src/system/query.rs
index fe12856744edb5..50ea3fde790c0f 100644
--- a/crates/bevy_ecs/src/system/query.rs
+++ b/crates/bevy_ecs/src/system/query.rs
@@ -426,7 +426,7 @@ impl<'w, 's, Q: WorldQuery, F: ReadOnlyWorldQuery> Query<'w, 's, Q, F> {
     pub fn iter(&self) -> QueryIter<'_, 's, Q::ReadOnly, F::ReadOnly> {
         // SAFETY:
         // - `self.world` has permission to access the required components.
-        // - The query is read-only, so it can be aliased even if it was originaly mutable.
+        // - The query is read-only, so it can be aliased even if it was originally mutable.
         unsafe {
             self.state
                 .as_readonly()
@@ -492,7 +492,7 @@ impl<'w, 's, Q: WorldQuery, F: ReadOnlyWorldQuery> Query<'w, 's, Q, F> {
     ) -> QueryCombinationIter<'_, 's, Q::ReadOnly, F::ReadOnly, K> {
         // SAFETY:
         // - `self.world` has permission to access the required components.
-        // - The query is read-only, so it can be aliased even if it was originaly mutable.
+        // - The query is read-only, so it can be aliased even if it was originally mutable.
         unsafe {
             self.state.as_readonly().iter_combinations_unchecked_manual(
                 self.world,
@@ -578,7 +578,7 @@ impl<'w, 's, Q: WorldQuery, F: ReadOnlyWorldQuery> Query<'w, 's, Q, F> {
     {
         // SAFETY:
         // - `self.world` has permission to access the required components.
-        // - The query is read-only, so it can be aliased even if it was originaly mutable.
+        // - The query is read-only, so it can be aliased even if it was originally mutable.
         unsafe {
             self.state.as_readonly().iter_many_unchecked_manual(
                 entities,
@@ -734,7 +734,7 @@ impl<'w, 's, Q: WorldQuery, F: ReadOnlyWorldQuery> Query<'w, 's, Q, F> {
     pub fn for_each<'this>(&'this self, f: impl FnMut(ROQueryItem<'this, Q>)) {
         // SAFETY:
         // - `self.world` has permission to access the required components.
-        // - The query is read-only, so it can be aliased even if it was originaly mutable.
+        // - The query is read-only, so it can be aliased even if it was originally mutable.
         unsafe {
             self.state.as_readonly().for_each_unchecked_manual(
                 self.world,
diff --git a/crates/bevy_ecs/src/system/system_param.rs b/crates/bevy_ecs/src/system/system_param.rs
index 4a3be817b8dbbc..ff4321ee6cd50d 100644
--- a/crates/bevy_ecs/src/system/system_param.rs
+++ b/crates/bevy_ecs/src/system/system_param.rs
@@ -627,7 +627,7 @@ unsafe impl SystemParam for &'_ World {
         world: UnsafeWorldCell<'w>,
         _change_tick: Tick,
     ) -> Self::Item<'w, 's> {
-        // SAFETY: Read-only access to the entire world was registerd in `init_state`.
+        // SAFETY: Read-only access to the entire world was registered in `init_state`.
         world.world()
     }
 }
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
index a5d1e5fb14e7bc..fae2931f7f8987 100644
--- a/crates/bevy_ecs/src/world/mod.rs
+++ b/crates/bevy_ecs/src/world/mod.rs
@@ -1864,23 +1864,6 @@ impl World {
     pub fn run_schedule(&mut self, label: impl AsRef<dyn ScheduleLabel>) {
         self.schedule_scope(label, |world, sched| sched.run(world));
     }
-
-    /// Runs the [`Schedule`] associated with the `label` a single time.
-    ///
-    /// Unlike the `run_schedule` method, this method takes the label by reference, which can save a clone.
-    ///
-    /// The [`Schedule`] is fetched from the [`Schedules`] resource of the world by its label,
-    /// and system state is cached.
-    ///
-    /// For simple testing use cases, call [`Schedule::run(&mut world)`](Schedule::run) instead.
-    ///
-    /// # Panics
-    ///
-    /// If the requested schedule does not exist.
-    #[deprecated = "Use `World::run_schedule` instead."]
-    pub fn run_schedule_ref(&mut self, label: &dyn ScheduleLabel) {
-        self.schedule_scope(label, |world, sched| sched.run(world));
-    }
 }
 
 impl fmt::Debug for World {
diff --git a/crates/bevy_ecs/src/world/unsafe_world_cell.rs b/crates/bevy_ecs/src/world/unsafe_world_cell.rs
index 9c3ec47406df2e..db89ef8e41e67b 100644
--- a/crates/bevy_ecs/src/world/unsafe_world_cell.rs
+++ b/crates/bevy_ecs/src/world/unsafe_world_cell.rs
@@ -232,13 +232,6 @@ impl<'w> UnsafeWorldCell<'w> {
         &unsafe { self.world_metadata() }.bundles
     }
 
-    /// Reads the current change tick of this world.
-    #[inline]
-    #[deprecated = "this method has been renamed to `UnsafeWorldCell::change_tick`"]
-    pub fn read_change_tick(self) -> Tick {
-        self.change_tick()
-    }
-
     /// Gets the current change tick of this world.
     #[inline]
     pub fn change_tick(self) -> Tick {
diff --git a/crates/bevy_encase_derive/Cargo.toml b/crates/bevy_encase_derive/Cargo.toml
index be4e0096d55bf7..a435765011f24e 100644
--- a/crates/bevy_encase_derive/Cargo.toml
+++ b/crates/bevy_encase_derive/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_encase_derive"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Bevy derive macro for encase"
 homepage = "https://bevyengine.org"
@@ -12,5 +12,5 @@ keywords = ["bevy"]
 proc-macro = true
 
 [dependencies]
-bevy_macro_utils = { path = "../bevy_macro_utils", version = "0.11.0-dev" }
+bevy_macro_utils = { path = "../bevy_macro_utils", version = "0.12.0-dev" }
 encase_derive_impl = "0.6.1"
diff --git a/crates/bevy_gilrs/Cargo.toml b/crates/bevy_gilrs/Cargo.toml
index 28800939fe055a..4f8a51b9064bdb 100644
--- a/crates/bevy_gilrs/Cargo.toml
+++ b/crates/bevy_gilrs/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_gilrs"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Gamepad system made using Gilrs for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,13 +10,13 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_input = { path = "../bevy_input", version = "0.11.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_time = { path = "../bevy_time", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_input = { path = "../bevy_input", version = "0.12.0-dev" }
+bevy_log = { path = "../bevy_log", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_time = { path = "../bevy_time", version = "0.12.0-dev" }
 
 # other
 gilrs = "0.10.1"
-thiserror = "1.0"
\ No newline at end of file
+thiserror = "1.0"
diff --git a/crates/bevy_gizmos/Cargo.toml b/crates/bevy_gizmos/Cargo.toml
index aaa4f71355ad11..4a40902afae7b4 100644
--- a/crates/bevy_gizmos/Cargo.toml
+++ b/crates/bevy_gizmos/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_gizmos"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides gizmos for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -13,15 +13,15 @@ webgl = []
 
 [dependencies]
 # Bevy
-bevy_pbr = { path = "../bevy_pbr", version = "0.11.0-dev", optional = true }
-bevy_sprite = { path = "../bevy_sprite", version = "0.11.0-dev", optional = true }
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_render = { path = "../bevy_render", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_core = { path = "../bevy_core", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev" }
-bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.11.0-dev" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
+bevy_pbr = { path = "../bevy_pbr", version = "0.12.0-dev", optional = true }
+bevy_sprite = { path = "../bevy_sprite", version = "0.12.0-dev", optional = true }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_render = { path = "../bevy_render", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_core = { path = "../bevy_core", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.12.0-dev" }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
diff --git a/crates/bevy_gizmos/src/gizmos.rs b/crates/bevy_gizmos/src/gizmos.rs
index 974532d11e7c91..e945761f59462a 100644
--- a/crates/bevy_gizmos/src/gizmos.rs
+++ b/crates/bevy_gizmos/src/gizmos.rs
@@ -571,7 +571,7 @@ pub struct CircleBuilder<'a, 's> {
 }
 
 impl CircleBuilder<'_, '_> {
-    /// Set the number of line-segements for this circle.
+    /// Set the number of line-segments for this circle.
     pub fn segments(mut self, segments: usize) -> Self {
         self.segments = segments;
         self
@@ -598,7 +598,7 @@ pub struct SphereBuilder<'a, 's> {
 }
 
 impl SphereBuilder<'_, '_> {
-    /// Set the number of line-segements per circle for this sphere.
+    /// Set the number of line-segments per circle for this sphere.
     pub fn circle_segments(mut self, segments: usize) -> Self {
         self.circle_segments = segments;
         self
@@ -625,7 +625,7 @@ pub struct Circle2dBuilder<'a, 's> {
 }
 
 impl Circle2dBuilder<'_, '_> {
-    /// Set the number of line-segements for this circle.
+    /// Set the number of line-segments for this circle.
     pub fn segments(mut self, segments: usize) -> Self {
         self.segments = segments;
         self
@@ -651,7 +651,7 @@ pub struct Arc2dBuilder<'a, 's> {
 }
 
 impl Arc2dBuilder<'_, '_> {
-    /// Set the number of line-segements for this arc.
+    /// Set the number of line-segments for this arc.
     pub fn segments(mut self, segments: usize) -> Self {
         self.segments = Some(segments);
         self
diff --git a/crates/bevy_gizmos/src/lines.wgsl b/crates/bevy_gizmos/src/lines.wgsl
index 037a9fbcaefbfe..2dbe84653db660 100644
--- a/crates/bevy_gizmos/src/lines.wgsl
+++ b/crates/bevy_gizmos/src/lines.wgsl
@@ -80,10 +80,10 @@ fn vertex(vertex: VertexInput) -> VertexOutput {
         // depth * (clip.w / depth)^-depth_bias. So that when -depth_bias is 1.0, this is equal to clip.w
         // and when equal to 0.0, it is exactly equal to depth.
         // the epsilon is here to prevent the depth from exceeding clip.w when -depth_bias = 1.0 
-        // clip.w represents the near plane in homogenous clip space in bevy, having a depth
+        // clip.w represents the near plane in homogeneous clip space in bevy, having a depth
         // of this value means nothing can be in front of this
         // The reason this uses an exponential function is that it makes it much easier for the 
-        // user to chose a value that is convinient for them
+        // user to chose a value that is convenient for them
         depth = clip.z * exp2(-line_gizmo.depth_bias * log2(clip.w / clip.z - epsilon));
     }
 
diff --git a/crates/bevy_gizmos/src/pipeline_2d.rs b/crates/bevy_gizmos/src/pipeline_2d.rs
index be983becec9f6c..06f21138d8a551 100644
--- a/crates/bevy_gizmos/src/pipeline_2d.rs
+++ b/crates/bevy_gizmos/src/pipeline_2d.rs
@@ -166,7 +166,7 @@ fn queue_line_gizmos_2d(
                 entity,
                 draw_function,
                 pipeline,
-                sort_key: FloatOrd(0.),
+                sort_key: FloatOrd(f32::INFINITY),
                 batch_range: None,
             });
         }
diff --git a/crates/bevy_gltf/Cargo.toml b/crates/bevy_gltf/Cargo.toml
index 27fdbcc140e417..80291f06e22acb 100644
--- a/crates/bevy_gltf/Cargo.toml
+++ b/crates/bevy_gltf/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_gltf"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Bevy Engine GLTF loading"
 homepage = "https://bevyengine.org"
@@ -10,22 +10,22 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_animation = { path = "../bevy_animation", version = "0.11.0-dev", optional = true }
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_core = { path = "../bevy_core", version = "0.11.0-dev" }
-bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_pbr = { path = "../bevy_pbr", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_render = { path = "../bevy_render", version = "0.11.0-dev" }
-bevy_scene = { path = "../bevy_scene", version = "0.11.0-dev", features = ["bevy_render"] }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_animation = { path = "../bevy_animation", version = "0.12.0-dev", optional = true }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_core = { path = "../bevy_core", version = "0.12.0-dev" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.12.0-dev" }
+bevy_log = { path = "../bevy_log", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_pbr = { path = "../bevy_pbr", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_render = { path = "../bevy_render", version = "0.12.0-dev" }
+bevy_scene = { path = "../bevy_scene", version = "0.12.0-dev", features = ["bevy_render"] }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 
 # other
 gltf = { version = "1.0.0", default-features = false, features = [
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index ff6f96bd21b563..8861bd7e6726f8 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -70,8 +70,8 @@ pub enum GltfError {
 
 /// Loads glTF files with all of their data as their corresponding bevy representations.
 pub struct GltfLoader {
-    pub(crate) supported_compressed_formats: CompressedImageFormats,
-    pub(crate) custom_vertex_attributes: HashMap<String, MeshVertexAttribute>,
+    pub supported_compressed_formats: CompressedImageFormats,
+    pub custom_vertex_attributes: HashMap<String, MeshVertexAttribute>,
 }
 
 impl AssetLoader for GltfLoader {
diff --git a/crates/bevy_hierarchy/Cargo.toml b/crates/bevy_hierarchy/Cargo.toml
index 598cb12fea004d..d6ec89524775dd 100644
--- a/crates/bevy_hierarchy/Cargo.toml
+++ b/crates/bevy_hierarchy/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_hierarchy"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides hierarchy functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -13,12 +13,12 @@ trace = []
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_core = { path = "../bevy_core", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev", features = ["bevy_reflect"] }
-bevy_log = { path = "../bevy_log", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_core = { path = "../bevy_core", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev", features = ["bevy_reflect"] }
+bevy_log = { path = "../bevy_log", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 
 # other
 smallvec = { version = "1.6", features = ["serde", "union", "const_generics"] }
diff --git a/crates/bevy_hierarchy/src/child_builder.rs b/crates/bevy_hierarchy/src/child_builder.rs
index 54c942144ecc45..466d6f7b95721f 100644
--- a/crates/bevy_hierarchy/src/child_builder.rs
+++ b/crates/bevy_hierarchy/src/child_builder.rs
@@ -289,7 +289,7 @@ impl<'w, 's, 'a> ChildBuilder<'w, 's, 'a> {
 
 /// Trait for removing, adding and replacing children and parents of an entity.
 pub trait BuildChildren {
-    /// Takes a clousre which builds children for this entity using [`ChildBuilder`].
+    /// Takes a closure which builds children for this entity using [`ChildBuilder`].
     fn with_children(&mut self, f: impl FnOnce(&mut ChildBuilder)) -> &mut Self;
     /// Pushes children to the back of the builder's children. For any entities that are
     /// already a child of this one, this method does nothing.
@@ -458,7 +458,7 @@ impl<'w> WorldChildBuilder<'w> {
 
 /// Trait that defines adding, changing and children and parents of an entity directly through the [`World`].
 pub trait BuildWorldChildren {
-    /// Takes a clousre which builds children for this entity using [`WorldChildBuilder`].
+    /// Takes a closure which builds children for this entity using [`WorldChildBuilder`].
     fn with_children(&mut self, spawn_children: impl FnOnce(&mut WorldChildBuilder)) -> &mut Self;
 
     /// Adds a single child.
diff --git a/crates/bevy_input/Cargo.toml b/crates/bevy_input/Cargo.toml
index fd1ac27be4fedf..9f1b890ccc29d2 100644
--- a/crates/bevy_input/Cargo.toml
+++ b/crates/bevy_input/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_input"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides input functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -14,15 +14,15 @@ serialize = ["serde"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["glam"] }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["glam"] }
 
 # other
 serde = { version = "1", features = ["derive"], optional = true }
 thiserror = "1.0"
 
 [dev-dependencies]
-bevy = { path = "../../", version = "0.11.0-dev" }
+bevy = { path = "../../", version = "0.12.0-dev" }
diff --git a/crates/bevy_internal/Cargo.toml b/crates/bevy_internal/Cargo.toml
index 8c8fa2c4dfb8c8..28252e43d37c15 100644
--- a/crates/bevy_internal/Cargo.toml
+++ b/crates/bevy_internal/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_internal"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "An internal Bevy crate used to facilitate optional dynamic linking via the 'dynamic_linking' feature"
 homepage = "https://bevyengine.org"
@@ -66,6 +66,7 @@ shader_format_spirv = ["bevy_render/shader_format_spirv"]
 filesystem_watcher = ["bevy_asset/filesystem_watcher"]
 
 serialize = ["bevy_core/serialize", "bevy_input/serialize", "bevy_time/serialize", "bevy_window/serialize", "bevy_transform/serialize", "bevy_math/serialize", "bevy_scene/serialize"]
+multi-threaded = ["bevy_ecs/multi-threaded", "bevy_tasks/multi-threaded"]
 
 # Display server protocol support (X11 is enabled by default)
 wayland = ["bevy_winit/wayland"]
@@ -106,36 +107,36 @@ default_font = ["bevy_text?/default_font"]
 
 [dependencies]
 # bevy
-bevy_a11y = { path = "../bevy_a11y", version = "0.11.0-dev" }
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_core = { path = "../bevy_core", version = "0.11.0-dev" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
-bevy_diagnostic = { path = "../bevy_diagnostic", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0-dev" }
-bevy_input = { path = "../bevy_input", version = "0.11.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_ptr = { path = "../bevy_ptr", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_time = { path = "../bevy_time", version = "0.11.0-dev" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_window = { path = "../bevy_window", version = "0.11.0-dev" }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0-dev" }
+bevy_a11y = { path = "../bevy_a11y", version = "0.12.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_core = { path = "../bevy_core", version = "0.12.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
+bevy_diagnostic = { path = "../bevy_diagnostic", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.12.0-dev" }
+bevy_input = { path = "../bevy_input", version = "0.12.0-dev" }
+bevy_log = { path = "../bevy_log", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_ptr = { path = "../bevy_ptr", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_time = { path = "../bevy_time", version = "0.12.0-dev" }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_window = { path = "../bevy_window", version = "0.12.0-dev" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.12.0-dev" }
 # bevy (optional)
-bevy_animation = { path = "../bevy_animation", optional = true, version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", optional = true, version = "0.11.0-dev" }
-bevy_audio = { path = "../bevy_audio", optional = true, version = "0.11.0-dev" }
-bevy_core_pipeline = { path = "../bevy_core_pipeline", optional = true, version = "0.11.0-dev" }
-bevy_gltf = { path = "../bevy_gltf", optional = true, version = "0.11.0-dev" }
-bevy_pbr = { path = "../bevy_pbr", optional = true, version = "0.11.0-dev" }
-bevy_render = { path = "../bevy_render", optional = true, version = "0.11.0-dev" }
-bevy_dynamic_plugin = { path = "../bevy_dynamic_plugin", optional = true, version = "0.11.0-dev" }
-bevy_scene = { path = "../bevy_scene", optional = true, version = "0.11.0-dev" }
-bevy_sprite = { path = "../bevy_sprite", optional = true, version = "0.11.0-dev" }
-bevy_text = { path = "../bevy_text", optional = true, version = "0.11.0-dev" }
-bevy_ui = { path = "../bevy_ui", optional = true, version = "0.11.0-dev" }
-bevy_winit = { path = "../bevy_winit", optional = true, version = "0.11.0-dev" }
-bevy_gilrs = { path = "../bevy_gilrs", optional = true, version = "0.11.0-dev" }
-bevy_gizmos = { path = "../bevy_gizmos", optional = true, version = "0.11.0-dev", default-features = false }
+bevy_animation = { path = "../bevy_animation", optional = true, version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", optional = true, version = "0.12.0-dev" }
+bevy_audio = { path = "../bevy_audio", optional = true, version = "0.12.0-dev" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", optional = true, version = "0.12.0-dev" }
+bevy_gltf = { path = "../bevy_gltf", optional = true, version = "0.12.0-dev" }
+bevy_pbr = { path = "../bevy_pbr", optional = true, version = "0.12.0-dev" }
+bevy_render = { path = "../bevy_render", optional = true, version = "0.12.0-dev" }
+bevy_dynamic_plugin = { path = "../bevy_dynamic_plugin", optional = true, version = "0.12.0-dev" }
+bevy_scene = { path = "../bevy_scene", optional = true, version = "0.12.0-dev" }
+bevy_sprite = { path = "../bevy_sprite", optional = true, version = "0.12.0-dev" }
+bevy_text = { path = "../bevy_text", optional = true, version = "0.12.0-dev" }
+bevy_ui = { path = "../bevy_ui", optional = true, version = "0.12.0-dev" }
+bevy_winit = { path = "../bevy_winit", optional = true, version = "0.12.0-dev" }
+bevy_gilrs = { path = "../bevy_gilrs", optional = true, version = "0.12.0-dev" }
+bevy_gizmos = { path = "../bevy_gizmos", optional = true, version = "0.12.0-dev", default-features = false }
diff --git a/crates/bevy_internal/src/default_plugins.rs b/crates/bevy_internal/src/default_plugins.rs
index fe3be50bf95362..fb5e3da69173f1 100644
--- a/crates/bevy_internal/src/default_plugins.rs
+++ b/crates/bevy_internal/src/default_plugins.rs
@@ -43,13 +43,13 @@ impl PluginGroup for DefaultPlugins {
         group = group
             .add(bevy_log::LogPlugin::default())
             .add(bevy_core::TaskPoolPlugin::default())
-            .add(bevy_core::TypeRegistrationPlugin::default())
-            .add(bevy_core::FrameCountPlugin::default())
-            .add(bevy_time::TimePlugin::default())
-            .add(bevy_transform::TransformPlugin::default())
-            .add(bevy_hierarchy::HierarchyPlugin::default())
-            .add(bevy_diagnostic::DiagnosticsPlugin::default())
-            .add(bevy_input::InputPlugin::default())
+            .add(bevy_core::TypeRegistrationPlugin)
+            .add(bevy_core::FrameCountPlugin)
+            .add(bevy_time::TimePlugin)
+            .add(bevy_transform::TransformPlugin)
+            .add(bevy_hierarchy::HierarchyPlugin)
+            .add(bevy_diagnostic::DiagnosticsPlugin)
+            .add(bevy_input::InputPlugin)
             .add(bevy_window::WindowPlugin::default())
             .add(bevy_a11y::AccessibilityPlugin);
 
@@ -60,17 +60,17 @@ impl PluginGroup for DefaultPlugins {
 
         #[cfg(feature = "debug_asset_server")]
         {
-            group = group.add(bevy_asset::debug_asset_server::DebugAssetServerPlugin::default());
+            group = group.add(bevy_asset::debug_asset_server::DebugAssetServerPlugin);
         }
 
         #[cfg(feature = "bevy_scene")]
         {
-            group = group.add(bevy_scene::ScenePlugin::default());
+            group = group.add(bevy_scene::ScenePlugin);
         }
 
         #[cfg(feature = "bevy_winit")]
         {
-            group = group.add(bevy_winit::WinitPlugin::default());
+            group = group.add(bevy_winit::WinitPlugin);
         }
 
         #[cfg(feature = "bevy_render")]
@@ -81,31 +81,30 @@ impl PluginGroup for DefaultPlugins {
                 // compressed texture formats
                 .add(bevy_render::texture::ImagePlugin::default());
 
-            #[cfg(not(target_arch = "wasm32"))]
+            #[cfg(all(not(target_arch = "wasm32"), feature = "multi-threaded"))]
             {
-                group = group
-                    .add(bevy_render::pipelined_rendering::PipelinedRenderingPlugin::default());
+                group = group.add(bevy_render::pipelined_rendering::PipelinedRenderingPlugin);
             }
         }
 
         #[cfg(feature = "bevy_core_pipeline")]
         {
-            group = group.add(bevy_core_pipeline::CorePipelinePlugin::default());
+            group = group.add(bevy_core_pipeline::CorePipelinePlugin);
         }
 
         #[cfg(feature = "bevy_sprite")]
         {
-            group = group.add(bevy_sprite::SpritePlugin::default());
+            group = group.add(bevy_sprite::SpritePlugin);
         }
 
         #[cfg(feature = "bevy_text")]
         {
-            group = group.add(bevy_text::TextPlugin::default());
+            group = group.add(bevy_text::TextPlugin);
         }
 
         #[cfg(feature = "bevy_ui")]
         {
-            group = group.add(bevy_ui::UiPlugin::default());
+            group = group.add(bevy_ui::UiPlugin);
         }
 
         #[cfg(feature = "bevy_pbr")]
@@ -127,12 +126,12 @@ impl PluginGroup for DefaultPlugins {
 
         #[cfg(feature = "bevy_gilrs")]
         {
-            group = group.add(bevy_gilrs::GilrsPlugin::default());
+            group = group.add(bevy_gilrs::GilrsPlugin);
         }
 
         #[cfg(feature = "bevy_animation")]
         {
-            group = group.add(bevy_animation::AnimationPlugin::default());
+            group = group.add(bevy_animation::AnimationPlugin);
         }
 
         #[cfg(feature = "bevy_gizmos")]
@@ -165,9 +164,9 @@ impl PluginGroup for MinimalPlugins {
     fn build(self) -> PluginGroupBuilder {
         PluginGroupBuilder::start::<Self>()
             .add(bevy_core::TaskPoolPlugin::default())
-            .add(bevy_core::TypeRegistrationPlugin::default())
-            .add(bevy_core::FrameCountPlugin::default())
-            .add(bevy_time::TimePlugin::default())
+            .add(bevy_core::TypeRegistrationPlugin)
+            .add(bevy_core::FrameCountPlugin)
+            .add(bevy_time::TimePlugin)
             .add(bevy_app::ScheduleRunnerPlugin::default())
     }
 }
diff --git a/crates/bevy_log/Cargo.toml b/crates/bevy_log/Cargo.toml
index c8100c8423fef4..edb3823ef4a6d2 100644
--- a/crates/bevy_log/Cargo.toml
+++ b/crates/bevy_log/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_log"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides logging for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -13,9 +13,9 @@ trace = [ "tracing-error" ]
 trace_tracy_memory = ["dep:tracy-client"]
 
 [dependencies]
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
 
 tracing-subscriber = {version = "0.3.1", features = ["registry", "env-filter"]}
 tracing-chrome = { version = "0.7.0", optional = true }
diff --git a/crates/bevy_macro_utils/Cargo.toml b/crates/bevy_macro_utils/Cargo.toml
index 08c1d0243b96ee..261e8778806522 100644
--- a/crates/bevy_macro_utils/Cargo.toml
+++ b/crates/bevy_macro_utils/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_macro_utils"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "A collection of utils for Bevy Engine"
 homepage = "https://bevyengine.org"
diff --git a/crates/bevy_math/Cargo.toml b/crates/bevy_math/Cargo.toml
index b6105f6664a261..ac74611a807154 100644
--- a/crates/bevy_math/Cargo.toml
+++ b/crates/bevy_math/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_math"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides math functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
diff --git a/crates/bevy_math/src/lib.rs b/crates/bevy_math/src/lib.rs
index f42a0b946d2358..b1b6144dbb2e7b 100644
--- a/crates/bevy_math/src/lib.rs
+++ b/crates/bevy_math/src/lib.rs
@@ -19,8 +19,8 @@ pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
         cubic_splines::{BSpline, Bezier, CardinalSpline, CubicGenerator, CubicSegment, Hermite},
-        BVec2, BVec3, BVec4, EulerRot, IVec2, IVec3, IVec4, Mat2, Mat3, Mat4, Quat, Ray, Rect,
-        UVec2, UVec3, UVec4, Vec2, Vec3, Vec4,
+        BVec2, BVec3, BVec4, EulerRot, IRect, IVec2, IVec3, IVec4, Mat2, Mat3, Mat4, Quat, Ray,
+        Rect, URect, UVec2, UVec3, UVec4, Vec2, Vec3, Vec4,
     };
 }
 
diff --git a/crates/bevy_math/src/rects/rect.rs b/crates/bevy_math/src/rects/rect.rs
index e06440f08cf499..a5c456f4621212 100644
--- a/crates/bevy_math/src/rects/rect.rs
+++ b/crates/bevy_math/src/rects/rect.rs
@@ -311,13 +311,13 @@ impl Rect {
 
     /// Returns self as [`IRect`] (i32)
     #[inline]
-    pub fn as_urect(&self) -> IRect {
+    pub fn as_irect(&self) -> IRect {
         IRect::from_corners(self.min.as_ivec2(), self.max.as_ivec2())
     }
 
     /// Returns self as [`URect`] (u32)
     #[inline]
-    pub fn as_rect(&self) -> URect {
+    pub fn as_urect(&self) -> URect {
         URect::from_corners(self.min.as_uvec2(), self.max.as_uvec2())
     }
 }
diff --git a/crates/bevy_math/src/rects/urect.rs b/crates/bevy_math/src/rects/urect.rs
index e68b5f161502f6..1f04882d16c350 100644
--- a/crates/bevy_math/src/rects/urect.rs
+++ b/crates/bevy_math/src/rects/urect.rs
@@ -332,7 +332,7 @@ impl URect {
 
     /// Returns self as [`IRect`] (i32)
     #[inline]
-    pub fn as_urect(&self) -> IRect {
+    pub fn as_irect(&self) -> IRect {
         IRect::from_corners(self.min.as_ivec2(), self.max.as_ivec2())
     }
 }
diff --git a/crates/bevy_mikktspace/Cargo.toml b/crates/bevy_mikktspace/Cargo.toml
index e0b7f5332943f7..24244c598da25c 100644
--- a/crates/bevy_mikktspace/Cargo.toml
+++ b/crates/bevy_mikktspace/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_mikktspace"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 authors = [
     "Benjamin Wasty <benny.wasty@gmail.com>",
diff --git a/crates/bevy_pbr/Cargo.toml b/crates/bevy_pbr/Cargo.toml
index 5d197916169ff6..2f3bc6617cc597 100644
--- a/crates/bevy_pbr/Cargo.toml
+++ b/crates/bevy_pbr/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_pbr"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Adds PBR rendering to Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -13,17 +13,17 @@ webgl = []
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_render = { path = "../bevy_render", version = "0.11.0-dev" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_window = { path = "../bevy_window", version = "0.11.0-dev" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_render = { path = "../bevy_render", version = "0.12.0-dev" }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_window = { path = "../bevy_window", version = "0.12.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
 
 # other
 bitflags = "2.3"
diff --git a/crates/bevy_pbr/src/render/morph.rs b/crates/bevy_pbr/src/render/morph.rs
index 90778564d6cfd5..43d2e2f585234c 100644
--- a/crates/bevy_pbr/src/render/morph.rs
+++ b/crates/bevy_pbr/src/render/morph.rs
@@ -52,7 +52,7 @@ fn add_to_alignment<T: Pod + Default>(buffer: &mut BufferVec<T>) {
         // This panic is stripped at compile time, due to n, t_size and can_align being const
         panic!(
             "BufferVec should contain only types with a size multiple or divisible by {n}, \
-            {} has a size of {t_size}, which is neiter multiple or divisible by {n}",
+            {} has a size of {t_size}, which is neither multiple or divisible by {n}",
             std::any::type_name::<T>()
         );
     }
diff --git a/crates/bevy_pbr/src/render/morph.wgsl b/crates/bevy_pbr/src/render/morph.wgsl
index ceabe789943cfb..6cfc6d96028683 100644
--- a/crates/bevy_pbr/src/render/morph.wgsl
+++ b/crates/bevy_pbr/src/render/morph.wgsl
@@ -1,6 +1,6 @@
 // If using this WGSL snippet as an #import, the following should be in scope:
 //
-// - the `morph_weigths` uniform of type `MorphWeights`
+// - the `morph_weights` uniform of type `MorphWeights`
 // - the `morph_targets` 3d texture
 //
 // They are defined in `mesh_types.wgsl` and `mesh_bindings.wgsl`.
diff --git a/crates/bevy_pbr/src/render/pbr_lighting.wgsl b/crates/bevy_pbr/src/render/pbr_lighting.wgsl
index 631167f14ecd45..6658c430340603 100644
--- a/crates/bevy_pbr/src/render/pbr_lighting.wgsl
+++ b/crates/bevy_pbr/src/render/pbr_lighting.wgsl
@@ -222,7 +222,7 @@ fn point_light(
     // where
     // f(v,l) = (f_d(v,l) + f_r(v,l)) * light_color
     // Φ is luminous power in lumens
-    // our rangeAttentuation = 1 / d^2 multiplied with an attenuation factor for smoothing at the edge of the non-physical maximum light radius
+    // our rangeAttenuation = 1 / d^2 multiplied with an attenuation factor for smoothing at the edge of the non-physical maximum light radius
 
     // For a point light, luminous intensity, I, in lumens per steradian is given by:
     // I = Φ / 4 π
diff --git a/crates/bevy_ptr/Cargo.toml b/crates/bevy_ptr/Cargo.toml
index adf236cf34b0d2..a9cb87a1f4536d 100644
--- a/crates/bevy_ptr/Cargo.toml
+++ b/crates/bevy_ptr/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_ptr"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Utilities for working with untyped pointers in a more safe way"
 homepage = "https://bevyengine.org"
diff --git a/crates/bevy_ptr/src/lib.rs b/crates/bevy_ptr/src/lib.rs
index 6a1ad7747af499..f6212c505ba70d 100644
--- a/crates/bevy_ptr/src/lib.rs
+++ b/crates/bevy_ptr/src/lib.rs
@@ -8,11 +8,12 @@ use core::{
     cell::UnsafeCell, marker::PhantomData, mem::ManuallyDrop, num::NonZeroUsize, ptr::NonNull,
 };
 
-#[derive(Copy, Clone)]
 /// Used as a type argument to [`Ptr`], [`PtrMut`] and [`OwningPtr`] to specify that the pointer is aligned.
-pub struct Aligned;
 #[derive(Copy, Clone)]
+pub struct Aligned;
+
 /// Used as a type argument to [`Ptr`], [`PtrMut`] and [`OwningPtr`] to specify that the pointer is not aligned.
+#[derive(Copy, Clone)]
 pub struct Unaligned;
 
 /// Trait that is only implemented for [`Aligned`] and [`Unaligned`] to work around the lack of ability
@@ -38,6 +39,7 @@ mod sealed {
 /// It may be helpful to think of this type as similar to `&'a dyn Any` but without
 /// the metadata and able to point to data that does not correspond to a Rust type.
 #[derive(Copy, Clone)]
+#[repr(transparent)]
 pub struct Ptr<'a, A: IsAligned = Aligned>(NonNull<u8>, PhantomData<(&'a u8, A)>);
 
 /// Type-erased mutable borrow of some unknown type chosen when constructing this type.
@@ -51,6 +53,7 @@ pub struct Ptr<'a, A: IsAligned = Aligned>(NonNull<u8>, PhantomData<(&'a u8, A)>
 ///
 /// It may be helpful to think of this type as similar to `&'a mut dyn Any` but without
 /// the metadata and able to point to data that does not correspond to a Rust type.
+#[repr(transparent)]
 pub struct PtrMut<'a, A: IsAligned = Aligned>(NonNull<u8>, PhantomData<(&'a mut u8, A)>);
 
 /// Type-erased Box-like pointer to some unknown type chosen when constructing this type.
@@ -68,6 +71,7 @@ pub struct PtrMut<'a, A: IsAligned = Aligned>(NonNull<u8>, PhantomData<(&'a mut
 ///
 /// It may be helpful to think of this type as similar to `&'a mut ManuallyDrop<dyn Any>` but
 /// without the metadata and able to point to data that does not correspond to a Rust type.
+#[repr(transparent)]
 pub struct OwningPtr<'a, A: IsAligned = Aligned>(NonNull<u8>, PhantomData<(&'a mut u8, A)>);
 
 macro_rules! impl_ptr {
diff --git a/crates/bevy_reflect/Cargo.toml b/crates/bevy_reflect/Cargo.toml
index d7b193beed9308..99c443a3cd0e17 100644
--- a/crates/bevy_reflect/Cargo.toml
+++ b/crates/bevy_reflect/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_reflect"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Dynamically interact with rust types"
 homepage = "https://bevyengine.org"
@@ -18,12 +18,12 @@ documentation = ["bevy_reflect_derive/documentation"]
 
 [dependencies]
 # bevy
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev", features = [
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev", features = [
     "serialize",
 ], optional = true }
-bevy_reflect_derive = { path = "bevy_reflect_derive", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_ptr = { path = "../bevy_ptr", version = "0.11.0-dev" }
+bevy_reflect_derive = { path = "bevy_reflect_derive", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_ptr = { path = "../bevy_ptr", version = "0.12.0-dev" }
 
 # other
 erased-serde = "0.3"
diff --git a/crates/bevy_reflect/bevy_reflect_derive/Cargo.toml b/crates/bevy_reflect/bevy_reflect_derive/Cargo.toml
index fa6b7259dce536..5073873b638c5e 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/Cargo.toml
+++ b/crates/bevy_reflect/bevy_reflect_derive/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_reflect_derive"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Derive implementations for bevy_reflect"
 homepage = "https://bevyengine.org"
@@ -17,7 +17,7 @@ default = []
 documentation = []
 
 [dependencies]
-bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.11.0-dev" }
+bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.12.0-dev" }
 
 syn = { version = "2.0", features = ["full"] }
 proc-macro2 = "1.0"
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/container_attributes.rs b/crates/bevy_reflect/bevy_reflect_derive/src/container_attributes.rs
index a7acbb2748d90e..d0fb321e3d0e7a 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/container_attributes.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/container_attributes.rs
@@ -249,7 +249,7 @@ impl ReflectTraits {
                                 lit: syn::Lit::Bool(lit),
                                 ..
                             }) => {
-                                // Overrride `lit` if this is a `FromReflect` derive.
+                                // Override `lit` if this is a `FromReflect` derive.
                                 // This typically means a user is opting out of the default implementation
                                 // from the `Reflect` derive and using the `FromReflect` derive directly instead.
                                 is_from_reflect_derive
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/derive_data.rs b/crates/bevy_reflect/bevy_reflect_derive/src/derive_data.rs
index 0bf42461deb70c..7a6d0154346d81 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/derive_data.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/derive_data.rs
@@ -567,7 +567,7 @@ impl<'a> EnumVariant<'a> {
 ///     custom_path: None,
 /// };
 ///
-/// // Eqivalent to "core::marker".
+/// // Equivalent to "core::marker".
 /// let module_path = type_path.module_path();
 /// # Ok::<(), syn::Error>(())
 /// ```
@@ -577,7 +577,7 @@ pub(crate) enum ReflectTypePath<'a> {
     Primitive(&'a Ident),
     /// Using `::my_crate::foo::Bar` syntax.
     ///
-    /// May have a seperate custom path used for the `TypePath` implementation.
+    /// May have a separate custom path used for the `TypePath` implementation.
     External {
         path: &'a Path,
         custom_path: Option<Path>,
@@ -587,7 +587,7 @@ pub(crate) enum ReflectTypePath<'a> {
     ///
     /// The type must be able to be reached with just its name.
     ///
-    /// May have a seperate alias path used for the `TypePath` implementation.
+    /// May have a separate alias path used for the `TypePath` implementation.
     ///
     /// Module and crate are found with [`module_path!()`](core::module_path),
     /// if there is no custom path specified.
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 2061782115988e..87eee59dc8d67b 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -523,7 +523,7 @@ pub fn impl_from_reflect_value(input: TokenStream) -> TokenStream {
 /// it requires an 'absolute' path definition.
 ///
 /// Specifically, a leading `::` denoting a global path must be specified
-/// or a preceeding `(in my_crate::foo)` to specify the custom path must be used.
+/// or a preceding `(in my_crate::foo)` to specify the custom path must be used.
 ///
 /// # Examples
 ///
@@ -571,7 +571,7 @@ pub fn impl_type_path(input: TokenStream) -> TokenStream {
                 generics,
             }
         }
-        NamedTypePathDef::Primtive(ref ident) => ReflectTypePath::Primitive(ident),
+        NamedTypePathDef::Primitive(ref ident) => ReflectTypePath::Primitive(ident),
     };
 
     let meta = ReflectMeta::new(type_path, ReflectTraits::default());
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/type_path.rs b/crates/bevy_reflect/bevy_reflect_derive/src/type_path.rs
index 5a2f8c9fae190e..3ef92981a33d97 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/type_path.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/type_path.rs
@@ -73,7 +73,7 @@ pub(crate) enum NamedTypePathDef {
         generics: Generics,
         custom_path: Option<CustomPathDef>,
     },
-    Primtive(Ident),
+    Primitive(Ident),
 }
 
 impl Parse for NamedTypePathDef {
@@ -87,7 +87,7 @@ impl Parse for NamedTypePathDef {
         if path.leading_colon.is_none() && custom_path.is_none() {
             if path.segments.len() == 1 {
                 let ident = path.segments.into_iter().next().unwrap().ident;
-                Ok(NamedTypePathDef::Primtive(ident))
+                Ok(NamedTypePathDef::Primitive(ident))
             } else {
                 Err(input.error("non-customized paths must start with a double colon (`::`)"))
             }
diff --git a/crates/bevy_reflect/src/array.rs b/crates/bevy_reflect/src/array.rs
index c1acb9835678b9..0959826fefd519 100644
--- a/crates/bevy_reflect/src/array.rs
+++ b/crates/bevy_reflect/src/array.rs
@@ -18,7 +18,7 @@ use std::{
 ///
 /// Due to the [type-erasing] nature of the reflection API as a whole,
 /// this trait does not make any guarantees that the implementor's elements
-/// are homogenous (i.e. all the same type).
+/// are homogeneous (i.e. all the same type).
 ///
 /// This trait has a blanket implementation over Rust arrays of up to 32 items.
 /// This implementation can technically contain more than 32,
diff --git a/crates/bevy_reflect/src/from_reflect.rs b/crates/bevy_reflect/src/from_reflect.rs
index ba13fbf13bf1dd..861d0b1d063d19 100644
--- a/crates/bevy_reflect/src/from_reflect.rs
+++ b/crates/bevy_reflect/src/from_reflect.rs
@@ -14,7 +14,7 @@ use crate::{FromType, Reflect};
 /// Additionally, some complex types like `Vec<T>` require that their element types
 /// implement this trait.
 /// The reason for such requirements is that some operations require new data to be constructed,
-/// such as swapping to a new variant or pushing data to a homogenous list.
+/// such as swapping to a new variant or pushing data to a homogeneous list.
 ///
 /// See the [crate-level documentation] to see how this trait can be used.
 ///
diff --git a/crates/bevy_reflect/src/impls/std.rs b/crates/bevy_reflect/src/impls/std.rs
index ab8b482c18df0f..72c79bb76511cc 100644
--- a/crates/bevy_reflect/src/impls/std.rs
+++ b/crates/bevy_reflect/src/impls/std.rs
@@ -1207,7 +1207,7 @@ impl<T: FromReflect + Clone + TypePath> List for Cow<'static, [T]> {
     }
 
     fn drain(self: Box<Self>) -> Vec<Box<dyn Reflect>> {
-        // into_owned() is not uneccessary here because it avoids cloning whenever you have a Cow::Owned already
+        // into_owned() is not unnecessary here because it avoids cloning whenever you have a Cow::Owned already
         #[allow(clippy::unnecessary_to_owned)]
         self.into_owned()
             .into_iter()
diff --git a/crates/bevy_reflect/src/list.rs b/crates/bevy_reflect/src/list.rs
index 94c269c5203c45..5eb8c7885e813c 100644
--- a/crates/bevy_reflect/src/list.rs
+++ b/crates/bevy_reflect/src/list.rs
@@ -29,7 +29,7 @@ use crate::{
 ///
 /// Due to the [type-erasing] nature of the reflection API as a whole,
 /// this trait does not make any guarantees that the implementor's elements
-/// are homogenous (i.e. all the same type).
+/// are homogeneous (i.e. all the same type).
 ///
 /// # Example
 ///
diff --git a/crates/bevy_reflect/src/type_path.rs b/crates/bevy_reflect/src/type_path.rs
index 8238c998cbb5f2..68c2e646905670 100644
--- a/crates/bevy_reflect/src/type_path.rs
+++ b/crates/bevy_reflect/src/type_path.rs
@@ -112,7 +112,7 @@ pub trait TypePath: 'static {
         None
     }
 
-    /// Returns the path to the moudle the type is in, or [`None`] if it is [anonymous].
+    /// Returns the path to the module the type is in, or [`None`] if it is [anonymous].
     ///
     /// For `Option<PhantomData>`, this is `"core::option"`.
     ///
diff --git a/crates/bevy_reflect/src/utility.rs b/crates/bevy_reflect/src/utility.rs
index 8952ffde98c993..e1072841d5b683 100644
--- a/crates/bevy_reflect/src/utility.rs
+++ b/crates/bevy_reflect/src/utility.rs
@@ -232,7 +232,7 @@ impl<T: TypedProperty> GenericTypeCell<T> {
     {
         let type_id = TypeId::of::<G>();
 
-        // Put in a seperate scope, so `mapping` is dropped before `f`,
+        // Put in a separate scope, so `mapping` is dropped before `f`,
         // since `f` might want to call `get_or_insert` recursively
         // and we don't want a deadlock!
         {
diff --git a/crates/bevy_reflect_compile_fail_tests/tests/reflect_derive/generics.fail.stderr b/crates/bevy_reflect_compile_fail_tests/tests/reflect_derive/generics.fail.stderr
index 4e0b99529567db..2c503d8a0188c4 100644
--- a/crates/bevy_reflect_compile_fail_tests/tests/reflect_derive/generics.fail.stderr
+++ b/crates/bevy_reflect_compile_fail_tests/tests/reflect_derive/generics.fail.stderr
@@ -28,5 +28,5 @@ note: required for `Foo<NoReflect>` to implement `Reflect`
 4  | #[reflect(from_reflect = false)]
 5  | struct Foo<T> {
    |        ^^^^^^
-   = note: required for the cast from `Foo<NoReflect>` to the object type `dyn Reflect`
+   = note: required for the cast from `Box<Foo<NoReflect>>` to `Box<(dyn Reflect + 'static)>`
    = note: this error originates in the derive macro `Reflect` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/bevy_render/Cargo.toml b/crates/bevy_render/Cargo.toml
index 739208248325bb..3d0ac77c11a85c 100644
--- a/crates/bevy_render/Cargo.toml
+++ b/crates/bevy_render/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_render"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides rendering functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -35,23 +35,23 @@ webgl = ["wgpu/webgl"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_core = { path = "../bevy_core", version = "0.11.0-dev" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_encase_derive = { path = "../bevy_encase_derive", version = "0.11.0-dev" }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_mikktspace = { path = "../bevy_mikktspace", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_render_macros = { path = "macros", version = "0.11.0-dev" }
-bevy_time = { path = "../bevy_time", version = "0.11.0-dev" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_window = { path = "../bevy_window", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_core = { path = "../bevy_core", version = "0.12.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_encase_derive = { path = "../bevy_encase_derive", version = "0.12.0-dev" }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.12.0-dev" }
+bevy_log = { path = "../bevy_log", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_mikktspace = { path = "../bevy_mikktspace", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_render_macros = { path = "macros", version = "0.12.0-dev" }
+bevy_time = { path = "../bevy_time", version = "0.12.0-dev" }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_window = { path = "../bevy_window", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.12.0-dev" }
 
 # rendering
 image = { version = "0.24", default-features = false }
diff --git a/crates/bevy_render/macros/Cargo.toml b/crates/bevy_render/macros/Cargo.toml
index 6f177ab2174b36..5ffcadfc98b361 100644
--- a/crates/bevy_render/macros/Cargo.toml
+++ b/crates/bevy_render/macros/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_render_macros"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Derive implementations for bevy_render"
 homepage = "https://bevyengine.org"
@@ -12,7 +12,7 @@ keywords = ["bevy"]
 proc-macro = true
 
 [dependencies]
-bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.11.0-dev" }
+bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.12.0-dev" }
 
 syn = "2.0"
 proc-macro2 = "1.0"
diff --git a/crates/bevy_render/macros/src/as_bind_group.rs b/crates/bevy_render/macros/src/as_bind_group.rs
index 06f58aea2db88d..df137e95d8b554 100644
--- a/crates/bevy_render/macros/src/as_bind_group.rs
+++ b/crates/bevy_render/macros/src/as_bind_group.rs
@@ -217,7 +217,7 @@ pub fn derive_as_bind_group(ast: syn::DeriveInput) -> Result<TokenStream> {
                         buffer,
                     } = get_storage_binding_attr(nested_meta_items)?;
                     let visibility =
-                        visibility.hygenic_quote(&quote! { #render_path::render_resource });
+                        visibility.hygienic_quote(&quote! { #render_path::render_resource });
 
                     let field_name = field.ident.as_ref().unwrap();
                     let field_ty = &field.ty;
@@ -271,7 +271,7 @@ pub fn derive_as_bind_group(ast: syn::DeriveInput) -> Result<TokenStream> {
                     } = tex_attrs.as_ref().unwrap();
 
                     let visibility =
-                        visibility.hygenic_quote(&quote! { #render_path::render_resource });
+                        visibility.hygienic_quote(&quote! { #render_path::render_resource });
 
                     let fallback_image = get_fallback_image(&render_path, *dimension);
 
@@ -310,7 +310,7 @@ pub fn derive_as_bind_group(ast: syn::DeriveInput) -> Result<TokenStream> {
                         .expect("sampler attribute must have matching texture attribute");
 
                     let visibility =
-                        visibility.hygenic_quote(&quote! { #render_path::render_resource });
+                        visibility.hygienic_quote(&quote! { #render_path::render_resource });
 
                     let fallback_image = get_fallback_image(&render_path, *dimension);
 
@@ -606,7 +606,7 @@ impl VisibilityFlags {
 }
 
 impl ShaderStageVisibility {
-    fn hygenic_quote(&self, path: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {
+    fn hygienic_quote(&self, path: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {
         match self {
             ShaderStageVisibility::All => quote! { #path::ShaderStages::all() },
             ShaderStageVisibility::None => quote! { #path::ShaderStages::NONE },
diff --git a/crates/bevy_render/src/camera/camera.rs b/crates/bevy_render/src/camera/camera.rs
index 9c174169605dec..76514019702348 100644
--- a/crates/bevy_render/src/camera/camera.rs
+++ b/crates/bevy_render/src/camera/camera.rs
@@ -19,7 +19,7 @@ use bevy_ecs::{
     system::{Commands, Query, Res, ResMut, Resource},
 };
 use bevy_log::warn;
-use bevy_math::{Mat4, Ray, Rect, UVec2, UVec4, Vec2, Vec3};
+use bevy_math::{Mat4, Ray, Rect, URect, UVec2, UVec4, Vec2, Vec3};
 use bevy_reflect::prelude::*;
 use bevy_transform::components::GlobalTransform;
 use bevy_utils::{HashMap, HashSet};
@@ -138,18 +138,18 @@ impl Camera {
         Some((physical_size.as_dvec2() / scale).as_vec2())
     }
 
-    /// The rendered physical bounds (minimum, maximum) of the camera. If the `viewport` field is
+    /// The rendered physical bounds [`URect`] of the camera. If the `viewport` field is
     /// set to [`Some`], this will be the rect of that custom viewport. Otherwise it will default to
     /// the full physical rect of the current [`RenderTarget`].
     #[inline]
-    pub fn physical_viewport_rect(&self) -> Option<(UVec2, UVec2)> {
+    pub fn physical_viewport_rect(&self) -> Option<URect> {
         let min = self
             .viewport
             .as_ref()
             .map(|v| v.physical_position)
             .unwrap_or(UVec2::ZERO);
         let max = min + self.physical_viewport_size()?;
-        Some((min, max))
+        Some(URect { min, max })
     }
 
     /// The rendered logical bounds [`Rect`] of the camera. If the `viewport` field is set to
@@ -157,7 +157,7 @@ impl Camera {
     /// full logical rect of the current [`RenderTarget`].
     #[inline]
     pub fn logical_viewport_rect(&self) -> Option<Rect> {
-        let (min, max) = self.physical_viewport_rect()?;
+        let URect { min, max } = self.physical_viewport_rect()?;
         Some(Rect {
             min: self.to_logical(min)?,
             max: self.to_logical(max)?,
@@ -636,7 +636,14 @@ pub fn extract_cameras(
             continue;
         }
 
-        if let (Some((viewport_origin, _)), Some(viewport_size), Some(target_size)) = (
+        if let (
+            Some(URect {
+                min: viewport_origin,
+                ..
+            }),
+            Some(viewport_size),
+            Some(target_size),
+        ) = (
             camera.physical_viewport_rect(),
             camera.physical_viewport_size(),
             camera.physical_target_size(),
diff --git a/crates/bevy_render/src/mesh/morph.rs b/crates/bevy_render/src/mesh/morph.rs
index c6eba94b477e11..be52d1f59b495c 100644
--- a/crates/bevy_render/src/mesh/morph.rs
+++ b/crates/bevy_render/src/mesh/morph.rs
@@ -104,7 +104,7 @@ impl MorphTargetImage {
 }
 
 /// Controls the [morph targets] for all child [`Handle<Mesh>`] entities. In most cases, [`MorphWeights`] should be considered
-/// the "source o[f truth" when writing morph targets for meshes. However you can choose to write child [`MeshMorphWeights`]
+/// the "source of truth" when writing morph targets for meshes. However you can choose to write child [`MeshMorphWeights`]
 /// if your situation requires more granularity. Just note that if you set [`MorphWeights`], it will overwrite child
 /// [`MeshMorphWeights`] values.
 ///
diff --git a/crates/bevy_scene/Cargo.toml b/crates/bevy_scene/Cargo.toml
index 86a40b7ed75a22..b408a45ea762bc 100644
--- a/crates/bevy_scene/Cargo.toml
+++ b/crates/bevy_scene/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_scene"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides scene functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -14,15 +14,15 @@ serialize = ["dep:serde", "uuid/serde"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0-dev" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_render = { path = "../bevy_render", version = "0.11.0-dev", optional = true }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.12.0-dev" }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_render = { path = "../bevy_render", version = "0.12.0-dev", optional = true }
 
 # other
 serde = { version = "1.0", features = ["derive"], optional = true }
diff --git a/crates/bevy_scene/src/dynamic_scene.rs b/crates/bevy_scene/src/dynamic_scene.rs
index 0ec7c99eca92d5..6ede5728342834 100644
--- a/crates/bevy_scene/src/dynamic_scene.rs
+++ b/crates/bevy_scene/src/dynamic_scene.rs
@@ -45,14 +45,13 @@ pub struct DynamicEntity {
 
 impl DynamicScene {
     /// Create a new dynamic scene from a given scene.
-    pub fn from_scene(scene: &Scene, type_registry: &AppTypeRegistry) -> Self {
-        Self::from_world(&scene.world, type_registry)
+    pub fn from_scene(scene: &Scene) -> Self {
+        Self::from_world(&scene.world)
     }
 
     /// Create a new dynamic scene from a given world.
-    pub fn from_world(world: &World, type_registry: &AppTypeRegistry) -> Self {
-        let mut builder =
-            DynamicSceneBuilder::from_world_with_type_registry(world, type_registry.clone());
+    pub fn from_world(world: &World) -> Self {
+        let mut builder = DynamicSceneBuilder::from_world(world);
 
         builder.extract_entities(world.iter_entities().map(|entity| entity.id()));
         builder.extract_resources();
diff --git a/crates/bevy_scene/src/dynamic_scene_builder.rs b/crates/bevy_scene/src/dynamic_scene_builder.rs
index 484262ba18dd9c..62e5a3ed1f348b 100644
--- a/crates/bevy_scene/src/dynamic_scene_builder.rs
+++ b/crates/bevy_scene/src/dynamic_scene_builder.rs
@@ -1,5 +1,6 @@
-use crate::{DynamicEntity, DynamicScene};
-use bevy_ecs::component::ComponentId;
+use crate::{DynamicEntity, DynamicScene, SceneFilter};
+use bevy_ecs::component::{Component, ComponentId};
+use bevy_ecs::system::Resource;
 use bevy_ecs::{
     prelude::Entity,
     reflect::{AppTypeRegistry, ReflectComponent, ReflectResource},
@@ -11,9 +12,27 @@ use std::collections::BTreeMap;
 
 /// A [`DynamicScene`] builder, used to build a scene from a [`World`] by extracting some entities and resources.
 ///
+/// # Component Extraction
+///
+/// By default, all components registered with [`ReflectComponent`] type data in a world's [`AppTypeRegistry`] will be extracted.
+/// (this type data is added automatically during registration if [`Reflect`] is derived with the `#[reflect(Component)]` attribute).
+/// This can be changed by [specifying a filter](DynamicSceneBuilder::with_filter) or by explicitly
+/// [allowing](DynamicSceneBuilder::allow)/[denying](DynamicSceneBuilder::deny) certain components.
+///
+/// Extraction happens immediately and uses the filter as it exists during the time of extraction.
+///
+/// # Resource Extraction
+///
+/// By default, all resources registered with [`ReflectResource`] type data in a world's [`AppTypeRegistry`] will be extracted.
+/// (this type data is added automatically during registration if [`Reflect`] is derived with the `#[reflect(Resource)]` attribute).
+/// This can be changed by [specifying a filter](DynamicSceneBuilder::with_resource_filter) or by explicitly
+/// [allowing](DynamicSceneBuilder::allow_resource)/[denying](DynamicSceneBuilder::deny_resource) certain resources.
+///
+/// Extraction happens immediately and uses the filter as it exists during the time of extraction.
+///
 /// # Entity Order
 ///
-/// Extracted entities will always be stored in ascending order based on their [id](Entity::index).
+/// Extracted entities will always be stored in ascending order based on their [index](Entity::index).
 /// This means that inserting `Entity(1v0)` then `Entity(0v0)` will always result in the entities
 /// being ordered as `[Entity(0v0), Entity(1v0)]`.
 ///
@@ -38,31 +57,117 @@ use std::collections::BTreeMap;
 pub struct DynamicSceneBuilder<'w> {
     extracted_resources: BTreeMap<ComponentId, Box<dyn Reflect>>,
     extracted_scene: BTreeMap<Entity, DynamicEntity>,
-    type_registry: AppTypeRegistry,
+    component_filter: SceneFilter,
+    resource_filter: SceneFilter,
     original_world: &'w World,
 }
 
 impl<'w> DynamicSceneBuilder<'w> {
     /// Prepare a builder that will extract entities and their component from the given [`World`].
-    /// All components registered in that world's [`AppTypeRegistry`] resource will be extracted.
     pub fn from_world(world: &'w World) -> Self {
         Self {
             extracted_resources: default(),
             extracted_scene: default(),
-            type_registry: world.resource::<AppTypeRegistry>().clone(),
+            component_filter: SceneFilter::default(),
+            resource_filter: SceneFilter::default(),
             original_world: world,
         }
     }
 
-    /// Prepare a builder that will extract entities and their component from the given [`World`].
-    /// Only components registered in the given [`AppTypeRegistry`] will be extracted.
-    pub fn from_world_with_type_registry(world: &'w World, type_registry: AppTypeRegistry) -> Self {
-        Self {
-            extracted_resources: default(),
-            extracted_scene: default(),
-            type_registry,
-            original_world: world,
-        }
+    /// Specify a custom component [`SceneFilter`] to be used with this builder.
+    pub fn with_filter(&mut self, filter: SceneFilter) -> &mut Self {
+        self.component_filter = filter;
+        self
+    }
+
+    /// Specify a custom resource [`SceneFilter`] to be used with this builder.
+    pub fn with_resource_filter(&mut self, filter: SceneFilter) -> &mut Self {
+        self.resource_filter = filter;
+        self
+    }
+
+    /// Allows the given component type, `T`, to be included in the generated scene.
+    ///
+    /// This method may be called multiple times for any number of components.
+    ///
+    /// This is the inverse of [`deny`](Self::deny).
+    /// If `T` has already been denied, then it will be removed from the denylist.
+    pub fn allow<T: Component>(&mut self) -> &mut Self {
+        self.component_filter.allow::<T>();
+        self
+    }
+
+    /// Denies the given component type, `T`, from being included in the generated scene.
+    ///
+    /// This method may be called multiple times for any number of components.
+    ///
+    /// This is the inverse of [`allow`](Self::allow).
+    /// If `T` has already been allowed, then it will be removed from the allowlist.
+    pub fn deny<T: Component>(&mut self) -> &mut Self {
+        self.component_filter.deny::<T>();
+        self
+    }
+
+    /// Updates the filter to allow all component types.
+    ///
+    /// This is useful for resetting the filter so that types may be selectively [denied].
+    ///
+    /// [denied]: Self::deny
+    pub fn allow_all(&mut self) -> &mut Self {
+        self.component_filter = SceneFilter::allow_all();
+        self
+    }
+
+    /// Updates the filter to deny all component types.
+    ///
+    /// This is useful for resetting the filter so that types may be selectively [allowed].
+    ///
+    /// [allowed]: Self::allow
+    pub fn deny_all(&mut self) -> &mut Self {
+        self.component_filter = SceneFilter::deny_all();
+        self
+    }
+
+    /// Allows the given resource type, `T`, to be included in the generated scene.
+    ///
+    /// This method may be called multiple times for any number of resources.
+    ///
+    /// This is the inverse of [`deny_resource`](Self::deny_resource).
+    /// If `T` has already been denied, then it will be removed from the denylist.
+    pub fn allow_resource<T: Resource>(&mut self) -> &mut Self {
+        self.resource_filter.allow::<T>();
+        self
+    }
+
+    /// Denies the given resource type, `T`, from being included in the generated scene.
+    ///
+    /// This method may be called multiple times for any number of resources.
+    ///
+    /// This is the inverse of [`allow_resource`](Self::allow_resource).
+    /// If `T` has already been allowed, then it will be removed from the allowlist.
+    pub fn deny_resource<T: Resource>(&mut self) -> &mut Self {
+        self.resource_filter.deny::<T>();
+        self
+    }
+
+    /// Updates the filter to allow all resource types.
+    ///
+    /// This is useful for resetting the filter so that types may be selectively [denied].
+    ///
+    /// [denied]: Self::deny_resource
+    pub fn allow_all_resources(&mut self) -> &mut Self {
+        self.resource_filter = SceneFilter::allow_all();
+        self
+    }
+
+    /// Updates the filter to deny all resource types.
+    ///
+    /// This is useful for resetting the filter so that types may be selectively [allowed].
+    ///
+    /// [allowed]: Self::allow_resource
+    pub fn deny_all_resources(&mut self) -> &mut Self {
+        self.resource_filter = SceneFilter::deny_all();
+        self
     }
 
     /// Consume the builder, producing a [`DynamicScene`].
@@ -97,7 +202,10 @@ impl<'w> DynamicSceneBuilder<'w> {
     ///
     /// Re-extracting an entity that was already extracted will have no effect.
     ///
-    /// Extracting entities can be used to extract entities from a query:
+    /// To control which components are extracted, use the [`allow`] or
+    /// [`deny`] helper methods.
+    ///
+    /// This method may be used to extract entities from a query:
     /// ```
     /// # use bevy_scene::DynamicSceneBuilder;
     /// # use bevy_ecs::reflect::AppTypeRegistry;
@@ -118,8 +226,13 @@ impl<'w> DynamicSceneBuilder<'w> {
     /// builder.extract_entities(query.iter(&world));
     /// let scene = builder.build();
     /// ```
+    ///
+    /// Note that components extracted from queried entities must still pass through the filter if one is set.
+    ///
+    /// [`allow`]: Self::allow
+    /// [`deny`]: Self::deny
     pub fn extract_entities(&mut self, entities: impl Iterator<Item = Entity>) -> &mut Self {
-        let type_registry = self.type_registry.read();
+        let type_registry = self.original_world.resource::<AppTypeRegistry>().read();
 
         for entity in entities {
             if self.extracted_scene.contains_key(&entity) {
@@ -139,6 +252,14 @@ impl<'w> DynamicSceneBuilder<'w> {
                         .components()
                         .get_info(component_id)?
                         .type_id()?;
+
+                    let is_denied = self.component_filter.is_denied_by_id(type_id);
+
+                    if is_denied {
+                        // Component is either in the denylist or _not_ in the allowlist
+                        return None;
+                    }
+
                     let component = type_registry
                         .get(type_id)?
                         .data::<ReflectComponent>()?
@@ -151,14 +272,16 @@ impl<'w> DynamicSceneBuilder<'w> {
             self.extracted_scene.insert(entity, entry);
         }
 
-        drop(type_registry);
         self
     }
 
     /// Extract resources from the builder's [`World`].
     ///
-    /// Only resources registered in the builder's [`AppTypeRegistry`] will be extracted.
     /// Re-extracting a resource that was already extracted will have no effect.
+    ///
+    /// To control which resources are extracted, use the [`allow_resource`] or
+    /// [`deny_resource`] helper methods.
+    ///
     /// ```
     /// # use bevy_scene::DynamicSceneBuilder;
     /// # use bevy_ecs::reflect::AppTypeRegistry;
@@ -176,8 +299,12 @@ impl<'w> DynamicSceneBuilder<'w> {
     /// builder.extract_resources();
     /// let scene = builder.build();
     /// ```
+    ///
+    /// [`allow_resource`]: Self::allow_resource
+    /// [`deny_resource`]: Self::deny_resource
     pub fn extract_resources(&mut self) -> &mut Self {
-        let type_registry = self.type_registry.read();
+        let type_registry = self.original_world.resource::<AppTypeRegistry>().read();
+
         for (component_id, _) in self.original_world.storages().resources.iter() {
             let mut extract_and_push = || {
                 let type_id = self
@@ -185,6 +312,14 @@ impl<'w> DynamicSceneBuilder<'w> {
                     .components()
                     .get_info(component_id)?
                     .type_id()?;
+
+                let is_denied = self.resource_filter.is_denied_by_id(type_id);
+
+                if is_denied {
+                    // Resource is either in the denylist or _not_ in the allowlist
+                    return None;
+                }
+
                 let resource = type_registry
                     .get(type_id)?
                     .data::<ReflectResource>()?
@@ -225,6 +360,10 @@ mod tests {
     #[reflect(Resource)]
     struct ResourceA;
 
+    #[derive(Resource, Reflect, Default, Eq, PartialEq, Debug)]
+    #[reflect(Resource)]
+    struct ResourceB;
+
     #[test]
     fn extract_one_entity() {
         let mut world = World::default();
@@ -401,4 +540,106 @@ mod tests {
         assert_eq!(scene.resources.len(), 1);
         assert!(scene.resources[0].represents::<ResourceA>());
     }
+
+    #[test]
+    fn should_extract_allowed_components() {
+        let mut world = World::default();
+
+        let atr = AppTypeRegistry::default();
+        {
+            let mut register = atr.write();
+            register.register::<ComponentA>();
+            register.register::<ComponentB>();
+        }
+        world.insert_resource(atr);
+
+        let entity_a_b = world.spawn((ComponentA, ComponentB)).id();
+        let entity_a = world.spawn(ComponentA).id();
+        let entity_b = world.spawn(ComponentB).id();
+
+        let mut builder = DynamicSceneBuilder::from_world(&world);
+        builder
+            .allow::<ComponentA>()
+            .extract_entities([entity_a_b, entity_a, entity_b].into_iter());
+        let scene = builder.build();
+
+        assert_eq!(scene.entities.len(), 3);
+        assert!(scene.entities[0].components[0].represents::<ComponentA>());
+        assert!(scene.entities[1].components[0].represents::<ComponentA>());
+        assert_eq!(scene.entities[2].components.len(), 0);
+    }
+
+    #[test]
+    fn should_not_extract_denied_components() {
+        let mut world = World::default();
+
+        let atr = AppTypeRegistry::default();
+        {
+            let mut register = atr.write();
+            register.register::<ComponentA>();
+            register.register::<ComponentB>();
+        }
+        world.insert_resource(atr);
+
+        let entity_a_b = world.spawn((ComponentA, ComponentB)).id();
+        let entity_a = world.spawn(ComponentA).id();
+        let entity_b = world.spawn(ComponentB).id();
+
+        let mut builder = DynamicSceneBuilder::from_world(&world);
+        builder
+            .deny::<ComponentA>()
+            .extract_entities([entity_a_b, entity_a, entity_b].into_iter());
+        let scene = builder.build();
+
+        assert_eq!(scene.entities.len(), 3);
+        assert!(scene.entities[0].components[0].represents::<ComponentB>());
+        assert_eq!(scene.entities[1].components.len(), 0);
+        assert!(scene.entities[2].components[0].represents::<ComponentB>());
+    }
+
+    #[test]
+    fn should_extract_allowed_resources() {
+        let mut world = World::default();
+
+        let atr = AppTypeRegistry::default();
+        {
+            let mut register = atr.write();
+            register.register::<ResourceA>();
+            register.register::<ResourceB>();
+        }
+        world.insert_resource(atr);
+
+        world.insert_resource(ResourceA);
+        world.insert_resource(ResourceB);
+
+        let mut builder = DynamicSceneBuilder::from_world(&world);
+        builder.allow_resource::<ResourceA>().extract_resources();
+        let scene = builder.build();
+
+        assert_eq!(scene.resources.len(), 1);
+        assert!(scene.resources[0].represents::<ResourceA>());
+    }
+
+    #[test]
+    fn should_not_extract_denied_resources() {
+        let mut world = World::default();
+
+        let atr = AppTypeRegistry::default();
+        {
+            let mut register = atr.write();
+            register.register::<ResourceA>();
+            register.register::<ResourceB>();
+        }
+        world.insert_resource(atr);
+
+        world.insert_resource(ResourceA);
+        world.insert_resource(ResourceB);
+
+        let mut builder = DynamicSceneBuilder::from_world(&world);
+        builder.deny_resource::<ResourceA>().extract_resources();
+        let scene = builder.build();
+
+        assert_eq!(scene.resources.len(), 1);
+        assert!(scene.resources[0].represents::<ResourceB>());
+    }
 }
diff --git a/crates/bevy_scene/src/lib.rs b/crates/bevy_scene/src/lib.rs
index 4185d1886285c1..e3ca8a2fee5739 100644
--- a/crates/bevy_scene/src/lib.rs
+++ b/crates/bevy_scene/src/lib.rs
@@ -4,6 +4,7 @@ mod bundle;
 mod dynamic_scene;
 mod dynamic_scene_builder;
 mod scene;
+mod scene_filter;
 mod scene_loader;
 mod scene_spawner;
 
@@ -14,13 +15,15 @@ pub use bundle::*;
 pub use dynamic_scene::*;
 pub use dynamic_scene_builder::*;
 pub use scene::*;
+pub use scene_filter::*;
 pub use scene_loader::*;
 pub use scene_spawner::*;
 
 pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
-        DynamicScene, DynamicSceneBuilder, DynamicSceneBundle, Scene, SceneBundle, SceneSpawner,
+        DynamicScene, DynamicSceneBuilder, DynamicSceneBundle, Scene, SceneBundle, SceneFilter,
+        SceneSpawner,
     };
 }
 
diff --git a/crates/bevy_scene/src/scene_filter.rs b/crates/bevy_scene/src/scene_filter.rs
new file mode 100644
index 00000000000000..a5076e5d9d668b
--- /dev/null
+++ b/crates/bevy_scene/src/scene_filter.rs
@@ -0,0 +1,278 @@
+use bevy_utils::hashbrown::hash_set::IntoIter;
+use bevy_utils::HashSet;
+use std::any::{Any, TypeId};
+
+/// A filter used to control which types can be added to a [`DynamicScene`].
+///
+/// This scene filter _can_ be used more generically to represent a filter for any given type;
+/// however, note that its intended usage with `DynamicScene` only considers [components] and [resources].
+/// Adding types that are not a component or resource will have no effect when used with `DynamicScene`.
+///
+/// [`DynamicScene`]: crate::DynamicScene
+/// [components]: bevy_ecs::prelude::Component
+/// [resources]: bevy_ecs::prelude::Resource
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub enum SceneFilter {
+    /// Represents an unset filter.
+    ///
+    /// This is the equivalent of an empty [`Denylist`] or an [`Allowlist`] containing every type—
+    /// essentially, all types are permissible.
+    ///
+    /// [Allowing] a type will convert this filter to an `Allowlist`.
+    /// Similarly, [denying] a type will convert this filter to a `Denylist`.
+    ///
+    /// [`Denylist`]: SceneFilter::Denylist
+    /// [`Allowlist`]: SceneFilter::Allowlist
+    /// [Allowing]: SceneFilter::allow
+    /// [denying]: SceneFilter::deny
+    #[default]
+    Unset,
+    /// Contains the set of permitted types by their [`TypeId`].
+    ///
+    /// Types not contained within this set should not be allowed to be saved to an associated [`DynamicScene`].
+    ///
+    /// [`DynamicScene`]: crate::DynamicScene
+    Allowlist(HashSet<TypeId>),
+    /// Contains the set of prohibited types by their [`TypeId`].
+    ///
+    /// Types contained within this set should not be allowed to be saved to an associated [`DynamicScene`].
+    ///
+    /// [`DynamicScene`]: crate::DynamicScene
+    Denylist(HashSet<TypeId>),
+}
+
+impl SceneFilter {
+    /// Creates a filter where all types are allowed.
+    ///
+    /// This is the equivalent of creating an empty [`Denylist`].
+    ///
+    /// [`Denylist`]: SceneFilter::Denylist
+    pub fn allow_all() -> Self {
+        Self::Denylist(HashSet::new())
+    }
+
+    /// Creates a filter where all types are denied.
+    ///
+    /// This is the equivalent of creating an empty [`Allowlist`].
+    ///
+    /// [`Allowlist`]: SceneFilter::Allowlist
+    pub fn deny_all() -> Self {
+        Self::Allowlist(HashSet::new())
+    }
+
+    /// Allow the given type, `T`.
+    ///
+    /// If this filter is already set as a [`Denylist`],
+    /// then the given type will be removed from the denied set.
+    ///
+    /// If this filter is [`Unset`], then it will be completely replaced by a new [`Allowlist`].
+    ///
+    /// [`Denylist`]: SceneFilter::Denylist
+    /// [`Unset`]: SceneFilter::Unset
+    /// [`Allowlist`]: SceneFilter::Allowlist
+    pub fn allow<T: Any>(&mut self) -> &mut Self {
+        self.allow_by_id(TypeId::of::<T>())
+    }
+
+    /// Allow the given type.
+    ///
+    /// If this filter is already set as a [`Denylist`],
+    /// then the given type will be removed from the denied set.
+    ///
+    /// If this filter is [`Unset`], then it will be completely replaced by a new [`Allowlist`].
+    ///
+    /// [`Denylist`]: SceneFilter::Denylist
+    /// [`Unset`]: SceneFilter::Unset
+    /// [`Allowlist`]: SceneFilter::Allowlist
+    pub fn allow_by_id(&mut self, type_id: TypeId) -> &mut Self {
+        match self {
+            Self::Unset => {
+                *self = Self::Allowlist(HashSet::from([type_id]));
+            }
+            Self::Allowlist(list) => {
+                list.insert(type_id);
+            }
+            Self::Denylist(list) => {
+                list.remove(&type_id);
+            }
+        }
+        self
+    }
+
+    /// Deny the given type, `T`.
+    ///
+    /// If this filter is already set as an [`Allowlist`],
+    /// then the given type will be removed from the allowed set.
+    ///
+    /// If this filter is [`Unset`], then it will be completely replaced by a new [`Denylist`].
+    ///
+    /// [`Allowlist`]: SceneFilter::Allowlist
+    /// [`Unset`]: SceneFilter::Unset
+    /// [`Denylist`]: SceneFilter::Denylist
+    pub fn deny<T: Any>(&mut self) -> &mut Self {
+        self.deny_by_id(TypeId::of::<T>())
+    }
+
+    /// Deny the given type.
+    ///
+    /// If this filter is already set as an [`Allowlist`],
+    /// then the given type will be removed from the allowed set.
+    ///
+    /// If this filter is [`Unset`], then it will be completely replaced by a new [`Denylist`].
+    ///
+    /// [`Allowlist`]: SceneFilter::Allowlist
+    /// [`Unset`]: SceneFilter::Unset
+    /// [`Denylist`]: SceneFilter::Denylist
+    pub fn deny_by_id(&mut self, type_id: TypeId) -> &mut Self {
+        match self {
+            Self::Unset => *self = Self::Denylist(HashSet::from([type_id])),
+            Self::Allowlist(list) => {
+                list.remove(&type_id);
+            }
+            Self::Denylist(list) => {
+                list.insert(type_id);
+            }
+        }
+        self
+    }
+
+    /// Returns true if the given type, `T`, is allowed by the filter.
+    ///
+    /// If the filter is [`Unset`], this will always return `true`.
+    ///
+    /// [`Unset`]: SceneFilter::Unset
+    pub fn is_allowed<T: Any>(&self) -> bool {
+        self.is_allowed_by_id(TypeId::of::<T>())
+    }
+
+    /// Returns true if the given type is allowed by the filter.
+    ///
+    /// If the filter is [`Unset`], this will always return `true`.
+    ///
+    /// [`Unset`]: SceneFilter::Unset
+    pub fn is_allowed_by_id(&self, type_id: TypeId) -> bool {
+        match self {
+            Self::Unset => true,
+            Self::Allowlist(list) => list.contains(&type_id),
+            Self::Denylist(list) => !list.contains(&type_id),
+        }
+    }
+
+    /// Returns true if the given type, `T`, is denied by the filter.
+    ///
+    /// If the filter is [`Unset`], this will always return `false`.
+    ///
+    /// [`Unset`]: SceneFilter::Unset
+    pub fn is_denied<T: Any>(&self) -> bool {
+        self.is_denied_by_id(TypeId::of::<T>())
+    }
+
+    /// Returns true if the given type is denied by the filter.
+    ///
+    /// If the filter is [`Unset`], this will always return `false`.
+    ///
+    /// [`Unset`]: SceneFilter::Unset
+    pub fn is_denied_by_id(&self, type_id: TypeId) -> bool {
+        !self.is_allowed_by_id(type_id)
+    }
+
+    /// Returns an iterator over the items in the filter.
+    ///
+    /// If the filter is [`Unset`], this will return an empty iterator.
+    ///
+    /// [`Unset`]: SceneFilter::Unset
+    pub fn iter(&self) -> Box<dyn ExactSizeIterator<Item = &TypeId> + '_> {
+        match self {
+            Self::Unset => Box::new(core::iter::empty()),
+            Self::Allowlist(list) | Self::Denylist(list) => Box::new(list.iter()),
+        }
+    }
+
+    /// Returns the number of items in the filter.
+    ///
+    /// If the filter is [`Unset`], this will always return a length of zero.
+    ///
+    /// [`Unset`]: SceneFilter::Unset
+    pub fn len(&self) -> usize {
+        match self {
+            Self::Unset => 0,
+            Self::Allowlist(list) | Self::Denylist(list) => list.len(),
+        }
+    }
+
+    /// Returns true if there are zero items in the filter.
+    ///
+    /// If the filter is [`Unset`], this will always return `true`.
+    ///
+    /// [`Unset`]: SceneFilter::Unset
+    pub fn is_empty(&self) -> bool {
+        match self {
+            Self::Unset => true,
+            Self::Allowlist(list) | Self::Denylist(list) => list.is_empty(),
+        }
+    }
+}
+
+impl IntoIterator for SceneFilter {
+    type Item = TypeId;
+    type IntoIter = IntoIter<TypeId>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        match self {
+            Self::Unset => HashSet::new().into_iter(),
+            Self::Allowlist(list) | Self::Denylist(list) => list.into_iter(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn should_set_list_type_if_none() {
+        let mut filter = SceneFilter::Unset;
+        filter.allow::<i32>();
+        assert!(matches!(filter, SceneFilter::Allowlist(_)));
+
+        let mut filter = SceneFilter::Unset;
+        filter.deny::<i32>();
+        assert!(matches!(filter, SceneFilter::Denylist(_)));
+    }
+
+    #[test]
+    fn should_add_to_list() {
+        let mut filter = SceneFilter::default();
+        filter.allow::<i16>();
+        filter.allow::<i32>();
+        assert_eq!(2, filter.len());
+        assert!(filter.is_allowed::<i16>());
+        assert!(filter.is_allowed::<i32>());
+
+        let mut filter = SceneFilter::default();
+        filter.deny::<i16>();
+        filter.deny::<i32>();
+        assert_eq!(2, filter.len());
+        assert!(filter.is_denied::<i16>());
+        assert!(filter.is_denied::<i32>());
+    }
+
+    #[test]
+    fn should_remove_from_list() {
+        let mut filter = SceneFilter::default();
+        filter.allow::<i16>();
+        filter.allow::<i32>();
+        filter.deny::<i32>();
+        assert_eq!(1, filter.len());
+        assert!(filter.is_allowed::<i16>());
+        assert!(!filter.is_allowed::<i32>());
+
+        let mut filter = SceneFilter::default();
+        filter.deny::<i16>();
+        filter.deny::<i32>();
+        filter.allow::<i32>();
+        assert_eq!(1, filter.len());
+        assert!(filter.is_denied::<i16>());
+        assert!(!filter.is_denied::<i32>());
+    }
+}
diff --git a/crates/bevy_scene/src/serde.rs b/crates/bevy_scene/src/serde.rs
index a16a8d8957543b..492c6ac33077ed 100644
--- a/crates/bevy_scene/src/serde.rs
+++ b/crates/bevy_scene/src/serde.rs
@@ -630,7 +630,7 @@ mod tests {
 
         let registry = world.resource::<AppTypeRegistry>();
 
-        let scene = DynamicScene::from_world(&world, registry);
+        let scene = DynamicScene::from_world(&world);
 
         let serialized = scene
             .serialize_ron(&world.resource::<AppTypeRegistry>().0)
@@ -680,7 +680,7 @@ mod tests {
 
         let registry = world.resource::<AppTypeRegistry>();
 
-        let scene = DynamicScene::from_world(&world, registry);
+        let scene = DynamicScene::from_world(&world);
 
         let scene_serializer = SceneSerializer::new(&scene, &registry.0);
         let serialized_scene = postcard::to_allocvec(&scene_serializer).unwrap();
@@ -718,7 +718,7 @@ mod tests {
 
         let registry = world.resource::<AppTypeRegistry>();
 
-        let scene = DynamicScene::from_world(&world, registry);
+        let scene = DynamicScene::from_world(&world);
 
         let scene_serializer = SceneSerializer::new(&scene, &registry.0);
         let mut buf = Vec::new();
@@ -761,7 +761,7 @@ mod tests {
 
         let registry = world.resource::<AppTypeRegistry>();
 
-        let scene = DynamicScene::from_world(&world, registry);
+        let scene = DynamicScene::from_world(&world);
 
         let scene_serializer = SceneSerializer::new(&scene, &registry.0);
         let serialized_scene = bincode::serialize(&scene_serializer).unwrap();
@@ -835,8 +835,7 @@ mod tests {
         #[should_panic(expected = "entity count did not match")]
         fn should_panic_when_entity_count_not_eq() {
             let mut world = create_world();
-            let registry = world.resource::<AppTypeRegistry>();
-            let scene_a = DynamicScene::from_world(&world, registry);
+            let scene_a = DynamicScene::from_world(&world);
 
             world.spawn(MyComponent {
                 foo: [1, 2, 3],
@@ -844,8 +843,7 @@ mod tests {
                 baz: MyEnum::Unit,
             });
 
-            let registry = world.resource::<AppTypeRegistry>();
-            let scene_b = DynamicScene::from_world(&world, registry);
+            let scene_b = DynamicScene::from_world(&world);
 
             assert_scene_eq(&scene_a, &scene_b);
         }
@@ -863,8 +861,7 @@ mod tests {
                 })
                 .id();
 
-            let registry = world.resource::<AppTypeRegistry>();
-            let scene_a = DynamicScene::from_world(&world, registry);
+            let scene_a = DynamicScene::from_world(&world);
 
             world.entity_mut(entity).insert(MyComponent {
                 foo: [3, 2, 1],
@@ -872,8 +869,7 @@ mod tests {
                 baz: MyEnum::Unit,
             });
 
-            let registry = world.resource::<AppTypeRegistry>();
-            let scene_b = DynamicScene::from_world(&world, registry);
+            let scene_b = DynamicScene::from_world(&world);
 
             assert_scene_eq(&scene_a, &scene_b);
         }
@@ -891,13 +887,11 @@ mod tests {
                 })
                 .id();
 
-            let registry = world.resource::<AppTypeRegistry>();
-            let scene_a = DynamicScene::from_world(&world, registry);
+            let scene_a = DynamicScene::from_world(&world);
 
             world.entity_mut(entity).remove::<MyComponent>();
 
-            let registry = world.resource::<AppTypeRegistry>();
-            let scene_b = DynamicScene::from_world(&world, registry);
+            let scene_b = DynamicScene::from_world(&world);
 
             assert_scene_eq(&scene_a, &scene_b);
         }
diff --git a/crates/bevy_sprite/Cargo.toml b/crates/bevy_sprite/Cargo.toml
index c3c522b10b9d41..37db1b9eb2a203 100644
--- a/crates/bevy_sprite/Cargo.toml
+++ b/crates/bevy_sprite/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_sprite"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides sprite functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,19 +10,19 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = [
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_log = { path = "../bevy_log", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = [
     "bevy",
 ] }
-bevy_render = { path = "../bevy_render", version = "0.11.0-dev" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
+bevy_render = { path = "../bevy_render", version = "0.12.0-dev" }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
 
 # other
 bytemuck = { version = "1.5", features = ["derive"] }
diff --git a/crates/bevy_tasks/Cargo.toml b/crates/bevy_tasks/Cargo.toml
index 60163485955edf..bcedb8b944cc23 100644
--- a/crates/bevy_tasks/Cargo.toml
+++ b/crates/bevy_tasks/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_tasks"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "A task executor for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -8,6 +8,10 @@ repository = "https://github.com/bevyengine/bevy"
 license = "MIT OR Apache-2.0"
 keywords = ["bevy"]
 
+[features]
+multi-threaded = []
+default = ["multi-threaded"]
+
 [dependencies]
 futures-lite = "1.4.0"
 async-executor = "1.3.0"
diff --git a/crates/bevy_tasks/src/lib.rs b/crates/bevy_tasks/src/lib.rs
index 538222883071f4..ffdce2d63c045f 100644
--- a/crates/bevy_tasks/src/lib.rs
+++ b/crates/bevy_tasks/src/lib.rs
@@ -8,14 +8,14 @@ pub use slice::{ParallelSlice, ParallelSliceMut};
 mod task;
 pub use task::Task;
 
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(not(target_arch = "wasm32"), feature = "multi-threaded"))]
 mod task_pool;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(not(target_arch = "wasm32"), feature = "multi-threaded"))]
 pub use task_pool::{Scope, TaskPool, TaskPoolBuilder};
 
-#[cfg(target_arch = "wasm32")]
+#[cfg(any(target_arch = "wasm32", not(feature = "multi-threaded")))]
 mod single_threaded_task_pool;
-#[cfg(target_arch = "wasm32")]
+#[cfg(any(target_arch = "wasm32", not(feature = "multi-threaded")))]
 pub use single_threaded_task_pool::{Scope, TaskPool, TaskPoolBuilder, ThreadExecutor};
 
 mod usages;
diff --git a/crates/bevy_tasks/src/single_threaded_task_pool.rs b/crates/bevy_tasks/src/single_threaded_task_pool.rs
index b1546884bce51e..92e2928124c94f 100644
--- a/crates/bevy_tasks/src/single_threaded_task_pool.rs
+++ b/crates/bevy_tasks/src/single_threaded_task_pool.rs
@@ -1,9 +1,10 @@
-use std::{
-    future::Future,
-    marker::PhantomData,
-    mem,
-    sync::{Arc, Mutex},
-};
+#[cfg(target_arch = "wasm32")]
+use std::sync::Arc;
+use std::{cell::RefCell, future::Future, marker::PhantomData, mem, rc::Rc};
+
+thread_local! {
+    static LOCAL_EXECUTOR: async_executor::LocalExecutor<'static> = async_executor::LocalExecutor::new();
+}
 
 /// Used to create a TaskPool
 #[derive(Debug, Default, Clone)]
@@ -76,7 +77,7 @@ impl TaskPool {
         1
     }
 
-    /// Allows spawning non-`static futures on the thread pool. The function takes a callback,
+    /// Allows spawning non-'static futures on the thread pool. The function takes a callback,
     /// passing a scope object into it. The scope object provided to the callback can be used
     /// to spawn tasks. This function will await the completion of all tasks before returning.
     ///
@@ -108,8 +109,9 @@ impl TaskPool {
         let executor: &'env async_executor::LocalExecutor<'env> =
             unsafe { mem::transmute(executor) };
 
-        let results: Mutex<Vec<Arc<Mutex<Option<T>>>>> = Mutex::new(Vec::new());
-        let results: &'env Mutex<Vec<Arc<Mutex<Option<T>>>>> = unsafe { mem::transmute(&results) };
+        let results: RefCell<Vec<Rc<RefCell<Option<T>>>>> = RefCell::new(Vec::new());
+        let results: &'env RefCell<Vec<Rc<RefCell<Option<T>>>>> =
+            unsafe { mem::transmute(&results) };
 
         let mut scope = Scope {
             executor,
@@ -125,29 +127,36 @@ impl TaskPool {
         // Loop until all tasks are done
         while executor.try_tick() {}
 
-        let results = scope.results.lock().unwrap();
+        let results = scope.results.borrow();
         results
             .iter()
-            .map(|result| result.lock().unwrap().take().unwrap())
+            .map(|result| result.borrow_mut().take().unwrap())
             .collect()
     }
 
-    /// Spawns a static future onto the JS event loop. For now it is returning FakeTask
-    /// instance with no-op detach method. Returning real Task is possible here, but tricky:
-    /// future is running on JS event loop, Task is running on async_executor::LocalExecutor
-    /// so some proxy future is needed. Moreover currently we don't have long-living
-    /// LocalExecutor here (above `spawn` implementation creates temporary one)
-    /// But for typical use cases it seems that current implementation should be sufficient:
-    /// caller can spawn long-running future writing results to some channel / event queue
-    /// and simply call detach on returned Task (like AssetServer does) - spawned future
-    /// can write results to some channel / event queue.
+    /// Spawns a static future onto the thread pool. The returned Task is a future. It can also be
+    /// cancelled and "detached" allowing it to continue running without having to be polled by the
+    /// end-user.
+    ///
+    /// If the provided future is non-`Send`, [`TaskPool::spawn_local`] should be used instead.
     pub fn spawn<T>(&self, future: impl Future<Output = T> + 'static) -> FakeTask
     where
         T: 'static,
     {
+        #[cfg(target_arch = "wasm32")]
         wasm_bindgen_futures::spawn_local(async move {
             future.await;
         });
+
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            LOCAL_EXECUTOR.with(|executor| {
+                let _task = executor.spawn(future);
+                // Loop until all tasks are done
+                while executor.try_tick() {}
+            });
+        }
+
         FakeTask
     }
 
@@ -158,6 +167,24 @@ impl TaskPool {
     {
         self.spawn(future)
     }
+
+    /// Runs a function with the local executor. Typically used to tick
+    /// the local executor on the main thread as it needs to share time with
+    /// other things.
+    ///
+    /// ```rust
+    /// use bevy_tasks::TaskPool;
+    ///
+    /// TaskPool::new().with_local_executor(|local_executor| {
+    ///     local_executor.try_tick();
+    /// });
+    /// ```
+    pub fn with_local_executor<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce(&async_executor::LocalExecutor) -> R,
+    {
+        LOCAL_EXECUTOR.with(f)
+    }
 }
 
 #[derive(Debug)]
@@ -175,7 +202,7 @@ impl FakeTask {
 pub struct Scope<'scope, 'env: 'scope, T> {
     executor: &'env async_executor::LocalExecutor<'env>,
     // Vector to gather results of all futures spawned during scope run
-    results: &'env Mutex<Vec<Arc<Mutex<Option<T>>>>>,
+    results: &'env RefCell<Vec<Rc<RefCell<Option<T>>>>>,
 
     // make `Scope` invariant over 'scope and 'env
     scope: PhantomData<&'scope mut &'scope ()>,
@@ -211,10 +238,10 @@ impl<'scope, 'env, T: Send + 'env> Scope<'scope, 'env, T> {
     ///
     /// For more information, see [`TaskPool::scope`].
     pub fn spawn_on_scope<Fut: Future<Output = T> + 'env>(&self, f: Fut) {
-        let result = Arc::new(Mutex::new(None));
-        self.results.lock().unwrap().push(result.clone());
+        let result = Rc::new(RefCell::new(None));
+        self.results.borrow_mut().push(result.clone());
         let f = async move {
-            result.lock().unwrap().replace(f.await);
+            result.borrow_mut().replace(f.await);
         };
         self.executor.spawn(f).detach();
     }
diff --git a/crates/bevy_tasks/src/thread_executor.rs b/crates/bevy_tasks/src/thread_executor.rs
index 7495fe525e0520..0131de91bec561 100644
--- a/crates/bevy_tasks/src/thread_executor.rs
+++ b/crates/bevy_tasks/src/thread_executor.rs
@@ -78,7 +78,7 @@ impl<'task> ThreadExecutor<'task> {
         if thread::current().id() == self.thread_id {
             return Some(ThreadExecutorTicker {
                 executor: self,
-                _marker: PhantomData::default(),
+                _marker: PhantomData,
             });
         }
         None
diff --git a/crates/bevy_text/Cargo.toml b/crates/bevy_text/Cargo.toml
index 7e17ab8c5640e3..578526a1e3a0ee 100644
--- a/crates/bevy_text/Cargo.toml
+++ b/crates/bevy_text/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_text"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides text functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -14,16 +14,16 @@ default_font = []
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_render = { path = "../bevy_render", version = "0.11.0-dev" }
-bevy_sprite = { path = "../bevy_sprite", version = "0.11.0-dev" }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_window = { path = "../bevy_window", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_render = { path = "../bevy_render", version = "0.12.0-dev" }
+bevy_sprite = { path = "../bevy_sprite", version = "0.12.0-dev" }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_window = { path = "../bevy_window", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 
 # other
 anyhow = "1.0.4"
diff --git a/crates/bevy_text/src/glyph_brush.rs b/crates/bevy_text/src/glyph_brush.rs
index 9b17f09a7b9103..70fea30322e180 100644
--- a/crates/bevy_text/src/glyph_brush.rs
+++ b/crates/bevy_text/src/glyph_brush.rs
@@ -1,6 +1,6 @@
-use ab_glyph::{Font as _, FontArc, Glyph, ScaleFont as _};
+use ab_glyph::{Font as _, FontArc, Glyph, PxScaleFont, ScaleFont as _};
 use bevy_asset::{Assets, Handle};
-use bevy_math::Vec2;
+use bevy_math::{Rect, Vec2};
 use bevy_render::texture::Image;
 use bevy_sprite::TextureAtlas;
 use bevy_utils::tracing::warn;
@@ -84,20 +84,7 @@ impl GlyphBrush {
             })
             .collect::<Result<Vec<_>, _>>()?;
 
-        let mut min_x = std::f32::MAX;
-        let mut min_y = std::f32::MAX;
-        let mut max_y = std::f32::MIN;
-        for sg in &glyphs {
-            let glyph = &sg.glyph;
-
-            let scaled_font = sections_data[sg.section_index].3;
-            min_x = min_x.min(glyph.position.x);
-            min_y = min_y.min(glyph.position.y - scaled_font.ascent());
-            max_y = max_y.max(glyph.position.y - scaled_font.descent());
-        }
-        min_x = min_x.floor();
-        min_y = min_y.floor();
-        max_y = max_y.floor();
+        let text_bounds = compute_text_bounds(&glyphs, |index| &sections_data[index].3);
 
         let mut positioned_glyphs = Vec::new();
         for sg in glyphs {
@@ -136,11 +123,15 @@ impl GlyphBrush {
                 let glyph_rect = texture_atlas.textures[atlas_info.glyph_index];
                 let size = Vec2::new(glyph_rect.width(), glyph_rect.height());
 
-                let x = bounds.min.x + size.x / 2.0 - min_x;
+                let x = bounds.min.x + size.x / 2.0 - text_bounds.min.x;
 
                 let y = match y_axis_orientation {
-                    YAxisOrientation::BottomToTop => max_y - bounds.max.y + size.y / 2.0,
-                    YAxisOrientation::TopToBottom => bounds.min.y + size.y / 2.0 - min_y,
+                    YAxisOrientation::BottomToTop => {
+                        text_bounds.max.y - bounds.max.y + size.y / 2.0
+                    }
+                    YAxisOrientation::TopToBottom => {
+                        bounds.min.y + size.y / 2.0 - text_bounds.min.y
+                    }
                 };
 
                 let position = adjust.position(Vec2::new(x, y));
@@ -209,3 +200,32 @@ impl GlyphPlacementAdjuster {
         Vec2::new(self.0, 0.) + v
     }
 }
+
+/// Computes the minimal bounding rectangle for a block of text.
+/// Ignores empty trailing lines.
+pub(crate) fn compute_text_bounds<'a, T>(
+    section_glyphs: &[SectionGlyph],
+    get_scaled_font: impl Fn(usize) -> &'a PxScaleFont<T>,
+) -> bevy_math::Rect
+where
+    T: ab_glyph::Font + 'a,
+{
+    let mut text_bounds = Rect {
+        min: Vec2::splat(std::f32::MAX),
+        max: Vec2::splat(std::f32::MIN),
+    };
+
+    for sg in section_glyphs {
+        let scaled_font = get_scaled_font(sg.section_index);
+        let glyph = &sg.glyph;
+        text_bounds = text_bounds.union(Rect {
+            min: Vec2::new(glyph.position.x, 0.),
+            max: Vec2::new(
+                glyph.position.x + scaled_font.h_advance(glyph.id),
+                glyph.position.y - scaled_font.descent(),
+            ),
+        });
+    }
+
+    text_bounds
+}
diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index e71e49c030e674..2d16ce03c33565 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -1,4 +1,4 @@
-use ab_glyph::{PxScale, ScaleFont};
+use ab_glyph::PxScale;
 use bevy_asset::{Assets, Handle, HandleId};
 use bevy_ecs::component::Component;
 use bevy_ecs::system::Resource;
@@ -10,8 +10,9 @@ use bevy_utils::HashMap;
 use glyph_brush_layout::{FontId, GlyphPositioner, SectionGeometry, SectionText};
 
 use crate::{
-    error::TextError, glyph_brush::GlyphBrush, scale_value, BreakLineOn, Font, FontAtlasSet,
-    FontAtlasWarning, PositionedGlyph, TextAlignment, TextSection, TextSettings, YAxisOrientation,
+    compute_text_bounds, error::TextError, glyph_brush::GlyphBrush, scale_value, BreakLineOn, Font,
+    FontAtlasSet, FontAtlasWarning, PositionedGlyph, TextAlignment, TextSection, TextSettings,
+    YAxisOrientation,
 };
 
 #[derive(Default, Resource)]
@@ -84,24 +85,7 @@ impl TextPipeline {
             return Ok(TextLayoutInfo::default());
         }
 
-        let mut min_x: f32 = std::f32::MAX;
-        let mut min_y: f32 = std::f32::MAX;
-        let mut max_x: f32 = std::f32::MIN;
-        let mut max_y: f32 = std::f32::MIN;
-
-        for sg in &section_glyphs {
-            let scaled_font = scaled_fonts[sg.section_index];
-            let glyph = &sg.glyph;
-            // The fonts use a coordinate system increasing upwards so ascent is a positive value
-            // and descent is negative, but Bevy UI uses a downwards increasing coordinate system,
-            // so we have to subtract from the baseline position to get the minimum and maximum values.
-            min_x = min_x.min(glyph.position.x);
-            min_y = min_y.min(glyph.position.y - scaled_font.ascent());
-            max_x = max_x.max(glyph.position.x + scaled_font.h_advance(glyph.id));
-            max_y = max_y.max(glyph.position.y - scaled_font.descent());
-        }
-
-        let size = Vec2::new(max_x - min_x, max_y - min_y);
+        let size = compute_text_bounds(&section_glyphs, |index| &scaled_fonts[index]).size();
 
         let glyphs = self.brush.process_glyphs(
             section_glyphs,
@@ -229,24 +213,7 @@ impl TextMeasureInfo {
             .line_breaker(self.linebreak_behaviour)
             .calculate_glyphs(&self.fonts, &geom, sections);
 
-        let mut min_x: f32 = std::f32::MAX;
-        let mut min_y: f32 = std::f32::MAX;
-        let mut max_x: f32 = std::f32::MIN;
-        let mut max_y: f32 = std::f32::MIN;
-
-        for sg in section_glyphs {
-            let scaled_font = &self.scaled_fonts[sg.section_index];
-            let glyph = &sg.glyph;
-            // The fonts use a coordinate system increasing upwards so ascent is a positive value
-            // and descent is negative, but Bevy UI uses a downwards increasing coordinate system,
-            // so we have to subtract from the baseline position to get the minimum and maximum values.
-            min_x = min_x.min(glyph.position.x);
-            min_y = min_y.min(glyph.position.y - scaled_font.ascent());
-            max_x = max_x.max(glyph.position.x + scaled_font.h_advance(glyph.id));
-            max_y = max_y.max(glyph.position.y - scaled_font.descent());
-        }
-
-        Vec2::new(max_x - min_x, max_y - min_y)
+        compute_text_bounds(&section_glyphs, |index| &self.scaled_fonts[index]).size()
     }
 
     pub fn compute_size(&self, bounds: Vec2) -> Vec2 {
diff --git a/crates/bevy_time/Cargo.toml b/crates/bevy_time/Cargo.toml
index 7d4743b0328348..4eb92f7f2946ab 100644
--- a/crates/bevy_time/Cargo.toml
+++ b/crates/bevy_time/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_time"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides time functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -15,10 +15,10 @@ bevy_ci_testing = ["bevy_app/bevy_ci_testing"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev", features = ["bevy_reflect"] }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev", features = ["bevy_reflect"] }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 
 # other
 crossbeam-channel = "0.5.0"
diff --git a/crates/bevy_transform/Cargo.toml b/crates/bevy_transform/Cargo.toml
index 0b426b6bf9e57c..9f250745232c56 100644
--- a/crates/bevy_transform/Cargo.toml
+++ b/crates/bevy_transform/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_transform"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides transform functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,15 +10,15 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev", features = ["bevy_reflect"] }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = ["bevy"] }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev", features = ["bevy_reflect"] }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
 serde = { version = "1", features = ["derive"], optional = true }
 
 [dev-dependencies]
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0-dev" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.12.0-dev" }
 
 [features]
 serialize = ["dep:serde", "bevy_math/serialize"]
diff --git a/crates/bevy_transform/src/components/transform.rs b/crates/bevy_transform/src/components/transform.rs
index e02ebebbbd98dd..5f6f42ab0b91f2 100644
--- a/crates/bevy_transform/src/components/transform.rs
+++ b/crates/bevy_transform/src/components/transform.rs
@@ -337,7 +337,7 @@ impl Transform {
     /// and [`Transform::up`] points towards `up`.
     ///
     /// In some cases it's not possible to construct a rotation. Another axis will be picked in those cases:
-    /// * if `target` is the same as the transtorm translation, `Vec3::Z` is used instead
+    /// * if `target` is the same as the transform translation, `Vec3::Z` is used instead
     /// * if `up` is zero, `Vec3::Y` is used instead
     /// * if the resulting forward direction is parallel with `up`, an orthogonal vector is used as the "right" direction
     #[inline]
diff --git a/crates/bevy_transform/src/systems.rs b/crates/bevy_transform/src/systems.rs
index 46629eca57db9b..420ce7a9e36234 100644
--- a/crates/bevy_transform/src/systems.rs
+++ b/crates/bevy_transform/src/systems.rs
@@ -2,6 +2,7 @@ use crate::components::{GlobalTransform, Transform};
 use bevy_ecs::{
     change_detection::Ref,
     prelude::{Changed, DetectChanges, Entity, Query, With, Without},
+    query::{Added, Or},
     removal_detection::RemovedComponents,
     system::{Local, ParamSet},
 };
@@ -14,7 +15,11 @@ pub fn sync_simple_transforms(
     mut query: ParamSet<(
         Query<
             (&Transform, &mut GlobalTransform),
-            (Changed<Transform>, Without<Parent>, Without<Children>),
+            (
+                Or<(Changed<Transform>, Added<GlobalTransform>)>,
+                Without<Parent>,
+                Without<Children>,
+            ),
         >,
         Query<(Ref<Transform>, &mut GlobalTransform), Without<Children>>,
     )>,
@@ -31,7 +36,7 @@ pub fn sync_simple_transforms(
     let mut query = query.p1();
     let mut iter = query.iter_many_mut(orphaned.iter());
     while let Some((transform, mut global_transform)) = iter.fetch_next() {
-        if !transform.is_changed() {
+        if !transform.is_changed() && !global_transform.is_added() {
             *global_transform = GlobalTransform::from(*transform);
         }
     }
@@ -56,7 +61,7 @@ pub fn propagate_transforms(
     orphaned_entities.sort_unstable();
     root_query.par_iter_mut().for_each_mut(
         |(entity, children, transform, mut global_transform)| {
-            let changed = transform.is_changed() || orphaned_entities.binary_search(&entity).is_ok();
+            let changed = transform.is_changed() || global_transform.is_added() || orphaned_entities.binary_search(&entity).is_ok();
             if changed {
                 *global_transform = GlobalTransform::from(*transform);
             }
@@ -143,7 +148,7 @@ unsafe fn propagate_recursive(
                 return;
             };
 
-        changed |= transform.is_changed();
+        changed |= transform.is_changed() || global_transform.is_added();
         if changed {
             *global_transform = parent.mul_transform(*transform);
         }
diff --git a/crates/bevy_ui/Cargo.toml b/crates/bevy_ui/Cargo.toml
index 0f3bf3320f22d5..60e8d74477ac55 100644
--- a/crates/bevy_ui/Cargo.toml
+++ b/crates/bevy_ui/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_ui"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "A custom ECS-driven UI framework built specifically for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,25 +10,25 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_a11y = { path = "../bevy_a11y", version = "0.11.0-dev" }
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.11.0-dev" }
-bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.11.0-dev" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0-dev" }
-bevy_input = { path = "../bevy_input", version = "0.11.0-dev" }
-bevy_log = { path = "../bevy_log", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = [
+bevy_a11y = { path = "../bevy_a11y", version = "0.12.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_asset = { path = "../bevy_asset", version = "0.12.0-dev" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.12.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.12.0-dev" }
+bevy_input = { path = "../bevy_input", version = "0.12.0-dev" }
+bevy_log = { path = "../bevy_log", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = [
     "bevy",
 ] }
-bevy_render = { path = "../bevy_render", version = "0.11.0-dev" }
-bevy_sprite = { path = "../bevy_sprite", version = "0.11.0-dev" }
-bevy_text = { path = "../bevy_text", version = "0.11.0-dev", optional = true }
-bevy_transform = { path = "../bevy_transform", version = "0.11.0-dev" }
-bevy_window = { path = "../bevy_window", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_render = { path = "../bevy_render", version = "0.12.0-dev" }
+bevy_sprite = { path = "../bevy_sprite", version = "0.12.0-dev" }
+bevy_text = { path = "../bevy_text", version = "0.12.0-dev", optional = true }
+bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_window = { path = "../bevy_window", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 
 # other
 taffy = { version = "0.3.10" }
diff --git a/crates/bevy_ui/src/focus.rs b/crates/bevy_ui/src/focus.rs
index 2b180fa7c2dd22..7837d19ac0bfaf 100644
--- a/crates/bevy_ui/src/focus.rs
+++ b/crates/bevy_ui/src/focus.rs
@@ -1,4 +1,4 @@
-use crate::{camera_config::UiCameraConfig, CalculatedClip, Node, UiStack};
+use crate::{camera_config::UiCameraConfig, CalculatedClip, Node, UiScale, UiStack};
 use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::{
     change_detection::DetectChangesMut,
@@ -138,6 +138,7 @@ pub fn ui_focus_system(
     windows: Query<&Window>,
     mouse_button_input: Res<Input<MouseButton>>,
     touches_input: Res<Touches>,
+    ui_scale: Res<UiScale>,
     ui_stack: Res<UiStack>,
     mut node_query: Query<NodeQuery>,
     primary_window: Query<Entity, With<PrimaryWindow>>,
@@ -187,7 +188,10 @@ pub fn ui_focus_system(
                 .ok()
                 .and_then(|window| window.cursor_position())
         })
-        .or_else(|| touches_input.first_pressed_position());
+        .or_else(|| touches_input.first_pressed_position())
+        // The cursor position returned by `Window` only takes into account the window scale factor and not `UiScale`.
+        // To convert the cursor position to logical UI viewport coordinates we have to divide it by `UiScale`.
+        .map(|cursor_position| cursor_position / ui_scale.scale as f32);
 
     // prepare an iterator that contains all the nodes that have the cursor in their rect,
     // from the top node to the bottom one. this will also reset the interaction to `None`
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index ca38a415003b82..8063eaac76a2a5 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -64,10 +64,12 @@ impl fmt::Debug for UiSurface {
 
 impl Default for UiSurface {
     fn default() -> Self {
+        let mut taffy = Taffy::new();
+        taffy.disable_rounding();
         Self {
             entity_to_taffy: Default::default(),
             window_nodes: Default::default(),
-            taffy: Taffy::new(),
+            taffy,
         }
     }
 }
@@ -223,9 +225,10 @@ pub fn ui_layout_system(
     style_query: Query<(Entity, Ref<Style>), With<Node>>,
     mut measure_query: Query<(Entity, &mut ContentSize)>,
     children_query: Query<(Entity, Ref<Children>), With<Node>>,
+    just_children_query: Query<&Children>,
     mut removed_children: RemovedComponents<Children>,
     mut removed_content_sizes: RemovedComponents<ContentSize>,
-    mut node_transform_query: Query<(Entity, &mut Node, &mut Transform, Option<&Parent>)>,
+    mut node_transform_query: Query<(&mut Node, &mut Transform)>,
     mut removed_nodes: RemovedComponents<Node>,
 ) {
     // assume one window for time being...
@@ -301,33 +304,88 @@ pub fn ui_layout_system(
     // compute layouts
     ui_surface.compute_window_layouts();
 
-    let physical_to_logical_factor = 1. / logical_to_physical_factor;
+    let inverse_target_scale_factor = 1. / scale_factor;
 
-    let to_logical = |v| (physical_to_logical_factor * v as f64) as f32;
-
-    // PERF: try doing this incrementally
-    for (entity, mut node, mut transform, parent) in &mut node_transform_query {
-        let layout = ui_surface.get_layout(entity).unwrap();
-        let new_size = Vec2::new(
-            to_logical(layout.size.width),
-            to_logical(layout.size.height),
-        );
-        // only trigger change detection when the new value is different
-        if node.calculated_size != new_size {
-            node.calculated_size = new_size;
-        }
-        let mut new_position = transform.translation;
-        new_position.x = to_logical(layout.location.x + layout.size.width / 2.0);
-        new_position.y = to_logical(layout.location.y + layout.size.height / 2.0);
-        if let Some(parent) = parent {
-            if let Ok(parent_layout) = ui_surface.get_layout(**parent) {
-                new_position.x -= to_logical(parent_layout.size.width / 2.0);
-                new_position.y -= to_logical(parent_layout.size.height / 2.0);
+    fn update_uinode_geometry_recursive(
+        entity: Entity,
+        ui_surface: &UiSurface,
+        node_transform_query: &mut Query<(&mut Node, &mut Transform)>,
+        children_query: &Query<&Children>,
+        inverse_target_scale_factor: f32,
+        parent_size: Vec2,
+        mut absolute_location: Vec2,
+    ) {
+        if let Ok((mut node, mut transform)) = node_transform_query.get_mut(entity) {
+            let layout = ui_surface.get_layout(entity).unwrap();
+            let layout_size = Vec2::new(layout.size.width, layout.size.height);
+            let layout_location = Vec2::new(layout.location.x, layout.location.y);
+
+            absolute_location += layout_location;
+            let rounded_location = round_layout_coords(layout_location);
+            let rounded_size = round_layout_coords(absolute_location + layout_size)
+                - round_layout_coords(absolute_location);
+
+            let new_size = inverse_target_scale_factor * rounded_size;
+            let new_position =
+                inverse_target_scale_factor * rounded_location + 0.5 * (new_size - parent_size);
+
+            // only trigger change detection when the new values are different
+            if node.calculated_size != new_size {
+                node.calculated_size = new_size;
+            }
+            if transform.translation.truncate() != new_position {
+                transform.translation = new_position.extend(0.);
+            }
+            if let Ok(children) = children_query.get(entity) {
+                for &child_uinode in children {
+                    update_uinode_geometry_recursive(
+                        child_uinode,
+                        ui_surface,
+                        node_transform_query,
+                        children_query,
+                        inverse_target_scale_factor,
+                        new_size,
+                        absolute_location,
+                    );
+                }
             }
         }
-        // only trigger change detection when the new value is different
-        if transform.translation != new_position {
-            transform.translation = new_position;
-        }
+    }
+
+    for entity in root_node_query.iter() {
+        update_uinode_geometry_recursive(
+            entity,
+            &ui_surface,
+            &mut node_transform_query,
+            &just_children_query,
+            inverse_target_scale_factor as f32,
+            Vec2::ZERO,
+            Vec2::ZERO,
+        );
+    }
+}
+
+#[inline]
+/// Round `value` to the closest whole integer, with ties (values with a fractional part equal to 0.5) rounded towards positive infinity.
+fn round_ties_up(value: f32) -> f32 {
+    if 0. <= value || value.fract() != 0.5 {
+        // The `round` function rounds ties away from zero. For positive numbers "away from zero" is towards positive infinity.
+        // So for all positive values, and negative values with a fractional part not equal to 0.5, `round` returns the correct result.
+        value.round()
+    } else {
+        // In the remaining cases, where `value` is negative and its fractional part is equal to 0.5, we use `ceil` to round it up towards positive infinity.
+        value.ceil()
+    }
+}
+
+#[inline]
+/// Rust `f32` only has support for rounding ties away from zero.
+/// When rounding the layout coordinates we need to round ties up, otherwise we can gain a pixel.
+/// For example consider a node with left and right bounds of -50.5 and 49.5 (width: 49.5 - (-50.5) == 100).
+/// After rounding left and right away from zero we get -51 and 50 (width: 50 - (-51) == 101), gaining a pixel.
+fn round_layout_coords(value: Vec2) -> Vec2 {
+    Vec2 {
+        x: round_ties_up(value.x),
+        y: round_ties_up(value.y),
     }
 }
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 66fa5e15be7be5..fba6ba1af15334 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -8,15 +8,15 @@ use bevy_window::{PrimaryWindow, Window};
 pub use pipeline::*;
 pub use render_pass::*;
 
-use crate::UiTextureAtlasImage;
 use crate::{
-    prelude::UiCameraConfig, BackgroundColor, BorderColor, CalculatedClip, Node, UiImage, UiStack,
+    prelude::UiCameraConfig, BackgroundColor, BorderColor, CalculatedClip, ContentSize, Node,
+    Style, UiImage, UiScale, UiStack, UiTextureAtlasImage, Val,
 };
-use crate::{ContentSize, Style, Val};
+
 use bevy_app::prelude::*;
 use bevy_asset::{load_internal_asset, AssetEvent, Assets, Handle, HandleUntyped};
 use bevy_ecs::prelude::*;
-use bevy_math::{Mat4, Rect, UVec4, Vec2, Vec3, Vec4Swizzles};
+use bevy_math::{Mat4, Rect, URect, UVec4, Vec2, Vec3, Vec4Swizzles};
 use bevy_reflect::TypeUuid;
 use bevy_render::texture::DEFAULT_IMAGE_HANDLE;
 use bevy_render::{
@@ -170,7 +170,6 @@ pub fn extract_atlas_uinodes(
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
     images: Extract<Res<Assets<Image>>>,
     texture_atlases: Extract<Res<Assets<TextureAtlas>>>,
-
     ui_stack: Extract<Res<UiStack>>,
     uinode_query: Extract<
         Query<
@@ -258,6 +257,7 @@ fn resolve_border_thickness(value: Val, parent_width: f32, viewport_size: Vec2)
 pub fn extract_uinode_borders(
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
     windows: Extract<Query<&Window, With<PrimaryWindow>>>,
+    ui_scale: Extract<Res<UiScale>>,
     ui_stack: Extract<Res<UiStack>>,
     uinode_query: Extract<
         Query<
@@ -277,10 +277,13 @@ pub fn extract_uinode_borders(
 ) {
     let image = bevy_render::texture::DEFAULT_IMAGE_HANDLE.typed();
 
-    let viewport_size = windows
+    let ui_logical_viewport_size = windows
         .get_single()
         .map(|window| Vec2::new(window.resolution.width(), window.resolution.height()))
-        .unwrap_or(Vec2::ZERO);
+        .unwrap_or(Vec2::ZERO)
+        // The logical window resolution returned by `Window` only takes into account the window scale factor and not `UiScale`,
+        // so we have to divide by `UiScale` to get the size of the UI viewport.
+        / ui_scale.scale as f32;
 
     for (stack_index, entity) in ui_stack.uinodes.iter().enumerate() {
         if let Ok((node, global_transform, style, border_color, parent, visibility, clip)) =
@@ -300,11 +303,21 @@ pub fn extract_uinode_borders(
             let parent_width = parent
                 .and_then(|parent| parent_node_query.get(parent.get()).ok())
                 .map(|parent_node| parent_node.size().x)
-                .unwrap_or(viewport_size.x);
-            let left = resolve_border_thickness(style.border.left, parent_width, viewport_size);
-            let right = resolve_border_thickness(style.border.right, parent_width, viewport_size);
-            let top = resolve_border_thickness(style.border.top, parent_width, viewport_size);
-            let bottom = resolve_border_thickness(style.border.bottom, parent_width, viewport_size);
+                .unwrap_or(ui_logical_viewport_size.x);
+            let left =
+                resolve_border_thickness(style.border.left, parent_width, ui_logical_viewport_size);
+            let right = resolve_border_thickness(
+                style.border.right,
+                parent_width,
+                ui_logical_viewport_size,
+            );
+            let top =
+                resolve_border_thickness(style.border.top, parent_width, ui_logical_viewport_size);
+            let bottom = resolve_border_thickness(
+                style.border.bottom,
+                parent_width,
+                ui_logical_viewport_size,
+            );
 
             // Calculate the border rects, ensuring no overlap.
             // The border occupies the space between the node's bounding rect and the node's bounding rect inset in each direction by the node's corresponding border value.
@@ -378,8 +391,6 @@ pub fn extract_uinodes(
         >,
     >,
 ) {
-    extracted_uinodes.uinodes.clear();
-
     for (stack_index, entity) in ui_stack.uinodes.iter().enumerate() {
         if let Ok((uinode, transform, color, maybe_image, visibility, clip)) =
             uinode_query.get(*entity)
@@ -396,7 +407,7 @@ pub fn extract_uinodes(
                 }
                 (image.texture.clone_weak(), image.flip_x, image.flip_y)
             } else {
-                (DEFAULT_IMAGE_HANDLE.typed().clone_weak(), false, false)
+                (DEFAULT_IMAGE_HANDLE.typed(), false, false)
             };
 
             extracted_uinodes.uinodes.push(ExtractedUiNode {
@@ -433,21 +444,36 @@ pub struct DefaultCameraView(pub Entity);
 
 pub fn extract_default_ui_camera_view<T: Component>(
     mut commands: Commands,
+    ui_scale: Extract<Res<UiScale>>,
     query: Extract<Query<(Entity, &Camera, Option<&UiCameraConfig>), With<T>>>,
 ) {
+    let scale = (ui_scale.scale as f32).recip();
     for (entity, camera, camera_ui) in &query {
         // ignore cameras with disabled ui
         if matches!(camera_ui, Some(&UiCameraConfig { show_ui: false, .. })) {
             continue;
         }
-        if let (Some(logical_size), Some((physical_origin, _)), Some(physical_size)) = (
+        if let (
+            Some(logical_size),
+            Some(URect {
+                min: physical_origin,
+                ..
+            }),
+            Some(physical_size),
+        ) = (
             camera.logical_viewport_size(),
             camera.physical_viewport_rect(),
             camera.physical_viewport_size(),
         ) {
             // use a projection matrix with the origin in the top left instead of the bottom left that comes with OrthographicProjection
-            let projection_matrix =
-                Mat4::orthographic_rh(0.0, logical_size.x, logical_size.y, 0.0, 0.0, UI_CAMERA_FAR);
+            let projection_matrix = Mat4::orthographic_rh(
+                0.0,
+                logical_size.x * scale,
+                logical_size.y * scale,
+                0.0,
+                0.0,
+                UI_CAMERA_FAR,
+            );
             let default_camera_view = commands
                 .spawn(ExtractedView {
                     projection: projection_matrix,
@@ -481,6 +507,7 @@ pub fn extract_text_uinodes(
     texture_atlases: Extract<Res<Assets<TextureAtlas>>>,
     windows: Extract<Query<&Window, With<PrimaryWindow>>>,
     ui_stack: Extract<Res<UiStack>>,
+    ui_scale: Extract<Res<UiScale>>,
     uinode_query: Extract<
         Query<(
             &Node,
@@ -495,10 +522,11 @@ pub fn extract_text_uinodes(
     // TODO: Support window-independent UI scale: https://github.com/bevyengine/bevy/issues/5621
     let scale_factor = windows
         .get_single()
-        .map(|window| window.resolution.scale_factor() as f32)
-        .unwrap_or(1.0);
+        .map(|window| window.resolution.scale_factor())
+        .unwrap_or(1.0)
+        * ui_scale.scale;
 
-    let inverse_scale_factor = scale_factor.recip();
+    let inverse_scale_factor = (scale_factor as f32).recip();
 
     for (stack_index, entity) in ui_stack.uinodes.iter().enumerate() {
         if let Ok((uinode, global_transform, text, text_layout_info, visibility, clip)) =
@@ -613,7 +641,7 @@ pub fn prepare_uinodes(
         image.id() != DEFAULT_IMAGE_HANDLE.id()
     }
 
-    for extracted_uinode in &extracted_uinodes.uinodes {
+    for extracted_uinode in extracted_uinodes.uinodes.drain(..) {
         let mode = if is_textured(&extracted_uinode.image) {
             if current_batch_image.id() != extracted_uinode.image.id() {
                 if is_textured(&current_batch_image) && start != end {
diff --git a/crates/bevy_ui/src/stack.rs b/crates/bevy_ui/src/stack.rs
index 6dd063b02ffbc7..c24a8aad66b268 100644
--- a/crates/bevy_ui/src/stack.rs
+++ b/crates/bevy_ui/src/stack.rs
@@ -108,7 +108,7 @@ fn fill_stack_recursively(result: &mut Vec<Entity>, stack: &mut StackingContext)
     stack.entries.sort_by_key(|e| e.z_index);
 
     for entry in &mut stack.entries {
-        // Parent node renders before/behind childs nodes
+        // Parent node renders before/behind child nodes
         result.push(entry.entity);
         fill_stack_recursively(result, &mut entry.stack);
     }
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index 532007ed3b752e..7a41270eeb0e6e 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -29,12 +29,12 @@ impl Node {
         self.calculated_size
     }
 
-    /// Returns the size of the node in physical pixels based on the given scale factor.
+    /// Returns the size of the node in physical pixels based on the given scale factor and `UiScale`.
     #[inline]
-    pub fn physical_size(&self, scale_factor: f64) -> Vec2 {
+    pub fn physical_size(&self, scale_factor: f64, ui_scale: f64) -> Vec2 {
         Vec2::new(
-            (self.calculated_size.x as f64 * scale_factor) as f32,
-            (self.calculated_size.y as f64 * scale_factor) as f32,
+            (self.calculated_size.x as f64 * scale_factor * ui_scale) as f32,
+            (self.calculated_size.y as f64 * scale_factor * ui_scale) as f32,
         )
     }
 
@@ -46,16 +46,21 @@ impl Node {
 
     /// Returns the physical pixel coordinates of the UI node, based on its [`GlobalTransform`] and the scale factor.
     #[inline]
-    pub fn physical_rect(&self, transform: &GlobalTransform, scale_factor: f64) -> Rect {
+    pub fn physical_rect(
+        &self,
+        transform: &GlobalTransform,
+        scale_factor: f64,
+        ui_scale: f64,
+    ) -> Rect {
         let rect = self.logical_rect(transform);
         Rect {
             min: Vec2::new(
-                (rect.min.x as f64 * scale_factor) as f32,
-                (rect.min.y as f64 * scale_factor) as f32,
+                (rect.min.x as f64 * scale_factor * ui_scale) as f32,
+                (rect.min.y as f64 * scale_factor * ui_scale) as f32,
             ),
             max: Vec2::new(
-                (rect.max.x as f64 * scale_factor) as f32,
-                (rect.max.y as f64 * scale_factor) as f32,
+                (rect.max.x as f64 * scale_factor * ui_scale) as f32,
+                (rect.max.y as f64 * scale_factor * ui_scale) as f32,
             ),
         }
     }
@@ -284,13 +289,13 @@ impl Val {
 /// ### Flexbox
 ///
 /// - [MDN: Basic Concepts of Grid Layout](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Grid_Layout/Basic_Concepts_of_Grid_Layout)
-/// - [A Complete Guide To Flexbox](https://css-tricks.com/snippets/css/a-guide-to-flexbox/) by CSS Tricks. This is detailed guide with illustrations and comphrehensive written explanation of the different Flexbox properties and how they work.
+/// - [A Complete Guide To Flexbox](https://css-tricks.com/snippets/css/a-guide-to-flexbox/) by CSS Tricks. This is detailed guide with illustrations and comprehensive written explanation of the different Flexbox properties and how they work.
 /// - [Flexbox Froggy](https://flexboxfroggy.com/). An interactive tutorial/game that teaches the essential parts of Flebox in a fun engaging way.
 ///
 /// ### CSS Grid
 ///
 /// - [MDN: Basic Concepts of Flexbox](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Flexible_Box_Layout/Basic_Concepts_of_Flexbox)
-/// - [A Complete Guide To CSS Grid](https://css-tricks.com/snippets/css/complete-guide-grid/) by CSS Tricks. This is detailed guide with illustrations and comphrehensive written explanation of the different CSS Grid properties and how they work.
+/// - [A Complete Guide To CSS Grid](https://css-tricks.com/snippets/css/complete-guide-grid/) by CSS Tricks. This is detailed guide with illustrations and comprehensive written explanation of the different CSS Grid properties and how they work.
 /// - [CSS Grid Garden](https://cssgridgarden.com/). An interactive tutorial/game that teaches the essential parts of CSS Grid in a fun engaging way.
 
 #[derive(Component, Clone, PartialEq, Debug, Reflect)]
@@ -390,7 +395,7 @@ pub struct Style {
     /// For CSS Grid containers:
     ///   - Controls block (vertical) axis alignment of children of this grid container within their grid areas
     ///
-    /// This value is overriden [`JustifySelf`] on the child node is set.
+    /// This value is overridden [`JustifySelf`] on the child node is set.
     ///
     /// <https://developer.mozilla.org/en-US/docs/Web/CSS/align-items>
     pub align_items: AlignItems,
@@ -400,7 +405,7 @@ pub struct Style {
     /// For CSS Grid containers:
     ///   - Sets default inline (horizontal) axis alignment of child items within their grid areas
     ///
-    /// This value is overriden [`JustifySelf`] on the child node is set.
+    /// This value is overridden [`JustifySelf`] on the child node is set.
     ///
     /// <https://developer.mozilla.org/en-US/docs/Web/CSS/justify-items>
     pub justify_items: JustifyItems,
@@ -491,8 +496,6 @@ pub struct Style {
     ///
     /// The size of the node will be expanded if there are constraints that prevent the layout algorithm from placing the border within the existing node boundary.
     ///
-    /// Rendering for borders is not yet implemented.
-    ///
     /// <https://developer.mozilla.org/en-US/docs/Web/CSS/border-width>
     pub border: UiRect,
 
@@ -561,7 +564,7 @@ pub struct Style {
     /// <https://developer.mozilla.org/en-US/docs/Web/CSS/grid-auto-rows>
     pub grid_auto_rows: Vec<GridTrack>,
     /// Defines the size of implicitly created columns. Columns are created implicitly when grid items are given explicit placements that are out of bounds
-    /// of the columns explicitly created using `grid_template_columms`.
+    /// of the columns explicitly created using `grid_template_columns`.
     ///
     /// <https://developer.mozilla.org/en-US/docs/Web/CSS/grid-template-columns>
     pub grid_auto_columns: Vec<GridTrack>,
@@ -1430,7 +1433,7 @@ impl From<RepeatedGridTrack> for Vec<RepeatedGridTrack> {
 ///
 /// The default `span` is 1. If neither `start` or `end` is set then the item will be placed automatically.
 ///
-/// Generally, at most two fields should be set. If all three fields are specifed then `span` will be ignored. If `end` specifies an earlier
+/// Generally, at most two fields should be set. If all three fields are specified then `span` will be ignored. If `end` specifies an earlier
 /// grid line than `start` then `end` will be ignored and the item will have a span of 1.
 ///
 /// <https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Grid_Layout/Line-based_Placement_with_CSS_Grid>
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index 06d876eb7a684a..391d15e1cbceef 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -99,7 +99,7 @@ fn create_text_measure(
                 content_size.set(TextMeasure { info: measure });
             }
 
-            // Text measure func created succesfully, so set `TextFlags` to schedule a recompute
+            // Text measure func created successfully, so set `TextFlags` to schedule a recompute
             text_flags.needs_new_measure_func = false;
             text_flags.needs_recompute = true;
         }
@@ -184,7 +184,8 @@ fn queue_text(
             // With `NoWrap` set, no constraints are placed on the width of the text.
             Vec2::splat(f32::INFINITY)
         } else {
-            node.physical_size(scale_factor)
+            // `scale_factor` is already multiplied by `UiScale`
+            node.physical_size(scale_factor, 1.)
         };
 
         match text_pipeline.queue_text(
diff --git a/crates/bevy_utils/Cargo.toml b/crates/bevy_utils/Cargo.toml
index e423aa950c4340..ba887e8057220b 100644
--- a/crates/bevy_utils/Cargo.toml
+++ b/crates/bevy_utils/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_utils"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "A collection of utils for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -17,7 +17,7 @@ tracing = { version = "0.1", default-features = false, features = ["std"] }
 instant = { version = "0.1", features = ["wasm-bindgen"] }
 uuid = { version = "1.1", features = ["v4", "serde"] }
 hashbrown = { version = "0.14", features = ["serde"] }
-bevy_utils_proc_macros = {version = "0.11.0-dev", path = "macros"}
+bevy_utils_proc_macros = {version = "0.12.0-dev", path = "macros"}
 petgraph = "0.6"
 thiserror = "1.0"
 
diff --git a/crates/bevy_utils/macros/Cargo.toml b/crates/bevy_utils/macros/Cargo.toml
index b6439e72b6da73..6cd46fba5a98a5 100644
--- a/crates/bevy_utils/macros/Cargo.toml
+++ b/crates/bevy_utils/macros/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_utils_proc_macros"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 description = "Bevy Utils Proc Macros"
 edition = "2021"
 license = "MIT OR Apache-2.0"
diff --git a/crates/bevy_utils/src/syncunsafecell.rs b/crates/bevy_utils/src/syncunsafecell.rs
index 839bf7b9d1a558..a2a3ac388507a2 100644
--- a/crates/bevy_utils/src/syncunsafecell.rs
+++ b/crates/bevy_utils/src/syncunsafecell.rs
@@ -12,7 +12,7 @@ pub use core::cell::UnsafeCell;
 /// This is just an `UnsafeCell`, except it implements `Sync`
 /// if `T` implements `Sync`.
 ///
-/// `UnsafeCell` doesn't implement `Sync`, to prevent accidental mis-use.
+/// `UnsafeCell` doesn't implement `Sync`, to prevent accidental misuse.
 /// You can use `SyncUnsafeCell` instead of `UnsafeCell` to allow it to be
 /// shared between threads, if that's intentional.
 /// Providing proper synchronization is still the task of the user,
diff --git a/crates/bevy_window/Cargo.toml b/crates/bevy_window/Cargo.toml
index c65bcc6e3b97de..8bffd6a53c8167 100644
--- a/crates/bevy_window/Cargo.toml
+++ b/crates/bevy_window/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_window"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "Provides windowing functionality for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -14,15 +14,15 @@ serialize = ["serde"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.11.0-dev", features = [
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = [
     "glam",
 ] }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 # Used for close_on_esc
-bevy_input = { path = "../bevy_input", version = "0.11.0-dev" }
+bevy_input = { path = "../bevy_input", version = "0.12.0-dev" }
 raw-window-handle = "0.5"
 
 # other
diff --git a/crates/bevy_winit/Cargo.toml b/crates/bevy_winit/Cargo.toml
index 1851c1db324bed..fd7d4d3a373c1d 100644
--- a/crates/bevy_winit/Cargo.toml
+++ b/crates/bevy_winit/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_winit"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "A winit window and input backend for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -12,24 +12,24 @@ keywords = ["bevy"]
 trace = []
 wayland = ["winit/wayland", "winit/wayland-csd-adwaita"]
 x11 = ["winit/x11"]
-accesskit_unix = ["accesskit_winit/accesskit_unix"]
+accesskit_unix = ["accesskit_winit/accesskit_unix", "accesskit_winit/async-io"]
 
 [dependencies]
 # bevy
-bevy_a11y = { path = "../bevy_a11y", version = "0.11.0-dev" }
-bevy_app = { path = "../bevy_app", version = "0.11.0-dev" }
-bevy_derive = { path = "../bevy_derive", version = "0.11.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.11.0-dev" }
-bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.11.0-dev" }
-bevy_input = { path = "../bevy_input", version = "0.11.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.11.0-dev" }
-bevy_window = { path = "../bevy_window", version = "0.11.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
-bevy_tasks = { path = "../bevy_tasks", version = "0.11.0-dev" }
+bevy_a11y = { path = "../bevy_a11y", version = "0.12.0-dev" }
+bevy_app = { path = "../bevy_app", version = "0.12.0-dev" }
+bevy_derive = { path = "../bevy_derive", version = "0.12.0-dev" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev" }
+bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.12.0-dev" }
+bevy_input = { path = "../bevy_input", version = "0.12.0-dev" }
+bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
+bevy_window = { path = "../bevy_window", version = "0.12.0-dev" }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.12.0-dev" }
 
 # other
 winit = { version = "0.28", default-features = false }
-accesskit_winit = { version = "0.12", default-features = false }
+accesskit_winit = { version = "0.14", default-features = false }
 approx = { version = "0.5", default-features = false }
 raw-window-handle = "0.5"
 
diff --git a/docs/cargo_features.md b/docs/cargo_features.md
index bf6a5e55fc643c..497fa403a332c3 100644
--- a/docs/cargo_features.md
+++ b/docs/cargo_features.md
@@ -31,6 +31,7 @@ The default feature set enables most of the expected features of a game engine,
 |filesystem_watcher|Enable watching file system for asset hot reload|
 |hdr|HDR image format support|
 |ktx2|KTX2 compressed texture support|
+|multi-threaded|Enables multithreaded parallelism in the engine. Disabling it forces all engine tasks to run on a single thread.|
 |png|PNG image format support|
 |tonemapping_luts|Include tonemapping Look Up Tables KTX2 files|
 |vorbis|OGG/VORBIS audio format support|
diff --git a/examples/audio/audio.rs b/examples/audio/audio.rs
index 8e70e39847985c..96ebdbb19e121d 100644
--- a/examples/audio/audio.rs
+++ b/examples/audio/audio.rs
@@ -9,7 +9,9 @@ fn main() {
         .run();
 }
 
-fn setup(asset_server: Res<AssetServer>, audio: Res<Audio>) {
-    let music = asset_server.load("sounds/Windless Slopes.ogg");
-    audio.play(music);
+fn setup(asset_server: Res<AssetServer>, mut commands: Commands) {
+    commands.spawn(AudioBundle {
+        source: asset_server.load("sounds/Windless Slopes.ogg"),
+        ..default()
+    });
 }
diff --git a/examples/audio/audio_control.rs b/examples/audio/audio_control.rs
index f14ef902a09e00..05be7807137578 100644
--- a/examples/audio/audio_control.rs
+++ b/examples/audio/audio_control.rs
@@ -10,48 +10,35 @@ fn main() {
         .run();
 }
 
-fn setup(
-    mut commands: Commands,
-    asset_server: Res<AssetServer>,
-    audio: Res<Audio>,
-    audio_sinks: Res<Assets<AudioSink>>,
-) {
-    let music = asset_server.load("sounds/Windless Slopes.ogg");
-    let handle = audio_sinks.get_handle(audio.play(music));
-    commands.insert_resource(MusicController(handle));
+fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
+    commands.spawn((
+        AudioBundle {
+            source: asset_server.load("sounds/Windless Slopes.ogg"),
+            ..default()
+        },
+        MyMusic,
+    ));
 }
 
-#[derive(Resource)]
-struct MusicController(Handle<AudioSink>);
+#[derive(Component)]
+struct MyMusic;
 
-fn update_speed(
-    audio_sinks: Res<Assets<AudioSink>>,
-    music_controller: Res<MusicController>,
-    time: Res<Time>,
-) {
-    if let Some(sink) = audio_sinks.get(&music_controller.0) {
+fn update_speed(music_controller: Query<&AudioSink, With<MyMusic>>, time: Res<Time>) {
+    if let Ok(sink) = music_controller.get_single() {
         sink.set_speed(((time.elapsed_seconds() / 5.0).sin() + 1.0).max(0.1));
     }
 }
 
-fn pause(
-    keyboard_input: Res<Input<KeyCode>>,
-    audio_sinks: Res<Assets<AudioSink>>,
-    music_controller: Res<MusicController>,
-) {
+fn pause(keyboard_input: Res<Input<KeyCode>>, music_controller: Query<&AudioSink, With<MyMusic>>) {
     if keyboard_input.just_pressed(KeyCode::Space) {
-        if let Some(sink) = audio_sinks.get(&music_controller.0) {
+        if let Ok(sink) = music_controller.get_single() {
             sink.toggle();
         }
     }
 }
 
-fn volume(
-    keyboard_input: Res<Input<KeyCode>>,
-    audio_sinks: Res<Assets<AudioSink>>,
-    music_controller: Res<MusicController>,
-) {
-    if let Some(sink) = audio_sinks.get(&music_controller.0) {
+fn volume(keyboard_input: Res<Input<KeyCode>>, music_controller: Query<&AudioSink, With<MyMusic>>) {
+    if let Ok(sink) = music_controller.get_single() {
         if keyboard_input.just_pressed(KeyCode::Plus) {
             sink.set_volume(sink.volume() + 0.1);
         } else if keyboard_input.just_pressed(KeyCode::Minus) {
diff --git a/examples/audio/decodable.rs b/examples/audio/decodable.rs
index 13a986c5af82dd..9ed6539d24c9e7 100644
--- a/examples/audio/decodable.rs
+++ b/examples/audio/decodable.rs
@@ -93,10 +93,13 @@ fn main() {
     .run();
 }
 
-fn setup(mut assets: ResMut<Assets<SineAudio>>, audio: Res<Audio<SineAudio>>) {
+fn setup(mut assets: ResMut<Assets<SineAudio>>, mut commands: Commands) {
     // add a `SineAudio` to the asset server so that it can be played
     let audio_handle = assets.add(SineAudio {
         frequency: 440., //this is the frequency of A4
     });
-    audio.play(audio_handle);
+    commands.spawn(AudioSourceBundle {
+        source: audio_handle,
+        ..default()
+    });
 }
diff --git a/examples/audio/spatial_audio_2d.rs b/examples/audio/spatial_audio_2d.rs
index b5c52bbe20945f..5a9c93a034edcc 100644
--- a/examples/audio/spatial_audio_2d.rs
+++ b/examples/audio/spatial_audio_2d.rs
@@ -18,21 +18,25 @@ fn setup(
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<ColorMaterial>>,
     asset_server: Res<AssetServer>,
-    audio: Res<Audio>,
-    audio_sinks: Res<Assets<SpatialAudioSink>>,
 ) {
     // Space between the two ears
     let gap = 400.0;
 
-    let music = asset_server.load("sounds/Windless Slopes.ogg");
-    let handle = audio_sinks.get_handle(audio.play_spatial_with_settings(
-        music,
-        PlaybackSettings::LOOP,
-        Transform::IDENTITY,
-        gap / AUDIO_SCALE,
-        Vec3::ZERO,
+    // sound emitter
+    commands.spawn((
+        MaterialMesh2dBundle {
+            mesh: meshes.add(shape::Circle::new(15.0).into()).into(),
+            material: materials.add(ColorMaterial::from(Color::BLUE)),
+            transform: Transform::from_translation(Vec3::new(0.0, 50.0, 0.0)),
+            ..default()
+        },
+        Emitter,
+        SpatialAudioBundle {
+            source: asset_server.load("sounds/Windless Slopes.ogg"),
+            settings: PlaybackSettings::LOOP,
+            spatial: SpatialSettings::new(Transform::IDENTITY, gap / AUDIO_SCALE, Vec3::ZERO),
+        },
     ));
-    commands.insert_resource(AudioController(handle));
 
     // left ear
     commands.spawn(SpriteBundle {
@@ -56,17 +60,6 @@ fn setup(
         ..default()
     });
 
-    // sound emitter
-    commands.spawn((
-        MaterialMesh2dBundle {
-            mesh: meshes.add(shape::Circle::new(15.0).into()).into(),
-            material: materials.add(ColorMaterial::from(Color::BLUE)),
-            transform: Transform::from_translation(Vec3::new(0.0, 50.0, 0.0)),
-            ..default()
-        },
-        Emitter,
-    ));
-
     // camera
     commands.spawn(Camera2dBundle::default());
 }
@@ -74,18 +67,14 @@ fn setup(
 #[derive(Component)]
 struct Emitter;
 
-#[derive(Resource)]
-struct AudioController(Handle<SpatialAudioSink>);
-
 fn update_positions(
-    audio_sinks: Res<Assets<SpatialAudioSink>>,
-    music_controller: Res<AudioController>,
     time: Res<Time>,
-    mut emitter: Query<&mut Transform, With<Emitter>>,
+    mut emitters: Query<(&mut Transform, Option<&SpatialAudioSink>), With<Emitter>>,
 ) {
-    if let Some(sink) = audio_sinks.get(&music_controller.0) {
-        let mut emitter_transform = emitter.single_mut();
+    for (mut emitter_transform, sink) in emitters.iter_mut() {
         emitter_transform.translation.x = time.elapsed_seconds().sin() * 500.0;
-        sink.set_emitter_position(emitter_transform.translation / AUDIO_SCALE);
+        if let Some(sink) = &sink {
+            sink.set_emitter_position(emitter_transform.translation / AUDIO_SCALE);
+        }
     }
 }
diff --git a/examples/audio/spatial_audio_3d.rs b/examples/audio/spatial_audio_3d.rs
index c9cfb839a89795..e7cea097687eda 100644
--- a/examples/audio/spatial_audio_3d.rs
+++ b/examples/audio/spatial_audio_3d.rs
@@ -12,23 +12,30 @@ fn main() {
 fn setup(
     mut commands: Commands,
     asset_server: Res<AssetServer>,
-    audio: Res<Audio>,
-    audio_sinks: Res<Assets<SpatialAudioSink>>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
     // Space between the two ears
     let gap = 4.0;
 
-    let music = asset_server.load("sounds/Windless Slopes.ogg");
-    let handle = audio_sinks.get_handle(audio.play_spatial_with_settings(
-        music,
-        PlaybackSettings::LOOP,
-        Transform::IDENTITY,
-        gap,
-        Vec3::ZERO,
+    // sound emitter
+    commands.spawn((
+        PbrBundle {
+            mesh: meshes.add(Mesh::from(shape::UVSphere {
+                radius: 0.2,
+                ..default()
+            })),
+            material: materials.add(Color::BLUE.into()),
+            transform: Transform::from_xyz(0.0, 0.0, 0.0),
+            ..default()
+        },
+        Emitter,
+        SpatialAudioBundle {
+            source: asset_server.load("sounds/Windless Slopes.ogg"),
+            settings: PlaybackSettings::LOOP,
+            spatial: SpatialSettings::new(Transform::IDENTITY, gap, Vec3::ZERO),
+        },
     ));
-    commands.insert_resource(AudioController(handle));
 
     // left ear
     commands.spawn(PbrBundle {
@@ -46,20 +53,6 @@ fn setup(
         ..default()
     });
 
-    // sound emitter
-    commands.spawn((
-        PbrBundle {
-            mesh: meshes.add(Mesh::from(shape::UVSphere {
-                radius: 0.2,
-                ..default()
-            })),
-            material: materials.add(Color::BLUE.into()),
-            transform: Transform::from_xyz(0.0, 0.0, 0.0),
-            ..default()
-        },
-        Emitter,
-    ));
-
     // light
     commands.spawn(PointLightBundle {
         point_light: PointLight {
@@ -80,19 +73,15 @@ fn setup(
 #[derive(Component)]
 struct Emitter;
 
-#[derive(Resource)]
-struct AudioController(Handle<SpatialAudioSink>);
-
 fn update_positions(
-    audio_sinks: Res<Assets<SpatialAudioSink>>,
-    music_controller: Res<AudioController>,
     time: Res<Time>,
-    mut emitter: Query<&mut Transform, With<Emitter>>,
+    mut emitters: Query<(&mut Transform, Option<&SpatialAudioSink>), With<Emitter>>,
 ) {
-    if let Some(sink) = audio_sinks.get(&music_controller.0) {
-        let mut emitter_transform = emitter.single_mut();
+    for (mut emitter_transform, sink) in emitters.iter_mut() {
         emitter_transform.translation.x = time.elapsed_seconds().sin() * 3.0;
         emitter_transform.translation.z = time.elapsed_seconds().cos() * 3.0;
-        sink.set_emitter_position(emitter_transform.translation);
+        if let Some(sink) = &sink {
+            sink.set_emitter_position(emitter_transform.translation);
+        }
     }
 }
diff --git a/examples/games/breakout.rs b/examples/games/breakout.rs
index a1db60dab67ecb..d582856cc52dc0 100644
--- a/examples/games/breakout.rs
+++ b/examples/games/breakout.rs
@@ -404,14 +404,18 @@ fn check_for_collisions(
 }
 
 fn play_collision_sound(
+    mut commands: Commands,
     mut collision_events: EventReader<CollisionEvent>,
-    audio: Res<Audio>,
     sound: Res<CollisionSound>,
 ) {
     // Play a sound once per frame if a collision occurred.
     if !collision_events.is_empty() {
         // This prevents events staying active on the next frame.
         collision_events.clear();
-        audio.play(sound.0.clone());
+        commands.spawn(AudioBundle {
+            source: sound.0.clone(),
+            // auto-despawn the entity when playback finishes
+            settings: PlaybackSettings::DESPAWN,
+        });
     }
 }
diff --git a/examples/mobile/Cargo.toml b/examples/mobile/Cargo.toml
index 8101ca0da6b4fa..02c7d3f8a33632 100644
--- a/examples/mobile/Cargo.toml
+++ b/examples/mobile/Cargo.toml
@@ -18,6 +18,8 @@ package = "org.bevyengine.example"
 apk_name = "bevyexample"
 assets = "../../assets"
 resources = "../../assets/android-res"
+# This strips debug symbols from the shared libraries, drastically reducing APK size. If you need them, remove the option.
+strip = "strip"
 build_targets = ["aarch64-linux-android", "armv7-linux-androideabi"]
 
 [package.metadata.android.sdk]
diff --git a/examples/mobile/src/lib.rs b/examples/mobile/src/lib.rs
index e6bca949e17547..b89a98490c4eed 100644
--- a/examples/mobile/src/lib.rs
+++ b/examples/mobile/src/lib.rs
@@ -152,7 +152,9 @@ fn button_handler(
     }
 }
 
-fn setup_music(asset_server: Res<AssetServer>, audio: Res<Audio>) {
-    let music = asset_server.load("sounds/Windless Slopes.ogg");
-    audio.play(music);
+fn setup_music(asset_server: Res<AssetServer>, mut commands: Commands) {
+    commands.spawn(AudioBundle {
+        source: asset_server.load("sounds/Windless Slopes.ogg"),
+        settings: PlaybackSettings::LOOP,
+    });
 }
diff --git a/examples/scene/scene.rs b/examples/scene/scene.rs
index ad4dd8d3efea21..e4e7b508befa8e 100644
--- a/examples/scene/scene.rs
+++ b/examples/scene/scene.rs
@@ -100,9 +100,18 @@ fn log_system(
 }
 
 fn save_scene_system(world: &mut World) {
-    // Scenes can be created from any ECS World. You can either create a new one for the scene or
-    // use the current World.
+    // Scenes can be created from any ECS World.
+    // You can either create a new one for the scene or use the current World.
+    // For demonstration purposes, we'll create a new one.
     let mut scene_world = World::new();
+
+    // The `TypeRegistry` resource contains information about all registered types (including components).
+    // This is used to construct scenes, so we'll want to ensure that our previous type registrations
+    // exist in this new scene world as well.
+    // To do this, we can simply clone the `AppTypeRegistry` resource.
+    let type_registry = world.resource::<AppTypeRegistry>().clone();
+    scene_world.insert_resource(type_registry);
+
     let mut component_b = ComponentB::from_world(world);
     component_b.value = "hello".to_string();
     scene_world.spawn((
@@ -113,12 +122,11 @@ fn save_scene_system(world: &mut World) {
     scene_world.spawn(ComponentA { x: 3.0, y: 4.0 });
     scene_world.insert_resource(ResourceA { score: 1 });
 
-    // The TypeRegistry resource contains information about all registered types (including
-    // components). This is used to construct scenes.
-    let type_registry = world.resource::<AppTypeRegistry>();
-    let scene = DynamicScene::from_world(&scene_world, type_registry);
+    // With our sample world ready to go, we can now create our scene:
+    let scene = DynamicScene::from_world(&scene_world);
 
     // Scenes can be serialized like this:
+    let type_registry = world.resource::<AppTypeRegistry>();
     let serialized_scene = scene.serialize_ron(type_registry).unwrap();
 
     // Showing the scene in the console
diff --git a/examples/shader/post_processing.rs b/examples/shader/post_processing.rs
index 470519377078bf..759cc2467769da 100644
--- a/examples/shader/post_processing.rs
+++ b/examples/shader/post_processing.rs
@@ -84,7 +84,7 @@ impl Plugin for PostProcessPlugin {
             // Add a [`Node`] to the [`RenderGraph`]
             // The Node needs to impl FromWorld
             .add_render_graph_node::<PostProcessNode>(
-                // Specifiy the name of the graph, in this case we want the graph for 3d
+                // Specify the name of the graph, in this case we want the graph for 3d
                 core_3d::graph::NAME,
                 // It also needs the name of the node
                 PostProcessNode::NAME,
diff --git a/examples/tools/scene_viewer/morph_viewer_plugin.rs b/examples/tools/scene_viewer/morph_viewer_plugin.rs
index c54c4fcdb4431b..e71a41db95fbf4 100644
--- a/examples/tools/scene_viewer/morph_viewer_plugin.rs
+++ b/examples/tools/scene_viewer/morph_viewer_plugin.rs
@@ -1,6 +1,6 @@
 //! Enable controls for morph targets detected in a loaded scene.
 //!
-//! Collect morph targets and assing keys to them,
+//! Collect morph targets and assign keys to them,
 //! shows on screen additional controls for morph targets.
 //!
 //! Illustrates how to access and modify individual morph target weights.
diff --git a/examples/ui/display_and_visibility.rs b/examples/ui/display_and_visibility.rs
index d5a7f35dce440e..799aca79fd3f42 100644
--- a/examples/ui/display_and_visibility.rs
+++ b/examples/ui/display_and_visibility.rs
@@ -168,7 +168,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                         ..Default::default()
                         });
                     builder.spawn(TextBundle::from_section(
-                        "The UI Node and its descendants will not be visible and will not be alloted any space in the UI layout.\nThe UI Node will not be visible but will still occupy space in the UI layout.\nThe UI node will inherit the visibility property of its parent. If it has no parent it will be visible.",
+                        "The UI Node and its descendants will not be visible and will not be allotted any space in the UI layout.\nThe UI Node will not be visible but will still occupy space in the UI layout.\nThe UI node will inherit the visibility property of its parent. If it has no parent it will be visible.",
                         text_style
                     ));
             });
diff --git a/examples/ui/size_constraints.rs b/examples/ui/size_constraints.rs
index b46430990df659..41a57224fc17df 100644
--- a/examples/ui/size_constraints.rs
+++ b/examples/ui/size_constraints.rs
@@ -94,13 +94,13 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                             ..Default::default()
                         })
                         .with_children(|parent| {
-                            for constaint in [
+                            for constraint in [
                                 Constraint::MinWidth,
                                 Constraint::FlexBasis,
                                 Constraint::Width,
                                 Constraint::MaxWidth,
                             ] {
-                                spawn_button_row(parent, constaint, text_style.clone());
+                                spawn_button_row(parent, constraint, text_style.clone());
                             }
                         });
                 });
diff --git a/examples/ui/ui.rs b/examples/ui/ui.rs
index f1bfbcd622cc14..6cf9a3a07d720b 100644
--- a/examples/ui/ui.rs
+++ b/examples/ui/ui.rs
@@ -290,7 +290,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                         ))
                         .with_children(|parent| {
                             // alt text
-                            // This UI node takes up no space in the layout and the `Text` component is used by the accessiblity module
+                            // This UI node takes up no space in the layout and the `Text` component is used by the accessibility module
                             // and is not rendered.
                             parent.spawn((
                                 NodeBundle {
diff --git a/examples/ui/viewport_debug.rs b/examples/ui/viewport_debug.rs
index 691d70ee6a3d8c..bec9809b33ae49 100644
--- a/examples/ui/viewport_debug.rs
+++ b/examples/ui/viewport_debug.rs
@@ -1,10 +1,14 @@
-//! An example for debugging viewport coordinates
-
+//! A simple example for debugging viewport coordinates
+//!
+//! This example creates two uinode trees, one using viewport coordinates and one using pixel coordinates,
+//! and then switches between them once per second using the `Display` style property.
+//! If there are no problems both layouts should be identical, except for the color of the margin changing which is used to signal that the displayed uinode tree has changed
+//! (red for viewport, yellow for pixel).
 use bevy::prelude::*;
 
 const PALETTE: [Color; 10] = [
-    Color::ORANGE,
-    Color::BLUE,
+    Color::RED,
+    Color::YELLOW,
     Color::WHITE,
     Color::BEIGE,
     Color::CYAN,
@@ -15,7 +19,7 @@ const PALETTE: [Color; 10] = [
     Color::BLACK,
 ];
 
-#[derive(Default, Debug, Hash, Eq, PartialEq, Clone, States)]
+#[derive(Component, Default, PartialEq)]
 enum Coords {
     #[default]
     Viewport,
@@ -24,66 +28,66 @@ enum Coords {
 
 fn main() {
     App::new()
+        .insert_resource(UiScale { scale: 2.0 })
         .add_plugins(DefaultPlugins.set(WindowPlugin {
             primary_window: Some(Window {
-                resolution: [800., 600.].into(),
+                resolution: [1600., 1200.].into(),
                 title: "Viewport Coordinates Debug".to_string(),
                 resizable: false,
                 ..Default::default()
             }),
             ..Default::default()
         }))
-        .add_state::<Coords>()
         .add_systems(Startup, setup)
-        .add_systems(OnEnter(Coords::Viewport), spawn_with_viewport_coords)
-        .add_systems(OnEnter(Coords::Pixel), spawn_with_pixel_coords)
-        .add_systems(OnExit(Coords::Viewport), despawn_nodes)
-        .add_systems(OnExit(Coords::Pixel), despawn_nodes)
         .add_systems(Update, update)
         .run();
 }
 
-fn despawn_nodes(mut commands: Commands, query: Query<Entity, With<Node>>) {
-    for entity in query.iter() {
-        commands.entity(entity).despawn();
-    }
-}
-
 fn update(
     mut timer: Local<f32>,
+    mut visible_tree: Local<Coords>,
     time: Res<Time>,
-    state: Res<State<Coords>>,
-    mut next_state: ResMut<NextState<Coords>>,
+    mut coords_style_query: Query<(&Coords, &mut Style)>,
 ) {
-    *timer += time.delta_seconds();
-    if 1. <= *timer {
-        *timer = 0.;
-        next_state.set(if *state.get() == Coords::Viewport {
-            Coords::Pixel
-        } else {
-            Coords::Viewport
-        });
+    *timer -= time.delta_seconds();
+    if *timer <= 0. {
+        *timer = 1.;
+        *visible_tree = match *visible_tree {
+            Coords::Viewport => Coords::Pixel,
+            Coords::Pixel => Coords::Viewport,
+        };
+        for (coords, mut style) in coords_style_query.iter_mut() {
+            style.display = if *coords == *visible_tree {
+                Display::Flex
+            } else {
+                Display::None
+            };
+        }
     }
 }
 
 fn setup(mut commands: Commands) {
     commands.spawn(Camera2dBundle::default());
+    spawn_with_viewport_coords(&mut commands);
+    spawn_with_pixel_coords(&mut commands);
 }
 
-fn spawn_with_viewport_coords(mut commands: Commands) {
+fn spawn_with_viewport_coords(commands: &mut Commands) {
     commands
-        .spawn(NodeBundle {
-            style: Style {
-                width: Val::Vw(100.),
-                height: Val::Vh(100.),
-                border: UiRect::axes(Val::Vw(5.), Val::Vh(5.)),
-                flex_wrap: FlexWrap::Wrap,
+        .spawn((
+            NodeBundle {
+                style: Style {
+                    width: Val::Vw(100.),
+                    height: Val::Vh(100.),
+                    border: UiRect::axes(Val::Vw(5.), Val::Vh(5.)),
+                    flex_wrap: FlexWrap::Wrap,
+                    ..default()
+                },
+                border_color: PALETTE[0].into(),
                 ..default()
             },
-            background_color: PALETTE[0].into(),
-            border_color: PALETTE[1].into(),
-            ..default()
-        })
+            Coords::Viewport,
+        ))
         .with_children(|builder| {
             builder.spawn(NodeBundle {
                 style: Style {
@@ -155,20 +159,22 @@ fn spawn_with_viewport_coords(mut commands: Commands) {
         });
 }
 
-fn spawn_with_pixel_coords(mut commands: Commands) {
+fn spawn_with_pixel_coords(commands: &mut Commands) {
     commands
-        .spawn(NodeBundle {
-            style: Style {
-                width: Val::Px(800.),
-                height: Val::Px(600.),
-                border: UiRect::axes(Val::Px(40.), Val::Px(30.)),
-                flex_wrap: FlexWrap::Wrap,
+        .spawn((
+            NodeBundle {
+                style: Style {
+                    width: Val::Px(800.),
+                    height: Val::Px(600.),
+                    border: UiRect::axes(Val::Px(40.), Val::Px(30.)),
+                    flex_wrap: FlexWrap::Wrap,
+                    ..default()
+                },
+                border_color: PALETTE[1].into(),
                 ..default()
             },
-            background_color: PALETTE[1].into(),
-            border_color: PALETTE[0].into(),
-            ..default()
-        })
+            Coords::Pixel,
+        ))
         .with_children(|builder| {
             builder.spawn(NodeBundle {
                 style: Style {
diff --git a/tools/build-templated-pages/Cargo.toml b/tools/build-templated-pages/Cargo.toml
index 5d0bee2a6aafaa..4d7405d510dc9f 100644
--- a/tools/build-templated-pages/Cargo.toml
+++ b/tools/build-templated-pages/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "build-templated-pages"
-version = "0.11.0-dev"
+version = "0.12.0-dev"
 edition = "2021"
 description = "handle templated pages in Bevy repository"
 publish = false
diff --git a/tools/build-wasm-example/src/main.rs b/tools/build-wasm-example/src/main.rs
index a181084860a31d..0eedf274aeb580 100644
--- a/tools/build-wasm-example/src/main.rs
+++ b/tools/build-wasm-example/src/main.rs
@@ -109,7 +109,7 @@ fn main() {
 
         if cli.optimize_size {
             cmd!(sh, "wasm-opt -Oz --output examples/wasm/target/wasm_example_bg.wasm.optimized examples/wasm/target/wasm_example_bg.wasm")
-                .run().expect("Failed to optimize for size. Do you have wasm-opt corretly set up?");
+                .run().expect("Failed to optimize for size. Do you have wasm-opt correctly set up?");
         }
 
         if cli.test {