diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index 6b577d43..99d576dd 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -3,14 +3,15 @@
 ## Architecture Overview
 
 **DropOut** is a Tauri v2 desktop application combining:
+
 - **Backend (Rust)**: Game launching, asset management, authentication, mod loader installation
-- **Frontend (Svelte 5)**: Reactive UI with Tailwind CSS 4 and particle effects
+- **Frontend (React + Svelte)**: Active React UI in `packages/ui-new`, legacy Svelte 5 UI in `packages/ui`
 - **Communication**: Tauri commands (invoke) and events (emit/listen)
 - **Pre-commit Hooks**: Python-based tooling for JSON/TOML validation (managed via `pyproject.toml`)
 
 **Key Data Flow**: Frontend invokes Rust commands → Rust processes/downloads → Rust emits progress events → Frontend updates UI via listeners
 
-**Version Management**: Uses `_version.py` for single source of truth, synced to `Cargo.toml` (0.1.24) and `tauri.conf.json`
+**Version Management**: `Cargo.toml` is the source of truth; `scripts/bump-tauri.ts` syncs `src-tauri/tauri.conf.json`
 
 ## Project Structure
 
@@ -33,59 +34,80 @@ src-tauri/          # Rust backend
       version_merge.rs # Parent version inheritance merging
     utils/
       zip.rs        # Native library extraction
-ui/                 # Svelte 5 frontend
-  src/
-    App.svelte      # Main app component, enforces dark mode
-    stores/         # Svelte 5 runes state management ($state, $effect)
-      auth.svelte.ts    # Authentication state with device code polling
-      game.svelte.ts    # Game state (running, logs)
-      settings.svelte.ts  # Settings + Java detection
-      ui.svelte.ts      # UI state (toasts, modals, active view)
-    components/     # UI components (HomeView, VersionsView, SettingsView, etc.)
-    lib/            # Reusable components (DownloadMonitor, GameConsole)
+packages/
+  ui-new/           # React frontend used by Tauri
+    src/
+      main.tsx      # React Router setup (hash routing)
+      pages/        # Route views (Home, Versions, Settings, ...)
+      stores/       # Zustand stores
+      components/   # UI components
+  ui/               # Legacy Svelte 5 frontend
+    src/
+      App.svelte    # Main app component, enforces dark mode
+      stores/       # Svelte 5 runes state management ($state, $effect)
+        auth.svelte.ts    # Authentication state with device code polling
+        game.svelte.ts    # Game state (running, logs)
+        settings.svelte.ts  # Settings + Java detection
+        ui.svelte.ts      # UI state (toasts, modals, active view)
+      components/   # UI components (HomeView, VersionsView, SettingsView, etc.)
+      lib/          # Reusable components (DownloadMonitor, GameConsole)
 ```
 
 ## Critical Development Workflows
 
 ### Development Mode
+
 ```bash
-cargo tauri dev  # Starts frontend dev server (Vite on :5173) + Tauri window
+cargo tauri dev  # Runs ui-new dev server (Vite on :5173) + Tauri window
 ```
-- Frontend uses **Rolldown-based Vite fork** (`npm:rolldown-vite@7.2.5`) with hot reload
+
+- `src-tauri/tauri.conf.json` runs `pnpm --filter @dropout/ui-new dev`
+- Frontend uses **Rolldown-based Vite fork** (`npm:rolldown-vite@^7`) with hot reload
 - Backend recompiles on Rust file changes
 - Console shows both Rust stdout and frontend Vite logs
-- **Vite Config**: Uses `usePolling: true` for watch compatibility with Tauri
 - **HMR**: WebSocket on `ws://localhost:5173`
 
 ### Pre-commit Checks
+
 - Uses **pre-commit** with Python (configured in `pyproject.toml`)
 - Hooks: JSON/TOML/YAML validation, Ruff for Python files
 - Run manually: `pre-commit run --all-files`
 - **IMPORTANT**: All Python tooling for CI/validation lives here, NOT for app logic
 
 ### Building
+
 ```bash
-cd ui && pnpm install  # Install frontend dependencies (requires pnpm 9, Node 22)
-cargo tauri build      # Produces platform bundles in src-tauri/target/release/bundle/
+pnpm install            # Install workspace deps (requires pnpm 10, Node 22)
+cargo tauri build       # Produces bundles in src-tauri/target/release/bundle/
+pnpm --filter @dropout/ui-new build  # Frontend-only build
 ```
 
 ### Frontend Workflows
+
 ```bash
-cd ui
-pnpm check         # Svelte type checking + TypeScript validation
-pnpm lint          # OxLint for code quality
-pnpm format        # OxFmt for formatting (--check for CI)
+# React UI (active)
+pnpm --filter @dropout/ui-new lint   # Biome check
+pnpm --filter @dropout/ui-new build
+
+# Svelte UI (legacy)
+pnpm --filter @dropout/ui check      # Svelte + TS checks
+pnpm --filter @dropout/ui lint       # OxLint
+pnpm --filter @dropout/ui format     # OxFmt (--check for CI)
 ```
 
 ### Testing
+
 - CI workflow: [`.github/workflows/test.yml`](.github/workflows/test.yml) tests on Ubuntu, Arch (Wayland), Windows, macOS
-- Local: `cargo test` (no comprehensive test suite exists yet)
+- Local: `cargo test` (run from `src-tauri/`)
+- Single test: `cargo test <test_name>` (unit) or `cargo test --test <integration_name>`
 - **Test workflow behavior**: Push/PR = Linux build only, `workflow_dispatch` = full multi-platform builds
 
 ## Project-Specific Patterns & Conventions
 
 ### Tauri Command Pattern
+
 Commands in [`main.rs`](../src-tauri/src/main.rs) follow this structure:
+
 ```rust
 #[tauri::command]
 async fn command_name(
@@ -98,35 +120,43 @@ async fn command_name(
     Ok(result)
 }
 ```
+
 **Register in `main()`:**
+
 ```rust
 tauri::Builder::default()
     .invoke_handler(tauri::generate_handler![command_name, ...])
 ```
 
 ### Event Communication
+
 **Rust → Frontend (Progress/Logs):**
+
 ```rust
 // In Rust
 window.emit("launcher-log", "Downloading assets...")?;
 window.emit("download-progress", progress_struct)?;
 ```
+
 ```typescript
-// In Frontend (Svelte)
+// In Frontend (React/Svelte)
 import { listen } from "@tauri-apps/api/event";
 const unlisten = await listen("launcher-log", (event) => {
-    console.log(event.payload);
+  console.log(event.payload);
 });
 ```
 
 **Frontend → Rust (Commands):**
+
 ```typescript
 import { invoke } from "@tauri-apps/api/core";
 const result = await invoke("start_game", { versionId: "1.20.4" });
 ```
 
 ### State Management (Rust)
+
 Global state via Tauri's managed state:
+
 ```rust
 pub struct ConfigState {
     pub config: Mutex<LauncherConfig>,
@@ -138,14 +168,16 @@ pub struct ConfigState {
 config_state: State<'_, ConfigState>
 ```
 
-### State Management (Svelte 5)
-Uses **Svelte 5 runes** (not stores):
+### State Management (Svelte 5, legacy UI)
+
+Uses **Svelte 5 runes** (not stores) in `packages/ui`:
+
 ```typescript
 // stores/auth.svelte.ts
 export class AuthState {
   currentAccount = $state<Account | null>(null);  // Reactive state
   isLoginModalOpen = $state(false);
-  
+
   $effect(() => {  // Side effects
     // Runs when dependencies change
   });
@@ -153,64 +185,83 @@ export class AuthState {
 // Export singleton
 export const authState = new AuthState();
 ```
+
 **CRITICAL**: Stores are TypeScript classes with `$state` runes, not Svelte 4's `writable()`. Each store file exports a singleton instance.
 
-**Store Pattern**: 
-- File: `stores/*.svelte.ts` (note `.svelte.ts` extension)
+**Store Pattern**:
+
+- File: `packages/ui/src/stores/*.svelte.ts` (note `.svelte.ts` extension)
 - Class-based with reactive `$state` properties
 - Methods for actions (async operations with `invoke()`)
 - Derived values with `get` accessors
 - Side effects with `$effect()` (auto-tracks dependencies)
 
+### State Management (React UI)
+
+`packages/ui-new` uses Zustand stores in `src/stores` with `create(...)` and hook exports (e.g., `useUIStore`).
+
 ### Version Inheritance System
+
 Modded versions (Fabric/Forge) use `inheritsFrom` field:
+
 - [`version_merge.rs`](../src-tauri/src/core/version_merge.rs): Merges parent vanilla JSON with mod loader JSON
 - [`manifest.rs`](../src-tauri/src/core/manifest.rs): `load_version()` recursively resolves inheritance
 - Libraries, assets, arguments are merged from parent + modded version
 
 ### Microsoft Authentication Flow
+
 Uses **Device Code Flow** (no redirect needed):
+
 1. Frontend calls `start_microsoft_login()` → gets device code + URL
 2. User visits URL in browser, enters code
-3. Frontend polls `complete_microsoft_login()` with device code
-4. Rust exchanges code → MS token → Xbox Live → XSTS → Minecraft token
-5. Stores MS refresh token for auto-refresh (see [`auth.rs`](../src-tauri/src/core/auth.rs))
+3. Frontend calls `complete_microsoft_login()` with device code
+4. Rust exchanges code → MS token → Xbox Live → XSTS → Minecraft token → profile
+5. Emits `auth-progress` during the flow and stores MS refresh token
 
-**Client ID**: Uses ATLauncher's public client ID (`c36a9fb6-4f2a-41ff-90bd-ae7cc92031eb`)
+**Client ID**: `CLIENT_ID` in [`auth.rs`](../src-tauri/src/core/auth.rs) is `fe165602-5410-4441-92f7-326e10a7cb82`.
 
 ### Download System
+
 [`downloader.rs`](../src-tauri/src/core/downloader.rs) features:
+
 - **Concurrent downloads** with semaphore (configurable threads)
 - **Resumable downloads**: `.part` + `.part.meta` files track progress
 - **Multi-segment downloads**: Large files split into segments downloaded in parallel
 - **Checksum verification**: SHA1/SHA256 validation
-- **Progress events**: Emits `download-progress` with file name, bytes, ETA
+- **Progress events**: Emits `download-progress` with file/status, bytes, and totals (plus `download-start`)
 - **Queue persistence**: Java downloads saved to `download_queue.json` for resumption
 
 ### Java Management
-[`java.rs`](../src-tauri/src/core/java.rs):
-- **Auto-detection**: Scans `/usr/lib/jvm`, `/Library/Java`, `JAVA_HOME`, `PATH`
-- **Adoptium API**: Fetches available JDK/JRE versions for current OS/arch
-- **Catalog caching**: `java_catalog.json` cached for 24 hours
-- **Installation**: Downloads, extracts to `app_data_dir/java/<version>`
-- **Cancellation**: Global `AtomicBool` flag for download cancellation
+
+`src-tauri/src/core/java/` module:
+
+- **Auto-detection**: PATH/JAVA_HOME plus OS-specific directories (e.g., `/usr/lib/jvm`, `/Library/Java/JavaVirtualMachines`, `Program Files\\Java`)
+- **Catalog caching**: `java_catalog_cache.json` cached for 24 hours
+- **Installation**: Downloads with queue persistence, extracts to `app_data_dir/java/<provider>-<major>-<jre|jdk>`
+- **Download progress event**: `java-download-progress`
 
 ### Error Handling
+
 - Commands return `Result<T, String>` (String for JS-friendly errors)
 - Use `.map_err(|e| e.to_string())` to convert errors
 - Emit detailed error logs: `emit_log!(window, format!("Error: {}", e))`
 
 ### File Paths
-- **Game directory**: `app_handle.path().app_data_dir()` (~/.local/share/com.dropout.launcher on Linux)
-- **Versions**: `game_dir/versions/<version_id>/<version_id>.json`
-- **Libraries**: `game_dir/libraries/<maven-path>`
-- **Assets**: `game_dir/assets/objects/<hash[0..2]>/<hash>`
-- **Config**: `game_dir/config.json`
-- **Accounts**: `game_dir/accounts.json`
+
+- **App data root**: `app_handle.path().app_data_dir()` (platform-specific)
+- **Instance metadata**: `app_data_dir/instances.json`
+- **Instance game dir**: `app_data_dir/instances/<instance_id>/`
+  - Versions: `versions/<version_id>/<version_id>.json`
+  - Libraries: `libraries/<maven-path>`
+  - Assets: `assets/objects/<hash[0..2]>/<hash>`
+- **Shared caches** (when `use_shared_caches`): `app_data_dir/{versions,libraries,assets}`
+- **Config**: `app_data_dir/config.json`
+- **Accounts**: `app_data_dir/accounts.json`
 
 ## Integration Points
 
 ### External APIs
+
 - **Mojang**: `https://piston-meta.mojang.com/mc/game/version_manifest_v2.json`
 - **Fabric Meta**: `https://meta.fabricmc.net/v2/`
 - **Forge Maven**: `https://maven.minecraftforge.net/`
@@ -218,6 +269,7 @@ Uses **Device Code Flow** (no redirect needed):
 - **GitHub Releases**: `https://api.github.com/repos/HsiangNianian/DropOut/releases`
 
 ### Native Dependencies
+
 - **Linux**: `libwebkit2gtk-4.1-dev`, `libgtk-3-dev` (see [test.yml](../.github/workflows/test.yml))
 - **macOS**: System WebKit via Tauri
 - **Windows**: WebView2 runtime (bundled)
@@ -225,40 +277,45 @@ Uses **Device Code Flow** (no redirect needed):
 ## Common Tasks
 
 ### Adding a New Tauri Command
+
 1. Define function in [`main.rs`](../src-tauri/src/main.rs) with `#[tauri::command]`
 2. Add to `.invoke_handler(tauri::generate_handler![..., new_command])`
 3. Call from frontend: `invoke("new_command", { args })`
 
 ### Adding a New UI View
-1. Create component in `ui/src/components/NewView.svelte`
-2. Import in [`App.svelte`](../ui/src/App.svelte)
-3. Add navigation in [`Sidebar.svelte`](../ui/src/components/Sidebar.svelte)
-4. Update `uiState.activeView` in [`ui.svelte.ts`](../ui/src/stores/ui.svelte.ts)
+
+- **React UI (active)**: add a page in `packages/ui-new/src/pages` and register the route in [`main.tsx`](../packages/ui-new/src/main.tsx).
+- **Svelte UI (legacy)**: create component in `packages/ui/src/components`, import in [`App.svelte`](../packages/ui/src/App.svelte), update `uiState.activeView` in [`ui.svelte.ts`](../packages/ui/src/stores/ui.svelte.ts).
 
 ### Emitting Progress Events
+
 Use `emit_log!` macro for launcher logs:
+
 ```rust
 emit_log!(window, format!("Downloading {}", filename));
 ```
+
 For custom events:
+
 ```rust
 window.emit("custom-event", payload)?;
 ```
 
 ### Handling Placeholders in Arguments
