diff --git a/src/config.rs b/src/config.rs
index 3bf56ea..58f952b 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -10,8 +10,6 @@ fn default_fps() -> u32 { 60 }
 fn default_video_codec() -> String { "h264".to_string() }
 fn default_audio_device() -> String { "default".to_string() }
 fn default_audio_mode() -> String { "system".to_string() }
-fn default_lang() -> String { "en".to_string() }
-fn default_theme() -> String { "dark".to_string() }
 fn default_save_hotkey() -> String { "Ctrl+Shift+R".to_string() }
 fn default_menu_hotkey() -> String { "Alt+Z".to_string() }
 fn default_record_hotkey() -> String { "Ctrl+Shift+F9".to_string() }
@@ -24,14 +22,9 @@ fn default_stream_service() -> String { "twitch".to_string() }
 fn default_stream_url() -> String { "rtmp://live.twitch.tv/app/".to_string() }
 fn default_screenshot_hotkey() -> String { "Ctrl+Shift+S".to_string() }
 fn default_screenshot_format() -> String { "png".to_string() }
-fn default_capture_source() -> String { "focused".to_string() }
 fn default_video_quality_mode() -> String { "cbr".to_string() }
 fn default_color_range() -> String { "limited".to_string() }
 fn default_audio_codec() -> String { "opus".to_string() }
-fn default_replay_storage() -> String { "ram".to_string() }
-fn default_container_format() -> String { "mp4".to_string() }
-fn default_res_w() -> u32 { 1920 }
-fn default_res_h() -> u32 { 1080 }
 fn default_screenshot_quality() -> u32 { 90 }
 fn default_screenshot_preset() -> String { "balanced".to_string() }
 fn default_pause_hotkey() -> String { "Ctrl+Shift+F8".to_string() }
