diff --git a/Cargo.toml b/Cargo.toml
index daee6fd..52191c7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,4 +14,6 @@ bevy_flycam = "*"
 rand = "*"
 noise = "0.9"
 bevy_meshem = { git = "https://github.com/TheFelidae/Meshem.git" }
-rayon = "1.5.1"
\ No newline at end of file
+rayon = "1.5.1"
+bevy_egui = "0.31.1"
+egui = "*"
\ No newline at end of file
diff --git a/src/client/mod.rs b/src/client/mod.rs
index 5afdbe6..10ac5fa 100644
--- a/src/client/mod.rs
+++ b/src/client/mod.rs
@@ -6,6 +6,7 @@ use bevy::{
     text::TextFont,
     DefaultPlugins,
 };
+use bevy_egui::EguiPlugin;
 use bevy_flycam::PlayerPlugin;
 use bevy_meshem::prelude::{generate_voxel_mesh, Face::Top};
 
@@ -42,8 +43,9 @@ impl Runtime {
         };
         app.insert_resource(block_registry);
 
-        app.add_plugins(FpsOverlayPlugin::default());
+        //   app.add_plugins(FpsOverlayPlugin::default());
         app.add_plugins(renderer::WorldRenderer::default());
+        app.add_plugins(EguiPlugin);
         app.add_systems(Startup, systems::startup::setup_camera);
         app.add_systems(Startup, systems::test_scene::register);
         app.add_systems(Startup, systems::test_scene::setup);
