Add window state persistence and start_minimized option

- Window position, size, and maximized state saved to <exe>.window.json
  and restored on next launch
- New config option start_minimized: "on" or "off"
- Updated README with new features documentation
- Added *.window.json to .gitignore

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: AtmanActive

.gitignore

@@ -14,5 +14,8 @@ Thumbs.db
 # Claude Code
 .claude/
 
+# Window state (auto-generated, user-specific)
+*.window.json
+
 # Windows reserved filename artifact
 nul

README.md

@@ -9,6 +9,8 @@ A lightweight [Tauri v2](https://v2.tauri.app/) desktop app that wraps any websi
 - **Custom title** — Optionally set a fixed window title via config
 - **Custom icon** — Set your own window icon (ICO or PNG)
 - **Dark mode control** — Request dark/light theme from sites, or force-dark all sites (Windows)
+- **Remember window position** — Window size, position, and maximized state are saved and restored across sessions
+- **Start minimized** — Optionally launch the app minimized to the taskbar
 - **Rename-to-configure** — Rename the executable and it auto-detects its config file (`MyApp.exe` → `MyApp.json`)
 - **Cross-platform** — Builds for Windows x64, Linux x64, and macOS ARM64
 
@@ -44,6 +46,7 @@ The config file is a simple JSON file placed next to the executable. The filenam
 | `icon` | No | `""` | Path to a custom window icon (`.ico` or `.png`). Absolute path, or relative to the executable |
 | `prefer_dark_mode` | No | `"default"` | Color scheme preference: `"default"` (let OS decide), `"dark"` (request dark theme), `"light"` (request light theme). Only affects sites that support `prefers-color-scheme` CSS. Windows only |
 | `force_dark_mode` | No | `"off"` | Force-dark rendering: `"on"` or `"off"`. When `"on"`, forces all sites into dark mode even if they don't natively support it — same as Chrome's force-dark flag. Windows only |
+| `start_minimized` | No | `"off"` | Start minimized to taskbar: `"on"` or `"off"` |
 
 ### Example — minimal
 
@@ -61,7 +64,8 @@ The config file is a simple JSON file placed next to the executable. The filenam
   "title": "YouTube Music",
   "icon": "music.png",
   "prefer_dark_mode": "dark",
-  "force_dark_mode": "off"
+  "force_dark_mode": "off",
+  "start_minimized": "off"
 }
 ```
 
@@ -73,6 +77,15 @@ The config file is a simple JSON file placed next to the executable. The filenam
 
 The two options can be combined: `prefer_dark_mode` handles CSS-aware sites gracefully, while `force_dark_mode` catches everything else.
 
+### Window state persistence
+
+The app automatically remembers your window position, size, and maximized state between sessions. This works out of the box — no configuration needed.
+
+- The state is saved to `<exe_name>.window.json` beside the executable (e.g. `app.window.json`)
+- Updated every time you move, resize, or maximize/restore the window
+- On next launch, the window opens exactly where you left it
+- To reset to defaults, simply delete the `.window.json` file
+
 ## Platform Notes
 
 | Platform | Runtime Requirement |
@@ -115,7 +128,7 @@ The binary will be at `src-tauri/target/release/app` (or `app.exe` on Windows).
     ├── tauri.conf.json           # Tauri build config
     └── src/
         ├── main.rs              # Entry point
-        ├── lib.rs               # App setup, navigation, title sync, dark mode
+        ├── lib.rs               # App setup, navigation, title sync, dark mode, window state
         └── config.rs            # Config struct + loader
 ```
 

app.json

@@ -12,5 +12,8 @@
   "prefer_dark_mode": "default",
 
   "_comment_force_dark_mode": "Optional. Values: 'on' or 'off'. When 'on', forces all sites into dark mode even if they don't natively support it (like Chrome's force-dark flag). Windows only.",
-  "force_dark_mode": "off"
+  "force_dark_mode": "off",
+
+  "_comment_start_minimized": "Optional. Values: 'on' or 'off'. When 'on', the app starts minimized to the taskbar.",
+  "start_minimized": "off"
 }

src-tauri/src/config.rs

@@ -1,4 +1,4 @@
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 
 #[derive(Deserialize)]