@@ -50,8 +43,6 @@ pub struct ScytheConfig {
     #[serde(default = "default_replay_bitrate")]
     pub replay_bitrate_kbps: u32,
     
-    #[serde(default)]
-    pub record_enabled: bool,
     #[serde(default = "default_record_bitrate")]
     pub record_bitrate_kbps: u32,
     #[serde(default = "default_fps")]
@@ -77,10 +68,6 @@ pub struct ScytheConfig {
     pub autostart_replay: bool,
     #[serde(default)]
     pub autostart_overlay: bool,
-    #[serde(default = "default_lang")]
-    pub language: String,
-    #[serde(default = "default_theme")]
-    pub ui_color_theme: String,
     #[serde(default = "default_save_hotkey")]
     pub save_hotkey: String,
     #[serde(default = "default_menu_hotkey")]
@@ -109,40 +96,20 @@ pub struct ScytheConfig {
     #[serde(default)]
     pub screenshot_cursor: bool,
 
-    #[serde(default = "default_capture_source")]
-    pub capture_source: String,
     #[serde(default = "default_video_quality_mode")]
     pub video_quality_mode: String,
     #[serde(default = "default_color_range")]
     pub color_range: String,
     #[serde(default = "default_audio_codec")]
     pub audio_codec: String,
-    #[serde(default = "default_replay_storage")]
-    pub replay_storage: String,
     #[serde(default)]
     pub record_low_power: bool,
     #[serde(default = "default_true")]
     pub show_replay_notifications: bool,
 
-    #[serde(default = "default_container_format")]
-    pub container_format: String,
-    #[serde(default)]
-    pub change_resolution: bool,
-    #[serde(default = "default_res_w")]
-    pub resolution_w: u32,
-    #[serde(default = "default_res_h")]
-    pub resolution_h: u32,
-    #[serde(default)]
-    pub save_folder_by_game: bool,
-    #[serde(default)]
-    pub name_by_game: bool,
     #[serde(default = "default_true")]
     pub restart_replay_on_save: bool,
     #[serde(default)]
-    pub show_scroll_lock_led: bool,
-    #[serde(default)]
-    pub autostart_on_game: bool,
-    #[serde(default)]
     pub autostart_power_only: bool,
 
     #[serde(default = "default_screenshot_quality")]
@@ -171,7 +138,6 @@ impl Default for ScytheConfig {
             replay_duration_sec: 60,
             replay_bitrate_kbps: 18000,
             
-            record_enabled: false,
             record_bitrate_kbps: 20000,
             fps: 60,
             video_codec: "h264".to_string(),
@@ -185,8 +151,6 @@ impl Default for ScytheConfig {
             autostart: false,
             autostart_replay: false,
             autostart_overlay: false,
-            language: "en".to_string(),
-            ui_color_theme: "dark".to_string(),
             save_hotkey: "Ctrl+Shift+R".to_string(),
             menu_hotkey: "Alt+Z".to_string(),
             record_hotkey: "Ctrl+Shift+F9".to_string(),
@@ -202,23 +166,13 @@ impl Default for ScytheConfig {
             screenshot_format: default_screenshot_format(),
             screenshot_cursor: false,
 
-            capture_source: default_capture_source(),
             video_quality_mode: default_video_quality_mode(),
             color_range: default_color_range(),
             audio_codec: default_audio_codec(),
-            replay_storage: default_replay_storage(),
             record_low_power: false,
             show_replay_notifications: true,
 
-            container_format: default_container_format(),
-            change_resolution: false,
-            resolution_w: default_res_w(),
-            resolution_h: default_res_h(),
-            save_folder_by_game: false,
-            name_by_game: false,
             restart_replay_on_save: true,
-            show_scroll_lock_led: false,
-            autostart_on_game: false,
             autostart_power_only: false,
 
             screenshot_quality: default_screenshot_quality(),
@@ -577,21 +531,11 @@ mod tests {
         assert_eq!(parsed.stream_url, "rtmp://live.twitch.tv/app/");
         assert_eq!(parsed.stream_key, "");
 
-        assert_eq!(parsed.container_format, "mp4");
-        assert!(!parsed.change_resolution);
-        assert_eq!(parsed.resolution_w, 1920);
-        assert_eq!(parsed.resolution_h, 1080);
-        assert!(!parsed.save_folder_by_game);
-        assert!(!parsed.name_by_game);
         assert!(parsed.restart_replay_on_save);
-        assert!(!parsed.show_scroll_lock_led);
-        assert!(!parsed.autostart_on_game);
         assert!(!parsed.autostart_power_only);
-        assert_eq!(parsed.capture_source, "focused");
         assert_eq!(parsed.video_quality_mode, "cbr");
         assert_eq!(parsed.color_range, "limited");
         assert_eq!(parsed.audio_codec, "opus");
-        assert_eq!(parsed.replay_storage, "ram");
         assert!(!parsed.record_low_power);
         assert!(parsed.show_replay_notifications);
         assert_eq!(parsed.screenshot_hotkey, "Ctrl+Shift+S");
diff --git a/src/daemon.rs b/src/daemon.rs
index c05baeb..88e5b20 100644
--- a/src/daemon.rs
+++ b/src/daemon.rs
@@ -13,6 +13,67 @@ use std::io::{Read, Write};
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::Arc;
 
+/// Returns true when the overlay process recorded in the pid file is still alive.
+fn overlay_alive() -> bool {
+    let pid_path = crate::ipc::get_overlay_pid_path();
+    let Ok(content) = std::fs::read_to_string(&pid_path) else {
+        return false;
+    };
+    let Ok(pid) = content.trim().parse::<i32>() else {
+        return false;
+    };
+    if pid <= 0 {
+        return false;
+    }
+
+    #[cfg(unix)]
+    {
+        unsafe { libc::kill(pid, 0) == 0 }
+    }
+    #[cfg(windows)]
+    {
+        use windows::Win32::Foundation::{CloseHandle, STILL_ACTIVE};
+        use windows::Win32::System::Threading::{
+            GetExitCodeProcess, OpenProcess, PROCESS_QUERY_LIMITED_INFORMATION,
+        };
+        unsafe {
+            let Ok(handle) = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, false, pid as u32) else {
+                return false;
+            };
+            let mut code = 0u32;
+            let alive = GetExitCodeProcess(handle, &mut code).is_ok() && code == STILL_ACTIVE.0 as u32;
+            let _ = CloseHandle(handle);
+            alive
+        }
+    }
+    #[cfg(not(any(unix, windows)))]
+    {
+        false
+    }
+}
+
+/// Opens the HUD overlay without toggling an already-visible one closed.
+fn spawn_overlay_once() {
+    if overlay_alive() {
+        return;
+    }
+    let exe = std::env::current_exe()
+        .map(|p| p.to_string_lossy().to_string())
+        .unwrap_or_else(|_| "scythe".to_string());
+
+    let mut cmd = std::process::Command::new(exe);
+    cmd.arg("--menu")
+        .stdin(std::process::Stdio::null())
+        .stdout(std::process::Stdio::null())
+        .stderr(std::process::Stdio::null());
+    #[cfg(target_os = "windows")]
+    {
+        use std::os::windows::process::CommandExt;
+        cmd.creation_flags(0x08000000);
+    }
+    let _ = cmd.spawn();
+}
+
 fn mask_stream_url(url: &str) -> String {
     if let Some((base, key)) = url.rsplit_once('/')
         && key.len() > 4 {
@@ -278,6 +339,10 @@ async fn run_daemon_async() -> Result<(), Box<dyn std::error::Error + Send + Syn
                                             println!("Audio mode cycled to: {}", cfg.audio_mode);
                                             let _ = cmd_tx_ipc.try_send(Command::ReloadConfig);
                                         },
+                                        Command::ShowOverlay => {
+                                            println!("ShowOverlay requested: opening HUD overlay.");
+                                            std::thread::spawn(spawn_overlay_once);
+                                        },
                                         Command::StopDaemon => {
                                             println!("StopDaemon requested: Finalizing active recordings...");
                                             crate::hyprland_binds::unregister_hyprland_binds(&crate::config::ScytheConfig::load());
diff --git a/src/main.rs b/src/main.rs
index 357addd..4c898d4 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -444,6 +444,17 @@ fn run_client(args: Vec<String>) -> Result<(), Box<dyn std::error::Error + Send
             "--pause" => {
                 return handle_toggle_recording();
             }
+            "--show-overlay" | "--open" => {
+                ensure_daemon_running();
+                // Daemon owns overlay lifetime; if it is unreachable, open the HUD directly.
+                if send_command(Command::ShowOverlay).is_err() {
+                    ensure_hotkeys_running();
+                    if !check_and_toggle_overlay() {
+                        scythe::overlay_egui::run_egui_overlay();
+                    }
+                }
+                return Ok(());
+            }
             "--toast" => {
                 let title = args.get(2).map(|s| s.as_str()).unwrap_or("SCYTHE");
                 let subtitle = args.get(3).map(|s| s.as_str()).unwrap_or("");
@@ -540,6 +551,7 @@ fn run_client(args: Vec<String>) -> Result<(), Box<dyn std::error::Error + Send
                 println!("  scythe-ui --record       Toggle normal recording on/off (with notification)");
                 println!("  scythe-ui --stream       Toggle livestreaming on/off (with notification)");
                 println!("  scythe-ui --cursor       Toggle mouse cursor recording on/off (with notification)");
+                println!("  scythe-ui --show-overlay Open the HUD overlay via the daemon (no toggle)");
                 println!("  scythe-ui --start        Start normal recording");
                 println!("  scythe-ui --stop         Stop normal recording");
                 println!("  scythe-ui --reload       Reload daemon configuration");
diff --git a/src/overlay_egui.rs b/src/overlay_egui.rs
index afeec1f..19c885e 100644
--- a/src/overlay_egui.rs
+++ b/src/overlay_egui.rs
@@ -1131,21 +1131,11 @@ pub struct ScytheOverlayApp {
     pub screenshot_dir: String,
     pub screenshot_format: String,
     pub screenshot_cursor: bool,
-    pub capture_source: String,
     pub video_quality_mode: String,
     pub color_range: String,
-    pub replay_storage: String,
     pub record_low_power: bool,
     pub show_replay_notifications: bool,
-    pub container_format: String,
-    pub change_resolution: bool,
-    pub resolution_w: u32,
-    pub resolution_h: u32,
-    pub res_w_str: String,
-    pub res_h_str: String,
     pub restart_replay_on_save: bool,
-    pub show_scroll_lock_led: bool,
-    pub autostart_on_game: bool,
     pub autostart_power_only: bool,
     pub screenshot_quality: u32,
     pub screenshot_preset: String,
@@ -1225,22 +1215,12 @@ impl ScytheOverlayApp {
         let screenshot_dir = config.screenshot_directory.clone();
         let screenshot_format = config.screenshot_format.clone();
         let screenshot_cursor = config.screenshot_cursor;
-        let capture_source = config.capture_source.clone();
         let video_quality_mode = config.video_quality_mode.clone();
         let color_range = config.color_range.clone();
-        let replay_storage = config.replay_storage.clone();
         let record_low_power = config.record_low_power;
         let show_replay_notifications = config.show_replay_notifications;
 
-        let container_format = config.container_format.clone();
-        let change_resolution = config.change_resolution;
-        let resolution_w = config.resolution_w;
-        let resolution_h = config.resolution_h;
-        let res_w_str = resolution_w.to_string();
-        let res_h_str = resolution_h.to_string();
         let restart_replay_on_save = config.restart_replay_on_save;
-        let show_scroll_lock_led = config.show_scroll_lock_led;
-        let autostart_on_game = config.autostart_on_game;
         let autostart_power_only = config.autostart_power_only;
         let screenshot_quality = config.screenshot_quality;
         let screenshot_preset = config.screenshot_preset.clone();
@@ -1307,21 +1287,11 @@ impl ScytheOverlayApp {
             screenshot_dir,
             screenshot_format,
             screenshot_cursor,
-            capture_source,
             video_quality_mode,
             color_range,
-            replay_storage,
             record_low_power,
             show_replay_notifications,
-            container_format,
-            change_resolution,
-            resolution_w,
-            resolution_h,
-            res_w_str,
-            res_h_str,
             restart_replay_on_save,
-            show_scroll_lock_led,
-            autostart_on_game,
             autostart_power_only,
             screenshot_quality,
             screenshot_preset,
@@ -1362,19 +1332,11 @@ impl ScytheOverlayApp {
         self.config.screenshot_directory = self.screenshot_dir.clone();
         self.config.screenshot_format = self.screenshot_format.clone();
         self.config.screenshot_cursor = self.screenshot_cursor;
-        self.config.capture_source = self.capture_source.clone();
         self.config.video_quality_mode = self.video_quality_mode.clone();
         self.config.color_range = self.color_range.clone();
-        self.config.replay_storage = self.replay_storage.clone();
         self.config.record_low_power = self.record_low_power;
         self.config.show_replay_notifications = self.show_replay_notifications;
-        self.config.container_format = "mp4".to_string();
-        self.config.change_resolution = self.change_resolution;
-        self.config.resolution_w = self.resolution_w;
-        self.config.resolution_h = self.resolution_h;
         self.config.restart_replay_on_save = self.restart_replay_on_save;
-        self.config.show_scroll_lock_led = self.show_scroll_lock_led;
-        self.config.autostart_on_game = self.autostart_on_game;
         self.config.autostart_power_only = self.autostart_power_only;
         self.config.screenshot_quality = self.screenshot_quality;
         self.config.screenshot_preset = self.screenshot_preset.clone();
@@ -1405,21 +1367,11 @@ impl ScytheOverlayApp {
         self.screenshot_dir = def.screenshot_directory;
         self.screenshot_format = def.screenshot_format;
         self.screenshot_cursor = def.screenshot_cursor;
-        self.capture_source = def.capture_source;
         self.video_quality_mode = def.video_quality_mode;
         self.color_range = def.color_range;
-        self.replay_storage = def.replay_storage;
         self.record_low_power = def.record_low_power;
         self.show_replay_notifications = def.show_replay_notifications;
-        self.container_format = "mp4".to_string();
-        self.change_resolution = def.change_resolution;
-        self.resolution_w = def.resolution_w;
-        self.resolution_h = def.resolution_h;
-        self.res_w_str = def.resolution_w.to_string();
-        self.res_h_str = def.resolution_h.to_string();
         self.restart_replay_on_save = def.restart_replay_on_save;
-        self.show_scroll_lock_led = def.show_scroll_lock_led;
-        self.autostart_on_game = def.autostart_on_game;
         self.autostart_power_only = def.autostart_power_only;
         self.screenshot_quality = def.screenshot_quality;
         self.screenshot_preset = def.screenshot_preset;
@@ -2467,18 +2419,6 @@ impl ScytheOverlayApp {
         ui.add_space(10.0);
 
         render_section_card(ui, "General", accent, |ui| {
-            ui.label(egui::RichText::new("Where should temporary replay data be stored?").size(11.5).color(Color32::from_rgb(180, 185, 190)));
-            ui.add_space(4.0);
-            ui.horizontal(|ui| {
-                if squared_button(ui, "RAM", self.replay_storage == "ram", accent) {
-                    self.replay_storage = "ram".to_string();
-                }
-                if squared_button(ui, "Disk (Not recommended on SSDs)", self.replay_storage == "disk", accent) {
-                    self.replay_storage = "disk".to_string();
-                }
-            });
-
-            ui.add_space(8.0);
             ui.horizontal(|ui| {
                 let mut rrs = self.restart_replay_on_save;
                 if toggle_switch(ui, &mut rrs, accent).changed() {
@@ -2552,14 +2492,6 @@ impl ScytheOverlayApp {
                 }
                 ui.label(egui::RichText::new("Show replay notifications").size(11.5).color(Color32::WHITE));
             });
-            ui.add_space(4.0);
-            ui.horizontal(|ui| {
-                let mut led_on = self.show_scroll_lock_led;
-                if toggle_switch(ui, &mut led_on, accent).changed() {
-                    self.show_scroll_lock_led = led_on;
-                }
-                ui.label(egui::RichText::new("Show replay status with scroll lock LED").size(11.5).color(Color32::WHITE));
-            });
         });
 
         ui.add_space(10.0);
@@ -2596,52 +2528,6 @@ impl ScytheOverlayApp {
     }
 
     fn render_tab_record(&mut self, ui: &mut egui::Ui, accent: Color32) {
-        render_section_card(ui, "Capture", accent, |ui| {
-            ui.label(egui::RichText::new("Capture source:").size(11.5).color(Color32::from_rgb(180, 185, 190)));
-            ui.add_space(3.0);
-            ui.horizontal(|ui| {
-                if squared_button(ui, "Focused monitor", self.capture_source == "focused", accent) {
-                    self.capture_source = "focused".to_string();
-                }
-                if squared_button(ui, "Monitor eDP-1 (1920x1080)", self.capture_source == "monitor", accent) {
-                    self.capture_source = "monitor".to_string();
-                }
-                if squared_button(ui, "Window", self.capture_source == "window", accent) {
-                    self.capture_source = "window".to_string();
-                }
-                if squared_button(ui, "Region", self.capture_source == "region", accent) {
-                    self.capture_source = "region".to_string();
-                }
-            });
-
-            ui.add_space(8.0);
-            ui.horizontal(|ui| {
-                let mut chg_res = self.change_resolution;
-                if toggle_switch(ui, &mut chg_res, accent).changed() {
-                    self.change_resolution = chg_res;
-                }
-                ui.label(egui::RichText::new("Change video resolution").size(11.5).color(Color32::WHITE));
-            });
-
-            if self.change_resolution {
-                ui.add_space(6.0);
-                ui.horizontal(|ui| {
-                    ui.label(egui::RichText::new("Resolution:").size(11.5).color(Color32::from_rgb(180, 185, 190)));
-                    let mut w = self.resolution_w;
-                    if numeric_input_box(ui, &mut self.res_w_str, &mut w, 640, 7680, 160, "W", accent) {
-                        self.resolution_w = w;
-                    }
-                    ui.label(egui::RichText::new("x").size(11.5).color(Color32::WHITE));
-                    let mut h = self.resolution_h;
-                    if numeric_input_box(ui, &mut self.res_h_str, &mut h, 480, 4320, 90, "H", accent) {
-                        self.resolution_h = h;
-                    }
-                });
-            }
-        });
-
-        ui.add_space(10.0);
-
         self.render_audio_controls(ui, accent);
 
         ui.add_space(10.0);
@@ -2840,16 +2726,6 @@ impl ScytheOverlayApp {
                 ui.label(egui::RichText::new("Capture mouse cursor in screenshot").size(11.5).color(Color32::WHITE));
             });
 
-            ui.add_space(8.0);
-            ui.label(egui::RichText::new("Capture source:").size(11.5).color(Color32::from_rgb(180, 185, 190)));
-            ui.add_space(4.0);
-            ui.horizontal(|ui| {
-                for (src_id, label) in [("focused", "Focused monitor"), ("full", "Full desktop")] {
-                    if squared_button(ui, label, self.capture_source == src_id, accent) {
-                        self.capture_source = src_id.to_string();
-                    }
-                }
-            });
 
             ui.add_space(8.0);
             ui.horizontal(|ui| {
@@ -4458,13 +4334,7 @@ mod tests {
     #[test]
     fn test_overlay_app_options_synchronization() {
         let mut app = ScytheOverlayApp::new();
-        app.container_format = "mp4".to_string();
-        app.change_resolution = true;
-        app.resolution_w = 2560;
-        app.resolution_h = 1440;
         app.restart_replay_on_save = false;
-        app.show_scroll_lock_led = true;
-        app.capture_source = "window".to_string();
         app.video_quality_mode = "vbr".to_string();
         app.color_range = "full".to_string();
         app.config.audio_codec = "opus".to_string();
@@ -4474,13 +4344,7 @@ mod tests {
 
         app.save_and_apply_settings();
 
-        assert_eq!(app.config.container_format, "mp4");
-        assert!(app.config.change_resolution);
-        assert_eq!(app.config.resolution_w, 2560);
-        assert_eq!(app.config.resolution_h, 1440);
         assert!(!app.config.restart_replay_on_save);
-        assert!(app.config.show_scroll_lock_led);
-        assert_eq!(app.config.capture_source, "window");
         assert_eq!(app.config.video_quality_mode, "vbr");
         assert_eq!(app.config.color_range, "full");
         assert_eq!(app.config.audio_codec, "opus");
@@ -4489,11 +4353,7 @@ mod tests {
         assert_eq!(app.config.screenshot_resolution, "1080p");
 
         app.reset_settings_to_defaults();
-        assert_eq!(app.container_format, "mp4");
-        assert!(!app.change_resolution);
         assert!(app.restart_replay_on_save);
-        assert!(!app.show_scroll_lock_led);
-        assert_eq!(app.capture_source, "focused");
         assert_eq!(app.video_quality_mode, "cbr");
         assert_eq!(app.color_range, "limited");
         assert_eq!(app.config.audio_codec, "opus");
diff --git a/tests/e2e_test.sh b/tests/e2e_test.sh
index ac47391..db4d4cb 100755
--- a/tests/e2e_test.sh
+++ b/tests/e2e_test.sh
@@ -10,6 +10,24 @@ echo "[1/6] Building release binaries..."
 cargo build --release --quiet
 
 SOCKET_PATH="${XDG_RUNTIME_DIR:-/tmp}/scythe.sock"
+
+# A live daemon owns this socket. Removing the path entry while it runs leaves the
+# kernel socket bound but unreachable, breaking the user's session until restart.
+# Shut it down gracefully instead, and refuse to run if it will not stop.
+if [ -S "$SOCKET_PATH" ] && target/release/scythe --status >/dev/null 2>&1; then
+    echo "[0/6] Stopping existing scythe daemon..."
+    target/release/scythe --quit >/dev/null 2>&1 || true
+    for _ in $(seq 1 50); do
+        [ -S "$SOCKET_PATH" ] || break
+        sleep 0.1
+    done
+    if target/release/scythe --status >/dev/null 2>&1; then
+        echo "ERROR: A scythe daemon is running and did not stop cleanly."
+        echo "       Refusing to unlink its socket. Stop it first: scythe --quit"
+        exit 1
+    fi
+fi
+
 rm -f "$SOCKET_PATH"
 rm -f record_*.mp4 replay_*.mp4