diff --git a/src/client/renderer/mod.rs b/src/client/renderer/mod.rs
index b8d1b33..dda8751 100644
--- a/src/client/renderer/mod.rs
+++ b/src/client/renderer/mod.rs
@@ -1,3 +1,5 @@
+use std::sync::{Mutex, RwLock};
+
 use bevy::{
     app::{App, Plugin, Startup, Update},
     asset::{AssetServer, Assets, Handle},
@@ -5,8 +7,8 @@ use bevy::{
     math::Vec3,
     pbr::{MeshMaterial3d, StandardMaterial},
     prelude::{
-        AlphaMode, Camera3d, Commands, Component, Entity, EventWriter, Mesh, Mesh3d, Query, Res,
-        ResMut, Transform, With,
+        AlphaMode, Camera3d, Commands, Component, Entity, EventReader, EventWriter, Mesh, Mesh3d,
+        Query, Res, ResMut, Transform, With,
     },
 };
 use bevy_meshem::{
@@ -17,12 +19,13 @@ use bevy_meshem::{
     },
     Dimensions, VoxelRegistry,
 };
+use rayon::iter::{IntoParallelIterator, ParallelIterator};
 
 use crate::{
     data::world::{World, WorldChunk, WorldChunkStatus, WorldChunkStorage},
     game::{
         registry::BlockRegistry,
-        world_generator::{GameWorld, GenerateWorldSignal},
+        world_generator::{ChunkDroppedEvent, ChunkGeneratedEvent, GameWorld, GenerateWorldSignal},
     },
 };
 
@@ -56,6 +59,7 @@ impl Plugin for WorldRenderer {
     fn build(&self, app: &mut App) {
         app.add_systems(Startup, sys_setup);
         app.add_systems(Update, sys_update);
+        app.add_systems(Update, sys_on_chunk_generated);
     }
 }
 
@@ -101,7 +105,7 @@ fn sys_update(
     world: Query<&GameWorld>,
     mut request_world: EventWriter<GenerateWorldSignal>,
 ) {
-    let mut renderer = renderer.single_mut();
+    /*let mut renderer = renderer.single_mut();
     let world = world.single();
     let block_registry = block_registry.into_inner();
     let camera_translation = camera.single().1.translation;
@@ -112,9 +116,9 @@ fn sys_update(
 
     // Identify chunks out of render distance (plus 2 for buffer), and remove them
     for mut chunk in render_chunks.iter_mut() {
-        if (chunk.1.position.0 - camera_grid_x).abs() > renderer.render_distance + 2
-            || (chunk.1.position.1 - camera_grid_y).abs() > renderer.render_distance + 2
-            || (chunk.1.position.2 - camera_grid_z).abs() > renderer.render_distance + 2
+        if (chunk.1.position.0 - camera_grid_x).abs() > renderer.render_distance + 16
+            || (chunk.1.position.1 - camera_grid_y).abs() > renderer.render_distance + 16
+            || (chunk.1.position.2 - camera_grid_z).abs() > renderer.render_distance + 16
         {
             commands.entity(chunk.0).despawn();
             // Remove chunk from renderer
@@ -122,19 +126,26 @@ fn sys_update(
         }
     }
 
+    let render_chunks = RwLock::new(render_chunks.iter_mut().collect::<Vec<_>>());
+    let meshes = RwLock::new(&mut meshes);
+    let commands = RwLock::new(&mut commands);
     // Identify chunks that should be loaded in by x y z
-    for x in camera_grid_x - renderer.render_distance..camera_grid_x + renderer.render_distance {
-        for y in camera_grid_y - renderer.render_distance..camera_grid_y + renderer.render_distance
-        {
+    let par_iter = (-renderer.render_distance..renderer.render_distance).into_par_iter();
+    par_iter.for_each(|x| {
+        let par_iter = (-renderer.render_distance..renderer.render_distance).into_par_iter();
+        par_iter.for_each(|y| {
             for z in
                 camera_grid_z - renderer.render_distance..camera_grid_z + renderer.render_distance
             {
                 let mut found = false;
-                // Check if chunk is already loaded (in ECS)
-                for chunk in render_chunks.iter_mut() {
-                    if chunk.1.position == (x, y, z) {
-                        found = true;
-                        break;
+                {
+                    let render_chunks = render_chunks.read().unwrap();
+                    // Check if chunk is already loaded (in ECS)
+                    for chunk in render_chunks.iter() {
+                        if chunk.1.position == (x, y, z) {
+                            found = true;
+                            break;
+                        }
                     }
                 }
 
@@ -159,13 +170,14 @@ fn sys_update(
                                         println!("Loaded chunk at {}, {}, {}", x, y, z);
 
                                         // Introduce adjacent chunks
-
+                                        let mut meshes = meshes.write().unwrap();
                                         let mesh = meshes.add(mesh);
                                         let new_chunk = WorldRendererChunk {
                                             position: (x, y, z),
                                             mesh: mesh.clone(),
                                             meta,
                                         };
+                                        let mut commands = commands.write().unwrap();
                                         commands.spawn((
                                             Mesh3d(mesh),
                                             Transform::from_translation(Vec3::new(
@@ -189,6 +201,159 @@ fn sys_update(
                     }
                 }
             }
+        });
+    });*/
+}
+
+fn sys_on_chunk_generated(
+    mut commands: Commands,
+    mut ev_chunk_generated: EventReader<ChunkGeneratedEvent>,
+    data: ResMut<Assets<Mesh>>,
+    block_registry: Res<BlockRegistry>,
+    world: Query<&GameWorld>,
+    renderer: Query<&WorldRenderer>,
+    chunks: Query<(Entity, &mut WorldRendererChunk, &mut Mesh3d)>,
+) {
+    let world = world.single();
+    let block_registry = block_registry.into_inner();
+    let mesh_registry = Mutex::new(data);
+    let commands = Mutex::new(commands);
+
+    let par_iter = ev_chunk_generated.par_read();
+    let adj_faces = [Bottom, Top, Left, Right, Forward, Back];
+    let adj_offsets = [
+        (0, -1, 0),
+        (0, 1, 0),
+        (-1, 0, 0),
+        (1, 0, 0),
+        (0, 0, 1),
+        (0, 0, -1),
+    ];
+
+    par_iter.for_each(|event| {
+        let event = event;
+        let chunk = world.map.chunk_at(event.x, event.y, event.z);
+        let x = event.x;
+        let y = event.y;
+        let z = event.z;
+        match chunk {
+            WorldChunkStatus::Stored(stored) => {
+                let mut loaded = false;
+                {
+                    let r = stored.read().unwrap();
+                    loaded = r.is_loaded();
+                }
+                if loaded {
+                    let r = stored.read().unwrap();
+                    let r_arc = r.unwrap().clone();
+                    let r_arc_3 = r_arc.read().unwrap();
+                    let data = r_arc_3.data();
+                    match mesh_grid(
+                        (WorldChunk::SIZE, WorldChunk::SIZE, WorldChunk::SIZE),
+                        &[],
+                        data,
+                        block_registry,
+                        MeshingAlgorithm::Culling,
+                        None,
+                    ) {
+                        Some((mesh, meta)) => {
+                            let mut mesh = mesh;
+                            let mut meta = meta;
+
+                            // Optimize mesh by introducing adjacent chunks
+                            for i in 0..6 {
+                                let offset = adj_offsets[i];
+                                let face = adj_faces[i];
+                                let adj_chunk =
+                                    world.map.chunk_at(x + offset.0, y + offset.1, z + offset.2);
+                                match adj_chunk {
+                                    WorldChunkStatus::Stored(adj_stored) => {
+                                        let adj_r = adj_stored.read().unwrap();
+                                        if adj_r.is_loaded() {
+                                            let adj_r_arc = adj_r.unwrap().clone();
+                                            let adj_r_arc_3 = adj_r_arc.read().unwrap();
+                                            let adj_data = adj_r_arc_3.data();
+                                            introduce_adjacent_chunks(
+                                                block_registry,
+                                                &mut mesh,
+                                                &mut meta,
+                                                face,
+                                                adj_data,
+                                            );
+                                        }
+                                    }
+                                    _ => {}
+                                }
+                            }
+
+                            // Optimize neighboring WorldRendererChunks by introducing this chunk
+                            /*    for i in 0..6 {
+                                let offset = adj_offsets[i];
+                                let face = adj_faces[i];
+                                // Find WorldRendererChunk with the same position
+                                for (entity, chunk, mesh) in chunks.iter() {
+                                    if chunk.position == (x + offset.0, y + offset.1, z + offset.2) {
+                                //        introduce_adjacent_chunks(
+                               //             block_registry,
+                               //             &mut mesh_registry.lock().unwrap().get_mut(mesh).unwrap(),
+                               //             &mut chunk.meta,
+                               //             face,
+                               //             data
+                               //         );
+                                    }
+                                }
+                            }*/
+
+                            println!("Meshed chunk at {}, {}, {}", x, y, z);
+
+                            let mesh = mesh_registry.lock().unwrap().add(mesh);
+                            let mut commands = commands.lock().unwrap();
+                            commands.spawn((
+                                Mesh3d(mesh),
+                                Transform::from_translation(Vec3::new(
+                                    x as f32 * WorldChunk::SIZE as f32,
+                                    y as f32 * WorldChunk::SIZE as f32,
+                                    z as f32 * WorldChunk::SIZE as f32,
+                                )),
+                                MeshMaterial3d(renderer.single().material.clone()),
+                                WorldRendererChunk {
+                                    position: (x, y, z),
+                                    mesh: Handle::default(),
+                                    meta,
+                                },
+                            ));
+                        }
+                        None => {}
+                    }
+                }
+            }
+            WorldChunkStatus::Unloaded => {}
+        }
+    });
+}
+
+fn sys_on_chunk_dropped(
+    mut commands: Commands,
+    mut ev_chunk_dropped: EventReader<ChunkDroppedEvent>,
+    world: Query<&GameWorld>,
+    renderer: Query<&WorldRenderer>,
+    chunks: Query<(Entity, &WorldRendererChunk)>,
+) {
+    let world = world.single();
+    let renderer = renderer.single();
+    // find all WorldRendererChunks that are in the dropped chunks
+    for event in ev_chunk_dropped.par_read() {
+        let event = event.0;
+        let chunk = world.map.chunk_at(event.x, event.y, event.z);
+        let x = event.x;
+        let y = event.y;
+        let z = event.z;
+
+        // Search for WorldRendererChunk with the same position
+        for (entity, chunk) in chunks.iter() {
+            if chunk.position == (x, y, z) {
+                commands.entity(entity).despawn();
+            }
         }
     }
 }
diff --git a/src/client/systems/debug.rs b/src/client/systems/debug.rs
index dbbaf08..fd42358 100644
--- a/src/client/systems/debug.rs
+++ b/src/client/systems/debug.rs
@@ -1,12 +1,17 @@
 use bevy::{
     color::palettes::css::{GREEN_YELLOW, MAROON, WHEAT},
-    prelude::{BuildChildren, ChildBuild, Commands, Component},
+    prelude::{BuildChildren, ChildBuild, Commands, Component, Entity, Query, Text},
     text::{Text2d, TextColor, TextFont, TextLayout, TextSpan},
+    time::Time,
     ui::{
         AlignItems, BackgroundColor, FlexDirection, JustifyContent, Node, PositionType, UiRect, Val,
     },
     utils::default,
 };
+use bevy_egui::{EguiContext, EguiContexts};
+use egui::Color32;
+
+use crate::data::world;
 
 #[derive(Component)]
 pub struct DebugMenuComponent {
@@ -15,15 +20,79 @@ pub struct DebugMenuComponent {
 
 pub fn setup_debug_menu(mut commands: Commands) {
     commands.spawn((
-        TextSpan::new("Debug Menu"),
-        TextFont { ..default() },
+        Text("Debug Menu".to_string()),
         Node {
             position_type: PositionType::Absolute,
             left: Val::Px(12.0),
             top: Val::Px(12.0),
             ..default()
         },
+        DebugMenuComponent { show: true },
     ));
 }
 
-pub fn update_debug_menu() {}
+pub fn update_debug_menu(
+    time: bevy::prelude::Res<Time>,
+    mut commands: Commands,
+    mut query: Query<(Entity, &DebugMenuComponent, &mut Text)>,
+    camera: Query<(&bevy::prelude::Transform, &bevy::prelude::Camera3d)>,
+    entities_query: Query<Entity>,
+    mut egui_contexts: EguiContexts
+) {
+    let camera_transform = camera.iter().next().unwrap().0;
+    for (entity, menu, text) in query.iter_mut() {
+        if menu.show {
+            // Features:
+            // - Entity count
+            // - FPS Counter
+            // - Current coordinates
+            // - Direction facing (N, S, E, W)
+
+            // Get data first
+            let mut entities = 0;
+            let mut fps = 60.0;
+            let mut coords = (0, 0, 0);
+            let mut dir = "North";
+
+            // Get entity count
+            {
+                let entities_count = entities_query.iter().count();
+                entities = entities_count;
+            }
+            // Calulate FPS via delta time
+            {
+                let delta = time.delta_secs_f64();
+                fps = 1.0 / delta;
+            }
+            // Get current coordinates
+            {
+                let player = camera_transform;
+                let x = player.translation.x as i32;
+                let y = player.translation.y as i32;
+                let z = player.translation.z as i32;
+
+                coords = (x, y, z);
+            }
+            // Get direction facing
+            {
+                let rotation = camera_transform.rotation;
+                // -180 to 180, wrapped
+                let facing = rotation.y.to_degrees();
+                dir = match facing {
+                    -180.0..=-135.0 => "North",
+                    -135.0..=-45.0 => "East",
+                    -45.0..=45.0 => "South",
+                    45.0..=135.0 => "West",
+                    135.0..=180.0 => "North",
+                    _ => "North",
+                };
+            }
+
+            // Apply data
+            commands.entity(entity).insert(Text(format!(
+                "Entities: {}\nFPS: {:.2}\nCoords: {:?}\nFacing: {}",
+                entities, fps, coords, dir
+            )));
+        }
+    }
+}
diff --git a/src/client/systems/test_scene.rs b/src/client/systems/test_scene.rs
index d394e0b..36d0692 100644
--- a/src/client/systems/test_scene.rs
+++ b/src/client/systems/test_scene.rs
@@ -32,7 +32,7 @@ use crate::{
         MemoryWorld, SimplePerlinGenerator, World, WorldChunk, WorldChunkStatus, WorldChunkStorage,
         WorldGenerator,
     },
-    game::world_generator::GameWorld,
+    game::world_generator::{vis::WorldObserver, GameWorld},
 };
 
 const CUBE_SIZE: usize = 16;
@@ -118,6 +118,12 @@ pub fn setup(
         }
     }
 
+    // Camera3d
+    // commands.spawn((
+    //      Camera3d::default(),
+    //     Transform::from_xyz(0.0, 0.0, 10.0)
+    //));
+
     // directional 'sun' light
     commands.spawn((
         DirectionalLight {
@@ -171,9 +177,14 @@ pub fn update(
     mut world_local_query: Query<&WorldComponent>,
     mut world_query: Query<&mut GameWorld>,
     mut materials: ResMut<Assets<StandardMaterial>>,
-    mut query: Query<(&Camera3d, &Transform)>,
+    mut query: Query<(&Camera3d, &Transform, Entity)>,
     mut mesh_query: Query<(Entity, &Transform), With<Mesh3d>>,
 ) {
+    // Ensure all cameras have a WorldObserver component
+    for (_, _, camera) in query.iter() {
+        commands.entity(camera).insert_if_new(WorldObserver::new());
+    }
+
     // Spawn in new Voxel meshes if they don't exist and are close enough to the active Camera3
     // despawn Voxel meshes that are too far away from the player
 
diff --git a/src/game/world_generator/mod.rs b/src/game/world_generator/mod.rs
index 5ad9813..d40207e 100644
--- a/src/game/world_generator/mod.rs
+++ b/src/game/world_generator/mod.rs
@@ -26,9 +26,16 @@ impl Default for WorldGeneratorPlugin {
 impl bevy::prelude::Plugin for WorldGeneratorPlugin {
     fn build(&self, app: &mut App) {
         app.add_event::<GenerateWorldSignal>();
+        app.add_event::<ChunkUpdatedEvent>();
+        app.add_event::<ChunkLoadedEvent>();
+        app.add_event::<ChunkGeneratedEvent>();
+        app.add_event::<ChunkDroppedEvent>();
         app.add_systems(Startup, sys_setup);
         app.add_systems(Update, sys_update);
         app.add_systems(Update, sys_generate_chunk);
+        // Visibility system
+        app.add_systems(Startup, vis::sys_setup);
+        app.add_systems(Update, vis::sys_update);
     }
 }
 
@@ -43,25 +50,25 @@ pub struct GenerateWorldSignal {
     pub y: i32,
     pub z: i32,
 }
-
+#[derive(Event, Debug, Clone)]
 pub struct ChunkUpdatedEvent {
     pub x: i32,
     pub y: i32,
     pub z: i32,
 }
-
+#[derive(Event, Debug, Clone)]
 pub struct ChunkLoadedEvent {
     pub x: i32,
     pub y: i32,
     pub z: i32,
 }
-
+#[derive(Event, Debug, Clone)]
 pub struct ChunkGeneratedEvent {
     pub x: i32,
     pub y: i32,
     pub z: i32,
 }
-
+#[derive(Event, Debug, Clone)]
 pub struct ChunkDroppedEvent {
     pub x: i32,
     pub y: i32,
@@ -100,48 +107,6 @@ pub fn sys_update(
     mut world: Query<&mut GameWorld>,
     mut ev_generate_world: EventWriter<GenerateWorldSignal>,
 ) {
-    let camera_translation = camera.single().0.translation;
-
-    // Submit load requests for chunks 8 chunks away from the camera, if they are not already loaded
-    let camera_grid_x = (camera_translation.x / 16.0).floor() as i32;
-    let camera_grid_y = (camera_translation.y / 16.0).floor() as i32;
-    let camera_grid_z = (camera_translation.z / 16.0).floor() as i32;
-
-    let mut world = world.single_mut();
-    let mut map = &world.map;
-
-    let mut requests: Arc<RwLock<Vec<GenerateWorldSignal>>> = Arc::new(RwLock::new(Vec::new()));
-
-    // Concurrently check if a chunk is loaded up to 8 chunks in each direction,
-    // and if not, submit a load request
-    let par_iter = (-5..5).into_par_iter();
-    par_iter.for_each(|x| {
-        let requests = requests.clone();
-        let x = x + camera_grid_x;
-        for y in -5..5 {
-            let y = y + camera_grid_y;
-            for z in -5..5 {
-                let z = z + camera_grid_z;
-                if !map.chunk_loaded(x, y, z) {
-                    let mut requests = requests.write().unwrap();
-                    requests.push(GenerateWorldSignal { x, y, z });
-                }
-            }
-        }
-    });
-
-    // Submit load requests
-    let requests = requests.read().unwrap();
-    for request in requests.iter() {
-        ev_generate_world.send(request.clone());
-    }
-
-    // Store last user position
-    world.prev_user_position = (
-        camera_translation.x,
-        camera_translation.y,
-        camera_translation.z,
-    );
 }
 
 fn task_generate_chunk(
@@ -158,6 +123,7 @@ fn task_generate_chunk(
 pub fn sys_generate_chunk(
     world: Query<&GameWorld>,
     mut ev_generate_world: EventReader<GenerateWorldSignal>,
+    mut ev_chunk_generated: EventWriter<ChunkGeneratedEvent>,
 ) {
     let world = world.single();
     use rayon::prelude::*;
@@ -166,7 +132,37 @@ pub fn sys_generate_chunk(
         .into_iter()
         .par_bridge()
         .into_par_iter();
+    let loaded_chunks: Mutex<Vec<(i32, i32, i32)>> = Mutex::new(Vec::new());
+    let offsets = vec![
+        (0, 0, 1),
+        (0, 0, -1),
+        (0, 1, 0),
+        (0, -1, 0),
+        (1, 0, 0),
+        (-1, 0, 0),
+    ];
+
+    let ev_chunk_generated = Mutex::new(ev_chunk_generated);
+
     par_iter.for_each(|signal| {
         task_generate_chunk(signal.x, signal.y, signal.z, world, &world.generator);
+        let mut loaded_chunks = loaded_chunks.lock().unwrap();
+        loaded_chunks.push((signal.x, signal.y, signal.z));
+
+        // Fire ChunkLoadedEvents for neighboring chunks if they have a buffer of one chunk at each cardinal direction
+        for (dx, dy, dz) in offsets.iter() {
+            if loaded_chunks.contains(&(signal.x + dx, signal.y + dy, signal.z + dz)) {
+                ev_chunk_generated
+                    .lock()
+                    .unwrap()
+                    .send(ChunkGeneratedEvent {
+                        x: signal.x + dx,
+                        y: signal.y + dy,
+                        z: signal.z + dz,
+                    });
+            }
+        }
     });
+
+    // Fire ChunkGeneratedEvents, only if there is a buffer of one chunk at each cardinal direction
 }
diff --git a/src/game/world_generator/vis.rs b/src/game/world_generator/vis.rs
index 6f97941..8f87334 100644
--- a/src/game/world_generator/vis.rs
+++ b/src/game/world_generator/vis.rs
@@ -1,8 +1,10 @@
-use bevy::prelude::{Commands, Component, Entity, Query, Res};
+use bevy::prelude::{Commands, Component, Entity, Query, Res, Transform};
 
-use crate::data::world::{World, WorldChunkCoordinate};
+use crate::data::world::{World, WorldChunk, WorldChunkCoordinate, WorldChunkStatus};
 
-const DISTANCE: u8 = 8;
+use super::{ChunkDroppedEvent, GameWorld, GenerateWorldSignal};
+
+const DISTANCE: i32 = 3;
 
 /// Identifies chunks coming in and out of visibility, and unloads them when they are no longer visible.
 enum WorldObserverStatus {
@@ -15,22 +17,111 @@ pub struct WorldObserver {
     pub status: WorldObserverStatus,
 }
 
+impl WorldObserver {
+    pub fn new() -> Self {
+        Self {
+            status: WorldObserverStatus::NeedsRefresh,
+        }
+    }
+}
+
 pub fn sys_setup() {}
 
 #[inline]
-fn poke_chunk(world: &dyn World) -> bool {
-    false
+fn poke_chunk(commands: &mut Commands, world: &dyn World, x: i32, y: i32, z: i32) -> bool {
+    let chunk = world.chunk_at(x, y, z);
+    match chunk {
+        WorldChunkStatus::Stored(chunk) => false,
+        WorldChunkStatus::Unloaded => {
+            commands.send_event(GenerateWorldSignal { x, y, z });
+            true
+        }
+    }
 }
 
 pub fn sys_update(
     mut commands: Commands,
-    mut query: Query<(Entity, &WorldObserver)>,
-    world: Res<dyn World>,
+    mut observers: Query<(Entity, &mut WorldObserver, &Transform)>,
+    world: Query<&GameWorld>,
 ) {
-    for (entity, observer) in query.iter_mut() {
-        match observer.status {
-            WorldObserverStatus::NeedsRefresh => {}
-            WorldObserverStatus::FromPosition(pos) => {}
+    let world = world.single();
+    for (entity, mut observer, transform) in observers.iter_mut() {
+        let status = &mut observer.status;
+        match status {
+            WorldObserverStatus::NeedsRefresh => {
+                // Refresh ALL chunks in a DISTANCE radius
+                for x in -DISTANCE..DISTANCE {
+                    for y in -DISTANCE..DISTANCE {
+                        for z in -DISTANCE..DISTANCE {
+                            let x = x + world.prev_user_position.0 as i32;
+                            let y = y + world.prev_user_position.1 as i32;
+                            let z = z + world.prev_user_position.2 as i32;
+                            poke_chunk(&mut commands, &world.map, x, y, z);
+                        }
+                    }
+                }
+
+                observer.status =
+                    WorldObserverStatus::FromPosition(WorldChunkCoordinate::from_world(
+                        transform.translation.x,
+                        transform.translation.y,
+                        transform.translation.z,
+                    ));
+            }
+            WorldObserverStatus::FromPosition(pos) => {
+                // Identify current position
+                let tr = transform.translation;
+                let current_pos = WorldChunkCoordinate::from_world(tr.x, tr.y, tr.z);
+                if *pos != current_pos {
+                    // Identify chunks newly coming in and out of visibility, don't worry about chunks that stay in visibility
+                    let d_x = current_pos.x - pos.x;
+                    let d_y = current_pos.y - pos.y;
+                    let d_z = current_pos.z - pos.z;
+
+                    // Identify newly visible chunks
+                    for x in -DISTANCE..DISTANCE {
+                        for y in -DISTANCE..DISTANCE {
+                            for z in -DISTANCE..DISTANCE {
+                                let x = x + current_pos.x;
+                                let y = y + current_pos.y;
+                                let z = z + current_pos.z;
+                                if x < pos.x - DISTANCE
+                                    || x > pos.x + DISTANCE
+                                    || y < pos.y - DISTANCE
+                                    || y > pos.y + DISTANCE
+                                    || z < pos.z - DISTANCE
+                                    || z > pos.z + DISTANCE
+                                {
+                                    poke_chunk(&mut commands, &world.map, x, y, z);
+                                }
+                            }
+                        }
+                    }
+
+                    // Identify no longer visible chunks
+                    for x in -DISTANCE..DISTANCE {
+                        for y in -DISTANCE..DISTANCE {
+                            for z in -DISTANCE..DISTANCE {
+                                let x = x + pos.x;
+                                let y = y + pos.y;
+                                let z = z + pos.z;
+                                if x < current_pos.x - DISTANCE
+                                    || x > current_pos.x + DISTANCE
+                                    || y < current_pos.y - DISTANCE
+                                    || y > current_pos.y + DISTANCE
+                                    || z < current_pos.z - DISTANCE
+                                    || z > current_pos.z + DISTANCE
+                                {
+                                    // Unload chunk
+                                    commands.send_event(ChunkDroppedEvent { x, y, z });
+                                }
+                            }
+                        }
+                    }
+                }
+
+                *pos = current_pos;
+            }
         }
     }
 }