diff --git a/CHANGELOG.md b/CHANGELOG.md
index c4b68af..37efd63 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,16 @@
 # Changelog
 
+## bevy_mod_outline 0.13.0 (unreleased)
+
+###
+- Added frustum culling.
+
+### Removed
+- Removed facility to warm-up invisible outlines.
+
+### Changed
+- Updated Bevy dependency to 0.19.
+
 ## bevy_mod_outline 0.12.1 (2026-05-11)
 
 ## Changed
diff --git a/Cargo.toml b/Cargo.toml
index 535d438..70dde9f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_mod_outline"
-version = "0.12.1"
+version = "0.13.0"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "A mesh outlining plugin for Bevy."
@@ -11,29 +11,31 @@ keywords = ["gamedev", "bevy", "outline"]
 categories = ["game-engines", "rendering"]
 
 [dependencies]
-bevy = { version = "0.18", default-features = false, features = [
+bevy = { version = "0.19.0-rc.1", default-features = false, features = [
     "std",
     "async_executor",
     "bevy_log",
     "bevy_color",
     "bevy_image",
+    "bevy_anti_alias",
     "bevy_pbr",
 ] }
 bitfield = "0.15"
+indexmap = "2"
 interpolation = { version = "0.3", optional = true }
 thiserror = "1.0"
 nonmax = "0.5"
-wgpu-types = "27"
+wgpu-types = "29"
 itertools = { version = "0.14", optional = true }
 
 [features]
-default = ["flood", "interpolation", "reflect", "scene"]
+default = ["flood", "interpolation", "reflect", "world_serialisation"]
 flood = ["dep:itertools"]
 reflect = []
-scene = ["bevy/bevy_scene"]
+world_serialisation = ["bevy/bevy_world_serialization"]
 
 [dev-dependencies]
-bevy = { version = "0.18", default-features = false, features = [
+bevy = { version = "0.19.0-rc.1", default-features = false, features = [
     "gltf_animation",
     "bevy_anti_alias",
     "bevy_gltf",
diff --git a/README.md b/README.md
index 3817ef1..2987df0 100644
--- a/README.md
+++ b/README.md
@@ -12,7 +12,7 @@ vertex extrusion and jump flood methods.
 
 ```toml
 [dependencies]
-bevy_mod_outline = "0.12"
+bevy_mod_outline = "0.13"
 ```
 
 ## Examples
@@ -96,6 +96,7 @@ cargo run --example picking
 
 | This Version | Bevy version |
 |--------------|--------------|
+| 0.13.x       | 0.19.x       |
 | 0.12.x       | 0.18.x       |
 | 0.11.x       | 0.17.x       |
 | 0.10.x       | 0.16.x       |
@@ -115,7 +116,7 @@ cargo run --example picking
 - `interpolation` _(default)_ - Define `Lerp` trait impls using the
 `interpolation` crate.
 - `reflect` _(default)_ Define `Reflect` trait impls for the components.
-- `scene` _(default)_ Enable the `AsyncSceneInheritOutline` component.
+- `world_serialisation` _(default)_ Enable the `AsyncWorldInheritOutline` component.
 
 ## Licence
 
diff --git a/examples/alpha_mask.rs b/examples/alpha_mask.rs
index 84cc4b8..5dc8f07 100644
--- a/examples/alpha_mask.rs
+++ b/examples/alpha_mask.rs
@@ -78,7 +78,7 @@ fn setup(
         PointLight {
             color: Color::WHITE,
             intensity: 1500.0,
-            shadows_enabled: true,
+            shadow_maps_enabled: true,
             ..default()
         },
         Transform::from_xyz(4.0, 8.0, 4.0),
diff --git a/examples/animated_fox.rs b/examples/animated_fox.rs
index 4452082..ddc6ded 100644
--- a/examples/animated_fox.rs
+++ b/examples/animated_fox.rs
@@ -1,8 +1,8 @@
 use std::f32::consts::PI;
 
-use bevy::{prelude::*, scene::SceneInstance};
+use bevy::{prelude::*, world_serialization::WorldInstance};
 use bevy_mod_outline::{
-    AsyncSceneInheritOutline, AutoGenerateOutlineNormalsPlugin, OutlinePlugin, OutlineVolume,
+    AsyncWorldInheritOutline, AutoGenerateOutlineNormalsPlugin, OutlinePlugin, OutlineVolume,
 };
 
 #[derive(Resource)]
@@ -51,7 +51,7 @@ fn setup(
     // Light
     commands.spawn((
         DirectionalLight {
-            shadows_enabled: true,
+            shadow_maps_enabled: true,
             ..default()
         },
         Transform::from_rotation(Quat::from_euler(EulerRot::ZYX, 0.0, 1.0, -PI / 4.)),
@@ -59,21 +59,21 @@ fn setup(
 
     // Fox
     commands.spawn((
-        SceneRoot(asset_server.load("Fox.glb#Scene0")),
+        WorldAssetRoot(asset_server.load("Fox.glb#Scene0")),
         OutlineVolume {
             visible: true,
             width: 3.0,
             colour: Color::srgb(1.0, 0.0, 0.0),
         },
-        AsyncSceneInheritOutline::default(),
+        AsyncWorldInheritOutline::default(),
     ));
 }
 
 // Once the scene is loaded, start the animation
 fn setup_scene_once_loaded(
     mut commands: Commands,
-    scene_query: Query<&SceneInstance>,
-    scene_manager: Res<SceneSpawner>,
+    scene_query: Query<&WorldInstance>,
+    scene_manager: Res<WorldInstanceSpawner>,
     mut player_query: Query<(Entity, &mut AnimationPlayer)>,
     animation: Res<Fox>,
     mut done: Local<bool>,
diff --git a/examples/bloom.rs b/examples/bloom.rs
index 9d23541..8e01a26 100644
--- a/examples/bloom.rs
+++ b/examples/bloom.rs
@@ -1,9 +1,9 @@
 use std::f32::consts::{PI, TAU};
 
 use bevy::{
+    camera::Hdr,
     post_process::bloom::{Bloom, BloomCompositeMode},
     prelude::*,
-    render::view::Hdr,
 };
 
 use bevy_mod_outline::*;
diff --git a/examples/hollow.rs b/examples/hollow.rs
index 1b22c51..8a185fe 100644
--- a/examples/hollow.rs
+++ b/examples/hollow.rs
@@ -1,8 +1,8 @@
 use std::f32::consts::{PI, TAU};
 
-use bevy::{gltf::GltfPlugin, prelude::*, scene::SceneInstance};
+use bevy::{gltf::GltfPlugin, prelude::*, world_serialization::WorldInstance};
 use bevy_mod_outline::{
-    AsyncSceneInheritOutline, OutlinePlugin, OutlineVolume, ATTRIBUTE_OUTLINE_NORMAL,
+    AsyncWorldInheritOutline, OutlinePlugin, OutlineVolume, ATTRIBUTE_OUTLINE_NORMAL,
 };
 
 fn main() {
@@ -41,29 +41,29 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     commands.spawn((
         Transform::from_rotation(Quat::from_euler(EulerRot::ZYX, 0.0, 1.0, -PI / 4.)),
         DirectionalLight {
-            shadows_enabled: true,
+            shadow_maps_enabled: true,
             ..default()
         },
     ));
 
     // Hollow
     commands.spawn((
-        SceneRoot(asset_server.load("hollow.glb#Scene0")),
+        WorldAssetRoot(asset_server.load("hollow.glb#Scene0")),
         RotatesAndPulses,
         OutlineVolume {
             visible: true,
             width: 0.0,
             colour: Color::srgb(0.0, 0.0, 1.0),
         },
-        AsyncSceneInheritOutline::default(),
+        AsyncWorldInheritOutline::default(),
     ));
 }
 
 // Once the scene is loaded, start the animation and add an outline
 fn setup_scene_once_loaded(
     mut commands: Commands,
-    scene_query: Query<&SceneInstance>,
-    scene_manager: Res<SceneSpawner>,
+    scene_query: Query<&WorldInstance>,
+    scene_manager: Res<WorldInstanceSpawner>,
     name_query: Query<&Name, With<Mesh3d>>,
     mut done: Local<bool>,
 ) {
@@ -103,7 +103,7 @@ fn rotates_hue(
     timer: Res<Time>,
 ) {
     for handle in query.iter() {
-        let material = materials.get_mut(handle.id()).unwrap();
+        let mut material = materials.get_mut(handle.id()).unwrap();
         if let Color::Hsla(hsla) = material.base_color {
             material.base_color = Color::Hsla(Hsla {
                 hue: (hsla.hue + 15.0 * timer.delta_secs()) % 360.0,
diff --git a/examples/morph_targets.rs b/examples/morph_targets.rs
index 129621e..0db83f7 100644
--- a/examples/morph_targets.rs
+++ b/examples/morph_targets.rs
@@ -7,7 +7,7 @@
 //! - How to read morph target names in [`name_morphs`].
 //! - How to play morph target animations in [`setup_animations`].
 
-use bevy::{prelude::*, scene::SceneInstance};
+use bevy::{prelude::*, world_serialization::WorldInstance};
 use bevy_mod_outline::{
     AutoGenerateOutlineNormalsPlugin, InheritOutline, OutlinePlugin, OutlineVolume,
 };
@@ -43,7 +43,7 @@ fn setup(asset_server: Res<AssetServer>, mut commands: Commands) {
         mesh: asset_server.load("MorphStressTest.gltf#Mesh0/Primitive0"),
     });
     commands.spawn((
-        SceneRoot(asset_server.load("MorphStressTest.gltf#Scene0")),
+        WorldAssetRoot(asset_server.load("MorphStressTest.gltf#Scene0")),
         OutlineVolume {
             visible: true,
             width: 3.0,
@@ -65,8 +65,8 @@ fn setup(asset_server: Res<AssetServer>, mut commands: Commands) {
 fn setup_outlines(
     mut commands: Commands,
     mut has_setup: Local<bool>,
-    scene_query: Query<&SceneInstance>,
-    scene_manager: Res<SceneSpawner>,
+    scene_query: Query<&WorldInstance>,
+    scene_manager: Res<WorldInstanceSpawner>,
 ) {
     if *has_setup {
         return;
diff --git a/examples/picking.rs b/examples/picking.rs
index 5b86483..6a91e2d 100644
--- a/examples/picking.rs
+++ b/examples/picking.rs
@@ -75,7 +75,7 @@ fn setup(
     commands.spawn((
         PointLight {
             color: Color::srgb_u8(255, 255, 192),
-            shadows_enabled: true,
+            shadow_maps_enabled: true,
             ..default()
         },
         Transform::from_xyz(4.0, 8.0, 4.0),
diff --git a/examples/pieces.rs b/examples/pieces.rs
index 10dc086..d812872 100644
--- a/examples/pieces.rs
+++ b/examples/pieces.rs
@@ -83,7 +83,7 @@ fn setup(
     ));
     commands.spawn((
         PointLight {
-            shadows_enabled: true,
+            shadow_maps_enabled: true,
             ..default()
         },
         Transform::from_xyz(4.0, 8.0, 4.0),
diff --git a/examples/render_layers.rs b/examples/render_layers.rs
index 99ca70b..dc05901 100644
--- a/examples/render_layers.rs
+++ b/examples/render_layers.rs
@@ -63,7 +63,7 @@ fn setup(
     ));
     commands.spawn((
         PointLight {
-            shadows_enabled: true,
+            shadow_maps_enabled: true,
             ..default()
         },
         Transform::from_xyz(4.0, 8.0, 4.0),
diff --git a/examples/shapes.rs b/examples/shapes.rs
index bc615ff..f5dcbfb 100644
--- a/examples/shapes.rs
+++ b/examples/shapes.rs
@@ -74,7 +74,7 @@ fn setup(
     ));
     commands.spawn((
         PointLight {
-            shadows_enabled: true,
+            shadow_maps_enabled: true,
             ..default()
         },
         Transform::from_xyz(4.0, 8.0, 4.0),
diff --git a/examples/ui_aa.rs b/examples/ui_aa.rs
index e08e469..facbb06 100644
--- a/examples/ui_aa.rs
+++ b/examples/ui_aa.rs
@@ -158,7 +158,7 @@ fn setup(
     // Add light source and camera
     commands.spawn((
         PointLight {
-            shadows_enabled: true,
+            shadow_maps_enabled: true,
             ..default()
         },
         Transform::from_xyz(4.0, 8.0, 4.0),
diff --git a/src/computed.rs b/src/computed.rs
index b548cd1..df4b113 100644
--- a/src/computed.rs
+++ b/src/computed.rs
@@ -79,7 +79,7 @@ impl<T: Clone> Sourced<T> {
             }
         } else if let Some(v) = fallback {
             Sourced {
-                value: f(&v.clone().into()),
+                value: f(&v.as_ref().clone().into()),
                 source: Source::SetFallback,
             }
         } else if let Some(v) = inherit {
diff --git a/src/culling.rs b/src/culling.rs
new file mode 100644
index 0000000..4ad76f0
--- /dev/null
+++ b/src/culling.rs
@@ -0,0 +1,277 @@
+use bevy::camera::primitives::{Aabb, Frustum};
+use bevy::camera::visibility::{NoFrustumCulling, RenderLayers, SetViewVisibility};
+use bevy::camera::Camera;
+use bevy::math::primitives::ViewFrustum;
+use bevy::math::{Affine3A, Mat4, UVec2, Vec3, Vec4Swizzles};
+use bevy::platform::collections::HashMap;
+use bevy::prelude::*;
+use bevy::render::sync_world::{MainEntity, MainEntityHashMap};
+use bevy::render::view::{
+    RenderExtractedVisibleEntitiesClass, RenderVisibleEntitiesClass, RetainedViewEntity,
+};
+use bevy::render::Extract;
+
+use crate::computed::ComputedOutline;
+
+/// Per-entity, per-view information collected during visibility checking.
+#[derive(Default, Clone, Copy, Debug)]
+pub(crate) struct OutlineVisibleEntity {
+    /// Screen-space bounds of the outline, in physical pixels of the render
+    /// target.
+    pub screen_space_bounds: URect,
+}
+
+/// Per-view information about outlined entities visible from a view, in the
+/// main world.
+#[derive(Default, Clone, Debug)]
+pub(crate) struct OutlineViewVisibleEntities {
+    pub visible_entities: Vec<(Entity, OutlineVisibleEntity)>,
+}
+
+#[derive(Resource, Default, Clone, Debug)]
+pub(crate) struct OutlineVisibleEntities {
+    pub views: HashMap<RetainedViewEntity, OutlineViewVisibleEntities>,
+}
+
+#[derive(Default, Clone, Debug)]
+pub(crate) struct RenderExtractedOutlineViewEntities {
+    pub visible_entities_info: MainEntityHashMap<OutlineVisibleEntity>,
+    pub visible_entities: RenderExtractedVisibleEntitiesClass,
+}
+
+#[derive(Resource, Default, Clone, Debug)]
+pub(crate) struct RenderExtractedOutlineEntities {
+    pub views: HashMap<RetainedViewEntity, RenderExtractedOutlineViewEntities>,
+}
+
+#[derive(Default, Clone, Debug)]
+pub(crate) struct RenderOutlineViewEntities(pub RenderVisibleEntitiesClass);
+
+#[derive(Resource, Default, Clone, Debug)]
+pub(crate) struct RenderOutlineEntities {
+    pub views: HashMap<RetainedViewEntity, RenderOutlineViewEntities>,
+}
+
+#[allow(clippy::type_complexity)]
+pub(crate) fn check_outline_view_visibility(
+    mut visible: ResMut<OutlineVisibleEntities>,
+    views: Query<(
+        Entity,
+        &Camera,
+        &GlobalTransform,
+        Option<&RenderLayers>,
+        &Frustum,
+    )>,
+    mut outlines: Query<(
+        Entity,
+        &ComputedOutline,
+        Option<&Aabb>,
+        &GlobalTransform,
+        Has<NoFrustumCulling>,
+        &mut ViewVisibility,
+    )>,
+) {
+    visible.views.retain(|retained, _| {
+        views
+            .get(retained.main_entity.id())
+            .ok()
+            .and_then(|(_, camera, _, _, _)| live_viewport(camera))
+            .is_some()
+    });
+
+    for (view_entity, camera, view_transform, view_mask, frustum) in views.iter() {
+        let Some(physical_viewport) = live_viewport(camera) else {
+            continue;
+        };
+
+        let retained_view_entity = RetainedViewEntity::new(MainEntity::from(view_entity), None, 0);
+        let view_visible = visible.views.entry(retained_view_entity).or_default();
+        view_visible.visible_entities.clear();
+
+        let view_mask = view_mask.cloned().unwrap_or_default();
+        let view_from_world = view_transform.to_matrix().inverse();
+        let clip_from_world = camera.clip_from_view() * view_from_world;
+        let scale_factor = camera.target_scaling_factor().unwrap_or(1.0);
+
+        for (entity, computed, aabb, transform, no_frustum_culling, mut entity_in_view) in
+            outlines.iter_mut()
+        {
+            let Some(computed) = &computed.0 else {
+                continue;
+            };
+
+            // 1) Outline enabled.
+            let volume_enabled = computed.volume.value.enabled;
+            let stencil_enabled = computed.stencil.value.enabled.is_enabled(volume_enabled);
+            if !volume_enabled && !stencil_enabled {
+                continue;
+            }
+
+            // 2) Render layer intersection.
+            if !view_mask.intersects(&computed.layers.value) {
+                continue;
+            }
+
+            let world_from_local = transform.affine();
+
+            let screen_space_bounds = if let (Some(aabb), false) = (aabb, no_frustum_culling) {
+                // 3) Mesh AABB at least partly in front of the near plane.
+                let near = &frustum.half_spaces[ViewFrustum::NEAR_PLANE_IDX];
+                let aabb_center_world = world_from_local.transform_point3a(aabb.center).extend(1.0);
+                let relative_radius =
+                    aabb.relative_radius(&near.normal(), &world_from_local.matrix3);
+                if near.normal_d().dot(aabb_center_world) + relative_radius <= 0.0 {
+                    continue;
+                }
+
+                // 4) Compute screen-space bounds and check overlap with the viewport.
+                let border = (scale_factor * computed.volume.value.offset).ceil() as u32;
+                let Some(bounds) = compute_screen_space_bounds(
+                    aabb,
+                    &world_from_local,
+                    &clip_from_world,
+                    physical_viewport,
+                    border,
+                ) else {
+                    continue;
+                };
+                bounds
+            } else {
+                physical_viewport
+            };
+
+            view_visible.visible_entities.push((
+                entity,
+                OutlineVisibleEntity {
+                    screen_space_bounds,
+                },
+            ));
+            entity_in_view.set_visible();
+        }
+    }
+}
+
+fn live_viewport(camera: &Camera) -> Option<URect> {
+    if !camera.is_active {
+        return None;
+    }
+    let physical_viewport = camera.physical_viewport_rect()?;
+    let viewport_size = physical_viewport.size();
+    if viewport_size.x == 0 || viewport_size.y == 0 {
+        return None;
+    }
+    Some(physical_viewport)
+}
+
+pub(crate) fn extract_outline_visible_entities(
+    main_visible: Extract<Res<OutlineVisibleEntities>>,
+    mut render_extracted: ResMut<RenderExtractedOutlineEntities>,
+) {
+    let render_extracted = &mut *render_extracted;
+
+    render_extracted
+        .views
+        .retain(|view, _| main_visible.views.contains_key(view));
+
+    for (view, main_view) in main_visible.views.iter() {
+        let render_view = render_extracted.views.entry(*view).or_default();
+
+        render_view.visible_entities_info.clear();
+        render_view.visible_entities_info.extend(
+            main_view
+                .visible_entities
+                .iter()
+                .map(|(entity, info)| (MainEntity::from(*entity), *info)),
+        );
+
+        let entities = &mut render_view.visible_entities.entities;
+        entities.clear();
+        entities.extend(
+            main_view
+                .visible_entities
+                .iter()
+                .map(|(entity, _)| (Entity::PLACEHOLDER, MainEntity::from(*entity))),
+        );
+    }
+}
+
+pub(crate) fn collect_outline_cpu_culled_entities(
+    mut render_extracted: ResMut<RenderExtractedOutlineEntities>,
+    mut render_outline: ResMut<RenderOutlineEntities>,
+) {
+    let render_extracted = &mut *render_extracted;
+    let render_outline = &mut *render_outline;
+
+    render_outline
+        .views
+        .retain(|view, _| render_extracted.views.contains_key(view));
+
+    for (view, render_view_extracted) in render_extracted.views.iter_mut() {
+        let render_view_outline = render_outline.views.entry(*view).or_default();
+
+        render_view_outline.0.prepare_for_new_frame();
+
+        render_view_extracted
+            .visible_entities
+            .entities
+            .sort_unstable_by_key(|(_, main_entity)| *main_entity);
+
+        render_view_outline
+            .0
+            .update_cpu_culled_entities(&render_view_extracted.visible_entities.entities);
+    }
+}
+
+fn compute_screen_space_bounds(
+    aabb: &Aabb,
+    world_from_local: &Affine3A,
+    clip_from_world: &Mat4,
+    physical_viewport: URect,
+    border: u32,
+) -> Option<URect> {
+    let min = aabb.min();
+    let max = aabb.max();
+    let corners = [
+        Vec3::new(min.x, min.y, min.z),
+        Vec3::new(min.x, min.y, max.z),
+        Vec3::new(min.x, max.y, min.z),
+        Vec3::new(min.x, max.y, max.z),
+        Vec3::new(max.x, min.y, min.z),
+        Vec3::new(max.x, min.y, max.z),
+        Vec3::new(max.x, max.y, min.z),
+        Vec3::new(max.x, max.y, max.z),
+    ];
+
+    let viewport_size = physical_viewport.size();
+    let width = viewport_size.x;
+    let height = viewport_size.y;
+
+    let mut min_screen = UVec2::MAX;
+    let mut max_screen = UVec2::MIN;
+
+    for corner in corners.iter() {
+        let world_pos = world_from_local.transform_point3(*corner);
+        let clip_pos = *clip_from_world * world_pos.extend(1.0);
+        let ndc = clip_pos.xyz() / clip_pos.w;
+        if ndc.z < -1.0 || ndc.z > 1.0 {
+            continue;
+        }
+        let screen_x = ((ndc.x + 1.0) * 0.5 * width as f32).max(0.0) as u32;
+        let screen_y = ((-ndc.y + 1.0) * 0.5 * height as f32).max(0.0) as u32;
+        min_screen.x = min_screen.x.min(screen_x);
+        min_screen.y = min_screen.y.min(screen_y);
+        max_screen.x = max_screen.x.max(screen_x);
+        max_screen.y = max_screen.y.max(screen_y);
+    }
+
+    if min_screen.x >= max_screen.x || min_screen.y >= max_screen.y {
+        None
+    } else {
+        Some(URect::new(
+            physical_viewport.min.x + min_screen.x.saturating_sub(border).min(width),
+            physical_viewport.min.y + min_screen.y.saturating_sub(border).min(height),
+            physical_viewport.min.x + (max_screen.x + border).min(width),
+            physical_viewport.min.y + (max_screen.y + border).min(height),
+        ))
+    }
+}
diff --git a/src/flood/bounds.rs b/src/flood/bounds.rs
deleted file mode 100644
index 03f608a..0000000
--- a/src/flood/bounds.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-use bevy::camera::primitives::Aabb;
-use bevy::camera::Viewport;
-use bevy::ecs::component::Component;
-use bevy::math::{Affine3A, Mat4, UVec2, Vec4Swizzles};
-use bevy::prelude::*;
-use bevy::render::extract_component::ExtractComponent;
-
-use crate::computed::ComputedOutline;
-use crate::uniforms::DrawMode;
-
-/// Component for storing mesh bounds information needed for scissoring jump-flood operations
-#[derive(Clone, Component)]
-pub struct FloodMeshBounds {
-    /// The axis-aligned bounding box of the mesh in model space
-    pub aabb: Aabb,
-    /// The world-from-local transform for the entity
-    pub world_from_local: Affine3A,
-}
-
-impl FloodMeshBounds {
-    pub fn calculate_screen_space_bounds(
-        &self,
-        clip_from_world: &Mat4,
-        viewport: &Viewport,
-        border: u32,
-    ) -> Option<URect> {
-        // Get the 8 corners of the AABB
-        let min = self.aabb.min();
-        let max = self.aabb.max();
-        let corners = [
-            Vec3::new(min.x, min.y, min.z),
-            Vec3::new(min.x, min.y, max.z),
-            Vec3::new(min.x, max.y, min.z),
-            Vec3::new(min.x, max.y, max.z),
-            Vec3::new(max.x, min.y, min.z),
-            Vec3::new(max.x, min.y, max.z),
-            Vec3::new(max.x, max.y, min.z),
-            Vec3::new(max.x, max.y, max.z),
-        ];
-
-        // Initialize min/max screen coordinates with extreme values
-        let mut min_screen = UVec2::MAX;
-        let mut max_screen = UVec2::MIN;
-
-        // Use the physical target size for width and height
-        let width = viewport.physical_size.x;
-        let height = viewport.physical_size.y;
-
-        // Project each corner to screen space and update min/max values
-        for corner in corners.iter() {
-            // Convert corner to world space
-            let world_pos = self.world_from_local.transform_point3(*corner);
-
-            // Project to clip space
-            let clip_pos = *clip_from_world * world_pos.extend(1.0);
-
-            // Perspective divide to get NDC coordinates
-            let ndc = clip_pos.xyz() / clip_pos.w;
-
-            // Skip if behind camera
-            if ndc.z < -1.0 || ndc.z > 1.0 {
-                continue;
-            }
-
-            // Convert from NDC to pixel coordinates
-            let screen_x = ((ndc.x + 1.0) * 0.5 * width as f32).max(0.0) as u32;
-            let screen_y = ((-ndc.y + 1.0) * 0.5 * height as f32).max(0.0) as u32;
-
-            min_screen.x = min_screen.x.min(screen_x);
-            min_screen.y = min_screen.y.min(screen_y);
-            max_screen.x = max_screen.x.max(screen_x);
-            max_screen.y = max_screen.y.max(screen_y);
-        }
-
-        // If nothing is in view, return None
-        if min_screen.x >= max_screen.x || min_screen.y >= max_screen.y {
-            None
-        } else {
-            Some(URect::new(
-                viewport.physical_position.x + min_screen.x.saturating_sub(border).min(width),
-                viewport.physical_position.y + min_screen.y.saturating_sub(border).min(height),
-                viewport.physical_position.x + (max_screen.x + border).min(width),
-                viewport.physical_position.y + (max_screen.y + border).min(height),
-            ))
-        }
-    }
-}
-
-impl ExtractComponent for FloodMeshBounds {
-    type QueryData = (
-        &'static Aabb,
-        &'static GlobalTransform,
-        &'static ComputedOutline,
-    );
-    type QueryFilter = ();
-    type Out = Self;
-
-    fn extract_component(
-        (aabb, global_transform, computed_outline): bevy::ecs::query::QueryItem<Self::QueryData>,
-    ) -> Option<Self::Out> {
-        let Some(computed_outline) = &computed_outline.0 else {
-            return None;
-        };
-
-        match computed_outline.mode.value.draw_mode {
-            DrawMode::JumpFlood => Some(FloodMeshBounds {
-                aabb: *aabb,
-                world_from_local: global_transform.affine(),
-            }),
-            _ => None,
-        }
-    }
-}
diff --git a/src/flood/compose_output.rs b/src/flood/compose_output.rs
index c675d27..523e076 100644
--- a/src/flood/compose_output.rs
+++ b/src/flood/compose_output.rs
@@ -7,11 +7,12 @@ use bevy::{
         render_resource::{
             binding_types::{sampler, texture_2d, uniform_buffer},
             BindGroupEntries, BindGroupLayoutDescriptor, BindGroupLayoutEntries,
-            CachedRenderPipelineId, FragmentState, PipelineCache, RenderPassDescriptor,
-            RenderPipeline, RenderPipelineDescriptor, Sampler, SamplerDescriptor, ShaderType,
-            StoreOp,
+            CachedRenderPipelineId, DynamicUniformBuffer, FragmentState, PipelineCache,
+            RenderPassDescriptor, RenderPipeline, RenderPipelineDescriptor, Sampler,
+            SamplerDescriptor, ShaderType, StoreOp,
         },
-        renderer::{RenderContext, RenderDevice},
+        renderer::{RenderContext, RenderDevice, RenderQueue},
+        sync_world::{MainEntity, MainEntityHashMap},
         texture::CachedTexture,
         view::{ExtractedView, ViewDepthTexture, ViewTarget},
     },
@@ -22,28 +23,41 @@ use wgpu_types::{
     TextureFormat, TextureSampleType,
 };
 
-use crate::{pipeline_key::ViewPipelineKey, uniforms::ExtractedOutline};
+use crate::{pipeline_key::ViewPipelineKey, uniforms::RenderOutlineInstances};
 
 use super::{DrawMode, OutlineViewUniform, COMPOSE_OUTPUT_SHADER_HANDLE};
 
-#[derive(Clone, Component, ShaderType)]
+#[derive(Clone, ShaderType)]
 pub(crate) struct ComposeOutputUniform {
     pub volume_offset: f32,
     pub volume_colour: Vec4,
 }
 
+#[derive(Resource, Default)]
+pub(crate) struct ComposeOutputUniforms {
+    pub buffer: DynamicUniformBuffer<ComposeOutputUniform>,
+    pub offsets: MainEntityHashMap<u32>,
+}
+
 pub(crate) fn prepare_compose_output_uniform(
-    mut commands: Commands,
-    query: Query<(Entity, &ExtractedOutline)>,
+    render_outlines: Res<RenderOutlineInstances>,
+    mut uniforms: ResMut<ComposeOutputUniforms>,
+    render_device: Res<RenderDevice>,
+    render_queue: Res<RenderQueue>,
 ) {
-    for (entity, outline) in query.iter() {
+    let uniforms = uniforms.as_mut();
+    uniforms.buffer.clear();
+    uniforms.offsets.clear();
+    for (main_entity, outline) in render_outlines.iter() {
         if outline.draw_mode == DrawMode::JumpFlood {
-            commands.entity(entity).insert(ComposeOutputUniform {
+            let offset = uniforms.buffer.push(&ComposeOutputUniform {
                 volume_offset: outline.instance_data.volume_offset,
                 volume_colour: outline.instance_data.volume_colour,
             });
+            uniforms.offsets.insert(*main_entity, offset);
         }
     }
+    uniforms.buffer.write_buffer(&render_device, &render_queue);
 }
 
 #[derive(Clone, Resource)]
@@ -53,31 +67,30 @@ pub(crate) struct ComposeOutputPipeline {
     pub(crate) pipeline_cache: HashMap<ViewPipelineKey, CachedRenderPipelineId>,
 }
 
-impl FromWorld for ComposeOutputPipeline {
-    fn from_world(world: &mut World) -> Self {
-        let render_device = world.resource::<RenderDevice>();
-
-        let layout = BindGroupLayoutDescriptor::new(
-            "outline_flood_compose_output_bind_group_layout",
-            &BindGroupLayoutEntries::sequential(
-                ShaderStages::FRAGMENT,
-                (
-                    texture_2d(TextureSampleType::Float { filterable: true }),
-                    sampler(SamplerBindingType::Filtering),
-                    uniform_buffer::<OutlineViewUniform>(true),
-                    uniform_buffer::<ComposeOutputUniform>(true),
-                ),
+pub(crate) fn init_compose_output_pipeline(
+    mut commands: Commands,
+    render_device: Res<RenderDevice>,
+) {
+    let layout = BindGroupLayoutDescriptor::new(
+        "outline_flood_compose_output_bind_group_layout",
+        &BindGroupLayoutEntries::sequential(
+            ShaderStages::FRAGMENT,
+            (
+                texture_2d(TextureSampleType::Float { filterable: true }),
+                sampler(SamplerBindingType::Filtering),
+                uniform_buffer::<OutlineViewUniform>(true),
+                uniform_buffer::<ComposeOutputUniform>(true),
             ),
-        );
+        ),
+    );
 
-        let sampler = render_device.create_sampler(&SamplerDescriptor::default());
+    let sampler = render_device.create_sampler(&SamplerDescriptor::default());
 
-        Self {
-            layout,
-            sampler,
-            pipeline_cache: HashMap::new(),
-        }
-    }
+    commands.insert_resource(ComposeOutputPipeline {
+        layout,
+        sampler,
+        pipeline_cache: HashMap::new(),
+    });
 }
 
 impl ComposeOutputPipeline {
@@ -97,11 +110,7 @@ impl ComposeOutputPipeline {
                     shader_defs: vec![],
                     entry_point: None,
                     targets: vec![Some(ColorTargetState {
-                        format: if key.hdr_format() {
-                            ViewTarget::TEXTURE_FORMAT_HDR
-                        } else {
-                            TextureFormat::bevy_default()
-                        },
+                        format: key.target_format(),
                         blend: Some(BlendState::ALPHA_BLENDING),
                         write_mask: ColorWrites::ALL,
                     })],
@@ -109,8 +118,8 @@ impl ComposeOutputPipeline {
                 primitive: PrimitiveState::default(),
                 depth_stencil: Some(DepthStencilState {
                     format: TextureFormat::Depth32Float,
-                    depth_write_enabled: true,
-                    depth_compare: CompareFunction::Greater,
+                    depth_write_enabled: Some(true),
+                    depth_compare: Some(CompareFunction::Greater),
                     stencil: StencilState::default(),
                     bias: DepthBiasState::default(),
                 }),
@@ -119,7 +128,7 @@ impl ComposeOutputPipeline {
                     mask: !0,
                     alpha_to_coverage_enabled: false,
                 },
-                push_constant_ranges: vec![],
+                immediate_size: 0,
                 zero_initialize_workgroup_memory: false,
             })
         })
@@ -144,7 +153,7 @@ pub(crate) fn prepare_compose_output_pass(
             &fullscreen_shader,
             ViewPipelineKey::new()
                 .with_msaa(*msaa)
-                .with_hdr_format(view.hdr),
+                .with_target_format(view.target_format),
         );
         commands
             .entity(entity)
@@ -157,7 +166,7 @@ pub(crate) struct ComposeOutputPass<'w> {
     pipeline: &'w ComposeOutputPipeline,
     render_pipeline: &'w RenderPipeline,
     outline_view_uniforms: &'w ComponentUniforms<OutlineViewUniform>,
-    compose_output_uniforms: &'w ComponentUniforms<ComposeOutputUniform>,
+    compose_output_uniforms: &'w ComposeOutputUniforms,
     view_target: &'w ViewTarget,
     view_depth: &'w ViewDepthTexture,
 }
@@ -174,7 +183,7 @@ impl<'w> ComposeOutputPass<'w> {
         let render_pipeline =
             pipeline_cache.get_render_pipeline(compose_output_view.pipeline_id)?;
         let outline_view_uniforms = world.resource::<ComponentUniforms<OutlineViewUniform>>();
-        let compose_output_uniforms = world.resource::<ComponentUniforms<ComposeOutputUniform>>();
+        let compose_output_uniforms = world.resource::<ComposeOutputUniforms>();
 
         Some(Self {
             world,
@@ -189,9 +198,9 @@ impl<'w> ComposeOutputPass<'w> {
 
     pub fn execute(
         &self,
-        render_context: &mut RenderContext<'_>,
+        render_context: &mut RenderContext<'_, '_>,
         view_entity: Entity,
-        render_entity: Entity,
+        main_entity: MainEntity,
         input: &CachedTexture,
         pipeline_cache: &PipelineCache,
         bounds: &URect,
@@ -202,12 +211,11 @@ impl<'w> ComposeOutputPass<'w> {
             .get::<DynamicUniformIndex<OutlineViewUniform>>()
             .unwrap()
             .index();
-        let dynamic_index = self
-            .world
-            .entity(render_entity)
-            .get::<DynamicUniformIndex<ComposeOutputUniform>>()
-            .unwrap()
-            .index();
+        let dynamic_index = *self
+            .compose_output_uniforms
+            .offsets
+            .get(&main_entity)
+            .unwrap();
 
         let bind_group = render_context.render_device().create_bind_group(
             "outline_flood_compose_output_bind_group",
@@ -216,7 +224,7 @@ impl<'w> ComposeOutputPass<'w> {
                 &input.default_view,
                 &self.pipeline.sampler,
                 self.outline_view_uniforms.binding().unwrap(),
-                self.compose_output_uniforms.binding().unwrap(),
+                self.compose_output_uniforms.buffer.binding().unwrap(),
             )),
         );
 
@@ -226,6 +234,7 @@ impl<'w> ComposeOutputPass<'w> {
             depth_stencil_attachment: Some(self.view_depth.get_attachment(StoreOp::Store)),
             timestamp_writes: None,
             occlusion_query_set: None,
+            multiview_mask: None,
         });
 
         render_pass.set_scissor_rect(bounds.min.x, bounds.min.y, bounds.width(), bounds.height());
diff --git a/src/flood/flood_init.rs b/src/flood/flood_init.rs
index 6e9f104..6a7e541 100644
--- a/src/flood/flood_init.rs
+++ b/src/flood/flood_init.rs
@@ -1,12 +1,9 @@
 use std::ops::Range;
 
-use bevy::camera::visibility::RenderLayers;
-use bevy::camera::Viewport;
 use bevy::prelude::*;
 use bevy::render::camera::ExtractedCamera;
 use bevy::render::mesh::allocator::MeshAllocator;
 use bevy::render::render_phase::{DrawFunctions, PhaseItemExtraIndex, ViewSortedRenderPhases};
-use bevy::render::sync_world::MainEntity;
 use bevy::render::view::ExtractedView;
 use bevy::render::{
     render_phase::SortedRenderPhase,
@@ -17,11 +14,14 @@ use bevy::render::{
     texture::CachedTexture,
 };
 
-use crate::queue::{OutlineCache, OutlineCacheEntry, OutlineRangefinder};
-use crate::uniforms::ExtractedOutline;
+use crate::culling::{RenderExtractedOutlineEntities, RenderOutlineEntities};
+use crate::node::OutlineSortingInfo;
+use crate::queue::{
+    DirtyOutlineSpecialisations, OutlineCache, OutlineCacheEntry, PendingOutlineQueues,
+};
+use crate::uniforms::RenderOutlineInstances;
 use crate::view_uniforms::OutlineQueueStatus;
 
-use super::bounds::FloodMeshBounds;
 use super::node::FloodOutline;
 use super::{DrawMode, DrawOutline, OutlineViewUniform};
 
@@ -30,7 +30,7 @@ pub(crate) fn prepare_flood_phases(
     mut flood_phases: ResMut<ViewSortedRenderPhases<FloodOutline>>,
 ) {
     for view in query.iter() {
-        flood_phases.insert_or_clear(view.retained_view_entity);
+        flood_phases.prepare_for_new_frame(view.retained_view_entity);
     }
 }
 
@@ -39,83 +39,86 @@ pub(crate) fn queue_flood_meshes(
     flood_draw_functions: Res<DrawFunctions<FloodOutline>>,
     mesh_allocator: Res<MeshAllocator>,
     outline_cache: Res<OutlineCache>,
-    material_meshes: Query<(Entity, &MainEntity, &ExtractedOutline, &FloodMeshBounds)>,
+    render_outlines: Res<RenderOutlineInstances>,
+    render_visible: Res<RenderOutlineEntities>,
+    render_extracted: Res<RenderExtractedOutlineEntities>,
+    pending_queues: ResMut<PendingOutlineQueues>,
+    specialisations: Res<DirtyOutlineSpecialisations>,
     mut flood_phases: ResMut<ViewSortedRenderPhases<FloodOutline>>,
-    mut views: Query<(
-        &ExtractedView,
-        &ExtractedCamera,
-        Option<&RenderLayers>,
-        &OutlineViewUniform,
-        &mut OutlineQueueStatus,
-    )>,
+    mut views: Query<(&ExtractedView, &mut OutlineQueueStatus)>,
 ) {
     let draw_flood = flood_draw_functions.read().get_id::<DrawOutline>().unwrap();
 
-    for (view, camera, view_mask, view_uniform, mut queue_status) in views.iter_mut() {
-        let view_mask = view_mask.cloned().unwrap_or_default();
-
+    for (view, mut queue_status) in views.iter_mut() {
         let Some(flood_phase) = flood_phases.get_mut(&view.retained_view_entity) else {
             continue;
         };
 
-        // Get the camera's physical target size for correct screen bounds calculation
-        let fallback_viewport = Viewport {
-            physical_size: camera.physical_target_size.unwrap_or_default(),
-            ..default()
-        };
-        let viewport = camera.viewport.as_ref().unwrap_or(&fallback_viewport);
-
-        let clip_from_world = view
-            .clip_from_world
-            .unwrap_or_else(|| view.clip_from_view * view.world_from_view.to_matrix().inverse());
-
-        let rangefinder = OutlineRangefinder::new(view);
-
         let outline_view_cache = outline_cache
             .view_map
             .get(&view.retained_view_entity)
             .unwrap();
 
-        for (entity, main_entity, outline, mesh_bounds) in material_meshes.iter() {
-            if !outline.volume {
-                continue;
-            }
+        let Some(render_view_visible) = render_visible.views.get(&view.retained_view_entity) else {
+            continue;
+        };
 
-            if !view_mask.intersects(&outline.layers) {
+        let Some(render_view_extracted) = render_extracted.views.get(&view.retained_view_entity)
+        else {
+            continue;
+        };
+
+        let Some(view_pending_queues) = pending_queues.get(&view.retained_view_entity) else {
+            continue;
+        };
+
+        for &main_entity in
+            specialisations.iter_to_dequeue(view.retained_view_entity, &render_view_visible.0)
+        {
+            flood_phase.remove(Entity::PLACEHOLDER, main_entity);
+        }
+
+        for (_, &main_entity) in specialisations.iter_to_queue(
+            view.retained_view_entity,
+            &render_view_visible.0,
+            &view_pending_queues.prev_frame,
+        ) {
+            let Some(outline) = render_outlines.get(&main_entity) else {
                 continue;
-            }
+            };
 
             if outline.draw_mode != DrawMode::JumpFlood {
                 continue;
             }
 
-            // Calculate screen-space bounds of outline
-            let border = (view_uniform.scale_physical_from_logical
-                * outline.instance_data.volume_offset)
-                .ceil() as u32;
-            let Some(screen_space_bounds) =
-                mesh_bounds.calculate_screen_space_bounds(&clip_from_world, viewport, border)
+            let Some(visible_info) = render_view_extracted
+                .visible_entities_info
+                .get(&main_entity)
             else {
                 continue;
             };
+            let screen_space_bounds = visible_info.screen_space_bounds;
 
-            let (_vertex_slab, index_slab) = mesh_allocator.mesh_slabs(&outline.mesh_id);
+            let mesh_slabs = mesh_allocator.mesh_slabs(&outline.mesh_id);
+            let index_slab = mesh_slabs.and_then(|s| s.index_slab_id);
 
             let Some(OutlineCacheEntry {
-                changed_tick: _,
                 stencil_pipeline_id: _,
                 volume_pipeline_id,
-            }) = outline_view_cache.entity_map.get(main_entity)
+            }) = outline_view_cache.entity_map.get(&main_entity)
             else {
                 continue;
             };
 
-            queue_status.has_volume = true;
-
+            let sorting_info = OutlineSortingInfo {
+                world_plane_origin: outline.instance_data.world_plane_origin,
+                world_plane_offset: outline.instance_data.world_plane_offset,
+            };
             flood_phase.add(FloodOutline {
-                distance: rangefinder.distance_of(outline),
-                entity,
-                main_entity: *main_entity,
+                sorting_info,
+                distance: 0.0,
+                entity: Entity::PLACEHOLDER,
+                main_entity,
                 pipeline: *volume_pipeline_id,
                 draw_function: draw_flood,
                 batch_range: 0..0,
@@ -126,6 +129,10 @@ pub(crate) fn queue_flood_meshes(
                 screen_space_bounds,
             });
         }
+
+        if !flood_phase.items.is_empty() {
+            queue_status.has_volume = true;
+        }
     }
 }
 
@@ -153,7 +160,7 @@ impl<'w> FloodInitPass<'w> {
 
     pub fn execute(
         &mut self,
-        render_context: &mut RenderContext<'_>,
+        render_context: &mut RenderContext<'_, '_>,
         range: Range<usize>,
         output: &CachedTexture,
     ) {
@@ -178,6 +185,7 @@ impl<'w> FloodInitPass<'w> {
             depth_stencil_attachment: None,
             timestamp_writes: None,
             occlusion_query_set: None,
+            multiview_mask: None,
         });
 
         if let Some(viewport) = self.camera.viewport.as_ref() {
diff --git a/src/flood/jump_flood.rs b/src/flood/jump_flood.rs
index 94ce21b..0383f29 100644
--- a/src/flood/jump_flood.rs
+++ b/src/flood/jump_flood.rs
@@ -35,71 +35,67 @@ pub(crate) struct JumpFloodPipeline {
     pub(crate) lookup_offsets: Vec<u32>,
 }
 
-impl FromWorld for JumpFloodPipeline {
-    fn from_world(world: &mut World) -> Self {
-        let render_device = world.resource::<RenderDevice>();
-
-        let layout = BindGroupLayoutDescriptor::new(
-            "outline_jump_flood_bind_group_layout",
-            &BindGroupLayoutEntries::sequential(
-                ShaderStages::FRAGMENT,
-                (
-                    texture_2d(TextureSampleType::Float { filterable: true }),
-                    sampler(SamplerBindingType::Filtering),
-                    uniform_buffer::<JumpFloodUniform>(true),
-                ),
+pub(crate) fn init_jump_flood_pipeline(
+    mut commands: Commands,
+    render_device: Res<RenderDevice>,
+    render_queue: Res<RenderQueue>,
+    fullscreen_shader: Res<FullscreenShader>,
+    pipeline_cache: Res<PipelineCache>,
+) {
+    let layout = BindGroupLayoutDescriptor::new(
+        "outline_jump_flood_bind_group_layout",
+        &BindGroupLayoutEntries::sequential(
+            ShaderStages::FRAGMENT,
+            (
+                texture_2d(TextureSampleType::Float { filterable: true }),
+                sampler(SamplerBindingType::Filtering),
+                uniform_buffer::<JumpFloodUniform>(true),
             ),
-        );
-
-        let sampler = render_device.create_sampler(&SamplerDescriptor::default());
+        ),
+    );
 
-        let fullscreen_shader = world.resource::<FullscreenShader>().to_vertex_state();
-        let pipeline_id =
-            world
-                .resource_mut::<PipelineCache>()
-                .queue_render_pipeline(RenderPipelineDescriptor {
-                    label: Some("outline_jump_flood_pipeline".into()),
-                    layout: vec![layout.clone()],
-                    vertex: fullscreen_shader,
-                    fragment: Some(FragmentState {
-                        shader: JUMP_FLOOD_SHADER_HANDLE,
-                        shader_defs: vec![],
-                        entry_point: None,
-                        targets: vec![Some(ColorTargetState {
-                            format: TextureFormat::Rgba16Float,
-                            blend: None,
-                            write_mask: ColorWrites::ALL,
-                        })],
-                    }),
-                    primitive: PrimitiveState::default(),
-                    depth_stencil: None,
-                    multisample: MultisampleState::default(),
-                    push_constant_ranges: vec![],
-                    zero_initialize_workgroup_memory: false,
-                });
+    let sampler = render_device.create_sampler(&SamplerDescriptor::default());
 
-        let render_device = world.resource::<RenderDevice>();
-        let render_queue = world.resource::<RenderQueue>();
-        let mut uniform_buffer = DynamicUniformBuffer::new_with_alignment(
-            render_device.limits().min_uniform_buffer_offset_alignment as u64,
-        );
-        let mut offsets = Vec::new();
-        for bit in 0..32 {
-            offsets.push(uniform_buffer.push(&JumpFloodUniform {
-                size: 1 << bit,
-                _padding: Vec3::default(),
-            }));
-        }
-        uniform_buffer.write_buffer(render_device, render_queue);
+    let pipeline_id = pipeline_cache.queue_render_pipeline(RenderPipelineDescriptor {
+        label: Some("outline_jump_flood_pipeline".into()),
+        layout: vec![layout.clone()],
+        vertex: fullscreen_shader.to_vertex_state(),
+        fragment: Some(FragmentState {
+            shader: JUMP_FLOOD_SHADER_HANDLE,
+            shader_defs: vec![],
+            entry_point: None,
+            targets: vec![Some(ColorTargetState {
+                format: TextureFormat::Rgba16Float,
+                blend: None,
+                write_mask: ColorWrites::ALL,
+            })],
+        }),
+        primitive: PrimitiveState::default(),
+        depth_stencil: None,
+        multisample: MultisampleState::default(),
+        immediate_size: 0,
+        zero_initialize_workgroup_memory: false,
+    });
 
-        Self {
-            layout,
-            sampler,
-            pipeline_id,
-            lookup_buffer: uniform_buffer,
-            lookup_offsets: offsets,
-        }
+    let mut uniform_buffer = DynamicUniformBuffer::new_with_alignment(
+        render_device.limits().min_uniform_buffer_offset_alignment as u64,
+    );
+    let mut offsets = Vec::new();
+    for bit in 0..32 {
+        offsets.push(uniform_buffer.push(&JumpFloodUniform {
+            size: 1 << bit,
+            _padding: Vec3::default(),
+        }));
     }
+    uniform_buffer.write_buffer(&render_device, &render_queue);
+
+    commands.insert_resource(JumpFloodPipeline {
+        layout,
+        sampler,
+        pipeline_id,
+        lookup_buffer: uniform_buffer,
+        lookup_offsets: offsets,
+    });
 }
 
 pub(crate) struct JumpFloodPass<'w> {
@@ -121,7 +117,7 @@ impl<'w> JumpFloodPass<'w> {
 
     pub fn execute(
         &mut self,
-        render_context: &mut RenderContext<'_>,
+        render_context: &mut RenderContext<'_, '_>,
         input: &CachedTexture,
         output: &CachedTexture,
         pipeline_cache: &PipelineCache,
@@ -149,6 +145,7 @@ impl<'w> JumpFloodPass<'w> {
             depth_stencil_attachment: None,
             timestamp_writes: None,
             occlusion_query_set: None,
+            multiview_mask: None,
         });
 
         render_pass.set_scissor_rect(bounds.min.x, bounds.min.y, bounds.width(), bounds.height());
diff --git a/src/flood/mod.rs b/src/flood/mod.rs
index 131e173..e9abb59 100644
--- a/src/flood/mod.rs
+++ b/src/flood/mod.rs
@@ -1,9 +1,7 @@
 use bevy::asset::{load_internal_asset, uuid_handle};
-use bevy::core_pipeline::core_3d::graph::Core3d;
+use bevy::core_pipeline::{Core3d, Core3dSystems};
 use bevy::pbr::{MeshInputUniform, MeshUniform};
 use bevy::render::batching::gpu_preprocessing::{BatchedInstanceBuffers, GpuPreprocessingSupport};
-use bevy::render::extract_component::{ExtractComponentPlugin, UniformComponentPlugin};
-use bevy::render::render_graph::RenderGraphExt;
 use bevy::render::render_phase::{
     sort_phase_system, AddRenderCommand, DrawFunctions, SortedRenderPhasePlugin,
 };
@@ -12,30 +10,29 @@ use bevy::{
     prelude::*,
     render::{
         camera::ExtractedCamera,
-        render_graph::ViewNodeRunner,
         render_resource::{
             Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages,
         },
         renderer::RenderDevice,
         texture::{CachedTexture, TextureCache},
-        Render, RenderApp, RenderSystems,
+        Render, RenderApp, RenderStartup, RenderSystems,
     },
 };
 use compose_output::{
-    prepare_compose_output_pass, prepare_compose_output_uniform, ComposeOutputPipeline,
-    ComposeOutputUniform,
+    init_compose_output_pipeline, prepare_compose_output_pass, prepare_compose_output_uniform,
+    ComposeOutputUniforms,
 };
 use flood_init::{prepare_flood_phases, queue_flood_meshes};
-use jump_flood::JumpFloodPipeline;
-use node::{FloodNode, FloodOutline};
+use jump_flood::init_jump_flood_pipeline;
+use node::{flood_render_pass, FloodOutline};
 
+use crate::add_dummy_phase_buffer;
+use crate::node::outline_render_pass;
 use crate::pipeline::OutlinePipeline;
 use crate::render::DrawOutline;
 use crate::uniforms::DrawMode;
 use crate::view_uniforms::OutlineViewUniform;
-use crate::{add_dummy_phase_buffer, NodeOutline};
 
-mod bounds;
 mod compose_output;
 mod flood_init;
 mod jump_flood;
@@ -134,12 +131,11 @@ impl Plugin for FloodPlugin {
             "compose_output.wgsl",
             Shader::from_wgsl
         );
-        app.add_plugins((
-            UniformComponentPlugin::<ComposeOutputUniform>::default(),
-            SortedRenderPhasePlugin::<FloodOutline, OutlinePipeline>::new(RenderDebugFlags::empty()),
-            ExtractComponentPlugin::<bounds::FloodMeshBounds>::default(),
+        app.add_plugins(SortedRenderPhasePlugin::<FloodOutline, OutlinePipeline>::new(
+            RenderDebugFlags::empty(),
         ))
         .sub_app_mut(RenderApp)
+        .init_resource::<ComposeOutputUniforms>()
         .init_resource::<DrawFunctions<FloodOutline>>()
         .add_render_command::<FloodOutline, DrawOutline>()
         .add_systems(
@@ -150,35 +146,27 @@ impl Plugin for FloodPlugin {
         )
         .add_systems(
             Render,
-            prepare_compose_output_uniform
-                .after(RenderSystems::ExtractCommands)
-                .before(RenderSystems::PrepareResources),
-        )
-        .add_systems(
-            Render,
-            (prepare_flood_textures, prepare_compose_output_pass).in_set(RenderSystems::Prepare),
+            (prepare_flood_textures, prepare_compose_output_uniform, prepare_compose_output_pass).in_set(RenderSystems::Prepare),
         )
         .add_systems(Render, queue_flood_meshes.in_set(RenderSystems::QueueMeshes))
         .add_systems(
             Render,
             sort_phase_system::<FloodOutline>.in_set(RenderSystems::PhaseSort),
         )
-        .add_render_graph_node::<ViewNodeRunner<FloodNode>>(Core3d, NodeOutline::FloodPass)
-        .add_render_graph_edges(
+        .add_systems(
             Core3d,
-            (
-                NodeOutline::OutlinePass,
-                NodeOutline::FloodPass,
-                NodeOutline::EndOutlinePasses,
-            ),
+            flood_render_pass
+                .after(outline_render_pass)
+                .in_set(Core3dSystems::PostProcess),
         );
     }
 
     fn finish(&self, app: &mut App) {
         let render_app = app.sub_app_mut(RenderApp);
-        render_app
-            .init_resource::<JumpFloodPipeline>()
-            .init_resource::<ComposeOutputPipeline>();
+        render_app.add_systems(
+            RenderStartup,
+            (init_jump_flood_pipeline, init_compose_output_pipeline),
+        );
 
         let gpu_preprocessing_support = render_app.world().resource::<GpuPreprocessingSupport>();
         if gpu_preprocessing_support.is_available() {
diff --git a/src/flood/node.rs b/src/flood/node.rs
index 72b1f85..55ab146 100644
--- a/src/flood/node.rs
+++ b/src/flood/node.rs
@@ -1,4 +1,4 @@
-use bevy::ecs::query::QueryItem;
+use bevy::ecs::entity::EntityHash;
 use bevy::render::render_phase::{
     CachedRenderPipelinePhaseItem, DrawFunctionId, PhaseItem, ViewSortedRenderPhases,
 };
@@ -8,17 +8,18 @@ use bevy::{
     prelude::*,
     render::{
         camera::ExtractedCamera,
-        render_graph::{NodeRunError, RenderGraphContext, ViewNode},
         render_phase::{PhaseItemExtraIndex, SortedPhaseItem},
         render_resource::{CachedRenderPipelineId, PipelineCache},
-        renderer::RenderContext,
+        renderer::{RenderContext, ViewQuery},
         sync_world::MainEntity,
         view::ViewTarget,
     },
 };
+use indexmap::IndexMap;
 use itertools::*;
 use std::ops::Range;
 
+use crate::node::{OutlineRangefinder, OutlineSortingInfo};
 use crate::OutlineViewUniform;
 
 use super::compose_output::{ComposeOutputPass, ComposeOutputView};
@@ -28,6 +29,7 @@ use super::FloodTextures;
 
 #[derive(Debug)]
 pub struct FloodOutline {
+    pub sorting_info: OutlineSortingInfo,
     pub distance: f32,
     pub entity: Entity,
     pub main_entity: MainEntity,
@@ -91,120 +93,112 @@ impl SortedPhaseItem for FloodOutline {
         FloatOrd(self.distance)
     }
 
-    fn indexed(&self) -> bool {
-        self.indexed
+    fn recalculate_sort_keys(
+        items: &mut IndexMap<(Entity, MainEntity), Self, EntityHash>,
+        view: &ExtractedView,
+    ) {
+        let rangefinder = OutlineRangefinder::new(view);
+        for item in items.values_mut() {
+            item.distance = rangefinder.distance_of(&item.sorting_info);
+        }
     }
-}
 
-pub(crate) struct FloodNode;
-
-impl FromWorld for FloodNode {
-    fn from_world(_world: &mut World) -> Self {
-        Self
+    fn indexed(&self) -> bool {
+        self.indexed
     }
 }
 
-impl ViewNode for FloodNode {
-    type ViewQuery = (
-        &'static ExtractedView,
-        &'static ExtractedCamera,
-        &'static ViewTarget,
-        &'static ViewDepthTexture,
-        &'static OutlineViewUniform,
-        &'static FloodTextures,
-        &'static ComposeOutputView,
-    );
-
-    fn run<'w>(
-        &self,
-        graph: &mut RenderGraphContext,
-        render_context: &mut RenderContext<'w>,
-        (view, camera, target, depth, view_uniform, flood_textures, compose_output_view): QueryItem<
-            'w,
-            '_,
-            Self::ViewQuery,
-        >,
-        world: &'w World,
-    ) -> Result<(), NodeRunError> {
-        let view_entity = graph.view_entity();
-        let pipeline_cache = world.resource::<PipelineCache>();
-        let Some(flood_phase) = world
-            .get_resource::<ViewSortedRenderPhases<FloodOutline>>()
-            .and_then(|ps| ps.get(&view.retained_view_entity))
-        else {
-            return Ok(());
+#[allow(clippy::too_many_arguments, clippy::type_complexity)]
+pub(crate) fn flood_render_pass(
+    world: &World,
+    view: ViewQuery<(
+        &ExtractedView,
+        &ExtractedCamera,
+        &ViewTarget,
+        &ViewDepthTexture,
+        &OutlineViewUniform,
+        &FloodTextures,
+        &ComposeOutputView,
+    )>,
+    flood_phases: Res<ViewSortedRenderPhases<FloodOutline>>,
+    pipeline_cache: Res<PipelineCache>,
+    mut render_context: RenderContext,
+) {
+    let view_entity = view.entity();
+    let (view_extracted, camera, target, depth, view_uniform, flood_textures, compose_output_view) =
+        view.into_inner();
+
+    let Some(flood_phase) = flood_phases.get(&view_extracted.retained_view_entity) else {
+        return;
+    };
+
+    let mut flood_textures = flood_textures.clone();
+
+    let mut flood_init_pass = FloodInitPass::new(world, view_entity, flood_phase, camera);
+    let Some(mut jump_flood_pass) = JumpFloodPass::new(world) else {
+        return;
+    };
+    let Some(compose_output_pass) =
+        ComposeOutputPass::new(world, compose_output_view, target, depth)
+    else {
+        return;
+    };
+
+    for ((_, volume_offset, _), group) in &flood_phase
+        .items
+        .values()
+        .enumerate()
+        .chunk_by(|(_, item)| (item.distance, item.volume_offset, item.volume_colour))
+    {
+        let mut group_iter = group.into_iter();
+        let Some((first_index, first_item)) = group_iter.next() else {
+            continue;
         };
 
-        let mut flood_textures = flood_textures.clone();
+        // Sum item range and screen-space bounds
+        let mut last_index = first_index;
+        let mut screen_space_bounds = first_item.screen_space_bounds;
+        for (index, item) in group_iter {
+            last_index = index;
+            screen_space_bounds = screen_space_bounds.union(item.screen_space_bounds);
+        }
 
-        let mut flood_init_pass = FloodInitPass::new(world, view_entity, flood_phase, camera);
-        let Some(mut jump_flood_pass) = JumpFloodPass::new(world) else {
-            return Ok(());
-        };
-        let Some(compose_output_pass) =
-            ComposeOutputPass::new(world, compose_output_view, target, depth)
-        else {
-            return Ok(());
+        flood_init_pass.execute(
+            &mut render_context,
+            first_index..last_index + 1,
+            flood_textures.output(),
+        );
+        flood_textures.flip();
+
+        let scaled_offset = view_uniform.scale_physical_from_logical * volume_offset;
+        let passes = if scaled_offset > 0.0 {
+            (scaled_offset.ceil() as u32 / 2 + 1)
+                .next_power_of_two()
+                .trailing_zeros()
+                + 1
+        } else {
+            0
         };
 
-        for ((_, volume_offset, _), group) in &flood_phase
-            .items
-            .iter()
-            .enumerate()
-            .chunk_by(|(_, item)| (item.distance, item.volume_offset, item.volume_colour))
-        {
-            let mut group_iter = group.into_iter();
-            let Some((first_index, first_item)) = group_iter.next() else {
-                continue;
-            };
-
-            // Sum item range and screen-space bounds
-            let mut last_index = first_index;
-            let mut screen_space_bounds = first_item.screen_space_bounds;
-            for (index, item) in group_iter {
-                last_index = index;
-                screen_space_bounds = screen_space_bounds.union(item.screen_space_bounds);
-            }
-
-            flood_init_pass.execute(
-                render_context,
-                first_index..last_index + 1,
-                flood_textures.output(),
-            );
-            flood_textures.flip();
-
-            let scaled_offset = view_uniform.scale_physical_from_logical * volume_offset;
-            let passes = if scaled_offset > 0.0 {
-                (scaled_offset.ceil() as u32 / 2 + 1)
-                    .next_power_of_two()
-                    .trailing_zeros()
-                    + 1
-            } else {
-                0
-            };
-
-            for size in (0..passes).rev() {
-                jump_flood_pass.execute(
-                    render_context,
-                    flood_textures.input(),
-                    flood_textures.output(),
-                    pipeline_cache,
-                    size,
-                    &screen_space_bounds,
-                );
-                flood_textures.flip();
-            }
-
-            compose_output_pass.execute(
-                render_context,
-                view_entity,
-                first_item.entity,
+        for size in (0..passes).rev() {
+            jump_flood_pass.execute(
+                &mut render_context,
                 flood_textures.input(),
-                pipeline_cache,
+                flood_textures.output(),
+                &pipeline_cache,
+                size,
                 &screen_space_bounds,
             );
+            flood_textures.flip();
         }
 
-        Ok(())
+        compose_output_pass.execute(
+            &mut render_context,
+            view_entity,
+            first_item.main_entity,
+            flood_textures.input(),
+            &pipeline_cache,
+            &screen_space_bounds,
+        );
     }
 }
diff --git a/src/generate.rs b/src/generate.rs
index c9b9b08..7792405 100644
--- a/src/generate.rs
+++ b/src/generate.rs
@@ -197,7 +197,7 @@ fn auto_generate_outline_normals(
                 if squelch.contains(id) {
                     // Suppress modification events created by this system
                     squelch.remove(id);
-                } else if let Some(mesh) = meshes.get_mut(*id) {
+                } else if let Some(mut mesh) = meshes.get_mut(*id) {
                     if mesh.asset_usage.contains(RenderAssetUsages::MAIN_WORLD) {
                         let _ = mesh.generate_outline_normals(&plugin.settings);
                         squelch.insert(*id);
diff --git a/src/lib.rs b/src/lib.rs
index 20438b4..b2f59b0 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -31,9 +31,12 @@
 
 use std::any::TypeId;
 
+use bevy::anti_alias::fxaa::fxaa;
+use bevy::anti_alias::smaa::smaa;
 use bevy::asset::{load_internal_asset, AssetEventSystems};
 use bevy::camera::visibility::{RenderLayers, VisibilitySystems};
-use bevy::core_pipeline::core_3d::graph::{Core3d, Node3d};
+use bevy::core_pipeline::tonemapping::tonemapping;
+use bevy::core_pipeline::{Core3d, Core3dSystems};
 use bevy::mesh::MeshVertexAttribute;
 use bevy::pbr::{MeshInputUniform, MeshUniform};
 use bevy::prelude::*;
@@ -41,40 +44,51 @@ use bevy::render::batching::gpu_preprocessing::{self, GpuPreprocessingSupport};
 use bevy::render::batching::no_gpu_preprocessing::{
     clear_batched_cpu_instance_buffers, write_batched_instance_buffer, BatchedInstanceBuffer,
 };
+use bevy::render::camera::DirtySpecializationSystems;
 use bevy::render::extract_component::UniformComponentPlugin;
-use bevy::render::render_graph::{EmptyNode, RenderGraphExt, RenderLabel, ViewNodeRunner};
 use bevy::render::render_phase::{
     sort_phase_system, AddRenderCommand, BinnedRenderPhasePlugin, DrawFunctions, PhaseItem,
     SortedRenderPhasePlugin,
 };
 use bevy::render::render_resource::{SpecializedMeshPipelines, VertexFormat};
 use bevy::render::renderer::RenderDevice;
-use bevy::render::sync_component::SyncComponentPlugin;
-use bevy::render::{Render, RenderApp, RenderDebugFlags, RenderSystems};
-use uniforms::extract_outlines;
-use uniforms::AlphaMaskBindGroups;
-use uniforms::RenderOutlineInstances;
-
-use crate::msaa::MsaaExtraWritebackNode;
-use crate::node::{OpaqueOutline, OutlineNode, StencilOutline, TransparentOutline};
+use bevy::render::texture::FallbackImage;
+use bevy::render::{
+    init_gpu_resource, Render, RenderApp, RenderDebugFlags, RenderStartup, RenderSystems,
+};
+
+use crate::culling::{
+    check_outline_view_visibility, collect_outline_cpu_culled_entities,
+    extract_outline_visible_entities, OutlineVisibleEntities, RenderExtractedOutlineEntities,
+    RenderOutlineEntities,
+};
+use crate::msaa::msaa_extra_writeback_pass;
+use crate::node::{outline_render_pass, OpaqueOutline, StencilOutline, TransparentOutline};
 use crate::pipeline::{
-    OutlinePipeline, COMMON_SHADER_HANDLE, FRAGMENT_SHADER_HANDLE, OUTLINE_SHADER_HANDLE,
+    init_outline_pipeline, OutlinePipeline, COMMON_SHADER_HANDLE, FRAGMENT_SHADER_HANDLE,
+    OUTLINE_SHADER_HANDLE,
 };
-use crate::pipeline_key::{compute_outline_key, ComputedOutlineKey};
+use crate::pipeline_key::compute_outline_key;
 use crate::queue::{
-    check_outline_entities_changed, extract_outline_entities_changed, queue_outline_mesh,
-    specialise_outlines, OutlineCache, OutlineEntitiesChanged,
+    check_outline_entities_needing_specialisation, clear_dirty_outline_specialisations,
+    expire_outline_specialisations_for_views, extract_outline_entities_needing_specialisation,
+    extract_outline_entities_needing_specialisation_removed, queue_outline_mesh,
+    specialise_outlines, DirtyOutlineSpecialisations, OutlineCache,
+    OutlineEntitiesNeedingSpecialisation, PendingOutlineQueues,
 };
 use crate::render::DrawOutline;
-use crate::uniforms::set_outline_visibility;
+use crate::uniforms::extract_outlines;
+use crate::uniforms::RenderOutlineInstances;
 use crate::uniforms::{
-    prepare_alpha_mask_bind_groups, prepare_outline_instance_bind_group, OutlineInstanceUniform,
+    init_alpha_mask_bind_groups, prepare_alpha_mask_bind_groups,
+    prepare_outline_instance_bind_group, OutlineInstanceUniform,
 };
 use crate::view_uniforms::{
     extract_outline_view_uniforms, prepare_outline_view_bind_group, OutlineViewUniform,
 };
 
 mod computed;
+mod culling;
 mod generate;
 mod msaa;
 mod node;
@@ -91,10 +105,10 @@ pub use generate::*;
 #[cfg(feature = "flood")]
 mod flood;
 
-#[cfg(feature = "scene")]
-mod scene;
-#[cfg(feature = "scene")]
-pub use scene::*;
+#[cfg(feature = "world_serialisation")]
+mod world_serialisation;
+#[cfg(feature = "world_serialisation")]
+pub use world_serialisation::*;
 
 // See https://alexanderameye.github.io/notes/rendering-outlines/
 
@@ -102,20 +116,6 @@ pub use scene::*;
 pub const ATTRIBUTE_OUTLINE_NORMAL: MeshVertexAttribute =
     MeshVertexAttribute::new("Outline_Normal", 1585570526, VertexFormat::Float32x3);
 
-/// Labels for render graph nodes which draw outlines.
-#[derive(Copy, Clone, Debug, RenderLabel, Hash, PartialEq, Eq)]
-#[non_exhaustive]
-pub enum NodeOutline {
-    /// This node writes back unsampled post-processing effects to the sampled attachment.
-    MsaaExtraWritebackPass,
-    /// This node runs the jump flood algorithm for outlines
-    FloodPass,
-    /// This node runs after the main 3D passes and before the UI pass.
-    OutlinePass,
-    /// This node marks the end of the outline passes.
-    EndOutlinePasses,
-}
-
 /// Specifies when a stencil should be rendered.
 #[derive(Copy, Clone, Default, Debug, PartialEq, Eq)]
 #[cfg_attr(feature = "reflect", derive(Reflect))]
@@ -359,35 +359,11 @@ pub struct OutlineAlphaMask {
 #[cfg_attr(feature = "reflect", derive(Reflect))]
 #[cfg_attr(feature = "reflect", reflect(Component, Default))]
 pub struct OutlineWarmUp {
-    layers: RenderLayers,
-    disabled_stencil: bool,
-    disabled_volume: bool,
     transparency: bool,
     vertex_offsets: bool,
 }
 
 impl OutlineWarmUp {
-    /// Warms up the shaders for the given render layers.
-    pub fn with_layers(self, layers: RenderLayers) -> Self {
-        let mut s = self.clone();
-        s.layers = layers;
-        s
-    }
-
-    /// Warms up the stencil shader even if the outline stencil is disabled.
-    pub fn with_disabled_stencil(self, disabled_stencil: bool) -> Self {
-        let mut s = self.clone();
-        s.disabled_stencil = disabled_stencil;
-        s
-    }
-
-    /// Warms up the volume shader even if the outline volume is disabled.
-    pub fn with_disabled_volume(self, disabled_volume: bool) -> Self {
-        let mut s = self.clone();
-        s.disabled_volume = disabled_volume;
-        s
-    }
-
     /// Warms up both the opaque and transparent versions of the volume shader.
     pub fn with_transparency(self, transparency: bool) -> Self {
         let mut s = self.clone();
@@ -400,7 +376,7 @@ impl OutlineWarmUp {
     pub fn with_vertex_offsets(self, vertex_offset_zero: bool) -> Self {
         let mut s = self.clone();
         s.vertex_offsets = vertex_offset_zero;
-        self
+        s
     }
 }
 
@@ -446,8 +422,6 @@ impl Plugin for OutlinePlugin {
         );
 
         app.add_plugins((
-            SyncComponentPlugin::<ComputedOutline>::default(),
-            SyncComponentPlugin::<ComputedOutlineKey>::default(),
             UniformComponentPlugin::<OutlineViewUniform>::default(),
             BinnedRenderPhasePlugin::<StencilOutline, OutlinePipeline>::new(
                 RenderDebugFlags::empty(),
@@ -462,7 +436,8 @@ impl Plugin for OutlinePlugin {
         .register_required_components::<OutlineStencil, ComputedOutline>()
         .register_required_components::<OutlineVolume, ComputedOutline>()
         .register_required_components::<InheritOutline, ComputedOutline>()
-        .init_resource::<OutlineEntitiesChanged>()
+        .init_resource::<OutlineEntitiesNeedingSpecialisation>()
+        .init_resource::<OutlineVisibleEntities>()
         .add_systems(
             PostUpdate,
             (
@@ -472,8 +447,10 @@ impl Plugin for OutlinePlugin {
                 compute_outline_key
                     .after(compute_outline)
                     .after(AssetEventSystems),
-                check_outline_entities_changed.after(compute_outline_key),
-                set_outline_visibility.in_set(VisibilitySystems::CheckVisibility),
+                check_outline_entities_needing_specialisation.after(compute_outline_key),
+                check_outline_view_visibility
+                    .after(VisibilitySystems::CheckVisibility)
+                    .after(compute_outline),
             ),
         )
         .sub_app_mut(RenderApp)
@@ -487,9 +464,15 @@ impl Plugin for OutlinePlugin {
         .add_systems(
             ExtractSchedule,
             (
+                clear_dirty_outline_specialisations.in_set(DirtySpecializationSystems::Clear),
                 extract_outline_view_uniforms,
                 extract_outlines,
-                extract_outline_entities_changed,
+                extract_outline_visible_entities,
+                extract_outline_entities_needing_specialisation
+                    .in_set(DirtySpecializationSystems::CheckForChanges),
+                extract_outline_entities_needing_specialisation_removed
+                    .in_set(DirtySpecializationSystems::CheckForRemovals),
+                expire_outline_specialisations_for_views.in_set(RenderSystems::Cleanup),
             ),
         )
         .add_systems(
@@ -505,6 +488,10 @@ impl Plugin for OutlinePlugin {
             )
                 .in_set(RenderSystems::PrepareBindGroups),
         )
+        .add_systems(
+            Render,
+            collect_outline_cpu_culled_entities.in_set(RenderSystems::PrepareAssets),
+        )
         .add_systems(
             Render,
             specialise_outlines.in_set(RenderSystems::PrepareMeshes),
@@ -523,26 +510,16 @@ impl Plugin for OutlinePlugin {
                 .in_set(RenderSystems::Cleanup)
                 .after(RenderSystems::Render),
         )
-        .add_render_graph_node::<ViewNodeRunner<MsaaExtraWritebackNode>>(
-            Core3d,
-            NodeOutline::MsaaExtraWritebackPass,
-        )
-        .add_render_graph_node::<ViewNodeRunner<OutlineNode>>(Core3d, NodeOutline::OutlinePass)
-        .add_render_graph_node::<EmptyNode>(Core3d, NodeOutline::EndOutlinePasses)
-        // Outlining occurs after tone-mapping...
-        .add_render_graph_edges(
+        // Outlining occurs after tone-mapping.
+        .add_systems(
             Core3d,
-            (
-                Node3d::Tonemapping,
-                NodeOutline::MsaaExtraWritebackPass,
-                NodeOutline::OutlinePass,
-                NodeOutline::EndOutlinePasses,
-                Node3d::EndMainPassPostProcessing,
-            ),
-        )
-        // ...and before any later anti-aliasing.
-        .add_render_graph_edge(Core3d, NodeOutline::EndOutlinePasses, Node3d::Fxaa)
-        .add_render_graph_edge(Core3d, NodeOutline::EndOutlinePasses, Node3d::Smaa);
+            (msaa_extra_writeback_pass, outline_render_pass)
+                .chain()
+                .in_set(Core3dSystems::PostProcess)
+                .after(tonemapping)
+                .before(fxaa)
+                .before(smaa),
+        );
 
         #[cfg(feature = "reflect")]
         app.register_type::<OutlineStencil>()
@@ -552,8 +529,8 @@ impl Plugin for OutlinePlugin {
             .register_type::<OutlineAlphaMask>()
             .register_type::<InheritOutline>();
 
-        #[cfg(feature = "scene")]
-        app.init_resource::<AsyncSceneInheritOutlineSystems>();
+        #[cfg(feature = "world_serialisation")]
+        app.init_resource::<AsyncWorldInheritOutlineSystems>();
 
         #[cfg(feature = "flood")]
         app.add_plugins(flood::FloodPlugin);
@@ -563,18 +540,26 @@ impl Plugin for OutlinePlugin {
         let render_app = app.sub_app_mut(RenderApp);
         render_app
             .init_resource::<RenderOutlineInstances>()
+            .init_resource::<RenderExtractedOutlineEntities>()
+            .init_resource::<RenderOutlineEntities>()
+            .init_resource::<PendingOutlineQueues>()
+            .init_resource::<DirtyOutlineSpecialisations>()
             .init_resource::<OutlineCache>()
-            .init_resource::<OutlinePipeline>()
-            .init_resource::<AlphaMaskBindGroups>();
-
-        let render_device = render_app.world().resource::<RenderDevice>();
-        let instance_buffer =
-            BatchedInstanceBuffer::<OutlineInstanceUniform>::new(&render_device.limits());
-        render_app.insert_resource(instance_buffer).add_systems(
-            Render,
-            write_batched_instance_buffer::<OutlinePipeline>
-                .in_set(RenderSystems::PrepareResourcesFlush),
-        );
+            .add_systems(
+                RenderStartup,
+                (
+                    (init_outline_pipeline, init_outline_instance_buffer)
+                        .after(bevy::pbr::MeshPipelineSystems),
+                    init_alpha_mask_bind_groups
+                        .after(init_outline_pipeline)
+                        .after(init_gpu_resource::<FallbackImage>),
+                ),
+            )
+            .add_systems(
+                Render,
+                write_batched_instance_buffer::<OutlinePipeline>
+                    .in_set(RenderSystems::PrepareResourcesFlush),
+            );
 
         let gpu_preprocessing_support = render_app.world().resource::<GpuPreprocessingSupport>();
         if gpu_preprocessing_support.is_available() {
@@ -585,3 +570,9 @@ impl Plugin for OutlinePlugin {
         }
     }
 }
+
+fn init_outline_instance_buffer(mut commands: Commands, render_device: Res<RenderDevice>) {
+    commands.insert_resource(BatchedInstanceBuffer::<OutlineInstanceUniform>::new(
+        &render_device.limits(),
+    ));
+}
diff --git a/src/msaa.rs b/src/msaa.rs
index 6bb83cd..e6f4e67 100644
--- a/src/msaa.rs
+++ b/src/msaa.rs
@@ -3,17 +3,14 @@ use bevy::{
     ecs::{
         component::Component,
         entity::Entity,
-        query::QueryItem,
         system::{Commands, Query, Res, ResMut},
-        world::{FromWorld, World},
     },
     render::{
-        render_graph::{NodeRunError, RenderGraphContext, ViewNode},
         render_resource::{
             CachedRenderPipelineId, LoadOp, Operations, PipelineCache, RenderPassColorAttachment,
             RenderPassDescriptor, SpecializedRenderPipelines, StoreOp,
         },
-        renderer::RenderContext,
+        renderer::{RenderContext, ViewQuery},
         view::{Msaa, ViewTarget},
     },
 };
@@ -21,64 +18,50 @@ use bevy::{
 #[derive(Component)]
 pub(crate) struct MsaaExtraWritebackPipeline(CachedRenderPipelineId);
 
-pub(crate) struct MsaaExtraWritebackNode;
-
-impl FromWorld for MsaaExtraWritebackNode {
-    fn from_world(_world: &mut World) -> Self {
-        Self
-    }
-}
-
-impl ViewNode for MsaaExtraWritebackNode {
-    type ViewQuery = (&'static ViewTarget, &'static MsaaExtraWritebackPipeline);
-
-    fn run<'w>(
-        &self,
-        _graph: &mut RenderGraphContext,
-        render_context: &mut RenderContext<'w>,
-        (target, blit_pipeline_id): QueryItem<'w, '_, Self::ViewQuery>,
-        world: &'w World,
-    ) -> Result<(), NodeRunError> {
-        let blit_pipeline = world.resource::<BlitPipeline>();
-        let pipeline_cache = world.resource::<PipelineCache>();
-        let Some(pipeline) = pipeline_cache.get_render_pipeline(blit_pipeline_id.0) else {
-            return Ok(());
-        };
+pub(crate) fn msaa_extra_writeback_pass(
+    view: ViewQuery<(&ViewTarget, &MsaaExtraWritebackPipeline)>,
+    blit_pipeline: Res<BlitPipeline>,
+    pipeline_cache: Res<PipelineCache>,
+    mut render_context: RenderContext,
+) {
+    let (target, blit_pipeline_id) = view.into_inner();
 
-        let post_process = target.post_process_write();
+    let Some(pipeline) = pipeline_cache.get_render_pipeline(blit_pipeline_id.0) else {
+        return;
+    };
 
-        let pass_descriptor = RenderPassDescriptor {
-            label: Some("msaa_extra_writeback"),
-            color_attachments: &[Some(RenderPassColorAttachment {
-                view: target.sampled_main_texture_view().unwrap(),
-                depth_slice: None,
-                resolve_target: Some(post_process.destination),
-                ops: Operations {
-                    load: LoadOp::Clear(wgpu_types::Color::BLACK),
-                    store: StoreOp::Store,
-                },
-            })],
-            depth_stencil_attachment: None,
-            timestamp_writes: None,
-            occlusion_query_set: None,
-        };
+    let post_process = target.post_process_write();
 
-        let bind_group = blit_pipeline.create_bind_group(
-            render_context.render_device(),
-            post_process.source,
-            pipeline_cache,
-        );
+    let pass_descriptor = RenderPassDescriptor {
+        label: Some("msaa_extra_writeback"),
+        color_attachments: &[Some(RenderPassColorAttachment {
+            view: target.sampled_main_texture_view().unwrap(),
+            depth_slice: None,
+            resolve_target: Some(post_process.destination),
+            ops: Operations {
+                load: LoadOp::Clear(wgpu_types::Color::BLACK),
+                store: StoreOp::Store,
+            },
+        })],
+        depth_stencil_attachment: None,
+        timestamp_writes: None,
+        occlusion_query_set: None,
+        multiview_mask: None,
+    };
 
-        let mut render_pass = render_context
-            .command_encoder()
-            .begin_render_pass(&pass_descriptor);
+    let bind_group = blit_pipeline.create_bind_group(
+        render_context.render_device(),
+        post_process.source,
+        &pipeline_cache,
+    );
 
-        render_pass.set_pipeline(pipeline);
-        render_pass.set_bind_group(0, &bind_group, &[]);
-        render_pass.draw(0..3, 0..1);
+    let mut render_pass = render_context
+        .command_encoder()
+        .begin_render_pass(&pass_descriptor);
 
-        Ok(())
-    }
+    render_pass.set_pipeline(pipeline);
+    render_pass.set_bind_group(0, &bind_group, &[]);
+    render_pass.draw(0..3, 0..1);
 }
 
 pub(crate) fn prepare_msaa_extra_writeback_pipelines(
@@ -91,9 +74,10 @@ pub(crate) fn prepare_msaa_extra_writeback_pipelines(
     for (entity, view_target, msaa) in view_targets.iter() {
         if *msaa != Msaa::Off {
             let key = BlitPipelineKey {
-                texture_format: view_target.main_texture_format(),
+                target_format: view_target.main_texture_format(),
                 samples: msaa.samples(),
                 blend_state: None,
+                source_space: None,
             };
 
             let pipeline = pipelines.specialize(&pipeline_cache, &blit_pipeline, key);
diff --git a/src/node.rs b/src/node.rs
index 96b9dd4..4ccb40d 100644
--- a/src/node.rs
+++ b/src/node.rs
@@ -1,32 +1,58 @@
 use std::ops::Range;
 
-use bevy::ecs::query::QueryItem;
-use bevy::math::FloatOrd;
+use bevy::ecs::entity::EntityHash;
+use bevy::math::{FloatOrd, Mat3A};
 use bevy::prelude::*;
 use bevy::render::camera::ExtractedCamera;
-use bevy::render::mesh::allocator::SlabId;
-use bevy::render::render_graph::{NodeRunError, ViewNode};
+use bevy::render::mesh::allocator::MeshSlabId;
 use bevy::render::render_phase::{
     BinnedPhaseItem, CachedRenderPipelinePhaseItem, DrawFunctionId, PhaseItem,
     PhaseItemBatchSetKey, PhaseItemExtraIndex, SortedPhaseItem, ViewBinnedRenderPhases,
-    ViewSortedRenderPhases,
+    ViewRangefinder3d, ViewSortedRenderPhases,
 };
 use bevy::render::render_resource::{
     CachedRenderPipelineId, Operations, RenderPassDepthStencilAttachment, RenderPassDescriptor,
     StoreOp,
 };
+use bevy::render::renderer::{RenderContext, ViewQuery};
 use bevy::render::sync_world::MainEntity;
 use bevy::render::view::{ExtractedView, ViewDepthTexture, ViewTarget};
-use bevy::render::{render_graph::RenderGraphContext, renderer::RenderContext};
+use indexmap::IndexMap;
 
 use crate::view_uniforms::OutlineQueueStatus;
 
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct OutlineSortingInfo {
+    pub world_plane_origin: Vec3,
+    pub world_plane_offset: Vec3,
+}
+
+pub(crate) struct OutlineRangefinder {
+    rangefinder: ViewRangefinder3d,
+    world_from_view: Mat3A,
+}
+
+impl OutlineRangefinder {
+    pub(crate) fn new(view: &ExtractedView) -> Self {
+        Self {
+            rangefinder: view.rangefinder3d(),
+            world_from_view: view.world_from_view.affine().matrix3,
+        }
+    }
+
+    pub(crate) fn distance_of(&self, sorting_info: &OutlineSortingInfo) -> f32 {
+        let world_plane = sorting_info.world_plane_origin
+            + self.world_from_view.mul_vec3(-Vec3::Z) * sorting_info.world_plane_offset;
+        self.rangefinder.distance(&world_plane)
+    }
+}
+
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub(crate) struct OutlineBatchSetKey {
     pub pipeline: CachedRenderPipelineId,
     pub draw_function: DrawFunctionId,
-    pub vertex_slab: SlabId,
-    pub index_slab: Option<SlabId>,
+    pub vertex_slab: MeshSlabId,
+    pub index_slab: Option<MeshSlabId>,
 }
 
 impl PhaseItemBatchSetKey for OutlineBatchSetKey {
@@ -186,6 +212,7 @@ impl CachedRenderPipelinePhaseItem for OpaqueOutline {
 }
 
 pub(crate) struct TransparentOutline {
+    pub sorting_info: OutlineSortingInfo,
     pub distance: f32,
     pub pipeline: CachedRenderPipelineId,
     pub entity: Entity,
@@ -234,6 +261,16 @@ impl SortedPhaseItem for TransparentOutline {
         FloatOrd(self.distance)
     }
 
+    fn recalculate_sort_keys(
+        items: &mut IndexMap<(Entity, MainEntity), Self, EntityHash>,
+        view: &ExtractedView,
+    ) {
+        let rangefinder = OutlineRangefinder::new(view);
+        for item in items.values_mut() {
+            item.distance = rangefinder.distance_of(&item.sorting_info);
+        }
+    }
+
     fn indexed(&self) -> bool {
         self.indexed
     }
@@ -246,105 +283,91 @@ impl CachedRenderPipelinePhaseItem for TransparentOutline {
     }
 }
 
-pub(crate) struct OutlineNode;
-
-impl FromWorld for OutlineNode {
-    fn from_world(_world: &mut World) -> Self {
-        Self
+pub(crate) fn outline_render_pass(
+    world: &World,
+    view: ViewQuery<(
+        &ExtractedView,
+        &ExtractedCamera,
+        &Camera3d,
+        &ViewTarget,
+        &ViewDepthTexture,
+        &OutlineQueueStatus,
+    )>,
+    stencil_phases: Res<ViewBinnedRenderPhases<StencilOutline>>,
+    opaque_phases: Res<ViewBinnedRenderPhases<OpaqueOutline>>,
+    transparent_phases: Res<ViewSortedRenderPhases<TransparentOutline>>,
+    mut render_context: RenderContext,
+) {
+    let view_entity = view.entity();
+    let (view_extracted, camera, camera_3d, target, depth, queue_status) = view.into_inner();
+
+    let (Some(stencil_phase), Some(opaque_phase), Some(transparent_phase)) = (
+        stencil_phases.get(&view_extracted.retained_view_entity),
+        opaque_phases.get(&view_extracted.retained_view_entity),
+        transparent_phases.get(&view_extracted.retained_view_entity),
+    ) else {
+        return;
+    };
+
+    // If drawing anything, run stencil pass to clear the depth buffer
+    if queue_status.has_volume {
+        let pass_descriptor = RenderPassDescriptor {
+            label: Some("outline_stencil_pass"),
+            color_attachments: &[],
+            depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
+                view: depth.view(),
+                depth_ops: Some(Operations {
+                    load: camera_3d.depth_load_op.clone().into(),
+                    store: StoreOp::Store,
+                }),
+                stencil_ops: None,
+            }),
+            timestamp_writes: None,
+            occlusion_query_set: None,
+            multiview_mask: None,
+        };
+        let mut tracked_pass = render_context.begin_tracked_render_pass(pass_descriptor);
+        if let Some(viewport) = camera.viewport.as_ref() {
+            tracked_pass.set_camera_viewport(viewport);
+        }
+        if let Err(err) = stencil_phase.render(&mut tracked_pass, world, view_entity) {
+            error!("Error encountered while rendering the outline stencil phase {err:?}");
+        }
     }
-}
 
-impl ViewNode for OutlineNode {
-    type ViewQuery = (
-        &'static ExtractedView,
-        &'static ExtractedCamera,
-        &'static Camera3d,
-        &'static ViewTarget,
-        &'static ViewDepthTexture,
-        &'static OutlineQueueStatus,
-    );
-
-    fn run<'w>(
-        &self,
-        graph: &mut RenderGraphContext,
-        render_context: &mut RenderContext<'w>,
-        (view, camera, camera_3d, target, depth, queue_status): QueryItem<'w, '_, Self::ViewQuery>,
-        world: &'w World,
-    ) -> Result<(), NodeRunError> {
-        let view_entity = graph.view_entity();
-        let (Some(stencil_phase), Some(opaque_phase), Some(transparent_phase)) = (
-            world
-                .get_resource::<ViewBinnedRenderPhases<StencilOutline>>()
-                .and_then(|ps| ps.get(&view.retained_view_entity)),
-            world
-                .get_resource::<ViewBinnedRenderPhases<OpaqueOutline>>()
-                .and_then(|ps| ps.get(&view.retained_view_entity)),
-            world
-                .get_resource::<ViewSortedRenderPhases<TransparentOutline>>()
-                .and_then(|ps| ps.get(&view.retained_view_entity)),
-        ) else {
-            return Ok(());
+    if !opaque_phase.is_empty() {
+        let pass_descriptor = RenderPassDescriptor {
+            label: Some("outline_opaque_pass"),
+            color_attachments: &[Some(target.get_color_attachment())],
+            depth_stencil_attachment: Some(depth.get_attachment(StoreOp::Store)),
+            timestamp_writes: None,
+            occlusion_query_set: None,
+            multiview_mask: None,
         };
-
-        // If drawing anything, run stencil pass to clear the depth buffer
-        if queue_status.has_volume {
-            let pass_descriptor = RenderPassDescriptor {
-                label: Some("outline_stencil_pass"),
-                color_attachments: &[],
-                depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
-                    view: depth.view(),
-                    depth_ops: Some(Operations {
-                        load: camera_3d.depth_load_op.clone().into(),
-                        store: StoreOp::Store,
-                    }),
-                    stencil_ops: None,
-                }),
-                timestamp_writes: None,
-                occlusion_query_set: None,
-            };
-            let mut tracked_pass = render_context.begin_tracked_render_pass(pass_descriptor);
-            if let Some(viewport) = camera.viewport.as_ref() {
-                tracked_pass.set_camera_viewport(viewport);
-            }
-            if let Err(err) = stencil_phase.render(&mut tracked_pass, world, view_entity) {
-                error!("Error encountered while rendering the outline stencil phase {err:?}");
-            }
+        let mut tracked_pass = render_context.begin_tracked_render_pass(pass_descriptor);
+        if let Some(viewport) = camera.viewport.as_ref() {
+            tracked_pass.set_camera_viewport(viewport);
         }
-
-        if !opaque_phase.is_empty() {
-            let pass_descriptor = RenderPassDescriptor {
-                label: Some("outline_opaque_pass"),
-                color_attachments: &[Some(target.get_color_attachment())],
-                depth_stencil_attachment: Some(depth.get_attachment(StoreOp::Store)),
-                timestamp_writes: None,
-                occlusion_query_set: None,
-            };
-            let mut tracked_pass = render_context.begin_tracked_render_pass(pass_descriptor);
-            if let Some(viewport) = camera.viewport.as_ref() {
-                tracked_pass.set_camera_viewport(viewport);
-            }
-            if let Err(err) = opaque_phase.render(&mut tracked_pass, world, view_entity) {
-                error!("Error encountered while rendering the outline opaque phase {err:?}");
-            }
+        if let Err(err) = opaque_phase.render(&mut tracked_pass, world, view_entity) {
+            error!("Error encountered while rendering the outline opaque phase {err:?}");
         }
+    }
 
-        if !transparent_phase.items.is_empty() {
-            let pass_descriptor = RenderPassDescriptor {
-                label: Some("outline_transparent_pass"),
-                color_attachments: &[Some(target.get_color_attachment())],
-                depth_stencil_attachment: Some(depth.get_attachment(StoreOp::Store)),
-                timestamp_writes: None,
-                occlusion_query_set: None,
-            };
-            let mut tracked_pass = render_context.begin_tracked_render_pass(pass_descriptor);
-            if let Some(viewport) = camera.viewport.as_ref() {
-                tracked_pass.set_camera_viewport(viewport);
-            }
-            if let Err(err) = transparent_phase.render(&mut tracked_pass, world, view_entity) {
-                error!("Error encountered while rendering the outline opaque phase {err:?}");
-            }
+    if !transparent_phase.items.is_empty() {
+        let pass_descriptor = RenderPassDescriptor {
+            label: Some("outline_transparent_pass"),
+            color_attachments: &[Some(target.get_color_attachment())],
+            depth_stencil_attachment: Some(depth.get_attachment(StoreOp::Store)),
+            timestamp_writes: None,
+            occlusion_query_set: None,
+            multiview_mask: None,
+        };
+        let mut tracked_pass = render_context.begin_tracked_render_pass(pass_descriptor);
+        if let Some(viewport) = camera.viewport.as_ref() {
+            tracked_pass.set_camera_viewport(viewport);
+        }
+        if let Err(err) = transparent_phase.render(&mut tracked_pass, world, view_entity) {
+            error!("Error encountered while rendering the outline transparent phase {err:?}");
         }
-
-        Ok(())
     }
 }
diff --git a/src/outline.wgsl b/src/outline.wgsl
index bc633c9..8ca3d9f 100644
--- a/src/outline.wgsl
+++ b/src/outline.wgsl
@@ -1,6 +1,6 @@
 #import bevy_render::view::View
 #import bevy_render::maths
-#import bevy_pbr::mesh_types::SkinnedMesh
+#import bevy_pbr::mesh_types::{SkinnedMesh, MorphAttributes, MorphDescriptor, MorphWeights}
 #import bevy_pbr::skinning::joint_matrices
 #import bevy_mod_outline::common::{OutlineViewUniform, VertexOutput}
 
@@ -14,6 +14,7 @@ struct Instance {
     alpha_mask_threshold: f32,
     first_vertex_index: u32,
     current_skin_index: u32,
+    current_morph_index: u32,
 };
 
 struct Vertex {
@@ -38,7 +39,6 @@ struct Vertex {
 var<uniform> view_uniform: OutlineViewUniform;
 
 #import bevy_pbr::skinning
-#import bevy_pbr::morph
 
 #ifdef INSTANCE_BATCH_SIZE
 @group(1) @binding(0) var<uniform> mesh: array<Instance, #{INSTANCE_BATCH_SIZE}u>;
@@ -47,18 +47,85 @@ var<uniform> view_uniform: OutlineViewUniform;
 #endif
 
 #ifdef MORPH_TARGETS
-fn morph_vertex(vertex_in: Vertex) -> Vertex {
+#ifdef SKINS_USE_UNIFORM_BUFFERS
+@group(2) @binding(2) var<uniform> morph_weights: MorphWeights;
+@group(2) @binding(3) var morph_targets: texture_3d<f32>;
+#else
+@group(2) @binding(2) var<storage> morph_weights: array<f32>;
+@group(2) @binding(3) var<storage> morph_targets: array<MorphAttributes>;
+@group(2) @binding(8) var<storage> morph_descriptors: array<MorphDescriptor>;
+#endif
+
+fn morph_layer_count(descriptor_index: u32) -> u32 {
+#ifdef SKINS_USE_UNIFORM_BUFFERS
+    let dimensions = textureDimensions(morph_targets);
+    return u32(dimensions.z);
+#else
+    return morph_descriptors[descriptor_index].weight_count;
+#endif
+}
+
+fn morph_weight_at(weight_index: u32, descriptor_index: u32) -> f32 {
+#ifdef SKINS_USE_UNIFORM_BUFFERS
+    let i = weight_index;
+    return morph_weights.weights[i / 4u][i % 4u];
+#else
+    let weights_offset = morph_descriptors[descriptor_index].current_weights_offset;
+    return morph_weights[weights_offset + weight_index];
+#endif
+}
+
+#ifdef SKINS_USE_UNIFORM_BUFFERS
+const morph_position_offset: u32 = 0u;
+const morph_total_component_count: u32 = 9u;
+
+fn morph_component_texture_coord(vertex_index: u32, component_offset: u32) -> vec2<u32> {
+    let width = u32(textureDimensions(morph_targets).x);
+    let component_index = morph_total_component_count * vertex_index + component_offset;
+    return vec2<u32>(component_index % width, component_index / width);
+}
+
+fn morph_pixel(vertex: u32, component: u32, weight: u32) -> f32 {
+    let coord = morph_component_texture_coord(vertex, component);
+    return textureLoad(morph_targets, vec3(coord, weight), 0).r;
+}
+
+fn morph(vertex_index: u32, component_offset: u32, weight_index: u32) -> vec3<f32> {
+    return vec3<f32>(
+        morph_pixel(vertex_index, component_offset, weight_index),
+        morph_pixel(vertex_index, component_offset + 1u, weight_index),
+        morph_pixel(vertex_index, component_offset + 2u, weight_index),
+    );
+}
+
+fn morph_position(vertex_index: u32, weight_index: u32, instance_index: u32) -> vec3<f32> {
+    return morph(vertex_index, morph_position_offset, weight_index);
+}
+#else
+fn get_morph_target(vertex_index: u32, weight_index: u32, descriptor_index: u32) -> MorphAttributes {
+    let targets_offset = morph_descriptors[descriptor_index].targets_offset;
+    let vertex_count = morph_descriptors[descriptor_index].vertex_count;
+    return morph_targets[targets_offset + weight_index * vertex_count + vertex_index];
+}
+
+fn morph_position(vertex_index: u32, weight_index: u32, descriptor_index: u32) -> vec3<f32> {
+    return get_morph_target(vertex_index, weight_index, descriptor_index).position;
+}
+#endif
+
+fn morph_vertex(vertex_in: Vertex, instance_index: u32) -> Vertex {
     var vertex = vertex_in;
-    let first_vertex = mesh[vertex.instance_index].first_vertex_index;
+    let first_vertex = mesh[instance_index].first_vertex_index;
+    var morph_index = mesh[instance_index].current_morph_index;
     let vertex_index = vertex.index - first_vertex;
 
-    let weight_count = bevy_pbr::morph::layer_count();
+    let weight_count = morph_layer_count(morph_index);
     for (var i: u32 = 0u; i < weight_count; i ++) {
-        let weight = bevy_pbr::morph::weight_at(i);
+        let weight = morph_weight_at(i, morph_index);
         if weight == 0.0 {
             continue;
         }
-        vertex.position += weight * bevy_pbr::morph::morph(vertex_index, bevy_pbr::morph::position_offset, i);
+        vertex.position += weight * morph_position(vertex_index, i, morph_index);
     }
     return vertex;
 }
@@ -103,7 +170,7 @@ fn model_origin_z(plane: vec3<f32>, view_proj: mat4x4<f32>) -> f32 {
 fn vertex(vertex_no_morph: Vertex) -> VertexOutput {
     let iid = vertex_no_morph.instance_index;
 #ifdef MORPH_TARGETS
-    var vertex = morph_vertex(vertex_no_morph);
+    var vertex = morph_vertex(vertex_no_morph, iid);
 #else
     var vertex = vertex_no_morph;
 #endif
diff --git a/src/pipeline.rs b/src/pipeline.rs
index f64f9eb..9ff3a04 100644
--- a/src/pipeline.rs
+++ b/src/pipeline.rs
@@ -4,22 +4,22 @@ use bevy::asset::uuid_handle;
 use bevy::ecs::system::lifetimeless::SRes;
 use bevy::ecs::system::SystemParamItem;
 use bevy::mesh::MeshVertexBufferLayoutRef;
-use bevy::pbr::{setup_morph_and_skinning_defs, skins_use_uniform_buffers, SkinUniforms};
+use bevy::pbr::{
+    setup_morph_and_skinning_defs, skins_use_uniform_buffers, MorphIndices, SkinUniforms,
+};
 use bevy::prelude::*;
 use bevy::render::batching::{gpu_preprocessing, GetBatchData, GetFullBatchData};
-use bevy::render::mesh::allocator::MeshAllocator;
+use bevy::render::mesh::allocator::{MeshAllocator, MeshSlabs};
 use bevy::render::render_resource::binding_types::{sampler, texture_2d, uniform_buffer_sized};
 use bevy::render::render_resource::{
     BindGroupLayoutDescriptor, BindGroupLayoutEntries, BlendState, ColorTargetState, ColorWrites,
     CompareFunction, DepthBiasState, DepthStencilState, Face, FragmentState, FrontFace,
-    GpuArrayBuffer, MultisampleState, PolygonMode, PrimitiveState, PushConstantRange,
-    SamplerBindingType, ShaderStages, ShaderType, StencilState, TextureFormat, TextureSampleType,
-    VertexState,
+    GpuArrayBuffer, MultisampleState, PolygonMode, PrimitiveState, SamplerBindingType,
+    ShaderStages, ShaderType, StencilState, TextureFormat, TextureSampleType, VertexState,
 };
 use bevy::render::renderer::RenderDevice;
 use bevy::render::settings::{Backends, WgpuSettings};
 use bevy::render::sync_world::MainEntity;
-use bevy::render::view::ViewTarget;
 use bevy::shader::ShaderDefVal;
 use bevy::{
     pbr::MeshPipeline,
@@ -53,47 +53,47 @@ pub(crate) struct OutlinePipeline {
     pub skins_use_uniform_buffers: bool,
 }
 
-impl FromWorld for OutlinePipeline {
-    fn from_world(world: &mut World) -> Self {
-        let mesh_pipeline = world.get_resource::<MeshPipeline>().unwrap().clone();
-        let render_device = world.get_resource::<RenderDevice>().unwrap();
-        let limits = render_device.limits();
-        let outline_view_bind_group_layout = BindGroupLayoutDescriptor::new(
-            "outline_view_bind_group_layout",
-            &BindGroupLayoutEntries::single(
-                ShaderStages::VERTEX,
-                uniform_buffer_sized(true, Some(OutlineViewUniform::min_size())),
-            ),
-        );
-        let outline_instance_bind_group_layout = BindGroupLayoutDescriptor::new(
-            "outline_instance_bind_group_layout",
-            &BindGroupLayoutEntries::single(
-                ShaderStages::VERTEX,
-                GpuArrayBuffer::<OutlineInstanceUniform>::binding_layout(&limits),
-            ),
-        );
-        let alpha_mask_bind_group_layout = BindGroupLayoutDescriptor::new(
-            "alpha_mask_bind_group_layout",
-            &BindGroupLayoutEntries::sequential(
-                ShaderStages::FRAGMENT,
-                (
-                    texture_2d(TextureSampleType::Float { filterable: true }),
-                    sampler(SamplerBindingType::Filtering),
-                ),
+pub(crate) fn init_outline_pipeline(
+    mut commands: Commands,
+    mesh_pipeline: Res<MeshPipeline>,
+    render_device: Res<RenderDevice>,
+) {
+    let limits = render_device.limits();
+    let outline_view_bind_group_layout = BindGroupLayoutDescriptor::new(
+        "outline_view_bind_group_layout",
+        &BindGroupLayoutEntries::single(
+            ShaderStages::VERTEX,
+            uniform_buffer_sized(true, Some(OutlineViewUniform::min_size())),
+        ),
+    );
+    let outline_instance_bind_group_layout = BindGroupLayoutDescriptor::new(
+        "outline_instance_bind_group_layout",
+        &BindGroupLayoutEntries::single(
+            ShaderStages::VERTEX,
+            GpuArrayBuffer::<OutlineInstanceUniform>::binding_layout(&limits),
+        ),
+    );
+    let alpha_mask_bind_group_layout = BindGroupLayoutDescriptor::new(
+        "alpha_mask_bind_group_layout",
+        &BindGroupLayoutEntries::sequential(
+            ShaderStages::FRAGMENT,
+            (
+                texture_2d(TextureSampleType::Float { filterable: true }),
+                sampler(SamplerBindingType::Filtering),
             ),
-        );
+        ),
+    );
 
-        let instance_batch_size = GpuArrayBuffer::<OutlineInstanceUniform>::batch_size(&limits);
-        let skins_use_uniform_buffers = skins_use_uniform_buffers(&limits);
-        OutlinePipeline {
-            mesh_pipeline,
-            outline_view_bind_group_layout,
-            outline_instance_bind_group_layout,
-            alpha_mask_bind_group_layout,
-            instance_batch_size,
-            skins_use_uniform_buffers,
-        }
-    }
+    let instance_batch_size = GpuArrayBuffer::<OutlineInstanceUniform>::batch_size(&limits);
+    let skins_use_uniform_buffers = skins_use_uniform_buffers(&limits);
+    commands.insert_resource(OutlinePipeline {
+        mesh_pipeline: mesh_pipeline.clone(),
+        outline_view_bind_group_layout,
+        outline_instance_bind_group_layout,
+        alpha_mask_bind_group_layout,
+        instance_batch_size,
+        skins_use_uniform_buffers,
+    });
 }
 
 impl SpecializedMeshPipeline for OutlinePipeline {
@@ -182,11 +182,7 @@ impl SpecializedMeshPipeline for OutlinePipeline {
                 vertex_defs.push(val.clone());
                 fragment_defs.push(val);
                 targets.push(Some(ColorTargetState {
-                    format: if key.hdr_format() {
-                        ViewTarget::TEXTURE_FORMAT_HDR
-                    } else {
-                        TextureFormat::bevy_default()
-                    },
+                    format: key.target_format(),
                     blend: Some(if key.transparent() {
                         BlendState::ALPHA_BLENDING
                     } else {
@@ -210,8 +206,8 @@ impl SpecializedMeshPipeline for OutlinePipeline {
         let depth_stencil = match key.pass_type() {
             PassType::Stencil | PassType::Volume => Some(DepthStencilState {
                 format: TextureFormat::Depth32Float,
-                depth_write_enabled: true,
-                depth_compare: CompareFunction::Greater,
+                depth_write_enabled: Some(true),
+                depth_compare: Some(CompareFunction::Greater),
                 stencil: StencilState::default(),
                 bias: DepthBiasState::default(),
             }),
@@ -219,14 +215,12 @@ impl SpecializedMeshPipeline for OutlinePipeline {
             PassType::FloodInit => None,
         };
         let buffers = vec![layout.0.get_layout(&buffer_attrs)?];
-        let mut push_constant_ranges = Vec::with_capacity(1);
         // Proxy for webgl feature flag in bevy
-        if WgpuSettings::default().backends == Some(Backends::GL) {
-            push_constant_ranges.push(PushConstantRange {
-                stages: ShaderStages::VERTEX,
-                range: 0..4,
-            });
-        }
+        let immediate_size = if WgpuSettings::default().backends == Some(Backends::GL) {
+            4
+        } else {
+            0
+        };
         Ok(RenderPipelineDescriptor {
             vertex: VertexState {
                 shader: OUTLINE_SHADER_HANDLE,
@@ -256,37 +250,57 @@ impl SpecializedMeshPipeline for OutlinePipeline {
                 mask: !0,
                 alpha_to_coverage_enabled: false,
             },
-            push_constant_ranges,
+            immediate_size,
             label: Some(Cow::Borrowed("outline_pipeline")),
             zero_initialize_workgroup_memory: false,
         })
     }
 }
 
+#[derive(Clone, Copy, PartialEq)]
+pub(crate) struct OutlineBatchSetCompareData {
+    mesh_slabs: Option<MeshSlabs>,
+    alpha_mask_id: Option<AssetId<Image>>,
+}
+
 impl GetBatchData for OutlinePipeline {
     type Param = (
         SRes<RenderOutlineInstances>,
         SRes<MeshAllocator>,
         SRes<SkinUniforms>,
+        SRes<MorphIndices>,
     );
-    type CompareData = (AssetId<Mesh>, Option<AssetId<Image>>);
+    type BatchSetCompareData = OutlineBatchSetCompareData;
+    type BatchCompareData = AssetId<Mesh>;
     type BufferData = OutlineInstanceUniform;
 
     fn get_batch_data(
-        (render_outlines, mesh_allocator, skin_uniforms): &SystemParamItem<Self::Param>,
+        (render_outlines, mesh_allocator, skin_uniforms, morph_indices): &SystemParamItem<
+            Self::Param,
+        >,
         (_entity, main_entity): (Entity, MainEntity),
-    ) -> Option<(Self::BufferData, Option<Self::CompareData>)> {
+    ) -> Option<(
+        Self::BufferData,
+        Option<(Self::BatchSetCompareData, Self::BatchCompareData)>,
+    )> {
         let outline = render_outlines.get(&main_entity)?;
         let instance_data = outline.instance_data.prepare_instance(
             &outline.mesh_id,
             main_entity,
             mesh_allocator,
             skin_uniforms,
+            morph_indices,
         );
 
         // Only batch entities with the same mesh and alpha mask texture
         let batch_data = if outline.automatic_batching {
-            Some((outline.mesh_id, outline.alpha_mask_id))
+            Some((
+                OutlineBatchSetCompareData {
+                    mesh_slabs: mesh_allocator.mesh_slabs(&outline.mesh_id),
+                    alpha_mask_id: outline.alpha_mask_id,
+                },
+                outline.mesh_id,
+            ))
         } else {
             None
         };
@@ -299,7 +313,9 @@ impl GetFullBatchData for OutlinePipeline {
     type BufferInputData = ();
 
     fn get_binned_batch_data(
-        (render_outlines, mesh_allocator, skin_uniforms): &SystemParamItem<Self::Param>,
+        (render_outlines, mesh_allocator, skin_uniforms, morph_indices): &SystemParamItem<
+            Self::Param,
+        >,
         main_entity: MainEntity,
     ) -> Option<Self::BufferData> {
         let outline = render_outlines.get(&main_entity)?;
@@ -308,13 +324,17 @@ impl GetFullBatchData for OutlinePipeline {
             main_entity,
             mesh_allocator,
             skin_uniforms,
+            morph_indices,
         ))
     }
 
     fn get_index_and_compare_data(
         _param: &SystemParamItem<Self::Param>,
         _main_entity: MainEntity,
-    ) -> Option<(NonMaxU32, Option<Self::CompareData>)> {
+    ) -> Option<(
+        NonMaxU32,
+        Option<(Self::BatchSetCompareData, Self::BatchCompareData)>,
+    )> {
         unimplemented!("GPU batching is not used.");
     }
 
diff --git a/src/pipeline_key.rs b/src/pipeline_key.rs
index fef5f20..29893ef 100644
--- a/src/pipeline_key.rs
+++ b/src/pipeline_key.rs
@@ -1,8 +1,13 @@
 use std::ops::BitOr;
 
 use bevy::{
-    math::Vec3, pbr::MeshPipelineKey, prelude::*, render::render_resource::PrimitiveTopology,
-    render::view::Msaa,
+    math::Vec3,
+    pbr::MeshPipelineKey,
+    prelude::*,
+    render::{
+        render_resource::{PrimitiveTopology, TextureFormat},
+        view::{texture_format_from_code, texture_format_to_code, Msaa},
+    },
 };
 use bitfield::{bitfield_bitrange, bitfield_fields};
 
@@ -23,10 +28,10 @@ bitfield_bitrange! {struct RawPipelineKey(u32)}
 impl RawPipelineKey {
     bitfield_fields! {
         u32;
-        // View parameters (0-7)
+        // View parameters (0:7)
         msaa_samples_minus_one, set_msaa_samples_minus_one: 2, 0;
-        pub hdr_format, set_hdr_format: 3;
-        pub motion_vector_prepass, set_motion_vector_prepass: 4;
+        pub motion_vector_prepass, set_motion_vector_prepass: 3;
+        target_format_code, set_target_format_code: 7, 4;
         // Mesh parameters (8:15)
         primitive_topology_int, set_primitive_topology_int: 10, 8;
         pub morph_targets, set_morph_targets: 11;
@@ -62,6 +67,10 @@ impl RawPipelineKey {
         }
     }
 
+    pub(crate) fn target_format(&self) -> TextureFormat {
+        texture_format_from_code(self.target_format_code() as u8).unwrap()
+    }
+
     pub(crate) fn primitive_topology(&self) -> PrimitiveTopology {
         match self.primitive_topology_int() {
             x if x == PrimitiveTopology::PointList as u32 => PrimitiveTopology::PointList,
@@ -113,8 +122,9 @@ impl ViewPipelineKey {
         self
     }
 
-    pub(crate) fn with_hdr_format(mut self, hdr_format: bool) -> Self {
-        self.0.set_hdr_format(hdr_format);
+    pub(crate) fn with_target_format(mut self, format: TextureFormat) -> Self {
+        self.0
+            .set_target_format_code(texture_format_to_code(format).unwrap() as u32);
         self
     }
 
@@ -205,10 +215,7 @@ impl DerivedPipelineKey {
         DerivedPipelineKey(
             match pass_type {
                 PassType::Stencil => {
-                    view_key
-                        .with_hdr_format(false)
-                        .with_motion_vector_prepass(false)
-                        .0
+                    view_key.with_motion_vector_prepass(false).0
                         | entity_key
                             .with_transparent(false)
                             .with_vertex_offset_zero(entity_key.stencil_vertex_offset_zero())
diff --git a/src/queue.rs b/src/queue.rs
index ee59eea..805d4c1 100644
--- a/src/queue.rs
+++ b/src/queue.rs
@@ -1,169 +1,175 @@
-use bevy::camera::visibility::RenderLayers;
 use bevy::core_pipeline::prepass::MotionVectorPrepass;
-use bevy::ecs::change_detection::Tick;
-use bevy::ecs::system::SystemChangeTick;
-use bevy::math::Mat3A;
-use bevy::pbr::ViewSpecializationTicks;
 use bevy::platform::collections::{HashMap, HashSet};
 use bevy::prelude::*;
+use bevy::render::camera::{DirtySpecializations, PendingQueues};
 use bevy::render::mesh::allocator::MeshAllocator;
 use bevy::render::mesh::RenderMesh;
 use bevy::render::render_asset::RenderAssets;
 use bevy::render::render_phase::{
     BinnedRenderPhaseType, DrawFunctions, InputUniformIndex, PhaseItemExtraIndex,
-    ViewBinnedRenderPhases, ViewRangefinder3d, ViewSortedRenderPhases,
+    ViewBinnedRenderPhases, ViewSortedRenderPhases,
 };
 use bevy::render::render_resource::{
     CachedRenderPipelineId, PipelineCache, SpecializedMeshPipelines,
 };
-use bevy::render::sync_world::{MainEntity, MainEntityHashMap};
+use bevy::render::sync_world::MainEntityHashMap;
 use bevy::render::view::{ExtractedView, RetainedViewEntity};
 use bevy::render::Extract;
 
 use crate::node::{
-    OpaqueOutline, OutlineBatchSetKey, OutlineBinKey, StencilOutline, TransparentOutline,
+    OpaqueOutline, OutlineBatchSetKey, OutlineBinKey, OutlineSortingInfo, StencilOutline,
+    TransparentOutline,
 };
 use crate::pipeline_key::ComputedOutlineKey;
 use crate::pipeline_key::{DerivedPipelineKey, EntityPipelineKey, PassType, ViewPipelineKey};
-use crate::ComputedOutline;
+use crate::uniforms::RenderOutlineInstances;
 use crate::{
-    pipeline::OutlinePipeline,
-    render::DrawOutline,
-    uniforms::{DrawMode, ExtractedOutline},
+    pipeline::OutlinePipeline, render::DrawOutline, uniforms::DrawMode,
     view_uniforms::OutlineQueueStatus,
 };
+use crate::{ComputedOutline, RenderOutlineEntities};
 
-#[derive(Resource, Default)]
-pub struct OutlineEntitiesChanged {
-    entities: Vec<MainEntity>,
+#[derive(Clone, Resource, Debug, Default)]
+pub(crate) struct OutlineEntitiesNeedingSpecialisation {
+    changed: Vec<Entity>,
+    removed: Vec<Entity>,
 }
 
 #[derive(Resource, Default)]
-pub struct OutlineCache {
+pub(crate) struct OutlineCache {
     pub(crate) view_map: HashMap<RetainedViewEntity, OutlineViewCache>,
 }
 
 #[derive(Default)]
-pub struct OutlineViewCache {
-    pub(crate) changed_tick: Tick,
+pub(crate) struct OutlineViewCache {
     pub(crate) entity_map: MainEntityHashMap<OutlineCacheEntry>,
 }
 
 #[derive(Debug, Clone, Copy)]
-pub struct OutlineCacheEntry {
-    pub(crate) changed_tick: Tick,
+pub(crate) struct OutlineCacheEntry {
     pub(crate) stencil_pipeline_id: CachedRenderPipelineId,
     pub(crate) volume_pipeline_id: CachedRenderPipelineId,
 }
 
-pub(crate) struct OutlineRangefinder {
-    rangefinder: ViewRangefinder3d,
-    world_from_view: Mat3A,
-}
+#[derive(Default, Deref, DerefMut, Resource)]
+pub(crate) struct PendingOutlineQueues(pub PendingQueues);
 
-impl OutlineRangefinder {
-    pub(crate) fn new(view: &ExtractedView) -> Self {
-        Self {
-            rangefinder: view.rangefinder3d(),
-            world_from_view: view.world_from_view.affine().matrix3,
-        }
-    }
+#[derive(Clone, Resource, Default, Deref, DerefMut)]
+pub(crate) struct DirtyOutlineSpecialisations(pub DirtySpecializations);
 
-    pub(crate) fn distance_of(&self, outline: &ExtractedOutline) -> f32 {
-        let world_plane = outline.instance_data.world_plane_origin
-            + self.world_from_view.mul_vec3(-Vec3::Z) * outline.instance_data.world_plane_offset;
-        self.rangefinder.distance(&world_plane)
-    }
+pub(crate) fn clear_dirty_outline_specialisations(
+    mut specialisations: ResMut<DirtyOutlineSpecialisations>,
+) {
+    specialisations.changed_renderables.clear();
+    specialisations.removed_renderables.clear();
+    specialisations.views.clear();
+}
+
+pub(crate) fn expire_outline_specialisations_for_views(
+    views: Query<&ExtractedView>,
+    mut specialisations: ResMut<DirtyOutlineSpecialisations>,
+) {
+    let all_live_retained_view_entities: HashSet<_> =
+        views.iter().map(|view| view.retained_view_entity).collect();
+    specialisations.views.retain(|retained_view_entity| {
+        all_live_retained_view_entities.contains(retained_view_entity)
+    });
 }
 
 #[allow(clippy::type_complexity)]
-pub(crate) fn check_outline_entities_changed(
+pub(crate) fn check_outline_entities_needing_specialisation(
     changed_entities: Query<Entity, Or<(Changed<ComputedOutline>, Changed<ComputedOutlineKey>)>>,
-    mut entities_changed: ResMut<OutlineEntitiesChanged>,
+    mut removed_components: RemovedComponents<ComputedOutline>,
+    mut needing_specialisation: ResMut<OutlineEntitiesNeedingSpecialisation>,
 ) {
-    entities_changed.entities.clear();
+    needing_specialisation.changed.clear();
+    needing_specialisation.removed.clear();
     for entity in changed_entities.iter() {
-        entities_changed.entities.push(entity.into());
+        needing_specialisation.changed.push(entity);
+    }
+    for entity in removed_components.read() {
+        needing_specialisation.removed.push(entity);
     }
 }
 
-pub(crate) fn extract_outline_entities_changed(
-    entities_changed: Extract<Res<OutlineEntitiesChanged>>,
-    mut entities_removed: Extract<RemovedComponents<ComputedOutline>>,
-    mut outline_cache: ResMut<OutlineCache>,
+pub(crate) fn extract_outline_entities_needing_specialisation(
+    needing_specialisation: Extract<Res<OutlineEntitiesNeedingSpecialisation>>,
+    mut specialisations: ResMut<DirtyOutlineSpecialisations>,
 ) {
-    for outline_view_cache in outline_cache.view_map.values_mut() {
-        for entity in entities_changed.entities.iter() {
-            outline_view_cache.entity_map.remove(entity);
-        }
-        for entity in entities_removed.read() {
-            outline_view_cache
-                .entity_map
-                .remove(&MainEntity::from(entity));
-        }
+    for &entity in needing_specialisation.changed.iter() {
+        specialisations.changed_renderables.insert(entity.into());
+    }
+}
+
+pub(crate) fn extract_outline_entities_needing_specialisation_removed(
+    needing_specialisation: Extract<Res<OutlineEntitiesNeedingSpecialisation>>,
+    mut specialisations: ResMut<DirtyOutlineSpecialisations>,
+) {
+    for &entity in needing_specialisation.removed.iter() {
+        specialisations.removed_renderables.insert(entity.into());
     }
 }
 
 #[allow(clippy::too_many_arguments, clippy::type_complexity)]
 pub(crate) fn specialise_outlines(
     render_meshes: Res<RenderAssets<RenderMesh>>,
-    view_specialisation_ticks: Res<ViewSpecializationTicks>,
+    render_outlines: Res<RenderOutlineInstances>,
+    render_visible: Res<RenderOutlineEntities>,
+    mut pending_queues: ResMut<PendingOutlineQueues>,
+    specialisations: Res<DirtyOutlineSpecialisations>,
     mut outline_cache: ResMut<OutlineCache>,
     mut pipelines: ResMut<SpecializedMeshPipelines<OutlinePipeline>>,
     mut all_views: Local<HashSet<RetainedViewEntity>>,
     mut warm_up_keys: Local<Vec<EntityPipelineKey>>,
     outline_pipeline: Res<OutlinePipeline>,
     pipeline_cache: Res<PipelineCache>,
-    ticks: SystemChangeTick,
-    views: Query<(
-        &ExtractedView,
-        Has<MotionVectorPrepass>,
-        &Msaa,
-        Option<&RenderLayers>,
-    )>,
-    outlines: Query<(&MainEntity, &ExtractedOutline)>,
+    views: Query<(&ExtractedView, Has<MotionVectorPrepass>, &Msaa)>,
 ) {
     all_views.clear();
 
-    for (view, motion_vector_prepass, msaa, view_mask) in &views {
+    for (view, motion_vector_prepass, msaa) in &views {
         all_views.insert(view.retained_view_entity);
 
         let view_key = ViewPipelineKey::new()
             .with_msaa(*msaa)
-            .with_hdr_format(view.hdr)
+            .with_target_format(view.target_format)
             .with_motion_vector_prepass(motion_vector_prepass);
 
-        let view_tick = view_specialisation_ticks
-            .get(&view.retained_view_entity)
-            .unwrap();
         let outline_view_cache = outline_cache
             .view_map
             .entry(view.retained_view_entity)
             .or_default();
-        if view_tick.is_newer_than(outline_view_cache.changed_tick, ticks.this_run()) {
-            outline_view_cache.changed_tick = *view_tick;
+
+        if specialisations.must_wipe_specializations_for_view(view.retained_view_entity) {
             outline_view_cache.entity_map.clear();
+        } else {
+            for entity in specialisations.iter_to_despecialize() {
+                outline_view_cache.entity_map.remove(entity);
+            }
         }
-        let view_layers = view_mask.unwrap_or_default();
 
-        for (main_entity, outline) in outlines.iter() {
+        let Some(render_view_visible) = render_visible.views.get(&view.retained_view_entity) else {
+            continue;
+        };
+        let view_pending_queues = pending_queues.prepare_for_new_frame(view.retained_view_entity);
+
+        for (render_entity, main_entity) in specialisations.iter_to_specialize(
+            view.retained_view_entity,
+            &render_view_visible.0,
+            &view_pending_queues.prev_frame,
+        ) {
+            let Some(outline) = render_outlines.get(main_entity) else {
+                continue;
+            };
+
             if outline_view_cache.entity_map.contains_key(main_entity) {
                 continue; // Already in entity cache
             };
 
-            let enable_stencil = outline.stencil || outline.warm_up.disabled_stencil;
-            let enable_volume = outline.volume || outline.warm_up.disabled_volume;
-            if !enable_stencil && !enable_volume {
-                continue; // Neither stencil nor volume enabled
-            }
-
-            if !outline.layers.intersects(view_layers)
-                && !outline.warm_up.layers.intersects(view_layers)
-            {
-                continue; // Layer not enabled
-            }
-
             let Some(mesh) = render_meshes.get(outline.mesh_id) else {
+                view_pending_queues
+                    .current_frame
+                    .insert((*render_entity, *main_entity));
                 continue; // Mesh not found
             };
 
@@ -192,7 +198,7 @@ pub(crate) fn specialise_outlines(
             let mut first_key = true;
             for warm_up_key in warm_up_keys.iter() {
                 // Specialise stencil pipeline
-                let stencil_pipeline_id = if enable_stencil {
+                let stencil_pipeline_id = if outline.stencil {
                     let stencil_key =
                         DerivedPipelineKey::new(view_key, *warm_up_key, PassType::Stencil);
 
@@ -213,7 +219,7 @@ pub(crate) fn specialise_outlines(
                 };
 
                 // Specialise volume pipeline
-                let volume_pipeline_id = if enable_volume {
+                let volume_pipeline_id = if outline.volume {
                     let pass_type = match outline.draw_mode {
                         DrawMode::Extrude => PassType::Volume,
                         #[cfg(feature = "flood")]
@@ -241,7 +247,6 @@ pub(crate) fn specialise_outlines(
                     outline_view_cache.entity_map.insert(
                         *main_entity,
                         OutlineCacheEntry {
-                            changed_tick: ticks.this_run(),
                             stencil_pipeline_id,
                             volume_pipeline_id,
                         },
@@ -265,15 +270,14 @@ pub(crate) fn queue_outline_mesh(
     transparent_draw_functions: Res<DrawFunctions<TransparentOutline>>,
     mesh_allocator: Res<MeshAllocator>,
     outline_cache: Res<OutlineCache>,
+    render_outlines: Res<RenderOutlineInstances>,
+    render_visible: Res<RenderOutlineEntities>,
+    pending_queues: Res<PendingOutlineQueues>,
+    specialisations: Res<DirtyOutlineSpecialisations>,
     mut stencil_phases: ResMut<ViewBinnedRenderPhases<StencilOutline>>,
     mut opaque_phases: ResMut<ViewBinnedRenderPhases<OpaqueOutline>>,
     mut transparent_phases: ResMut<ViewSortedRenderPhases<TransparentOutline>>,
-    mut views: Query<(
-        &ExtractedView,
-        Option<&RenderLayers>,
-        &mut OutlineQueueStatus,
-    )>,
-    outlines: Query<(Entity, &MainEntity, &ExtractedOutline)>,
+    mut views: Query<(&ExtractedView, &mut OutlineQueueStatus)>,
 ) {
     let draw_stencil = stencil_draw_functions
         .read()
@@ -288,10 +292,7 @@ pub(crate) fn queue_outline_mesh(
         .get_id::<DrawOutline>()
         .unwrap();
 
-    for (view, view_mask, mut queue_status) in views.iter_mut() {
-        let view_mask = view_mask.unwrap_or_default();
-        let rangefinder = OutlineRangefinder::new(view);
-
+    for (view, mut queue_status) in views.iter_mut() {
         let outline_view_cache = outline_cache
             .view_map
             .get(&view.retained_view_entity)
@@ -305,12 +306,34 @@ pub(crate) fn queue_outline_mesh(
             continue; // No render phase
         };
 
-        for (render_entity, main_entity, outline) in outlines.iter() {
-            if !view_mask.intersects(&outline.layers) {
-                continue; // Layer not enabled
-            }
+        let Some(render_view_visible) = render_visible.views.get(&view.retained_view_entity) else {
+            continue;
+        };
 
-            let (vertex_slab, index_slab) = mesh_allocator.mesh_slabs(&outline.mesh_id);
+        let Some(view_pending_queues) = pending_queues.get(&view.retained_view_entity) else {
+            continue;
+        };
+
+        for &main_entity in
+            specialisations.iter_to_dequeue(view.retained_view_entity, &render_view_visible.0)
+        {
+            stencil_phase.remove(main_entity);
+            opaque_phase.remove(main_entity);
+            transparent_phase.remove(Entity::PLACEHOLDER, main_entity);
+        }
+
+        for (_, main_entity) in specialisations.iter_to_queue(
+            view.retained_view_entity,
+            &render_view_visible.0,
+            &view_pending_queues.prev_frame,
+        ) {
+            let Some(outline) = render_outlines.get(main_entity) else {
+                continue;
+            };
+
+            let mesh_slabs = mesh_allocator.mesh_slabs(&outline.mesh_id);
+            let vertex_slab = mesh_slabs.map(|s| s.vertex_slab_id);
+            let index_slab = mesh_slabs.and_then(|s| s.index_slab_id);
             let phase_type = if outline.automatic_batching {
                 BinnedRenderPhaseType::BatchableMesh
             } else {
@@ -318,7 +341,6 @@ pub(crate) fn queue_outline_mesh(
             };
 
             let Some(OutlineCacheEntry {
-                changed_tick,
                 stencil_pipeline_id,
                 volume_pipeline_id,
             }) = outline_view_cache.entity_map.get(main_entity)
@@ -327,8 +349,7 @@ pub(crate) fn queue_outline_mesh(
             };
 
             // Queue stencil pass if needed
-            if outline.stencil && !stencil_phase.validate_cached_entity(*main_entity, *changed_tick)
-            {
+            if outline.stencil {
                 stencil_phase.add(
                     OutlineBatchSetKey {
                         pipeline: *stencil_pipeline_id,
@@ -340,31 +361,33 @@ pub(crate) fn queue_outline_mesh(
                         asset_id: outline.mesh_id,
                         texture_id: outline.alpha_mask_id,
                     },
-                    (render_entity, *main_entity),
+                    (Entity::PLACEHOLDER, *main_entity),
                     InputUniformIndex::default(),
                     phase_type,
-                    *changed_tick,
                 );
             }
 
             // Queue volume pass if needed
             if outline.volume && outline.draw_mode == DrawMode::Extrude {
-                queue_status.has_volume = true;
                 let transparent = outline.instance_data.volume_colour[3] < 1.0;
 
                 if transparent {
-                    let distance = rangefinder.distance_of(outline);
+                    let sorting_info = OutlineSortingInfo {
+                        world_plane_origin: outline.instance_data.world_plane_origin,
+                        world_plane_offset: outline.instance_data.world_plane_offset,
+                    };
                     transparent_phase.add(TransparentOutline {
-                        entity: render_entity,
+                        sorting_info,
+                        entity: Entity::PLACEHOLDER,
                         main_entity: *main_entity,
                         pipeline: *volume_pipeline_id,
                         draw_function: draw_transparent_outline,
-                        distance,
+                        distance: 0.0,
                         batch_range: 0..0,
                         extra_index: PhaseItemExtraIndex::None,
                         indexed: index_slab.is_some(),
                     });
-                } else if !opaque_phase.validate_cached_entity(*main_entity, *changed_tick) {
+                } else {
                     opaque_phase.add(
                         OutlineBatchSetKey {
                             pipeline: *volume_pipeline_id,
@@ -376,13 +399,16 @@ pub(crate) fn queue_outline_mesh(
                             asset_id: outline.mesh_id,
                             texture_id: outline.alpha_mask_id,
                         },
-                        (render_entity, *main_entity),
+                        (Entity::PLACEHOLDER, *main_entity),
                         InputUniformIndex::default(),
                         phase_type,
-                        *changed_tick,
                     );
                 }
             }
         }
+
+        if !opaque_phase.is_empty() || !transparent_phase.items.is_empty() {
+            queue_status.has_volume = true;
+        }
     }
 }
diff --git a/src/uniforms.rs b/src/uniforms.rs
index 313dc86..53772ca 100644
--- a/src/uniforms.rs
+++ b/src/uniforms.rs
@@ -1,7 +1,6 @@
 use bevy::{
-    camera::visibility::{RenderLayers, SetViewVisibility},
-    math::Affine3,
-    pbr::SkinUniforms,
+    math::{Affine3, Affine3Ext},
+    pbr::{MorphDescriptorIndex, MorphIndices, SkinUniforms},
     platform::collections::HashMap,
     prelude::*,
     render::{
@@ -10,7 +9,7 @@ use bevy::{
         render_asset::RenderAssets,
         render_resource::{BindGroup, BindGroupEntries, BindGroupEntry, PipelineCache, ShaderType},
         renderer::RenderDevice,
-        sync_world::{MainEntity, MainEntityHashMap, RenderEntity},
+        sync_world::{MainEntity, MainEntityHashMap},
         texture::{FallbackImage, GpuImage},
         Extract,
     },
@@ -22,12 +21,11 @@ use crate::{
     ComputedOutline, OutlineWarmUp,
 };
 
-#[derive(Clone, Component)]
+#[derive(Clone)]
 pub struct ExtractedOutline {
     pub(crate) stencil: bool,
     pub(crate) volume: bool,
     pub(crate) draw_mode: DrawMode,
-    pub(crate) layers: RenderLayers,
     pub(crate) mesh_id: AssetId<Mesh>,
     pub(crate) alpha_mask_id: Option<AssetId<Image>>,
     pub(crate) pipeline_key: EntityPipelineKey,
@@ -36,17 +34,11 @@ pub struct ExtractedOutline {
     pub(crate) warm_up: OutlineWarmUp,
 }
 
-#[derive(Resource, Default)]
-pub struct RenderOutlineInstances {
+#[derive(Resource, Default, Deref)]
+pub(crate) struct RenderOutlineInstances {
     entity_map: MainEntityHashMap<ExtractedOutline>,
 }
 
-impl RenderOutlineInstances {
-    pub fn get(&self, main_entity: &MainEntity) -> Option<&ExtractedOutline> {
-        self.entity_map.get(main_entity)
-    }
-}
-
 #[derive(Clone, ShaderType)]
 pub(crate) struct OutlineInstanceUniform {
     pub world_from_local: [Vec4; 3],
@@ -58,6 +50,7 @@ pub(crate) struct OutlineInstanceUniform {
     pub alpha_mask_threshold: f32,
     pub first_vertex_index: u32,
     pub current_skin_index: u32,
+    pub current_morph_index: u32,
 }
 
 impl OutlineInstanceUniform {
@@ -67,6 +60,7 @@ impl OutlineInstanceUniform {
         main_entity: MainEntity,
         mesh_allocator: &MeshAllocator,
         skin_uniforms: &SkinUniforms,
+        morph_indices: &MorphIndices,
     ) -> Self {
         let mut instance_data = self.clone();
         instance_data.first_vertex_index = mesh_allocator
@@ -74,6 +68,10 @@ impl OutlineInstanceUniform {
             .map(|x| x.range.start)
             .unwrap_or(0);
         instance_data.current_skin_index = skin_uniforms.skin_index(main_entity).unwrap_or(0);
+        instance_data.current_morph_index = morph_indices
+            .morph_descriptor_index(main_entity)
+            .unwrap_or(MorphDescriptorIndex(0))
+            .0;
         instance_data
     }
 }
@@ -96,30 +94,12 @@ pub(crate) struct OutlineInstanceBindGroup {
     pub bind_group: BindGroup,
 }
 
-pub(crate) fn set_outline_visibility(mut query: Query<(&mut ViewVisibility, &ComputedOutline)>) {
-    for (mut visibility, computed) in query.iter_mut() {
-        if let ComputedOutline(Some(computed)) = computed {
-            if computed.volume.value.enabled
-                || computed
-                    .stencil
-                    .value
-                    .enabled
-                    .is_enabled(computed.volume.value.enabled)
-            {
-                visibility.set_visible();
-            }
-        }
-    }
-}
-
 #[allow(clippy::type_complexity)]
 pub(crate) fn extract_outlines(
-    mut commands: Commands,
     mut render_outlines: ResMut<RenderOutlineInstances>,
     outlines: Extract<
         Query<(
             Entity,
-            RenderEntity,
             &ComputedOutline,
             &ComputedOutlineKey,
             &GlobalTransform,
@@ -130,9 +110,7 @@ pub(crate) fn extract_outlines(
 ) {
     render_outlines.entity_map.clear();
 
-    for (entity, render_entity, computed, key, transform, mesh, no_automatic_batching) in
-        outlines.iter()
-    {
+    for (entity, computed, key, transform, mesh, no_automatic_batching) in outlines.iter() {
         let ComputedOutline(Some(computed)) = computed else {
             continue;
         };
@@ -144,7 +122,6 @@ pub(crate) fn extract_outlines(
                 .is_enabled(computed.volume.value.enabled),
             volume: computed.volume.value.enabled,
             draw_mode: computed.mode.value.draw_mode,
-            layers: computed.layers.value.clone(),
             mesh_id: mesh.id(),
             alpha_mask_id: computed
                 .alpha_mask
@@ -156,7 +133,7 @@ pub(crate) fn extract_outlines(
             automatic_batching: !no_automatic_batching
                 && computed.mode.value.draw_mode == DrawMode::Extrude,
             instance_data: OutlineInstanceUniform {
-                world_from_local: Affine3::from(&transform.affine()).to_transpose(),
+                world_from_local: Affine3::from(transform.affine()).to_transpose(),
                 world_plane_origin: computed.depth.value.world_plane_origin,
                 world_plane_offset: computed.depth.value.world_plane_offset,
                 stencil_offset: computed.stencil.value.offset,
@@ -165,12 +142,10 @@ pub(crate) fn extract_outlines(
                 alpha_mask_threshold: computed.alpha_mask.value.threshold,
                 first_vertex_index: 0,
                 current_skin_index: 0,
+                current_morph_index: 0,
             },
             warm_up: computed.warm_up.value.clone(),
         };
-        commands
-            .entity(render_entity)
-            .insert(extracted_outline.clone());
         render_outlines
             .entity_map
             .insert(entity.into(), extracted_outline);
@@ -204,26 +179,24 @@ pub(crate) struct AlphaMaskBindGroups {
     pub default_bind_group: BindGroup,
 }
 
-impl FromWorld for AlphaMaskBindGroups {
-    fn from_world(world: &mut World) -> Self {
-        let render_device = world.resource::<RenderDevice>();
-        let fallback_image = world.resource::<FallbackImage>();
-        let outline_pipeline = world.resource::<OutlinePipeline>();
-        let pipeline_cache = world.resource::<PipelineCache>();
-
-        Self {
-            bind_groups: HashMap::new(),
-            default_bind_group: render_device.create_bind_group(
-                "default_outline_alpha_mask_bind_group",
-                &pipeline_cache
-                    .get_bind_group_layout(&outline_pipeline.alpha_mask_bind_group_layout),
-                &BindGroupEntries::sequential((
-                    &fallback_image.d2.texture_view,
-                    &fallback_image.d2.sampler,
-                )),
-            ),
-        }
-    }
+pub(crate) fn init_alpha_mask_bind_groups(
+    mut commands: Commands,
+    render_device: Res<RenderDevice>,
+    fallback_image: Res<FallbackImage>,
+    outline_pipeline: Res<OutlinePipeline>,
+    pipeline_cache: Res<PipelineCache>,
+) {
+    commands.insert_resource(AlphaMaskBindGroups {
+        bind_groups: HashMap::new(),
+        default_bind_group: render_device.create_bind_group(
+            "default_outline_alpha_mask_bind_group",
+            &pipeline_cache.get_bind_group_layout(&outline_pipeline.alpha_mask_bind_group_layout),
+            &BindGroupEntries::sequential((
+                &fallback_image.d2.texture_view,
+                &fallback_image.d2.sampler,
+            )),
+        ),
+    });
 }
 
 pub(crate) fn prepare_alpha_mask_bind_groups(
@@ -231,13 +204,13 @@ pub(crate) fn prepare_alpha_mask_bind_groups(
     render_device: Res<RenderDevice>,
     outline_pipeline: Res<OutlinePipeline>,
     gpu_images: Res<RenderAssets<GpuImage>>,
-    outlines: Query<&ExtractedOutline>,
+    render_outlines: Res<RenderOutlineInstances>,
     pipeline_cache: Res<PipelineCache>,
 ) {
     alpha_mask_bind_groups.bind_groups.clear();
 
     // Collect all unique textures used by outline alpha masks
-    for outline in outlines.iter() {
+    for outline in render_outlines.entity_map.values() {
         if let Some(texture_id) = outline.alpha_mask_id {
             if let Some(gpu_image) = gpu_images.get(texture_id) {
                 alpha_mask_bind_groups
diff --git a/src/view_uniforms.rs b/src/view_uniforms.rs
index c4e2255..8452e91 100644
--- a/src/view_uniforms.rs
+++ b/src/view_uniforms.rs
@@ -74,7 +74,7 @@ pub(crate) fn extract_outline_view_uniforms(
             let retained_view_entity = RetainedViewEntity::new(main_entity.into(), None, 0);
             stencil_phases.prepare_for_new_frame(retained_view_entity, GpuPreprocessingMode::None);
             opaque_phases.prepare_for_new_frame(retained_view_entity, GpuPreprocessingMode::None);
-            transparent_phases.insert_or_clear(retained_view_entity);
+            transparent_phases.prepare_for_new_frame(retained_view_entity);
         }
     }
 }
diff --git a/src/scene.rs b/src/world_serialisation.rs
similarity index 69%
rename from src/scene.rs
rename to src/world_serialisation.rs
index 261e200..65ff6d4 100644
--- a/src/scene.rs
+++ b/src/world_serialisation.rs
@@ -3,7 +3,7 @@ use std::mem;
 use bevy::{
     ecs::{lifecycle::HookContext, system::SystemId, world::DeferredWorld},
     prelude::*,
-    scene::{InstanceId, SceneInstance, SceneInstanceReady},
+    world_serialization::{InstanceId, WorldInstance, WorldInstanceReady, WorldInstanceSpawner},
 };
 
 use crate::{ComputedOutline, InheritOutline};
@@ -12,24 +12,24 @@ use crate::{ComputedOutline, InheritOutline};
 enum InternalState {
     #[default]
     Pending,
-    WaitingForSceneReady(Entity),
-    SceneProcessed(InstanceId),
+    WaitingForWorldReady(Entity),
+    WorldProcessed(InstanceId),
 }
 
-/// Automatically inherits outlines for the entities in a scene.
+/// Automatically inherits outlines for the entities in a world instance.
 ///
-/// Once a `SceneInstance` marked with this component is ready, it will add
-/// `InheritOutline` to all of the scene's entities. If this component is
+/// Once a `WorldInstance` marked with this component is ready, it will add
+/// `InheritOutline` to all of the world's entities. If this component is
 /// removed then the `InheritOutline` components will be removed too.
 #[derive(Component, Default)]
 #[component(on_add = add_hook, on_remove = remove_hook)]
-pub struct AsyncSceneInheritOutline {
+pub struct AsyncWorldInheritOutline {
     state: InternalState,
 }
 
 fn add_hook(mut world: DeferredWorld<'_>, context: HookContext) {
     let add_outline = world
-        .resource::<AsyncSceneInheritOutlineSystems>()
+        .resource::<AsyncWorldInheritOutlineSystems>()
         .add_outline;
     world
         .commands()
@@ -39,29 +39,29 @@ fn add_hook(mut world: DeferredWorld<'_>, context: HookContext) {
 fn add_outline(
     entity_input: In<Entity>,
     mut commands: Commands,
-    mut query: Query<(&mut AsyncSceneInheritOutline, Option<&SceneInstance>)>,
-    systems: Res<AsyncSceneInheritOutlineSystems>,
-    scene_spawner: Option<Res<SceneSpawner>>,
+    mut query: Query<(&mut AsyncWorldInheritOutline, Option<&WorldInstance>)>,
+    systems: Res<AsyncWorldInheritOutlineSystems>,
+    world_spawner: Option<Res<WorldInstanceSpawner>>,
 ) {
     let Ok((mut scene_outline, scene_instance)) = query.get_mut(*entity_input) else {
         return;
     };
     let mut ready = false;
     // Assume that this scene cannot be ready if the SceneSpawner is currently in use.
-    if let (Some(scene_instance), Some(scene_spawner)) = (scene_instance, scene_spawner) {
+    if let (Some(scene_instance), Some(world_spawner)) = (scene_instance, world_spawner) {
         let iid = **scene_instance;
-        if scene_spawner.instance_is_ready(iid) {
-            for child in scene_spawner.iter_instance_entities(iid) {
+        if world_spawner.instance_is_ready(iid) {
+            for child in world_spawner.iter_instance_entities(iid) {
                 if let Ok(mut ecmds) = commands.get_entity(child) {
                     ecmds.insert(InheritOutline);
                 }
             }
-            if let InternalState::WaitingForSceneReady(observer) = scene_outline.state {
+            if let InternalState::WaitingForWorldReady(observer) = scene_outline.state {
                 if let Ok(mut ecmds) = commands.get_entity(observer) {
                     ecmds.despawn();
                 }
             }
-            scene_outline.state = InternalState::SceneProcessed(iid);
+            scene_outline.state = InternalState::WorldProcessed(iid);
             ready = true;
         }
     }
@@ -70,25 +70,25 @@ fn add_outline(
         let observer = commands
             .spawn(
                 Observer::new(
-                    move |trigger: On<SceneInstanceReady>, mut commands: Commands| {
+                    move |trigger: On<WorldInstanceReady>, mut commands: Commands| {
                         commands.run_system_with(add_outline, trigger.entity);
                     },
                 )
                 .with_entity(*entity_input),
             )
             .id();
-        scene_outline.state = InternalState::WaitingForSceneReady(observer);
+        scene_outline.state = InternalState::WaitingForWorldReady(observer);
     }
 }
 
 fn remove_hook(mut world: DeferredWorld<'_>, context: HookContext) {
     let remove_outline = world
-        .resource::<AsyncSceneInheritOutlineSystems>()
+        .resource::<AsyncWorldInheritOutlineSystems>()
         .remove_outline;
     let mut entity_ref = world.entity_mut(context.entity);
     let outline = mem::take(
         entity_ref
-            .get_mut::<AsyncSceneInheritOutline>()
+            .get_mut::<AsyncWorldInheritOutline>()
             .unwrap()
             .into_inner(),
     );
@@ -96,18 +96,18 @@ fn remove_hook(mut world: DeferredWorld<'_>, context: HookContext) {
 }
 
 fn remove_outline(
-    input: In<AsyncSceneInheritOutline>,
+    input: In<AsyncWorldInheritOutline>,
     mut commands: Commands,
-    scene_spawner: Res<SceneSpawner>,
+    world_spawner: Res<WorldInstanceSpawner>,
 ) {
     match input.state {
-        InternalState::WaitingForSceneReady(observer) => {
+        InternalState::WaitingForWorldReady(observer) => {
             if let Ok(mut ecmds) = commands.get_entity(observer) {
                 ecmds.despawn();
             }
         }
-        InternalState::SceneProcessed(iid) => {
-            for child in scene_spawner.iter_instance_entities(iid) {
+        InternalState::WorldProcessed(iid) => {
+            for child in world_spawner.iter_instance_entities(iid) {
                 if let Ok(mut ecmds) = commands.get_entity(child) {
                     ecmds.remove::<(InheritOutline, ComputedOutline)>();
                 }
@@ -118,12 +118,12 @@ fn remove_outline(
 }
 
 #[derive(Resource)]
-pub(crate) struct AsyncSceneInheritOutlineSystems {
+pub(crate) struct AsyncWorldInheritOutlineSystems {
     add_outline: SystemId<In<Entity>, ()>,
-    remove_outline: SystemId<In<AsyncSceneInheritOutline>, ()>,
+    remove_outline: SystemId<In<AsyncWorldInheritOutline>, ()>,
 }
 
-impl FromWorld for AsyncSceneInheritOutlineSystems {
+impl FromWorld for AsyncWorldInheritOutlineSystems {
     fn from_world(world: &mut World) -> Self {
         Self {
             add_outline: world.register_system(add_outline),
@@ -135,7 +135,10 @@ impl FromWorld for AsyncSceneInheritOutlineSystems {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use bevy::{ecs::system::RunSystemOnce, scene::ScenePlugin};
+    use bevy::{
+        ecs::system::RunSystemOnce,
+        world_serialization::{DynamicWorld, DynamicWorldRoot, WorldSerializationPlugin},
+    };
 
     #[derive(Component, Reflect, Default)]
     #[reflect(Component, Default)]
@@ -143,9 +146,9 @@ mod tests {
 
     fn setup() -> (App, Entity) {
         let mut app = App::new();
-        app.add_plugins((AssetPlugin::default(), ScenePlugin))
+        app.add_plugins((AssetPlugin::default(), WorldSerializationPlugin))
             .register_type::<SpawnedEntity>()
-            .init_resource::<AsyncSceneInheritOutlineSystems>();
+            .init_resource::<AsyncWorldInheritOutlineSystems>();
 
         // Create scene
         let mut scene_world = World::new();
@@ -161,10 +164,10 @@ mod tests {
             .world_mut()
             .get_resource_mut::<AssetServer>()
             .unwrap()
-            .add(DynamicScene::from_world(&scene_world));
+            .add(DynamicWorld::from_world(&scene_world));
 
         // Prepare scene to spawn at next update
-        let scene_entity = app.world_mut().spawn(DynamicSceneRoot(scene_handle)).id();
+        let scene_entity = app.world_mut().spawn(DynamicWorldRoot(scene_handle)).id();
         assert_counts(&mut app, 0, 0);
         (app, scene_entity)
     }
@@ -187,7 +190,7 @@ mod tests {
         app.world_mut()
             .get_entity_mut(scene_entity)
             .unwrap()
-            .insert(AsyncSceneInheritOutline::default());
+            .insert(AsyncWorldInheritOutline::default());
         app.update();
         assert_counts(&mut app, 0, 2);
     }
@@ -200,7 +203,7 @@ mod tests {
         app.world_mut()
             .get_entity_mut(scene_entity)
             .unwrap()
-            .insert(AsyncSceneInheritOutline::default());
+            .insert(AsyncWorldInheritOutline::default());
         app.update();
         assert_counts(&mut app, 0, 2);
     }
@@ -211,7 +214,7 @@ mod tests {
         app.world_mut()
             .get_entity_mut(scene_entity)
             .unwrap()
-            .insert(AsyncSceneInheritOutline::default());
+            .insert(AsyncWorldInheritOutline::default());
         app.update();
         assert_counts(&mut app, 0, 2);
 
@@ -219,7 +222,7 @@ mod tests {
         app.world_mut()
             .get_entity_mut(scene_entity)
             .unwrap()
-            .remove::<AsyncSceneInheritOutline>();
+            .remove::<AsyncWorldInheritOutline>();
         app.update();
         assert_counts(&mut app, 2, 0);
     }
@@ -230,11 +233,11 @@ mod tests {
         app.world_mut()
             .get_entity_mut(scene_entity)
             .unwrap()
-            .insert(AsyncSceneInheritOutline::default());
+            .insert(AsyncWorldInheritOutline::default());
         app.world_mut()
             .get_entity_mut(scene_entity)
             .unwrap()
-            .remove::<AsyncSceneInheritOutline>();
+            .remove::<AsyncWorldInheritOutline>();
         app.update();
         assert_counts(&mut app, 2, 0);
     }
@@ -243,11 +246,14 @@ mod tests {
     fn test_add_when_scene_spawner_missing() {
         let (mut app, scene_entity) = setup();
 
-        let scene_spawner = app.world_mut().remove_resource::<SceneSpawner>().unwrap();
+        let scene_spawner = app
+            .world_mut()
+            .remove_resource::<WorldInstanceSpawner>()
+            .unwrap();
         app.world_mut()
             .get_entity_mut(scene_entity)
             .unwrap()
-            .insert(AsyncSceneInheritOutline::default());
+            .insert(AsyncWorldInheritOutline::default());
         app.world_mut().flush();
         app.world_mut().insert_resource(scene_spawner);