diff --git a/Cargo.toml b/Cargo.toml
index 5fb0f90..8b4f1da 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,6 +15,7 @@ path = "src/main.rs"
 default = [
     # Default to a native dev build.
     "dev_native",
+    "render",
 ]
 dev = [
     # Improve compile times for dev builds by linking Bevy as a dynamic
@@ -27,28 +28,46 @@ dev_native = [
     # Enable system information plugin for native dev builds.
     "bevy/sysinfo_plugin",
 ]
+headless = [
+    # Exclude rendering features
+    # This feature does not include the "render" feature
+    # Thus, rendering-related dependencies are disabled
+]
+render = [
+    # Enable features needed for visuals, windowed operation, and UIs.
+    "bevy/bevy_asset",
+    "bevy/bevy_color",
+    "bevy/bevy_core_pipeline",
+    "bevy/bevy_gizmos",
+    "bevy/ktx2",
+    "bevy/bevy_mesh_picking_backend",
+    "bevy/bevy_pbr",
+    "bevy/bevy_render",
+    "bevy/bevy_picking",
+    "bevy/bevy_text",
+    "bevy/bevy_ui",
+    "bevy/bevy_ui_picking_backend",
+    "bevy/bevy_window",
+    "bevy/bevy_winit",
+    "bevy/default_font",
+    "bevy/tonemapping_luts",
+    "bevy/png",
+    "bevy/webgl2",
+]
+inspect = [
+    "default",
+    "bevy-inspector-egui",
+]
 
 [dependencies]
 bevy = { version =  "0.15.0", default-features = false, features = [
-    "bevy_core_pipeline",
-    "bevy_gizmos",
-    "bevy_mesh_picking_backend",
-    "bevy_pbr",
-    "bevy_picking",
-    "bevy_render",
+    "bevy_asset",
     "bevy_state",
-    "bevy_text",
-    "bevy_ui",
-    "bevy_ui_picking_backend",
-    "bevy_window",
-    "bevy_winit",
-    "default_font",
     "multi_threaded",
-    
 ] }
 avian3d = { git = "https://github.com/Jondolf/avian.git", branch = "main", features = ["debug-plugin"] }
 bevy-trait-query = { git = "https://github.com/JoJoJet/bevy-trait-query.git", branch = "bevy-0.15-rc" }
-
+bevy-inspector-egui = { version = "0.28", optional = true, features = ["highlight_changes"] }
 # -----------------------------------------------------------------------------
 # Some Bevy optimizations
 # -----------------------------------------------------------------------------
diff --git a/README.md b/README.md
index 096f437..10a7b0f 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,8 @@
 # yet another HAB simulator
 
-A high altitude balloon flight simulator based on
-[tkschuler/EarthSHAB](https://github.com/tkschuler/EarthSHAB) and
-[brickworks/mfc-apps](https://github.com/Brickworks/mfc-apps), built on Rust.
+A high altitude balloon flight simulator built in
+[Bevy](https://bevyengine.org/) with Rust, inspired by
+[tkschuler/EarthSHAB](https://github.com/tkschuler/EarthSHAB).
 
 [devlog](docs/devlog.md)
 
diff --git a/docs/devlog.md b/docs/devlog.md
index 744abbb..32ae5ee 100644
--- a/docs/devlog.md
+++ b/docs/devlog.md
@@ -8,12 +8,39 @@ Bevy 0.15 support. Looks like they haven't but there are branches for it.
 - [x] `avian3d` -> branch `main`
 - [x] `bevy-trait-query` -> branch `bevy-0.15-rc`
 - [x] `iyes_perf_ui` -> branch `main`
+- [x] `bevy_egui` -> version `0.31`
+- [x] `bevy_inspector_egui` -> version `0.28`
 
 I'm hoping to slim down the dependencies for the project to shorten compile
 times. I'm a little annoyed with the `iyes_perf_ui` crate. It is a great tool
 but there is a ton of boilerplate code to set up the Ui. I think the built-in
 text crate will be enough for what I'm doing and will simplify things.
 
+Now, there are still a few things I am interested in doing soon:
+
+- [ ] Add a payload hanging from a tether.
+- [ ] Add a skybox or some reference in the background to illustrate the
+      balloon's size and altitude.
+- [ ] Style the UI like a retro radar display.
+- [ ] Sort out the time scale multiplier (the physics becomes unstable when it
+  goes above 1.5).
+- [ ] Add plots for altitude, pressure, temperature, volume, and density.
+
+I did a little work to group the rendering plugins into a separate plugin group
+from the headless plugins. I don't know why I decided to do that, but it will
+come in handy when I want to compile for wasm or terminal operation.
+
+Things I added:
+
+- [x] Rendering plugins in separate plugin group. `headless` runs without gfx.
+- [x] Lighting based on Bevy's example.
+- [x] Camera controller based on Bevy's `camera_controller` example.
+- [x] Observer/trigger-based debug UI toggles. Only some of them are working.
+- [x] Added targeting controls to the camera.
+
+I spent a few hours trying to get the skybox working but I couldn't get it to
+load.
+
 ## 2024-11-29
 
 I should lean into the wireframe aesthetic and make this whole thing look like a
diff --git a/src/app3d/camera.rs b/src/app3d/camera.rs
index 760a72d..1319ba6 100644
--- a/src/app3d/camera.rs
+++ b/src/app3d/camera.rs
@@ -1,114 +1,369 @@
 use bevy::{
-    input::mouse::{MouseScrollUnit, MouseWheel},
+    input::mouse::{AccumulatedMouseMotion, AccumulatedMouseScroll, MouseScrollUnit},
     prelude::*,
+    window::CursorGrabMode,
 };
+use std::f32::consts::PI;
 
-use super::controls::KeyBindingsConfig;
+use super::controls::{CameraControls, KeyBindingsConfig};
 use crate::simulator::Balloon;
 
-const INVERT_ZOOM: bool = true;
-
 pub struct CameraPlugin;
 
 impl Plugin for CameraPlugin {
     fn build(&self, app: &mut App) {
-        app.init_resource::<CameraSelection>();
         app.add_systems(Startup, setup);
-        app.add_systems(Update, zoom_camera);
-        app.add_plugins(CameraFollowPlugin);
+        app.add_plugins(CameraTargetPlugin);
+        app.add_plugins(CameraControllerPlugin);
     }
 }
 
-#[derive(Component, Default)]
-#[require(Camera3d, PerspectiveProjection)]
+/// The main camera component.
+#[derive(Component, Default, Reflect)]
+#[require(Camera3d, PerspectiveProjection, CameraController)]
 pub struct MainCamera;
 
-/// A resource that stores the currently selected camera target.
-#[derive(Resource)]
-struct CameraSelection {
-    entity: Entity,
-    offset: Vec3,
+fn setup(mut commands: Commands, keybinds: Res<KeyBindingsConfig>) {
+    commands.spawn((
+        Name::new("Main Camera"),
+        MainCamera,
+        Transform::from_xyz(0.0, 0.0, 10.0),
+    ));
+    let controls = &keybinds.into_inner().camera_controls;
+    commands.spawn((
+        Text::new(format!(
+            "Freecam Controls:
+    {:?} - Focus on target
+    {:?} - Cycle to next target & follow it
+    {:?} - Clear target
+    {:?} Mouse - Click & drag to rotate camera
+    {:?} / {:?} / {:?} / {:?} - Fly forward, backward, left, right
+    {:?} / {:?} - Fly up / down
+    {:?} - Hold to fly faster",
+            controls.tap_focus_target,
+            controls.tap_cycle_target,
+            controls.tap_clear_target,
+            controls.hold_look,
+            controls.tap_forward,
+            controls.tap_back,
+            controls.tap_left,
+            controls.tap_right,
+            controls.tap_up,
+            controls.tap_down,
+            controls.tap_run,
+        )),
+        Node {
+            position_type: PositionType::Absolute,
+            bottom: Val::Px(12.),
+            left: Val::Px(12.),
+            ..default()
+        },
+    ));
 }
 
-impl Default for CameraSelection {
-    fn default() -> Self {
-        Self {
-            entity: Entity::PLACEHOLDER,
-            offset: Vec3::new(0., 0., 10.),
-        }
+struct CameraTargetPlugin;
+
+impl Plugin for CameraTargetPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_event::<CycleToNextTarget>();
+        app.add_observer(cycle_to_next_target_system);
+
+        app.add_event::<FocusOnTarget>();
+        app.add_observer(focus_on_target);
+
+        app.add_event::<ClearTarget>();
+        app.add_observer(clear_target);
+
+        app.add_systems(
+            Update,
+            (
+                mark_new_targetables,
+                follow_selected_target,
+                handle_camera_targeting_inputs,
+            ),
+        );
     }
 }
 
+const DEFAULT_TARGET_OFFSET: Vec3 = Vec3::new(0.0, 0.0, 10.0);
+
+#[derive(Event)]
+struct FocusOnTarget;
+
 /// A marker component for entities that can be selected as a camera target.
 #[derive(Component, Default, Reflect)]
-pub struct CameraTarget;
+pub struct Targetable;
 
-fn setup(mut commands: Commands) {
-    commands.spawn((
-        Name::new("Main Camera"),
-        MainCamera,
-        Camera3d::default(),
-        Transform::from_xyz(0.0, 20., 50.0).looking_at(Vec3::new(0., 20., 0.), Vec3::Y),
-    ));
+/// A marker component for entities that can be selected as a camera target.
+#[derive(Component, Default, Reflect)]
+pub struct Targeted;
+
+/// An event that is emitted when the camera should cycle to the next target.
+#[derive(Event)]
+struct CycleToNextTarget;
+
+/// An event that is emitted when the camera should clear its target.
+#[derive(Event)]
+struct ClearTarget;
+
+fn mark_new_targetables(mut commands: Commands, balloons: Query<Entity, Added<Balloon>>) {
+    for entity in &balloons {
+        commands.entity(entity).insert(Targetable);
+    }
 }
 
-fn zoom_camera(
-    mut camera: Query<&mut PerspectiveProjection, (With<Camera3d>, With<MainCamera>)>,
-    mut evr_scroll: EventReader<MouseWheel>,
-    key_bindings: Res<KeyBindingsConfig>,
+fn handle_camera_targeting_inputs(
+    mut commands: Commands,
+    key_input: Res<ButtonInput<KeyCode>>,
+    keybinds: Res<KeyBindingsConfig>,
 ) {
-    let mut projection = camera.single_mut();
-    let ctrl = &key_bindings.camera_controls;
-    let direction = if INVERT_ZOOM { -1.0 } else { 1.0 };
-    for ev in evr_scroll.read() {
-        match ev.unit {
-            MouseScrollUnit::Line => {
-                projection.fov = projection.fov.clamp(ctrl.min_fov, ctrl.max_fov)
-                    + ev.y * ctrl.zoom_step * direction;
-            }
-            MouseScrollUnit::Pixel => {
-                projection.fov = projection.fov.clamp(ctrl.min_fov, ctrl.max_fov)
-                    + ev.y * ctrl.zoom_step * direction;
-            }
-        }
+    let controls = &keybinds.into_inner().camera_controls;
+    if key_input.just_pressed(controls.tap_focus_target) {
+        commands.trigger(FocusOnTarget);
+    }
+    if key_input.just_pressed(controls.tap_cycle_target) {
+        commands.trigger(CycleToNextTarget);
+    }
+    if key_input.just_pressed(controls.tap_clear_target) {
+        commands.trigger(ClearTarget);
     }
 }
 
-struct CameraFollowPlugin;
+fn clear_target(
+    _trigger: Trigger<ClearTarget>,
+    mut commands: Commands,
+    target: Option<Single<Entity, With<Targeted>>>,
+) {
+    if let Some(target) = target {
+        commands.entity(target.into_inner()).remove::<Targeted>();
+    }
+}
 
-impl Plugin for CameraFollowPlugin {
-    fn build(&self, app: &mut App) {
-        app.add_systems(Update, (mark_new_targets, follow_selected_target));
+fn focus_on_target(
+    _trigger: Trigger<FocusOnTarget>,
+    target: Option<Single<&Transform, (With<Targeted>, Without<MainCamera>)>>,
+    camera: Single<&mut Transform, With<MainCamera>>,
+) {
+    if let Some(target) = target {
+        let target = target.into_inner();
+        let mut cam = camera.into_inner();
+        cam.look_at(target.translation, Vec3::Y);
+    }
+}
+
+fn follow_selected_target(
+    target: Option<Single<&Transform, (With<Targeted>, Without<MainCamera>)>>,
+    camera: Single<&mut Transform, (With<MainCamera>, Without<Targeted>)>,
+) {
+    let mut cam = camera.into_inner();
+    if let Some(target) = target {
+        let target = target.into_inner();
+        cam.translation = cam.translation + target.translation;
     }
 }
 
-fn mark_new_targets(
+fn cycle_to_next_target_system(
+    _trigger: Trigger<CycleToNextTarget>,
     mut commands: Commands,
-    balloons: Query<Entity, Added<Balloon>>,
-    mut selection: ResMut<CameraSelection>,
+    old_target: Option<Single<Entity, With<Targeted>>>,
+    targets: Query<
+        (Entity, &Transform),
+        (With<Targetable>, Without<Targeted>, Without<MainCamera>),
+    >,
+    mut camera_query: Query<&mut Transform, With<MainCamera>>,
 ) {
-    for entity in &balloons {
-        commands.entity(entity).insert(CameraTarget);
-        // Focus on the newest balloon
-        selection.entity = entity;
+    let mut camera = camera_query.single_mut();
+
+    let target_entities: Vec<(Entity, &Transform)> = targets.iter().collect();
+    if target_entities.is_empty() {
+        return;
+    }
+
+    let old_target = match old_target {
+        Some(target) => Some(target.into_inner()),
+        None => None,
+    };
+
+    // Determine the next target index
+    let next_target = if let Some(current_entity) = old_target {
+        let current_index = target_entities
+            .iter()
+            .position(|&(e, _)| e == current_entity)
+            .unwrap_or(0);
+        target_entities
+            .iter()
+            .cycle()
+            .nth(current_index + 1)
+            .map(|&(e, _)| e)
+            .unwrap_or(target_entities[0].0)
+    } else {
+        target_entities[0].0
+    };
+
+    // Remove Targeted from the current entity, if any
+    if let Some(current_entity) = old_target {
+        commands.entity(current_entity).remove::<Targeted>();
+    }
+
+    // Add Targeted to the next entity
+    commands.entity(next_target).insert(Targeted);
+
+    // Retrieve the Transform of the new target and update the camera position
+    if let Ok((_, target_transform)) = targets.get(next_target) {
+        camera.translation = target_transform.translation + DEFAULT_TARGET_OFFSET;
+        camera.look_at(target_transform.translation, Vec3::Y);
     }
 }
 
-fn follow_selected_target(
-    selection: Res<CameraSelection>,
-    targets: Query<&Transform, (With<CameraTarget>, Without<MainCamera>)>,
-    mut camera: Query<&mut Transform, With<MainCamera>>,
+struct CameraControllerPlugin;
+
+impl Plugin for CameraControllerPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(Update, run_camera_controller);
+    }
+}
+
+#[derive(Component)]
+struct CameraController {
+    pub enabled: bool,
+    pub initialized: bool,
+    pub sensitivity: f32,
+    pub walk_speed: f32,
+    pub run_speed: f32,
+    pub scroll_factor: f32,
+    pub friction: f32,
+    pub pitch: f32,
+    pub yaw: f32,
+    pub velocity: Vec3,
+    pub controls: CameraControls,
+}
+
+impl Default for CameraController {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            initialized: false,
+            sensitivity: 1.0,
+            walk_speed: 10.0,
+            run_speed: 30.0,
+            scroll_factor: 0.1,
+            friction: 0.1,
+            pitch: 0.0,
+            yaw: 0.0,
+            velocity: Vec3::ZERO,
+            controls: CameraControls::default(),
+        }
+    }
+}
+
+/// Based on Valorant's default sensitivity, not entirely sure why it is exactly
+/// 1.0 / 180.0, but I'm guessing it is a misunderstanding between
+/// degrees/radians and then sticking with it because it felt nice.
+pub const RADIANS_PER_DOT: f32 = 1.0 / 180.0;
+
+#[allow(clippy::too_many_arguments)]
+fn run_camera_controller(
+    time: Res<Time>,
+    mut windows: Query<&mut Window>,
+    accumulated_mouse_motion: Res<AccumulatedMouseMotion>,
+    accumulated_mouse_scroll: Res<AccumulatedMouseScroll>,
+    mouse_button_input: Res<ButtonInput<MouseButton>>,
+    key_input: Res<ButtonInput<KeyCode>>,
+    query: Single<(&mut Transform, &mut CameraController), With<MainCamera>>,
 ) {
-    let mut cam = camera.single_mut();
-    match targets.get(selection.entity) {
-        Ok(t) => {
-            // If the target exists, move the camera next to it
-            cam.translation = t.translation + selection.offset;
-            // Look at the target position
-            cam.look_at(t.translation, Vec3::Y);
+    let dt = time.delta_secs();
+
+    let (mut transform, mut controller) = query.into_inner();
+
+    if !controller.initialized {
+        let (yaw, pitch, _roll) = transform.rotation.to_euler(EulerRot::YXZ);
+        controller.yaw = yaw;
+        controller.pitch = pitch;
+        controller.initialized = true;
+    }
+    if !controller.enabled {
+        return;
+    }
+
+    let mut scroll = 0.0;
+
+    let amount = match accumulated_mouse_scroll.unit {
+        MouseScrollUnit::Line => accumulated_mouse_scroll.delta.y,
+        MouseScrollUnit::Pixel => accumulated_mouse_scroll.delta.y / 16.0,
+    };
+    scroll += amount;
+    controller.walk_speed += scroll * controller.scroll_factor * controller.walk_speed;
+    controller.run_speed = controller.walk_speed * 3.0;
+
+    // Handle key input
+    let mut axis_input = Vec3::ZERO;
+    if key_input.pressed(controller.controls.tap_forward) {
+        axis_input.z += 1.0;
+    }
+    if key_input.pressed(controller.controls.tap_back) {
+        axis_input.z -= 1.0;
+    }
+    if key_input.pressed(controller.controls.tap_right) {
+        axis_input.x += 1.0;
+    }
+    if key_input.pressed(controller.controls.tap_left) {
+        axis_input.x -= 1.0;
+    }
+    if key_input.pressed(controller.controls.tap_up) {
+        axis_input.y += 1.0;
+    }
+    if key_input.pressed(controller.controls.tap_down) {
+        axis_input.y -= 1.0;
+    }
+
+    let looking = mouse_button_input.pressed(controller.controls.hold_look);
+
+    // Apply movement update
+    if axis_input != Vec3::ZERO {
+        let max_speed = if key_input.pressed(controller.controls.tap_run) {
+            controller.run_speed
+        } else {
+            controller.walk_speed
+        };
+        controller.velocity = axis_input.normalize() * max_speed;
+    } else {
+        let friction = controller.friction.clamp(0.0, 1.0);
+        controller.velocity *= 1.0 - friction;
+        if controller.velocity.length_squared() < 1e-6 {
+            controller.velocity = Vec3::ZERO;
         }
-        Err(_) => {
-            // If there is no selected entity, stay where you are
+    }
+    let forward = *transform.forward();
+    let right = *transform.right();
+    transform.translation += controller.velocity.x * dt * right
+        + controller.velocity.y * dt * Vec3::Y
+        + controller.velocity.z * dt * forward;
+
+    // Handle cursor grab
+    if looking {
+        for mut window in &mut windows {
+            if !window.focused {
+                continue;
+            }
+
+            window.cursor_options.grab_mode = CursorGrabMode::Locked;
+            window.cursor_options.visible = false;
+        }
+    } else {
+        for mut window in &mut windows {
+            window.cursor_options.grab_mode = CursorGrabMode::None;
+            window.cursor_options.visible = true;
         }
     }
+
+    // Handle mouse input
+    if accumulated_mouse_motion.delta != Vec2::ZERO && looking {
+        // Apply look update
+        controller.pitch = (controller.pitch
+            - accumulated_mouse_motion.delta.y * RADIANS_PER_DOT * controller.sensitivity)
+            .clamp(-PI / 2., PI / 2.);
+        controller.yaw -=
+            accumulated_mouse_motion.delta.x * RADIANS_PER_DOT * controller.sensitivity;
+        transform.rotation = Quat::from_euler(EulerRot::ZYX, 0.0, controller.yaw, controller.pitch);
+    }
 }
diff --git a/src/app3d/controls.rs b/src/app3d/controls.rs
index 56f5d08..1dfbab9 100644
--- a/src/app3d/controls.rs
+++ b/src/app3d/controls.rs
@@ -21,13 +21,17 @@ pub struct KeyBindingsConfig {
 
 #[derive(Reflect)]
 pub struct CameraControls {
-    pub cycle_target: KeyCode,
-    pub modifier_pan: KeyCode,
-    pub button_pan: MouseButton,
-    pub button_orbit: MouseButton,
-    pub zoom_step: f32,
-    pub max_fov: f32,
-    pub min_fov: f32,
+    pub hold_look: MouseButton,
+    pub tap_cycle_target: KeyCode,
+    pub tap_clear_target: KeyCode,
+    pub tap_focus_target: KeyCode,
+    pub tap_forward: KeyCode,
+    pub tap_back: KeyCode,
+    pub tap_left: KeyCode,
+    pub tap_right: KeyCode,
+    pub tap_up: KeyCode,
+    pub tap_down: KeyCode,
+    pub tap_run: KeyCode,
 }
 
 #[derive(Reflect)]
@@ -55,13 +59,17 @@ pub struct TimeControls {
 impl Default for CameraControls {
     fn default() -> Self {
         Self {
-            cycle_target: KeyCode::Tab,
-            modifier_pan: KeyCode::ShiftLeft,
-            button_pan: MouseButton::Middle,
-            button_orbit: MouseButton::Middle,
-            zoom_step: 0.01,
-            max_fov: 1.0,
-            min_fov: 0.01,
+            hold_look: MouseButton::Right,
+            tap_cycle_target: KeyCode::Tab,
+            tap_clear_target: KeyCode::KeyT,
+            tap_focus_target: KeyCode::KeyF,
+            tap_forward: KeyCode::KeyW,
+            tap_back: KeyCode::KeyS,
+            tap_left: KeyCode::KeyA,
+            tap_right: KeyCode::KeyD,
+            tap_up: KeyCode::KeyE,
+            tap_down: KeyCode::KeyQ,
+            tap_run: KeyCode::ShiftLeft,
         }
     }
 }
diff --git a/src/app3d/dev_tools.rs b/src/app3d/dev_tools.rs
index 0948461..609e840 100644
--- a/src/app3d/dev_tools.rs
+++ b/src/app3d/dev_tools.rs
@@ -1,59 +1,136 @@
-//! Development tools for the game. This plugin is only enabled in dev builds.
-use avian3d::debug_render::*;
-#[cfg(not(target_arch = "wasm32"))]
-use bevy::pbr::wireframe::{WireframeConfig, WireframePlugin};
 #[allow(unused_imports)]
 use bevy::{
     color::palettes::basic::*,
-    dev_tools::states::log_transitions,
-    diagnostic::{
-        EntityCountDiagnosticsPlugin, FrameTimeDiagnosticsPlugin,
-    },
+    dev_tools::{states::log_transitions, fps_overlay::{FpsOverlayPlugin, FpsOverlayConfig}},
+    diagnostic::*,
     input::common_conditions::input_just_pressed,
     prelude::*,
+    time::common_conditions::on_timer,
+    
+    text::FontSmoothing,
 };
+use avian3d::debug_render::*;
 
-use crate::simulator::{SimState, forces::Force};
 use super::controls::KeyBindingsConfig;
+use crate::simulator::{forces::Force, SimState};
+
+// Define all Show and Hide events
+#[derive(Event)]
+struct ShowEngineDebug;
+
+#[derive(Event)]
+struct HideEngineDebug;
+
+#[derive(Event)]
+struct ShowWireframe;
+
+#[derive(Event)]
+struct HideWireframe;
+
+#[derive(Event)]
+struct ShowForceGizmos;
+
+#[derive(Event)]
+struct HideForceGizmos;
+
+#[derive(Event)]
+struct ShowPhysicsGizmos;
+
+#[derive(Event)]
+struct HidePhysicsGizmos;
 
 pub struct DevToolsPlugin;
 
 impl Plugin for DevToolsPlugin {
     fn build(&self, app: &mut App) {
-        // Toggle the debug overlay for UI.
         app.add_plugins((
-        // physics
-        PhysicsDebugPlugin::default(),
-        ForceArrowsPlugin,
-        // performance
-        FrameTimeDiagnosticsPlugin,
-        EntityCountDiagnosticsPlugin,
-        // rendering
-        #[cfg(not(target_arch = "wasm32"))]
-        WireframePlugin,
-    ));
+            #[cfg(feature = "headless")]
+            (
+                FrameTimeDiagnosticsPlugin,
+                EntityCountDiagnosticsPlugin,
+                LogDiagnosticsPlugin::default(),
+            ),
+            #[cfg(feature = "render")]
+            RenderedDevToolsPlugin,
+        ));
+
+        app.add_systems(Update, log_transitions::<SimState>);
+    }
+}
+
+struct RenderedDevToolsPlugin;
+
+impl Plugin for RenderedDevToolsPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins((
+            PhysicsDebugPlugin::default(),
+            ForceArrowsPlugin,
+            #[cfg(not(target_arch = "wasm32"))]
+            bevy::pbr::wireframe::WireframePlugin,
+            FpsOverlayPlugin {
+                config: FpsOverlayConfig {
+                    text_config: TextFont {
+                        // Here we define size of our overlay
+                        font_size: 14.0,
+                        // If we want, we can use a custom font
+                        font: default(),
+                        // We could also disable font smoothing,
+                        font_smoothing: FontSmoothing::default(),
+                    },
+                    // We can also change color of the overlay
+                    text_color: Color::srgb(0.0, 1.0, 0.0),
+                    enabled: false,
+                },
+            },
+        ));
 
-    app.init_resource::<DebugState>();
+        app.init_resource::<DebugState>();
 
-    app.add_systems(Update, (
-        log_transitions::<SimState>,
-        // show_performance_stats,
-        show_force_gizmos,
-        show_physics_gizmos,
-    ));
+        // Register all events
+        app.add_event::<ShowEngineDebug>();
+        app.add_event::<HideEngineDebug>();
+        app.add_event::<ShowForceGizmos>();
+        app.add_event::<HideForceGizmos>();
+        app.add_event::<ShowPhysicsGizmos>();
+        app.add_event::<HidePhysicsGizmos>();
 
-    app.add_systems(Update, toggle_debug_ui);
-    // #[cfg(feature = "inspect")]
-    // {
-    //     use bevy_inspector_egui::quick::WorldInspectorPlugin;
-    //     app.add_plugins(WorldInspectorPlugin::new());
-    // }
+        app.add_systems(Startup, init_debug_ui);
+        app.add_systems(Update, trigger_debug_ui);
+
+        // Register handler functions as observers
+        app.add_observer(show_engine_debug);
+        app.add_observer(show_force_gizmos);
+        app.add_observer(show_physics_gizmos);
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            app.add_event::<ShowWireframe>();
+            app.add_event::<HideWireframe>();
+            app.add_observer(show_wireframe);
+            app.add_observer(hide_wireframe);
+        }
+        
+        app.add_observer(hide_engine_debug);
+        app.add_observer(hide_force_gizmos);
+        app.add_observer(hide_physics_gizmos);
+
+        #[cfg(feature = "inspect")]
+        {
+            use bevy_inspector_egui::quick;
+            app.add_plugins((
+                quick::FilterQueryInspectorPlugin::default(),
+                quick::ResourceInspectorPlugin::default(),
+                quick::StateInspectorPlugin::default(),
+                quick::WorldInspectorPlugin::default(),
+                quick::AssetInspectorPlugin::<Mesh3d>::default(),
+                quick::AssetInspectorPlugin::<StandardMaterial>::default(),
+            ));
+        }
     }
 }
 
 #[derive(Debug, Resource)]
 struct DebugState {
-    performance: bool,
+    engine: bool,
     wireframe: bool,
     forces: bool,
     physics: bool,
@@ -62,7 +139,7 @@ struct DebugState {
 impl Default for DebugState {
     fn default() -> Self {
         Self {
-            performance: true,
+            engine: true,
             wireframe: false,
             forces: true,
             physics: false,
@@ -71,73 +148,153 @@ impl Default for DebugState {
 }
 
 impl DebugState {
-    fn toggle_performance(&mut self) {
-        self.performance = !self.performance;
-        warn!("performance debug: {}", self.performance);
+    fn toggle_engine(&mut self) {
+        self.engine = !self.engine;
     }
     fn toggle_wireframe(&mut self) {
         self.wireframe = !self.wireframe;
-        warn!("wireframe debug: {}", self.wireframe);
     }
     fn toggle_forces(&mut self) {
         self.forces = !self.forces;
-        warn!("forces debug: {}", self.forces);
     }
     fn toggle_physics(&mut self) {
         self.physics = !self.physics;
-        warn!("physics debug: {}", self.physics);
     }
 }
 
-fn toggle_debug_ui(
-    mut wireframe_config: ResMut<WireframeConfig>,
+fn init_debug_ui(mut commands: Commands, debug_state: Res<DebugState>) {
+    info!("initializing debug ui");
+    if debug_state.engine {
+        commands.trigger(ShowEngineDebug);
+    }
+    #[cfg(not(target_arch = "wasm32"))]
+    if debug_state.wireframe {
+        commands.trigger(ShowWireframe);
+    }
+    if debug_state.forces {
+        commands.trigger(ShowForceGizmos);
+    }
+    if debug_state.physics {
+        commands.trigger(ShowPhysicsGizmos);
+    }
+}
+
+fn trigger_debug_ui(
+    mut commands: Commands,
     mut debug_state: ResMut<DebugState>,
     key_input: Res<ButtonInput<KeyCode>>,
     key_bindings: Res<KeyBindingsConfig>,
 ) {
     if key_input.just_pressed(key_bindings.debug_controls.toggle_1) {
-        debug_state.toggle_performance();
+        debug_state.toggle_engine();
+        if debug_state.engine {
+            commands.trigger(ShowEngineDebug);
+        } else {
+            commands.trigger(HideEngineDebug);
+        }
     }
+    #[cfg(not(target_arch = "wasm32"))]
     if key_input.just_pressed(key_bindings.debug_controls.toggle_2) {
-        // Wireframe doesn't work on WASM
-        #[cfg(not(target_arch = "wasm32"))]
         debug_state.toggle_wireframe();
-        wireframe_config.global = !wireframe_config.global;
+        // Wireframe doesn't work on WASM
+        if debug_state.wireframe {
+            commands.trigger(ShowWireframe);
+        } else {
+            commands.trigger(HideWireframe);
+        }
     }
     if key_input.just_pressed(key_bindings.debug_controls.toggle_3) {
         debug_state.toggle_forces();
+        if debug_state.forces {
+            commands.trigger(ShowForceGizmos);
+        } else {
+            commands.trigger(HideForceGizmos);
+        }
     }
     if key_input.just_pressed(key_bindings.debug_controls.toggle_4) {
         debug_state.toggle_physics();
+        if debug_state.physics {
+            commands.trigger(ShowPhysicsGizmos);
+        } else {
+            commands.trigger(HidePhysicsGizmos);
+        }
     }
 }
 
-fn show_force_gizmos(
-    debug_state: Res<DebugState>,
-    mut gizmo_store: ResMut<GizmoConfigStore>
+fn show_engine_debug(
+    _trigger: Trigger<ShowEngineDebug>,
+    mut store: ResMut<DiagnosticsStore>,
+    mut overlay_config: ResMut<FpsOverlayConfig>,
 ) {
-    if debug_state.is_changed() {
-        let (_, force_config) = gizmo_store.config_mut::<ForceGizmos>();
-        if debug_state.forces {
-            *force_config = ForceGizmos::all();
-        } else {
-            *force_config = ForceGizmos::none();
-        }
+    for diag in store.iter_mut() {
+        info!("showing diagnostic {}", diag.path());
+        diag.is_enabled = true;
     }
+    overlay_config.enabled = true;
 }
 
-fn show_physics_gizmos(
-    debug_state: Res<DebugState>,
-    mut gizmo_store: ResMut<GizmoConfigStore>
+fn hide_engine_debug(
+    _trigger: Trigger<HideEngineDebug>,
+    mut store: ResMut<DiagnosticsStore>,
+    mut overlay_config: ResMut<FpsOverlayConfig>,
 ) {
-    if debug_state.is_changed() {
-        let (_, physics_config) = gizmo_store.config_mut::<PhysicsGizmos>();
-        if debug_state.physics {
-            *physics_config = PhysicsGizmos::all();
-        } else {
-            *physics_config = PhysicsGizmos::none();
-        }
+    for diag in store.iter_mut() {
+        info!("hiding diagnostic {}", diag.path());
+        diag.is_enabled = false;
     }
+    overlay_config.enabled = false;
+}
+
+fn show_wireframe(
+    _trigger: Trigger<ShowWireframe>,
+    mut wireframe_config: ResMut<bevy::pbr::wireframe::WireframeConfig>,
+) {
+    info!("showing wireframe");
+    wireframe_config.global = true;
+}
+
+fn hide_wireframe(
+    _trigger: Trigger<HideWireframe>,
+    mut wireframe_config: ResMut<bevy::pbr::wireframe::WireframeConfig>,
+) {
+    info!("hiding wireframe");
+    wireframe_config.global = false;
+}
+
+fn show_force_gizmos(
+    _trigger: Trigger<ShowForceGizmos>,
+    mut store: ResMut<GizmoConfigStore>,
+) {
+    info!("showing force gizmos");
+    let (_, force_config) = store.config_mut::<ForceGizmos>();
+    *force_config = ForceGizmos::all();
+}
+
+fn hide_force_gizmos(
+    _trigger: Trigger<HideForceGizmos>,
+    mut store: ResMut<GizmoConfigStore>,
+) {
+    info!("hiding force gizmos");
+    let (_, force_config) = store.config_mut::<ForceGizmos>();
+    *force_config = ForceGizmos::none();
+}
+
+fn show_physics_gizmos(
+    _trigger: Trigger<ShowPhysicsGizmos>,
+    mut store: ResMut<GizmoConfigStore>,
+) {
+    info!("showing physics gizmos");
+    let (_, physics_config) = store.config_mut::<PhysicsGizmos>();
+    *physics_config = PhysicsGizmos::all();
+}
+
+fn hide_physics_gizmos(
+    _trigger: Trigger<HidePhysicsGizmos>,
+    mut store: ResMut<GizmoConfigStore>,
+) {
+    info!("hiding physics gizmos");
+    let (_, physics_config) = store.config_mut::<PhysicsGizmos>();
+    *physics_config = PhysicsGizmos::none();
 }
 
 const ARROW_SCALE: f32 = 0.1;
@@ -150,18 +307,13 @@ impl Plugin for ForceArrowsPlugin {
         app.register_type::<ForceGizmos>();
         app.add_systems(
             PostUpdate,
-            force_arrows.run_if(
-                |store: Res<GizmoConfigStore>| {
-                    store.config::<ForceGizmos>().0.enabled
-                }),
+            force_arrows
+                .run_if(|store: Res<GizmoConfigStore>| store.config::<ForceGizmos>().0.enabled),
         );
     }
 }
 
-fn force_arrows(
-    query: Query<&dyn Force>,
-    mut gizmos: Gizmos,
-) {
+fn force_arrows(query: Query<&dyn Force>, mut gizmos: Gizmos) {
     for forces in query.iter() {
         for force in forces.iter() {
             let start = force.point_of_application();
@@ -209,7 +361,7 @@ impl ForceGizmos {
         }
     }
 
-    /// Creates a [`ForceGizmos`] configuration with debug rendering enabled but all options turned off.
+    /// Creates a [`ForceGizmos`] configuration with all rendering options disabled.
     pub fn none() -> Self {
         Self {
             arrow_scale: None,
diff --git a/src/app3d/mod.rs b/src/app3d/mod.rs
index c6ee1db..828048b 100644
--- a/src/app3d/mod.rs
+++ b/src/app3d/mod.rs
@@ -19,20 +19,27 @@ impl PluginGroup for App3dPlugins {
     fn build(self) -> PluginGroupBuilder {
         PluginGroupBuilder::start::<Self>()
             .add(UiPlugin)
-            .add(ControlsPlugin)
-            .add(ScenePlugin)
-            .add(CameraPlugin)
+            .add(RenderedObjectsPlugin)
     }
 }
 
 /// A plugin group that includes all interface-related plugins
-pub struct UiPlugin;
+struct UiPlugin;
 
 impl Plugin for UiPlugin {
     fn build(&self, app: &mut App) {
         app.add_plugins((
+            ControlsPlugin,
             #[cfg(feature = "dev")]
             DevToolsPlugin,
         ));
     }
 }
+
+struct RenderedObjectsPlugin;
+
+impl Plugin for RenderedObjectsPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins((ScenePlugin, CameraPlugin));
+    }
+}
diff --git a/src/app3d/scene.rs b/src/app3d/scene.rs
index 0a0cc38..582cfd1 100644
--- a/src/app3d/scene.rs
+++ b/src/app3d/scene.rs
@@ -1,5 +1,6 @@
 use avian3d::prelude::*;
 use bevy::prelude::*;
+use std::f32::consts::PI;
 
 use crate::simulator::*;
 
@@ -7,47 +8,21 @@ pub struct ScenePlugin;
 
 impl Plugin for ScenePlugin {
     fn build(&self, app: &mut App) {
-        app.add_systems(Startup, (spawn_balloon, simple_scene));
+        app.add_systems(Startup, (setup_lighting, spawn_balloon));
+        app.add_systems(Update, animate_light_direction);
         // app.add_systems(PostStartup, |mut commands: Commands| {
         //     commands.set_state(SimState::Running);
         // });
     }
 }
 
-/// set up a simple 3D scene
-fn simple_scene(
-    mut commands: Commands,
-    mut meshes: ResMut<Assets<Mesh>>,
-    mut materials: ResMut<Assets<StandardMaterial>>,
-) {
-    let ground_size = Vec3::new(50.0, 0.1, 50.0);
-    let plane = meshes.add(Plane3d::default().mesh().size(ground_size.x,  ground_size.z).subdivisions(10));
-    let plane_material = materials.add(StandardMaterial {
-        base_color: Color::srgb(0.5, 0.5, 0.0),
-        perceptual_roughness: 0.5,
-        ..default()
-    });
-
-    // ground
-    commands.spawn((
-        Name::new("Ground"),
-        RigidBody::Static,
-        Mesh3d(plane.clone()),
-        MeshMaterial3d(plane_material.clone()),
-        ColliderConstructor::TrimeshFromMesh,
-    ));
-}
-
 fn spawn_balloon(
     mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
     let debug_material = materials.add(StandardMaterial {
-        base_color: Color::srgba(1.0, 0.0, 0.0, 0.5),
-        perceptual_roughness: 0.0,
-        metallic: 1.0,
-        alpha_mode: AlphaMode::Blend,
+        base_color: Color::srgb(1.0, 0.0, 0.0),
         ..default()
     });
     let sphere = Sphere::default();
@@ -65,10 +40,37 @@ fn spawn_balloon(
         RigidBody::Dynamic,
         Collider::sphere(sphere.radius),
         Transform {
-            translation: Vec3::new(0.0, 10.0, 0.0),
+            translation: Vec3::new(0.0, 0.0, 0.0),
             ..default()
         },
         MeshMaterial3d(debug_material),
         Mesh3d(shape),
     ));
 }
+
+fn setup_lighting(mut commands: Commands) {
+    // directional 'sun' light
+    commands.spawn((
+        DirectionalLight {
+            illuminance: 32000.0,
+            ..default()
+        },
+        Transform::from_xyz(0.0, 2.0, 0.0).with_rotation(Quat::from_rotation_x(-PI / 4.)),
+    ));
+    // ambient light
+    // NOTE: The ambient light is used to scale how bright the environment map is so with a bright
+    // environment map, use an appropriate color and brightness to match
+    commands.insert_resource(AmbientLight {
+        color: Color::srgb_u8(210, 220, 240),
+        brightness: 1.0,
+    });
+}
+
+fn animate_light_direction(
+    time: Res<Time>,
+    mut query: Query<&mut Transform, With<DirectionalLight>>,
+) {
+    for mut transform in &mut query {
+        transform.rotate_y(time.delta_secs() * 0.5);
+    }
+}
diff --git a/src/simulator/balloon.rs b/src/simulator/balloon.rs
index 6c87c0f..5e1b590 100644
--- a/src/simulator/balloon.rs
+++ b/src/simulator/balloon.rs
@@ -5,7 +5,7 @@ use bevy::prelude::*;
 
 use super::{
     ideal_gas::IdealGas, properties::sphere_radius_from_volume,
-    SimulationUpdateOrder, Volume,
+    SimulationUpdateOrder, Volume, Weight, Drag, Buoyancy,
 };
 
 pub struct BalloonPlugin;
@@ -24,7 +24,7 @@ impl Plugin for BalloonPlugin {
 }
 
 #[derive(Component, Debug, Clone, PartialEq, Reflect)]
-#[require(IdealGas, RigidBody(|| RigidBody::Dynamic))]
+#[require(IdealGas, RigidBody(|| RigidBody::Dynamic), Weight, Drag, Buoyancy)]
 pub struct Balloon {
     pub material_properties: BalloonMaterial,
     pub shape: Sphere,
diff --git a/src/simulator/forces/mod.rs b/src/simulator/forces/mod.rs
index d68bf3a..00d63ce 100644
--- a/src/simulator/forces/mod.rs
+++ b/src/simulator/forces/mod.rs
@@ -31,10 +31,6 @@ impl Plugin for ForcesPlugin {
                 .chain()
                 .in_set(SimulationUpdateOrder::Forces),
         );
-        app.add_systems(
-            Update,
-            on_simulated_body_added.in_set(ForceUpdateOrder::First),
-        );
         app.add_systems(
             Update,
             update_total_external_force
@@ -51,6 +47,8 @@ pub enum ForceUpdateOrder {
     First,
     Prepare,
     Apply,
+    #[allow(dead_code)]
+    Last,
 }
 
 /// A bundle of force components to be added to entities with a `RigidBody`. The
@@ -62,15 +60,6 @@ pub struct ForceBundle {
     drag: aero::Drag,
 }
 
-fn on_simulated_body_added(mut commands: Commands, query: Query<(Entity, &RigidBody), Added<RigidBody>>) {
-    for (entity, rigid_body) in &query {
-        let mut this_entity = commands.entity(entity);
-        if rigid_body.is_dynamic() {
-            this_entity.insert(ForceBundle::default());
-        }
-    }
-}
-
 /// This trait is used to identify a force vector component. All forces are
 /// collected and summed to determine the net force acting on a rigid body. All
 /// forces assume a right-handed Y-up coordinate frame and are reported in
diff --git a/src/simulator/payload.rs b/src/simulator/payload.rs
index ffcc056..41111ee 100644
--- a/src/simulator/payload.rs
+++ b/src/simulator/payload.rs
@@ -1,8 +1,10 @@
 //! The things that are carried by the balloon.
 #![allow(dead_code)]
-
+use avian3d::prelude::*;
 use bevy::prelude::*;
 
+use super::forces::{Drag, Force, Weight};
+
 pub struct PayloadPlugin;
 
 impl Plugin for PayloadPlugin {
@@ -13,10 +15,9 @@ impl Plugin for PayloadPlugin {
 
 /// A thing carried by the balloon.
 #[derive(Component, Default)]
+#[require(Transform, RigidBody(|| RigidBody::Dynamic), Weight, Drag)]
 pub struct Payload;
 
-
 /// A tether that connects the balloon to the payload.
 #[derive(Component, Default)]
-#[require(Payload)]
 pub struct Tether;