+
 Game arguments may contain `${variable}` placeholders. Use the `has_unresolved_placeholder()` helper to skip malformed arguments (see [`main.rs:57-67`](../src-tauri/src/main.rs#L57-L67)).
 
 ## Important Notes
 
-- **Dark mode enforced**: [`App.svelte`](../ui/src/App.svelte) force-adds `dark` class regardless of system preference
+- **Dark mode enforced (legacy UI)**: [`App.svelte`](../packages/ui/src/App.svelte) force-adds `dark` class regardless of system preference
 - **Svelte 5 syntax**: Use `$state`, `$derived`, `$effect` (not `writable` stores)
-- **No CREATE_NO_WINDOW on non-Windows**: Use `#[cfg(target_os = "windows")]` for Windows-specific code
+- **Java launch on Windows**: Uses `CREATE_NO_WINDOW` behind `#[cfg(target_os = "windows")]`
 - **Version IDs**: Fabric uses `fabric-loader-<loader>-<game>`, Forge uses `<game>-forge-<loader>`
-- **Mod loader libraries**: Don't have `downloads.artifact`, use Maven resolution via [`maven.rs`](../src-tauri/src/core/maven.rs)
+- **Library resolution**: When `downloads.artifact` is missing, resolve via Maven coordinates in [`maven.rs`](../src-tauri/src/core/maven.rs)
 - **Native extraction**: Extract to `versions/<version>/natives/`, exclude META-INF
 - **Classpath order**: Libraries → Client JAR (see [`main.rs:437-453`](../src-tauri/src/main.rs#L437-L453))
-- **Version management**: Single source in `_version.py`, synced to Cargo.toml and tauri.conf.json
-- **Frontend dependencies**: Must use pnpm 9 + Node 22 (uses Rolldown-based Vite fork)
+- **Version management**: `Cargo.toml` version is synced to `tauri.conf.json` via `pnpm bump-tauri`
+- **Frontend dependencies**: Use Node 22 + pnpm 10 (Rolldown-based Vite fork)
 - **Store files**: Must have `.svelte.ts` extension, not `.ts`
 
 ## Debugging Tips
@@ -272,15 +329,16 @@ Game arguments may contain `${variable}` placeholders. Use the `has_unresolved_p
 ## Version Compatibility
 
 - **Rust**: Edition 2021, requires Tauri v2 dependencies
-- **Node.js**: 22+ with pnpm 9+ for frontend (uses Rolldown-based Vite fork `npm:rolldown-vite@7.2.5`)
+- **Node.js**: 22+ with pnpm 10+ for frontend (uses Rolldown-based Vite fork `npm:rolldown-vite@^7`)
 - **Tauri**: v2.9+
 - **Svelte**: v5.46+ (runes mode)
-- **Java**: Supports detection of Java 8-23+, recommends Java 17+ for modern Minecraft
+- **Java**: Required versions come from `javaVersion` in version JSON; Java 8 is enforced as a max for old versions
 - **Python**: 3.10+ for pre-commit hooks (validation only, not app logic)
 
 ## Commit Conventions
 
 Follow instructions in [`.github/instructions/commit.instructions.md`](.github/instructions/commit.instructions.md):
+
 - **Format**: `<type>[scope]: <description>` (lowercase, imperative, no period)
 - **AI commits**: MUST include `Reviewed-by: [MODEL_NAME]`
 - **Common types**: `feat`, `fix`, `docs`, `refactor`, `perf`, `test`, `chore`
diff --git a/.gitignore b/.gitignore
index 1419805a..22fcb7f0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -34,3 +34,6 @@ release/
 
 # claude code
 .claude/
+
+# Vscode
+.vscode/
diff --git a/packages/ui/src/client.ts b/packages/ui/src/client.ts
index 18d2377f..07398616 100644
--- a/packages/ui/src/client.ts
+++ b/packages/ui/src/client.ts
@@ -25,6 +25,13 @@ import type {
   VersionMetadata,
 } from "@/types";
 
+export interface InstanceRepairResult {
+  restoredInstances: number;
+  removedStaleEntries: number;
+  createdDefaultActive: boolean;
+  activeInstanceId: string | null;
+}
+
 export function assistantChat(messages: Message[]): Promise<Message> {
   return invoke<Message>("assistant_chat", {
     messages,
@@ -119,6 +126,16 @@ export function duplicateInstance(
   });
 }
 
+export function exportInstance(
+  instanceId: string,
+  archivePath: string,
+): Promise<string> {
+  return invoke<string>("export_instance", {
+    instanceId,
+    archivePath,
+  });
+}
+
 export function fetchAdoptiumJava(
   majorVersion: number,
   imageType: string,
@@ -267,6 +284,16 @@ export function installVersion(
   });
 }
 
+export function importInstance(
+  archivePath: string,
+  newName?: string,
+): Promise<Instance> {
+  return invoke<Instance>("import_instance", {
+    archivePath,
+    newName,
+  });
+}
+
 export function isFabricInstalled(
   instanceId: string,
   gameVersion: string,
@@ -351,6 +378,10 @@ export function refreshJavaCatalog(): Promise<JavaCatalog> {
   return invoke<JavaCatalog>("refresh_java_catalog");
 }
 
+export function repairInstances(): Promise<InstanceRepairResult> {
+  return invoke<InstanceRepairResult>("repair_instances");
+}
+
 export function resumeJavaDownloads(): Promise<JavaInstallation[]> {
   return invoke<JavaInstallation[]>("resume_java_downloads");
 }
@@ -383,6 +414,10 @@ export function startGame(
   });
 }
 
+export function stopGame(): Promise<string> {
+  return invoke<string>("stop_game");
+}
+
 export function startMicrosoftLogin(): Promise<DeviceCodeResponse> {
   return invoke<DeviceCodeResponse>("start_microsoft_login");
 }
diff --git a/packages/ui/src/components/bottom-bar.tsx b/packages/ui/src/components/bottom-bar.tsx
index 0710c3ae..8f709852 100644
--- a/packages/ui/src/components/bottom-bar.tsx
+++ b/packages/ui/src/components/bottom-bar.tsx
@@ -1,11 +1,10 @@
-import { listen, type UnlistenFn } from "@tauri-apps/api/event";
 import { Play, User, XIcon } from "lucide-react";
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useCallback, useEffect, useState } from "react";
 import { toast } from "sonner";
-import { listInstalledVersions, startGame } from "@/client";
 import { cn } from "@/lib/utils";
 import { useAuthStore } from "@/models/auth";
 import { useInstanceStore } from "@/models/instance";
+import { useGameStore } from "@/stores/game-store";
 import { LoginModal } from "./login-modal";
 import { Button } from "./ui/button";
 import {
@@ -18,150 +17,74 @@ import {
 } from "./ui/select";
 import { Spinner } from "./ui/spinner";
 
-interface InstalledVersion {
-  id: string;
-  type: string;
-}
-
 export function BottomBar() {
-  const authStore = useAuthStore();
-  const instancesStore = useInstanceStore();
+  const account = useAuthStore((state) => state.account);
+  const instances = useInstanceStore((state) => state.instances);
+  const activeInstance = useInstanceStore((state) => state.activeInstance);
+  const setActiveInstance = useInstanceStore((state) => state.setActiveInstance);
+  const selectedVersion = useGameStore((state) => state.selectedVersion);
+  const setSelectedVersion = useGameStore((state) => state.setSelectedVersion);
+  const startGame = useGameStore((state) => state.startGame);
+  const stopGame = useGameStore((state) => state.stopGame);
+  const runningInstanceId = useGameStore((state) => state.runningInstanceId);
+  const launchingInstanceId = useGameStore((state) => state.launchingInstanceId);
+  const stoppingInstanceId = useGameStore((state) => state.stoppingInstanceId);
 
-  const [isLaunched, setIsLaunched] = useState<boolean>(false);
-  const gameUnlisten = useRef<UnlistenFn | null>(null);
-  const [isLaunching, setIsLaunching] = useState<boolean>(false);
-  const [selectedVersion, setSelectedVersion] = useState<string | null>(null);
-  const [installedVersions, setInstalledVersions] = useState<
-    InstalledVersion[]
-  >([]);
-  const [isLoadingVersions, setIsLoadingVersions] = useState(true);
   const [showLoginModal, setShowLoginModal] = useState(false);
 
-  const loadInstalledVersions = useCallback(async () => {
-    if (!instancesStore.activeInstance) {
-      setInstalledVersions([]);
-      setIsLoadingVersions(false);
+  useEffect(() => {
+    const nextVersion = activeInstance?.versionId ?? "";
+    if (selectedVersion === nextVersion) {
       return;
     }
 
-    setIsLoadingVersions(true);
-    try {
-      const versions = await listInstalledVersions(
-        instancesStore.activeInstance.id,
-      );
-      setInstalledVersions(versions);
+    setSelectedVersion(nextVersion);
+  }, [activeInstance?.id, activeInstance?.versionId, selectedVersion, setSelectedVersion]);
 
-      // If no version is selected but we have installed versions, select the first one
-      if (!selectedVersion && versions.length > 0) {
-        setSelectedVersion(versions[0].id);
+  const handleInstanceChange = useCallback(
+    async (instanceId: string) => {
+      if (activeInstance?.id === instanceId) {
+        return;
       }
-    } catch (error) {
-      console.error("Failed to load installed versions:", error);
-    } finally {
-      setIsLoadingVersions(false);
-    }
-  }, [instancesStore.activeInstance, selectedVersion]);
 
-  useEffect(() => {
-    loadInstalledVersions();
-
-    // Listen for backend events that should refresh installed versions.
-    let unlistenDownload: UnlistenFn | null = null;
-    let unlistenVersionDeleted: UnlistenFn | null = null;
-
-    (async () => {
-      try {
-        unlistenDownload = await listen("download-complete", () => {
-          loadInstalledVersions();
-        });
-      } catch (err) {
-        // best-effort: do not break UI if listening fails
-        // eslint-disable-next-line no-console
-        console.warn("Failed to attach download-complete listener:", err);
+      const nextInstance = instances.find((instance) => instance.id === instanceId);
+      if (!nextInstance) {
+        return;
       }
 
       try {
-        unlistenVersionDeleted = await listen("version-deleted", () => {
-          loadInstalledVersions();
-        });
-      } catch (err) {
-        // eslint-disable-next-line no-console
-        console.warn("Failed to attach version-deleted listener:", err);
+        await setActiveInstance(nextInstance);
+      } catch (error) {
+        console.error("Failed to activate instance:", error);
+        toast.error(`Failed to activate instance: ${String(error)}`);
       }
-    })();
-
-    return () => {
-      try {
-        if (unlistenDownload) unlistenDownload();
-      } catch {
-        // ignore
-      }
-      try {
-        if (unlistenVersionDeleted) unlistenVersionDeleted();
-      } catch {
-        // ignore
-      }
-    };
-  }, [loadInstalledVersions]);
+    },
+    [activeInstance?.id, instances, setActiveInstance],
+  );
 
   const handleStartGame = async () => {
-    if (!selectedVersion) {
-      toast.info("Please select a version!");
-      return;
-    }
-
-    if (!instancesStore.activeInstance) {
+    if (!activeInstance) {
       toast.info("Please select an instance first!");
       return;
     }
 
-    try {
-      gameUnlisten.current = await listen("game-exited", () => {
-        setIsLaunched(false);
-      });
-    } catch (error) {
-      toast.warning(`Failed to listen to game-exited event: ${error}`);
-    }
-
-    setIsLaunching(true);
-    try {
-      await startGame(instancesStore.activeInstance?.id, selectedVersion);
-      setIsLaunched(true);
-    } catch (error) {
-      console.error(`Failed to start game: ${error}`);
-      toast.error(`Failed to start game: ${error}`);
-    } finally {
-      setIsLaunching(false);
-    }
+    await startGame(
+      account,
+      () => setShowLoginModal(true),
+      activeInstance.id,
+      selectedVersion || activeInstance.versionId,
+      () => undefined,
+    );
   };
 
-  const getVersionTypeColor = (type: string) => {
-    switch (type) {
-      case "release":
-        return "bg-emerald-500";
-      case "snapshot":
-        return "bg-amber-500";
-      case "old_beta":
-        return "bg-rose-500";
-      case "old_alpha":
-        return "bg-violet-500";
-      default:
-        return "bg-gray-500";
-    }
+  const handleStopGame = async () => {
+    await stopGame(runningInstanceId);
   };
 
-  const versionOptions = useMemo(
-    () =>
-      installedVersions.map((v) => ({
-        label: `${v.id}${v.type !== "release" ? ` (${v.type})` : ""}`,
-        value: v.id,
-        type: v.type,
-      })),
-    [installedVersions],
-  );
-
   const renderButton = () => {
-    if (!authStore.account) {
+    const isGameRunning = runningInstanceId !== null;
+
+    if (!account) {
       return (
         <Button
           className="px-4 py-2"
@@ -173,20 +96,20 @@ export function BottomBar() {
       );
     }
 
-    return isLaunched ? (
-      <Button
-        variant="destructive"
-        onClick={() => {
-          toast.warning(
-            "Minecraft Process will not be terminated, please close it manually.",
-          );
-          setIsLaunched(false);
-        }}
-      >
-        <XIcon />
-        Game started
-      </Button>
-    ) : (
+    if (isGameRunning) {
+      return (
+        <Button
+          variant="destructive"
+          onClick={handleStopGame}
+          disabled={stoppingInstanceId !== null}
+        >
+          {stoppingInstanceId ? <Spinner /> : <XIcon />}
+          Close
+        </Button>
+      );
+    }
+
+    return (
       <Button
         className={cn(
           "px-4 py-2 shadow-xl",
@@ -194,9 +117,9 @@ export function BottomBar() {
         )}
         size="lg"
         onClick={handleStartGame}
-        disabled={isLaunching}
+        disabled={launchingInstanceId === activeInstance?.id}
       >
-        {isLaunching ? <Spinner /> : <Play />}
+        {launchingInstanceId === activeInstance?.id ? <Spinner /> : <Play />}
         Start
       </Button>
     );
@@ -206,40 +129,39 @@ export function BottomBar() {
     <div className="absolute bottom-0 left-0 right-0 bg-linear-to-t from-black/30 via-transparent to-transparent p-4 z-10">
       <div className="max-w-7xl mx-auto">
         <div className="flex items-center justify-between bg-white/5 dark:bg-black/20 backdrop-blur-xl border border-white/10 dark:border-white/5 p-3 shadow-lg">
-          <div className="flex items-center gap-4">
-            <div className="flex flex-col">
-              <span className="text-xs font-mono text-zinc-400 uppercase tracking-wider">
-                Active Instance
-              </span>
-              <span className="text-sm font-medium text-white">
-                {instancesStore.activeInstance?.name || "No instance selected"}
-              </span>
-            </div>
-
+          <div className="flex items-center gap-4 min-w-0">
             <Select
-              value={selectedVersion}
-              items={versionOptions}
-              onValueChange={setSelectedVersion}
-              disabled={isLoadingVersions}
+              value={activeInstance?.id ?? null}
+              items={instances.map((instance) => ({
+                label: instance.name,
+                value: instance.id,
+              }))}
+              onValueChange={(value) => {
+                if (value) {
+                  void handleInstanceChange(value);
+                }
+              }}
+              disabled={instances.length === 0}
             >
-              <SelectTrigger className="max-w-48">
+              <SelectTrigger className="w-full min-w-64 max-w-80">
                 <SelectValue
                   placeholder={
-                    isLoadingVersions
-                      ? "Loading versions..."
-                      : "Please select a version"
+                    instances.length === 0
+                      ? "No instances available"
+                      : "Please select an instance"
                   }
                 />
               </SelectTrigger>
               <SelectContent alignItemWithTrigger={false}>
                 <SelectGroup>
-                  {versionOptions.map((item) => (
-                    <SelectItem
-                      key={item.value}
-                      value={item.value}
-                      className={getVersionTypeColor(item.type)}
-                    >
-                      {item.label}
+                  {instances.map((instance) => (
+                    <SelectItem key={instance.id} value={instance.id}>
+                      <div className="flex min-w-0 flex-col">
+                        <span className="truncate">{instance.name}</span>
+                        <span className="text-muted-foreground truncate text-[11px]">
+                          {instance.versionId ?? "No version selected"}
+                        </span>
+                      </div>
                     </SelectItem>
                   ))}
                 </SelectGroup>
diff --git a/packages/ui/src/models/auth.ts b/packages/ui/src/models/auth.ts
index 10b2a0d9..9c814d25 100644
--- a/packages/ui/src/models/auth.ts
+++ b/packages/ui/src/models/auth.ts
@@ -13,6 +13,10 @@ import {
 } from "@/client";
 import type { Account, DeviceCodeResponse } from "@/types";
 
+function getAuthErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
 export interface AuthState {
   account: Account | null;
   loginMode: Account["type"] | null;
@@ -68,36 +72,78 @@ export const useAuthStore = create<AuthState>((set, get) => ({
       toast.warning("Failed to attch auth-progress listener");
     }
 
-    const deviceCode = await startMicrosoftLogin();
-    navigator.clipboard?.writeText(deviceCode.userCode).catch((err) => {
-      console.error("Failed to copy to clipboard:", err);
-    });
-    open(deviceCode.verificationUri).catch((err) => {
-      console.error("Failed to open browser:", err);
-    });
-    const ms = Number(deviceCode.interval) * 1000;
-    const interval = setInterval(() => {
-      _pollLoginStatus(deviceCode.deviceCode, onSuccess);
-    }, ms);
-    set({ _pollingInterval: interval, deviceCode });
+    try {
+      const deviceCode = await startMicrosoftLogin();
+
+      navigator.clipboard?.writeText(deviceCode.userCode).catch((err) => {
+        console.error("Failed to copy to clipboard:", err);
+      });
+      open(deviceCode.verificationUri).catch((err) => {
+        console.error("Failed to open browser:", err);
+      });
+
+      const ms = Math.max(1, Number(deviceCode.interval) || 5) * 1000;
+      const interval = setInterval(() => {
+        _pollLoginStatus(deviceCode.deviceCode, onSuccess);
+      }, ms);
+
+      set({
+        _pollingInterval: interval,
+        deviceCode,
+        statusMessage: deviceCode.message ?? "Waiting for authorization...",
+      });
+    } catch (error) {
+      const message = getAuthErrorMessage(error);
+      console.error("Failed to start Microsoft login:", error);
+      set({ loginMode: null, statusMessage: `Failed to start login: ${message}` });
+      toast.error(`Failed to start Microsoft login: ${message}`);
+    }
   },
   _pollLoginStatus: async (deviceCode, onSuccess) => {
     const { _pollingInterval, _mutex: mutex, _progressUnlisten } = get();
     if (mutex.isLocked) return;
-    mutex.acquire();
+
+    await mutex.acquire();
+
     try {
       const account = await completeMicrosoftLogin(deviceCode);
       clearInterval(_pollingInterval ?? undefined);
       _progressUnlisten?.();
       onSuccess?.();
-      set({ account, loginMode: "microsoft" });
-    } catch (error) {
-      if (error === "authorization_pending") {
-        console.log("Authorization pending...");
-      } else {
-        console.error("Failed to poll login status:", error);
-        toast.error("Failed to poll login status");
+      set({
+        account,
+        loginMode: "microsoft",
+        deviceCode: null,
+        _pollingInterval: null,
+        _progressUnlisten: null,
+        statusMessage: "Login successful",
+      });
+    } catch (error: unknown) {
+      const message = getAuthErrorMessage(error);
+
+      if (message.includes("authorization_pending")) {
+        set({ statusMessage: "Waiting for authorization..." });
+        return;
+      }
+
+      if (message.includes("slow_down")) {
+        set({ statusMessage: "Microsoft asked to slow down polling..." });
+        return;
       }
+
+      clearInterval(_pollingInterval ?? undefined);
+      _progressUnlisten?.();
+
+      set({
+        loginMode: null,
+        deviceCode: null,
+        _pollingInterval: null,
+        _progressUnlisten: null,
+        statusMessage: `Login failed: ${message}`,
+      });
+
+      console.error("Failed to poll login status:", error);
+      toast.error(`Microsoft login failed: ${message}`);
     } finally {
       mutex.release();
     }
@@ -111,6 +157,7 @@ export const useAuthStore = create<AuthState>((set, get) => ({
     }
     set({
       loginMode: null,
+      deviceCode: null,
       _pollingInterval: null,
       statusMessage: null,
       _progressUnlisten: null,
diff --git a/packages/ui/src/models/instance.ts b/packages/ui/src/models/instance.ts
index b1b463eb..e1eb7c15 100644
--- a/packages/ui/src/models/instance.ts
+++ b/packages/ui/src/models/instance.ts
@@ -4,10 +4,13 @@ import {
   createInstance,
   deleteInstance,
   duplicateInstance,
+  exportInstance,
   getActiveInstance,
   getInstance,
+  importInstance,
   listInstances,
-  setActiveInstance,
+  repairInstances,
+  setActiveInstance as setActiveInstanceCommand,
   updateInstance,
 } from "@/client";
 import type { Instance } from "@/types";
@@ -22,6 +25,9 @@ interface InstanceState {
   update: (instance: Instance) => Promise<void>;
   setActiveInstance: (instance: Instance) => Promise<void>;
   duplicate: (id: string, newName: string) => Promise<Instance | null>;
+  exportArchive: (id: string, archivePath: string) => Promise<void>;
+  importArchive: (archivePath: string, newName?: string) => Promise<Instance | null>;
+  repair: () => Promise<void>;
   get: (id: string) => Promise<Instance | null>;
 }
 
@@ -30,14 +36,20 @@ export const useInstanceStore = create<InstanceState>((set, get) => ({
   activeInstance: null,
 
   refresh: async () => {
-    const { setActiveInstance } = get();
     try {
       const instances = await listInstances();
-      const activeInstance = await getActiveInstance();
+      let activeInstance = await getActiveInstance();
+
+      if (
+        activeInstance &&
+        !instances.some((instance) => instance.id === activeInstance?.id)
+      ) {
+        activeInstance = null;
+      }
 
       if (!activeInstance && instances.length > 0) {
-        // If no active instance but instances exist, set the first one as active
-        await setActiveInstance(instances[0]);
+        await setActiveInstanceCommand(instances[0].id);
+        activeInstance = instances[0];
       }
 
       set({ instances, activeInstance });
@@ -51,35 +63,27 @@ export const useInstanceStore = create<InstanceState>((set, get) => ({
     const { refresh } = get();
     try {
       const instance = await createInstance(name);
+      await setActiveInstanceCommand(instance.id);
       await refresh();
       toast.success(`Instance "${name}" created successfully`);
       return instance;
     } catch (e) {
       console.error("Failed to create instance:", e);
-      toast.error("Error creating instance");
+      toast.error(String(e));
       return null;
     }
   },
 
   delete: async (id) => {
-    const { refresh, instances, activeInstance, setActiveInstance } = get();
+    const { refresh } = get();
     try {
       await deleteInstance(id);
       await refresh();
 
-      // If deleted instance was active, set another as active
-      if (activeInstance?.id === id) {
-        if (instances.length > 0) {
-          await setActiveInstance(instances[0]);
-        } else {
-          set({ activeInstance: null });
-        }
-      }
-
       toast.success("Instance deleted successfully");
     } catch (e) {
       console.error("Failed to delete instance:", e);
-      toast.error("Error deleting instance");
+      toast.error(String(e));
     }
   },
 
@@ -96,7 +100,7 @@ export const useInstanceStore = create<InstanceState>((set, get) => ({
   },
 
   setActiveInstance: async (instance) => {
-    await setActiveInstance(instance.id);
+    await setActiveInstanceCommand(instance.id);
     set({ activeInstance: instance });
   },
 
@@ -104,16 +108,56 @@ export const useInstanceStore = create<InstanceState>((set, get) => ({
     const { refresh } = get();
     try {
       const instance = await duplicateInstance(id, newName);
+      await setActiveInstanceCommand(instance.id);
       await refresh();
       toast.success(`Instance duplicated as "${newName}"`);
       return instance;
     } catch (e) {
       console.error("Failed to duplicate instance:", e);
-      toast.error("Error duplicating instance");
+      toast.error(String(e));
+      return null;
+    }
+  },
+
+  exportArchive: async (id, archivePath) => {
+    try {
+      await exportInstance(id, archivePath);
+      toast.success("Instance exported successfully");
+    } catch (e) {
+      console.error("Failed to export instance:", e);
+      toast.error(String(e));
+    }
+  },
+
+  importArchive: async (archivePath, newName) => {
+    const { refresh } = get();
+    try {
+      const instance = await importInstance(archivePath, newName);
+      await setActiveInstanceCommand(instance.id);
+      await refresh();
+      toast.success(`Instance "${instance.name}" imported successfully`);
+      return instance;
+    } catch (e) {
+      console.error("Failed to import instance:", e);
+      toast.error(String(e));
       return null;
     }
   },
 
+  repair: async () => {
+    const { refresh } = get();
+    try {
+      const result = await repairInstances();
+      await refresh();
+      toast.success(
+        `Repair completed: restored ${result.restoredInstances}, removed ${result.removedStaleEntries}`,
+      );
+    } catch (e) {
+      console.error("Failed to repair instances:", e);
+      toast.error(String(e));
+    }
+  },
+
   get: async (id) => {
     try {
       return await getInstance(id);
diff --git a/packages/ui/src/pages/index.tsx b/packages/ui/src/pages/index.tsx
index 093ccb2e..db08acce 100644
--- a/packages/ui/src/pages/index.tsx
+++ b/packages/ui/src/pages/index.tsx
@@ -5,11 +5,13 @@ import { Sidebar } from "@/components/sidebar";
 import { useAuthStore } from "@/models/auth";
 import { useInstanceStore } from "@/models/instance";
 import { useSettingsStore } from "@/models/settings";
+import { useGameStore } from "@/stores/game-store";
 
 export function IndexPage() {
   const authStore = useAuthStore();
   const settingsStore = useSettingsStore();
   const instanceStore = useInstanceStore();
+  const initGameLifecycle = useGameStore((state) => state.initLifecycle);
 
   const location = useLocation();
 
@@ -17,7 +19,8 @@ export function IndexPage() {
     authStore.init();
     settingsStore.refresh();
     instanceStore.refresh();
-  }, [authStore.init, settingsStore.refresh, instanceStore.refresh]);
+    initGameLifecycle();
+  }, [authStore.init, settingsStore.refresh, instanceStore.refresh, initGameLifecycle]);
 
   return (
     <div className="relative h-screen w-full overflow-hidden bg-background font-sans">
diff --git a/packages/ui/src/pages/instances-view.tsx b/packages/ui/src/pages/instances-view.tsx
index e99004c9..4d36201a 100644
--- a/packages/ui/src/pages/instances-view.tsx
+++ b/packages/ui/src/pages/instances-view.tsx
@@ -1,7 +1,16 @@
-import { CopyIcon, EditIcon, Plus, RocketIcon, Trash2Icon } from "lucide-react";
+import { open, save } from "@tauri-apps/plugin-dialog";
+import {
+  CopyIcon,
+  EditIcon,
+  FolderOpenIcon,
+  Plus,
+  RocketIcon,
+  Trash2Icon,
+  XIcon,
+} from "lucide-react";
 import { useEffect, useState } from "react";
 import { toast } from "sonner";
-import { startGame } from "@/client";
+import { openFileExplorer } from "@/client";
 import InstanceCreationModal from "@/components/instance-creation-modal";
 import InstanceEditorModal from "@/components/instance-editor-modal";
 import { Button } from "@/components/ui/button";
@@ -15,11 +24,22 @@ import {
 } from "@/components/ui/dialog";
 import { Input } from "@/components/ui/input";
 import { cn } from "@/lib/utils";
+import { useAuthStore } from "@/models/auth";
 import { useInstanceStore } from "@/models/instance";
+import { useGameStore } from "@/stores/game-store";
 import type { Instance } from "@/types";
 
 export function InstancesView() {
+  const account = useAuthStore((state) => state.account);
   const instancesStore = useInstanceStore();
+  const startGame = useGameStore((state) => state.startGame);
+  const stopGame = useGameStore((state) => state.stopGame);
+  const runningInstanceId = useGameStore((state) => state.runningInstanceId);
+  const launchingInstanceId = useGameStore((state) => state.launchingInstanceId);
+  const stoppingInstanceId = useGameStore((state) => state.stoppingInstanceId);
+  const [isImporting, setIsImporting] = useState(false);
+  const [repairing, setRepairing] = useState(false);
+  const [exportingId, setExportingId] = useState<string | null>(null);
 
   // Modal / UI state
   const [showCreateModal, setShowCreateModal] = useState(false);
@@ -78,20 +98,73 @@ export function InstancesView() {
     setShowDuplicateModal(false);
   };
 
+  const handleImport = async () => {
+    setIsImporting(true);
+    try {
+      const selected = await open({
+        multiple: false,
+        filters: [{ name: "Zip Archive", extensions: ["zip"] }],
+      });
+
+      if (typeof selected !== "string") {
+        return;
+      }
+
+      await instancesStore.importArchive(selected);
+    } finally {
+      setIsImporting(false);
+    }
+  };
+
+  const handleRepair = async () => {
+    setRepairing(true);
+    try {
+      await instancesStore.repair();
+    } finally {
+      setRepairing(false);
+    }
+  };
+
+  const handleExport = async (instance: Instance) => {
+    setExportingId(instance.id);
+    try {
+      const filePath = await save({
+        defaultPath: `${instance.name.replace(/[\\/:*?"<>|]/g, "_")}.zip`,
+        filters: [{ name: "Zip Archive", extensions: ["zip"] }],
+      });
+
+      if (!filePath) {
+        return;
+      }
+
+      await instancesStore.exportArchive(instance.id, filePath);
+    } finally {
+      setExportingId(null);
+    }
+  };
+
   return (
     <div className="h-full flex flex-col gap-4 p-6 overflow-y-auto">
       <div className="flex items-center justify-between">
         <h1 className="text-2xl font-bold text-gray-900 dark:text-white">
           Instances
         </h1>
-        <Button
-          type="button"
-          onClick={openCreate}
-          className="px-4 py-2 transition-colors"
-        >
-          <Plus size={18} />
-          Create Instance
-        </Button>
+        <div className="flex items-center gap-2">
+          <Button type="button" variant="outline" onClick={handleImport}>
+            {isImporting ? "Importing..." : "Import"}
+          </Button>
+          <Button type="button" variant="outline" onClick={handleRepair}>
+            {repairing ? "Repairing..." : "Repair Index"}
+          </Button>
+          <Button
+            type="button"
+            onClick={openCreate}
+            className="px-4 py-2 transition-colors"
+          >
+            <Plus size={18} />
+            Create Instance
+          </Button>
+        </div>
       </div>
 
       {instancesStore.instances.length === 0 ? (
@@ -105,6 +178,10 @@ export function InstancesView() {
         <ul className="flex flex-col space-y-3">
           {instancesStore.instances.map((instance) => {
             const isActive = instancesStore.activeInstance?.id === instance.id;
+            const isRunning = runningInstanceId === instance.id;
+            const isLaunching = launchingInstanceId === instance.id;
+            const isStopping = stoppingInstanceId === instance.id;
+            const otherInstanceRunning = runningInstanceId !== null && !isRunning;
 
             return (
               <li
@@ -164,22 +241,71 @@ export function InstancesView() {
                   <div className="flex items-center">
                     <div className="flex flex-row space-x-2">
                       <Button
-                        variant="ghost"
+                        variant={isRunning ? "destructive" : "ghost"}
                         size="icon"
-                        onClick={async () => {
+                        onClick={async (e) => {
+                          e.stopPropagation();
+
+                          try {
+                            await instancesStore.setActiveInstance(instance);
+                          } catch (error) {
+                            console.error("Failed to set active instance:", error);
+                            toast.error("Error setting active instance");
+                            return;
+                          }
+
+                          if (isRunning) {
+                            await stopGame(instance.id);
+                            return;
+                          }
+
                           if (!instance.versionId) {
                             toast.error("No version selected or installed");
                             return;
                           }
-                          try {
-                            await startGame(instance.id, instance.versionId);
-                          } catch (e) {
-                            console.error("Failed to start game:", e);
-                            toast.error("Error starting game");
-                          }
+
+                          await startGame(
+                            account,
+                            () => {
+                              toast.info("Please login first");
+                            },
+                            instance.id,
+                            instance.versionId,
+                            () => undefined,
+                          );
                         }}
+                        disabled={otherInstanceRunning || isLaunching || isStopping}
                       >
-                        <RocketIcon />
+                        {isLaunching || isStopping ? (
+                          <span className="text-xs">...</span>
+                        ) : isRunning ? (
+                          <XIcon />
+                        ) : (
+                          <RocketIcon />
+                        )}
+                      </Button>
+                      <Button
+                        variant="ghost"
+                        size="icon"
+                        onClick={(e) => {
+                          e.stopPropagation();
+                          void openFileExplorer(instance.gameDir);
+                        }}
+                      >
+                        <FolderOpenIcon />
+                      </Button>
+                      <Button
+                        variant="ghost"
+                        size="icon"
+                        onClick={(e) => {
+                          e.stopPropagation();
+                          void handleExport(instance);
+                        }}
+                        disabled={exportingId === instance.id}
+                      >
+                        <span className="text-xs">
+                          {exportingId === instance.id ? "..." : "ZIP"}
+                        </span>
                       </Button>
                       <Button
                         variant="ghost"
diff --git a/packages/ui/src/stores/game-store.ts b/packages/ui/src/stores/game-store.ts
index fa0f9f8f..7e407de9 100644
--- a/packages/ui/src/stores/game-store.ts
+++ b/packages/ui/src/stores/game-store.ts
@@ -1,49 +1,98 @@
+import { listen, type UnlistenFn } from "@tauri-apps/api/event";
 import { toast } from "sonner";
 import { create } from "zustand";
-import { getVersions } from "@/client";
+import {
+  getVersions,
+  getVersionsOfInstance,
+  startGame as startGameCommand,
+  stopGame as stopGameCommand,
+} from "@/client";
+import type { Account } from "@/types/bindings/auth";
 import type { Version } from "@/types/bindings/manifest";
 
+interface GameExitedEvent {
+  instanceId: string;
+  versionId: string;
+  exitCode: number | null;
+  wasStopped: boolean;
+}
+
 interface GameState {
-  // State
   versions: Version[];
   selectedVersion: string;
+  runningInstanceId: string | null;
+  runningVersionId: string | null;
+  launchingInstanceId: string | null;
+  stoppingInstanceId: string | null;
+  lifecycleUnlisten: UnlistenFn | null;
 
-  // Computed property
   latestRelease: Version | undefined;
+  isGameRunning: boolean;
 
-  // Actions
+  initLifecycle: () => Promise<void>;
   loadVersions: (instanceId?: string) => Promise<void>;
   startGame: (
-    currentAccount: any,
+    currentAccount: Account | null,
     openLoginModal: () => void,
     activeInstanceId: string | null,
-    setView: (view: any) => void,
-  ) => Promise<void>;
+    versionId: string | null,
+    setView: (view: string) => void,
+  ) => Promise<string | null>;
+  stopGame: (instanceId?: string | null) => Promise<string | null>;
   setSelectedVersion: (version: string) => void;
   setVersions: (versions: Version[]) => void;
 }
 
 export const useGameStore = create<GameState>((set, get) => ({
-  // Initial state
   versions: [],
   selectedVersion: "",
+  runningInstanceId: null,
+  runningVersionId: null,
+  launchingInstanceId: null,
+  stoppingInstanceId: null,
+  lifecycleUnlisten: null,
 
-  // Computed property
   get latestRelease() {
     return get().versions.find((v) => v.type === "release");
   },
 
-  // Actions
+  get isGameRunning() {
+    return get().runningInstanceId !== null;
+  },
+
+  initLifecycle: async () => {
+    if (get().lifecycleUnlisten) {
+      return;
+    }
+
+    const unlisten = await listen<GameExitedEvent>("game-exited", (event) => {
+      const { instanceId, versionId, wasStopped } = event.payload;
+
+      set({
+        runningInstanceId: null,
+        runningVersionId: null,
+        launchingInstanceId: null,
+        stoppingInstanceId: null,
+      });
+
+      if (wasStopped) {
+        toast.success(`Stopped Minecraft ${versionId} for instance ${instanceId}`);
+      } else {
+        toast.info(`Minecraft ${versionId} exited for instance ${instanceId}`);
+      }
+    });
+
+    set({ lifecycleUnlisten: unlisten });
+  },
+
   loadVersions: async (instanceId?: string) => {
-    console.log("Loading versions for instance:", instanceId);
     try {
-      // Ask the backend for known versions (optionally scoped to an instance).
-      // The Tauri command `get_versions` is expected to return an array of `Version`.
-      const versions = await getVersions();
+      const versions = instanceId
+        ? await getVersionsOfInstance(instanceId)
+        : await getVersions();
       set({ versions: versions ?? [] });
     } catch (e) {
       console.error("Failed to load versions:", e);
-      // Keep the store consistent on error by clearing versions.
       set({ versions: [] });
     }
   },
@@ -52,42 +101,79 @@ export const useGameStore = create<GameState>((set, get) => ({
     currentAccount,
     openLoginModal,
     activeInstanceId,
+    versionId,
     setView,
   ) => {
-    const { selectedVersion } = get();
+    const { isGameRunning } = get();
+    const targetVersion = versionId ?? get().selectedVersion;
 
     if (!currentAccount) {
-      alert("Please login first!");
+      toast.info("Please login first");
       openLoginModal();
-      return;
+      return null;
     }
 
-    if (!selectedVersion) {
-      alert("Please select a version!");
-      return;
+    if (!targetVersion) {
+      toast.info("Please select a version first");
+      return null;
     }
 
     if (!activeInstanceId) {
-      alert("Please select an instance first!");
+      toast.info("Please select an instance first");
       setView("instances");
-      return;
+      return null;
+    }
+
+    if (isGameRunning) {
+      toast.info("A game is already running");
+      return null;
     }
 
-    toast.info("Preparing to launch " + selectedVersion + "...");
+    set({
+      launchingInstanceId: activeInstanceId,
+      selectedVersion: targetVersion,
+    });
+    toast.info(`Preparing to launch ${targetVersion}...`);
 
     try {
-      // Note: In production, this would call Tauri invoke
-      // const msg = await invoke<string>("start_game", {
-      //   instanceId: activeInstanceId,
-      //   versionId: selectedVersion,
-      // });
-
-      // Simulate success
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-      toast.success("Game started successfully!");
+      const message = await startGameCommand(activeInstanceId, targetVersion);
+      set({
+        launchingInstanceId: null,
+        runningInstanceId: activeInstanceId,
+        runningVersionId: targetVersion,
+      });
+      toast.success(message);
+      return message;
     } catch (e) {
       console.error(e);
+      set({ launchingInstanceId: null });
       toast.error(`Error: ${e}`);
+      return null;
+    }
+  },
+
+  stopGame: async (instanceId) => {
+    const { runningInstanceId } = get();
+
+    if (!runningInstanceId) {
+      toast.info("No running game found");
+      return null;
+    }
+
+    if (instanceId && instanceId !== runningInstanceId) {
+      toast.info("That instance is not the one currently running");
+      return null;
+    }
+
+    set({ stoppingInstanceId: runningInstanceId });
+
+    try {
+      return await stopGameCommand();
+    } catch (e) {
+      console.error("Failed to stop game:", e);
+      set({ stoppingInstanceId: null });
+      toast.error(`Failed to stop game: ${e}`);
+      return null;
     }
   },
 
diff --git a/packages/ui/vite.config.ts b/packages/ui/vite.config.ts
index 8c902673..efc18b4a 100644
--- a/packages/ui/vite.config.ts
+++ b/packages/ui/vite.config.ts
@@ -6,6 +6,11 @@ import { defineConfig } from "vite";
 // https://vite.dev/config/
 export default defineConfig({
   plugins: [react(), tailwindcss()],
+  server: {
+    host: "127.0.0.1",
+    port: 5173,
+    strictPort: true,
+  },
   resolve: {
     alias: {
       "@": path.resolve(__dirname, "./src"),
diff --git a/src-tauri/capabilities/default.json b/src-tauri/capabilities/default.json
index ea3fd7bb..ee3644a6 100644
--- a/src-tauri/capabilities/default.json
+++ b/src-tauri/capabilities/default.json
@@ -3,6 +3,14 @@
   "identifier": "default",
   "description": "Default capabilities for the DropOut launcher",
   "windows": ["main"],
+  "remote": {
+    "urls": [
+      "http://127.0.0.1:5173",
+      "http://127.0.0.1:5173/*",
+      "http://localhost:5173",
+      "http://localhost:5173/*"
+    ]
+  },
   "permissions": [
     "core:default",
     "core:event:default",
diff --git a/src-tauri/src/core/downloader.rs b/src-tauri/src/core/downloader.rs
index a6b11c58..f6c2dbef 100644
--- a/src-tauri/src/core/downloader.rs
+++ b/src-tauri/src/core/downloader.rs
@@ -3,12 +3,15 @@ use serde::{Deserialize, Serialize};
 use sha1::Digest as Sha1Digest;
 use std::path::PathBuf;
 use std::sync::Arc;
+use std::sync::Mutex;
 use std::sync::atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering};
 use tauri::{AppHandle, Emitter, Manager, Window};
 use tokio::io::{AsyncSeekExt, AsyncWriteExt};
 use tokio::sync::Semaphore;
 use ts_rs::TS;
 
+static DOWNLOAD_QUEUE_FILE_LOCK: Mutex<()> = Mutex::new(());
+
 #[derive(Debug, Clone, Serialize, Deserialize, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export, export_to = "downloader.ts")]
@@ -84,15 +87,17 @@ pub struct DownloadQueue {
 }
 
 impl DownloadQueue {
-    /// Load download queue from file
-    pub fn load(app_handle: &AppHandle) -> Self {
-        let queue_path = app_handle
+    fn queue_path(app_handle: &AppHandle) -> Result<PathBuf, String> {
+        app_handle
             .path()
             .app_data_dir()
-            .unwrap()
-            .join("download_queue.json");
+            .map(|dir| dir.join("download_queue.json"))
+            .map_err(|e| e.to_string())
+    }
+
+    fn load_from_path(queue_path: &PathBuf) -> Self {
         if queue_path.exists() {
-            if let Ok(content) = std::fs::read_to_string(&queue_path) {
+            if let Ok(content) = std::fs::read_to_string(queue_path) {
                 if let Ok(queue) = serde_json::from_str(&content) {
                     return queue;
                 }
@@ -101,18 +106,93 @@ impl DownloadQueue {
         Self::default()
     }
 
-    /// Save download queue to file
-    pub fn save(&self, app_handle: &AppHandle) -> Result<(), String> {
-        let queue_path = app_handle
-            .path()
-            .app_data_dir()
-            .unwrap()
-            .join("download_queue.json");
+    fn save_atomic_to_path(&self, queue_path: &PathBuf) -> Result<(), String> {
+        let parent = queue_path
+            .parent()
+            .ok_or_else(|| "Download queue path has no parent directory".to_string())?;
+        std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+
         let content = serde_json::to_string_pretty(self).map_err(|e| e.to_string())?;
-        std::fs::write(&queue_path, content).map_err(|e| e.to_string())?;
+        let tmp_path = queue_path.with_extension("json.tmp");
+        std::fs::write(&tmp_path, content).map_err(|e| e.to_string())?;
+
+        if queue_path.exists() {
+            let _ = std::fs::remove_file(queue_path);
+        }
+
+        std::fs::rename(&tmp_path, queue_path).map_err(|e| e.to_string())?;
         Ok(())
     }
 
+    pub fn update<T, F>(app_handle: &AppHandle, mutator: F) -> Result<T, String>
+    where
+        F: FnOnce(&mut Self) -> T,
+    {
+        let _guard = DOWNLOAD_QUEUE_FILE_LOCK
+            .lock()
+            .map_err(|_| "Download queue lock poisoned".to_string())?;
+        let queue_path = Self::queue_path(app_handle)?;
+        let mut queue = Self::load_from_path(&queue_path);
+        let result = mutator(&mut queue);
+        queue.save_atomic_to_path(&queue_path)?;
+        Ok(result)
+    }
+
+    pub fn list_pending(app_handle: &AppHandle) -> Vec<PendingJavaDownload> {
+        let _guard = match DOWNLOAD_QUEUE_FILE_LOCK.lock() {
+            Ok(guard) => guard,
+            Err(_) => return Vec::new(),
+        };
+
+        let queue_path = match Self::queue_path(app_handle) {
+            Ok(path) => path,
+            Err(_) => return Vec::new(),
+        };
+
+        Self::load_from_path(&queue_path).pending_downloads
+    }
+
+    pub fn add_pending(
+        app_handle: &AppHandle,
+        download: PendingJavaDownload,
+    ) -> Result<(), String> {
+        Self::update(app_handle, |queue| queue.add(download)).map(|_| ())
+    }
+
+    pub fn remove_pending(
+        app_handle: &AppHandle,
+        major_version: u32,
+        image_type: &str,
+    ) -> Result<(), String> {
+        Self::update(app_handle, |queue| queue.remove(major_version, image_type)).map(|_| ())
+    }
+
+    /// Load download queue from file
+    #[allow(dead_code)]
+    pub fn load(app_handle: &AppHandle) -> Self {
+        let _guard = match DOWNLOAD_QUEUE_FILE_LOCK.lock() {
+            Ok(guard) => guard,
+            Err(_) => return Self::default(),
+        };
+
+        let queue_path = match Self::queue_path(app_handle) {
+            Ok(path) => path,
+            Err(_) => return Self::default(),
+        };
+
+        Self::load_from_path(&queue_path)
+    }
+
+    /// Save download queue to file
+    #[allow(dead_code)]
+    pub fn save(&self, app_handle: &AppHandle) -> Result<(), String> {
+        let _guard = DOWNLOAD_QUEUE_FILE_LOCK
+            .lock()
+            .map_err(|_| "Download queue lock poisoned".to_string())?;
+        let queue_path = Self::queue_path(app_handle)?;
+        self.save_atomic_to_path(&queue_path)
+    }
+
     /// Add a pending download
     pub fn add(&mut self, download: PendingJavaDownload) {
         // Remove existing download for same version/type
diff --git a/src-tauri/src/core/instance.rs b/src-tauri/src/core/instance.rs
index 0237270d..2646d2bd 100644
--- a/src-tauri/src/core/instance.rs
+++ b/src-tauri/src/core/instance.rs
@@ -5,13 +5,16 @@
 //! - Each instance has its own versions, libraries, assets, mods, and saves
 //! - Support for instance switching and isolation
 
+use crate::core::config::LauncherConfig;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::fs;
+use std::io::{Read, Write};
 use std::path::{Path, PathBuf};
 use std::sync::Mutex;
 use tauri::{AppHandle, Manager};
 use ts_rs::TS;
+use zip::write::SimpleFileOptions;
 
 /// Represents a game instance/profile
 #[derive(Debug, Clone, Serialize, Deserialize, TS)]
@@ -52,10 +55,69 @@ pub struct InstanceConfig {
     pub active_instance_id: Option<String>, // 当前活动的实例ID
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "instance.ts")]
+pub struct InstanceRepairResult {
+    pub restored_instances: usize,
+    pub removed_stale_entries: usize,
+    pub created_default_active: bool,
+    pub active_instance_id: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct InstancePaths {
+    pub root: PathBuf,
+    pub metadata_versions: PathBuf,
+    pub version_cache: PathBuf,
+    pub libraries: PathBuf,
+    pub assets: PathBuf,
+    pub mods: PathBuf,
+    pub config: PathBuf,
+    pub saves: PathBuf,
+    pub resourcepacks: PathBuf,
+    pub shaderpacks: PathBuf,
+    pub screenshots: PathBuf,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum InstanceOperation {
+    Launch,
+    Install,
+    Delete,
+    ImportExport,
+}
+
+impl InstanceOperation {
+    fn label(self) -> &'static str {
+        match self {
+            Self::Launch => "launching",
+            Self::Install => "installing",
+            Self::Delete => "deleting",
+            Self::ImportExport => "importing or exporting",
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct ExportedInstance {
+    name: String,
+    version_id: Option<String>,
+    icon_path: Option<String>,
+    notes: Option<String>,
+    mod_loader: Option<String>,
+    mod_loader_version: Option<String>,
+    jvm_args_override: Option<String>,
+    memory_override: Option<MemoryOverride>,
+    java_path_override: Option<String>,
+}
+
 /// State management for instances
 pub struct InstanceState {
     pub instances: Mutex<InstanceConfig>,
     pub file_path: PathBuf,
+    operation_locks: Mutex<HashMap<String, InstanceOperation>>,
 }
 
 impl InstanceState {
@@ -74,9 +136,160 @@ impl InstanceState {
         Self {
             instances: Mutex::new(config),
             file_path,
+            operation_locks: Mutex::new(HashMap::new()),
         }
     }
 
+    fn app_dir(app_handle: &AppHandle) -> Result<PathBuf, String> {
+        app_handle.path().app_data_dir().map_err(|e| e.to_string())
+    }
+
+    fn instances_dir(app_handle: &AppHandle) -> Result<PathBuf, String> {
+        Ok(Self::app_dir(app_handle)?.join("instances"))
+    }
+
+    fn validate_instance_name(
+        config: &InstanceConfig,
+        name: &str,
+        exclude_id: Option<&str>,
+    ) -> Result<(), String> {
+        let trimmed = name.trim();
+        if trimmed.is_empty() {
+            return Err("Instance name cannot be empty".to_string());
+        }
+
+        let duplicated = config.instances.iter().any(|instance| {
+            if let Some(exclude_id) = exclude_id {
+                if instance.id == exclude_id {
+                    return false;
+                }
+            }
+
+            instance.name.trim().eq_ignore_ascii_case(trimmed)
+        });
+
+        if duplicated {
+            return Err(format!("Instance \"{}\" already exists", trimmed));
+        }
+
+        Ok(())
+    }
+
+    fn create_instance_directory_structure(instance_dir: &Path) -> Result<(), String> {
+        fs::create_dir_all(instance_dir).map_err(|e| e.to_string())?;
+
+        for folder in [
+            "versions",
+            "libraries",
+            "assets",
+            "mods",
+            "config",
+            "saves",
+            "resourcepacks",
+            "shaderpacks",
+            "screenshots",
+            "logs",
+        ] {
+            fs::create_dir_all(instance_dir.join(folder)).map_err(|e| e.to_string())?;
+        }
+
+        Ok(())
+    }
+
+    fn insert_instance(
+        &self,
+        instance: Instance,
+        set_active_when_empty: bool,
+    ) -> Result<(), String> {
+        let mut config = self.instances.lock().unwrap();
+        Self::validate_instance_name(&config, &instance.name, Some(&instance.id))?;
+        config.instances.push(instance.clone());
+
+        if set_active_when_empty && config.active_instance_id.is_none() {
+            config.active_instance_id = Some(instance.id);
+        }
+
+        drop(config);
+        self.save()
+    }
+
+    pub fn begin_operation(&self, id: &str, operation: InstanceOperation) -> Result<(), String> {
+        let mut locks = self.operation_locks.lock().unwrap();
+        if let Some(active) = locks.get(id) {
+            return Err(format!("Instance {} is busy: {}", id, active.label()));
+        }
+
+        locks.insert(id.to_string(), operation);
+        Ok(())
+    }
+
+    pub fn end_operation(&self, id: &str) {
+        self.operation_locks.lock().unwrap().remove(id);
+    }
+
+    pub fn resolve_paths(
+        &self,
+        id: &str,
+        config: &LauncherConfig,
+        app_handle: &AppHandle,
+    ) -> Result<InstancePaths, String> {
+        let instance = self
+            .get_instance(id)
+            .ok_or_else(|| format!("Instance {} not found", id))?;
+        let shared_root = Self::app_dir(app_handle)?;
+
+        Ok(InstancePaths {
+            root: instance.game_dir.clone(),
+            metadata_versions: instance.game_dir.join("versions"),
+            version_cache: if config.use_shared_caches {
+                shared_root.join("versions")
+            } else {
+                instance.game_dir.join("versions")
+            },
+            libraries: if config.use_shared_caches {
+                shared_root.join("libraries")
+            } else {
+                instance.game_dir.join("libraries")
+            },
+            assets: if config.use_shared_caches {
+                shared_root.join("assets")
+            } else {
+                instance.game_dir.join("assets")
+            },
+            mods: instance.game_dir.join("mods"),
+            config: instance.game_dir.join("config"),
+            saves: instance.game_dir.join("saves"),
+            resourcepacks: instance.game_dir.join("resourcepacks"),
+            shaderpacks: instance.game_dir.join("shaderpacks"),
+            screenshots: instance.game_dir.join("screenshots"),
+        })
+    }
+
+    pub fn resolve_directory(
+        &self,
+        id: &str,
+        folder: &str,
+        config: &LauncherConfig,
+        app_handle: &AppHandle,
+    ) -> Result<PathBuf, String> {
+        let paths = self.resolve_paths(id, config, app_handle)?;
+        let resolved = match folder {
+            "versions" => paths.metadata_versions,
+            "version-cache" => paths.version_cache,
+            "libraries" => paths.libraries,
+            "assets" => paths.assets,
+            "mods" => paths.mods,
+            "config" => paths.config,
+            "saves" => paths.saves,
+            "resourcepacks" => paths.resourcepacks,
+            "shaderpacks" => paths.shaderpacks,
+            "screenshots" => paths.screenshots,
+            other => paths.root.join(other),
+        };
+
+        Ok(resolved)
+    }
+
     /// Save the instance configuration to disk
     pub fn save(&self) -> Result<(), String> {
         let config = self.instances.lock().unwrap();
@@ -92,23 +305,22 @@ impl InstanceState {
         name: String,
         app_handle: &AppHandle,
     ) -> Result<Instance, String> {
-        let app_dir = app_handle.path().app_data_dir().unwrap();
+        let trimmed_name = name.trim().to_string();
+        {
+            let config = self.instances.lock().unwrap();
+            Self::validate_instance_name(&config, &trimmed_name, None)?;
+        }
+
+        let app_dir = Self::app_dir(app_handle)?;
         let instance_id = uuid::Uuid::new_v4().to_string();
         let instance_dir = app_dir.join("instances").join(&instance_id);
         let game_dir = instance_dir.clone();
 
-        // Create instance directory structure
-        fs::create_dir_all(&instance_dir).map_err(|e| e.to_string())?;
-        fs::create_dir_all(instance_dir.join("versions")).map_err(|e| e.to_string())?;
-        fs::create_dir_all(instance_dir.join("libraries")).map_err(|e| e.to_string())?;
-        fs::create_dir_all(instance_dir.join("assets")).map_err(|e| e.to_string())?;
-        fs::create_dir_all(instance_dir.join("mods")).map_err(|e| e.to_string())?;
-        fs::create_dir_all(instance_dir.join("config")).map_err(|e| e.to_string())?;
-        fs::create_dir_all(instance_dir.join("saves")).map_err(|e| e.to_string())?;
+        Self::create_instance_directory_structure(&instance_dir)?;
 
         let instance = Instance {
             id: instance_id.clone(),
-            name,
+            name: trimmed_name,
             game_dir,
             version_id: None,
             created_at: chrono::Utc::now().timestamp(),
@@ -122,22 +334,14 @@ impl InstanceState {
             java_path_override: None,
         };
 
-        let mut config = self.instances.lock().unwrap();
-        config.instances.push(instance.clone());
-
-        // If this is the first instance, set it as active
-        if config.active_instance_id.is_none() {
-            config.active_instance_id = Some(instance_id);
-        }
-
-        drop(config);
-        self.save()?;
+        self.insert_instance(instance.clone(), true)?;
 
         Ok(instance)
     }
 
     /// Delete an instance
     pub fn delete_instance(&self, id: &str) -> Result<(), String> {
+        self.begin_operation(id, InstanceOperation::Delete)?;
         let mut config = self.instances.lock().unwrap();
 
         // Find the instance
@@ -166,6 +370,8 @@ impl InstanceState {
                 .map_err(|e| format!("Failed to delete instance directory: {}", e))?;
         }
 
+        self.end_operation(id);
+
         Ok(())
     }
 
@@ -179,7 +385,13 @@ impl InstanceState {
             .position(|i| i.id == instance.id)
             .ok_or_else(|| format!("Instance {} not found", instance.id))?;
 
-        config.instances[index] = instance;
+        Self::validate_instance_name(&config, &instance.name, Some(&instance.id))?;
+
+        let existing = config.instances[index].clone();
+        let mut updated = instance;
+        updated.game_dir = existing.game_dir;
+        updated.created_at = existing.created_at;
+        config.instances[index] = updated;
         drop(config);
         self.save()?;
 
@@ -236,17 +448,19 @@ impl InstanceState {
         new_name: String,
         app_handle: &AppHandle,
     ) -> Result<Instance, String> {
+        self.begin_operation(id, InstanceOperation::ImportExport)?;
         let source_instance = self
             .get_instance(id)
             .ok_or_else(|| format!("Instance {} not found", id))?;
 
+        {
+            let config = self.instances.lock().unwrap();
+            Self::validate_instance_name(&config, &new_name, None)?;
+        }
+
         // Prepare new instance metadata (but don't save yet)
         let new_id = uuid::Uuid::new_v4().to_string();
-        let instances_dir = app_handle
-            .path()
-            .app_data_dir()
-            .map_err(|e| e.to_string())?
-            .join("instances");
+        let instances_dir = Self::instances_dir(app_handle)?;
         let new_game_dir = instances_dir.join(&new_id);
 
         // Copy directory FIRST - if this fails, don't create metadata
@@ -255,14 +469,13 @@ impl InstanceState {
                 .map_err(|e| format!("Failed to copy instance directory: {}", e))?;
         } else {
             // If source dir doesn't exist, create new empty game dir
-            std::fs::create_dir_all(&new_game_dir)
-                .map_err(|e| format!("Failed to create instance directory: {}", e))?;
+            Self::create_instance_directory_structure(&new_game_dir)?;
         }
 
         // NOW create metadata and save
         let new_instance = Instance {
             id: new_id,
-            name: new_name,
+            name: new_name.trim().to_string(),
             game_dir: new_game_dir,
             version_id: source_instance.version_id.clone(),
             mod_loader: source_instance.mod_loader.clone(),
@@ -279,10 +492,239 @@ impl InstanceState {
             java_path_override: source_instance.java_path_override.clone(),
         };
 
-        self.update_instance(new_instance.clone())?;
+        self.insert_instance(new_instance.clone(), false)?;
+        self.end_operation(id);
 
         Ok(new_instance)
     }
+
+    pub fn export_instance(&self, id: &str, archive_path: &Path) -> Result<PathBuf, String> {
+        self.begin_operation(id, InstanceOperation::ImportExport)?;
+        let instance = self
+            .get_instance(id)
+            .ok_or_else(|| format!("Instance {} not found", id))?;
+
+        if let Some(parent) = archive_path.parent() {
+            fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+        }
+
+        let file = fs::File::create(archive_path).map_err(|e| e.to_string())?;
+        let mut writer = zip::ZipWriter::new(file);
+        let options = SimpleFileOptions::default()
+            .compression_method(zip::CompressionMethod::Deflated)
+            .unix_permissions(0o644);
+
+        let exported = ExportedInstance {
+            name: instance.name.clone(),
+            version_id: instance.version_id.clone(),
+            icon_path: instance.icon_path.clone(),
+            notes: instance.notes.clone(),
+            mod_loader: instance.mod_loader.clone(),
+            mod_loader_version: instance.mod_loader_version.clone(),
+            jvm_args_override: instance.jvm_args_override.clone(),
+            memory_override: instance.memory_override.clone(),
+            java_path_override: instance.java_path_override.clone(),
+        };
+
+        writer
+            .start_file("dropout-instance.json", options)
+            .map_err(|e| e.to_string())?;
+        writer
+            .write_all(
+                serde_json::to_string_pretty(&exported)
+                    .map_err(|e| e.to_string())?
+                    .as_bytes(),
+            )
+            .map_err(|e| e.to_string())?;
+
+        append_directory_to_zip(&mut writer, &instance.game_dir, &instance.game_dir, options)?;
+        writer.finish().map_err(|e| e.to_string())?;
+        self.end_operation(id);
+
+        Ok(archive_path.to_path_buf())
+    }
+
+    pub fn import_instance(
+        &self,
+        archive_path: &Path,
+        app_handle: &AppHandle,
+        new_name: Option<String>,
+    ) -> Result<Instance, String> {
+        let file = fs::File::open(archive_path).map_err(|e| e.to_string())?;
+        let mut archive = zip::ZipArchive::new(file).map_err(|e| e.to_string())?;
+
+        let exported: ExportedInstance = {
+            let mut metadata = archive.by_name("dropout-instance.json").map_err(|_| {
+                "Invalid instance archive: missing dropout-instance.json".to_string()
+            })?;
+            let mut content = String::new();
+            metadata
+                .read_to_string(&mut content)
+                .map_err(|e| e.to_string())?;
+            serde_json::from_str(&content).map_err(|e| e.to_string())?
+        };
+
+        let final_name = new_name.unwrap_or(exported.name.clone());
+        {
+            let config = self.instances.lock().unwrap();
+            Self::validate_instance_name(&config, &final_name, None)?;
+        }
+
+        let imported = self.create_instance(final_name, app_handle)?;
+        self.begin_operation(&imported.id, InstanceOperation::ImportExport)?;
+
+        for index in 0..archive.len() {
+            let mut entry = archive.by_index(index).map_err(|e| e.to_string())?;
+            let Some(enclosed_name) = entry.enclosed_name().map(|p| p.to_path_buf()) else {
+                continue;
+            };
+
+            if enclosed_name == PathBuf::from("dropout-instance.json") {
+                continue;
+            }
+
+            let out_path = imported.game_dir.join(&enclosed_name);
+            if entry.name().ends_with('/') {
+                fs::create_dir_all(&out_path).map_err(|e| e.to_string())?;
+                continue;
+            }
+
+            if let Some(parent) = out_path.parent() {
+                fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+            }
+
+            let mut output = fs::File::create(&out_path).map_err(|e| e.to_string())?;
+            std::io::copy(&mut entry, &mut output).map_err(|e| e.to_string())?;
+        }
+
+        let mut hydrated = imported.clone();
+        hydrated.version_id = exported.version_id;
+        hydrated.icon_path = exported.icon_path;
+        hydrated.notes = exported.notes;
+        hydrated.mod_loader = exported.mod_loader;
+        hydrated.mod_loader_version = exported.mod_loader_version;
+        hydrated.jvm_args_override = exported.jvm_args_override;
+        hydrated.memory_override = exported.memory_override;
+        hydrated.java_path_override = exported.java_path_override;
+        self.update_instance(hydrated.clone())?;
+        self.end_operation(&imported.id);
+
+        Ok(hydrated)
+    }
+
+    pub fn repair_instances(&self, app_handle: &AppHandle) -> Result<InstanceRepairResult, String> {
+        let instances_dir = Self::instances_dir(app_handle)?;
+        fs::create_dir_all(&instances_dir).map_err(|e| e.to_string())?;
+
+        let mut config = self.instances.lock().unwrap().clone();
+        let mut restored_instances = 0usize;
+        let mut removed_stale_entries = 0usize;
+
+        config.instances.retain(|instance| {
+            let keep = instance.game_dir.exists();
+            if !keep {
+                removed_stale_entries += 1;
+            }
+            keep
+        });
+
+        let known_ids: std::collections::HashSet<String> = config
+            .instances
+            .iter()
+            .map(|instance| instance.id.clone())
+            .collect();
+
+        for entry in fs::read_dir(&instances_dir).map_err(|e| e.to_string())? {
+            let entry = entry.map_err(|e| e.to_string())?;
+            if !entry.file_type().map_err(|e| e.to_string())?.is_dir() {
+                continue;
+            }
+
+            let id = entry.file_name().to_string_lossy().to_string();
+            if known_ids.contains(&id) {
+                continue;
+            }
+
+            let recovered = Instance {
+                id: id.clone(),
+                name: format!("Recovered {}", &id[..id.len().min(8)]),
+                game_dir: entry.path(),
+                version_id: None,
+                created_at: chrono::Utc::now().timestamp(),
+                last_played: None,
+                icon_path: None,
+                notes: Some("Recovered from instances directory".to_string()),
+                mod_loader: Some("vanilla".to_string()),
+                mod_loader_version: None,
+                jvm_args_override: None,
+                memory_override: None,
+                java_path_override: None,
+            };
+
+            config.instances.push(recovered);
+            restored_instances += 1;
+        }
+
+        config
+            .instances
+            .sort_by(|left, right| left.created_at.cmp(&right.created_at));
+
+        let mut created_default_active = false;
+        if config.active_instance_id.is_none()
+            || !config
+                .instances
+                .iter()
+                .any(|instance| Some(&instance.id) == config.active_instance_id.as_ref())
+        {
+            config.active_instance_id =
+                config.instances.first().map(|instance| instance.id.clone());
+            created_default_active = config.active_instance_id.is_some();
+        }
+
+        *self.instances.lock().unwrap() = config.clone();
+        drop(config);
+        self.save()?;
+
+        Ok(InstanceRepairResult {
+            restored_instances,
+            removed_stale_entries,
+            created_default_active,
+            active_instance_id: self.get_active_instance().map(|instance| instance.id),
+        })
+    }
+}
+
+fn append_directory_to_zip(
+    writer: &mut zip::ZipWriter<fs::File>,
+    current_dir: &Path,
+    base_dir: &Path,
+    options: SimpleFileOptions,
+) -> Result<(), String> {
+    if !current_dir.exists() {
+        return Ok(());
+    }
+
+    for entry in fs::read_dir(current_dir).map_err(|e| e.to_string())? {
+        let entry = entry.map_err(|e| e.to_string())?;
+        let path = entry.path();
+        let relative = path.strip_prefix(base_dir).map_err(|e| e.to_string())?;
+        let zip_name = relative.to_string_lossy().replace('\\', "/");
+
+        if path.is_dir() {
+            writer
+                .add_directory(format!("{}/", zip_name), options)
+                .map_err(|e| e.to_string())?;
+            append_directory_to_zip(writer, &path, base_dir, options)?;
+        } else {
+            writer
+                .start_file(zip_name, options)
+                .map_err(|e| e.to_string())?;
+            let data = fs::read(&path).map_err(|e| e.to_string())?;
+            writer.write_all(&data).map_err(|e| e.to_string())?;
+        }
+    }
+
+    Ok(())
 }
 
 /// Copy a directory recursively
diff --git a/src-tauri/src/core/java/cache.rs b/src-tauri/src/core/java/cache.rs
new file mode 100644
index 00000000..6f8c6fdc
--- /dev/null
+++ b/src-tauri/src/core/java/cache.rs
@@ -0,0 +1,77 @@
+use crate::core::java::error::JavaError;
+use crate::core::java::JavaCatalog;
+use std::path::PathBuf;
+use tauri::{AppHandle, Manager};
+
+const CACHE_DURATION_SECS: u64 = 24 * 60 * 60;
+
+fn get_catalog_cache_path(app_handle: &AppHandle) -> PathBuf {
+    app_handle
+        .path()
+        .app_data_dir()
+        .unwrap()
+        .join("java_catalog_cache.json")
+}
+
+fn write_file_atomic(path: &PathBuf, content: &str) -> Result<(), JavaError> {
+    let parent = path.parent().ok_or_else(|| {
+        JavaError::InvalidConfig("Java cache path has no parent directory".to_string())
+    })?;
+    std::fs::create_dir_all(parent)?;
+
+    let tmp_path = path.with_extension("tmp");
+    std::fs::write(&tmp_path, content)?;
+
+    if path.exists() {
+        let _ = std::fs::remove_file(path);
+    }
+
+    std::fs::rename(&tmp_path, path)?;
+    Ok(())
+}
+
+pub fn load_cached_catalog_result(
+    app_handle: &AppHandle,
+) -> Result<Option<JavaCatalog>, JavaError> {
+    let cache_path = get_catalog_cache_path(app_handle);
+    if !cache_path.exists() {
+        return Ok(None);
+    }
+
+    let content = std::fs::read_to_string(&cache_path)?;
+    let catalog: JavaCatalog = serde_json::from_str(&content)?;
+
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map_err(|e| JavaError::Other(format!("System time error: {}", e)))?
+        .as_secs();
+
+    if now - catalog.cached_at < CACHE_DURATION_SECS {
+        Ok(Some(catalog))
+    } else {
+        Ok(None)
+    }
+}
+
+#[allow(dead_code)]
+pub fn load_cached_catalog(app_handle: &AppHandle) -> Option<JavaCatalog> {
+    match load_cached_catalog_result(app_handle) {
+        Ok(value) => value,
+        Err(_) => None,
+    }
+}
+
+pub fn save_catalog_cache(app_handle: &AppHandle, catalog: &JavaCatalog) -> Result<(), JavaError> {
+    let cache_path = get_catalog_cache_path(app_handle);
+    let content = serde_json::to_string_pretty(catalog)?;
+    write_file_atomic(&cache_path, &content)
+}
+
+#[allow(dead_code)]
+pub fn clear_catalog_cache(app_handle: &AppHandle) -> Result<(), JavaError> {
+    let cache_path = get_catalog_cache_path(app_handle);
+    if cache_path.exists() {
+        std::fs::remove_file(&cache_path)?;
+    }
+    Ok(())
+}
diff --git a/src-tauri/src/core/java/detection.rs b/src-tauri/src/core/java/detection.rs
deleted file mode 100644
index 08dcebb9..00000000
--- a/src-tauri/src/core/java/detection.rs
+++ /dev/null
@@ -1,311 +0,0 @@
-use std::io::Read;
-use std::path::Path;
-use std::path::PathBuf;
-use std::process::{Command, Stdio};
-use std::time::Duration;
-
-#[cfg(target_os = "windows")]
-use std::os::windows::process::CommandExt;
-
-use crate::core::java::strip_unc_prefix;
-
-const WHICH_TIMEOUT: Duration = Duration::from_secs(2);
-
-/// Scans a directory for Java installations, filtering out symlinks
-///
-/// # Arguments
-/// * `base_dir` - Base directory to scan (e.g., mise or SDKMAN java dir)
-/// * `should_skip` - Predicate to determine if an entry should be skipped
-///
-/// # Returns
-/// First valid Java installation found, or `None`
-fn scan_java_dir<F>(base_dir: &Path, should_skip: F) -> Option<PathBuf>
-where
-    F: Fn(&std::fs::DirEntry) -> bool,
-{
-    std::fs::read_dir(base_dir)
-        .ok()?
-        .flatten()
-        .filter(|entry| {
-            let path = entry.path();
-            // Only consider real directories, not symlinks
-            path.is_dir() && !path.is_symlink() && !should_skip(entry)
-        })
-        .find_map(|entry| {
-            let java_path = entry.path().join("bin/java");
-            if java_path.exists() && java_path.is_file() {
-                Some(java_path)
-            } else {
-                None
-            }
-        })
-}
-
-/// Finds Java installation from SDKMAN! if available
-///
-/// Scans the SDKMAN! candidates directory and returns the first valid Java installation found.
-/// Skips the 'current' symlink to avoid duplicates.
-///
-/// Path: `~/.sdkman/candidates/java/`
-///
-/// # Returns
-/// `Some(PathBuf)` pointing to `bin/java` if found, `None` otherwise
-pub fn find_sdkman_java() -> Option<PathBuf> {
-    let home = std::env::var("HOME").ok()?;
-    let sdkman_base = PathBuf::from(&home).join(".sdkman/candidates/java/");
-
-    if !sdkman_base.exists() {
-        return None;
-    }
-
-    scan_java_dir(&sdkman_base, |entry| entry.file_name() == "current")
-}
-
-/// Finds Java installation from mise if available
-///
-/// Scans the mise Java installation directory and returns the first valid installation found.
-/// Skips version alias symlinks (e.g., `21`, `21.0`, `latest`, `lts`) to avoid duplicates.
-///
-/// Path: `~/.local/share/mise/installs/java/`
-///
-/// # Returns
-/// `Some(PathBuf)` pointing to `bin/java` if found, `None` otherwise
-pub fn find_mise_java() -> Option<PathBuf> {
-    let home = std::env::var("HOME").ok()?;
-    let mise_base = PathBuf::from(&home).join(".local/share/mise/installs/java/");
-
-    if !mise_base.exists() {
-        return None;
-    }
-
-    scan_java_dir(&mise_base, |_| false) // mise: no additional filtering needed
-}
-
-/// Runs `which` (Unix) or `where` (Windows) command to find Java in PATH with timeout
-///
-/// This function spawns a subprocess to locate the `java` executable in the system PATH.
-/// It enforces a 2-second timeout to prevent hanging if the command takes too long.
-///
-/// # Returns
-/// `Some(String)` containing the output (paths separated by newlines) if successful,
-/// `None` if the command fails, times out, or returns non-zero exit code
-///
-/// # Platform-specific behavior
-/// - Unix/Linux/macOS: Uses `which java`
-/// - Windows: Uses `where java` and hides the console window
-///
-/// # Timeout Behavior
-/// If the command does not complete within 2 seconds, the process is killed
-/// and `None` is returned. This prevents the launcher from hanging on systems
-/// where `which`/`where` may be slow or unresponsive.
-fn run_which_command_with_timeout() -> Option<String> {
-    let mut cmd = Command::new(if cfg!(windows) { "where" } else { "which" });
-    cmd.arg("java");
-    // Hide console window on Windows
-    #[cfg(target_os = "windows")]
-    cmd.creation_flags(0x08000000);
-    cmd.stdout(Stdio::piped());
-
-    let mut child = cmd.spawn().ok()?;
-    let start = std::time::Instant::now();
-
-    loop {
-        // Check if timeout has been exceeded
-        if start.elapsed() > WHICH_TIMEOUT {
-            let _ = child.kill();
-            let _ = child.wait();
-            return None;
-        }
-
-        match child.try_wait() {
-            Ok(Some(status)) => {
-                if status.success() {
-                    let mut output = String::new();
-                    if let Some(mut stdout) = child.stdout.take() {
-                        let _ = stdout.read_to_string(&mut output);
-                    }
-                    return Some(output);
-                } else {
-                    let _ = child.wait();
-                    return None;
-                }
-            }
-            Ok(None) => {
-                // Command still running, sleep briefly before checking again
-                std::thread::sleep(Duration::from_millis(50));
-            }
-            Err(_) => {
-                let _ = child.kill();
-                let _ = child.wait();
-                return None;
-            }
-        }
-    }
-}
-
-/// Detects all available Java installations on the system
-///
-/// This function searches for Java installations in multiple locations:
-/// - **All platforms**: `JAVA_HOME` environment variable, `java` in PATH
-/// - **Linux**: `/usr/lib/jvm`, `/usr/java`, `/opt/java`, `/opt/jdk`, `/opt/openjdk`, SDKMAN!
-/// - **macOS**: `/Library/Java/JavaVirtualMachines`, `/System/Library/Java/JavaVirtualMachines`,
-///   Homebrew paths (`/usr/local/opt/openjdk`, `/opt/homebrew/opt/openjdk`), SDKMAN!
-/// - **Windows**: `Program Files`, `Program Files (x86)`, `LOCALAPPDATA` for various JDK distributions
-///
-/// # Returns
-/// A vector of `PathBuf` pointing to Java executables found on the system.
-/// Note: Paths may include symlinks and duplicates; callers should canonicalize and deduplicate as needed.
-///
-/// # Examples
-/// ```ignore
-/// let candidates = get_java_candidates();
-/// for java_path in candidates {
-///     println!("Found Java at: {}", java_path.display());
-/// }
-/// ```
-pub fn get_java_candidates() -> Vec<PathBuf> {
-    let mut candidates = Vec::new();
-
-    // Try to find Java in PATH using 'which' or 'where' command with timeout
-    // CAUTION: linux 'which' may return symlinks, so we need to canonicalize later
-    if let Some(paths_str) = run_which_command_with_timeout() {
-        for line in paths_str.lines() {
-            let path = PathBuf::from(line.trim());
-            if path.exists() {
-                let resolved = std::fs::canonicalize(&path).unwrap_or(path);
-                let final_path = strip_unc_prefix(resolved);
-                candidates.push(final_path);
-            }
-        }
-    }
-
-    #[cfg(target_os = "linux")]
-    {
-        let linux_paths = [
-            "/usr/lib/jvm",
-            "/usr/java",
-            "/opt/java",
-            "/opt/jdk",
-            "/opt/openjdk",
-        ];
-
-        for base in &linux_paths {
-            if let Ok(entries) = std::fs::read_dir(base) {
-                for entry in entries.flatten() {
-                    let java_path = entry.path().join("bin/java");
-                    if java_path.exists() {
-                        candidates.push(java_path);
-                    }
-                }
-            }
-        }
-
-        // Check common SDKMAN! java candidates
-        if let Some(sdkman_java) = find_sdkman_java() {
-            candidates.push(sdkman_java);
-        }
-
-        // Check common mise java candidates
-        if let Some(mise_java) = find_mise_java() {
-            candidates.push(mise_java);
-        }
-    }
-
-    #[cfg(target_os = "macos")]
-    {
-        let mac_paths = [
-            "/Library/Java/JavaVirtualMachines",
-            "/System/Library/Java/JavaVirtualMachines",
-            "/usr/local/opt/openjdk/bin/java",
-            "/opt/homebrew/opt/openjdk/bin/java",
-        ];
-
-        for path in &mac_paths {
-            let p = PathBuf::from(path);
-            if p.is_dir() {
-                if let Ok(entries) = std::fs::read_dir(&p) {
-                    for entry in entries.flatten() {
-                        let java_path = entry.path().join("Contents/Home/bin/java");
-                        if java_path.exists() {
-                            candidates.push(java_path);
-                        }
-                    }
-                }
-            } else if p.exists() {
-                candidates.push(p);
-            }
-        }
-
-        // Check common Homebrew java candidates for aarch64 macs
-        let homebrew_arm = PathBuf::from("/opt/homebrew/Cellar/openjdk");
-        if homebrew_arm.exists() {
-            if let Ok(entries) = std::fs::read_dir(&homebrew_arm) {
-                for entry in entries.flatten() {
-                    let java_path = entry
-                        .path()
-                        .join("libexec/openjdk.jdk/Contents/Home/bin/java");
-                    if java_path.exists() {
-                        candidates.push(java_path);
-                    }
-                }
-            }
-        }
-
-        // Check common SDKMAN! java candidates
-        if let Some(sdkman_java) = find_sdkman_java() {
-            candidates.push(sdkman_java);
-        }
-
-        // Check common mise java candidates
-        if let Some(mise_java) = find_mise_java() {
-            candidates.push(mise_java);
-        }
-    }
-
-    #[cfg(target_os = "windows")]
-    {
-        let program_files =
-            std::env::var("ProgramFiles").unwrap_or_else(|_| "C:\\Program Files".to_string());
-        let program_files_x86 = std::env::var("ProgramFiles(x86)")
-            .unwrap_or_else(|_| "C:\\Program Files (x86)".to_string());
-        let local_app_data = std::env::var("LOCALAPPDATA").unwrap_or_default();
-
-        // Common installation paths for various JDK distributions
-        let mut win_paths = vec![];
-        for base in &[&program_files, &program_files_x86, &local_app_data] {
-            win_paths.push(format!("{}\\Java", base));
-            win_paths.push(format!("{}\\Eclipse Adoptium", base));
-            win_paths.push(format!("{}\\AdoptOpenJDK", base));
-            win_paths.push(format!("{}\\Microsoft\\jdk", base));
-            win_paths.push(format!("{}\\Zulu", base));
-            win_paths.push(format!("{}\\Amazon Corretto", base));
-            win_paths.push(format!("{}\\BellSoft\\LibericaJDK", base));
-            win_paths.push(format!("{}\\Programs\\Eclipse Adoptium", base));
-        }
-
-        for base in &win_paths {
-            let base_path = PathBuf::from(base);
-            if base_path.exists() {
-                if let Ok(entries) = std::fs::read_dir(&base_path) {
-                    for entry in entries.flatten() {
-                        let java_path = entry.path().join("bin\\java.exe");
-                        if java_path.exists() {
-                            candidates.push(java_path);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    // Check JAVA_HOME environment variable
-    if let Ok(java_home) = std::env::var("JAVA_HOME") {
-        let bin_name = if cfg!(windows) { "java.exe" } else { "java" };
-        let java_path = PathBuf::from(&java_home).join("bin").join(bin_name);
-        if java_path.exists() {
-            candidates.push(java_path);
-        }
-    }
-
-    candidates
-}
diff --git a/src-tauri/src/core/java/detection/common.rs b/src-tauri/src/core/java/detection/common.rs
new file mode 100644
index 00000000..266c0bf0
--- /dev/null
+++ b/src-tauri/src/core/java/detection/common.rs
@@ -0,0 +1,82 @@
+use std::io::Read;
+use std::path::PathBuf;
+use std::process::{Command, Stdio};
+use std::time::Duration;
+
+#[cfg(target_os = "windows")]
+use std::os::windows::process::CommandExt;
+
+use crate::core::java::strip_unc_prefix;
+
+// We set a timeout for the which/where command to prevent hanging if it encounters issues.
+const WHICH_TIMEOUT: Duration = Duration::from_secs(2);
+
+fn run_which_command_with_timeout() -> Option<String> {
+    let mut cmd = Command::new(if cfg!(windows) { "where" } else { "which" });
+    cmd.arg("java");
+    #[cfg(target_os = "windows")]
+    // hide the console window on Windows to avoid flashing a command prompt.
+    cmd.creation_flags(0x08000000);
+    cmd.stdout(Stdio::piped());
+
+    let mut child = cmd.spawn().ok()?;
+    let start = std::time::Instant::now();
+
+    loop {
+        if start.elapsed() > WHICH_TIMEOUT {
+            let _ = child.kill();
+            let _ = child.wait();
+            return None;
+        }
+
+        match child.try_wait() {
+            Ok(Some(status)) => {
+                if status.success() {
+                    let mut output = String::new();
+                    if let Some(mut stdout) = child.stdout.take() {
+                        let _ = stdout.read_to_string(&mut output);
+                    }
+                    return Some(output);
+                }
+                let _ = child.wait();
+                return None;
+            }
+            Ok(None) => {
+                std::thread::sleep(Duration::from_millis(50));
+            }
+            Err(_) => {
+                let _ = child.kill();
+                let _ = child.wait();
+                return None;
+            }
+        }
+    }
+}
+
+pub fn path_candidates() -> Vec<PathBuf> {
+    let mut candidates = Vec::new();
+
+    if let Some(paths_str) = run_which_command_with_timeout() {
+        for line in paths_str.lines() {
+            let path = PathBuf::from(line.trim());
+            if path.exists() {
+                let resolved = std::fs::canonicalize(&path).unwrap_or(path);
+                let final_path = strip_unc_prefix(resolved);
+                candidates.push(final_path);
+            }
+        }
+    }
+
+    candidates
+}
+
+pub fn java_home_candidate() -> Option<PathBuf> {
+    let java_home = std::env::var("JAVA_HOME").ok()?;
+    let bin_name = if cfg!(windows) { "java.exe" } else { "java" };
+    let java_path = PathBuf::from(&java_home).join("bin").join(bin_name);
+    if java_path.exists() {
+        Some(java_path)
+    } else {
+        None
+    }
+}
diff --git a/src-tauri/src/core/java/detection/linux.rs b/src-tauri/src/core/java/detection/linux.rs
new file mode 100644
index 00000000..84f6c640
--- /dev/null
+++ b/src-tauri/src/core/java/detection/linux.rs
@@ -0,0 +1,36 @@
+use std::path::PathBuf;
+
+use super::unix::{find_mise_java, find_sdkman_java};
+
+pub fn linux_candidates() -> Vec<PathBuf> {
+    let mut candidates = Vec::new();
+
+    let linux_paths = [
+        "/usr/lib/jvm",
+        "/usr/java",
+        "/opt/java",
+        "/opt/jdk",
+        "/opt/openjdk",
+    ];
+
+    for base in &linux_paths {
+        if let Ok(entries) = std::fs::read_dir(base) {
+            for entry in entries.flatten() {
+                let java_path = entry.path().join("bin/java");
+                if java_path.exists() {
+                    candidates.push(java_path);
+                }
+            }
+        }
+    }
+
+    if let Some(sdkman_java) = find_sdkman_java() {
+        candidates.push(sdkman_java);
+    }
+
+    if let Some(mise_java) = find_mise_java() {
+        candidates.push(mise_java);
+    }
+
+    candidates
+}
diff --git a/src-tauri/src/core/java/detection/macos.rs b/src-tauri/src/core/java/detection/macos.rs
new file mode 100644
index 00000000..5c2ed2ad
--- /dev/null
+++ b/src-tauri/src/core/java/detection/macos.rs
@@ -0,0 +1,54 @@
+use std::path::PathBuf;
+
+use super::unix::{find_mise_java, find_sdkman_java};
+
+pub fn macos_candidates() -> Vec<PathBuf> {
+    let mut candidates = Vec::new();
+
+    let mac_paths = [
+        "/Library/Java/JavaVirtualMachines",
+        "/System/Library/Java/JavaVirtualMachines",
+        "/usr/local/opt/openjdk/bin/java",
+        "/opt/homebrew/opt/openjdk/bin/java",
+    ];
+
+    for path in &mac_paths {
+        let p = PathBuf::from(path);
+        if p.is_dir() {
+            if let Ok(entries) = std::fs::read_dir(&p) {
+                for entry in entries.flatten() {
+                    let java_path = entry.path().join("Contents/Home/bin/java");
+                    if java_path.exists() {
+                        candidates.push(java_path);
+                    }
+                }
+            }
+        } else if p.exists() {
+            candidates.push(p);
+        }
+    }
+
+    let homebrew_arm = PathBuf::from("/opt/homebrew/Cellar/openjdk");
+    if homebrew_arm.exists() {
+        if let Ok(entries) = std::fs::read_dir(&homebrew_arm) {
+            for entry in entries.flatten() {
+                let java_path = entry
+                    .path()
+                    .join("libexec/openjdk.jdk/Contents/Home/bin/java");
+                if java_path.exists() {
+                    candidates.push(java_path);
+                }
+            }
+        }
+    }
+
+    if let Some(sdkman_java) = find_sdkman_java() {
+        candidates.push(sdkman_java);
+    }
+
+    if let Some(mise_java) = find_mise_java() {
+        candidates.push(mise_java);
+    }
+
+    candidates
+}
diff --git a/src-tauri/src/core/java/detection/mod.rs b/src-tauri/src/core/java/detection/mod.rs
new file mode 100644
index 00000000..2c2e692f
--- /dev/null
+++ b/src-tauri/src/core/java/detection/mod.rs
@@ -0,0 +1,34 @@
+use std::path::PathBuf;
+
+mod common;
+mod linux;
+mod macos;
+mod unix;
+mod windows;
+
+pub fn get_java_candidates() -> Vec<PathBuf> {
+    let mut candidates = Vec::new();
+
+    candidates.extend(common::path_candidates());
+
+    #[cfg(target_os = "linux")]
+    {
+        candidates.extend(linux::linux_candidates());
+    }
+
+    #[cfg(target_os = "macos")]
+    {
+        candidates.extend(macos::macos_candidates());
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+        candidates.extend(windows::windows_candidates());
+    }
+
+    if let Some(java_home) = common::java_home_candidate() {
+        candidates.push(java_home);
+    }
+
+    candidates
+}
diff --git a/src-tauri/src/core/java/detection/unix.rs b/src-tauri/src/core/java/detection/unix.rs
new file mode 100644
index 00000000..f06b0d82
--- /dev/null
+++ b/src-tauri/src/core/java/detection/unix.rs
@@ -0,0 +1,44 @@
+use std::path::{Path, PathBuf};
+
+fn scan_java_dir<F>(base_dir: &Path, should_skip: F) -> Option<PathBuf>
+where
+    F: Fn(&std::fs::DirEntry) -> bool,
+{
+    std::fs::read_dir(base_dir)
+        .ok()?
+        .flatten()
+        .filter(|entry| {
+            let path = entry.path();
+            path.is_dir() && !path.is_symlink() && !should_skip(entry)
+        })
+        .find_map(|entry| {
+            let java_path = entry.path().join("bin/java");
+            if java_path.exists() && java_path.is_file() {
+                Some(java_path)
+            } else {
+                None
+            }
+        })
+}
+
+pub fn find_sdkman_java() -> Option<PathBuf> {
+    let home = std::env::var("HOME").ok()?;
+    let sdkman_base = PathBuf::from(&home).join(".sdkman/candidates/java/");
+
+    if !sdkman_base.exists() {
+        return None;
+    }
+
+    scan_java_dir(&sdkman_base, |entry| entry.file_name() == "current")
+}
+
+pub fn find_mise_java() -> Option<PathBuf> {
+    let home = std::env::var("HOME").ok()?;
+    let mise_base = PathBuf::from(&home).join(".local/share/mise/installs/java/");
+
+    if !mise_base.exists() {
+        return None;
+    }
+
+    scan_java_dir(&mise_base, |_| false)
+}
diff --git a/src-tauri/src/core/java/detection/windows.rs b/src-tauri/src/core/java/detection/windows.rs
new file mode 100644
index 00000000..4f664ff4
--- /dev/null
+++ b/src-tauri/src/core/java/detection/windows.rs
@@ -0,0 +1,39 @@
+use std::path::PathBuf;
+
+pub fn windows_candidates() -> Vec<PathBuf> {
+    let mut candidates = Vec::new();
+
+    let program_files =
+        std::env::var("ProgramFiles").unwrap_or_else(|_| "C:\\Program Files".to_string());
+    let program_files_x86 = std::env::var("ProgramFiles(x86)")
+        .unwrap_or_else(|_| "C:\\Program Files (x86)".to_string());
+    let local_app_data = std::env::var("LOCALAPPDATA").unwrap_or_default();
+
+    let mut win_paths = vec![];
+    for base in &[&program_files, &program_files_x86, &local_app_data] {
+        win_paths.push(format!("{}\\Java", base));
+        win_paths.push(format!("{}\\Eclipse Adoptium", base));
+        win_paths.push(format!("{}\\AdoptOpenJDK", base));
+        win_paths.push(format!("{}\\Microsoft\\jdk", base));
+        win_paths.push(format!("{}\\Zulu", base));
+        win_paths.push(format!("{}\\Amazon Corretto", base));
+        win_paths.push(format!("{}\\BellSoft\\LibericaJDK", base));
+        win_paths.push(format!("{}\\Programs\\Eclipse Adoptium", base));
+    }
+
+    for base in &win_paths {
+        let base_path = PathBuf::from(base);
+        if base_path.exists() {
+            if let Ok(entries) = std::fs::read_dir(&base_path) {
+                for entry in entries.flatten() {
+                    let java_path = entry.path().join("bin\\java.exe");
+                    if java_path.exists() {
+                        candidates.push(java_path);
+                    }
+                }
+            }
+        }
+    }
+
+    candidates
+}
diff --git a/src-tauri/src/core/java/error.rs b/src-tauri/src/core/java/error.rs
index bf78d3b0..d0066e05 100644
--- a/src-tauri/src/core/java/error.rs
+++ b/src-tauri/src/core/java/error.rs
@@ -1,4 +1,6 @@
+use serde::{Deserialize, Serialize};
 use std::fmt;
+use ts_rs::TS;
 
 /// Unified error type for Java component operations
 ///
@@ -32,6 +34,65 @@ pub enum JavaError {
     Other(String),
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "snake_case")]
+#[ts(
+    export,
+    export_to = "../../packages/ui-new/src/types/bindings/java/index.ts"
+)]
+pub enum ResumeJavaDownloadFailureReason {
+    Network,
+    Cancelled,
+    ChecksumMismatch,
+    ExtractionFailed,
+    VerificationFailed,
+    Filesystem,
+    InvalidArchive,
+    Unknown,
+}
+
+impl ResumeJavaDownloadFailureReason {
+    /// Classify a raw error message into a stable reason enum for metrics/alert aggregation.
+    pub fn from_error_message(error: &str) -> Self {
+        let lower = error.to_ascii_lowercase();
+
+        if lower.contains("cancel") {
+            return Self::Cancelled;
+        }
+        if lower.contains("checksum") {
+            return Self::ChecksumMismatch;
+        }
+        if lower.contains("extract") || lower.contains("unsupported archive") {
+            return Self::ExtractionFailed;
+        }
+        if lower.contains("verify") || lower.contains("java executable not found") {
+            return Self::VerificationFailed;
+        }
+        if lower.contains("request")
+            || lower.contains("network")
+            || lower.contains("timed out")
+            || lower.contains("http status")
+        {
+            return Self::Network;
+        }
+        if lower.contains("archive") || lower.contains("top-level directory") {
+            return Self::InvalidArchive;
+        }
+        if lower.contains("create")
+            || lower.contains("write")
+            || lower.contains("read")
+            || lower.contains("rename")
+            || lower.contains("permission")
+            || lower.contains("directory")
+            || lower.contains("path")
+        {
+            return Self::Filesystem;
+        }
+
+        Self::Unknown
+    }
+}
+
 impl fmt::Display for JavaError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
@@ -93,3 +154,77 @@ impl From<String> for JavaError {
         JavaError::Other(err)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::ResumeJavaDownloadFailureReason;
+
+    #[test]
+    fn classify_resume_failure_reason_table_driven() {
+        let cases = [
+            (
+                "Download cancelled by user",
+                ResumeJavaDownloadFailureReason::Cancelled,
+            ),
+            (
+                "Checksum verification failed",
+                ResumeJavaDownloadFailureReason::ChecksumMismatch,
+            ),
+            (
+                "Failed to extract file: invalid archive",
+                ResumeJavaDownloadFailureReason::ExtractionFailed,
+            ),
+            (
+                "Failed to verify Java installation",
+                ResumeJavaDownloadFailureReason::VerificationFailed,
+            ),
+            (
+                "Request failed: timed out",
+                ResumeJavaDownloadFailureReason::Network,
+            ),
+            ("HTTP status 503", ResumeJavaDownloadFailureReason::Network),
+            (
+                "Failed to create directory",
+                ResumeJavaDownloadFailureReason::Filesystem,
+            ),
+            (
+                "Top-level directory not found in archive",
+                ResumeJavaDownloadFailureReason::InvalidArchive,
+            ),
+            (
+                "completely unknown issue",
+                ResumeJavaDownloadFailureReason::Unknown,
+            ),
+        ];
+
+        for (message, expected) in cases {
+            let actual = ResumeJavaDownloadFailureReason::from_error_message(message);
+            assert_eq!(
+                std::mem::discriminant(&actual),
+                std::mem::discriminant(&expected),
+                "message '{}' expected {:?} but got {:?}",
+                message,
+                expected,
+                actual
+            );
+        }
+    }
+
+    #[test]
+    fn classify_resume_failure_reason_priority_rules() {
+        let cancelled_over_network =
+            ResumeJavaDownloadFailureReason::from_error_message("request cancelled due to timeout");
+        assert_eq!(
+            std::mem::discriminant(&cancelled_over_network),
+            std::mem::discriminant(&ResumeJavaDownloadFailureReason::Cancelled)
+        );
+
+        let checksum_over_filesystem = ResumeJavaDownloadFailureReason::from_error_message(
+            "failed to read file: checksum mismatch",
+        );
+        assert_eq!(
+            std::mem::discriminant(&checksum_over_filesystem),
+            std::mem::discriminant(&ResumeJavaDownloadFailureReason::ChecksumMismatch)
+        );
+    }
+}
diff --git a/src-tauri/src/core/java/install.rs b/src-tauri/src/core/java/install.rs
new file mode 100644
index 00000000..6337388d
--- /dev/null
+++ b/src-tauri/src/core/java/install.rs
@@ -0,0 +1,179 @@
+use std::path::{Path, PathBuf};
+
+use tauri::{AppHandle, Emitter};
+
+use crate::core::downloader::{DownloadQueue, JavaDownloadProgress, PendingJavaDownload};
+use crate::utils::zip;
+
+use super::{
+    fetch_java_release_with, get_java_install_dir, strip_unc_prefix, validation, ImageType,
+    JavaInstallation, JavaProvider,
+};
+
+pub async fn download_and_install_java_with_provider<P: JavaProvider>(
+    provider: &P,
+    app_handle: &AppHandle,
+    major_version: u32,
+    image_type: ImageType,
+    custom_path: Option<PathBuf>,
+) -> Result<JavaInstallation, String> {
+    let info = fetch_java_release_with(provider, major_version, image_type)
+        .await
+        .map_err(|e| e.to_string())?;
+    let file_name = info.file_name.clone();
+
+    let install_base = custom_path.unwrap_or_else(|| get_java_install_dir(app_handle));
+    let version_dir = install_base.join(format!(
+        "{}-{}-{}",
+        provider.install_prefix(),
+        major_version,
+        image_type
+    ));
+
+    std::fs::create_dir_all(&install_base)
+        .map_err(|e| format!("Failed to create installation directory: {}", e))?;
+
+    DownloadQueue::add_pending(
+        app_handle,
+        PendingJavaDownload {
+            major_version,
+            image_type: image_type.to_string(),
+            download_url: info.download_url.clone(),
+            file_name: info.file_name.clone(),
+            file_size: info.file_size,
+            checksum: info.checksum.clone(),
+            install_path: install_base.to_string_lossy().to_string(),
+            created_at: std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_secs(),
+        },
+    )?;
+
+    let archive_path = install_base.join(&info.file_name);
+
+    let need_download = if archive_path.exists() {
+        if let Some(expected_checksum) = &info.checksum {
+            let data = std::fs::read(&archive_path)
+                .map_err(|e| format!("Failed to read downloaded file: {}", e))?;
+            !crate::core::downloader::verify_checksum(&data, Some(expected_checksum), None)
+        } else {
+            false
+        }
+    } else {
+        true
+    };
+
+    if need_download {
+        crate::core::downloader::download_with_resume(
+            app_handle,
+            &info.download_url,
+            &archive_path,
+            info.checksum.as_deref(),
+            info.file_size,
+        )
+        .await?;
+    }
+
+    let _ = app_handle.emit(
+        "java-download-progress",
+        JavaDownloadProgress {
+            file_name: file_name.clone(),
+            downloaded_bytes: info.file_size,
+            total_bytes: info.file_size,
+            speed_bytes_per_sec: 0,
+            eta_seconds: 0,
+            status: "Extracting".to_string(),
+            percentage: 100.0,
+        },
+    );
+
+    if version_dir.exists() {
+        std::fs::remove_dir_all(&version_dir)
+            .map_err(|e| format!("Failed to remove old version directory: {}", e))?;
+    }
+
+    std::fs::create_dir_all(&version_dir)
+        .map_err(|e| format!("Failed to create version directory: {}", e))?;
+
+    let top_level_dir = if info.file_name.ends_with(".tar.gz") || info.file_name.ends_with(".tgz") {
+        zip::extract_tar_gz(&archive_path, &version_dir)?
+    } else if info.file_name.ends_with(".zip") {
+        zip::extract_zip(&archive_path, &version_dir)?;
+        find_top_level_dir(&version_dir)?
+    } else {
+        return Err(format!("Unsupported archive format: {}", info.file_name));
+    };
+
+    let _ = std::fs::remove_file(&archive_path);
+
+    let java_home = version_dir.join(&top_level_dir);
+    let java_bin = resolve_java_executable(&java_home);
+
+    if !java_bin.exists() {
+        return Err(format!(
+            "Installation completed but Java executable not found: {}",
+            java_bin.display()
+        ));
+    }
+
+    let java_bin = std::fs::canonicalize(&java_bin).map_err(|e| e.to_string())?;
+    let java_bin = strip_unc_prefix(java_bin);
+
+    let installation = validation::check_java_installation(&java_bin)
+        .await
+        .ok_or_else(|| "Failed to verify Java installation".to_string())?;
+
+    DownloadQueue::remove_pending(app_handle, major_version, &image_type.to_string())?;
+
+    let _ = app_handle.emit(
+        "java-download-progress",
+        JavaDownloadProgress {
+            file_name,
+            downloaded_bytes: info.file_size,
+            total_bytes: info.file_size,
+            speed_bytes_per_sec: 0,
+            eta_seconds: 0,
+            status: "Completed".to_string(),
+            percentage: 100.0,
+        },
+    );
+
+    Ok(installation)
+}
+
+fn find_top_level_dir(extract_dir: &PathBuf) -> Result<String, String> {
+    let entries: Vec<_> = std::fs::read_dir(extract_dir)
+        .map_err(|e| format!("Failed to read directory: {}", e))?
+        .filter_map(|e| e.ok())
+        .filter(|e| e.path().is_dir())
+        .collect();
+
+    if entries.len() == 1 {
+        Ok(entries[0].file_name().to_string_lossy().to_string())
+    } else {
+        let names: Vec<String> = entries
+            .iter()
+            .map(|e| e.file_name().to_string_lossy().to_string())
+            .collect();
+        Err(format!(
+            "Expected exactly one top-level directory, found {}: {:?}",
+            names.len(),
+            names
+        ))
+    }
+}
+
+fn resolve_java_executable(java_home: &Path) -> PathBuf {
+    if cfg!(target_os = "macos") {
+        java_home
+            .join("Contents")
+            .join("Home")
+            .join("bin")
+            .join("java")
+    } else if cfg!(windows) {
+        java_home.join("bin").join("java.exe")
+    } else {
+        java_home.join("bin").join("java")
+    }
+}
diff --git a/src-tauri/src/core/java/mod.rs b/src-tauri/src/core/java/mod.rs
index 091ad0a7..cfdb27e1 100644
--- a/src-tauri/src/core/java/mod.rs
+++ b/src-tauri/src/core/java/mod.rs
@@ -1,16 +1,19 @@
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
-use tauri::{AppHandle, Emitter, Manager};
+use tauri::{AppHandle, Manager};
 
+pub mod cache;
 pub mod detection;
 pub mod error;
+pub mod install;
 pub mod persistence;
 pub mod priority;
 pub mod provider;
 pub mod providers;
 pub mod validation;
 
-pub use error::JavaError;
+pub use cache::{load_cached_catalog_result, save_catalog_cache};
+pub use error::{JavaError, ResumeJavaDownloadFailureReason};
 use ts_rs::TS;
 
 /// Remove the UNC prefix (\\?\) from Windows paths
@@ -25,12 +28,30 @@ pub fn strip_unc_prefix(path: PathBuf) -> PathBuf {
     path
 }
 
-use crate::core::downloader::{DownloadQueue, JavaDownloadProgress, PendingJavaDownload};
-use crate::utils::zip;
+use crate::core::downloader::{DownloadQueue, PendingJavaDownload};
 use provider::JavaProvider;
-use providers::AdoptiumProvider;
 
-const CACHE_DURATION_SECS: u64 = 24 * 60 * 60;
+pub async fn fetch_java_catalog_with<P: JavaProvider>(
+    provider: &P,
+    app_handle: &AppHandle,
+    force_refresh: bool,
+) -> Result<JavaCatalog, JavaError> {
+    provider.fetch_catalog(app_handle, force_refresh).await
+}
+
+pub async fn fetch_java_release_with<P: JavaProvider>(
+    provider: &P,
+    major_version: u32,
+    image_type: ImageType,
+) -> Result<JavaDownloadInfo, JavaError> {
+    provider.fetch_release(major_version, image_type).await
+}
+
+pub async fn fetch_available_versions_with<P: JavaProvider>(
+    provider: &P,
+) -> Result<Vec<u32>, JavaError> {
+    provider.available_versions().await
+}
 
 #[derive(Debug, Clone, Serialize, Deserialize, TS)]
 #[serde(rename_all = "camelCase")]
@@ -44,8 +65,36 @@ pub struct JavaInstallation {
     pub is_64bit: bool,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[ts(
+    export,
+    export_to = "../../packages/ui-new/src/types/bindings/java/index.ts"
+)]
+pub struct ResumeJavaDownloadFailure {
+    pub major_version: u32,
+    pub image_type: String,
+    pub install_path: String,
+    pub reason: ResumeJavaDownloadFailureReason,
+    pub error: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[ts(
+    export,
+    export_to = "../../packages/ui-new/src/types/bindings/java/index.ts"
+)]
+pub struct ResumeJavaDownloadsResult {
+    pub successful_installations: Vec<JavaInstallation>,
+    pub failed_downloads: Vec<ResumeJavaDownloadFailure>,
+    pub total_pending: usize,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, TS)]
 #[serde(rename_all = "lowercase")]
+#[ts(
+    export,
+    export_to = "../../packages/ui-new/src/types/bindings/java/index.ts"
+)]
 pub enum ImageType {
     Jre,
     Jdk,
@@ -66,12 +115,22 @@ impl std::fmt::Display for ImageType {
     }
 }
 
+impl ImageType {
+    pub fn parse(value: &str) -> Option<Self> {
+        match value.trim().to_ascii_lowercase().as_str() {
+            "jre" => Some(Self::Jre),
+            "jdk" => Some(Self::Jdk),
+            _ => None,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, TS)]
 #[ts(export, export_to = "java/core.ts")]
 #[serde(rename_all = "camelCase")]
 pub struct JavaReleaseInfo {
     pub major_version: u32,
-    pub image_type: String,
+    pub image_type: ImageType,
     pub version: String,
     pub release_name: String,
     pub release_date: Option<String>,
@@ -102,245 +161,13 @@ pub struct JavaDownloadInfo {
     pub file_name: String,        // e.g., "OpenJDK17U-jre_x64_linux_hotspot_17.0.2_8.tar.gz"
     pub file_size: u64,           // in bytes
     pub checksum: Option<String>, // SHA256 checksum
-    pub image_type: String,       // "jre" or "jdk"
+    pub image_type: ImageType,
 }
 
 pub fn get_java_install_dir(app_handle: &AppHandle) -> PathBuf {
     app_handle.path().app_data_dir().unwrap().join("java")
 }
 
-fn get_catalog_cache_path(app_handle: &AppHandle) -> PathBuf {
-    app_handle
-        .path()
-        .app_data_dir()
-        .unwrap()
-        .join("java_catalog_cache.json")
-}
-
-pub fn load_cached_catalog(app_handle: &AppHandle) -> Option<JavaCatalog> {
-    let cache_path = get_catalog_cache_path(app_handle);
-    if !cache_path.exists() {
-        return None;
-    }
-
-    // Read cache file
-    let content = std::fs::read_to_string(&cache_path).ok()?;
-    let catalog: JavaCatalog = serde_json::from_str(&content).ok()?;
-
-    // Get current time in seconds since UNIX_EPOCH
-    let now = std::time::SystemTime::now()
-        .duration_since(std::time::UNIX_EPOCH)
-        .unwrap()
-        .as_secs();
-
-    // Check if cache is still valid
-    if now - catalog.cached_at < CACHE_DURATION_SECS {
-        Some(catalog)
-    } else {
-        None
-    }
-}
-
-pub fn save_catalog_cache(app_handle: &AppHandle, catalog: &JavaCatalog) -> Result<(), String> {
-    let cache_path = get_catalog_cache_path(app_handle);
-    let content = serde_json::to_string_pretty(catalog).map_err(|e| e.to_string())?;
-    std::fs::write(&cache_path, content).map_err(|e| e.to_string())?;
-    Ok(())
-}
-
-#[allow(dead_code)]
-pub fn clear_catalog_cache(app_handle: &AppHandle) -> Result<(), String> {
-    let cache_path = get_catalog_cache_path(app_handle);
-    if cache_path.exists() {
-        std::fs::remove_file(&cache_path).map_err(|e| e.to_string())?;
-    }
-    Ok(())
-}
-
-pub async fn fetch_java_catalog(
-    app_handle: &AppHandle,
-    force_refresh: bool,
-) -> Result<JavaCatalog, String> {
-    let provider = AdoptiumProvider::new();
-    provider
-        .fetch_catalog(app_handle, force_refresh)
-        .await
-        .map_err(|e| e.to_string())
-}
-
-pub async fn fetch_java_release(
-    major_version: u32,
-    image_type: ImageType,
-) -> Result<JavaDownloadInfo, String> {
-    let provider = AdoptiumProvider::new();
-    provider
-        .fetch_release(major_version, image_type)
-        .await
-        .map_err(|e| e.to_string())
-}
-
-pub async fn fetch_available_versions() -> Result<Vec<u32>, String> {
-    let provider = AdoptiumProvider::new();
-    provider
-        .available_versions()
-        .await
-        .map_err(|e| e.to_string())
-}
-
-pub async fn download_and_install_java(
-    app_handle: &AppHandle,
-    major_version: u32,
-    image_type: ImageType,
-    custom_path: Option<PathBuf>,
-) -> Result<JavaInstallation, String> {
-    let provider = AdoptiumProvider::new();
-    let info = provider.fetch_release(major_version, image_type).await?;
-    let file_name = info.file_name.clone();
-
-    let install_base = custom_path.unwrap_or_else(|| get_java_install_dir(app_handle));
-    let version_dir = install_base.join(format!(
-        "{}-{}-{}",
-        provider.install_prefix(),
-        major_version,
-        image_type
-    ));
-
-    std::fs::create_dir_all(&install_base)
-        .map_err(|e| format!("Failed to create installation directory: {}", e))?;
-
-    let mut queue = DownloadQueue::load(app_handle);
-    queue.add(PendingJavaDownload {
-        major_version,
-        image_type: image_type.to_string(),
-        download_url: info.download_url.clone(),
-        file_name: info.file_name.clone(),
-        file_size: info.file_size,
-        checksum: info.checksum.clone(),
-        install_path: install_base.to_string_lossy().to_string(),
-        created_at: std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_secs(),
-    });
-    queue.save(app_handle)?;
-
-    let archive_path = install_base.join(&info.file_name);
-
-    let need_download = if archive_path.exists() {
-        if let Some(expected_checksum) = &info.checksum {
-            let data = std::fs::read(&archive_path)
-                .map_err(|e| format!("Failed to read downloaded file: {}", e))?;
-            !crate::core::downloader::verify_checksum(&data, Some(expected_checksum), None)
-        } else {
-            false
-        }
-    } else {
-        true
-    };
-
-    if need_download {
-        crate::core::downloader::download_with_resume(
-            app_handle,
-            &info.download_url,
-            &archive_path,
-            info.checksum.as_deref(),
-            info.file_size,
-        )
-        .await?;
-    }
-
-    let _ = app_handle.emit(
-        "java-download-progress",
-        JavaDownloadProgress {
-            file_name: file_name.clone(),
-            downloaded_bytes: info.file_size,
-            total_bytes: info.file_size,
-            speed_bytes_per_sec: 0,
-            eta_seconds: 0,
-            status: "Extracting".to_string(),
-            percentage: 100.0,
-        },
-    );
-
-    if version_dir.exists() {
-        std::fs::remove_dir_all(&version_dir)
-            .map_err(|e| format!("Failed to remove old version directory: {}", e))?;
-    }
-
-    std::fs::create_dir_all(&version_dir)
-        .map_err(|e| format!("Failed to create version directory: {}", e))?;
-
-    let top_level_dir = if info.file_name.ends_with(".tar.gz") || info.file_name.ends_with(".tgz") {
-        zip::extract_tar_gz(&archive_path, &version_dir)?
-    } else if info.file_name.ends_with(".zip") {
-        zip::extract_zip(&archive_path, &version_dir)?;
-        find_top_level_dir(&version_dir)?
-    } else {
-        return Err(format!("Unsupported archive format: {}", info.file_name));
-    };
-
-    let _ = std::fs::remove_file(&archive_path);
-
-    let java_home = version_dir.join(&top_level_dir);
-    let java_bin = if cfg!(target_os = "macos") {
-        java_home
-            .join("Contents")
-            .join("Home")
-            .join("bin")
-            .join("java")
-    } else if cfg!(windows) {
-        java_home.join("bin").join("java.exe")
-    } else {
-        java_home.join("bin").join("java")
-    };
-
-    if !java_bin.exists() {
-        return Err(format!(
-            "Installation completed but Java executable not found: {}",
-            java_bin.display()
-        ));
-    }
-
-    let java_bin = std::fs::canonicalize(&java_bin).map_err(|e| e.to_string())?;
-    let java_bin = strip_unc_prefix(java_bin);
-
-    let installation = validation::check_java_installation(&java_bin)
-        .await
-        .ok_or_else(|| "Failed to verify Java installation".to_string())?;
-
-    queue.remove(major_version, &image_type.to_string());
-    queue.save(app_handle)?;
-
-    let _ = app_handle.emit(
-        "java-download-progress",
-        JavaDownloadProgress {
-            file_name,
-            downloaded_bytes: info.file_size,
-            total_bytes: info.file_size,
-            speed_bytes_per_sec: 0,
-            eta_seconds: 0,
-            status: "Completed".to_string(),
-            percentage: 100.0,
-        },
-    );
-
-    Ok(installation)
-}
-
-fn find_top_level_dir(extract_dir: &PathBuf) -> Result<String, String> {
-    let entries: Vec<_> = std::fs::read_dir(extract_dir)
-        .map_err(|e| format!("Failed to read directory: {}", e))?
-        .filter_map(|e| e.ok())
-        .filter(|e| e.path().is_dir())
-        .collect();
-
-    if entries.len() == 1 {
-        Ok(entries[0].file_name().to_string_lossy().to_string())
-    } else {
-        Ok(String::new())
-    }
-}
-
 pub async fn detect_java_installations() -> Vec<JavaInstallation> {
     let mut installations = Vec::new();
     let candidates = detection::get_java_candidates();
@@ -481,20 +308,26 @@ fn find_java_executable(dir: &PathBuf) -> Option<PathBuf> {
     None
 }
 
-pub async fn resume_pending_downloads(
+pub async fn resume_pending_downloads_with<P: JavaProvider>(
+    provider: &P,
     app_handle: &AppHandle,
-) -> Result<Vec<JavaInstallation>, String> {
-    let queue = DownloadQueue::load(app_handle);
+) -> Result<ResumeJavaDownloadsResult, String> {
+    let pending_downloads = DownloadQueue::list_pending(app_handle);
     let mut installed = Vec::new();
-
-    for pending in queue.pending_downloads.iter() {
-        let image_type = if pending.image_type == "jdk" {
-            ImageType::Jdk
-        } else {
+    let mut failed = Vec::new();
+    let total_pending = pending_downloads.len();
+
+    for pending in pending_downloads.iter() {
+        let image_type = ImageType::parse(&pending.image_type).unwrap_or_else(|| {
+            eprintln!(
+                "Unknown image type '{}' in pending download, defaulting to jre",
+                pending.image_type
+            );
             ImageType::Jre
-        };
+        });
 
-        match download_and_install_java(
+        match install::download_and_install_java_with_provider(
+            provider,
             app_handle,
             pending.major_version,
             image_type,
@@ -510,11 +343,23 @@ pub async fn resume_pending_downloads(
                     "Failed to resume Java {} {} download: {}",
                     pending.major_version, pending.image_type, e
                 );
+
+                failed.push(ResumeJavaDownloadFailure {
+                    major_version: pending.major_version,
+                    image_type: pending.image_type.clone(),
+                    install_path: pending.install_path.clone(),
+                    reason: ResumeJavaDownloadFailureReason::from_error_message(&e),
+                    error: e,
+                });
             }
         }
     }
 
-    Ok(installed)
+    Ok(ResumeJavaDownloadsResult {
+        successful_installations: installed,
+        failed_downloads: failed,
+        total_pending,
+    })
 }
 
 pub fn cancel_current_download() {
@@ -522,8 +367,7 @@ pub fn cancel_current_download() {
 }
 
 pub fn get_pending_downloads(app_handle: &AppHandle) -> Vec<PendingJavaDownload> {
-    let queue = DownloadQueue::load(app_handle);
-    queue.pending_downloads
+    DownloadQueue::list_pending(app_handle)
 }
 
 #[allow(dead_code)]
@@ -532,7 +376,5 @@ pub fn clear_pending_download(
     major_version: u32,
     image_type: &str,
 ) -> Result<(), String> {
-    let mut queue = DownloadQueue::load(app_handle);
-    queue.remove(major_version, image_type);
-    queue.save(app_handle)
+    DownloadQueue::remove_pending(app_handle, major_version, image_type)
 }
diff --git a/src-tauri/src/core/java/persistence.rs b/src-tauri/src/core/java/persistence.rs
index a6727d7f..0cef9f07 100644
--- a/src-tauri/src/core/java/persistence.rs
+++ b/src-tauri/src/core/java/persistence.rs
@@ -30,28 +30,31 @@ fn get_java_config_path(app_handle: &AppHandle) -> PathBuf {
         .join("java_config.json")
 }
 
-pub fn load_java_config(app_handle: &AppHandle) -> JavaConfig {
-    let config_path = get_java_config_path(app_handle);
-    if !config_path.exists() {
-        return JavaConfig::default();
+fn write_file_atomic(path: &PathBuf, content: &str) -> Result<(), JavaError> {
+    let parent = path.parent().ok_or_else(|| {
+        JavaError::InvalidConfig("Java config path has no parent directory".to_string())
+    })?;
+
+    std::fs::create_dir_all(parent)?;
+
+    let tmp_path = path.with_extension("tmp");
+    std::fs::write(&tmp_path, content)?;
+
+    if path.exists() {
+        let _ = std::fs::remove_file(path);
     }
 
-    match std::fs::read_to_string(&config_path) {
-        Ok(content) => match serde_json::from_str(&content) {
-            Ok(config) => config,
-            Err(err) => {
-                // Log the error but don't panic - return default config
-                log::warn!(
-                    "Failed to parse Java config at {}: {}. Using default configuration.",
-                    config_path.display(),
-                    err
-                );
-                JavaConfig::default()
-            }
-        },
+    std::fs::rename(&tmp_path, path)?;
+    Ok(())
+}
+
+pub fn load_java_config(app_handle: &AppHandle) -> JavaConfig {
+    match load_java_config_result(app_handle) {
+        Ok(config) => config,
         Err(err) => {
+            let config_path = get_java_config_path(app_handle);
             log::warn!(
-                "Failed to read Java config at {}: {}. Using default configuration.",
+                "Failed to load Java config at {}: {}. Using default configuration.",
                 config_path.display(),
                 err
             );
@@ -60,16 +63,21 @@ pub fn load_java_config(app_handle: &AppHandle) -> JavaConfig {
     }
 }
 
-pub fn save_java_config(app_handle: &AppHandle, config: &JavaConfig) -> Result<(), JavaError> {
+pub fn load_java_config_result(app_handle: &AppHandle) -> Result<JavaConfig, JavaError> {
     let config_path = get_java_config_path(app_handle);
-    let content = serde_json::to_string_pretty(config)?;
+    if !config_path.exists() {
+        return Ok(JavaConfig::default());
+    }
 
-    std::fs::create_dir_all(config_path.parent().ok_or_else(|| {
-        JavaError::InvalidConfig("Java config path has no parent directory".to_string())
-    })?)?;
+    let content = std::fs::read_to_string(&config_path)?;
+    let config: JavaConfig = serde_json::from_str(&content)?;
+    Ok(config)
+}
 
-    std::fs::write(&config_path, content)?;
-    Ok(())
+pub fn save_java_config(app_handle: &AppHandle, config: &JavaConfig) -> Result<(), JavaError> {
+    let config_path = get_java_config_path(app_handle);
+    let content = serde_json::to_string_pretty(config)?;
+    write_file_atomic(&config_path, &content)
 }
 
 #[allow(dead_code)]
diff --git a/src-tauri/src/core/java/providers/adoptium.rs b/src-tauri/src/core/java/providers/adoptium.rs
index 1765a994..19e0de4b 100644
--- a/src-tauri/src/core/java/providers/adoptium.rs
+++ b/src-tauri/src/core/java/providers/adoptium.rs
@@ -3,10 +3,22 @@ use crate::core::java::provider::JavaProvider;
 use crate::core::java::save_catalog_cache;
 use crate::core::java::{ImageType, JavaCatalog, JavaDownloadInfo, JavaReleaseInfo};
 use serde::Deserialize;
+use std::sync::Arc;
 use tauri::AppHandle;
+use tokio::sync::Semaphore;
+use tokio::time::{sleep, Duration};
 use ts_rs::TS;
 
 const ADOPTIUM_API_BASE: &str = "https://api.adoptium.net/v3";
+const CATALOG_MAX_CONCURRENT_REQUESTS: usize = 6;
+#[cfg(not(test))]
+const CATALOG_REQUEST_RETRIES: u32 = 3;
+#[cfg(test)]
+const CATALOG_REQUEST_RETRIES: u32 = 2; // TODO: Consider making this configurable
+#[cfg(not(test))]
+const CATALOG_RETRY_BASE_DELAY_MS: u64 = 300;
+#[cfg(test)]
+const CATALOG_RETRY_BASE_DELAY_MS: u64 = 10; // TODO: Consider making this configurable
 
 #[derive(Debug, Clone, Deserialize, TS)]
 #[ts(export, export_to = "java/providers/adoptium.ts")]
@@ -72,6 +84,91 @@ impl Default for AdoptiumProvider {
     }
 }
 
+async fn fetch_available_releases_with_retry(
+    client: &reqwest::Client,
+    releases_url: &str,
+) -> Result<AvailableReleases, JavaError> {
+    for attempt in 0..=CATALOG_REQUEST_RETRIES {
+        let response = client
+            .get(releases_url)
+            .header("Accept", "application/json")
+            .send()
+            .await;
+
+        match response {
+            Ok(resp) => {
+                if resp.status().is_success() {
+                    return resp.json::<AvailableReleases>().await.map_err(|e| {
+                        JavaError::SerializationError(format!(
+                            "Failed to parse available releases: {}",
+                            e
+                        ))
+                    });
+                }
+
+                if attempt == CATALOG_REQUEST_RETRIES {
+                    return Err(JavaError::NetworkError(format!(
+                        "Failed to fetch available releases after retries, status: {}",
+                        resp.status()
+                    )));
+                }
+            }
+            Err(err) => {
+                if attempt == CATALOG_REQUEST_RETRIES {
+                    return Err(JavaError::NetworkError(format!(
+                        "Failed to fetch available releases: {}",
+                        err
+                    )));
+                }
+            }
+        }
+
+        let backoff = CATALOG_RETRY_BASE_DELAY_MS * (1_u64 << attempt);
+        sleep(Duration::from_millis(backoff)).await;
+    }
+
+    Err(JavaError::NetworkError(
+        "Failed to fetch available releases after retries".to_string(),
+    ))
+}
+
+async fn fetch_adoptium_assets_with_retry(
+    client: &reqwest::Client,
+    url: &str,
+) -> Result<Vec<AdoptiumAsset>, String> {
+    let mut last_error = "unknown error".to_string();
+
+    for attempt in 0..=CATALOG_REQUEST_RETRIES {
+        match client
+            .get(url)
+            .header("Accept", "application/json")
+            .send()
+            .await
+        {
+            Ok(response) => {
+                if response.status().is_success() {
+                    return response
+                        .json::<Vec<AdoptiumAsset>>()
+                        .await
+                        .map_err(|e| format!("Failed to parse assets response: {}", e));
+                }
+
+                last_error = format!("HTTP status {}", response.status());
+            }
+            Err(err) => {
+                last_error = err.to_string();
+            }
+        }
+
+        if attempt < CATALOG_REQUEST_RETRIES {
+            let backoff = CATALOG_RETRY_BASE_DELAY_MS * (1_u64 << attempt);
+            sleep(Duration::from_millis(backoff)).await;
+        }
+    }
+
+    Err(last_error)
+}
+
 impl JavaProvider for AdoptiumProvider {
     async fn fetch_catalog(
         &self,
@@ -79,8 +176,12 @@ impl JavaProvider for AdoptiumProvider {
         force_refresh: bool,
     ) -> Result<JavaCatalog, JavaError> {
         if !force_refresh {
-            if let Some(cached) = crate::core::java::load_cached_catalog(app_handle) {
-                return Ok(cached);
+            match crate::core::java::load_cached_catalog_result(app_handle) {
+                Ok(Some(cached)) => return Ok(cached),
+                Ok(None) => {}
+                Err(err) => {
+                    log::warn!("Failed to load Java catalog cache: {}", err);
+                }
             }
         }
 
@@ -89,27 +190,16 @@ impl JavaProvider for AdoptiumProvider {
         let client = reqwest::Client::new();
 
         let releases_url = format!("{}/info/available_releases", ADOPTIUM_API_BASE);
-        let available: AvailableReleases = client
-            .get(&releases_url)
-            .header("Accept", "application/json")
-            .send()
-            .await
-            .map_err(|e| {
-                JavaError::NetworkError(format!("Failed to fetch available releases: {}", e))
-            })?
-            .json::<AvailableReleases>()
-            .await
-            .map_err(|e| {
-                JavaError::SerializationError(format!("Failed to parse available releases: {}", e))
-            })?;
+        let available = fetch_available_releases_with_retry(&client, &releases_url).await?;
 
-        // Parallelize HTTP requests for better performance
+        // Bounded parallel requests with retry to avoid request spikes.
         let mut fetch_tasks = Vec::new();
+        let semaphore = Arc::new(Semaphore::new(CATALOG_MAX_CONCURRENT_REQUESTS));
 
         for major_version in &available.available_releases {
-            for image_type in &["jre", "jdk"] {
+            for image_type in [ImageType::Jre, ImageType::Jdk] {
                 let major_version = *major_version;
-                let image_type = image_type.to_string();
+                let image_type = image_type;
                 let url = format!(
                     "{}/assets/latest/{}/hotspot?os={}&architecture={}&image_type={}",
                     ADOPTIUM_API_BASE, major_version, os, arch, image_type
@@ -117,64 +207,50 @@ impl JavaProvider for AdoptiumProvider {
                 let client = client.clone();
                 let is_lts = available.available_lts_releases.contains(&major_version);
                 let arch = arch.to_string();
+                let semaphore = semaphore.clone();
 
                 let task = tokio::spawn(async move {
-                    match client
-                        .get(&url)
-                        .header("Accept", "application/json")
-                        .send()
-                        .await
-                    {
-                        Ok(response) => {
-                            if response.status().is_success() {
-                                if let Ok(assets) = response.json::<Vec<AdoptiumAsset>>().await {
-                                    if let Some(asset) = assets.into_iter().next() {
-                                        let release_date = asset.binary.updated_at.clone();
-                                        return Some(JavaReleaseInfo {
-                                            major_version,
-                                            image_type,
-                                            version: asset.version.semver.clone(),
-                                            release_name: asset.release_name.clone(),
-                                            release_date,
-                                            file_size: asset.binary.package.size,
-                                            checksum: asset.binary.package.checksum,
-                                            download_url: asset.binary.package.link,
-                                            is_lts,
-                                            is_available: true,
-                                            architecture: asset.binary.architecture.clone(),
-                                        });
-                                    }
-                                }
-                            }
-                            // Fallback for unsuccessful response
-                            Some(JavaReleaseInfo {
+                    let _permit = semaphore.acquire_owned().await.ok();
+
+                    if let Ok(assets) = fetch_adoptium_assets_with_retry(&client, &url).await {
+                        if let Some(asset) = assets.into_iter().next() {
+                            let release_date = asset.binary.updated_at.clone();
+                            return Some(JavaReleaseInfo {
                                 major_version,
                                 image_type,
-                                version: format!("{}.x", major_version),
-                                release_name: format!("jdk-{}", major_version),
-                                release_date: None,
-                                file_size: 0,
-                                checksum: None,
-                                download_url: String::new(),
+                                version: asset.version.semver.clone(),
+                                release_name: asset.release_name.clone(),
+                                release_date,
+                                file_size: asset.binary.package.size,
+                                checksum: asset.binary.package.checksum,
+                                download_url: asset.binary.package.link,
                                 is_lts,
-                                is_available: false,
-                                architecture: arch,
-                            })
+                                is_available: true,
+                                architecture: asset.binary.architecture.clone(),
+                            });
                         }
-                        Err(_) => Some(JavaReleaseInfo {
+                    } else {
+                        log::warn!(
+                            "Adoptium catalog fetch failed after retries (major={}, image_type={})",
                             major_version,
-                            image_type,
-                            version: format!("{}.x", major_version),
-                            release_name: format!("jdk-{}", major_version),
-                            release_date: None,
-                            file_size: 0,
-                            checksum: None,
-                            download_url: String::new(),
-                            is_lts,
-                            is_available: false,
-                            architecture: arch,
-                        }),
+                            image_type
+                        );
                     }
+
+                    // Fallback for failed/unavailable response
+                    Some(JavaReleaseInfo {
+                        major_version,
+                        image_type,
+                        version: format!("{}.x", major_version),
+                        release_name: format!("jdk-{}", major_version),
+                        release_date: None,
+                        file_size: 0,
+                        checksum: None,
+                        download_url: String::new(),
+                        is_lts,
+                        is_available: false,
+                        architecture: arch,
+                    })
                 });
                 fetch_tasks.push(task);
             }
@@ -261,7 +337,7 @@ impl JavaProvider for AdoptiumProvider {
             file_name: asset.binary.package.name,
             file_size: asset.binary.package.size,
             checksum: asset.binary.package.checksum,
-            image_type: asset.binary.image_type,
+            image_type,
         })
     }
 
@@ -338,3 +414,141 @@ impl JavaProvider for AdoptiumProvider {
         "temurin"
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::{Read, Write};
+    use std::net::TcpListener;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    use std::sync::Arc;
+    use std::thread;
+    use std::time::Duration as StdDuration;
+
+    #[derive(Clone)]
+    struct MockResponse {
+        status_line: &'static str,
+        body: &'static str,
+        delay_ms: u64,
+    }
+
+    fn spawn_mock_server(
+        responses: Vec<MockResponse>,
+    ) -> (String, Arc<AtomicUsize>, thread::JoinHandle<()>) {
+        let listener = TcpListener::bind("127.0.0.1:0").expect("bind test server failed");
+        let addr = listener.local_addr().expect("read local addr failed");
+        let hits = Arc::new(AtomicUsize::new(0));
+        let hits_clone = Arc::clone(&hits);
+
+        let handle = thread::spawn(move || {
+            for response in responses {
+                let (mut stream, _) = listener.accept().expect("accept failed");
+                hits_clone.fetch_add(1, Ordering::SeqCst);
+
+                let _ = stream.set_read_timeout(Some(StdDuration::from_millis(100)));
+                let mut buf = [0_u8; 2048];
+                let _ = stream.read(&mut buf);
+
+                if response.delay_ms > 0 {
+                    thread::sleep(StdDuration::from_millis(response.delay_ms));
+                }
+
+                let body_bytes = response.body.as_bytes();
+                let head = format!(
+                    "HTTP/1.1 {}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
+                    response.status_line,
+                    body_bytes.len()
+                );
+                let _ = stream.write_all(head.as_bytes());
+                let _ = stream.write_all(body_bytes);
+                let _ = stream.flush();
+            }
+        });
+
+        (format!("http://{}", addr), hits, handle)
+    }
+
+    #[tokio::test]
+    async fn fetch_available_releases_retries_on_timeout() {
+        let attempts = CATALOG_REQUEST_RETRIES as usize + 1;
+        let responses = vec![
+            MockResponse {
+                status_line: "200 OK",
+                body: "{\"available_releases\":[21],\"available_lts_releases\":[21],\"most_recent_lts\":21,\"most_recent_feature_release\":21}",
+                delay_ms: 120,
+            };
+            attempts
+        ];
+        let (base_url, hits, handle) = spawn_mock_server(responses);
+
+        let client = reqwest::Client::builder()
+            .timeout(StdDuration::from_millis(30))
+            .build()
+            .expect("build client failed");
+
+        let result =
+            fetch_available_releases_with_retry(&client, &format!("{}/releases", base_url)).await;
+        let _ = handle.join();
+
+        assert!(matches!(result, Err(JavaError::NetworkError(_))));
+        assert_eq!(hits.load(Ordering::SeqCst), attempts);
+    }
+
+    #[tokio::test]
+    async fn fetch_available_releases_retries_on_http_5xx() {
+        let attempts = CATALOG_REQUEST_RETRIES as usize + 1;
+        let responses = vec![
+            MockResponse {
+                status_line: "503 Service Unavailable",
+                body: "{}",
+                delay_ms: 0,
+            };
+            attempts
+        ];
+        let (base_url, hits, handle) = spawn_mock_server(responses);
+        let client = reqwest::Client::new();
+
+        let result =
+            fetch_available_releases_with_retry(&client, &format!("{}/releases", base_url)).await;
+        let _ = handle.join();
+
+        assert!(matches!(result, Err(JavaError::NetworkError(_))));
+        assert_eq!(hits.load(Ordering::SeqCst), attempts);
+    }
+
+    #[tokio::test]
+    async fn fetch_available_releases_parse_failure_returns_serialization_error() {
+        let responses = vec![MockResponse {
+            status_line: "200 OK",
+            body: "{this is invalid json",
+            delay_ms: 0,
+        }];
+        let (base_url, hits, handle) = spawn_mock_server(responses);
+        let client = reqwest::Client::new();
+
+        let result =
+            fetch_available_releases_with_retry(&client, &format!("{}/releases", base_url)).await;
+        let _ = handle.join();
+
+        assert!(matches!(result, Err(JavaError::SerializationError(_))));
+        assert_eq!(hits.load(Ordering::SeqCst), 1);
+    }
+
+    #[tokio::test]
+    async fn fetch_assets_parse_failure_returns_error() {
+        let responses = vec![MockResponse {
+            status_line: "200 OK",
+            body: "[invalid",
+            delay_ms: 0,
+        }];
+        let (base_url, hits, handle) = spawn_mock_server(responses);
+        let client = reqwest::Client::new();
+
+        let result =
+            fetch_adoptium_assets_with_retry(&client, &format!("{}/assets", base_url)).await;
+        let _ = handle.join();
+
+        assert!(result.is_err());
+        assert_eq!(hits.load(Ordering::SeqCst), 1);
+    }
+}
diff --git a/src-tauri/src/core/java/validation.rs b/src-tauri/src/core/java/validation.rs
index b56ad59d..b83d5a74 100644
--- a/src-tauri/src/core/java/validation.rs
+++ b/src-tauri/src/core/java/validation.rs
@@ -24,7 +24,13 @@ fn check_java_installation_blocking(path: &PathBuf) -> Option<JavaInstallation>
 
     let output = cmd.output().ok()?;
 
-    let version_output = String::from_utf8_lossy(&output.stderr);
+    let stderr_output = String::from_utf8_lossy(&output.stderr);
+    let stdout_output = String::from_utf8_lossy(&output.stdout);
+    let version_output = if stderr_output.trim().is_empty() {
+        stdout_output
+    } else {
+        stderr_output
+    };
 
     let version = parse_version_string(&version_output)?;
     let arch = extract_architecture(&version_output);
diff --git a/src-tauri/src/core/modpack.rs b/src-tauri/src/core/modpack.rs
index 5ac9493e..2998167d 100644
--- a/src-tauri/src/core/modpack.rs
+++ b/src-tauri/src/core/modpack.rs
@@ -294,8 +294,6 @@ fn parse_multimc(archive: &mut Archive) -> Result<ParsedModpack, String> {
 
 // ── CurseForge API resolution ─────────────────────────────────────────────
 
-const CURSEFORGE_API_KEY: &str = env!("CURSEFORGE_API_KEY");
-
 async fn resolve_curseforge_files(files: &[ModpackFile]) -> Result<Vec<ModpackFile>, String> {
     let file_ids: Vec<u64> = files
         .iter()
@@ -368,9 +366,15 @@ async fn cf_post(
     endpoint: &str,
     body: &serde_json::Value,
 ) -> Result<serde_json::Value, String> {
+    let api_key = std::env::var("CURSEFORGE_API_KEY")
+        .map_err(|_| "CURSEFORGE_API_KEY is not set".to_string())?;
+    if api_key.trim().is_empty() {
+        return Err("CURSEFORGE_API_KEY is empty".to_string());
+    }
+
     let resp = client
         .post(format!("https://api.curseforge.com{endpoint}"))
-        .header("x-api-key", CURSEFORGE_API_KEY)
+        .header("x-api-key", api_key)
         .json(body)
         .send()
         .await
diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
index 33c94fe4..143f4346 100644
--- a/src-tauri/src/main.rs
+++ b/src-tauri/src/main.rs
@@ -6,7 +6,9 @@ use std::process::Stdio;
 use std::sync::Mutex;
 use tauri::{Emitter, Manager, State, Window}; // Added Emitter
 use tokio::io::{AsyncBufReadExt, BufReader};
-use tokio::process::Command;
+use tokio::process::{Child, Command};
+use tokio::sync::Mutex as AsyncMutex;
+use tokio::time::{Duration, sleep};
 use ts_rs::TS; // Added Serialize
 
 #[cfg(target_os = "windows")]
@@ -42,6 +44,39 @@ impl MsRefreshTokenState {
     }
 }
 
+struct RunningGameProcess {
+    child: Child,
+    instance_id: String,
+    version_id: String,
+}
+
+pub struct GameProcessState {
+    running_game: AsyncMutex<Option<RunningGameProcess>>,
+}
+
+impl Default for GameProcessState {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl GameProcessState {
+    pub fn new() -> Self {
+        Self {
+            running_game: AsyncMutex::new(None),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct GameExitedEvent {
+    instance_id: String,
+    version_id: String,
+    exit_code: Option<i32>,
+    was_stopped: bool,
+}
+
 /// Check if a string contains unresolved placeholders in the form ${...}
 ///
 /// After the replacement phase, if a string still contains ${...}, it means
@@ -63,6 +98,24 @@ fn has_unresolved_placeholder(s: &str) -> bool {
     false
 }
 
+fn resolve_minecraft_version(version_id: &str) -> String {
+    if version_id.starts_with("fabric-loader-") {
+        version_id
+            .split('-')
+            .next_back()
+            .unwrap_or(version_id)
+            .to_string()
+    } else if version_id.contains("-forge-") {
+        version_id
+            .split("-forge-")
+            .next()
+            .unwrap_or(version_id)
+            .to_string()
+    } else {
+        version_id.to_string()
+    }
+}
+
 #[tauri::command]
 #[dropout_macros::api]
 async fn start_game(
@@ -70,6 +123,7 @@ async fn start_game(
     auth_state: State<'_, core::auth::AccountState>,
     config_state: State<'_, core::config::ConfigState>,
     assistant_state: State<'_, core::assistant::AssistantState>,
+    game_process_state: State<'_, GameProcessState>,
     instance_state: State<'_, core::instance::InstanceState>,
     instance_id: String,
     version_id: String,
@@ -82,6 +136,52 @@ async fn start_game(
         )
     );
 
+    let stale_instance_to_unlock = {
+        let mut running_game = game_process_state.running_game.lock().await;
+
+        if let Some(existing_game) = running_game.as_mut() {
+            match existing_game.child.try_wait() {
+                Ok(Some(status)) => {
+                    emit_log!(
+                        window,
+                        format!(
+                            "Clearing stale game process for instance {} (exit code: {:?})",
+                            existing_game.instance_id,
+                            status.code()
+                        )
+                    );
+                    let stale_instance_id = existing_game.instance_id.clone();
+                    *running_game = None;
+                    Some(stale_instance_id)
+                }
+                Ok(None) => {
+                    return Err(format!(
+                        "A game is already running for instance {}",
+                        existing_game.instance_id
+                    ));
+                }
+                Err(error) => {
+                    emit_log!(
+                        window,
+                        format!(
+                            "Clearing broken game process state for instance {}: {}",
+                            existing_game.instance_id, error
+                        )
+                    );
+                    let stale_instance_id = existing_game.instance_id.clone();
+                    *running_game = None;
+                    Some(stale_instance_id)
+                }
+            }
+        } else {
+            None
+        }
+    };
+
+    if let Some(stale_instance_id) = stale_instance_to_unlock {
+        instance_state.end_operation(&stale_instance_id);
+    }
+
     // Check for active account
     emit_log!(window, "Checking for active account...".to_string());
     let mut account = auth_state
@@ -123,16 +223,18 @@ async fn start_game(
     emit_log!(window, "Account found".to_string());
 
     let config = config_state.config.lock().unwrap().clone();
+    let app_handle = window.app_handle();
+    instance_state.begin_operation(&instance_id, core::instance::InstanceOperation::Launch)?;
+
+    let launch_result: Result<String, String> = async {
     emit_log!(window, format!("Java path: {}", config.java_path));
     emit_log!(
         window,
         format!("Memory: {}MB - {}MB", config.min_memory, config.max_memory)
     );
 
-    // Get game directory from instance
-    let game_dir = instance_state
-        .get_instance_game_dir(&instance_id)
-        .ok_or_else(|| format!("Instance {} not found", instance_id))?;
+    let resolved_paths = instance_state.resolve_paths(&instance_id, &config, &app_handle)?;
+    let game_dir = resolved_paths.root.clone();
 
     // Ensure game directory exists
     tokio::fs::create_dir_all(&game_dir)
@@ -203,7 +305,6 @@ async fn start_game(
     // Resolve Java using priority-based resolution
     // Priority: instance override > global config > user preference > auto-detect
     // TODO: refactor into a separate function
-    let app_handle = window.app_handle();
     let instance = instance_state
         .get_instance(&instance_id)
         .ok_or_else(|| format!("Instance {} not found", instance_id))?;
@@ -260,12 +361,7 @@ async fn start_game(
         .as_ref()
         .ok_or("Version has no downloads information")?;
     let client_jar = &downloads.client;
-    // Use shared caches for versions if enabled
-    let mut client_path = if config.use_shared_caches {
-        app_handle.path().app_data_dir().unwrap().join("versions")
-    } else {
-        game_dir.join("versions")
-    };
+    let mut client_path = resolved_paths.version_cache.clone();
     client_path.push(&minecraft_version);
     client_path.push(format!("{}.jar", minecraft_version));
 
@@ -278,12 +374,7 @@ async fn start_game(
 
     // --- Libraries ---
     println!("Processing libraries...");
-    // Use shared caches for libraries if enabled
-    let libraries_dir = if config.use_shared_caches {
-        app_handle.path().app_data_dir().unwrap().join("libraries")
-    } else {
-        game_dir.join("libraries")
-    };
+    let libraries_dir = resolved_paths.libraries.clone();
     let mut native_libs_paths = Vec::new(); // Store paths to native jars for extraction
 
     for lib in &version_details.libraries {
@@ -380,12 +471,7 @@ async fn start_game(
 
     // --- Assets ---
     println!("Fetching asset index...");
-    // Use shared caches for assets if enabled
-    let assets_dir = if config.use_shared_caches {
-        app_handle.path().app_data_dir().unwrap().join("assets")
-    } else {
-        game_dir.join("assets")
-    };
+    let assets_dir = resolved_paths.assets.clone();
     let objects_dir = assets_dir.join("objects");
     let indexes_dir = assets_dir.join("indexes");
 
@@ -772,6 +858,15 @@ async fn start_game(
         .take()
         .expect("child did not have a handle to stderr");
 
+    {
+        let mut running_game = game_process_state.running_game.lock().await;
+        *running_game = Some(RunningGameProcess {
+            child,
+            instance_id: instance_id.clone(),
+            version_id: version_id.clone(),
+        });
+    }
+
     // Emit launcher log that game is running
     emit_log!(
         window,
@@ -793,6 +888,7 @@ async fn start_game(
     let window_rx_err = window.clone();
     let assistant_arc_err = assistant_state.assistant.clone();
     let window_exit = window.clone();
+    let app_handle_exit = app_handle.clone();
     tokio::spawn(async move {
         let mut reader = BufReader::new(stderr).lines();
         while let Ok(Some(line)) = reader.next_line().await {
@@ -804,17 +900,64 @@ async fn start_game(
     });
 
     // Monitor game process exit
+    let launch_instance_id = instance_id.clone();
+    let launch_version_id = version_id.clone();
     tokio::spawn(async move {
-        match child.wait().await {
-            Ok(status) => {
-                let msg = format!("Game process exited with status: {}", status);
-                let _ = window_exit.emit("launcher-log", &msg);
-                let _ = window_exit.emit("game-exited", status.code().unwrap_or(-1));
-            }
-            Err(e) => {
-                let msg = format!("Error waiting for game process: {}", e);
+        loop {
+            let exit_event = {
+                let state: State<'_, GameProcessState> = app_handle_exit.state();
+                let mut running_game = state.running_game.lock().await;
+
+                let Some(active_game) = running_game.as_mut() else {
+                    break;
+                };
+
+                if active_game.instance_id != launch_instance_id {
+                    break;
+                }
+
+                match active_game.child.try_wait() {
+                    Ok(Some(status)) => {
+                        let exit_code = status.code();
+                        *running_game = None;
+                        Some(GameExitedEvent {
+                            instance_id: launch_instance_id.clone(),
+                            version_id: launch_version_id.clone(),
+                            exit_code,
+                            was_stopped: false,
+                        })
+                    }
+                    Ok(None) => None,
+                    Err(error) => {
+                        let _ = window_exit.emit(
+                            "launcher-log",
+                            format!("Error waiting for game process: {}", error),
+                        );
+                        *running_game = None;
+                        Some(GameExitedEvent {
+                            instance_id: launch_instance_id.clone(),
+                            version_id: launch_version_id.clone(),
+                            exit_code: None,
+                            was_stopped: false,
+                        })
+                    }
+                }
+            };
+
+            if let Some(event) = exit_event {
+                let msg = format!(
+                    "Game process exited for instance {} with status {:?}",
+                    event.instance_id, event.exit_code
+                );
                 let _ = window_exit.emit("launcher-log", &msg);
+                let _ = window_exit.emit("game-exited", &event);
+
+                let state: State<core::instance::InstanceState> = window_exit.app_handle().state();
+                state.end_operation(&event.instance_id);
+                break;
             }
+
+            sleep(Duration::from_millis(500)).await;
         }
     });
 
@@ -825,6 +968,70 @@ async fn start_game(
     }
 
     Ok(format!("Launched Minecraft {} successfully!", version_id))
+    }
+    .await;
+
+    if launch_result.is_err() {
+        instance_state.end_operation(&instance_id);
+    }
+
+    launch_result
+}
+
+#[tauri::command]
+#[dropout_macros::api]
+async fn stop_game(
+    window: Window,
+    game_process_state: State<'_, GameProcessState>,
+    instance_state: State<'_, core::instance::InstanceState>,
+) -> Result<String, String> {
+    let mut running_game = {
+        let mut state = game_process_state.running_game.lock().await;
+        state.take().ok_or("No running game process found")?
+    };
+
+    emit_log!(
+        window,
+        format!(
+            "Stopping game process for instance {}...",
+            running_game.instance_id
+        )
+    );
+
+    let exit_code = match running_game.child.try_wait() {
+        Ok(Some(status)) => status.code(),
+        Ok(None) => {
+            running_game
+                .child
+                .start_kill()
+                .map_err(|e| format!("Failed to stop game process: {}", e))?;
+
+            running_game
+                .child
+                .wait()
+                .await
+                .map_err(|e| format!("Failed while waiting for the game to stop: {}", e))?
+                .code()
+        }
+        Err(error) => {
+            return Err(format!("Failed to inspect running game process: {}", error));
+        }
+    };
+
+    let event = GameExitedEvent {
+        instance_id: running_game.instance_id.clone(),
+        version_id: running_game.version_id.clone(),
+        exit_code,
+        was_stopped: true,
+    };
+
+    let _ = window.emit("game-exited", &event);
+    instance_state.end_operation(&running_game.instance_id);
+
+    Ok(format!(
+        "Stopped Minecraft {} for instance {}",
+        running_game.version_id, running_game.instance_id
+    ))
 }
 
 /// Parse JVM arguments from version.json
@@ -911,12 +1118,14 @@ async fn get_versions() -> Result<Vec<core::manifest::Version>, String> {
 #[dropout_macros::api]
 async fn get_versions_of_instance(
     _window: Window,
+    config_state: State<'_, core::config::ConfigState>,
     instance_state: State<'_, core::instance::InstanceState>,
     instance_id: String,
 ) -> Result<Vec<core::manifest::Version>, String> {
-    let game_dir = instance_state
-        .get_instance_game_dir(&instance_id)
-        .ok_or_else(|| format!("Instance {} not found", instance_id))?;
+    let config = config_state.config.lock().unwrap().clone();
+    let app_handle = _window.app_handle();
+    let resolved_paths = instance_state.resolve_paths(&instance_id, &config, &app_handle)?;
+    let game_dir = resolved_paths.root.clone();
 
     match core::manifest::fetch_version_manifest().await {
         Ok(manifest) => {
@@ -925,9 +1134,12 @@ async fn get_versions_of_instance(
             // For each version, try to load Java version info and check installation status
             for version in &mut versions {
                 // Check if version is installed
-                let version_dir = game_dir.join("versions").join(&version.id);
+                let version_dir = resolved_paths.metadata_versions.join(&version.id);
                 let json_path = version_dir.join(format!("{}.json", version.id));
-                let client_jar_path = version_dir.join(format!("{}.jar", version.id));
+                let client_jar_path = resolved_paths
+                    .version_cache
+                    .join(&version.id)
+                    .join(format!("{}.jar", version.id));
 
                 // Version is installed if both JSON and client jar exist
                 let is_installed = json_path.exists() && client_jar_path.exists();
@@ -956,35 +1168,18 @@ async fn get_versions_of_instance(
 #[dropout_macros::api]
 async fn check_version_installed(
     _window: Window,
+    config_state: State<'_, core::config::ConfigState>,
     instance_state: State<'_, core::instance::InstanceState>,
     instance_id: String,
     version_id: String,
 ) -> Result<bool, String> {
-    let game_dir = instance_state
-        .get_instance_game_dir(&instance_id)
-        .ok_or_else(|| format!("Instance {} not found", instance_id))?;
-
-    // For modded versions, check the parent vanilla version
-    let minecraft_version = if version_id.starts_with("fabric-loader-") {
-        // Format: fabric-loader-X.X.X-1.20.4
-        version_id
-            .split('-')
-            .next_back()
-            .unwrap_or(&version_id)
-            .to_string()
-    } else if version_id.contains("-forge-") {
-        // Format: 1.20.4-forge-49.0.38
-        version_id
-            .split("-forge-")
-            .next()
-            .unwrap_or(&version_id)
-            .to_string()
-    } else {
-        version_id.clone()
-    };
+    let config = config_state.config.lock().unwrap().clone();
+    let app_handle = _window.app_handle();
+    let resolved_paths = instance_state.resolve_paths(&instance_id, &config, &app_handle)?;
+    let minecraft_version = resolve_minecraft_version(&version_id);
 
-    let client_jar = game_dir
-        .join("versions")
+    let client_jar = resolved_paths
+        .version_cache
         .join(&minecraft_version)
         .join(format!("{}.jar", minecraft_version));
 
@@ -1010,310 +1205,295 @@ async fn install_version(
     );
 
     let config = config_state.config.lock().unwrap().clone();
+    let app_handle = window.app_handle();
+    instance_state.begin_operation(&instance_id, core::instance::InstanceOperation::Install)?;
 
-    // Get game directory from instance
-    let game_dir = instance_state
-        .get_instance_game_dir(&instance_id)
-        .ok_or_else(|| format!("Instance {} not found", instance_id))?;
-
-    // Ensure game directory exists
-    tokio::fs::create_dir_all(&game_dir)
-        .await
-        .map_err(|e| e.to_string())?;
-
-    emit_log!(window, format!("Game directory: {:?}", game_dir));
-
-    // Load version (supports both vanilla and modded versions with inheritance)
-    emit_log!(
-        window,
-        format!("Loading version details for {}...", version_id)
-    );
-
-    // First, try to fetch the vanilla version from Mojang and save it locally
-    let _version_details = match core::manifest::load_local_version(&game_dir, &version_id).await {
-        Ok(v) => v,
-        Err(_) => {
-            // Not found locally, fetch from Mojang
-            emit_log!(
-                window,
-                format!("Fetching version {} from Mojang...", version_id)
-            );
-            let fetched = core::manifest::fetch_vanilla_version(&version_id)
-                .await
-                .map_err(|e| e.to_string())?;
+    let install_result: Result<(), String> = async {
+        let resolved_paths = instance_state.resolve_paths(&instance_id, &config, &app_handle)?;
+        let game_dir = resolved_paths.root.clone();
 
-            // Save the version JSON locally
-            emit_log!(window, format!("Saving version JSON..."));
-            core::manifest::save_local_version(&game_dir, &fetched)
-                .await
-                .map_err(|e| e.to_string())?;
+        // Ensure game directory exists
+        tokio::fs::create_dir_all(&game_dir)
+            .await
+            .map_err(|e| e.to_string())?;
 
-            fetched
-        }
-    };
+        emit_log!(window, format!("Game directory: {:?}", game_dir));
 
-    // Now load the full version with inheritance resolved
-    let version_details = core::manifest::load_version(&game_dir, &version_id)
-        .await
-        .map_err(|e| e.to_string())?;
+        // Load version (supports both vanilla and modded versions with inheritance)
+        emit_log!(
+            window,
+            format!("Loading version details for {}...", version_id)
+        );
 
-    emit_log!(
-        window,
-        format!(
-            "Version details loaded: main class = {}",
-            version_details.main_class
-        )
-    );
+        // First, try to fetch the vanilla version from Mojang and save it locally
+        let _version_details =
+            match core::manifest::load_local_version(&game_dir, &version_id).await {
+                Ok(v) => v,
+                Err(_) => {
+                    // Not found locally, fetch from Mojang
+                    emit_log!(
+                        window,
+                        format!("Fetching version {} from Mojang...", version_id)
+                    );
+                    let fetched = core::manifest::fetch_vanilla_version(&version_id)
+                        .await
+                        .map_err(|e| e.to_string())?;
+
+                    // Save the version JSON locally
+                    emit_log!(window, format!("Saving version JSON..."));
+                    core::manifest::save_local_version(&game_dir, &fetched)
+                        .await
+                        .map_err(|e| e.to_string())?;
+
+                    fetched
+                }
+            };
 
-    // Determine the actual minecraft version for client.jar
-    let minecraft_version = version_details
-        .inherits_from
-        .clone()
-        .unwrap_or_else(|| version_id.clone());
+        // Now load the full version with inheritance resolved
+        let version_details = core::manifest::load_version(&game_dir, &version_id)
+            .await
+            .map_err(|e| e.to_string())?;
 
-    // Prepare download tasks
-    emit_log!(window, "Preparing download tasks...".to_string());
-    let mut download_tasks = Vec::new();
+        emit_log!(
+            window,
+            format!(
+                "Version details loaded: main class = {}",
+                version_details.main_class
+            )
+        );
 
-    // --- Client Jar ---
-    let downloads = version_details
-        .downloads
-        .as_ref()
-        .ok_or("Version has no downloads information")?;
-    let client_jar = &downloads.client;
-    // Use shared caches for versions if enabled
-    let mut client_path = if config.use_shared_caches {
-        window
-            .app_handle()
-            .path()
-            .app_data_dir()
-            .unwrap()
-            .join("versions")
-    } else {
-        game_dir.join("versions")
-    };
-    client_path.push(&minecraft_version);
-    client_path.push(format!("{}.jar", minecraft_version));
+        // Determine the actual minecraft version for client.jar
+        let minecraft_version = version_details
+            .inherits_from
+            .clone()
+            .unwrap_or_else(|| version_id.clone());
+
+        // Prepare download tasks
+        emit_log!(window, "Preparing download tasks...".to_string());
+        let mut download_tasks = Vec::new();
+
+        // --- Client Jar ---
+        let downloads = version_details
+            .downloads
+            .as_ref()
+            .ok_or("Version has no downloads information")?;
+        let client_jar = &downloads.client;
+        let mut client_path = resolved_paths.version_cache.clone();
+        client_path.push(&minecraft_version);
+        client_path.push(format!("{}.jar", minecraft_version));
 
-    download_tasks.push(core::downloader::DownloadTask {
-        url: client_jar.url.clone(),
-        path: client_path.clone(),
-        sha1: client_jar.sha1.clone(),
-        sha256: None,
-    });
+        download_tasks.push(core::downloader::DownloadTask {
+            url: client_jar.url.clone(),
+            path: client_path.clone(),
+            sha1: client_jar.sha1.clone(),
+            sha256: None,
+        });
 
-    // --- Libraries ---
-    // Use shared caches for libraries if enabled
-    let libraries_dir = if config.use_shared_caches {
-        window
-            .app_handle()
-            .path()
-            .app_data_dir()
-            .unwrap()
-            .join("libraries")
-    } else {
-        game_dir.join("libraries")
-    };
+        // --- Libraries ---
+        let libraries_dir = resolved_paths.libraries.clone();
 
-    for lib in &version_details.libraries {
-        if core::rules::is_library_allowed(&lib.rules, Some(&config.feature_flags)) {
-            if let Some(downloads) = &lib.downloads {
-                if let Some(artifact) = &downloads.artifact {
-                    let path_str = artifact
-                        .path
-                        .clone()
-                        .unwrap_or_else(|| format!("{}.jar", lib.name));
-
-                    let mut lib_path = libraries_dir.clone();
-                    lib_path.push(path_str);
+        for lib in &version_details.libraries {
+            if core::rules::is_library_allowed(&lib.rules, Some(&config.feature_flags)) {
+                if let Some(downloads) = &lib.downloads {
+                    if let Some(artifact) = &downloads.artifact {
+                        let path_str = artifact
+                            .path
+                            .clone()
+                            .unwrap_or_else(|| format!("{}.jar", lib.name));
 
-                    download_tasks.push(core::downloader::DownloadTask {
-                        url: artifact.url.clone(),
-                        path: lib_path,
-                        sha1: artifact.sha1.clone(),
-                        sha256: None,
-                    });
-                }
+                        let mut lib_path = libraries_dir.clone();
+                        lib_path.push(path_str);
 
-                // Native Library (classifiers)
-                if let Some(classifiers) = &downloads.classifiers {
-                    // Determine candidate keys based on OS and architecture
-                    let arch = std::env::consts::ARCH;
-                    let mut candidates: Vec<String> = Vec::new();
-                    if cfg!(target_os = "linux") {
-                        candidates.push("natives-linux".to_string());
-                        candidates.push(format!("natives-linux-{}", arch));
-                        if arch == "aarch64" {
-                            candidates.push("natives-linux-arm64".to_string());
-                        }
-                    } else if cfg!(target_os = "windows") {
-                        candidates.push("natives-windows".to_string());
-                        candidates.push(format!("natives-windows-{}", arch));
-                    } else if cfg!(target_os = "macos") {
-                        candidates.push("natives-osx".to_string());
-                        candidates.push("natives-macos".to_string());
-                        candidates.push(format!("natives-macos-{}", arch));
+                        download_tasks.push(core::downloader::DownloadTask {
+                            url: artifact.url.clone(),
+                            path: lib_path,
+                            sha1: artifact.sha1.clone(),
+                            sha256: None,
+                        });
                     }
 
-                    // Pick the first available classifier key
-                    let mut chosen: Option<core::game_version::DownloadArtifact> = None;
-                    for key in candidates {
-                        if let Some(native_artifact_value) = classifiers.get(&key) {
-                            if let Ok(artifact) =
-                                serde_json::from_value::<core::game_version::DownloadArtifact>(
-                                    native_artifact_value.clone(),
-                                )
-                            {
-                                chosen = Some(artifact);
-                                break;
+                    // Native Library (classifiers)
+                    if let Some(classifiers) = &downloads.classifiers {
+                        // Determine candidate keys based on OS and architecture
+                        let arch = std::env::consts::ARCH;
+                        let mut candidates: Vec<String> = Vec::new();
+                        if cfg!(target_os = "linux") {
+                            candidates.push("natives-linux".to_string());
+                            candidates.push(format!("natives-linux-{}", arch));
+                            if arch == "aarch64" {
+                                candidates.push("natives-linux-arm64".to_string());
                             }
+                        } else if cfg!(target_os = "windows") {
+                            candidates.push("natives-windows".to_string());
+                            candidates.push(format!("natives-windows-{}", arch));
+                        } else if cfg!(target_os = "macos") {
+                            candidates.push("natives-osx".to_string());
+                            candidates.push("natives-macos".to_string());
+                            candidates.push(format!("natives-macos-{}", arch));
                         }
-                    }
-
-                    if let Some(native_artifact) = chosen {
-                        let path_str = native_artifact.path.clone().unwrap();
-                        let mut native_path = libraries_dir.clone();
-                        native_path.push(&path_str);
 
-                        download_tasks.push(core::downloader::DownloadTask {
-                            url: native_artifact.url,
-                            path: native_path.clone(),
-                            sha1: native_artifact.sha1,
-                            sha256: None,
-                        });
-                    }
-                }
-            } else {
-                // Library without explicit downloads (mod loader libraries)
-                if let Some(url) =
-                    core::maven::resolve_library_url(&lib.name, None, lib.url.as_deref())
-                {
-                    if let Some(lib_path) = core::maven::get_library_path(&lib.name, &libraries_dir)
+                        // Pick the first available classifier key
+                        let mut chosen: Option<core::game_version::DownloadArtifact> = None;
+                        for key in candidates {
+                            if let Some(native_artifact_value) = classifiers.get(&key) {
+                                if let Ok(artifact) =
+                                    serde_json::from_value::<core::game_version::DownloadArtifact>(
+                                        native_artifact_value.clone(),
+                                    )
+                                {
+                                    chosen = Some(artifact);
+                                    break;
+                                }
+                            }
+                        }
+
+                        if let Some(native_artifact) = chosen {
+                            let path_str = native_artifact.path.clone().unwrap();
+                            let mut native_path = libraries_dir.clone();
+                            native_path.push(&path_str);
+
+                            download_tasks.push(core::downloader::DownloadTask {
+                                url: native_artifact.url,
+                                path: native_path.clone(),
+                                sha1: native_artifact.sha1,
+                                sha256: None,
+                            });
+                        }
+                    }
+                } else {
+                    // Library without explicit downloads (mod loader libraries)
+                    if let Some(url) =
+                        core::maven::resolve_library_url(&lib.name, None, lib.url.as_deref())
                     {
-                        download_tasks.push(core::downloader::DownloadTask {
-                            url,
-                            path: lib_path,
-                            sha1: None,
-                            sha256: None,
-                        });
+                        if let Some(lib_path) =
+                            core::maven::get_library_path(&lib.name, &libraries_dir)
+                        {
+                            download_tasks.push(core::downloader::DownloadTask {
+                                url,
+                                path: lib_path,
+                                sha1: None,
+                                sha256: None,
+                            });
+                        }
                     }
                 }
             }
         }
-    }
-
-    // --- Assets ---
-    // Use shared caches for assets if enabled
-    let assets_dir = if config.use_shared_caches {
-        window
-            .app_handle()
-            .path()
-            .app_data_dir()
-            .unwrap()
-            .join("assets")
-    } else {
-        game_dir.join("assets")
-    };
-    let objects_dir = assets_dir.join("objects");
-    let indexes_dir = assets_dir.join("indexes");
 
-    let asset_index = version_details
-        .asset_index
-        .as_ref()
-        .ok_or("Version has no asset index information")?;
+        // --- Assets ---
+        let assets_dir = resolved_paths.assets.clone();
+        let objects_dir = assets_dir.join("objects");
+        let indexes_dir = assets_dir.join("indexes");
 
-    let asset_index_path = indexes_dir.join(format!("{}.json", asset_index.id));
+        let asset_index = version_details
+            .asset_index
+            .as_ref()
+            .ok_or("Version has no asset index information")?;
 
-    let asset_index_content: String = if asset_index_path.exists() {
-        tokio::fs::read_to_string(&asset_index_path)
-            .await
-            .map_err(|e| e.to_string())?
-    } else {
-        emit_log!(window, format!("Downloading asset index..."));
-        let content = reqwest::get(&asset_index.url)
-            .await
-            .map_err(|e| e.to_string())?
-            .text()
-            .await
-            .map_err(|e| e.to_string())?;
+        let asset_index_path = indexes_dir.join(format!("{}.json", asset_index.id));
 
-        tokio::fs::create_dir_all(&indexes_dir)
-            .await
-            .map_err(|e| e.to_string())?;
-        tokio::fs::write(&asset_index_path, &content)
-            .await
-            .map_err(|e| e.to_string())?;
-        content
-    };
+        let asset_index_content: String = if asset_index_path.exists() {
+            tokio::fs::read_to_string(&asset_index_path)
+                .await
+                .map_err(|e| e.to_string())?
+        } else {
+            emit_log!(window, format!("Downloading asset index..."));
+            let content = reqwest::get(&asset_index.url)
+                .await
+                .map_err(|e| e.to_string())?
+                .text()
+                .await
+                .map_err(|e| e.to_string())?;
 
-    #[derive(serde::Deserialize)]
-    struct AssetObject {
-        hash: String,
-    }
+            tokio::fs::create_dir_all(&indexes_dir)
+                .await
+                .map_err(|e| e.to_string())?;
+            tokio::fs::write(&asset_index_path, &content)
+                .await
+                .map_err(|e| e.to_string())?;
+            content
+        };
 
-    #[derive(serde::Deserialize)]
-    struct AssetIndexJson {
-        objects: std::collections::HashMap<String, AssetObject>,
-    }
+        #[derive(serde::Deserialize)]
+        struct AssetObject {
+            hash: String,
+        }
 
-    let asset_index_parsed: AssetIndexJson =
-        serde_json::from_str(&asset_index_content).map_err(|e| e.to_string())?;
+        #[derive(serde::Deserialize)]
+        struct AssetIndexJson {
+            objects: std::collections::HashMap<String, AssetObject>,
+        }
 
-    emit_log!(
-        window,
-        format!("Processing {} assets...", asset_index_parsed.objects.len())
-    );
+        let asset_index_parsed: AssetIndexJson =
+            serde_json::from_str(&asset_index_content).map_err(|e| e.to_string())?;
 
-    for (_name, object) in asset_index_parsed.objects {
-        let hash = object.hash;
-        let prefix = &hash[0..2];
-        let path = objects_dir.join(prefix).join(&hash);
-        let url = format!(
-            "https://resources.download.minecraft.net/{}/{}",
-            prefix, hash
+        emit_log!(
+            window,
+            format!("Processing {} assets...", asset_index_parsed.objects.len())
         );
 
-        download_tasks.push(core::downloader::DownloadTask {
-            url,
-            path,
-            sha1: Some(hash),
-            sha256: None,
-        });
-    }
+        for (_name, object) in asset_index_parsed.objects {
+            let hash = object.hash;
+            let prefix = &hash[0..2];
+            let path = objects_dir.join(prefix).join(&hash);
+            let url = format!(
+                "https://resources.download.minecraft.net/{}/{}",
+                prefix, hash
+            );
 
-    emit_log!(
-        window,
-        format!(
-            "Total download tasks: {} (Client + Libraries + Assets)",
-            download_tasks.len()
-        )
-    );
+            download_tasks.push(core::downloader::DownloadTask {
+                url,
+                path,
+                sha1: Some(hash),
+                sha256: None,
+            });
+        }
 
-    // Start Download
-    emit_log!(
-        window,
-        format!(
-            "Starting downloads with {} concurrent threads...",
-            config.download_threads
+        emit_log!(
+            window,
+            format!(
+                "Total download tasks: {} (Client + Libraries + Assets)",
+                download_tasks.len()
+            )
+        );
+
+        // Start Download
+        emit_log!(
+            window,
+            format!(
+                "Starting downloads with {} concurrent threads...",
+                config.download_threads
+            )
+        );
+        core::downloader::download_files(
+            window.clone(),
+            download_tasks,
+            config.download_threads as usize,
         )
-    );
-    core::downloader::download_files(
-        window.clone(),
-        download_tasks,
-        config.download_threads as usize,
-    )
-    .await
-    .map_err(|e| e.to_string())?;
+        .await
+        .map_err(|e| e.to_string())?;
 
-    emit_log!(
-        window,
-        format!("Installation of {} completed successfully!", version_id)
-    );
+        emit_log!(
+            window,
+            format!("Installation of {} completed successfully!", version_id)
+        );
 
-    // Emit event to notify frontend that version installation is complete
-    let _ = window.emit("version-installed", &version_id);
+        if let Some(mut instance) = instance_state.get_instance(&instance_id) {
+            instance.version_id = Some(version_id.clone());
+            instance.mod_loader = Some("vanilla".to_string());
+            instance.mod_loader_version = None;
+            instance_state.update_instance(instance)?;
+        }
 
-    Ok(())
+        // Emit event to notify frontend that version installation is complete
+        let _ = window.emit("version-installed", &version_id);
+
+        Ok(())
+    }
+    .await;
+
+    instance_state.end_operation(&instance_id);
+    install_result
 }
 
 #[tauri::command]
@@ -1579,7 +1759,8 @@ async fn fetch_adoptium_java(
         "jdk" => core::java::ImageType::Jdk,
         _ => core::java::ImageType::Jre,
     };
-    core::java::fetch_java_release(major_version, img_type)
+    let provider = core::java::providers::AdoptiumProvider::new();
+    core::java::fetch_java_release_with(&provider, major_version, img_type)
         .await
         .map_err(|e| e.to_string())
 }
@@ -1598,16 +1779,24 @@ async fn download_adoptium_java(
         _ => core::java::ImageType::Jre,
     };
     let path = custom_path.map(std::path::PathBuf::from);
-    core::java::download_and_install_java(&app_handle, major_version, img_type, path)
-        .await
-        .map_err(|e| e.to_string())
+    let provider = core::java::providers::AdoptiumProvider::new();
+    core::java::install::download_and_install_java_with_provider(
+        &provider,
+        &app_handle,
+        major_version,
+        img_type,
+        path,
+    )
+    .await
+    .map_err(|e| e.to_string())
 }
 
 /// Get available Adoptium Java versions
 #[tauri::command]
 #[dropout_macros::api]
 async fn fetch_available_java_versions() -> Result<Vec<u32>, String> {
-    core::java::fetch_available_versions()
+    let provider = core::java::providers::AdoptiumProvider::new();
+    core::java::fetch_available_versions_with(&provider)
         .await
         .map_err(|e| e.to_string())
 }
@@ -1618,7 +1807,8 @@ async fn fetch_available_java_versions() -> Result<Vec<u32>, String> {
 async fn fetch_java_catalog(
     app_handle: tauri::AppHandle,
 ) -> Result<core::java::JavaCatalog, String> {
-    core::java::fetch_java_catalog(&app_handle, false)
+    let provider = core::java::providers::AdoptiumProvider::new();
+    core::java::fetch_java_catalog_with(&provider, &app_handle, false)
         .await
         .map_err(|e| e.to_string())
 }
@@ -1629,7 +1819,8 @@ async fn fetch_java_catalog(
 async fn refresh_java_catalog(
     app_handle: tauri::AppHandle,
 ) -> Result<core::java::JavaCatalog, String> {
-    core::java::fetch_java_catalog(&app_handle, true)
+    let provider = core::java::providers::AdoptiumProvider::new();
+    core::java::fetch_java_catalog_with(&provider, &app_handle, true)
         .await
         .map_err(|e| e.to_string())
 }
@@ -1656,8 +1847,9 @@ async fn get_pending_java_downloads(
 #[dropout_macros::api]
 async fn resume_java_downloads(
     app_handle: tauri::AppHandle,
-) -> Result<Vec<core::java::JavaInstallation>, String> {
-    core::java::resume_pending_downloads(&app_handle).await
+) -> Result<core::java::ResumeJavaDownloadsResult, String> {
+    let provider = core::java::providers::AdoptiumProvider::new();
+    core::java::resume_pending_downloads_with(&provider, &app_handle).await
 }
 
 /// Get Minecraft versions supported by Fabric
@@ -1707,31 +1899,39 @@ async fn install_fabric(
         )
     );
 
-    let game_dir = instance_state
-        .get_instance_game_dir(&instance_id)
-        .ok_or_else(|| format!("Instance {} not found", instance_id))?;
+    instance_state.begin_operation(&instance_id, core::instance::InstanceOperation::Install)?;
 
-    let result = core::fabric::install_fabric(&game_dir, &game_version, &loader_version)
-        .await
-        .map_err(|e| e.to_string())?;
+    let install_result: Result<core::fabric::InstalledFabricVersion, String> = async {
+        let game_dir = instance_state
+            .get_instance_game_dir(&instance_id)
+            .ok_or_else(|| format!("Instance {} not found", instance_id))?;
 
-    emit_log!(
-        window,
-        format!("Fabric installed successfully: {}", result.id)
-    );
+        let result = core::fabric::install_fabric(&game_dir, &game_version, &loader_version)
+            .await
+            .map_err(|e| e.to_string())?;
 
-    // Update Instance's mod_loader metadata and version_id
-    if let Some(mut instance) = instance_state.get_instance(&instance_id) {
-        instance.mod_loader = Some("fabric".to_string());
-        instance.mod_loader_version = Some(loader_version.clone());
-        instance.version_id = Some(result.id.clone());
-        instance_state.update_instance(instance)?;
-    }
+        emit_log!(
+            window,
+            format!("Fabric installed successfully: {}", result.id)
+        );
 
-    // Emit event to notify frontend
-    let _ = window.emit("fabric-installed", &result.id);
+        // Update Instance's mod_loader metadata and version_id
+        if let Some(mut instance) = instance_state.get_instance(&instance_id) {
+            instance.mod_loader = Some("fabric".to_string());
+            instance.mod_loader_version = Some(loader_version.clone());
+            instance.version_id = Some(result.id.clone());
+            instance_state.update_instance(instance)?;
+        }
 
-    Ok(result)
+        // Emit event to notify frontend
+        let _ = window.emit("fabric-installed", &result.id);
+
+        Ok(result)
+    }
+    .await;
+
+    instance_state.end_operation(&instance_id);
+    install_result
 }
 
 /// List installed Fabric versions
@@ -1786,15 +1986,15 @@ struct VersionMetadata {
 #[dropout_macros::api]
 async fn delete_version(
     window: Window,
+    config_state: State<'_, core::config::ConfigState>,
     instance_state: State<'_, core::instance::InstanceState>,
     instance_id: String,
     version_id: String,
 ) -> Result<(), String> {
-    let game_dir = instance_state
-        .get_instance_game_dir(&instance_id)
-        .ok_or_else(|| format!("Instance {} not found", instance_id))?;
-
-    let version_dir = game_dir.join("versions").join(&version_id);
+    let config = config_state.config.lock().unwrap().clone();
+    let app_handle = window.app_handle();
+    let resolved_paths = instance_state.resolve_paths(&instance_id, &config, &app_handle)?;
+    let version_dir = resolved_paths.metadata_versions.join(&version_id);
 
     if !version_dir.exists() {
         return Err(format!("Version {} not found", version_id));
@@ -1841,13 +2041,15 @@ async fn delete_version(
 #[dropout_macros::api]
 async fn get_version_metadata(
     _window: Window,
+    config_state: State<'_, core::config::ConfigState>,
     instance_state: State<'_, core::instance::InstanceState>,
     instance_id: String,
     version_id: String,
 ) -> Result<VersionMetadata, String> {
-    let game_dir = instance_state
-        .get_instance_game_dir(&instance_id)
-        .ok_or_else(|| format!("Instance {} not found", instance_id))?;
+    let config = config_state.config.lock().unwrap().clone();
+    let app_handle = _window.app_handle();
+    let resolved_paths = instance_state.resolve_paths(&instance_id, &config, &app_handle)?;
+    let game_dir = resolved_paths.root.clone();
 
     // Initialize metadata
     let mut metadata = VersionMetadata {
@@ -1868,35 +2070,15 @@ async fn get_version_metadata(
     }
 
     // Check if version is installed (both JSON and client jar must exist)
-    let version_dir = game_dir.join("versions").join(&version_id);
+    let version_dir = resolved_paths.metadata_versions.join(&version_id);
     let json_path = version_dir.join(format!("{}.json", version_id));
 
     // For modded versions, check the parent vanilla version's client jar
-    let client_jar_path = if version_id.starts_with("fabric-loader-") {
-        // Format: fabric-loader-X.X.X-1.20.4
-        let minecraft_version = version_id
-            .split('-')
-            .next_back()
-            .unwrap_or(&version_id)
-            .to_string();
-        game_dir
-            .join("versions")
-            .join(&minecraft_version)
-            .join(format!("{}.jar", minecraft_version))
-    } else if version_id.contains("-forge-") {
-        // Format: 1.20.4-forge-49.0.38
-        let minecraft_version = version_id
-            .split("-forge-")
-            .next()
-            .unwrap_or(&version_id)
-            .to_string();
-        game_dir
-            .join("versions")
-            .join(&minecraft_version)
-            .join(format!("{}.jar", minecraft_version))
-    } else {
-        version_dir.join(format!("{}.jar", version_id))
-    };
+    let minecraft_version = resolve_minecraft_version(&version_id);
+    let client_jar_path = resolved_paths
+        .version_cache
+        .join(&minecraft_version)
+        .join(format!("{}.jar", minecraft_version));
 
     metadata.is_installed = json_path.exists() && client_jar_path.exists();
 
@@ -2081,83 +2263,91 @@ async fn install_forge(
         )
     );
 
-    let game_dir = instance_state
-        .get_instance_game_dir(&instance_id)
-        .ok_or_else(|| format!("Instance {} not found", instance_id))?;
+    instance_state.begin_operation(&instance_id, core::instance::InstanceOperation::Install)?;
 
-    // Get Java path from config or detect
-    let config = config_state.config.lock().unwrap().clone();
-    let app_handle = window.app_handle();
-    let java_path_str = if !config.java_path.is_empty() && config.java_path != "java" {
-        config.java_path.clone()
-    } else {
-        // Try to find a suitable Java installation
-        let javas = core::java::detect_all_java_installations(app_handle).await;
-        if let Some(java) = javas.first() {
-            java.path.clone()
+    let install_result: Result<core::forge::InstalledForgeVersion, String> = async {
+        let game_dir = instance_state
+            .get_instance_game_dir(&instance_id)
+            .ok_or_else(|| format!("Instance {} not found", instance_id))?;
+
+        // Get Java path from config or detect
+        let config = config_state.config.lock().unwrap().clone();
+        let app_handle = window.app_handle();
+        let java_path_str = if !config.java_path.is_empty() && config.java_path != "java" {
+            config.java_path.clone()
         } else {
-            return Err(
-                "No Java installation found. Please configure Java in settings.".to_string(),
-            );
-        }
-    };
-    let java_path = utils::path::normalize_java_path(&java_path_str)?;
+            // Try to find a suitable Java installation
+            let javas = core::java::detect_all_java_installations(app_handle).await;
+            if let Some(java) = javas.first() {
+                java.path.clone()
+            } else {
+                return Err(
+                    "No Java installation found. Please configure Java in settings.".to_string(),
+                );
+            }
+        };
+        let java_path = utils::path::normalize_java_path(&java_path_str)?;
 
-    emit_log!(window, "Running Forge installer...".to_string());
+        emit_log!(window, "Running Forge installer...".to_string());
 
-    // Run the Forge installer to properly patch the client
-    core::forge::run_forge_installer(&game_dir, &game_version, &forge_version, &java_path)
-        .await
-        .map_err(|e| format!("Forge installer failed: {}", e))?;
+        // Run the Forge installer to properly patch the client
+        core::forge::run_forge_installer(&game_dir, &game_version, &forge_version, &java_path)
+            .await
+            .map_err(|e| format!("Forge installer failed: {}", e))?;
 
-    emit_log!(
-        window,
-        "Forge installer completed, creating version profile...".to_string()
-    );
+        emit_log!(
+            window,
+            "Forge installer completed, creating version profile...".to_string()
+        );
+
+        // Check if the version JSON already exists
+        let version_id = core::forge::generate_version_id(&game_version, &forge_version);
+        let json_path = game_dir
+            .join("versions")
+            .join(&version_id)
+            .join(format!("{}.json", version_id));
 
-    // Check if the version JSON already exists
-    let version_id = core::forge::generate_version_id(&game_version, &forge_version);
-    let json_path = game_dir
-        .join("versions")
-        .join(&version_id)
-        .join(format!("{}.json", version_id));
+        let result = if json_path.exists() {
+            // Version JSON was created by the installer, load it
+            emit_log!(
+                window,
+                "Using version profile created by Forge installer".to_string()
+            );
+            core::forge::InstalledForgeVersion {
+                id: version_id,
+                minecraft_version: game_version.clone(),
+                forge_version: forge_version.clone(),
+                path: json_path,
+            }
+        } else {
+            // Installer didn't create JSON, create it manually
+            core::forge::install_forge(&game_dir, &game_version, &forge_version)
+                .await
+                .map_err(|e| e.to_string())?
+        };
 
-    let result = if json_path.exists() {
-        // Version JSON was created by the installer, load it
         emit_log!(
             window,
-            "Using version profile created by Forge installer".to_string()
+            format!("Forge installed successfully: {}", result.id)
         );
-        core::forge::InstalledForgeVersion {
-            id: version_id,
-            minecraft_version: game_version.clone(),
-            forge_version: forge_version.clone(),
-            path: json_path,
+
+        // Update Instance's mod_loader metadata and version_id
+        if let Some(mut instance) = instance_state.get_instance(&instance_id) {
+            instance.mod_loader = Some("forge".to_string());
+            instance.mod_loader_version = Some(forge_version.clone());
+            instance.version_id = Some(result.id.clone());
+            instance_state.update_instance(instance)?;
         }
-    } else {
-        // Installer didn't create JSON, create it manually
-        core::forge::install_forge(&game_dir, &game_version, &forge_version)
-            .await
-            .map_err(|e| e.to_string())?
-    };
 
-    emit_log!(
-        window,
-        format!("Forge installed successfully: {}", result.id)
-    );
+        // Emit event to notify frontend
+        let _ = window.emit("forge-installed", &result.id);
 
-    // Update Instance's mod_loader metadata and version_id
-    if let Some(mut instance) = instance_state.get_instance(&instance_id) {
-        instance.mod_loader = Some("forge".to_string());
-        instance.mod_loader_version = Some(forge_version.clone());
-        instance.version_id = Some(result.id.clone());
-        instance_state.update_instance(instance)?;
+        Ok(result)
     }
+    .await;
 
-    // Emit event to notify frontend
-    let _ = window.emit("forge-installed", &result.id);
-
-    Ok(result)
+    instance_state.end_operation(&instance_id);
+    install_result
 }
 
 #[derive(serde::Serialize, TS)]
@@ -2416,6 +2606,43 @@ async fn duplicate_instance(
     state.duplicate_instance(&instance_id, new_name, app_handle)
 }
 
+/// Export an instance to a zip archive
+#[tauri::command]
+#[dropout_macros::api]
+async fn export_instance(
+    state: State<'_, core::instance::InstanceState>,
+    instance_id: String,
+    archive_path: String,
+) -> Result<String, String> {
+    state
+        .export_instance(&instance_id, std::path::Path::new(&archive_path))
+        .map(|path| path.to_string_lossy().to_string())
+}
+
+/// Import an instance from a zip archive
+#[tauri::command]
+#[dropout_macros::api]
+async fn import_instance(
+    window: Window,
+    state: State<'_, core::instance::InstanceState>,
+    archive_path: String,
+    new_name: Option<String>,
+) -> Result<core::instance::Instance, String> {
+    let app_handle = window.app_handle();
+    state.import_instance(std::path::Path::new(&archive_path), app_handle, new_name)
+}
+
+/// Repair instance index from on-disk directories
+#[tauri::command]
+#[dropout_macros::api]
+async fn repair_instances(
+    window: Window,
+    state: State<'_, core::instance::InstanceState>,
+) -> Result<core::instance::InstanceRepairResult, String> {
+    let app_handle = window.app_handle();
+    state.repair_instances(app_handle)
+}
+
 #[tauri::command]
 #[dropout_macros::api]
 async fn assistant_chat_stream(
@@ -2467,11 +2694,11 @@ async fn migrate_shared_caches(
     );
 
     // Automatically enable shared caches config
-    let mut config = config_state.config.lock().unwrap().clone();
-    config.use_shared_caches = true;
-    drop(config);
-    *config_state.config.lock().unwrap() = config_state.config.lock().unwrap().clone();
-    config_state.config.lock().unwrap().use_shared_caches = true;
+    {
+        let mut config = config_state.config.lock().unwrap();
+        config.use_shared_caches = true;
+        config.keep_legacy_per_instance_storage = false;
+    }
     config_state.save()?;
 
     Ok(MigrationResult {
@@ -2499,15 +2726,15 @@ struct FileInfo {
 #[tauri::command]
 #[dropout_macros::api]
 async fn list_instance_directory(
+    app: Window,
+    config_state: State<'_, core::config::ConfigState>,
     instance_state: State<'_, core::instance::InstanceState>,
     instance_id: String,
     folder: String, // "mods" | "resourcepacks" | "shaderpacks" | "saves" | "screenshots"
 ) -> Result<Vec<FileInfo>, String> {
-    let game_dir = instance_state
-        .get_instance_game_dir(&instance_id)
-        .ok_or_else(|| format!("Instance {} not found", instance_id))?;
-
-    let target_dir = game_dir.join(&folder);
+    let config = config_state.config.lock().unwrap().clone();
+    let target_dir =
+        instance_state.resolve_directory(&instance_id, &folder, &config, app.app_handle())?;
     if !target_dir.exists() {
         tokio::fs::create_dir_all(&target_dir)
             .await
@@ -2599,6 +2826,7 @@ fn main() {
         .plugin(tauri_plugin_shell::init())
         .manage(core::auth::AccountState::new())
         .manage(MsRefreshTokenState::new())
+        .manage(GameProcessState::new())
         .manage(core::assistant::AssistantState::new())
         .setup(|app| {
             let config_state = core::config::ConfigState::new(app.handle());
@@ -2643,6 +2871,7 @@ fn main() {
         })
         .invoke_handler(tauri::generate_handler![
             start_game,
+            stop_game,
             get_versions,
             get_versions_of_instance,
             check_version_installed,
@@ -2700,6 +2929,9 @@ fn main() {
             set_active_instance,
             get_active_instance,
             duplicate_instance,
+            export_instance,
+            import_instance,
+            repair_instances,
             migrate_shared_caches,
             list_instance_directory,
             delete_instance_file,
diff --git a/src-tauri/src/utils/zip.rs b/src-tauri/src/utils/zip.rs
index dfe1214c..e164bd52 100644
--- a/src-tauri/src/utils/zip.rs
+++ b/src-tauri/src/utils/zip.rs
@@ -1,8 +1,33 @@
 use flate2::read::GzDecoder;
 use std::fs;
-use std::path::Path;
+use std::path::{Component, Path, PathBuf};
 use tar::Archive;
 
+fn sanitize_relative_path(entry_path: &Path) -> Result<PathBuf, String> {
+    let mut safe_path = PathBuf::new();
+
+    for component in entry_path.components() {
+        match component {
+            Component::Normal(part) => safe_path.push(part),
+            Component::CurDir => {}
+            Component::ParentDir => {
+                return Err(format!(
+                    "Unsafe archive entry path detected (parent traversal): {}",
+                    entry_path.display()
+                ));
+            }
+            Component::RootDir | Component::Prefix(_) => {
+                return Err(format!(
+                    "Unsafe archive entry path detected (absolute path): {}",
+                    entry_path.display()
+                ));
+            }
+        }
+    }
+
+    Ok(safe_path)
+}
+
 pub fn extract_zip(zip_path: &Path, extract_to: &Path) -> Result<(), String> {
     let file = fs::File::open(zip_path)
         .map_err(|e| format!("Failed to open zip {}: {}", zip_path.display(), e))?;
@@ -69,9 +94,14 @@ pub fn extract_tar_gz(archive_path: &Path, extract_to: &Path) -> Result<String,
             .map_err(|e| format!("Failed to get entry path: {}", e))?
             .into_owned();
 
+        let safe_entry_path = sanitize_relative_path(&entry_path)?;
+        if safe_entry_path.as_os_str().is_empty() {
+            continue;
+        }
+
         // Extract the top-level directory name (the first path component)
         if top_level_dir.is_none() {
-            if let Some(first_component) = entry_path.components().next() {
+            if let Some(first_component) = safe_entry_path.components().next() {
                 let component_str = first_component.as_os_str().to_string_lossy().to_string();
                 if !component_str.is_empty() && component_str != "." {
                     top_level_dir = Some(component_str);
@@ -79,7 +109,7 @@ pub fn extract_tar_gz(archive_path: &Path, extract_to: &Path) -> Result<String,
             }
         }
 
-        let outpath = extract_to.join(&entry_path);
+        let outpath = extract_to.join(&safe_entry_path);
 
         if entry.header().entry_type().is_dir() {
             fs::create_dir_all(&outpath)
diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.json
index 1c31a092..9ab9e6ae 100644
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -5,7 +5,7 @@
   "build": {
     "beforeDevCommand": "pnpm --filter @dropout/ui dev",
     "beforeBuildCommand": "pnpm --filter @dropout/ui build",
-    "devUrl": "http://localhost:5173",
+    "devUrl": "http://127.0.0.1:5173",
     "frontendDist": "../packages/ui/dist"
   },
   "app": {
@@ -20,6 +20,7 @@
       }
     ],
     "security": {
+      "devCsp": null,
       "csp": "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self' data:; connect-src 'self' https: ws: wss:;",
       "capabilities": ["default"]
     }