diff --git a/goud_engine/Cargo.toml b/goud_engine/Cargo.toml
index 5cf64a3ec..be7e6bcbe 100644
--- a/goud_engine/Cargo.toml
+++ b/goud_engine/Cargo.toml
@@ -140,6 +140,10 @@ harness = false
 name = "spatial_grid_benchmarks"
 harness = false
 
+[[bench]]
+name = "scene_culling_benchmarks"
+harness = false
+
 [[test]]
 name = "native_main_thread"
 path = "tests/native_main_thread.rs"
diff --git a/goud_engine/benches/scene_culling_benchmarks.rs b/goud_engine/benches/scene_culling_benchmarks.rs
new file mode 100644
index 000000000..61a9d3862
--- /dev/null
+++ b/goud_engine/benches/scene_culling_benchmarks.rs
@@ -0,0 +1,103 @@
+//! Scene-Culling Scaling Benchmarks (#678)
+//!
+//! Drives the [`Renderer3D`] frustum-cull path with 1k / 10k / 50k registered
+//! 3D objects and asserts (via the per-frame `Renderer3DStats`) that the
+//! candidate set fed into the frustum sphere test grows sub-linearly when the
+//! spatial index is enabled.
+//!
+//! Run with: `cargo bench --bench scene_culling_benchmarks`
+//!
+//! The benchmark emits the spatial-index candidate count to stdout each
+//! sample so before/after comparisons are easy to eyeball without a baseline
+//! file.
+
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
+use goud_engine::libs::graphics::backend::null::NullBackend;
+use goud_engine::libs::graphics::renderer3d::config::SpatialIndexConfig;
+use goud_engine::libs::graphics::renderer3d::{PrimitiveCreateInfo, PrimitiveType, Renderer3D};
+
+fn make_renderer() -> Renderer3D {
+    Renderer3D::new(Box::new(NullBackend::new()), 800, 600)
+        .expect("renderer should initialize against the null backend")
+}
+
+fn populate_grid(renderer: &mut Renderer3D, side: i32, spacing: f32) {
+    for x in 0..side {
+        for z in 0..side {
+            let id = renderer.create_primitive(PrimitiveCreateInfo {
+                primitive_type: PrimitiveType::Cube,
+                width: 1.0,
+                height: 1.0,
+                depth: 1.0,
+                segments: 1,
+                texture_id: 0,
+            });
+            assert_ne!(id, 0);
+            renderer.set_object_position(id, x as f32 * spacing, 0.0, z as f32 * spacing);
+        }
+    }
+}
+
+fn aim_camera_at_origin(renderer: &mut Renderer3D) {
+    renderer.set_camera_position(5.0, 5.0, 5.0);
+    renderer.set_camera_rotation(-30.0, -135.0, 0.0);
+}
+
+fn bench_render_with_spatial_index(c: &mut Criterion) {
+    let mut group = c.benchmark_group("scene_culling_spatial_index_on");
+
+    // 1k / 10k / 30k / 50k matches the scaling table in #678 so the bench
+    // output lines up with the issue's three named checkpoints.
+    for &(side, label) in &[
+        (32i32, 1_024usize),
+        (100, 10_000),
+        (174, 30_276),
+        (224, 50_176),
+    ] {
+        group.bench_with_input(BenchmarkId::from_parameter(label), &side, |b, &side| {
+            let mut renderer = make_renderer();
+            populate_grid(&mut renderer, side, 4.0);
+            aim_camera_at_origin(&mut renderer);
+            b.iter(|| {
+                renderer.render(None);
+                black_box(renderer.stats().spatial_index_candidates);
+            });
+        });
+    }
+    group.finish();
+}
+
+fn bench_render_with_linear_scan(c: &mut Criterion) {
+    let mut group = c.benchmark_group("scene_culling_spatial_index_off");
+
+    for &(side, label) in &[
+        (32i32, 1_024usize),
+        (100, 10_000),
+        (174, 30_276),
+        (224, 50_176),
+    ] {
+        group.bench_with_input(BenchmarkId::from_parameter(label), &side, |b, &side| {
+            let mut renderer = make_renderer();
+            let mut config = renderer.render_config().clone();
+            config.spatial_index = SpatialIndexConfig {
+                enabled: false,
+                cell_size: config.spatial_index.cell_size,
+            };
+            renderer.set_render_config(config);
+            populate_grid(&mut renderer, side, 4.0);
+            aim_camera_at_origin(&mut renderer);
+            b.iter(|| {
+                renderer.render(None);
+                black_box(renderer.stats().spatial_index_candidates);
+            });
+        });
+    }
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    bench_render_with_spatial_index,
+    bench_render_with_linear_scan
+);
+criterion_main!(benches);
diff --git a/goud_engine/src/libs/graphics/renderer3d/config.rs b/goud_engine/src/libs/graphics/renderer3d/config.rs
index 74429f54a..fd3ce0a9b 100644
--- a/goud_engine/src/libs/graphics/renderer3d/config.rs
+++ b/goud_engine/src/libs/graphics/renderer3d/config.rs
@@ -9,6 +9,8 @@
 pub struct Render3DConfig {
     /// Frustum culling settings.
     pub frustum_culling: FrustumCullingConfig,
+    /// Spatial index settings used to accelerate frustum culling.
+    pub spatial_index: SpatialIndexConfig,
     /// Draw call batching and instancing settings.
     pub batching: BatchingConfig,
     /// Skeletal animation skinning settings.
@@ -19,6 +21,35 @@ pub struct Render3DConfig {
     pub default_material_color: [f32; 4],
 }
 
+/// Spatial index configuration. The renderer uses a sparse uniform grid to
+/// shrink the per-frame frustum-cull candidate set from "every scene object"
+/// down to "objects whose grid cell touches the frustum AABB".
+#[derive(Debug, Clone)]
+pub struct SpatialIndexConfig {
+    /// Whether the spatial index is consulted during frustum culling
+    /// (default: `true`). When `false` the renderer falls back to a linear
+    /// scan over every registered object — same behavior as before #678.
+    pub enabled: bool,
+    /// Grid cell size in world units (default: `32.0`). Cells smaller than
+    /// `0.5` are clamped up to keep grid coordinates finite. Tune this for
+    /// scenes where most objects fit inside one cell.
+    ///
+    /// Note: changing this at runtime forces a rebuild of the spatial index
+    /// over every registered scene object. That is cheap for small scenes
+    /// but is `O(n)` work over the whole `objects` registry, so prefer to
+    /// set it once at startup for large scenes.
+    pub cell_size: f32,
+}
+
+impl Default for SpatialIndexConfig {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            cell_size: 32.0,
+        }
+    }
+}
+
 /// Frustum culling configuration.
 #[derive(Debug, Clone)]
 pub struct FrustumCullingConfig {
@@ -148,6 +179,7 @@ impl Default for Render3DConfig {
     fn default() -> Self {
         Self {
             frustum_culling: FrustumCullingConfig::default(),
+            spatial_index: SpatialIndexConfig::default(),
             batching: BatchingConfig::default(),
             skinning: SkinningConfig::default(),
             shadows: ShadowConfig::default(),
@@ -217,6 +249,13 @@ mod tests {
         assert_eq!(config.default_material_color, [0.8, 0.8, 0.8, 1.0]);
     }
 
+    #[test]
+    fn test_spatial_index_config_default() {
+        let si = SpatialIndexConfig::default();
+        assert!(si.enabled);
+        assert!((si.cell_size - 32.0).abs() < f32::EPSILON);
+    }
+
     #[test]
     fn test_frustum_culling_config_default() {
         let fc = FrustumCullingConfig::default();
diff --git a/goud_engine/src/libs/graphics/renderer3d/core/mod.rs b/goud_engine/src/libs/graphics/renderer3d/core/mod.rs
index 610be3874..a61142b85 100644
--- a/goud_engine/src/libs/graphics/renderer3d/core/mod.rs
+++ b/goud_engine/src/libs/graphics/renderer3d/core/mod.rs
@@ -165,11 +165,20 @@ pub struct Renderer3D {
     /// Object IDs that were actually included in the static batch (not overflowed).
     /// Used to distinguish batched objects from overflow objects that need individual draws.
     pub(in crate::libs::graphics::renderer3d) static_batched_ids: FxHashSet<u32>,
+    /// Sparse uniform-grid spatial index over scene objects, used to shrink
+    /// the per-frame frustum-cull candidate set. Maintained incrementally
+    /// alongside `objects` so culling does not have to scan the full registry.
+    pub(in crate::libs::graphics::renderer3d) spatial_index: super::spatial_index::SpatialIndex,
+    /// Reusable scratch buffer of cull candidate IDs gathered from the
+    /// spatial index each frame; reset at the start of every render.
+    pub(in crate::libs::graphics::renderer3d) scratch_cull_candidates: Vec<u32>,
 }
 
 // StaticBatchGroup is defined in core_static_batch.rs
 pub(in crate::libs::graphics::renderer3d) use super::core_static_batch::StaticBatchGroup;
 
+mod spatial;
+
 #[allow(missing_docs)]
 impl Renderer3D {
     #[rustfmt::skip]
@@ -364,6 +373,10 @@ impl Renderer3D {
             static_batch_groups: Vec::new(),
             static_batch_vertex_count: 0,
             static_batched_ids: FxHashSet::default(),
+            spatial_index: super::spatial_index::SpatialIndex::new(
+                super::spatial_index::DEFAULT_CELL_SIZE,
+            ),
+            scratch_cull_candidates: Vec::with_capacity(1024),
         })
     }
 }
diff --git a/goud_engine/src/libs/graphics/renderer3d/core/object_transforms.rs b/goud_engine/src/libs/graphics/renderer3d/core/object_transforms.rs
index a0eb24e1a..6809b3885 100644
--- a/goud_engine/src/libs/graphics/renderer3d/core/object_transforms.rs
+++ b/goud_engine/src/libs/graphics/renderer3d/core/object_transforms.rs
@@ -11,12 +11,22 @@ impl Renderer3D {
         let ok = self.mutate_object(id, |obj| {
             obj.position = Vector3::new(x, y, z);
         });
-        if ok && self.objects.get(&id).is_some_and(|o| o.is_static) {
-            self.static_batch_dirty = true;
+        if ok {
+            if self.objects.get(&id).is_some_and(|o| o.is_static) {
+                self.static_batch_dirty = true;
+            }
+            self.spatial_index_refresh(id);
         }
         ok
     }
     pub fn set_object_rotation(&mut self, id: u32, x: f32, y: f32, z: f32) -> bool {
+        // Rotation does not change the bounding-sphere AABB, so no spatial-index
+        // refresh is needed here.
+        //
+        // INVARIANT: only safe while the per-object bound is a sphere
+        // (uniform radius around `bounds.center`). If `Object3D::bounds` is
+        // ever switched to an axis-aligned or oriented box, this skip must
+        // be removed and `spatial_index_refresh` called below.
         let ok = self.mutate_object(id, |obj| obj.rotation = Vector3::new(x, y, z));
         if ok && self.objects.get(&id).is_some_and(|o| o.is_static) {
             self.static_batch_dirty = true;
@@ -27,8 +37,11 @@ impl Renderer3D {
         let ok = self.mutate_object(id, |obj| {
             obj.scale = Vector3::new(x, y, z);
         });
-        if ok && self.objects.get(&id).is_some_and(|o| o.is_static) {
-            self.static_batch_dirty = true;
+        if ok {
+            if self.objects.get(&id).is_some_and(|o| o.is_static) {
+                self.static_batch_dirty = true;
+            }
+            self.spatial_index_refresh(id);
         }
         ok
     }
@@ -61,6 +74,7 @@ impl Renderer3D {
             if obj.is_static {
                 self.static_batch_dirty = true;
             }
+            self.spatial_index_remove(id);
             self.backend.destroy_buffer(obj.buffer);
             true
         } else {
diff --git a/goud_engine/src/libs/graphics/renderer3d/core/spatial.rs b/goud_engine/src/libs/graphics/renderer3d/core/spatial.rs
new file mode 100644
index 000000000..5ffcea321
--- /dev/null
+++ b/goud_engine/src/libs/graphics/renderer3d/core/spatial.rs
@@ -0,0 +1,34 @@
+//! Spatial-index helpers for [`Renderer3D`].
+//!
+//! These methods keep the renderer's `spatial_index` in sync with the
+//! `objects` map and translate per-object [`super::super::types::Object3D`]
+//! state into the world-space AABB the index expects. They are deliberately
+//! tiny so the call sites in `core_primitives.rs`, `core_models/mod.rs`,
+//! `core_model_instances.rs`, and `object_transforms.rs` only have to add a
+//! one-line hook after each insert/update/remove.
+
+use super::super::spatial_index::world_aabb_from_sphere;
+use super::Renderer3D;
+
+impl Renderer3D {
+    /// Refresh `id` in the spatial index by reading the current state of the
+    /// object out of `self.objects`. No-op when the ID is not registered.
+    pub(in crate::libs::graphics::renderer3d) fn spatial_index_refresh(&mut self, id: u32) {
+        let Some(obj) = self.objects.get(&id) else {
+            return;
+        };
+        let (min, max) = world_aabb_from_sphere(
+            obj.position,
+            obj.bounds.center,
+            obj.bounds.radius,
+            obj.scale,
+        );
+        self.spatial_index.insert(id, min, max);
+    }
+
+    /// Drop `id` from the spatial index. Returns `true` when the entry
+    /// existed.
+    pub(in crate::libs::graphics::renderer3d) fn spatial_index_remove(&mut self, id: u32) -> bool {
+        self.spatial_index.remove(id)
+    }
+}
diff --git a/goud_engine/src/libs/graphics/renderer3d/core_model_instances.rs b/goud_engine/src/libs/graphics/renderer3d/core_model_instances.rs
index 6eae1b6e5..a86dcb101 100644
--- a/goud_engine/src/libs/graphics/renderer3d/core_model_instances.rs
+++ b/goud_engine/src/libs/graphics/renderer3d/core_model_instances.rs
@@ -15,20 +15,40 @@ impl Renderer3D {
     ///
     /// Returns the instance handle, or `None` if the source model does not exist.
     pub fn instantiate_model(&mut self, source_id: u32) -> Option<u32> {
-        let source = self.models.get(&source_id)?;
-        let has_skeleton = source.skeleton.is_some();
-
-        // Pre-collect bind-pose data we may need for creating instance buffers.
-        let bind_poses: Vec<Vec<f32>> = if has_skeleton {
-            source.bind_pose_vertices.clone()
-        } else {
-            Vec::new()
+        // Copy out everything we need from `source` up front so we do not have
+        // to keep a long-lived `&self.models` borrow across the loop body
+        // (which mutates `self.objects`, `self.spatial_index`, etc.).
+        struct SourceSnapshot {
+            has_skeleton: bool,
+            is_skinned: bool,
+            skeleton_bone_count: Option<usize>,
+            mesh_object_ids: Vec<u32>,
+            mesh_material_ids: Vec<u32>,
+            bind_poses: Vec<Vec<f32>>,
+        }
+        let snapshot = {
+            let source = self.models.get(&source_id)?;
+            let has_skeleton = source.skeleton.is_some();
+            SourceSnapshot {
+                has_skeleton,
+                is_skinned: source.is_skinned,
+                skeleton_bone_count: source.skeleton.as_ref().map(|s| s.bones.len()),
+                mesh_object_ids: source.mesh_object_ids.clone(),
+                mesh_material_ids: source.mesh_material_ids.clone(),
+                bind_poses: if has_skeleton {
+                    source.bind_pose_vertices.clone()
+                } else {
+                    Vec::new()
+                },
+            }
         };
+        let has_skeleton = snapshot.has_skeleton;
+        let bind_poses = snapshot.bind_poses;
 
-        let mut instance_object_ids = Vec::with_capacity(source.mesh_object_ids.len());
-        let mut instance_material_ids = Vec::with_capacity(source.mesh_material_ids.len());
+        let mut instance_object_ids = Vec::with_capacity(snapshot.mesh_object_ids.len());
+        let mut instance_material_ids = Vec::with_capacity(snapshot.mesh_material_ids.len());
 
-        for (i, &src_obj_id) in source.mesh_object_ids.iter().enumerate() {
+        for (i, &src_obj_id) in snapshot.mesh_object_ids.iter().enumerate() {
             let (src_buffer, vertex_count, texture_id, src_bounds, src_vertices) =
                 match self.objects.get(&src_obj_id) {
                     Some(o) => (
@@ -43,7 +63,7 @@ impl Renderer3D {
 
             // CPU-skinned instances need their own dynamic buffer for per-frame re-upload.
             // GPU-skinned instances share the source buffer (GPU deforms via shader).
-            let buffer = if has_skeleton && !source.is_skinned {
+            let buffer = if has_skeleton && !snapshot.is_skinned {
                 if let Some(bp) = bind_poses.get(i) {
                     use crate::libs::graphics::backend::{BufferType, BufferUsage};
                     match self.backend.create_buffer(
@@ -83,9 +103,10 @@ impl Renderer3D {
                     is_static: false,
                 },
             );
+            self.spatial_index_refresh(new_obj_id);
 
             // Clone the material (cheap -- just a few floats).
-            let src_mat_id = source
+            let src_mat_id = snapshot
                 .mesh_material_ids
                 .get(i)
                 .and_then(|id| self.materials.get(id));
@@ -114,8 +135,8 @@ impl Renderer3D {
         }
 
         // Create animation player if the source model has a skeleton.
-        if let Some(ref skeleton) = source.skeleton {
-            let player = AnimationPlayer::new(skeleton.bones.len());
+        if let Some(bone_count) = snapshot.skeleton_bone_count {
+            let player = AnimationPlayer::new(bone_count);
             self.animation_players.insert(instance_id, player);
         }
 
@@ -129,7 +150,7 @@ impl Renderer3D {
         );
 
         // Update skinned object ID set if the source model is skinned.
-        if source.is_skinned {
+        if snapshot.is_skinned {
             self.skinned_object_ids
                 .extend(instance_object_ids.iter().copied());
         }
diff --git a/goud_engine/src/libs/graphics/renderer3d/core_models/lifecycle.rs b/goud_engine/src/libs/graphics/renderer3d/core_models/lifecycle.rs
index c35b127e7..957f4234f 100644
--- a/goud_engine/src/libs/graphics/renderer3d/core_models/lifecycle.rs
+++ b/goud_engine/src/libs/graphics/renderer3d/core_models/lifecycle.rs
@@ -55,6 +55,7 @@ impl Renderer3D {
         for &obj_id in &model.mesh_object_ids {
             self.skinned_object_ids.remove(&obj_id);
             if let Some(obj) = self.objects.remove(&obj_id) {
+                self.spatial_index_remove(obj_id);
                 self.backend.destroy_buffer(obj.buffer);
             }
             self.object_materials.remove(&obj_id);
@@ -100,6 +101,7 @@ impl Renderer3D {
                 if obj.is_static {
                     self.static_batch_dirty = true;
                 }
+                self.spatial_index_remove(obj_id);
                 if !source_buffers.contains(&obj.buffer) {
                     self.backend.destroy_buffer(obj.buffer);
                 }
@@ -117,17 +119,22 @@ impl Renderer3D {
 
     /// Set position on all sub-mesh objects of a model or instance.
     pub fn set_model_position(&mut self, id: u32, x: f32, y: f32, z: f32) -> bool {
-        self.set_model_transform(id, |obj| obj.position = Vector3::new(x, y, z))
+        self.set_model_transform(id, true, |obj| obj.position = Vector3::new(x, y, z))
     }
 
     /// Set rotation (degrees) on all sub-mesh objects of a model or instance.
     pub fn set_model_rotation(&mut self, id: u32, x: f32, y: f32, z: f32) -> bool {
-        self.set_model_transform(id, |obj| obj.rotation = Vector3::new(x, y, z))
+        // Rotation alone does not move or resize the world-space bounding
+        // sphere, so the spatial index does not need refreshing here.
+        //
+        // INVARIANT: matches the assumption in `set_object_rotation` —
+        // safe only while per-object bounds are uniform spheres.
+        self.set_model_transform(id, false, |obj| obj.rotation = Vector3::new(x, y, z))
     }
 
     /// Set scale on all sub-mesh objects of a model or instance.
     pub fn set_model_scale(&mut self, id: u32, x: f32, y: f32, z: f32) -> bool {
-        self.set_model_transform(id, |obj| obj.scale = Vector3::new(x, y, z))
+        self.set_model_transform(id, true, |obj| obj.scale = Vector3::new(x, y, z))
     }
 
     /// Mark all sub-mesh objects of a model or instance as static for batching.
@@ -284,14 +291,19 @@ impl Renderer3D {
             .unwrap_or(&[])
     }
 
-    fn set_model_transform(&mut self, id: u32, f: impl Fn(&mut Object3D)) -> bool {
+    fn set_model_transform(
+        &mut self,
+        id: u32,
+        affects_world_aabb: bool,
+        f: impl Fn(&mut Object3D),
+    ) -> bool {
         let obj_ids = self.collect_model_object_ids(id).to_vec();
         if obj_ids.is_empty() {
             return false;
         }
         let mut has_static = false;
-        for obj_id in obj_ids {
-            if let Some(obj) = self.objects.get_mut(&obj_id) {
+        for obj_id in &obj_ids {
+            if let Some(obj) = self.objects.get_mut(obj_id) {
                 f(obj);
                 if obj.is_static {
                     has_static = true;
@@ -301,6 +313,11 @@ impl Renderer3D {
         if has_static {
             self.static_batch_dirty = true;
         }
+        if affects_world_aabb {
+            for obj_id in obj_ids {
+                self.spatial_index_refresh(obj_id);
+            }
+        }
         true
     }
 }
diff --git a/goud_engine/src/libs/graphics/renderer3d/core_models/mod.rs b/goud_engine/src/libs/graphics/renderer3d/core_models/mod.rs
index 53d787f82..19ce97388 100644
--- a/goud_engine/src/libs/graphics/renderer3d/core_models/mod.rs
+++ b/goud_engine/src/libs/graphics/renderer3d/core_models/mod.rs
@@ -142,6 +142,7 @@ impl Renderer3D {
                     is_static: false,
                 },
             );
+            self.spatial_index_refresh(object_id);
 
             let material = if let Some(mesh_mat) = material_opt {
                 Material3D {
diff --git a/goud_engine/src/libs/graphics/renderer3d/core_primitives.rs b/goud_engine/src/libs/graphics/renderer3d/core_primitives.rs
index 548b5254e..0381e1134 100644
--- a/goud_engine/src/libs/graphics/renderer3d/core_primitives.rs
+++ b/goud_engine/src/libs/graphics/renderer3d/core_primitives.rs
@@ -50,6 +50,7 @@ impl Renderer3D {
                 is_static: false,
             },
         );
+        self.spatial_index_refresh(id);
 
         id
     }
diff --git a/goud_engine/src/libs/graphics/renderer3d/frustum.rs b/goud_engine/src/libs/graphics/renderer3d/frustum.rs
index 75dad77f9..13139b9b5 100644
--- a/goud_engine/src/libs/graphics/renderer3d/frustum.rs
+++ b/goud_engine/src/libs/graphics/renderer3d/frustum.rs
@@ -4,7 +4,7 @@
 //! frustum planes from a view-projection matrix and tests bounding spheres
 //! against them.
 
-use cgmath::{Matrix4, Vector3};
+use cgmath::{Matrix4, SquareMatrix, Vector3, Vector4};
 
 /// A plane in 3D space represented as `normal · point + d = 0`.
 #[derive(Debug, Clone, Copy)]
@@ -85,6 +85,55 @@ impl Frustum {
     }
 }
 
+/// World-space AABB enclosing the view frustum produced by `view * projection`.
+///
+/// Computed by transforming the eight clip-space cube corners through the
+/// inverse view-projection matrix and taking the per-axis min/max. Used by
+/// the spatial index to pick the cell range to query — if `inv(VP)` is
+/// non-invertible (degenerate camera), returns `None` so the caller can fall
+/// back to a full scan.
+///
+/// NDC z is sampled at `-1` (near) and `+1` (far), matching cgmath's
+/// `perspective()` output. Even when the active backend clips at `[0, 1]`,
+/// this AABB is a conservative superset of the actual visible volume.
+pub(in crate::libs::graphics::renderer3d) fn frustum_world_aabb(
+    view: &Matrix4<f32>,
+    projection: &Matrix4<f32>,
+) -> Option<(Vector3<f32>, Vector3<f32>)> {
+    let vp = projection * view;
+    let inv_vp = vp.invert()?;
+    const NDC_CORNERS: [[f32; 3]; 8] = [
+        [-1.0, -1.0, -1.0],
+        [1.0, -1.0, -1.0],
+        [-1.0, 1.0, -1.0],
+        [1.0, 1.0, -1.0],
+        [-1.0, -1.0, 1.0],
+        [1.0, -1.0, 1.0],
+        [-1.0, 1.0, 1.0],
+        [1.0, 1.0, 1.0],
+    ];
+    let mut min = Vector3::new(f32::INFINITY, f32::INFINITY, f32::INFINITY);
+    let mut max = Vector3::new(f32::NEG_INFINITY, f32::NEG_INFINITY, f32::NEG_INFINITY);
+    for c in &NDC_CORNERS {
+        let v = inv_vp * Vector4::new(c[0], c[1], c[2], 1.0);
+        if v.w.abs() < f32::EPSILON {
+            return None;
+        }
+        let inv_w = 1.0 / v.w;
+        let p = Vector3::new(v.x * inv_w, v.y * inv_w, v.z * inv_w);
+        if !(p.x.is_finite() && p.y.is_finite() && p.z.is_finite()) {
+            return None;
+        }
+        min.x = min.x.min(p.x);
+        min.y = min.y.min(p.y);
+        min.z = min.z.min(p.z);
+        max.x = max.x.max(p.x);
+        max.y = max.y.max(p.y);
+        max.z = max.z.max(p.z);
+    }
+    Some((min, max))
+}
+
 fn make_plane(a: f32, b: f32, c: f32, d: f32) -> Plane {
     Plane {
         normal: Vector3::new(a, b, c),
@@ -195,6 +244,42 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_frustum_world_aabb_encloses_visible_object() {
+        let proj = perspective(Deg(60.0), 16.0 / 9.0, 0.1, 200.0);
+        let view = Matrix4::look_at_rh(
+            Point3::new(0.0, 0.0, 5.0),
+            Point3::new(0.0, 0.0, 0.0),
+            Vector3::new(0.0, 1.0, 0.0),
+        );
+        let (min, max) = super::frustum_world_aabb(&view, &proj)
+            .expect("perspective frustum must be invertible");
+        // Camera at z=5 looking toward origin (-z). Far plane should be roughly
+        // at z = 5 - 200 = -195, near at z = 5 - 0.1 = 4.9.
+        assert!(
+            min.z <= -190.0 && max.z >= 4.0,
+            "frustum z range {:?}..{:?} should span near to far plane",
+            min.z,
+            max.z
+        );
+        // X/Y extent grows with distance; far plane half-extent at fov=60,
+        // aspect=16/9, far=200 is large.
+        assert!(
+            max.x.abs() > 10.0 && max.y.abs() > 10.0,
+            "frustum should be wide at far plane, got max=({},{},{})",
+            max.x,
+            max.y,
+            max.z
+        );
+    }
+
+    #[test]
+    fn test_frustum_world_aabb_returns_none_for_degenerate_projection() {
+        // Zero matrix is non-invertible; helper should bail out cleanly.
+        let zero = Matrix4::from_scale(0.0);
+        assert!(super::frustum_world_aabb(&zero, &zero).is_none());
+    }
+
     /// Regression test: objects with non-unit scale must have their bounding
     /// radius scaled correctly.
     #[test]
diff --git a/goud_engine/src/libs/graphics/renderer3d/mod.rs b/goud_engine/src/libs/graphics/renderer3d/mod.rs
index b99cb3ed8..e88150a8a 100644
--- a/goud_engine/src/libs/graphics/renderer3d/mod.rs
+++ b/goud_engine/src/libs/graphics/renderer3d/mod.rs
@@ -43,6 +43,8 @@ pub mod scene;
 mod shaders;
 mod shadow;
 mod skinned_mesh;
+mod spatial_index;
+mod stats;
 mod texture;
 mod types;
 
diff --git a/goud_engine/src/libs/graphics/renderer3d/render/mod.rs b/goud_engine/src/libs/graphics/renderer3d/render/mod.rs
index a0631529b..3efa9d101 100644
--- a/goud_engine/src/libs/graphics/renderer3d/render/mod.rs
+++ b/goud_engine/src/libs/graphics/renderer3d/render/mod.rs
@@ -5,7 +5,7 @@ mod skinned_render;
 mod util;
 
 use super::core::Renderer3D;
-use super::frustum::Frustum;
+use super::frustum::{frustum_world_aabb, Frustum};
 use super::shadow::build_directional_shadow_map;
 use super::texture::TextureManagerTrait;
 use crate::libs::graphics::backend::{
@@ -193,6 +193,45 @@ impl Renderer3D {
             None
         };
 
+        let use_spatial_index = self.config.spatial_index.enabled
+            && self.config.frustum_culling.enabled
+            && frustum.is_some();
+        // Refresh cell size if config changed since last frame.
+        if (self.spatial_index.cell_size() - self.config.spatial_index.cell_size).abs()
+            > f32::EPSILON
+        {
+            let new_size = self.config.spatial_index.cell_size;
+            self.spatial_index = super::spatial_index::SpatialIndex::new(new_size);
+            // Re-populate from current objects to keep the index in sync.
+            // Done here (not on every config write) so games that hot-tune
+            // cell size do not pay the cost on each setter call.
+            let object_state: Vec<(
+                u32,
+                cgmath::Vector3<f32>,
+                cgmath::Vector3<f32>,
+                f32,
+                cgmath::Vector3<f32>,
+            )> = self
+                .objects
+                .iter()
+                .map(|(&id, obj)| {
+                    (
+                        id,
+                        obj.position,
+                        obj.bounds.center,
+                        obj.bounds.radius,
+                        obj.scale,
+                    )
+                })
+                .collect();
+            for (id, position, b_center, b_radius, scale) in object_state {
+                let (min, max) = super::spatial_index::world_aabb_from_sphere(
+                    position, b_center, b_radius, scale,
+                );
+                self.spatial_index.insert(id, min, max);
+            }
+        }
+
         let skinned_obj_ids = &self.skinned_object_ids;
 
         self.stats.total_objects = self.objects.len() as u32;
@@ -217,7 +256,33 @@ impl Renderer3D {
         let default_color = self.config.default_material_color;
         let mut visible_draw_data: Vec<VisibleDrawData> = Vec::new();
         self.visible_object_ids.clear();
-        for (&id, obj) in &self.objects {
+
+        // Collect cull candidates: spatial-index pre-filter when enabled, else
+        // every registered object ID.
+        let mut candidates = std::mem::take(&mut self.scratch_cull_candidates);
+        candidates.clear();
+        let mut cells_visited: u32 = 0;
+        if use_spatial_index {
+            if let Some((aabb_min, aabb_max)) = frustum_world_aabb(&view, &projection) {
+                self.spatial_index.query_aabb(aabb_min, aabb_max, |id| {
+                    candidates.push(id);
+                });
+                cells_visited = self.spatial_index.last_query_visited_cells();
+            } else {
+                // Inverse VP failed (degenerate camera) -- fall back to a full
+                // scan for this frame so culling still produces correct output.
+                candidates.extend(self.objects.keys().copied());
+            }
+        } else {
+            candidates.extend(self.objects.keys().copied());
+        }
+        self.stats.spatial_index_candidates = candidates.len() as u32;
+        self.stats.spatial_index_cells_visited = cells_visited;
+
+        for &id in &candidates {
+            let Some(obj) = self.objects.get(&id) else {
+                continue;
+            };
             if skinned_obj_ids.contains(&id) {
                 continue;
             }
@@ -259,6 +324,8 @@ impl Renderer3D {
                 color,
             });
         }
+        // Return the scratch buffer for next-frame reuse.
+        self.scratch_cull_candidates = candidates;
 
         let material_sorting = self.config.batching.material_sorting_enabled;
         if material_sorting {
diff --git a/goud_engine/src/libs/graphics/renderer3d/spatial_index/mod.rs b/goud_engine/src/libs/graphics/renderer3d/spatial_index/mod.rs
new file mode 100644
index 000000000..ad7778bca
--- /dev/null
+++ b/goud_engine/src/libs/graphics/renderer3d/spatial_index/mod.rs
@@ -0,0 +1,335 @@
+//! Sparse uniform-grid spatial index for fast frustum culling of 3D scene objects.
+//!
+//! Each object is keyed by its world-space AABB. The grid is a sparse
+//! `FxHashMap<(i32,i32,i32), Vec<u32>>` so empty space costs nothing. Inserts,
+//! removes, and updates are O(cells touched) per object — for typical scene
+//! objects whose bounding sphere fits inside one cell, that is O(1) work.
+//!
+//! `query_aabb` enumerates the cells overlapping the queried AABB and yields
+//! every object ID found at least once, deduplicated via a per-query stamp so
+//! callers do not have to maintain their own seen-set.
+//!
+//! The index does not perform the per-object frustum-sphere test itself — that
+//! still lives in [`super::frustum::Frustum`]. Its job is to shrink the
+//! candidate set from the full scene-object registry (which can grow to ~55k
+//! sub-meshes on large maps) to only the objects whose grid cell touches the
+//! frustum AABB.
+//!
+//! See `goud_engine/tests/integration/scene_culling.rs` for the
+//! parity check against the linear-scan baseline and `benches/scene_culling.rs`
+//! for the 1k/10k/50k scaling benchmark.
+use cgmath::Vector3;
+use rustc_hash::FxHashMap;
+
+/// Default cell size in world units. Sized to cover typical small props
+/// (1–8 units) without forcing one object to span more than a 2×2×2 footprint
+/// while keeping cell count manageable for 200×200 maps.
+pub(in crate::libs::graphics::renderer3d) const DEFAULT_CELL_SIZE: f32 = 32.0;
+
+/// Cached cell-coord range for a single object so removals and updates do not
+/// have to re-derive the cell footprint from a stale AABB.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct CellRange {
+    min: (i32, i32, i32),
+    max: (i32, i32, i32),
+}
+
+/// Sparse uniform-grid spatial index over `u32` object IDs.
+#[derive(Debug)]
+pub(in crate::libs::graphics::renderer3d) struct SpatialIndex {
+    cell_size: f32,
+    inv_cell_size: f32,
+    cells: FxHashMap<(i32, i32, i32), Vec<u32>>,
+    object_ranges: FxHashMap<u32, CellRange>,
+    /// Per-object visit stamp for query dedup. Indexed by object ID; grown
+    /// lazily on first sight of an ID.
+    ///
+    /// Memory note: this `Vec` is keyed by raw `u32` object ID, so its size
+    /// tracks the renderer's monotonically increasing `next_object_id`. For
+    /// long-running sessions that churn through many millions of object
+    /// allocations the vec grows unboundedly. In practice the renderer skips
+    /// `0` and wraps at `u32::MAX`, so a worst-case session would need to
+    /// burn through ~2^32 object IDs before this becomes a real RAM hog.
+    /// Trimming on object removal is intentionally not done — clearing a
+    /// slot would require either re-stamping every live entry or tracking
+    /// an explicit free list, neither of which is worth the complexity.
+    query_stamp: Vec<u64>,
+    next_stamp: u64,
+    last_query_visited_cells: u32,
+    last_query_visited_candidates: u32,
+}
+
+// Diagnostic accessors and `clear`/`update` are exposed for tests and
+// integration callers. `update` is a thin alias around `insert` because
+// `insert` already overwrites stale cell entries when an ID is re-inserted.
+#[allow(dead_code)]
+impl SpatialIndex {
+    /// Construct a new empty index with the given cell size in world units.
+    /// `cell_size` is clamped to at least `0.5` to keep the grid coordinates
+    /// finite when callers accidentally pass `0.0`.
+    pub(in crate::libs::graphics::renderer3d) fn new(cell_size: f32) -> Self {
+        let cs = cell_size.max(0.5);
+        Self {
+            cell_size: cs,
+            inv_cell_size: 1.0 / cs,
+            cells: FxHashMap::default(),
+            object_ranges: FxHashMap::default(),
+            query_stamp: Vec::new(),
+            next_stamp: 0,
+            last_query_visited_cells: 0,
+            last_query_visited_candidates: 0,
+        }
+    }
+
+    pub(in crate::libs::graphics::renderer3d) fn cell_size(&self) -> f32 {
+        self.cell_size
+    }
+
+    pub(in crate::libs::graphics::renderer3d) fn cell_count(&self) -> usize {
+        self.cells.len()
+    }
+
+    pub(in crate::libs::graphics::renderer3d) fn object_count(&self) -> usize {
+        self.object_ranges.len()
+    }
+
+    /// Cell count visited by the most recent `query_aabb` call. Useful for
+    /// stats / instrumentation; resets at the start of every query.
+    pub(in crate::libs::graphics::renderer3d) fn last_query_visited_cells(&self) -> u32 {
+        self.last_query_visited_cells
+    }
+
+    /// Candidate object count visited by the most recent `query_aabb` call,
+    /// **after** dedup. This is the size of the set the caller iterates over.
+    pub(in crate::libs::graphics::renderer3d) fn last_query_visited_candidates(&self) -> u32 {
+        self.last_query_visited_candidates
+    }
+
+    /// Drop every entry. Equivalent to recreating the index with the same
+    /// cell size.
+    pub(in crate::libs::graphics::renderer3d) fn clear(&mut self) {
+        self.cells.clear();
+        self.object_ranges.clear();
+        // query_stamp can stay — it is keyed by ID and will be overwritten
+        // on the next stamped query. Resizing here would just churn allocs.
+        self.last_query_visited_cells = 0;
+        self.last_query_visited_candidates = 0;
+    }
+
+    fn aabb_to_cell_range(&self, world_min: Vector3<f32>, world_max: Vector3<f32>) -> CellRange {
+        let min = (
+            (world_min.x * self.inv_cell_size).floor() as i32,
+            (world_min.y * self.inv_cell_size).floor() as i32,
+            (world_min.z * self.inv_cell_size).floor() as i32,
+        );
+        let max = (
+            (world_max.x * self.inv_cell_size).floor() as i32,
+            (world_max.y * self.inv_cell_size).floor() as i32,
+            (world_max.z * self.inv_cell_size).floor() as i32,
+        );
+        CellRange { min, max }
+    }
+
+    fn add_to_cells(&mut self, id: u32, range: CellRange) {
+        for x in range.min.0..=range.max.0 {
+            for y in range.min.1..=range.max.1 {
+                for z in range.min.2..=range.max.2 {
+                    self.cells.entry((x, y, z)).or_default().push(id);
+                }
+            }
+        }
+    }
+
+    fn remove_from_cells(&mut self, id: u32, range: CellRange) {
+        for x in range.min.0..=range.max.0 {
+            for y in range.min.1..=range.max.1 {
+                for z in range.min.2..=range.max.2 {
+                    let key = (x, y, z);
+                    if let Some(bucket) = self.cells.get_mut(&key) {
+                        if let Some(pos) = bucket.iter().position(|&i| i == id) {
+                            bucket.swap_remove(pos);
+                        }
+                        if bucket.is_empty() {
+                            self.cells.remove(&key);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /// Insert (or re-insert) `id` with the given world-space AABB. If the
+    /// object was already present, its old entries are removed first.
+    pub(in crate::libs::graphics::renderer3d) fn insert(
+        &mut self,
+        id: u32,
+        world_min: Vector3<f32>,
+        world_max: Vector3<f32>,
+    ) {
+        let new_range = self.aabb_to_cell_range(world_min, world_max);
+        if let Some(old_range) = self.object_ranges.insert(id, new_range) {
+            if old_range == new_range {
+                // Already in the right cells — bail out before we double-add.
+                return;
+            }
+            self.remove_from_cells(id, old_range);
+        }
+        self.add_to_cells(id, new_range);
+    }
+
+    /// Update `id` to a new world-space AABB. Falls back to `insert` when the
+    /// object is not yet tracked.
+    pub(in crate::libs::graphics::renderer3d) fn update(
+        &mut self,
+        id: u32,
+        world_min: Vector3<f32>,
+        world_max: Vector3<f32>,
+    ) {
+        self.insert(id, world_min, world_max);
+    }
+
+    /// Remove `id` and all of its cell entries. Returns `true` when the entry
+    /// existed.
+    pub(in crate::libs::graphics::renderer3d) fn remove(&mut self, id: u32) -> bool {
+        if let Some(range) = self.object_ranges.remove(&id) {
+            self.remove_from_cells(id, range);
+            true
+        } else {
+            false
+        }
+    }
+
+    /// Visit every object whose stored AABB cell-range overlaps the queried
+    /// AABB. Each object is visited at most once per call.
+    ///
+    /// Two iteration strategies, picked per-call:
+    /// * **AABB cell sweep** when the queried cell range is small relative to
+    ///   the index's occupied cell count — typical for tight queries.
+    /// * **Occupied-cell scan** when the queried cell range is much larger
+    ///   than the populated grid — typical when the far plane stretches well
+    ///   past the actual scene extent. Walking the populated cells avoids
+    ///   spending time on empty space the camera could in principle see but
+    ///   that has no objects in it.
+    pub(in crate::libs::graphics::renderer3d) fn query_aabb<F>(
+        &mut self,
+        world_min: Vector3<f32>,
+        world_max: Vector3<f32>,
+        mut visit: F,
+    ) where
+        F: FnMut(u32),
+    {
+        // Use a fresh stamp every query; on wrap-around just clear the stamp
+        // table so old marks cannot collide with the new one.
+        self.next_stamp = self.next_stamp.wrapping_add(1);
+        if self.next_stamp == 0 {
+            for slot in self.query_stamp.iter_mut() {
+                *slot = 0;
+            }
+            self.next_stamp = 1;
+        }
+        let stamp = self.next_stamp;
+        let range = self.aabb_to_cell_range(world_min, world_max);
+        let mut visited_cells: u32 = 0;
+        let mut visited_candidates: u32 = 0;
+
+        // Estimate cell-sweep cost as the AABB cell-range product. Saturating
+        // arithmetic keeps a giant query (e.g. far plane >> scene extent) from
+        // overflowing into a misleadingly small `usize`.
+        let dx = (range.max.0 as i64 - range.min.0 as i64 + 1).max(0) as u64;
+        let dy = (range.max.1 as i64 - range.min.1 as i64 + 1).max(0) as u64;
+        let dz = (range.max.2 as i64 - range.min.2 as i64 + 1).max(0) as u64;
+        let sweep_cost = dx.saturating_mul(dy).saturating_mul(dz);
+        let occupied = self.cells.len() as u64;
+
+        if sweep_cost <= occupied.saturating_mul(2) {
+            // AABB sweep: cheap when the AABB only touches a handful of cells.
+            for x in range.min.0..=range.max.0 {
+                for y in range.min.1..=range.max.1 {
+                    for z in range.min.2..=range.max.2 {
+                        let key = (x, y, z);
+                        let Some(bucket) = self.cells.get(&key) else {
+                            continue;
+                        };
+                        visited_cells = visited_cells.saturating_add(1);
+                        Self::visit_bucket(
+                            bucket,
+                            stamp,
+                            &mut self.query_stamp,
+                            &mut visited_candidates,
+                            &mut visit,
+                        );
+                    }
+                }
+            }
+        } else {
+            // Occupied-cell scan: cheaper when the AABB straddles many empty
+            // cells (far plane >> scene extent).
+            for (cell_key, bucket) in &self.cells {
+                if cell_key.0 < range.min.0
+                    || cell_key.0 > range.max.0
+                    || cell_key.1 < range.min.1
+                    || cell_key.1 > range.max.1
+                    || cell_key.2 < range.min.2
+                    || cell_key.2 > range.max.2
+                {
+                    continue;
+                }
+                visited_cells = visited_cells.saturating_add(1);
+                Self::visit_bucket(
+                    bucket,
+                    stamp,
+                    &mut self.query_stamp,
+                    &mut visited_candidates,
+                    &mut visit,
+                );
+            }
+        }
+        self.last_query_visited_cells = visited_cells;
+        self.last_query_visited_candidates = visited_candidates;
+    }
+
+    fn visit_bucket<F>(
+        bucket: &[u32],
+        stamp: u64,
+        query_stamp: &mut Vec<u64>,
+        visited_candidates: &mut u32,
+        visit: &mut F,
+    ) where
+        F: FnMut(u32),
+    {
+        for &id in bucket {
+            let idx = id as usize;
+            if idx >= query_stamp.len() {
+                query_stamp.resize(idx + 1, 0);
+            }
+            if query_stamp[idx] != stamp {
+                query_stamp[idx] = stamp;
+                *visited_candidates = visited_candidates.saturating_add(1);
+                visit(id);
+            }
+        }
+    }
+}
+
+/// Convenience: derive a tight world-space AABB from a local-space bounding
+/// sphere `(center, radius)` plus a world transform `(position, scale)`.
+/// Conservative: ignores rotation by extending by the scaled radius on every
+/// axis, which is correct for sphere-style bounds but slightly loose for
+/// non-uniform scale.
+pub(in crate::libs::graphics::renderer3d) fn world_aabb_from_sphere(
+    position: Vector3<f32>,
+    bounds_center: Vector3<f32>,
+    bounds_radius: f32,
+    scale: Vector3<f32>,
+) -> (Vector3<f32>, Vector3<f32>) {
+    let max_scale = scale.x.abs().max(scale.y.abs()).max(scale.z.abs());
+    let world_center = position + bounds_center;
+    let r = bounds_radius * max_scale;
+    (
+        Vector3::new(world_center.x - r, world_center.y - r, world_center.z - r),
+        Vector3::new(world_center.x + r, world_center.y + r, world_center.z + r),
+    )
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/goud_engine/src/libs/graphics/renderer3d/spatial_index/tests.rs b/goud_engine/src/libs/graphics/renderer3d/spatial_index/tests.rs
new file mode 100644
index 000000000..45e161784
--- /dev/null
+++ b/goud_engine/src/libs/graphics/renderer3d/spatial_index/tests.rs
@@ -0,0 +1,243 @@
+use super::*;
+use cgmath::Vector3;
+
+fn collect(idx: &mut SpatialIndex, min: Vector3<f32>, max: Vector3<f32>) -> Vec<u32> {
+    let mut out = Vec::new();
+    idx.query_aabb(min, max, |id| out.push(id));
+    out.sort_unstable();
+    out
+}
+
+#[test]
+fn empty_index_yields_no_candidates() {
+    let mut idx = SpatialIndex::new(16.0);
+    let got = collect(
+        &mut idx,
+        Vector3::new(-100.0, -100.0, -100.0),
+        Vector3::new(100.0, 100.0, 100.0),
+    );
+    assert!(got.is_empty());
+    assert_eq!(idx.last_query_visited_cells(), 0);
+    assert_eq!(idx.last_query_visited_candidates(), 0);
+}
+
+#[test]
+fn insert_then_query_returns_object() {
+    let mut idx = SpatialIndex::new(16.0);
+    idx.insert(7, Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 2.0, 2.0));
+    let got = collect(
+        &mut idx,
+        Vector3::new(0.0, 0.0, 0.0),
+        Vector3::new(8.0, 8.0, 8.0),
+    );
+    assert_eq!(got, vec![7]);
+    assert_eq!(idx.last_query_visited_candidates(), 1);
+}
+
+#[test]
+fn query_outside_skips_object() {
+    let mut idx = SpatialIndex::new(16.0);
+    idx.insert(7, Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 2.0, 2.0));
+    let got = collect(
+        &mut idx,
+        Vector3::new(100.0, 100.0, 100.0),
+        Vector3::new(120.0, 120.0, 120.0),
+    );
+    assert!(got.is_empty());
+    assert_eq!(idx.last_query_visited_cells(), 0);
+}
+
+#[test]
+fn object_spanning_cells_dedupes_to_one_visit() {
+    let mut idx = SpatialIndex::new(8.0);
+    // AABB straddles four cells in the XY plane: (0,0,0), (1,0,0),
+    // (0,1,0), (1,1,0).
+    idx.insert(42, Vector3::new(7.0, 7.0, 0.5), Vector3::new(9.0, 9.0, 0.5));
+    let got = collect(
+        &mut idx,
+        Vector3::new(0.0, 0.0, 0.0),
+        Vector3::new(20.0, 20.0, 1.0),
+    );
+    assert_eq!(got, vec![42]);
+    assert_eq!(idx.last_query_visited_candidates(), 1);
+    assert!(
+        idx.last_query_visited_cells() >= 4,
+        "expected at least 4 cells visited, got {}",
+        idx.last_query_visited_cells()
+    );
+}
+
+#[test]
+fn update_moves_object_between_cells() {
+    let mut idx = SpatialIndex::new(16.0);
+    idx.insert(7, Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 2.0, 2.0));
+    idx.update(
+        7,
+        Vector3::new(100.0, 100.0, 100.0),
+        Vector3::new(101.0, 101.0, 101.0),
+    );
+    // Old location should yield nothing.
+    assert!(collect(
+        &mut idx,
+        Vector3::new(0.0, 0.0, 0.0),
+        Vector3::new(8.0, 8.0, 8.0)
+    )
+    .is_empty());
+    // New location should yield the object.
+    assert_eq!(
+        collect(
+            &mut idx,
+            Vector3::new(99.0, 99.0, 99.0),
+            Vector3::new(110.0, 110.0, 110.0)
+        ),
+        vec![7]
+    );
+}
+
+#[test]
+fn remove_drops_object_from_all_cells() {
+    let mut idx = SpatialIndex::new(8.0);
+    idx.insert(42, Vector3::new(7.0, 7.0, 0.5), Vector3::new(9.0, 9.0, 0.5));
+    assert!(idx.remove(42));
+    assert_eq!(idx.object_count(), 0);
+    assert_eq!(idx.cell_count(), 0);
+    let got = collect(
+        &mut idx,
+        Vector3::new(0.0, 0.0, 0.0),
+        Vector3::new(20.0, 20.0, 1.0),
+    );
+    assert!(got.is_empty());
+}
+
+#[test]
+fn remove_missing_id_returns_false() {
+    let mut idx = SpatialIndex::new(16.0);
+    assert!(!idx.remove(99));
+}
+
+#[test]
+fn many_objects_in_one_cell_survive_partial_removal() {
+    let mut idx = SpatialIndex::new(16.0);
+    for id in 0..32 {
+        idx.insert(id, Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 2.0, 2.0));
+    }
+    // Remove evens.
+    for id in (0..32).step_by(2) {
+        assert!(idx.remove(id));
+    }
+    let got = collect(
+        &mut idx,
+        Vector3::new(0.0, 0.0, 0.0),
+        Vector3::new(8.0, 8.0, 8.0),
+    );
+    let expected: Vec<u32> = (1..32).step_by(2).collect();
+    assert_eq!(got, expected);
+}
+
+#[test]
+fn reinsert_with_same_aabb_is_idempotent() {
+    let mut idx = SpatialIndex::new(16.0);
+    idx.insert(5, Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 2.0, 2.0));
+    idx.insert(5, Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 2.0, 2.0));
+    let got = collect(
+        &mut idx,
+        Vector3::new(0.0, 0.0, 0.0),
+        Vector3::new(8.0, 8.0, 8.0),
+    );
+    assert_eq!(got, vec![5]);
+    assert_eq!(idx.object_count(), 1);
+}
+
+#[test]
+fn world_aabb_from_sphere_handles_scale() {
+    let (min, max) = world_aabb_from_sphere(
+        Vector3::new(10.0, 0.0, 0.0),
+        Vector3::new(0.0, 1.0, 0.0),
+        2.0,
+        Vector3::new(3.0, 1.0, 1.0),
+    );
+    // World center is (10, 1, 0); scaled radius is 2 * max(3,1,1) = 6.
+    assert!((min.x - 4.0).abs() < f32::EPSILON);
+    assert!((max.x - 16.0).abs() < f32::EPSILON);
+    assert!((min.y - (-5.0)).abs() < f32::EPSILON);
+    assert!((max.y - 7.0).abs() < f32::EPSILON);
+}
+
+#[test]
+fn clear_drops_everything_but_keeps_cell_size() {
+    let mut idx = SpatialIndex::new(16.0);
+    idx.insert(1, Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 1.0, 1.0));
+    idx.clear();
+    assert_eq!(idx.object_count(), 0);
+    assert_eq!(idx.cell_count(), 0);
+    assert!((idx.cell_size() - 16.0).abs() < f32::EPSILON);
+}
+
+#[test]
+fn negative_world_coords_route_to_negative_cells() {
+    let mut idx = SpatialIndex::new(8.0);
+    idx.insert(
+        1,
+        Vector3::new(-9.0, -9.0, -9.0),
+        Vector3::new(-1.0, -1.0, -1.0),
+    );
+    let got = collect(
+        &mut idx,
+        Vector3::new(-16.0, -16.0, -16.0),
+        Vector3::new(0.0, 0.0, 0.0),
+    );
+    assert_eq!(got, vec![1]);
+}
+
+#[test]
+fn stamp_wraparound_preserves_correctness() {
+    let mut idx = SpatialIndex::new(16.0);
+    idx.insert(3, Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 2.0, 2.0));
+    // Force the stamp counter to wrap.
+    idx.next_stamp = u64::MAX - 1;
+    for _ in 0..4 {
+        let got = collect(
+            &mut idx,
+            Vector3::new(0.0, 0.0, 0.0),
+            Vector3::new(8.0, 8.0, 8.0),
+        );
+        assert_eq!(got, vec![3]);
+    }
+}
+
+#[test]
+fn cell_size_floor_clamp_protects_against_zero() {
+    let idx = SpatialIndex::new(0.0);
+    assert!(idx.cell_size() >= 0.5);
+}
+
+/// Forces the `query_aabb` occupied-cell-scan branch by populating just a
+/// handful of cells in a tiny region but querying a huge AABB whose cell
+/// sweep would cost orders of magnitude more lookups than the populated
+/// cell count. The query must still report exactly the populated objects
+/// and the visited-cells stat must not exceed the populated cell count.
+#[test]
+fn occupied_cell_scan_used_for_huge_aabb() {
+    let mut idx = SpatialIndex::new(8.0);
+    // Populate a small cluster: three objects in a few cells at ~origin.
+    idx.insert(1, Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 1.0, 1.0));
+    idx.insert(2, Vector3::new(8.0, 0.0, 0.0), Vector3::new(9.0, 1.0, 1.0));
+    idx.insert(3, Vector3::new(0.0, 8.0, 0.0), Vector3::new(1.0, 9.0, 1.0));
+    let occupied = idx.cell_count() as u32;
+
+    // Query a far-plane-sized AABB; sweep cost would be ~(20000/8)^3
+    // > 10^10, way more than 3 occupied cells, so the implementation
+    // must switch to occupied-cell scan.
+    let got = collect(
+        &mut idx,
+        Vector3::new(-10000.0, -10000.0, -10000.0),
+        Vector3::new(10000.0, 10000.0, 10000.0),
+    );
+    assert_eq!(got, vec![1, 2, 3]);
+    assert!(
+        idx.last_query_visited_cells() <= occupied,
+        "occupied-cell scan should not visit more than {} cells, got {}",
+        occupied,
+        idx.last_query_visited_cells()
+    );
+}
diff --git a/goud_engine/src/libs/graphics/renderer3d/stats.rs b/goud_engine/src/libs/graphics/renderer3d/stats.rs
new file mode 100644
index 000000000..48bf2d180
--- /dev/null
+++ b/goud_engine/src/libs/graphics/renderer3d/stats.rs
@@ -0,0 +1,46 @@
+//! Per-frame renderer statistics.
+//!
+//! Split out of [`super::types`] so the file-size budget for `types.rs`
+//! stays under the repo's per-file line limit. Re-exported from `types.rs`
+//! for backward compatibility with the existing public API path.
+
+/// Last-frame renderer statistics exposed for tests and debugging.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct Renderer3DStats {
+    /// Total draw calls recorded by the renderer this frame.
+    pub draw_calls: u32,
+    /// Instanced draw calls recorded this frame.
+    pub instanced_draw_calls: u32,
+    /// Particle instanced draw calls recorded this frame.
+    pub particle_draw_calls: u32,
+    /// Number of instance records submitted this frame.
+    pub active_instances: u32,
+    /// Number of live particles submitted this frame.
+    pub active_particles: u32,
+    /// Total objects in the scene (before culling).
+    pub total_objects: u32,
+    /// Objects that passed frustum culling and were drawn.
+    pub visible_objects: u32,
+    /// Objects culled by frustum test.
+    pub culled_objects: u32,
+    /// Number of material/shader state switches this frame.
+    pub material_switches: u32,
+    /// Number of texture bind operations this frame.
+    pub texture_binds: u32,
+    /// Number of skinned mesh instances rendered this frame.
+    pub skinned_instances: u32,
+    /// Number of bone matrix uploads this frame.
+    pub bone_matrix_uploads: u32,
+    /// Number of animation evaluations this frame.
+    pub animation_evaluations: u32,
+    /// Number of animation evaluations saved (cache hits / LOD skips) this frame.
+    pub animation_evaluations_saved: u32,
+    /// Number of objects that survived the spatial-index pre-filter and were
+    /// fed into the frustum sphere test this frame. Equals `total_objects`
+    /// when the spatial index is disabled.
+    pub spatial_index_candidates: u32,
+    /// Number of grid cells visited by the spatial index this frame.
+    /// Useful for tuning [`crate::libs::graphics::renderer3d::Render3DConfig`]
+    /// `spatial_index.cell_size` against the active scene.
+    pub spatial_index_cells_visited: u32,
+}
diff --git a/goud_engine/src/libs/graphics/renderer3d/tests.rs b/goud_engine/src/libs/graphics/renderer3d/tests/mod.rs
similarity index 98%
rename from goud_engine/src/libs/graphics/renderer3d/tests.rs
rename to goud_engine/src/libs/graphics/renderer3d/tests/mod.rs
index bdf99219b..22f41c17f 100644
--- a/goud_engine/src/libs/graphics/renderer3d/tests.rs
+++ b/goud_engine/src/libs/graphics/renderer3d/tests/mod.rs
@@ -413,3 +413,8 @@ fn test_static_primitive_renders_via_batch() {
         "static object should not appear in dynamic pass"
     );
 }
+
+// #678: BeginFrame/EndFrame scaling with total scene-object count. Scaling
+// + parity coverage lives in its own submodule so the renderer3d test file
+// stays under the repo's per-file line limit.
+mod scene_culling_678;
diff --git a/goud_engine/src/libs/graphics/renderer3d/tests/scene_culling_678.rs b/goud_engine/src/libs/graphics/renderer3d/tests/scene_culling_678.rs
new file mode 100644
index 000000000..1d79b8bad
--- /dev/null
+++ b/goud_engine/src/libs/graphics/renderer3d/tests/scene_culling_678.rs
@@ -0,0 +1,233 @@
+use super::*;
+use crate::libs::graphics::renderer3d::config::SpatialIndexConfig;
+
+fn populate_grid(renderer: &mut Renderer3D, side: i32, spacing: f32) -> Vec<u32> {
+    let mut ids = Vec::with_capacity((side as usize).pow(2));
+    for x in 0..side {
+        for z in 0..side {
+            let id = renderer.create_primitive(PrimitiveCreateInfo {
+                primitive_type: PrimitiveType::Cube,
+                width: 1.0,
+                height: 1.0,
+                depth: 1.0,
+                segments: 1,
+                texture_id: 0,
+            });
+            assert_ne!(id, 0);
+            renderer.set_object_position(id, x as f32 * spacing, 0.0, z as f32 * spacing);
+            ids.push(id);
+        }
+    }
+    ids
+}
+
+fn aim_camera_at_origin(renderer: &mut Renderer3D) {
+    // Camera at (5, 5, 5) looking at origin: a small visible patch covers
+    // only the first few cells of the populated grid.
+    renderer.set_camera_position(5.0, 5.0, 5.0);
+    renderer.set_camera_rotation(-30.0, -135.0, 0.0);
+}
+
+fn collect_candidate_ratio(renderer: &mut Renderer3D) -> (u32, u32) {
+    renderer.render(None);
+    let stats = renderer.stats();
+    (stats.spatial_index_candidates, stats.total_objects)
+}
+
+#[test]
+fn spatial_index_shrinks_candidate_set_at_1k_objects() {
+    let mut renderer = make_renderer();
+    let _ids = populate_grid(&mut renderer, 32, 4.0); // 1024 objects.
+    aim_camera_at_origin(&mut renderer);
+    let (candidates, total) = collect_candidate_ratio(&mut renderer);
+    assert_eq!(total, 1024);
+    assert!(
+        candidates < total / 2,
+        "expected spatial index to halve the candidate set at 1k objects, \
+         got {candidates}/{total}"
+    );
+}
+
+#[test]
+fn spatial_index_stays_sublinear_at_10k_objects() {
+    let mut renderer = make_renderer();
+    let _ids = populate_grid(&mut renderer, 100, 4.0); // 10_000 objects.
+    aim_camera_at_origin(&mut renderer);
+    let (candidates, total) = collect_candidate_ratio(&mut renderer);
+    assert_eq!(total, 10_000);
+    // 10k objects across a 400x400 patch with the camera looking at a
+    // narrow region near the origin: <10% of the scene should make it
+    // through the spatial-index pre-filter.
+    assert!(
+        candidates * 10 < total,
+        "expected <10% candidate ratio at 10k, got {candidates}/{total}"
+    );
+    assert!(
+        renderer.stats().spatial_index_cells_visited > 0,
+        "spatial index must report at least one visited cell"
+    );
+}
+
+#[test]
+fn spatial_index_stays_sublinear_at_30k_objects() {
+    let mut renderer = make_renderer();
+    let _ids = populate_grid(&mut renderer, 174, 4.0); // 30_276 objects.
+    aim_camera_at_origin(&mut renderer);
+    let (candidates, total) = collect_candidate_ratio(&mut renderer);
+    assert_eq!(total, 30_276);
+    assert!(
+        candidates * 10 < total,
+        "expected <10% candidate ratio at 30k, got {candidates}/{total}"
+    );
+}
+
+#[test]
+fn spatial_index_stays_sublinear_at_50k_objects() {
+    let mut renderer = make_renderer();
+    let _ids = populate_grid(&mut renderer, 224, 4.0); // 50_176 objects.
+    aim_camera_at_origin(&mut renderer);
+    let (candidates, total) = collect_candidate_ratio(&mut renderer);
+    assert_eq!(total, 50_176);
+    // The candidate set must not scale linearly with the total. We
+    // require the pre-filter to deliver <5% of the registry.
+    assert!(
+        candidates * 20 < total,
+        "expected <5% candidate ratio at 50k, got {candidates}/{total}"
+    );
+}
+
+#[test]
+fn spatial_index_disabled_falls_back_to_full_scan() {
+    let mut renderer = make_renderer();
+    let _ids = populate_grid(&mut renderer, 32, 4.0); // 1024 objects.
+    aim_camera_at_origin(&mut renderer);
+
+    let mut config = renderer.render_config().clone();
+    config.spatial_index = SpatialIndexConfig {
+        enabled: false,
+        cell_size: config.spatial_index.cell_size,
+    };
+    renderer.set_render_config(config);
+
+    renderer.render(None);
+    let stats = renderer.stats();
+    // When the index is disabled, the pre-filter is a no-op so every
+    // object is a candidate.
+    assert_eq!(stats.total_objects, 1024);
+    assert_eq!(stats.spatial_index_candidates, 1024);
+    assert_eq!(stats.spatial_index_cells_visited, 0);
+}
+
+#[test]
+fn spatial_index_visible_count_matches_linear_scan() {
+    // Parity check: enabling the spatial index must not change which
+    // objects survive the frustum sphere test compared to the legacy
+    // linear scan — the index is a *pre-filter*, not a replacement.
+    let make_scene = || {
+        let mut r = make_renderer();
+        populate_grid(&mut r, 24, 4.0); // 576 objects across 92x92 units.
+        aim_camera_at_origin(&mut r);
+        r
+    };
+
+    let mut spatial = make_scene();
+    spatial.render(None);
+    let spatial_visible = spatial.stats().visible_objects;
+
+    let mut linear = make_scene();
+    let mut config = linear.render_config().clone();
+    config.spatial_index.enabled = false;
+    linear.set_render_config(config);
+    linear.render(None);
+    let linear_visible = linear.stats().visible_objects;
+
+    assert_eq!(
+        spatial_visible, linear_visible,
+        "spatial-indexed visible count {spatial_visible} != linear-scan visible count {linear_visible}"
+    );
+}
+
+#[test]
+fn spatial_index_tracks_object_movement() {
+    // Move an object out of view, render, move it back, render. The
+    // spatial index must keep its cell membership in sync so a moved
+    // object that re-enters the frustum is rendered again.
+    let mut renderer = make_renderer();
+    let id = renderer.create_primitive(PrimitiveCreateInfo {
+        primitive_type: PrimitiveType::Cube,
+        width: 1.0,
+        height: 1.0,
+        depth: 1.0,
+        segments: 1,
+        texture_id: 0,
+    });
+    // Camera at (0,0,-5) with yaw=0 looks down +Z, putting the origin in
+    // front of the camera.
+    renderer.set_camera_position(0.0, 0.0, -5.0);
+    renderer.set_camera_rotation(0.0, 0.0, 0.0);
+
+    renderer.render(None);
+    assert_eq!(
+        renderer.stats().visible_objects,
+        1,
+        "object at origin should be visible from camera at (0,0,-5) facing +Z"
+    );
+
+    // Move object far behind the camera.
+    assert!(renderer.set_object_position(id, 0.0, 0.0, -500.0));
+    renderer.render(None);
+    assert_eq!(
+        renderer.stats().visible_objects,
+        0,
+        "object behind camera should be culled after move"
+    );
+
+    // Move back into view.
+    assert!(renderer.set_object_position(id, 0.0, 0.0, 0.0));
+    renderer.render(None);
+    assert_eq!(
+        renderer.stats().visible_objects,
+        1,
+        "object should be visible again after move-back"
+    );
+}
+
+#[test]
+fn spatial_index_tracks_object_scale_growth() {
+    // Place a small object far enough off to one side that its tight
+    // bounding sphere never reaches the frustum, then scale it up so the
+    // sphere swells into view. The spatial index must refresh on the
+    // scale change so the now-overlapping object becomes a candidate.
+    let mut renderer = make_renderer();
+    let id = renderer.create_primitive(PrimitiveCreateInfo {
+        primitive_type: PrimitiveType::Cube,
+        width: 0.5,
+        height: 0.5,
+        depth: 0.5,
+        segments: 1,
+        texture_id: 0,
+    });
+    // Camera at origin looking down +Z; object at (0, 0, 80) is in front.
+    renderer.set_camera_position(0.0, 0.0, -5.0);
+    renderer.set_camera_rotation(0.0, 0.0, 0.0);
+    // Park the object far out to the side at +X so a unit-scale bounding
+    // sphere does not intersect the camera's central frustum.
+    assert!(renderer.set_object_position(id, 200.0, 0.0, 50.0));
+
+    renderer.render(None);
+    assert_eq!(
+        renderer.stats().visible_objects,
+        0,
+        "tiny far-side object should be culled at unit scale"
+    );
+
+    // Scale it up so its world-space sphere swells through the frustum.
+    assert!(renderer.set_object_scale(id, 800.0, 800.0, 800.0));
+    renderer.render(None);
+    assert_eq!(
+        renderer.stats().visible_objects,
+        1,
+        "scaled-up object should be picked up by the spatial index after \
+         the scale change refreshes its cell membership"
+    );
+}
diff --git a/goud_engine/src/libs/graphics/renderer3d/types.rs b/goud_engine/src/libs/graphics/renderer3d/types.rs
index 33e5691bb..2f561b8f4 100644
--- a/goud_engine/src/libs/graphics/renderer3d/types.rs
+++ b/goud_engine/src/libs/graphics/renderer3d/types.rs
@@ -146,38 +146,9 @@ impl Default for ParticleEmitterConfig {
     }
 }
 
-/// Last-frame renderer statistics exposed for tests and debugging.
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
-pub struct Renderer3DStats {
-    /// Total draw calls recorded by the renderer this frame.
-    pub draw_calls: u32,
-    /// Instanced draw calls recorded this frame.
-    pub instanced_draw_calls: u32,
-    /// Particle instanced draw calls recorded this frame.
-    pub particle_draw_calls: u32,
-    /// Number of instance records submitted this frame.
-    pub active_instances: u32,
-    /// Number of live particles submitted this frame.
-    pub active_particles: u32,
-    /// Total objects in the scene (before culling).
-    pub total_objects: u32,
-    /// Objects that passed frustum culling and were drawn.
-    pub visible_objects: u32,
-    /// Objects culled by frustum test.
-    pub culled_objects: u32,
-    /// Number of material/shader state switches this frame.
-    pub material_switches: u32,
-    /// Number of texture bind operations this frame.
-    pub texture_binds: u32,
-    /// Number of skinned mesh instances rendered this frame.
-    pub skinned_instances: u32,
-    /// Number of bone matrix uploads this frame.
-    pub bone_matrix_uploads: u32,
-    /// Number of animation evaluations this frame.
-    pub animation_evaluations: u32,
-    /// Number of animation evaluations saved (cache hits / LOD skips) this frame.
-    pub animation_evaluations_saved: u32,
-}
+// `Renderer3DStats` lives in `super::stats` so that file stays under the
+// repo's per-file line limit; re-exported here for backward compatibility.
+pub use super::stats::Renderer3DStats;
 
 /// Local-space bounding sphere for frustum culling.
 #[derive(Debug, Clone, Copy)]