diff --git a/.gitignore b/.gitignore
index 706cf583..7664883e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -19,3 +19,6 @@ trace-*.json
 .DS_Store
 *.swp
 /.idea/
+
+# MONKEY: per-run client state written by benilla (saved variables, camera) — not source.
+/benilla-config/
diff --git a/crates/benilla-app/assets/ui/OptionsFrame.xml b/crates/benilla-app/assets/ui/OptionsFrame.xml
index 34096572..39320152 100644
--- a/crates/benilla-app/assets/ui/OptionsFrame.xml
+++ b/crates/benilla-app/assets/ui/OptionsFrame.xml
@@ -677,6 +677,11 @@
             .. "There is no exclusive fullscreen mode. WoW itself removed one in 8.0.1, and "
             .. "modern Classic offers these same two."
 
+        BENILLA_TOOLTIP_WORLD_SHADOWS =
+            "Renders real dynamic silhouettes for players, NPCs, creatures, and mounts. Terrain, "
+            .. "buildings, and trees keep their authored shading, matching Wrath's character-only "
+            .. "shadow tier. This uses additional GPU time and memory."
+
         OPTIONS_PAGE_ROWS = {
             Controls = {
                 "RowStickyTarget", "RowBlockTrades", "RowAutoLoot", "RowInvertMouse",
@@ -689,7 +694,7 @@
             },
             Graphics = {
                 "RowUiScale", "RowFarclip", "RowWorldDetail",
-                "RowDisplayMode", "RowVerticalSync", "RowRenderScale",
+                "RowDisplayMode", "RowVerticalSync", "RowWorldShadows", "RowRenderScale",
             },
             Nameplates = {
                 "RowEnemyPlates", "RowFriendlyPlates",
@@ -2517,11 +2522,21 @@
                                                     "OPTION_TOOLTIP_VERTICAL_SYNC")
                                             </OnLoad></Scripts>
                                         </Frame>
-                                        <Frame name="$parentRowRenderScale" inherits="OptionsSliderRowTemplate">
+                                        <Frame name="$parentRowWorldShadows" inherits="OptionsCheckboxRowTemplate">
                                             <Anchors>
                                                 <Anchor point="TOPLEFT" relativeTo="$parentRowVerticalSync" relativePoint="BOTTOMLEFT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
                                                 <Anchor point="TOPRIGHT" relativeTo="$parentRowVerticalSync" relativePoint="BOTTOMRIGHT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
                                             </Anchors>
+                                            <Scripts><OnLoad>
+                                                OptionsRow_OnLoad(self, "worldShadows", "Real Character Shadows",
+                                                    "BENILLA_TOOLTIP_WORLD_SHADOWS")
+                                            </OnLoad></Scripts>
+                                        </Frame>
+                                        <Frame name="$parentRowRenderScale" inherits="OptionsSliderRowTemplate">
+                                            <Anchors>
+                                                <Anchor point="TOPLEFT" relativeTo="$parentRowWorldShadows" relativePoint="BOTTOMLEFT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
+                                                <Anchor point="TOPRIGHT" relativeTo="$parentRowWorldShadows" relativePoint="BOTTOMRIGHT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
+                                            </Anchors>
                                             <Scripts><OnLoad>
                                                 -- Render Scale (decision 1639) -- benilla's own
                                                 -- row, no 1.12 counterpart: the reference renders
diff --git a/crates/benilla-app/src/blob_shadow.rs b/crates/benilla-app/src/blob_shadow.rs
index 6070f668..953f15d8 100644
--- a/crates/benilla-app/src/blob_shadow.rs
+++ b/crates/benilla-app/src/blob_shadow.rs
@@ -182,6 +182,7 @@ fn sync_shadows(
 /// reaches zero, or no receiving surface is in the box (the reference's no-ground gate).
 #[allow(clippy::too_many_arguments, clippy::type_complexity)]
 fn update_shadows(
+    video: Res<crate::video::VideoConfig>,
     time: Res<Time>,
     catalog: Option<Res<AnimData>>,
     rig: Option<Res<CameraControl>>,
@@ -219,6 +220,19 @@ fn update_shadows(
     // report, answerable from a log instead of a debugger.
     mut census_at: Local<f32>,
 ) {
+    // `worldShadows 1`: the realtime shadow-map path owns unit shadows — every record hides so a
+    // unit never wears the oval underneath its cast shadow. The records themselves stay (spawned
+    // by `sync_shadows` as usual) and `hide` drops each cache key, so flipping the cvar back
+    // rebuilds every projection on the next frame. With the cvar off — the shipped default —
+    // this gate is a single false branch and the lane below is the untouched reference path.
+    if video.world_shadows {
+        for (_, mut key, mut verts) in &mut shadows {
+            if key.shown || !verts.0.is_empty() {
+                hide(&mut key, &mut verts);
+            }
+        }
+        return;
+    }
     let now = time.elapsed_secs();
     let census = now >= *census_at;
     if census {
diff --git a/crates/benilla-app/src/cvars.rs b/crates/benilla-app/src/cvars.rs
index ef892c33..f05cfccf 100644
--- a/crates/benilla-app/src/cvars.rs
+++ b/crates/benilla-app/src/cvars.rs
@@ -585,6 +585,9 @@ pub(crate) const REGISTERED: &[Registered] = &[
     // `gxRestart = 1` does not apply (wgpu swaps the presentation interval live, so the box takes
     // effect on click), and `$WOW_NOVSYNC=1` overrides it session-only, below.
     same("gxVSync", "1"),
+    // Benilla's opt-in Wrath-style character shadow-map path. Static world assets keep their
+    // authored shading; players, NPCs, creatures and mounts cast realtime silhouettes.
+    same("worldShadows", "0"),
     // **Display mode** (decisions 1627, 1650) — 1.12's own `gxWindow`, worn since 1650 as modern
     // Classic's two-entry *Display Mode* dropdown rather than 1.12's *Windowed Mode* checkbox: the
     // two states 1627 settled on ARE that client's two (its own `Graphics.lua` builds the list from
@@ -1064,6 +1067,7 @@ fn apply_to_knobs(name: &str, value: &str, knobs: &mut Knobs) -> bool {
         // Vertical Sync — a flag like every other checkbox here. `video::apply_present_mode`
         // watches the value and pushes it to the window; nothing else reads it.
         "gxvsync" => knobs.video.vsync = v != 0.0,
+        "worldshadows" => knobs.video.world_shadows = v != 0.0,
         // Display mode (1627) — a flag like every other checkbox here, and the reference's own
         // polarity: `1` is WINDOWED (the row is "Windowed Mode"). `video::apply_window_mode`
         // watches the value and pushes it to the window; nothing else reads it.
@@ -1366,7 +1370,7 @@ fn sync_cvars(
                 .collect(),
         );
         let flag = |b: bool| if b { "1" } else { "0" }.to_string();
-        let session: [(&str, String); 44] = [
+        let session: [(&str, String); 45] = [
             ("MasterVolume", sound.master.to_string()),
             ("SoundVolume", sound.sfx.to_string()),
             ("MusicVolume", sound.music.to_string()),
@@ -1412,6 +1416,7 @@ fn sync_cvars(
             ("minimapZoom", minimap.outdoor.to_string()),
             ("minimapInsideZoom", minimap.inside.to_string()),
             ("gxVSync", flag(video.vsync)),
+            ("worldShadows", flag(video.world_shadows)),
             // The reference's polarity: the CVar is `gxWindow`, so `1` is the WINDOWED state.
             (
                 "gxWindow",
@@ -1821,6 +1826,10 @@ mod tests {
         // VSync welds to the video knob, which in turn welds to the window literal's boot
         // mode (`video::tests`) — so the registered "1" cannot drift from what we ship.
         assert_eq!(d["gxVSync"] != 0.0, VideoConfig::default().vsync);
+        assert_eq!(
+            d["worldShadows"] != 0.0,
+            VideoConfig::default().world_shadows
+        );
         // The pane half-rate (1444) welds to the portrait knob's shipped default.
         assert_eq!(d["boothHalfRate"] != 0.0, PaneRate::default().half);
         // Render scale (1639) welds to OFF. Not a taste default: the whole tree of visual
diff --git a/crates/benilla-app/src/lib.rs b/crates/benilla-app/src/lib.rs
index f4071b98..1db62a0b 100644
--- a/crates/benilla-app/src/lib.rs
+++ b/crates/benilla-app/src/lib.rs
@@ -93,6 +93,7 @@ mod pending_item_ops;
 mod perf;
 mod pipe_warm;
 mod player;
+mod player_shadow;
 mod poi_marker;
 mod portrait;
 #[cfg(feature = "dev")]
@@ -525,7 +526,10 @@ pub fn run(build: BuildId) -> AppExit {
     .add_plugins(CreatureAnimPlugin)
     // The unit blob shadow: the dark ground oval under every unit, sized from the playing
     // animation's box (the byte-verified law — wow-re unit-blob-shadow RE), on the same
-    // surface-decal projector as the selection ring.
+    // surface-decal projector as the selection ring. `worldShadows 0` — the shipped default,
+    // the faithful 1.12 frame — draws it exactly as the reference does; while `worldShadows 1`
+    // the realtime shadow-map path owns unit shadows and this lane hides (the gate inside
+    // `update_shadows`), so a unit never wears the oval underneath its cast shadow.
     .add_plugins(BlobShadowPlugin)
     // Footprint decals (B212, decision 1006): the prints a walking unit leaves on snow/sand,
     // spawn-once projections on the same decal projector, fading off the effect stream.
@@ -612,6 +616,7 @@ pub fn run(build: BuildId) -> AppExit {
     // The video knobs the CVar host writes into (today: `gxVSync`). Before CvarPlugin so the
     // resource exists when `load_config` applies the saved value at Startup.
     .add_plugins(video::VideoPlugin)
+    .add_plugins(player_shadow::WorldShadowPlugin)
     // The realmlist (decision 1667) — the logon address the login screen edits. Same reason as
     // VideoPlugin above: it is a CVar knob, so its resource has to exist before `load_config`.
     .add_plugins(realmlist::RealmlistPlugin)
diff --git a/crates/benilla-app/src/player_shadow.rs b/crates/benilla-app/src/player_shadow.rs
new file mode 100644
index 00000000..01bcbf23
--- /dev/null
+++ b/crates/benilla-app/src/player_shadow.rs
@@ -0,0 +1,653 @@
+//! Isolated real shadow-map support for the world.
+//!
+//! The old unit shadow is a projected oval. This path deliberately does not put a directional
+//! light on the normal world layer: that would make every existing custom WoW material enter
+//! Bevy's shadow-prepass path, which is the source of the pipeline validation/corruption failure
+//! seen during the first experiment. Instead, a private layer contains one CPU-built copy of the
+//! current world model triangles. Only that copy casts; the normal world shaders only receive the
+//! resulting shadow lookup when the option is enabled.
+
+use bevy::asset::RenderAssetUsages;
+use bevy::camera::visibility::{NoFrustumCulling, RenderLayers};
+use bevy::light::{
+    CascadeShadowConfigBuilder, DirectionalLight, DirectionalLightShadowMap, NotShadowReceiver,
+};
+use bevy::mesh::{Indices, PrimitiveTopology};
+use bevy::pbr::{Material, MaterialPipeline, MaterialPlugin, MeshMaterial3d};
+use bevy::prelude::*;
+use bevy::reflect::TypePath;
+use bevy::render::render_resource::{
+    AsBindGroup, RenderPipelineDescriptor, SpecializedMeshPipelineError,
+};
+use bevy::shader::ShaderRef;
+
+use benilla_assets::coords::wow_to_bevy;
+use benilla_assets::materials::WowModelMaterial;
+use benilla_formats::ModelBlend;
+use benilla_world::billboard::BillboardCard;
+use benilla_world::interact::PickMesh;
+use benilla_world::lighting::WowLighting;
+use benilla_world::model_render::{ModelKind, ModelPart, ShadowOccluder};
+use benilla_world::rig_palette::{RigPalettes, RigPart, RigSkin};
+use benilla_world::view::WorldCamera;
+
+use crate::char_select::ClientState;
+use crate::video::VideoConfig;
+
+/// Layer 31 is deliberately private to this feature. Bevy supports 32 render layers; the normal
+/// world is layer 0 and the UI/portrait layers occupy the low numbered slots.
+pub(crate) const PLAYER_SHADOW_LAYER: usize = 31;
+
+/// How far from the camera the shadow map RESOLVES (the single cascade's `maximum_distance`).
+/// Collection reaches farther than this: a caster's own body may stand outside the cascade
+/// while its shadow lands inside it — in light space a caster's footprint sits exactly where
+/// its shadow falls, so an out-of-frustum tree still darkens ground the player is looking at.
+/// See [`static_collection_reach`] for the collection law.
+const CASTER_RANGE: f32 = 80.0;
+
+/// How far the camera may drift before a caster-collection pass must refresh. The collection
+/// reach carries this as margin so coverage holds everywhere between refreshes.
+const STATIC_REBUILD_STEP: f32 = 16.0;
+
+/// The tallest COMMON caster the reach law budgets for (the big Elwynn/Duskwood tree class,
+/// in world units). Not a clamp on what casts — only on how far past the resolve range the
+/// collection hunts for shadow SOURCES.
+const MAX_CASTER_HEIGHT: f32 = 35.0;
+
+/// Ceiling on the shadow-reach extension: the lighting sun's elevation only spans ~20°–37°
+/// over the whole day, but a degenerate near-horizontal direction must not explode the
+/// collection radius (and with it the rebuild cost) unbounded.
+const SHADOW_REACH_CAP: f32 = 120.0;
+
+/// How far past a caster's own position its shadow can land: `height × horizontal/vertical`
+/// of the lighting sun's travel direction. At the night elevation (~20°) a 35-unit tree throws
+/// a ~96-unit shadow — collecting only to `CASTER_RANGE + STATIC_REBUILD_STEP` made exactly
+/// those trees pop in as the camera drifted a rebuild step, their long shadows sweeping across
+/// ground the player was already looking at.
+fn shadow_reach_extension(sun_travel: Vec3) -> f32 {
+    // `sun_travel` is the direction the light TRAVELS (downward): -y is the vertical drop.
+    let down = -sun_travel.y;
+    if down <= 1e-3 {
+        return SHADOW_REACH_CAP;
+    }
+    let horizontal = Vec3::new(sun_travel.x, 0.0, sun_travel.z).length();
+    (MAX_CASTER_HEIGHT * horizontal / down).min(SHADOW_REACH_CAP)
+}
+
+/// The one collection law for a lane that can contribute a TALL caster (a doodad/WMO entity
+/// exile, were the character-only tier ever to admit one): resolve range + rebuild margin +
+/// the sun-dependent shadow reach.
+fn static_collection_reach(sun_travel: Vec3) -> f32 {
+    CASTER_RANGE + STATIC_REBUILD_STEP + shadow_reach_extension(sun_travel)
+}
+
+/// `WOW_SHADOW_TRACE=1` — log the caster population whenever it CHANGES, so "the shadow
+/// vanished when I turned" can be attributed to a lane: a dynamic-mesh count that dips with
+/// camera rotation means the entity lane is still being view-culled somewhere; a static
+/// rebuild logged at the same moment means the cached half swapped content; neither changing
+/// while the shadow still pops on screen exonerates the caster and indicts the map/receiver.
+fn shadow_trace() -> bool {
+    static ON: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+    *ON.get_or_init(|| std::env::var("WOW_SHADOW_TRACE").is_ok_and(|v| v != "0"))
+}
+
+/// How far the LIVE sun may drift from the direction the shadow light was last given before
+/// the light snaps to it — about one game minute of lighting-sun travel (the DayNight phi
+/// table sweeps ~0.297 rad over 360 game minutes ≈ 8.25e-4 rad/min).
+///
+/// The shadow basis is quantised because a light that rotates EVERY frame defeats the cascade
+/// fit's texel snap: `calculate_cascade` (bevy_light) snaps the ortho origin to texel
+/// multiples in LIGHT space, which pins shadow edges to world positions under camera
+/// translation — but rotating the basis re-maps every world position, and at WoW map
+/// coordinates (Elwynn sits ~9,300 units from the world origin) even the lighting sun's tiny
+/// ~1.4e-5 rad/s drift slides light-space positions ~0.13 units/s ≈ 1.6 shadow texels/s: a
+/// continuous sub-texel re-rasterisation crawl on every shadow edge (the inn-roof field
+/// report). Held between snaps, the basis is bit-stable and the map only re-rasterises when
+/// the sun has honestly moved — a discrete 1–2 texel tick roughly once a game minute, the
+/// same physical reasoning that lets MCSH ship as a static bake. LIGHTING stays continuous;
+/// only the shadow basis steps.
+const SUN_SNAP_RADIANS: f32 = 8.0e-4;
+
+/// Whether the live sun direction has drifted far enough from the held (last-written) one to
+/// re-aim the shadow light. `None` = never written (first frame after spawn, or re-enable
+/// after teardown): always due.
+fn sun_snap_due(held: Option<Vec3>, live: Vec3) -> bool {
+    match held {
+        None => true,
+        Some(held) => held.angle_between(live) > SUN_SNAP_RADIANS,
+    }
+}
+
+#[derive(Component)]
+struct WorldShadowCaster;
+
+#[derive(Component)]
+struct WorldShadowSun;
+
+#[derive(Component)]
+struct WorldShadowCameraLayer {
+    had_layers: bool,
+}
+
+#[derive(Resource, Default)]
+struct WorldShadowRuntime {
+    /// The PER-FRAME caster: entity parts (animated rigs, creatures) collected fresh every
+    /// frame — the character-only tier's whole caster population.
+    dynamic_caster: Option<Entity>,
+    sun: Option<Entity>,
+    /// The direction the sun entity was LAST GIVEN — the held shadow basis. The live
+    /// direction is compared against this each frame and written through only past
+    /// [`SUN_SNAP_RADIANS`] (see there for why); `None` until the first write, and again
+    /// after teardown, so spawn and re-enable always aim the light immediately.
+    sun_written: Option<Vec3>,
+    dynamic_mesh: Option<Handle<Mesh>>,
+    material: Option<Handle<ShadowCasterMaterial>>,
+    /// [`shadow_trace`]'s change detector: (dynamic tris, admitted parts, rejected parts).
+    /// Triangle counts only change when the SET changes (animation moves vertices, not
+    /// counts), so any change here is a population event worth one log line.
+    traced: (u32, u32, u32),
+}
+
+pub(crate) struct WorldShadowPlugin;
+
+/// Opaque to Bevy's shadow pass, but discarded by the normal forward pass. This lets the
+/// private-layer proxy participate in the real shadow map without drawing a second copy of the
+/// world in the main camera.
+#[derive(Asset, AsBindGroup, TypePath, Debug, Clone, Default)]
+struct ShadowCasterMaterial {}
+
+impl Material for ShadowCasterMaterial {
+    fn fragment_shader() -> ShaderRef {
+        "embedded://benilla_app/shaders/shadow_caster.wgsl".into()
+    }
+
+    fn specialize(
+        _pipeline: &MaterialPipeline,
+        descriptor: &mut RenderPipelineDescriptor,
+        _layout: &bevy::mesh::MeshVertexBufferLayoutRef,
+        _key: bevy::pbr::MaterialPipelineKey<Self>,
+    ) -> Result<(), SpecializedMeshPipelineError> {
+        // WoW's model batches are frequently authored as two-sided geometry. Keeping both faces
+        // in the caster avoids holes in the projected silhouette when a batch has mixed winding.
+        descriptor.primitive.cull_mode = None;
+        Ok(())
+    }
+}
+
+impl Plugin for WorldShadowPlugin {
+    fn build(&self, app: &mut App) {
+        app.insert_resource(DirectionalLightShadowMap { size: 2048 })
+            .add_plugins(MaterialPlugin::<ShadowCasterMaterial>::default())
+            .init_resource::<WorldShadowRuntime>()
+            .add_systems(Last, update_world_shadow);
+    }
+}
+
+fn update_world_shadow(
+    state: Res<State<ClientState>>,
+    video: Res<VideoConfig>,
+    lighting: Res<WowLighting>,
+    mut runtime: ResMut<WorldShadowRuntime>,
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<ShadowCasterMaterial>>,
+    parts: Query<
+        (
+            &PickMesh,
+            &ModelPart,
+            Option<&GlobalTransform>,
+            Option<&RigPart>,
+            &ShadowOccluder,
+            Option<&MeshMaterial3d<WowModelMaterial>>,
+        ),
+        Without<BillboardCard>,
+    >,
+    rigs: Query<&RigSkin>,
+    palettes: Res<RigPalettes>,
+    mut cameras: Query<
+        (
+            Entity,
+            Option<&mut RenderLayers>,
+            Option<&WorldShadowCameraLayer>,
+        ),
+        With<WorldCamera>,
+    >,
+    mut suns: Query<&mut Transform, With<WorldShadowSun>>,
+    cameras_for_position: Query<&GlobalTransform, With<WorldCamera>>,
+) {
+    let wanted = video.world_shadows && *state.get() == ClientState::InWorld;
+    if !wanted {
+        if let Some(entity) = runtime.dynamic_caster.take() {
+            commands.entity(entity).despawn();
+        }
+        if let Some(entity) = runtime.sun.take() {
+            commands.entity(entity).despawn();
+        }
+        // Forget the held shadow basis with its light, so a re-enable aims the fresh sun on
+        // its first frame rather than waiting out a snap threshold.
+        runtime.sun_written = None;
+        if let Some(handle) = runtime.dynamic_mesh.take() {
+            meshes.remove(handle.id());
+        }
+        if let Some(handle) = runtime.material.take() {
+            materials.remove(handle.id());
+        }
+        for (entity, layers, marker) in &mut cameras {
+            let Some(marker) = marker else { continue };
+            if marker.had_layers {
+                if let Some(mut layers) = layers {
+                    *layers = layers.clone().without(PLAYER_SHADOW_LAYER);
+                }
+            } else {
+                commands.entity(entity).remove::<RenderLayers>();
+            }
+            commands.entity(entity).remove::<WorldShadowCameraLayer>();
+        }
+        return;
+    }
+
+    // The proxies are opaque to the shadow pass and their custom forward fragment discards
+    // every fragment. They have no texture lookup or custom WoW shader, so their shadow
+    // pipeline cannot perturb the login/character/world material pipelines.
+    if runtime.dynamic_caster.is_none() {
+        let dynamic_mesh = meshes.add(empty_shadow_mesh());
+        let material = materials.add(ShadowCasterMaterial {});
+        let spawn_caster = |commands: &mut Commands, mesh: &Handle<Mesh>| {
+            commands
+                .spawn((
+                    Mesh3d(mesh.clone()),
+                    MeshMaterial3d(material.clone()),
+                    Transform::IDENTITY,
+                    Visibility::Visible,
+                    RenderLayers::layer(PLAYER_SHADOW_LAYER),
+                    NoFrustumCulling,
+                    NotShadowReceiver,
+                    WorldShadowCaster,
+                ))
+                .id()
+        };
+        let dynamic_caster = spawn_caster(&mut commands, &dynamic_mesh);
+        let sun = commands
+            .spawn((
+                DirectionalLight {
+                    // The light exists to populate a shadow map. WoW's existing shader lighting
+                    // remains authoritative, so this light must not add a second diffuse term.
+                    illuminance: 0.0,
+                    shadows_enabled: true,
+                    // Keep enough separation from the receiver to avoid shadow-map acne on WMO
+                    // floors, while staying small enough that the silhouette remains attached.
+                    // The old 0.003/0.15 pair was below the useful texel-scale bias for Stormwind
+                    // and let the floor shadow itself, producing the broken dark patches.
+                    shadow_depth_bias: 0.02,
+                    shadow_normal_bias: 0.8,
+                    ..default()
+                },
+                CascadeShadowConfigBuilder {
+                    // This is a short-range shadow feature, not a whole-map sun-shadow system.
+                    // Independent cascade grids were showing up as square light patches on the
+                    // cobbles when the custom receiver sampled their transition. With ONE
+                    // cascade, Bevy ignores `first_cascade_far_bound`/`overlap_proportion` and
+                    // the single 2048 map spans the full `maximum_distance`.
+                    num_cascades: 1,
+                    minimum_distance: 0.1,
+                    maximum_distance: CASTER_RANGE,
+                    ..default()
+                }
+                .build(),
+                Transform::IDENTITY,
+                Visibility::Visible,
+                RenderLayers::layer(PLAYER_SHADOW_LAYER),
+                WorldShadowSun,
+            ))
+            .id();
+        runtime.dynamic_caster = Some(dynamic_caster);
+        runtime.sun = Some(sun);
+        runtime.dynamic_mesh = Some(dynamic_mesh);
+        runtime.material = Some(material);
+    }
+
+    for (entity, layers, marker) in &mut cameras {
+        if marker.is_some() {
+            if let Some(mut layers) = layers {
+                *layers = layers.clone().with(PLAYER_SHADOW_LAYER);
+            }
+        } else if let Some(mut layers) = layers {
+            *layers = layers.clone().with(PLAYER_SHADOW_LAYER);
+            commands
+                .entity(entity)
+                .insert(WorldShadowCameraLayer { had_layers: true });
+        } else {
+            commands.entity(entity).insert((
+                RenderLayers::default().with(PLAYER_SHADOW_LAYER),
+                WorldShadowCameraLayer { had_layers: false },
+            ));
+        }
+    }
+
+    let light_position = cameras_for_position
+        .iter()
+        .next()
+        .map(GlobalTransform::translation)
+        .unwrap_or(Vec3::ZERO);
+
+    let sun_direction = if lighting.sun_dir.length_squared() > 1e-6 {
+        lighting.sun_dir.normalize()
+    } else {
+        Vec3::NEG_Z
+    };
+    // The two gating radii: short casters (creatures/gameobjects — at most a body length
+    // tall) stop mattering just past the resolve range; a tall-caster lane (doodads/WMO)
+    // would carry the sun-dependent shadow reach on top, so a tree whose shadow lands in
+    // view casts before its trunk enters the resolve range. The character-only tier never
+    // admits that lane (`casts_realtime_shadow`), but `collect_world_geometry`'s signature
+    // still takes both reaches.
+    let entity_reach = CASTER_RANGE + STATIC_REBUILD_STEP;
+    let tall_reach = static_collection_reach(sun_direction);
+
+    // Animated rigs re-skin every frame, and entity doodads, creatures and mounts spawn and
+    // despawn under entity lifecycles this module cannot cheaply observe — the whole caster
+    // population is collected fresh every frame.
+    if let Some(handle) = runtime.dynamic_mesh.clone() {
+        if let Some(mesh) = meshes.get_mut(&handle) {
+            let (mut positions, mut indices) = take_mesh_buffers(mesh);
+            let (admitted, rejected) = collect_world_geometry(
+                &parts,
+                &rigs,
+                &palettes,
+                light_position,
+                entity_reach,
+                tall_reach,
+                &mut positions,
+                &mut indices,
+            );
+            let dynamic_tris = (indices.len() / 3) as u32;
+            restore_mesh_buffers(mesh, positions, indices);
+            if shadow_trace() {
+                let now = (dynamic_tris, admitted, rejected);
+                if runtime.traced != now {
+                    info!(
+                        "shadow-trace: dynamic {} tris | parts admitted {} / occluder-rejected {} (was {:?})",
+                        dynamic_tris, admitted, rejected, runtime.traced
+                    );
+                    runtime.traced = now;
+                }
+            }
+        }
+    }
+
+    if let Some(sun) = runtime.sun {
+        // Only the rotation matters: Bevy fits directional-light cascades to each view's
+        // frustum and ignores the light's translation entirely. The rotation is QUANTISED —
+        // written only when the live sun has drifted [`SUN_SNAP_RADIANS`] past the held
+        // basis — because a per-frame rotation defeats the cascade texel snap and crawls
+        // every shadow edge (see the constant's doc for the arithmetic). Skipping the write
+        // also keeps the light's `Transform` change detection quiet between snaps.
+        if sun_snap_due(runtime.sun_written, sun_direction) {
+            if let Ok(mut current) = suns.get_mut(sun) {
+                *current = Transform::IDENTITY.looking_to(sun_direction, Vec3::Y);
+                runtime.sun_written = Some(sun_direction);
+            }
+        }
+    }
+}
+
+/// Append a triangle list, dropping WHOLE triangles whose indices exceed the vertex range.
+/// Filtering single indices out of a `TriangleList` shifts every subsequent index by one and
+/// rewires the rest of the submesh into garbage triangles.
+fn append_triangles(source: &[u32], vertex_count: u32, base: u32, indices: &mut Vec<u32>) {
+    for triangle in source.chunks_exact(3) {
+        if triangle.iter().all(|index| *index < vertex_count) {
+            indices.extend(triangle.iter().map(|index| base + *index));
+        }
+    }
+}
+
+/// Take a caster mesh's own buffers so a rebuild reuses their allocations rather than paying
+/// a fresh `Vec` growth curve every time. The mesh is left attribute-less until
+/// [`restore_mesh_buffers`] puts them back.
+fn take_mesh_buffers(mesh: &mut Mesh) -> (Vec<[f32; 3]>, Vec<u32>) {
+    let mut positions = match mesh.remove_attribute(Mesh::ATTRIBUTE_POSITION) {
+        Some(bevy::mesh::VertexAttributeValues::Float32x3(values)) => values,
+        _ => Vec::new(),
+    };
+    let mut indices = match mesh.remove_indices() {
+        Some(Indices::U32(values)) => values,
+        _ => Vec::new(),
+    };
+    positions.clear();
+    indices.clear();
+    (positions, indices)
+}
+
+fn restore_mesh_buffers(mesh: &mut Mesh, positions: Vec<[f32; 3]>, indices: Vec<u32>) {
+    mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, positions);
+    mesh.insert_indices(Indices::U32(indices));
+}
+
+fn empty_shadow_mesh() -> Mesh {
+    let mut mesh = Mesh::new(
+        PrimitiveTopology::TriangleList,
+        RenderAssetUsages::default(),
+    );
+    mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, Vec::<[f32; 3]>::new());
+    mesh.insert_indices(Indices::U32(Vec::new()));
+    mesh
+}
+
+fn collect_world_geometry(
+    parts: &Query<
+        (
+            &PickMesh,
+            &ModelPart,
+            Option<&GlobalTransform>,
+            Option<&RigPart>,
+            &ShadowOccluder,
+            Option<&MeshMaterial3d<WowModelMaterial>>,
+        ),
+        Without<BillboardCard>,
+    >,
+    rigs: &Query<&RigSkin>,
+    palettes: &RigPalettes,
+    light_position: Vec3,
+    creature_reach: f32,
+    doodad_reach: f32,
+    positions: &mut Vec<[f32; 3]>,
+    indices: &mut Vec<u32>,
+) -> (u32, u32) {
+    let (mut admitted, mut rejected) = (0u32, 0u32);
+    for (pick, part, global, rig_part, occluder, _material) in parts.iter() {
+        if !casts_realtime_shadow(part.kind, part.blend) {
+            continue;
+        }
+        // NOT `InheritedVisibility`: that folds the exterior window gate, the portal PVS and
+        // the exterior-scene cull — all camera-orientation verdicts — and a tree behind the
+        // camera still blocks the sun. `ShadowOccluder` is the content half of the same law
+        // (toggles, far clip, distance fade, material alpha), written by the one visibility
+        // authority.
+        if !occluder.0 {
+            rejected += 1;
+            continue;
+        }
+        // The distance gate, BEFORE any vertex work: the cascade resolves to CASTER_RANGE, so
+        // a part beyond its lane's reach contributes nothing — skinning it first would be the
+        // per-frame cost this gate exists to remove (every resident creature within far clip
+        // was CPU-skinned per vertex, per frame). Creatures/gameobjects are at most a body
+        // tall; doodad/WMO exiles can be whole trees and take the tall-caster reach.
+        let reach = match part.kind {
+            ModelKind::Creature | ModelKind::GameObject => creature_reach,
+            ModelKind::Doodad | ModelKind::Wmo => doodad_reach,
+        };
+        // A rig part's placement lives in its palette (world-space rows), not necessarily a
+        // propagated `GlobalTransform`; prefer the transform when present, else the rig's
+        // slot origin — both are one lookup, never a skin.
+        let anchor = global.map(GlobalTransform::translation).or_else(|| {
+            rig_part
+                .and_then(|rig_part| rigs.get(rig_part.0).ok())
+                .and_then(|rig| palettes.slot_origin(rig.slot))
+        });
+        let Some(anchor) = anchor else { continue };
+        if anchor.distance_squared(light_position) > reach * reach {
+            continue;
+        }
+        admitted += 1;
+        let base = positions.len() as u32;
+        if let Some(rig_part) = rig_part {
+            append_skinned(pick, rig_part, rigs, palettes, positions);
+        } else if let Some(global) = global {
+            positions.extend(
+                pick.0
+                    .positions
+                    .iter()
+                    .map(|p| global.transform_point(wow_to_bevy(*p)).to_array()),
+            );
+        }
+        let added = positions.len() as u32 - base;
+        if added != 0 {
+            append_triangles(&pick.0.indices, added, base, indices);
+        }
+    }
+    (admitted, rejected)
+}
+
+/// Wrath's character-only shadow tier. Player bodies, equipment, NPCs, creatures and mounts all
+/// use the `Creature` model lane. Static gameobjects, doodads and WMO batches keep their authored
+/// world shading and must never enter this camera-fitted realtime map.
+fn casts_realtime_shadow(kind: ModelKind, blend: ModelBlend) -> bool {
+    matches!(kind, ModelKind::Creature)
+        && matches!(blend, ModelBlend::Opaque | ModelBlend::AlphaTest)
+}
+
+fn append_skinned(
+    pick: &PickMesh,
+    rig_part: &RigPart,
+    rigs: &Query<&RigSkin>,
+    palettes: &RigPalettes,
+    positions: &mut Vec<[f32; 3]>,
+) {
+    let Ok(rig) = rigs.get(rig_part.0) else {
+        return;
+    };
+    let Some(palette) = palettes.world_palette(rig.slot, rig.bones() as usize) else {
+        return;
+    };
+    for (index, position) in pick.0.positions.iter().enumerate() {
+        // A vertex without skinning data still gets an entry: skipping it would shorten
+        // `positions` against the index buffer and rewire every later triangle in the
+        // submesh. Seat it on the root matrix so it at least stays near the model.
+        let (Some(joints), Some(weights)) = (pick.0.joints.get(index), pick.0.weights.get(index))
+        else {
+            let fallback = palette
+                .get(0)
+                .map(|matrix| matrix.transform_point3(wow_to_bevy(*position)))
+                .unwrap_or(Vec3::ZERO);
+            positions.push(fallback.to_array());
+            continue;
+        };
+        let mut skinned = Vec3::ZERO;
+        for lane in 0..4 {
+            if weights[lane] > 0.0 {
+                if let Some(matrix) = palette.get(joints[lane] as usize) {
+                    skinned += matrix.transform_point3(wow_to_bevy(*position)) * weights[lane];
+                }
+            }
+        }
+        positions.push(skinned.to_array());
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        append_triangles, casts_realtime_shadow, shadow_reach_extension, static_collection_reach,
+        sun_snap_due, CASTER_RANGE, MAX_CASTER_HEIGHT, SHADOW_REACH_CAP, STATIC_REBUILD_STEP,
+        SUN_SNAP_RADIANS,
+    };
+    use benilla_formats::ModelBlend;
+    use benilla_world::model_render::ModelKind;
+    use bevy::prelude::Vec3;
+
+    #[test]
+    fn character_only_mode_never_admits_environment_casters() {
+        assert!(casts_realtime_shadow(
+            ModelKind::Creature,
+            ModelBlend::Opaque
+        ));
+        assert!(casts_realtime_shadow(
+            ModelKind::Creature,
+            ModelBlend::AlphaTest
+        ));
+        assert!(!casts_realtime_shadow(
+            ModelKind::Creature,
+            ModelBlend::Blend
+        ));
+
+        for kind in [ModelKind::GameObject, ModelKind::Doodad, ModelKind::Wmo] {
+            assert!(!casts_realtime_shadow(kind, ModelBlend::Opaque));
+            assert!(!casts_realtime_shadow(kind, ModelBlend::AlphaTest));
+        }
+    }
+
+    #[test]
+    fn the_shadow_sun_snaps_on_first_write_holds_under_drift_and_rearms() {
+        let held = Vec3::new(0.3, -0.8, 0.52).normalize();
+        // Never written (spawn, or re-enable after teardown): always due.
+        assert!(sun_snap_due(None, held), "first write always fires");
+        // Sub-threshold drift holds the basis bit-stable — this is the whole point.
+        let axis = Vec3::Y;
+        let small = bevy::prelude::Quat::from_axis_angle(axis, SUN_SNAP_RADIANS * 0.5) * held;
+        assert!(
+            !sun_snap_due(Some(held), small),
+            "sub-threshold drift holds"
+        );
+        // Past the threshold the light snaps…
+        let large = bevy::prelude::Quat::from_axis_angle(axis, SUN_SNAP_RADIANS * 2.0) * held;
+        assert!(sun_snap_due(Some(held), large), "over-threshold snaps");
+        // …and the new held value re-arms the window around the NEW direction.
+        assert!(
+            !sun_snap_due(Some(large), large),
+            "identical direction never rewrites"
+        );
+        let drift_from_new =
+            bevy::prelude::Quat::from_axis_angle(axis, SUN_SNAP_RADIANS * 0.5) * large;
+        assert!(
+            !sun_snap_due(Some(large), drift_from_new),
+            "window re-arms around the snapped direction"
+        );
+    }
+
+    #[test]
+    fn shadow_reach_follows_the_sun_and_is_capped() {
+        // 45° sun: horizontal == vertical, a shadow reaches exactly one caster height.
+        let diagonal = Vec3::new(1.0, -1.0, 0.0).normalize();
+        assert!((shadow_reach_extension(diagonal) - MAX_CASTER_HEIGHT).abs() < 1e-3);
+        // The night lighting sun (~20° elevation): ~2.7× height, still under the cap — the
+        // Goldshire/Duskwood long-shadow case the reach law exists for.
+        let e = 20.0f32.to_radians();
+        let night = Vec3::new(e.cos(), -e.sin(), 0.0);
+        let expected = MAX_CASTER_HEIGHT * e.cos() / e.sin();
+        assert!((shadow_reach_extension(night) - expected).abs() < 1e-2);
+        assert!(expected < SHADOW_REACH_CAP);
+        // Straight down sheds no shadow beyond the caster; a degenerate horizontal
+        // direction (the NEG_Z fallback for a zeroed sun) takes the cap, never unbounded.
+        assert_eq!(shadow_reach_extension(Vec3::NEG_Y), 0.0);
+        assert_eq!(shadow_reach_extension(Vec3::NEG_Z), SHADOW_REACH_CAP);
+        // The collection law always contains the resolve range plus the rebuild margin.
+        assert!(static_collection_reach(Vec3::NEG_Y) >= CASTER_RANGE + STATIC_REBUILD_STEP);
+    }
+
+    #[test]
+    fn an_out_of_range_index_drops_its_whole_triangle_and_no_others() {
+        let mut out = Vec::new();
+        // Middle triangle references vertex 9 of 3 — the whole triple must go, and the last
+        // triangle must keep its own vertices (a single dropped index would shift it).
+        append_triangles(&[0, 1, 2, 1, 2, 9, 2, 0, 1], 3, 10, &mut out);
+        assert_eq!(out, vec![10, 11, 12, 12, 10, 11]);
+    }
+
+    #[test]
+    fn a_trailing_partial_triple_is_ignored() {
+        let mut out = Vec::new();
+        append_triangles(&[0, 1, 2, 0, 1], 3, 0, &mut out);
+        assert_eq!(out, vec![0, 1, 2]);
+    }
+}
diff --git a/crates/benilla-app/src/shaders.rs b/crates/benilla-app/src/shaders.rs
index 07eb4b88..f4b4b473 100644
--- a/crates/benilla-app/src/shaders.rs
+++ b/crates/benilla-app/src/shaders.rs
@@ -24,6 +24,7 @@ pub(crate) fn plugin(app: &mut App) {
     bevy::asset::embedded_asset!(app, "shaders/ui_gamma.wgsl");
     bevy::asset::embedded_asset!(app, "shaders/ui_node_gamma.wgsl");
     bevy::asset::embedded_asset!(app, "shaders/ui_slice_gamma.wgsl");
+    bevy::asset::embedded_asset!(app, "shaders/shadow_caster.wgsl");
 }
 
 #[cfg(test)]
@@ -59,6 +60,6 @@ mod tests {
                  `shaders::plugin`, or was registered from a file that is not directly under src/"
             );
         }
-        assert_eq!(found, 5, "the game's shader set changed size");
+        assert_eq!(found, 6, "the game's shader set changed size");
     }
 }
diff --git a/crates/benilla-app/src/shaders/shadow_caster.wgsl b/crates/benilla-app/src/shaders/shadow_caster.wgsl
new file mode 100644
index 00000000..47dedcc1
--- /dev/null
+++ b/crates/benilla-app/src/shaders/shadow_caster.wgsl
@@ -0,0 +1,7 @@
+// The proxy is deliberately invisible in the camera's forward pass. Its material remains
+// opaque, so Bevy still queues it for the depth-only directional-light shadow pass.
+@fragment
+fn fragment() -> @location(0) vec4<f32> {
+    discard;
+    return vec4<f32>(0.0);
+}
diff --git a/crates/benilla-app/src/ui_script/options_tests.rs b/crates/benilla-app/src/ui_script/options_tests.rs
index c38de37e..0f809e7f 100644
--- a/crates/benilla-app/src/ui_script/options_tests.rs
+++ b/crates/benilla-app/src/ui_script/options_tests.rs
@@ -2184,6 +2184,7 @@ fn every_row_tooltip_key_resolves_in_the_real_global_strings() {
                 "BENILLA_TOOLTIP_BACKGROUND_SOUND",
                 "AudioRowBackgroundSound",
             ),
+            ("BENILLA_TOOLTIP_WORLD_SHADOWS", "GraphicsRowWorldShadows"),
         ];
         if let Some((_, want_row)) = BENILLA_OWNED.iter().find(|(k, _)| *k == key) {
             assert_eq!(row, *want_row, "{row}: not this row's string");
@@ -2228,7 +2229,7 @@ fn every_row_tooltip_key_resolves_in_the_real_global_strings() {
     // 29th is Enable Error Speech (1815), 1.12's own fourth Sound checkbox, ditto; the 30th is
     // Enable Sound in Background (1847), the Audio page's fifth checkbox and the one row on that
     // page the reference never made settable.
-    assert_eq!(checked, 58, "every tipped row carries a live key");
+    assert_eq!(checked, 59, "every tipped row carries a live key");
     assert_eq!(
         untipped,
         vec![
@@ -2338,7 +2339,7 @@ fn every_flavor_of_row_raises_its_plate_from_the_page_it_lives_on() {
     // rather than 1.12 GlobalStrings — see the guard above.
     // …and Block Trades (1764), the Controls page's 28th CVar row, and Enable Error Speech
     // (1815), the Audio page's fourth checkbox and 1.12's own.
-    assert_eq!(raised, 58, "every row but Auto Loot raises a description");
+    assert_eq!(raised, 59, "every row but Auto Loot raises a description");
 }
 
 /// The **Combat page** (decision 1134) — the first rows in this window whose store is a
diff --git a/crates/benilla-app/src/video.rs b/crates/benilla-app/src/video.rs
index 95f810d1..92de116d 100644
--- a/crates/benilla-app/src/video.rs
+++ b/crates/benilla-app/src/video.rs
@@ -215,6 +215,8 @@ pub(crate) fn boot_windowed_size() -> UVec2 {
 #[derive(Resource, Clone, Copy, PartialEq, Eq, Debug)]
 pub(crate) struct VideoConfig {
     pub(crate) vsync: bool,
+    /// Whether characters use the isolated real shadow-map path.
+    pub(crate) world_shadows: bool,
     pub(crate) display: DisplayMode,
     /// The windowed size, `gxResolution`. Kept while fullscreen so leaving it can restore it.
     pub(crate) windowed: UVec2,
@@ -224,6 +226,7 @@ impl Default for VideoConfig {
     fn default() -> Self {
         Self {
             vsync: !novsync_env(),
+            world_shadows: false,
             display: if windowed_env() {
                 DisplayMode::Windowed
             } else {
@@ -534,6 +537,7 @@ mod tests {
         let mut app = App::new();
         app.insert_resource(VideoConfig {
             vsync: true,
+            world_shadows: false,
             display: DisplayMode::Fullscreen,
             windowed: UVec2::new(1024, 768),
         })
diff --git a/crates/benilla-assets/src/materials.rs b/crates/benilla-assets/src/materials.rs
index db9859a5..8d09ad38 100644
--- a/crates/benilla-assets/src/materials.rs
+++ b/crates/benilla-assets/src/materials.rs
@@ -253,6 +253,12 @@ impl MaterialExtension for WowModelExt {
         // at 10/11. Bevy's own SKINNED branch never fires for these meshes — that's the point.
         if layout.0.contains(crate::ATTRIBUTE_WOW_JOINT_INDEX) {
             descriptor.vertex.shader_defs.push("WOW_RIG_SKIN".into());
+            // The FRAGMENT stage keys on the same def: a skinned unit takes the whole-unit
+            // ground-point shadow sample (one fetch at its rig origin) instead of the
+            // per-fragment fetch, which would read the unit's own caster copy as an occluder.
+            if let Some(fragment) = descriptor.fragment.as_mut() {
+                fragment.shader_defs.push("WOW_RIG_SKIN".into());
+            }
             let mut attrs = Vec::with_capacity(7);
             for (attr, loc) in [
                 (Mesh::ATTRIBUTE_POSITION, 0),
diff --git a/crates/benilla-assets/src/shaders/terrain.wgsl b/crates/benilla-assets/src/shaders/terrain.wgsl
index e5ce32c2..9c7fc949 100644
--- a/crates/benilla-assets/src/shaders/terrain.wgsl
+++ b/crates/benilla-assets/src/shaders/terrain.wgsl
@@ -29,7 +29,8 @@
     mesh_functions,
     forward_io::Vertex,
     view_transformations::position_world_to_clip,
-    mesh_view_bindings::view,
+    mesh_view_bindings::{lights, view},
+    shadows,
 }
 
 @group(#{MATERIAL_BIND_GROUP}) @binding(100) var layer_array: texture_2d_array<f32>;
@@ -37,6 +38,9 @@
 @group(#{MATERIAL_BIND_GROUP}) @binding(105) var splat_samp: sampler;
 @group(#{MATERIAL_BIND_GROUP}) @binding(110) var shadow_array: texture_2d_array<f32>;
 
+// A fully covered character shadow retains 45% of the authored terrain colour.
+const SHADOW_SUN_FLOOR: f32 = 0.45;
+
 // Per-tile Vec4 uniforms packed into ONE buffer (binding 106) — the field order here MUST match the
 // Rust `TerrainExtension` struct. Light + fog live in the shared global-light storage buffer (below);
 // what's left is just the per-tile layer tiling factor.
@@ -89,6 +93,9 @@ struct TerrainVsOut {
     // hard knee, the director's "hard square". Sun N·L moving per-pixel → per-vertex is the
     // faithful direction (Step 3's own note: indistinguishable on the smooth term).
     @location(6) primary: vec3<f32>,
+    // The receiver normal is carried so the real cascaded shadow lookup can apply a slope-aware
+    // bias. This is forward-pass data only; the terrain shadow caster is a stock Bevy proxy.
+    @location(7) world_normal: vec3<f32>,
 }
 
 // Terrain's point-light **candidacy half-width** (yd): the reference's guaranteed covered box is
@@ -196,6 +203,7 @@ fn vertex(in: Vertex) -> TerrainVsOut {
         mesh_functions::mesh_position_local_to_world(world_from_local, vec4<f32>(in.position, 1.0));
     out.clip_position = position_world_to_clip(out.world_position.xyz);
     let world_normal = mesh_functions::mesh_normal_local_to_world(in.normal, in.instance_index);
+    out.world_normal = world_normal;
     out.uv = in.uv;
     out.uv_b = in.uv_b;
     out.color = in.color;
@@ -216,8 +224,9 @@ fn vertex(in: Vertex) -> TerrainVsOut {
     // byte-verified `1/(0.7d + 0.03d²)`, raw over-gamut colours in.
     let ndotl = max(dot(n, l), 0.0);
     let points = point_light_sum(out.world_position.xyz, n, mcnk_cell_anchor(out.world_position.xyz));
+    let sun_lighting = wow_light.light_diffuse.rgb * ndotl;
     out.primary = clamp(
-        wow_light.light_ambient.rgb + wow_light.light_diffuse.rgb * ndotl + points,
+        wow_light.light_ambient.rgb + sun_lighting + points,
         vec3<f32>(0.0),
         vec3<f32>(1.0),
     );
@@ -281,6 +290,28 @@ fn fragment(in: TerrainVsOut) -> @location(0) vec4<f32> {
     // colour, byte-faithful to GL T&L (see the `primary` struct note; the MCNR normal and the
     // DayNight sun share a space per the Phase-0 validation). The MCSH ×(0.3·s + 0.7) factor below
     // still scales the whole modulate, as the traced combine does.
+    // Fetch the character coverage here, but apply it as a NEUTRAL scalar after the terrain's
+    // authored lighting below. Subtracting the warm sun RGB left only Elwynn's green ambient and
+    // produced a green silhouette on yellow morning ground. The era-style projected shadow is a
+    // greyscale attenuation: it darkens the existing hue instead of changing it.
+    // Keep the raw fetch for the specular gate below. The realtime map now contains CHARACTERS
+    // only; MCSH contains the static world's baked blockers. They are independent occluders, so
+    // the character map must never replace (and thereby brighten) the authored terrain bake.
+    var world_shadow = 1.0;
+    if (lights.n_directional_lights > 0u) {
+        let view_z = (view.view_from_world * in.world_position).z;
+        for (var light_id = 0u; light_id < lights.n_directional_lights; light_id = light_id + 1u) {
+            if ((lights.directional_lights[light_id].flags & 1u) != 0u) {
+                world_shadow = shadows::fetch_directional_shadow(
+                    light_id,
+                    in.world_position,
+                    normalize(in.world_normal),
+                    view_z,
+                );
+                break;
+            }
+        }
+    }
     let primary = in.primary;
 
     // STEP 4: MCSH baked shadow. On the reference path (pixelShaders+specular) terrain is ONE pass
@@ -294,14 +325,20 @@ fn fragment(in: TerrainVsOut) -> @location(0) vec4<f32> {
         let mcsh = textureSample(shadow_array, splat_samp, auv, i32(round(si))).r;
         shadow_lit = 1.0 - mcsh;
     }
+    // MCSH always remains the authored base. Realtime character coverage applies a neutral
+    // attenuation and closes the sheen gate. This makes the result monotonic and hue-preserving:
+    // a character can only darken the terrain already underneath it.
+    let shadow_lit_eff = shadow_lit;
+    let spec_gate = min(shadow_lit, world_shadow);
+    let character_shadow_term = mix(SHADOW_SUN_FLOOR, 1.0, world_shadow);
 
     // The faithful `terrainp_s` combine (Q15):
     //   diffuse  = tex · primary · (0.3·shadow + 0.7)   → a flat −30% in shadow, NO colour tint
     //   specular = per-vertex sheen · gloss_mask · shadow → gated to ZERO in shadow (no sheen in shade)
     // (`tex·primary` is the MODULATE-1× diffuse; the sheen is added after, separate-specular.) Then
     // LDR-clamp; gamma/byte throughout; raw gamma out (GAMMA LANE, 0161).
-    let diffuse_term = color * primary * (0.3 * shadow_lit + 0.7);
-    let spec_term = in.specular * specmask * shadow_lit;
+    let diffuse_term = color * primary * (0.3 * shadow_lit_eff + 0.7) * character_shadow_term;
+    let spec_term = in.specular * specmask * spec_gate;
     var tuned = clamp(diffuse_term + spec_term, vec3<f32>(0.0), vec3<f32>(1.0));
 
     // STEP 5: gamma-space linear fog (q6). Applied AFTER tone/curve (so the diagnostic knobs see
diff --git a/crates/benilla-assets/src/shaders/wow_model.wgsl b/crates/benilla-assets/src/shaders/wow_model.wgsl
index c5964ed2..8ac68859 100644
--- a/crates/benilla-assets/src/shaders/wow_model.wgsl
+++ b/crates/benilla-assets/src/shaders/wow_model.wgsl
@@ -47,7 +47,8 @@
     pbr_functions::alpha_discard,
     pbr_bindings,
     forward_io::VertexOutput,
-    mesh_view_bindings::view,
+    mesh_view_bindings::{lights, view},
+    shadows,
     mesh_functions,
 }
 
@@ -111,6 +112,9 @@ struct ModelParams {
 };
 @group(#{MATERIAL_BIND_GROUP}) @binding(100) var<uniform> m: ModelParams;
 
+// A fully covered character shadow retains 45% of the authored model lighting.
+const SHADOW_SUN_FLOOR: f32 = 0.45;
+
 // The shared global light (lighting::global_light): ONE storage buffer every material reads, updated
 // once/frame in place — replaces the per-material light/fog uniforms the old apply_wow_lighting re-pushed
 // each frame. The model reads rows 0-2 (ambient/diffuse/sun) + fog, plus rows 6-12: the disassembled
@@ -972,6 +976,63 @@ fn fragment(in: WowVsOut, @builtin(front_facing) is_front: bool) -> WowFragOut {
     // through `point_diffuse` below like any exterior entity.
     let is_rig = m.sun_scale.x >= 1.5;
     let lit = select(select(lit_exterior, lit_interior, is_interior), lit_m2_interior, is_rig);
+    var player_shadow = 1.0;
+    if (lights.n_directional_lights > 0u) {
+        let view_z = (view.view_from_world * in.world_position).z;
+        for (var light_id = 0u; light_id < lights.n_directional_lights; light_id = light_id + 1u) {
+            if ((lights.directional_lights[light_id].flags & 1u) != 0u) {
+#ifdef WOW_RIG_SKIN
+                // A skinned UNIT samples the map ONCE at its rig origin (between the feet),
+                // nudged 2.5 units TOWARD the sun, and the whole unit dims uniformly — the
+                // reference's own per-unit response. Per-fragment sampling is wrong here: the
+                // caster proxy holds a CPU-skinned copy of this very body, so a body fragment
+                // reads its own limbs/weapon as occluders (self-shadow speckle no bias fixes on
+                // animated silhouettes). Points along the sun ray share a shadow-map texel, so
+                // the nudge only excludes occluders within ~2.5 units of the feet ALONG the ray
+                // (a fence hugging the unit) — a building or canopy still lands. Gated on the
+                // directional-enable flag so an interior-lit unit never takes an exterior dim.
+                if (wow_light.light_sun.w > 0.5) {
+                    let sun_ray = normalize(wow_light.light_sun.xyz);
+                    let anchor = wow_light.rig_origin[(fade_tag >> 19u) & 0x7ffu].xyz
+                        - 2.5 * sun_ray;
+                    player_shadow = shadows::fetch_directional_shadow(
+                        light_id,
+                        vec4<f32>(anchor, 1.0),
+                        vec3<f32>(0.0, 1.0, 0.0),
+                        view_z,
+                    );
+                }
+#else
+                player_shadow = shadows::fetch_directional_shadow(
+                    light_id,
+                    in.world_position,
+                    wow_normalize(in.world_normal),
+                    view_z,
+                );
+#endif
+                break;
+            }
+        }
+    }
+    // The realtime map blocks only the directional sun. Preserve the authored ambient/probe
+    // contribution instead of multiplying the whole lighting result; the latter makes interiors,
+    // point-lit props, and shadow-side characters globally too dark.
+    //
+    // `is_rig` (the glue create-booth lane) is excluded DELIBERATELY: a booth scene's light is
+    // entirely its authored rig — there is no world sun to block. World units are `ShadeSel::Lit`
+    // and receive through the WOW_RIG_SKIN ground sample above. The `player_shadow < 0.999`
+    // arm keeps `worldShadows 0` (and a fully sunlit fragment) byte-identical: `ambient +
+    // (lit − ambient) × 1.0` is not guaranteed to round back to `lit`.
+    let shadow_term = mix(SHADOW_SUN_FLOOR, 1.0, player_shadow);
+    let lit_with_shadow = select(
+        lit,
+        clamp(
+            wow_light.light_ambient.rgb + (lit - wow_light.light_ambient.rgb) * shadow_term,
+            vec3<f32>(0.0),
+            vec3<f32>(1.0),
+        ),
+        !is_interior && !is_rig && player_shadow < 0.999,
+    );
     // Gamma-space albedo — the lane (0161): the buffer holds bytes, lighting math runs on the
     // authored values. (The old fog_params.z linear-space A/B is dead — settled by the lane.)
     // `m.tint` is the animated M2Color RGB (identity 1 for static batches) — the same per-batch
@@ -1028,7 +1089,7 @@ fn fragment(in: WowVsOut, @builtin(front_facing) is_front: bool) -> WowFragOut {
         // MOCV multiplies the lit terms (GL_COLOR_MATERIAL) but NOT the emission terms — SIDN and
         // the highlight add alongside, exactly the FFP's material-emission placement.
         let primary = clamp(
-            vc * (lit + point_diffuse) + sidn_e + vec3<f32>(highlight),
+            vc * (lit_with_shadow + point_diffuse) + sidn_e + vec3<f32>(highlight),
             vec3<f32>(0.0),
             vec3<f32>(1.0),
         );
@@ -1058,7 +1119,7 @@ fn fragment(in: WowVsOut, @builtin(front_facing) is_front: bool) -> WowFragOut {
         // writes a colour. (Left off the `is_wmo` branch on purpose: a WMO surface is not a CM2
         // instance and has no tint slot of its own.)
         let primary = clamp(
-            inst_tint * (lit + point_diffuse) + sidn_e + vec3<f32>(highlight),
+            inst_tint * (lit_with_shadow + point_diffuse) + sidn_e + vec3<f32>(highlight),
             vec3<f32>(0.0),
             vec3<f32>(1.0),
         );
@@ -1068,7 +1129,7 @@ fn fragment(in: WowVsOut, @builtin(front_facing) is_front: bool) -> WowFragOut {
     // (`sidn_e` is zero for every M2 batch; a WMO batch without MOCV lands here too and keeps it —
     // harmlessly, since a WMO instance's tint slot is the identity slot 0.)
     let primary = clamp(
-        inst_tint * (lit + point_diffuse) + sidn_e + vec3<f32>(highlight),
+        inst_tint * (lit_with_shadow + point_diffuse) + sidn_e + vec3<f32>(highlight),
         vec3<f32>(0.0),
         vec3<f32>(1.0),
     );
diff --git a/crates/benilla-world/src/model_render.rs b/crates/benilla-world/src/model_render.rs
index 3e4ebff2..d538fffa 100644
--- a/crates/benilla-world/src/model_render.rs
+++ b/crates/benilla-world/src/model_render.rs
@@ -1176,11 +1176,29 @@ pub enum ModelKind {
 /// Tags every spawned model submesh with the metadata the panel toggles on: its subsystem and its
 /// blend mode (the "layer" — opaque trunk vs alpha-cut canopy).
 #[derive(Component, Clone, Copy)]
+#[require(ShadowOccluder)]
 pub struct ModelPart {
     pub kind: ModelKind,
     pub blend: ModelBlend,
 }
 
+/// The camera-INDEPENDENT half of [`visibility::apply_model_visibility`]'s verdict: does this
+/// submesh exist as world content this frame (toggles, far clip, distance fade, material alpha)?
+///
+/// `Visibility` cannot answer that for a shadow caster: it also folds the exterior window gate,
+/// the portal PVS and the exterior-scene cull — all functions of where the camera LOOKS — and a
+/// wall behind the camera still blocks the sun. Gating the caster proxy on `InheritedVisibility`
+/// made every entity-lane shadow swing with view direction. Defaults to occluding so a part casts
+/// correctly from its spawn frame; the walk corrects a toggled-off part one frame later.
+#[derive(Component, Clone, Copy)]
+pub struct ShadowOccluder(pub bool);
+
+impl Default for ShadowOccluder {
+    fn default() -> Self {
+        Self(true)
+    }
+}
+
 /// Ordering handle so the one system allowed to *override* the model-`Visibility` authority — the
 /// self-avatar first-person hide ([`crate::player`]) — can run **after** it and win the frame.
 #[derive(SystemSet, Debug, Clone, Copy, PartialEq, Eq, Hash)]
diff --git a/crates/benilla-world/src/model_render/visibility.rs b/crates/benilla-world/src/model_render/visibility.rs
index a04c4bda..05559c2d 100644
--- a/crates/benilla-world/src/model_render/visibility.rs
+++ b/crates/benilla-world/src/model_render/visibility.rs
@@ -59,6 +59,7 @@ pub(super) fn apply_model_visibility(
         &ModelPart,
         &GlobalTransform,
         &mut Visibility,
+        &mut super::ShadowOccluder,
         Option<&DoodadFade>,
         Option<&mut MeshTag>,
         Option<&mut MeshMaterial3d<WowModelMaterial>>,
@@ -106,6 +107,7 @@ pub(super) fn apply_model_visibility(
             part,
             xf,
             mut vis,
+            mut occluder,
             fade,
             tag,
             mat,
@@ -241,6 +243,15 @@ pub(super) fn apply_model_visibility(
                 *vis = desired;
             }
 
+            // The shadow-caster verdict: the CONTENT terms only. `portal_visible`, `exterior_ok`
+            // and `owner_hidden` are all functions of where the camera looks, and geometry the
+            // camera cannot see still blocks the sun — folding them in made entity-lane shadows
+            // swing with view direction. Change-gated like every write in this walk.
+            let occludes = toggled_on && in_range && fade_alpha > 0.0 && mat_factor > 0.0;
+            if occluder.0 != occludes {
+                occluder.0 = occludes;
+            }
+
             // Push the fade alpha to the shader (per-instance `MeshTag` alpha field — `wow_model.wgsl`
             // multiplies the cutout alpha by it) and swap to the blend material variant while feathering,
             // back to the cutout once opaque. Write only on change so steady doodads (`fade == 1.0`,
diff --git a/crates/benilla-world/src/shaders/static_gx.wgsl b/crates/benilla-world/src/shaders/static_gx.wgsl
index 37c500a8..d02a735e 100644
--- a/crates/benilla-world/src/shaders/static_gx.wgsl
+++ b/crates/benilla-world/src/shaders/static_gx.wgsl
@@ -27,9 +27,14 @@
 // `Matte`). Output alpha is pinned 1.0 — every draw here is opaque-intent by admission
 // (wow_model.wgsl's bit-3 armor, as a constant).
 
-#import bevy_render::view::View
+#import bevy_pbr::{
+    mesh_view_bindings::{lights, view},
+    shadows,
+}
 
-@group(0) @binding(0) var<uniform> view: View;
+// Group 0 is Bevy's standard mesh-view bind group (view matrices, directional-light records and
+// the shadow textures the retained pass reads).
+const SHADOW_SUN_FLOOR: f32 = 0.45;
 
 // The shared global light's per-frame PREFIX (lighting::global_light; the full layout lives in
 // wow_model.wgsl — keep field order in sync with BOTH).
@@ -59,7 +64,7 @@ struct WowLight {
     // rig/tint/mat-anim regions beyond it stay unmirrored (statics never read them).
     prop_probes: array<vec4<f32>, 57344>,
 }
-@group(0) @binding(1) var<storage, read> wow_light: WowLight;
+@group(2) @binding(0) var<storage, read> wow_light: WowLight;
 
 // Per-cell state (static_gx/render.rs `cell_layout`).
 struct GxCell {
@@ -281,6 +286,39 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
         vec3<f32>(0.0),
         vec3<f32>(1.0),
     );
+    // The retained path uses the same Bevy directional shadow map as terrain and entity models.
+    // `static_gx` used to have no mesh-view shadow bindings, which made every Stormwind WMO act
+    // as if shadows were disabled even though the caster map was populated.
+    var world_shadow = 1.0;
+    if (lights.n_directional_lights > 0u && (in.word & WORD_INTERIOR) == 0u) {
+        let view_z = (view.view_from_world * in.world_position).z;
+        for (var light_id = 0u; light_id < lights.n_directional_lights; light_id = light_id + 1u) {
+            if ((lights.directional_lights[light_id].flags & 1u) != 0u) {
+                world_shadow = shadows::fetch_directional_shadow(
+                    light_id,
+                    in.world_position,
+                    n_lit,
+                    view_z,
+                );
+                break;
+            }
+        }
+    }
+    let shadow_term = mix(SHADOW_SUN_FLOOR, 1.0, world_shadow);
+    // Keep ambient energy when the realtime map blocks the sun. The retained pass also carries
+    // authored fixture/probe lighting, which must not be darkened by a directional shadow. The
+    // `world_shadow < 0.999` arm keeps `worldShadows 0` (no shadow-mapped light) and a fully
+    // sunlit fragment byte-identical: `ambient + (lit − ambient) × 1.0` is not guaranteed to
+    // round back to `lit`.
+    let lit_nl_shadowed = select(
+        lit_nl,
+        clamp(
+            wow_light.light_ambient.rgb + (lit_nl - wow_light.light_ambient.rgb) * shadow_term,
+            vec3<f32>(0.0),
+            vec3<f32>(1.0),
+        ),
+        world_shadow < 0.999,
+    );
     // The order-2 SH basis products over the fragment normal — shared by the exterior
     // doodad lobe and the interior-prop probe lane (wow_model.wgsl computes them once too).
     let quad = vec4<f32>(n_lit.x * n_lit.y, n_lit.y * n_lit.z, n_lit.z * n_lit.z, n_lit.x * n_lit.z);
@@ -307,12 +345,14 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
         // WINDOW (MOMT 0x20) — interior drawer only: GL_LIGHT0 swapped to the brighter
         // Direct/Ambient midpoint pair, ambient +16/255 saturating (0x6d37e0).
         let window_mid = 0.5 * (wow_light.light_ambient.rgb + wow_light.light_diffuse.rgb);
-        let lit_window = clamp(
-            window_mid + vec3<f32>(16.0 / 255.0) + window_mid * ndotl,
+        // The window's directional half rides the sun, so it takes the shadow term (×1.0 exact
+        // when the caster is off — no identity guard needed on a pure multiply).
+        let lit_window_shadowed = clamp(
+            window_mid + vec3<f32>(16.0 / 255.0) + window_mid * ndotl * shadow_term,
             vec3<f32>(0.0),
             vec3<f32>(1.0),
         );
-        let lit_int_base = select(lit_nl, lit_window, (in.word & WORD_WINDOW) != 0u);
+        let lit_int_base = select(lit_nl_shadowed, lit_window_shadowed, (in.word & WORD_WINDOW) != 0u);
         // The interior BATCH-CLASS lanes (trace-forensics-abbey-interior-d3d §2): INT = unlit
         // (the bake IS the room's light), TRANS = the per-vertex MOCV-alpha lit↔bake lerp,
         // EXT = plain lit_nl. Exterior groups take lit_nl at sun-scale 1 (prog 198/VS 151 —
@@ -323,7 +363,11 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
         } else if (!class_int) {
             lit_wmo_interior = lit_int_base;
         }
-        let lit_wmo = select(lit_nl, lit_wmo_interior, interior);
+        // EXTERIOR surfaces are the ones the realtime map can shadow (the fetch above is
+        // gated on !interior, so `lit_nl_shadowed` collapses to `lit_nl` for interior
+        // fragments anyway). Taking plain `lit_nl` here left every Stormwind street and
+        // wall unshadowed while the caster map was fully populated.
+        let lit_wmo = select(lit_nl_shadowed, lit_wmo_interior, interior);
         // SIDN night glow (MOMT 0x10): the authored emissive × the live night fraction, an
         // EMISSION term — inside the clamped sum, never MOCV-multiplied; dead on the unlit
         // INT lane, TRANS-weighted by the lit-pass alpha (wmo-interior-night-light §4).
@@ -421,9 +465,26 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
                     * (dot(wow_light.sh_c10_b.xyz, n_lit) + dot(wow_light.sh_c13_b, quad)
                         + wow_light.sh_c16.z * x2y2),
         );
-        let lit_doodad = clamp(sun_lobe, vec3<f32>(0.0), vec3<f32>(1.0));
+        // The SH lobe's own ambient rows (the .w column) are the doodad lane's ambient share:
+        // subtract-and-restore around the shadow term so only the directional part of the lobe
+        // dims. Guarded like `lit_nl_shadowed` so the no-shadow state stays byte-identical.
+        let sun_ambient = vec3<f32>(
+            wow_light.sh_c10_r.w,
+            wow_light.sh_c10_g.w,
+            wow_light.sh_c10_b.w,
+        );
+        let lit_doodad_plain = clamp(sun_lobe, vec3<f32>(0.0), vec3<f32>(1.0));
+        let lit_doodad = select(
+            lit_doodad_plain,
+            clamp(
+                sun_ambient + (sun_lobe - sun_ambient) * shadow_term,
+                vec3<f32>(0.0),
+                vec3<f32>(1.0),
+            ),
+            world_shadow < 0.999,
+        );
         // Sun disabled (light_sun.w) falls back to the FFP matte, like the entity path.
-        let lit = select(lit_nl, lit_doodad, wow_light.light_sun.w > 0.5);
+        let lit = select(lit_nl_shadowed, lit_doodad, wow_light.light_sun.w > 0.5);
         // FFP combine: the light sum saturates FIRST, the texture (× the baked constant
         // tint, when authored) modulates the clamped result. Statics: inst_tint identity,
         // no highlight, no SIDN.
diff --git a/crates/benilla-world/src/static_gx/mod.rs b/crates/benilla-world/src/static_gx/mod.rs
index 6880ad40..84f4af97 100644
--- a/crates/benilla-world/src/static_gx/mod.rs
+++ b/crates/benilla-world/src/static_gx/mod.rs
@@ -294,8 +294,11 @@ struct GxItem {
     owner: (i32, i32),
     texture: Option<AssetId<bevy::image::Image>>,
     /// Kept as a live handle so the render world's `GpuImage` can never be dropped from under
-    /// the baked cell (the id alone holds nothing).
-    _texture_handle: Option<Handle<bevy::image::Image>>,
+    /// the baked cell (the id alone holds nothing). Never READ (the bake keys everything off
+    /// [`Self::texture`]'s id) — its whole job is the strong reference held by its own
+    /// existence, so `dead_code` is a false positive here.
+    #[allow(dead_code)]
+    texture_handle: Option<Handle<bevy::image::Image>>,
     cutout: bool,
     two_sided: bool,
     unlit: bool,
@@ -770,7 +773,7 @@ impl StaticGx {
             local_aabb: b.aabb,
             owner: b.owner,
             texture: b.texture.as_ref().map(Handle::id),
-            _texture_handle: b.texture,
+            texture_handle: b.texture,
             cutout: b.blend == ModelBlend::AlphaTest && !crate::model_render::alphatest_disabled(),
             two_sided: b.two_sided,
             unlit: b.unlit,
diff --git a/crates/benilla-world/src/static_gx/render.rs b/crates/benilla-world/src/static_gx/render.rs
index 6d584b18..eab48cc2 100644
--- a/crates/benilla-world/src/static_gx/render.rs
+++ b/crates/benilla-world/src/static_gx/render.rs
@@ -16,9 +16,15 @@
 //! bind groups, never a texture.
 
 use bevy::camera::primitives::Aabb;
+use bevy::core_pipeline::oit::OrderIndependentTransparencySettingsOffset;
 use bevy::ecs::query::QueryItem;
 use bevy::image::Image;
 use bevy::mesh::VertexBufferLayout;
+use bevy::pbr::{
+    MeshPipeline, MeshPipelineViewLayoutKey, MeshViewBindGroup, ViewEnvironmentMapUniformOffset,
+    ViewFogUniformOffset, ViewLightProbesUniformOffset, ViewLightsUniformOffset,
+    ViewScreenSpaceReflectionsUniformOffset,
+};
 use bevy::platform::collections::HashMap;
 use bevy::prelude::*;
 use bevy::render::extract_component::{ExtractComponent, ExtractComponentPlugin};
@@ -30,14 +36,12 @@ use bevy::render::render_graph::{
     NodeRunError, RenderGraphContext, RenderGraphExt, RenderLabel, ViewNode, ViewNodeRunner,
 };
 use bevy::render::render_resource::binding_types::{
-    sampler, storage_buffer_read_only_sized, texture_2d_array, uniform_buffer, uniform_buffer_sized,
+    sampler, storage_buffer_read_only_sized, texture_2d_array, uniform_buffer_sized,
 };
 use bevy::render::render_resource::*;
 use bevy::render::renderer::{RenderContext, RenderDevice, RenderQueue};
 use bevy::render::texture::GpuImage;
-use bevy::render::view::{
-    ExtractedView, Msaa, ViewDepthTexture, ViewTarget, ViewUniform, ViewUniformOffset, ViewUniforms,
-};
+use bevy::render::view::{ExtractedView, Msaa, ViewDepthTexture, ViewTarget, ViewUniformOffset};
 use bevy::render::{Render, RenderSystems};
 use bevy::shader::ShaderDefVal;
 use std::ops::Range;
@@ -216,6 +220,7 @@ struct GxGpuCache {
 struct GxPipelines {
     view_layout: BindGroupLayoutDescriptor,
     cell_layout: BindGroupLayoutDescriptor,
+    light_layout: BindGroupLayoutDescriptor,
     sampler: Sampler,
     sampler_clamp: Sampler,
     /// Keyed `(cutout, two_sided)`; specialized for the world view's (samples, format) pair —
@@ -224,15 +229,25 @@ struct GxPipelines {
     specialized_for: Option<(u32, TextureFormat)>,
 }
 
-fn init_pipelines(mut commands: Commands, render_device: Res<RenderDevice>) {
-    let view_layout = BindGroupLayoutDescriptor::new(
-        "static_gx_view_layout",
+fn init_pipelines(
+    mut commands: Commands,
+    mesh_pipeline: Res<MeshPipeline>,
+    render_device: Res<RenderDevice>,
+) {
+    // Use Bevy's real mesh-view layout for the retained pass. Besides the view and light records,
+    // this carries the directional shadow textures and comparison samplers produced for the
+    // world camera. The old two-binding layout could render the city, but it had no legal way for
+    // `static_gx.wgsl` to receive the shadow map.
+    let view_layout = mesh_pipeline
+        .get_view_layout(MeshPipelineViewLayoutKey::empty())
+        .main_layout
+        .clone();
+    // The pass's own extra (group 2): the shared light storage.
+    let light_layout = BindGroupLayoutDescriptor::new(
+        "static_gx_light_layout",
         &BindGroupLayoutEntries::sequential(
             ShaderStages::VERTEX_FRAGMENT,
-            (
-                uniform_buffer::<ViewUniform>(true),
-                storage_buffer_read_only_sized(false, None),
-            ),
+            (storage_buffer_read_only_sized(false, None),),
         ),
     );
     let cell_layout = BindGroupLayoutDescriptor::new(
@@ -276,6 +291,7 @@ fn init_pipelines(mut commands: Commands, render_device: Res<RenderDevice>) {
     commands.insert_resource(GxPipelines {
         view_layout,
         cell_layout,
+        light_layout,
         sampler: make("static_gx_repeat", AddressMode::Repeat),
         sampler_clamp: make("static_gx_clamp", AddressMode::ClampToEdge),
         pipelines: HashMap::default(),
@@ -347,6 +363,7 @@ fn prepare_static_gx(
     render_device: Res<RenderDevice>,
     render_queue: Res<RenderQueue>,
     asset_server: Res<AssetServer>,
+    mesh_pipeline: Res<MeshPipeline>,
     images: Res<RenderAssets<GpuImage>>,
     views: Query<GxViewKey>,
 ) {
@@ -362,12 +379,20 @@ fn prepare_static_gx(
     };
     let key = (msaa.samples(), format);
     if pipes.specialized_for != Some(key) {
+        pipes.view_layout = mesh_pipeline
+            .get_view_layout(MeshPipelineViewLayoutKey::from(*msaa))
+            .main_layout
+            .clone();
         let shader: Handle<Shader> =
             asset_server.load("embedded://benilla_world/shaders/static_gx.wgsl");
         pipes.pipelines.clear();
         for cutout in [false, true] {
             for two_sided in [false, true] {
                 let mut defs = vec![];
+                // The world camera uses Bevy's default Gaussian shadow filtering. The retained
+                // pipeline is custom, so it must opt into the same shader branch explicitly;
+                // otherwise `shadows::fetch_directional_shadow` falls back to a constant 1.0.
+                defs.push(ShaderDefVal::from("SHADOW_FILTER_METHOD_GAUSSIAN"));
                 if cutout {
                     defs.push(ShaderDefVal::from("GX_CUTOUT"));
                 }
@@ -375,7 +400,11 @@ fn prepare_static_gx(
                     label: Some(
                         format!("static_gx c{} t{}", u8::from(cutout), u8::from(two_sided)).into(),
                     ),
-                    layout: vec![pipes.view_layout.clone(), pipes.cell_layout.clone()],
+                    layout: vec![
+                        pipes.view_layout.clone(),
+                        pipes.cell_layout.clone(),
+                        pipes.light_layout.clone(),
+                    ],
                     vertex: VertexState {
                         shader: shader.clone(),
                         shader_defs: defs.clone(),
@@ -705,28 +734,28 @@ fn kill_bit(killed: &[u64], i: usize) -> u32 {
     )
 }
 
-/// The per-frame view bind group (group 0): bevy's view uniform + the shared light buffer —
-/// the SAME `wow_shared_light` storage every material binds (1429: identical lighting by
-/// construction).
+/// The retained pass's extra bind group (group 2): the shared light buffer — the SAME
+/// `wow_shared_light` storage every material binds (1429: identical lighting by construction) —
+/// Group 0 is Bevy's standard mesh-view bind group, which supplies the view matrices,
+/// directional-light records, and shadow textures.
 #[derive(Resource)]
-struct GxViewBind(BindGroup);
+struct GxLightBind(BindGroup);
 
 fn prepare_view_bind(
     mut commands: Commands,
     pipes: Res<GxPipelines>,
     pipeline_cache: Res<PipelineCache>,
     render_device: Res<RenderDevice>,
-    view_uniforms: Res<ViewUniforms>,
     light: Option<Res<crate::lighting::SharedLightBuffer>>,
 ) {
-    let (Some(view_binding), Some(light)) = (view_uniforms.uniforms.binding(), light) else {
+    let Some(light) = light else {
         return;
     };
-    let layout = pipeline_cache.get_bind_group_layout(&pipes.view_layout);
-    commands.insert_resource(GxViewBind(render_device.create_bind_group(
-        "static_gx_view",
+    let layout = pipeline_cache.get_bind_group_layout(&pipes.light_layout);
+    commands.insert_resource(GxLightBind(render_device.create_bind_group(
+        "static_gx_light",
         &layout,
-        &BindGroupEntries::sequential((view_binding, light.0.as_entire_binding())),
+        &BindGroupEntries::sequential((light.0.as_entire_binding(),)),
     )));
 }
 
@@ -741,6 +770,13 @@ impl ViewNode for StaticGxNode {
         &'static ViewTarget,
         &'static ViewDepthTexture,
         &'static ViewUniformOffset,
+        &'static ViewLightsUniformOffset,
+        &'static ViewFogUniformOffset,
+        &'static ViewLightProbesUniformOffset,
+        &'static ViewScreenSpaceReflectionsUniformOffset,
+        &'static ViewEnvironmentMapUniformOffset,
+        Option<&'static OrderIndependentTransparencySettingsOffset>,
+        &'static MeshViewBindGroup,
         // The world camera only — a booth bake must never receive world cells (see the marker).
         &'static StaticGxView,
     );
@@ -749,7 +785,19 @@ impl ViewNode for StaticGxNode {
         &self,
         _graph: &mut RenderGraphContext,
         render_context: &mut RenderContext<'w>,
-        (target, depth, view_offset, _marker): QueryItem<'w, '_, Self::ViewQuery>,
+        (
+            target,
+            depth,
+            view_offset,
+            view_lights,
+            view_fog,
+            view_light_probes,
+            view_ssr,
+            view_environment_map,
+            maybe_oit,
+            view_bind,
+            _marker,
+        ): QueryItem<'w, '_, Self::ViewQuery>,
         world: &'w World,
     ) -> Result<(), NodeRunError> {
         let _t = super::gx_perf_guard(4);
@@ -760,7 +808,7 @@ impl ViewNode for StaticGxNode {
         let cache = world.resource::<GxGpuCache>();
         let pipes = world.resource::<GxPipelines>();
         let pipeline_cache = world.resource::<PipelineCache>();
-        let Some(view_bind) = world.get_resource::<GxViewBind>() else {
+        let Some(light_bind) = world.get_resource::<GxLightBind>() else {
             return Ok(());
         };
         let meshes = world.resource::<RenderAssets<RenderMesh>>();
@@ -818,7 +866,18 @@ impl ViewNode for StaticGxNode {
             timestamp_writes: None,
             occlusion_query_set: None,
         });
-        pass.set_bind_group(0, &view_bind.0, &[view_offset.offset]);
+        let mut view_offsets = vec![
+            view_offset.offset,
+            view_lights.offset,
+            view_fog.offset,
+            **view_light_probes,
+            **view_ssr,
+            **view_environment_map,
+        ];
+        if let Some(oit) = maybe_oit {
+            view_offsets.push(oit.offset);
+        }
+        pass.set_bind_group(0, &view_bind.main, &view_offsets);
         for (gpu, draw, sel) in &resolved {
             let Some(mesh) = meshes.get(draw.mesh.id()) else {
                 continue;
@@ -847,6 +906,7 @@ impl ViewNode for StaticGxNode {
                 }
                 pass.set_render_pipeline(ready[&(run.cutout, run.two_sided)]);
                 pass.set_bind_group(1, &gpu.bind_groups[run.slot].1, &[]);
+                pass.set_bind_group(2, &light_bind.0, &[]);
                 pass.draw_indexed(
                     (islice.range.start + run.index_range.start)
                         ..(islice.range.start + run.index_range.end),