@@ -12,6 +12,18 @@ pub struct AppConfig {
     pub prefer_dark_mode: String,
     #[serde(default)]
     pub force_dark_mode: String,
+    #[serde(default)]
+    pub start_minimized: String,
+}
+
+/// Persisted window geometry — saved beside the config as `<name>.window.json`
+#[derive(Serialize, Deserialize, Default)]
+pub struct WindowState {
+    pub x: i32,
+    pub y: i32,
+    pub width: u32,
+    pub height: u32,
+    pub maximized: bool,
 }
 
 impl AppConfig {
@@ -62,6 +74,29 @@ impl AppConfig {
         Err(format!("{} not found", config_name).into())
     }
 
+    /// Path for the window state file: `<exe_name>.window.json` beside the config
+    pub fn window_state_path() -> Option<PathBuf> {
+        let exe_name = std::env::current_exe()
+            .ok()
+            .and_then(|p| p.file_stem().map(|s| s.to_string_lossy().into_owned()))?;
+        let filename = format!("{}.window.json", exe_name);
+
+        // In debug mode, check project root first
+        #[cfg(debug_assertions)]
+        {
+            if let Ok(manifest_dir) = std::env::var("CARGO_MANIFEST_DIR") {
+                if let Some(project_root) = PathBuf::from(manifest_dir).parent() {
+                    return Some(project_root.join(&filename));
+                }
+            }
+        }
+
+        // Beside the executable
+        std::env::current_exe()
+            .ok()
+            .and_then(|p| p.parent().map(|d| d.join(&filename)))
+    }
+
     pub fn resolve_icon_path(&self) -> Option<PathBuf> {
         if self.icon.is_empty() {
             return None;
@@ -98,3 +133,19 @@ impl AppConfig {
         None
     }
 }
+
+impl WindowState {
+    pub fn load() -> Option<Self> {
+        let path = AppConfig::window_state_path()?;
+        let contents = std::fs::read_to_string(&path).ok()?;
+        serde_json::from_str(&contents).ok()
+    }
+
+    pub fn save(&self) {
+        if let Some(path) = AppConfig::window_state_path() {
+            if let Ok(json) = serde_json::to_string_pretty(self) {
+                let _ = std::fs::write(path, json);
+            }
+        }
+    }
+}

src-tauri/src/lib.rs

@@ -1,6 +1,6 @@
 mod config;
 
-use config::AppConfig;
+use config::{AppConfig, WindowState};
 use tauri::Manager;
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
@@ -25,6 +25,9 @@ pub fn run() {
                 .get_webview_window("main")
                 .expect("Failed to get main window");
 
+            // Restore saved window position/size (if available)
+            restore_window_state(&window);
+
             // Set initial title from config (if provided)
             if !config.title.is_empty() {
                 window
@@ -47,16 +50,88 @@ pub fn run() {
             let color_scheme = config.prefer_dark_mode.clone();
             setup_webview_handlers(&window, title_window, has_static_title, &color_scheme);
 
+            // Register window event handler to persist position/size
+            let save_window = window.clone();
+            window.on_window_event(move |event| {
+                use tauri::WindowEvent;
+                match event {
+                    WindowEvent::Moved(_) | WindowEvent::Resized(_) => {
+                        save_window_state(&save_window);
+                    }
+                    _ => {}
+                }
+            });
+
             // Navigate to the configured URL
             let url: tauri::Url = config.url.parse().expect("Invalid URL in config.json");
             let _ = window.navigate(url);
 
+            // Start minimized (if configured)
+            if config.start_minimized.eq_ignore_ascii_case("on") {
+                let _ = window.minimize();
+            }
+
             Ok(())
         })
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
 }
 
+/// Restore window position, size, and maximized state from the saved state file
+fn restore_window_state(window: &tauri::WebviewWindow) {
+    if let Some(state) = WindowState::load() {
+        // Validate that the saved size is reasonable (at least 200x200)
+        if state.width >= 200 && state.height >= 200 {
+            let _ = window.set_size(tauri::PhysicalSize::new(state.width, state.height));
+        }
+        // Restore position
+        let _ = window.set_position(tauri::PhysicalPosition::new(state.x, state.y));
+        // Restore maximized state
+        if state.maximized {
+            let _ = window.maximize();
+        }
+    }
+}
+
+/// Save current window position, size, and maximized state to disk
+fn save_window_state(window: &tauri::WebviewWindow) {
+    let maximized = window.is_maximized().unwrap_or(false);
+
+    // When maximized, don't overwrite the saved normal position/size —
+    // we want to restore the non-maximized geometry next time.
+    // Only save the maximized flag.
+    if maximized {
+        if let Some(mut state) = WindowState::load() {
+            state.maximized = true;
+            state.save();
+        } else {
+            // No previous state — save current dimensions with maximized flag
+            let pos = window.outer_position().unwrap_or_default();
+            let size = window.outer_size().unwrap_or_default();
+            let state = WindowState {
+                x: pos.x,
+                y: pos.y,
+                width: size.width,
+                height: size.height,
+                maximized: true,
+            };
+            state.save();
+        }
+        return;
+    }
+
+    let pos = window.outer_position().unwrap_or_default();
+    let size = window.outer_size().unwrap_or_default();
+    let state = WindowState {
+        x: pos.x,
+        y: pos.y,
+        width: size.width,
+        height: size.height,
+        maximized: false,
+    };
+    state.save();
+}
+
 #[cfg(target_os = "windows")]
 fn setup_webview_handlers(
     webview_window: &tauri::WebviewWindow,