diff --git a/.github/workflows/test-all.yml b/.github/workflows/test-all.yml
index 6c15a8e..56a989d 100644
--- a/.github/workflows/test-all.yml
+++ b/.github/workflows/test-all.yml
@@ -11,7 +11,7 @@ permissions:
   contents: read
 
 env:
-  NODE_VERSION: '22'
+  NODE_VERSION: '24'
 
 jobs:
   lint:
diff --git a/.nvmrc b/.nvmrc
index 2bd5a0a..a45fd52 100644
--- a/.nvmrc
+++ b/.nvmrc
@@ -1 +1 @@
-22
+24
diff --git a/README.md b/README.md
index 7d1e430..5fe208c 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,13 @@ ROSI is an Electron GUI for yt-dlp
 
 [<img src="https://get.microsoft.com/images/en-us%20dark.svg" width="200"/>](https://apps.microsoft.com/detail/9p4q134b2jw3?referrer=appbadge&mode=direct) [<img width="150" alt="ROSI" src="https://prod.rosie.run/img/download-for-windows.png"/>](https://github.com/BurntToasters/ROSI/releases/latest/download/ROSI-Windows-x64.exe) [<img width="150" alt="ROSI" src="https://prod.rosie.run/img/download-for-windows-arm64.png"/>](https://github.com/BurntToasters/ROSI/releases/latest/download/ROSI-Windows-arm64.exe) [<img width="150" alt="ROSI" src="https://prod.rosie.run/img/download-for-macos.png"/>](https://github.com/BurntToasters/ROSI/releases/latest/download/ROSI-MacOS-universal.dmg) [<img width="150" alt="ROSI" src="https://prod.rosie.run/img/download-for-linux.png"/>](https://github.com/BurntToasters/ROSI/releases/latest)
 
-<p align="center"><img width="700" src="https://prod.rosie.run/img/rosi/ROSI.png"></p>
+<p align="center">
+
+<img width="45%" height="1012" alt="ROSI-3-1-1" src="https://github.com/user-attachments/assets/e66cebfb-6925-409d-9843-e94cfd868891" />
+  &nbsp;
+  <img width="45%" height="1012" alt="ROSI-3-x-app" src="https://github.com/user-attachments/assets/7a15cea3-1f32-432e-a142-aaded90c9f2a" />
+
+</p>
 
 # LICENSES
 
diff --git a/build-scripts/build-with-restore.js b/build-scripts/build-with-restore.js
new file mode 100644
index 0000000..40a194d
--- /dev/null
+++ b/build-scripts/build-with-restore.js
@@ -0,0 +1,90 @@
+const { spawnSync } = require('child_process');
+const path = require('path');
+
+const args = process.argv.slice(2);
+
+function usage() {
+  console.error(
+    'Usage: node build-scripts/build-with-restore.js [--prepare <script>] [--env KEY=VALUE] -- <command> [args...]'
+  );
+  process.exit(1);
+}
+
+function resolveCommand(command) {
+  if (process.platform === 'win32' && (command === 'npm' || command === 'npx')) {
+    return `${command}.cmd`;
+  }
+  return command;
+}
+
+function run(command, commandArgs, envOverrides) {
+  const result = spawnSync(resolveCommand(command), commandArgs, {
+    stdio: 'inherit',
+    env: { ...process.env, ...envOverrides },
+    shell: false,
+  });
+
+  if (result.error) {
+    console.error(result.error.message);
+    return 1;
+  }
+  return result.status ?? 1;
+}
+
+let prepareScript = null;
+const envOverrides = {};
+const separatorIndex = args.indexOf('--');
+
+if (separatorIndex === -1) {
+  usage();
+}
+
+const optionArgs = args.slice(0, separatorIndex);
+const commandParts = args.slice(separatorIndex + 1);
+if (commandParts.length === 0) {
+  usage();
+}
+
+for (let i = 0; i < optionArgs.length; i++) {
+  const current = optionArgs[i];
+  if (current === '--prepare') {
+    const next = optionArgs[i + 1];
+    if (!next) usage();
+    prepareScript = next;
+    i++;
+    continue;
+  }
+
+  if (current === '--env') {
+    const next = optionArgs[i + 1];
+    if (!next || !next.includes('=')) usage();
+    const [key, ...valueParts] = next.split('=');
+    envOverrides[key] = valueParts.join('=');
+    i++;
+    continue;
+  }
+
+  usage();
+}
+
+let exitCode = 0;
+
+try {
+  if (prepareScript) {
+    exitCode = run(process.execPath, [path.resolve(prepareScript)], envOverrides);
+  }
+
+  if (exitCode === 0) {
+    const [command, ...commandArgs] = commandParts;
+    exitCode = run(command, commandArgs, envOverrides);
+  }
+} finally {
+  if (prepareScript) {
+    const restoreCode = run(process.execPath, [path.join(__dirname, 'restore-binaries.js')], {});
+    if (exitCode === 0 && restoreCode !== 0) {
+      exitCode = restoreCode;
+    }
+  }
+}
+
+process.exit(exitCode);
diff --git a/package-lock.json b/package-lock.json
index d501e6d..26d68fc 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "rosi",
-  "version": "3.4.2",
+  "version": "3.5.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "rosi",
-      "version": "3.4.2",
+      "version": "3.5.0",
       "license": "MPL-2.0",
       "dependencies": {
         "electron-log": "^5.3.4",
@@ -31,7 +31,7 @@
         "vitest": "^4.0.16"
       },
       "engines": {
-        "node": ">=22.x",
+        "node": ">=24.x",
         "npm": ">=10.x"
       }
     },
diff --git a/package.json b/package.json
index 12499d8..60b50cb 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "rosi",
-  "version": "3.4.2",
+  "version": "3.5.0",
   "private": true,
   "description": "Electron GUI for yt-dlp",
   "keywords": [
@@ -12,7 +12,7 @@
   "main": "dist/main/main.js",
   "packageManager": "npm@11.10.1",
   "engines": {
-    "node": ">=22.x",
+    "node": ">=24.x",
     "npm": ">=10.x"
   },
   "scripts": {
@@ -44,18 +44,18 @@
     "build:win:all": "npm run build:win && npm run build:win:x64 && npm run build:win:arm64",
     "build:mac:universal": "npm run prebuild && dotenv -e .env -- electron-builder -c electron-builder.base.yml --mac --universal",
     "build:linux": "npm run prebuild && electron-builder -c electron-builder.base.yml --linux AppImage deb rpm --x64 --arm64",
-    "build:linux:x64": "node build-scripts/prepare-linux-x64.js && electron-builder -c electron-builder.base.yml --linux AppImage deb rpm --x64 && node build-scripts/restore-binaries.js",
-    "build:linux:arm64": "node build-scripts/prepare-linux-arm64.js && electron-builder -c electron-builder.base.yml --linux AppImage deb rpm --arm64 && node build-scripts/restore-binaries.js",
+    "build:linux:x64": "node build-scripts/build-with-restore.js --prepare build-scripts/prepare-linux-x64.js -- npx electron-builder -c electron-builder.base.yml --linux AppImage deb rpm --x64",
+    "build:linux:arm64": "node build-scripts/build-with-restore.js --prepare build-scripts/prepare-linux-arm64.js -- npx electron-builder -c electron-builder.base.yml --linux AppImage deb rpm --arm64",
     "build:linux:all": "npm run prebuild && npm run build:linux:x64 && npm run build:linux:arm64",
     "build:linux:native": "npm run prebuild && npm run build:linux:native:x64 && npm run build:linux:native:arm64",
-    "build:linux:native:x64": "node build-scripts/prepare-linux-x64.js && cross-env USE_SYSTEM_FPM=true electron-builder -c electron-builder.base.yml --linux AppImage deb rpm --x64 && node build-scripts/restore-binaries.js",
-    "build:linux:native:arm64": "node build-scripts/prepare-linux-arm64.js && cross-env USE_SYSTEM_FPM=true electron-builder -c electron-builder.base.yml --linux AppImage deb rpm --arm64 && node build-scripts/restore-binaries.js",
+    "build:linux:native:x64": "node build-scripts/build-with-restore.js --prepare build-scripts/prepare-linux-x64.js --env USE_SYSTEM_FPM=true -- npx electron-builder -c electron-builder.base.yml --linux AppImage deb rpm --x64",
+    "build:linux:native:arm64": "node build-scripts/build-with-restore.js --prepare build-scripts/prepare-linux-arm64.js --env USE_SYSTEM_FPM=true -- npx electron-builder -c electron-builder.base.yml --linux AppImage deb rpm --arm64",
     "build:linux:native:all": "npm run prebuild && npm run build:linux:native:x64 && npm run build:linux:native:arm64",
     "build:github": "npm run prebuild && dotenv -e .env -- cross-env CHANNEL=github electron-builder -c electron-builder.github.yml --win --arm64 --x64",
     "build:github:win": "npm run prebuild && dotenv -e .env -- cross-env CHANNEL=github electron-builder -c electron-builder.github.yml --win --arm64 --x64",
     "build:github:mac": "npm run prebuild && dotenv -e .env -- cross-env CHANNEL=github electron-builder -c electron-builder.github.yml --mac --universal",
-    "build:msstore:x64": "cross-env CHANNEL=msstore node build-scripts/prepare-x64.js && electron-builder --win --x64 -c electron-builder.msstore.yml && node build-scripts/restore-binaries.js",
-    "build:msstore:arm64": "cross-env CHANNEL=msstore node build-scripts/prepare-arm64.js && electron-builder --win --arm64 -c electron-builder.msstore.yml && node build-scripts/restore-binaries.js",
+    "build:msstore:x64": "node build-scripts/build-with-restore.js --prepare build-scripts/prepare-x64.js --env CHANNEL=msstore -- npx electron-builder --win --x64 -c electron-builder.msstore.yml",
+    "build:msstore:arm64": "node build-scripts/build-with-restore.js --prepare build-scripts/prepare-arm64.js --env CHANNEL=msstore -- npx electron-builder --win --arm64 -c electron-builder.msstore.yml",
     "build:msstore": "npm run prebuild && npm run build:msstore:x64 && npm run build:msstore:arm64",
     "restore-binaries": "node build-scripts/restore-binaries.js",
     "sign:gpg": "dotenv -e .env -- node build-scripts/gpg-sign.js",
@@ -68,10 +68,10 @@
     "release:linux:chain": "npm run prebuild && npm run release:linux:x64 && npm run release:linux:arm64",
     "release:linux:chain:f": "npm run prebuild && npm run release:linux:native:x64 && npm run release:linux:native:arm64",
     "release:linux": "npm run prebuild && dotenv -e .env -- cross-env CHANNEL=github electron-builder -c electron-builder.github.yml --linux AppImage deb rpm --x64 --arm64 --publish always && npm run sign:gpg",
-    "release:linux:x64": "node build-scripts/prepare-linux-x64.js && dotenv -e .env -- cross-env CHANNEL=github electron-builder -c electron-builder.github.yml --linux AppImage deb rpm --x64 --publish always && node build-scripts/restore-binaries.js && npm run sign:gpg:x64",
-    "release:linux:arm64": "node build-scripts/prepare-linux-arm64.js && dotenv -e .env -- cross-env CHANNEL=github electron-builder -c electron-builder.github.yml --linux AppImage deb rpm --arm64 --publish always && node build-scripts/restore-binaries.js && npm run sign:gpg:arm64",
-    "release:linux:native:x64": "node build-scripts/prepare-linux-x64.js && dotenv -e .env -- cross-env USE_SYSTEM_FPM=true CHANNEL=github electron-builder -c electron-builder.github.yml --linux AppImage deb rpm --x64 --publish always && node build-scripts/restore-binaries.js && npm run sign:gpg:x64",
-    "release:linux:native:arm64": "node build-scripts/prepare-linux-arm64.js && dotenv -e .env -- cross-env USE_SYSTEM_FPM=true CHANNEL=github electron-builder -c electron-builder.github.yml --linux AppImage deb rpm --arm64 --publish always && node build-scripts/restore-binaries.js && npm run sign:gpg:arm64",
+    "release:linux:x64": "dotenv -e .env -- node build-scripts/build-with-restore.js --prepare build-scripts/prepare-linux-x64.js --env CHANNEL=github -- npx electron-builder -c electron-builder.github.yml --linux AppImage deb rpm --x64 --publish always && npm run sign:gpg:x64",
+    "release:linux:arm64": "dotenv -e .env -- node build-scripts/build-with-restore.js --prepare build-scripts/prepare-linux-arm64.js --env CHANNEL=github -- npx electron-builder -c electron-builder.github.yml --linux AppImage deb rpm --arm64 --publish always && npm run sign:gpg:arm64",
+    "release:linux:native:x64": "dotenv -e .env -- node build-scripts/build-with-restore.js --prepare build-scripts/prepare-linux-x64.js --env USE_SYSTEM_FPM=true --env CHANNEL=github -- npx electron-builder -c electron-builder.github.yml --linux AppImage deb rpm --x64 --publish always && npm run sign:gpg:x64",
+    "release:linux:native:arm64": "dotenv -e .env -- node build-scripts/build-with-restore.js --prepare build-scripts/prepare-linux-arm64.js --env USE_SYSTEM_FPM=true --env CHANNEL=github -- npx electron-builder -c electron-builder.github.yml --linux AppImage deb rpm --arm64 --publish always && npm run sign:gpg:arm64",
     "release:all": "npm run prebuild && npm run release:mac && npm run release:win && npm run release:linux"
   },
   "overrides": {
diff --git a/src/main/deno.ts b/src/main/deno.ts
index 078f4d5..a251e7c 100644
--- a/src/main/deno.ts
+++ b/src/main/deno.ts
@@ -3,6 +3,7 @@ import * as fs from 'fs';
 import { spawn } from 'child_process';
 import { BrowserWindow, dialog } from 'electron';
 import log from 'electron-log/main';
+import type { MessageBoxOptions } from 'electron';
 import { DENO_CHECK_TIMEOUT_MS, DENO_INSTALL_TIMEOUT_MS } from './constants';
 import { isWindows } from './platform';
 
@@ -91,14 +92,17 @@ export async function installDeno(
   mainWindow: BrowserWindow | null
 ): Promise<{ success?: boolean; cancelled?: boolean; output?: string; error?: string }> {
   const parentWindow = BrowserWindow.getFocusedWindow() || mainWindow;
-  const confirm = await dialog.showMessageBox(parentWindow!, {
+  const confirmOptions: MessageBoxOptions = {
     type: 'warning',
     buttons: ['Install', 'Cancel'],
     defaultId: 0,
     cancelId: 1,
     message:
       'This will download and run the Deno installer from deno.land. Do you want to continue?',
-  });
+  };
+  const confirm = parentWindow
+    ? await dialog.showMessageBox(parentWindow, confirmOptions)
+    : await dialog.showMessageBox(confirmOptions);
 
   if (confirm.response !== 0) {
     return { cancelled: true };
diff --git a/src/main/download/commandBuilders.ts b/src/main/download/commandBuilders.ts
new file mode 100644
index 0000000..97a1f01
--- /dev/null
+++ b/src/main/download/commandBuilders.ts
@@ -0,0 +1,108 @@
+import type { DownloadRequestOptions, Settings } from '../../types';
+
+export function resolveVideoEncoder(settings: Settings): string {
+  if (!settings.gpuAcceleration) return 'copy';
+  if (settings.gpuType === 'nvidia') return 'h264_nvenc';
+  if (settings.gpuType === 'amd') return 'h264_amf';
+  if (settings.gpuType === 'intel') return 'h264_qsv';
+  return 'copy';
+}
+
+export function buildFfmpegArgs(
+  inputPath: string,
+  outputPath: string,
+  targetFormat: string,
+  videoEncoder: string
+): string[] {
+  if (targetFormat === 'mp3' || targetFormat === 'm4a') {
+    return [
+      '-i',
+      inputPath,
+      '-vn',
+      '-c:a',
+      targetFormat === 'mp3' ? 'libmp3lame' : 'aac',
+      '-y',
+      outputPath,
+    ];
+  }
+
+  return [
+    '-i',
+    inputPath,
+    '-c:v',
+    videoEncoder,
+    '-c:a',
+    'aac',
+    '-movflags',
+    '+faststart',
+    '-y',
+    outputPath,
+  ];
+}
+
+interface BuildYtdlpArgsInput {
+  normalizedDownloadDir: string;
+  url: string;
+  settings: Settings;
+  options: DownloadRequestOptions;
+  ffmpegLocation: string | null;
+}
+
+export interface BuildYtdlpArgsResult {
+  args: string[];
+  statusMessages: string[];
+}
+
+export function buildYtdlpArgs({
+  normalizedDownloadDir,
+  url,
+  settings,
+  options,
+  ffmpegLocation,
+}: BuildYtdlpArgsInput): BuildYtdlpArgsResult {
+  const args = [
+    '-P',
+    normalizedDownloadDir,
+    '--no-playlist',
+    '--print',
+    'after_move:filepath',
+    '--newline',
+    '--progress',
+    '--progress-delta',
+    '1',
+    '-f',
+    settings.bestQuality ? 'bestvideo+bestaudio/best' : 'best[ext=mp4]/best[ext=webm]/best',
+    url,
+  ];
+  const statusMessages: string[] = [];
+
+  if (ffmpegLocation) {
+    args.splice(args.length - 1, 0, '--ffmpeg-location', ffmpegLocation);
+  }
+
+  const formatFlagIndex = args.indexOf('-f');
+  if (options.videoFormat && options.audioFormat) {
+    args[formatFlagIndex + 1] = `${options.videoFormat}+${options.audioFormat}`;
+    statusMessages.push(
+      `📹 Using formats: video=${options.videoFormat}, audio=${options.audioFormat}`
+    );
+  } else if (options.videoFormat) {
+    args[formatFlagIndex + 1] = options.videoFormat;
+    statusMessages.push(`📹 Using video format: ${options.videoFormat}`);
+  } else if (options.audioFormat) {
+    args[formatFlagIndex + 1] = options.audioFormat;
+    statusMessages.push(`🎵 Using audio format: ${options.audioFormat}`);
+  }
+
+  if (settings.audioOnly && !options.videoFormat && !options.audioFormat) {
+    args.splice(formatFlagIndex, 2);
+    args.splice(-1, 0, '-x', '--audio-format', 'mp3', '--audio-quality', '0');
+    statusMessages.push('🎵 Audio-only mode enabled');
+  }
+
+  if (settings.hookBrowser && settings.browserChoice) {
+    args.splice(-1, 0, '--cookies-from-browser', settings.browserChoice);
+  }
+
+  return { args, statusMessages };
+}
diff --git a/src/main/downloader.ts b/src/main/downloader.ts
index 080c406..9ca6d38 100644
--- a/src/main/downloader.ts
+++ b/src/main/downloader.ts
@@ -5,6 +5,7 @@ import { dialog } from 'electron';
 import log from 'electron-log/main';
 import { spawnWithEnv, resolveFfmpegPath, ytdlpBinary, isWindows } from './platform';
 import { loadSettings } from './settings';
+import { buildFfmpegArgs, buildYtdlpArgs, resolveVideoEncoder } from './download/commandBuilders';
 import { isSafeHttpUrl } from '../utils/validation';
 import {
   createDownloadLifecycleState,
@@ -221,47 +222,14 @@ function runConversion(
 
     sendProgress(session, `🎬 Converting ${inputFilename} to ${targetFormat.toUpperCase()}...`);
 
-    const getVideoEncoder = () => {
-      if (!effectiveSettings.gpuAcceleration) return 'copy';
-      const gpuType = effectiveSettings.gpuType || 'auto';
-      if (gpuType === 'nvidia') return 'h264_nvenc';
-      if (gpuType === 'amd') return 'h264_amf';
-      if (gpuType === 'intel') return 'h264_qsv';
-      return 'copy';
-    };
-
-    const videoEncoder = getVideoEncoder();
+    const videoEncoder = resolveVideoEncoder(effectiveSettings);
     const useGpu = effectiveSettings.gpuAcceleration && videoEncoder !== 'copy';
 
     if (useGpu) {
       sendProgress(session, `🖥️ Using GPU acceleration (${videoEncoder})`);
     }
 
-    let ffmpegArgs: string[];
-    if (targetFormat === 'mp3' || targetFormat === 'm4a') {
-      ffmpegArgs = [
-        '-i',
-        inputPath,
-        '-vn',
-        '-c:a',
-        targetFormat === 'mp3' ? 'libmp3lame' : 'aac',
-        '-y',
-        outputPath,
-      ];
-    } else {
-      ffmpegArgs = [
-        '-i',
-        inputPath,
-        '-c:v',
-        videoEncoder,
-        '-c:a',
-        'aac',
-        '-movflags',
-        '+faststart',
-        '-y',
-        outputPath,
-      ];
-    }
+    const ffmpegArgs = buildFfmpegArgs(inputPath, outputPath, targetFormat, videoEncoder);
 
     ffmpegProcess = spawnWithEnv(ffmpegCommand, ffmpegArgs);
     session.ffmpegProcess = ffmpegProcess;
@@ -426,51 +394,14 @@ export function startDownload(
       }
     }
 
-    const ytdlpArgs = [
-      '-P',
+    const { args: ytdlpArgs, statusMessages } = buildYtdlpArgs({
       normalizedDownloadDir,
-      '--no-playlist',
-      '--print',
-      'after_move:filepath',
-      '--newline',
-      '--progress',
-      '--progress-delta',
-      '1',
-      '-f',
-      effectiveSettings.bestQuality
-        ? 'bestvideo+bestaudio/best'
-        : 'best[ext=mp4]/best[ext=webm]/best',
       url,
-    ];
-    if (ffmpegLocation) {
-      ytdlpArgs.splice(ytdlpArgs.length - 1, 0, '--ffmpeg-location', ffmpegLocation);
-    }
-
-    const formatFlagIndex = ytdlpArgs.indexOf('-f');
-
-    if (options.videoFormat && options.audioFormat) {
-      ytdlpArgs[formatFlagIndex + 1] = `${options.videoFormat}+${options.audioFormat}`;
-      sendProgress(
-        session,
-        `📹 Using formats: video=${options.videoFormat}, audio=${options.audioFormat}`
-      );
-    } else if (options.videoFormat) {
-      ytdlpArgs[formatFlagIndex + 1] = options.videoFormat;
-      sendProgress(session, `📹 Using video format: ${options.videoFormat}`);
-    } else if (options.audioFormat) {
-      ytdlpArgs[formatFlagIndex + 1] = options.audioFormat;
-      sendProgress(session, `🎵 Using audio format: ${options.audioFormat}`);
-    }
-
-    if (effectiveSettings.audioOnly && !options.videoFormat && !options.audioFormat) {
-      ytdlpArgs.splice(formatFlagIndex, 2);
-      ytdlpArgs.splice(-1, 0, '-x', '--audio-format', 'mp3', '--audio-quality', '0');
-      sendProgress(session, '🎵 Audio-only mode enabled');
-    }
-
-    if (effectiveSettings.hookBrowser && effectiveSettings.browserChoice) {
-      ytdlpArgs.splice(-1, 0, '--cookies-from-browser', effectiveSettings.browserChoice);
-    }
+      settings: effectiveSettings,
+      options,
+      ffmpegLocation,
+    });
+    statusMessages.forEach((message) => sendProgress(session, message));
 
     sendProgress(session, `🚀 Starting download: ${url}`);
     sendProgress(session, `   Command: ${ytdlpBinary} ${ytdlpArgs.join(' ')}`);
diff --git a/src/main/main.ts b/src/main/main.ts
index 9c4814c..5b5d241 100644
--- a/src/main/main.ts
+++ b/src/main/main.ts
@@ -21,6 +21,15 @@ import {
   cancelFormats,
 } from './downloader';
 import { isSafeExternalUrl, isAllowedNavigationUrl } from '../utils/validation';
+import {
+  errorResult,
+  okResult,
+  validateDownloadRequestPayload,
+  validateExternalUrlPayload,
+  validateFileLocationPayload,
+  validateNotificationPayload,
+  validateSettingsPatchPayload,
+} from '../utils/ipcValidation';
 import { SPLASH_SHOW_DELAY_MS, SPLASH_FADE_DELAY_MS } from './constants';
 import type { DownloadRequestOptions } from '../types';
 
@@ -148,13 +157,27 @@ ipcMain.handle('check-deno-installed', () => checkDenoInstalled());
 ipcMain.handle('install-deno', () => installDeno(mainWindow));
 
 ipcMain.handle('get-settings', () => loadSettings());
-ipcMain.on('save-settings', (_, data) => saveSettings(data, mainWindow));
+ipcMain.handle('save-settings', (_, data) => {
+  const validation = validateSettingsPatchPayload(data);
+  if (!validation.ok) {
+    return errorResult(validation.error.code, validation.error.message, validation.error.details);
+  }
+
+  const saved = saveSettings(validation.data, mainWindow);
+  if (!saved) {
+    return errorResult('INTERNAL_ERROR', 'Failed to persist settings.');
+  }
+  return okResult(loadSettings());
+});
 
 ipcMain.handle('detect-gpu', () => detectGpu());
 
 ipcMain.on('reset-settings', () => {
   try {
-    saveSettings(getDefaultSettings(), mainWindow);
+    const saved = saveSettings(getDefaultSettings(), mainWindow);
+    if (!saved) {
+      log.error('Failed to save default settings during reset-settings.');
+    }
     app.relaunch();
     app.exit();
   } catch (error) {
@@ -164,15 +187,18 @@ ipcMain.on('reset-settings', () => {
   }
 });
 
-ipcMain.on('open-external', (_, url) => {
+ipcMain.handle('open-external', async (_, url) => {
+  const validation = validateExternalUrlPayload(url);
+  if (!validation.ok) {
+    return errorResult(validation.error.code, validation.error.message, validation.error.details);
+  }
+
   try {
-    if (isSafeExternalUrl(url)) {
-      shell.openExternal(url).catch((err) => {
-        log.error('Failed to open external URL:', err);
-      });
-    }
+    await shell.openExternal(validation.data);
+    return okResult({ opened: true });
   } catch (error) {
     log.error('Error in open-external handler:', error);
+    return errorResult('INTERNAL_ERROR', 'Failed to open external URL.');
   }
 });
 
@@ -195,11 +221,27 @@ ipcMain.handle('select-download-location', async () => {
   }
 });
 
-ipcMain.handle('getFormats', (_, url) => fetchFormats(ytdlpPath, url));
+ipcMain.handle('getFormats', (_, url) => {
+  if (typeof url !== 'string') {
+    return Promise.reject('Invalid URL provided');
+  }
+  return fetchFormats(ytdlpPath, url);
+});
 ipcMain.on('cancel-formats', () => cancelFormats());
 
-ipcMain.on('download-video', (event, options) => {
-  startDownload(ytdlpPath, event.sender, options as DownloadRequestOptions, mainWindow);
+ipcMain.handle('download-video', (event, options) => {
+  const validation = validateDownloadRequestPayload(options);
+  if (!validation.ok) {
+    return errorResult(validation.error.code, validation.error.message, validation.error.details);
+  }
+
+  try {
+    startDownload(ytdlpPath, event.sender, validation.data as DownloadRequestOptions, mainWindow);
+    return okResult({ started: true });
+  } catch (error) {
+    log.error('Error in download-video handler:', error);
+    return errorResult('INTERNAL_ERROR', 'Failed to start download.');
+  }
 });
 
 ipcMain.on('cancel-download', () => {
@@ -215,52 +257,67 @@ ipcMain.handle('restart-app', () => {
   app.exit(0);
 });
 
-ipcMain.on('open-file-location', (_, filePath) => {
+ipcMain.handle('open-file-location', async (_, filePath) => {
+  const validation = validateFileLocationPayload(filePath);
+  if (!validation.ok) {
+    return errorResult(validation.error.code, validation.error.message, validation.error.details);
+  }
+
   try {
-    if (filePath && typeof filePath === 'string') {
-      if (fs.existsSync(filePath)) {
-        shell.showItemInFolder(filePath);
-      } else {
-        const dir = path.dirname(filePath);
-        if (fs.existsSync(dir)) {
-          shell.openPath(dir).catch((err: Error) => {
-            log.error('Error opening directory:', err);
-          });
-        }
-      }
+    if (fs.existsSync(validation.data)) {
+      shell.showItemInFolder(validation.data);
+      return okResult({ opened: true });
     }
+
+    const dir = path.dirname(validation.data);
+    if (fs.existsSync(dir)) {
+      await shell.openPath(dir);
+      return okResult({ opened: true });
+    }
+
+    return errorResult('INVALID_PATH', 'Path and containing directory do not exist.');
   } catch (error) {
     log.error('Error in open-file-location handler:', error);
+    return errorResult('INTERNAL_ERROR', 'Failed to open file location.');
   }
 });
 
-ipcMain.on('show-notification', (_, options) => {
+ipcMain.handle('show-notification', (_, options) => {
+  const validation = validateNotificationPayload(options);
+  if (!validation.ok) {
+    return errorResult(validation.error.code, validation.error.message, validation.error.details);
+  }
+
   try {
-    if (Notification.isSupported()) {
-      const notification = new Notification({
-        title: options?.title || 'ROSI',
-        body: options?.body || '',
-        icon: path.join(__dirname, '..', '..', 'src', 'renderer', 'app.png'),
-        silent: false,
-      });
+    if (!Notification.isSupported()) {
+      return errorResult('NOT_SUPPORTED', 'Notifications are not supported in this environment.');
+    }
 
-      notification.on('click', () => {
-        try {
-          if (mainWindow && !mainWindow.isDestroyed()) {
-            if (mainWindow.isMinimized()) mainWindow.restore();
-            mainWindow.focus();
-          }
-          if (options?.filePath) {
-            shell.showItemInFolder(options.filePath);
-          }
-        } catch (clickErr) {
-          log.error('Error handling notification click:', clickErr);
+    const notification = new Notification({
+      title: validation.data.title || 'ROSI',
+      body: validation.data.body || '',
+      icon: path.join(__dirname, '..', '..', 'src', 'renderer', 'app.png'),
+      silent: false,
+    });
+
+    notification.on('click', () => {
+      try {
+        if (mainWindow && !mainWindow.isDestroyed()) {
+          if (mainWindow.isMinimized()) mainWindow.restore();
+          mainWindow.focus();
         }
-      });
+        if (validation.data.filePath) {
+          shell.showItemInFolder(validation.data.filePath);
+        }
+      } catch (clickErr) {
+        log.error('Error handling notification click:', clickErr);
+      }
+    });
 
-      notification.show();
-    }
+    notification.show();
+    return okResult({ shown: true });
   } catch (error) {
     log.error('Error showing notification:', error);
+    return errorResult('INTERNAL_ERROR', 'Failed to show notification.');
   }
 });
diff --git a/src/main/preload.ts b/src/main/preload.ts
index 3cb4e49..16fa5cf 100644
--- a/src/main/preload.ts
+++ b/src/main/preload.ts
@@ -1,51 +1,52 @@
 import { contextBridge, ipcRenderer } from 'electron';
+import type {
+  DownloadRequestOptions,
+  NotificationRequest,
+  RendererApi,
+  Settings,
+  UpdateDownloadResult,
+  UpdaterProgressEvent,
+  UpdaterStatusEvent,
+} from '../types';
 
-const api = {
+const api: RendererApi = {
   restartApp: () => ipcRenderer.invoke('restart-app'),
-  // get active distribution channel
   getChannel: () =>
     process.env.CHANNEL === 'msstore' || process.windowsStore ? 'msstore' : 'github',
   getFormats: (url: string) => ipcRenderer.invoke('getFormats', url),
   selectDownloadLocation: () => ipcRenderer.invoke('select-download-location'),
   getSettings: () => ipcRenderer.invoke('get-settings'),
-  saveSettings: (settings: Record<string, unknown>) => ipcRenderer.send('save-settings', settings),
+  saveSettings: (settings: Partial<Settings>) => ipcRenderer.invoke('save-settings', settings),
   resetSettings: () => ipcRenderer.send('reset-settings'),
-  openExternal: (url: string) => ipcRenderer.send('open-external', url),
-  downloadVideo: (options: Record<string, unknown>) => ipcRenderer.send('download-video', options),
+  openExternal: (url: string) => ipcRenderer.invoke('open-external', url),
+  downloadVideo: (options: DownloadRequestOptions) => ipcRenderer.invoke('download-video', options),
   cancelDownload: () => ipcRenderer.send('cancel-download'),
   cancelFormats: () => ipcRenderer.send('cancel-formats'),
   getAppVersion: () => ipcRenderer.invoke('get-app-version'),
   checkDenoInstalled: () => ipcRenderer.invoke('check-deno-installed'),
   installDeno: () => ipcRenderer.invoke('install-deno'),
   detectGpu: () => ipcRenderer.invoke('detect-gpu'),
-
-  // Auto-updater APIs
   isPackaged: () => ipcRenderer.invoke('is-packaged'),
   checkForUpdates: () => ipcRenderer.invoke('check-for-updates'),
-  downloadUpdate: () => ipcRenderer.invoke('download-update'),
+  downloadUpdate: () => ipcRenderer.invoke('download-update') as Promise<UpdateDownloadResult>,
   cancelUpdateDownload: () => ipcRenderer.send('cancel-update-download'),
   installUpdate: () => ipcRenderer.send('install-update'),
-  onUpdaterStatus: (callback: (data: Record<string, unknown>) => void) => {
-    const listener = (_: Electron.IpcRendererEvent, data: Record<string, unknown>) =>
-      callback(data);
+  onUpdaterStatus: (callback: (data: UpdaterStatusEvent) => void) => {
+    const listener = (_: Electron.IpcRendererEvent, data: UpdaterStatusEvent) => callback(data);
     ipcRenderer.on('updater-status', listener);
     return () => ipcRenderer.removeListener('updater-status', listener);
   },
-  onUpdaterProgress: (callback: (data: Record<string, unknown>) => void) => {
-    const listener = (_: Electron.IpcRendererEvent, data: Record<string, unknown>) =>
-      callback(data);
+  onUpdaterProgress: (callback: (data: UpdaterProgressEvent) => void) => {
+    const listener = (_: Electron.IpcRendererEvent, data: UpdaterProgressEvent) => callback(data);
     ipcRenderer.on('updater-progress', listener);
     return () => ipcRenderer.removeListener('updater-progress', listener);
   },
-
-  // dl progress
   onDownloadProgress: (callback: (data: Record<string, unknown>) => void) => {
     const listener = (_: Electron.IpcRendererEvent, data: Record<string, unknown>) =>
       callback(data);
     ipcRenderer.on('download-progress', listener);
     return () => ipcRenderer.removeListener('download-progress', listener);
   },
-
   onProgress: (callback: (message: string) => void) => {
     const listener = (_: Electron.IpcRendererEvent, message: string) => callback(message);
     ipcRenderer.on('progress', listener);
@@ -56,9 +57,9 @@ const api = {
     ipcRenderer.on('complete', listener);
     return () => ipcRenderer.removeListener('complete', listener);
   },
-  openFileLocation: (filePath: string) => ipcRenderer.send('open-file-location', filePath),
-  showNotification: (options: Record<string, unknown>) =>
-    ipcRenderer.send('show-notification', options),
+  openFileLocation: (filePath: string) => ipcRenderer.invoke('open-file-location', filePath),
+  showNotification: (options: NotificationRequest) =>
+    ipcRenderer.invoke('show-notification', options),
 };
 
 contextBridge.exposeInMainWorld('api', api);
diff --git a/src/main/settings.ts b/src/main/settings.ts
index ad776cd..9314f23 100644
--- a/src/main/settings.ts
+++ b/src/main/settings.ts
@@ -5,8 +5,10 @@ import log from 'electron-log/main';
 import type { Settings } from '../types';
 
 const settingsPath = path.join(app.getPath('userData'), 'settings.json');
+export const CURRENT_SETTINGS_VERSION = 1;
 
 const defaultSettings: Settings = {
+  settingsVersion: CURRENT_SETTINGS_VERSION,
   showConsoleOutput: false,
   consoleCollapsed: false,
   advancedOptions: false,
@@ -33,6 +35,89 @@ export function getDefaultSettings(): Settings {
   return { ...defaultSettings };
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function readBoolean(value: unknown, fallback: boolean): boolean {
+  return typeof value === 'boolean' ? value : fallback;
+}
+
+function readString(value: unknown, fallback: string): string {
+  return typeof value === 'string' ? value : fallback;
+}
+
+function readUpdateChannel(value: unknown): Settings['updateChannel'] {
+  return value === 'stable' || value === 'beta' || value === 'auto'
+    ? value
+    : defaultSettings.updateChannel;
+}
+
+function readGpuType(value: unknown): Settings['gpuType'] {
+  return value === 'auto' || value === 'nvidia' || value === 'amd' || value === 'intel'
+    ? value
+    : defaultSettings.gpuType;
+}
+
+function readSettingsVersion(value: unknown): number {
+  if (typeof value === 'number' && Number.isInteger(value) && value >= 1) {
+    return value;
+  }
+  return CURRENT_SETTINGS_VERSION;
+}
+
+export function migrateSettings(rawSettings: unknown): Settings {
+  if (!isRecord(rawSettings)) {
+    return { ...defaultSettings };
+  }
+
+  return {
+    settingsVersion: readSettingsVersion(rawSettings.settingsVersion),
+    showConsoleOutput: readBoolean(
+      rawSettings.showConsoleOutput,
+      defaultSettings.showConsoleOutput
+    ),
+    consoleCollapsed: readBoolean(rawSettings.consoleCollapsed, defaultSettings.consoleCollapsed),
+    advancedOptions: readBoolean(rawSettings.advancedOptions, defaultSettings.advancedOptions),
+    audioOnly: readBoolean(rawSettings.audioOnly, defaultSettings.audioOnly),
+    convertEnabled: readBoolean(rawSettings.convertEnabled, defaultSettings.convertEnabled),
+    convertFormat: readString(rawSettings.convertFormat, defaultSettings.convertFormat),
+    keepOriginalAfterConvert: readBoolean(
+      rawSettings.keepOriginalAfterConvert,
+      defaultSettings.keepOriginalAfterConvert
+    ),
+    firstLaunch: readBoolean(rawSettings.firstLaunch, defaultSettings.firstLaunch),
+    hookBrowser: readBoolean(rawSettings.hookBrowser, defaultSettings.hookBrowser),
+    browserChoice: readString(rawSettings.browserChoice, defaultSettings.browserChoice),
+    animateBackground: readBoolean(
+      rawSettings.animateBackground,
+      defaultSettings.animateBackground
+    ),
+    notifications: readBoolean(rawSettings.notifications, defaultSettings.notifications),
+    denoReminderDismissed: readBoolean(
+      rawSettings.denoReminderDismissed,
+      defaultSettings.denoReminderDismissed
+    ),
+    gpuAcceleration: readBoolean(rawSettings.gpuAcceleration, defaultSettings.gpuAcceleration),
+    gpuType: readGpuType(rawSettings.gpuType),
+    bestQuality: readBoolean(rawSettings.bestQuality, defaultSettings.bestQuality),
+    ffmpegPath: readString(rawSettings.ffmpegPath, defaultSettings.ffmpegPath),
+    hideSupportModal: readBoolean(rawSettings.hideSupportModal, defaultSettings.hideSupportModal),
+    checkUpdatesOnStartup: readBoolean(
+      rawSettings.checkUpdatesOnStartup,
+      defaultSettings.checkUpdatesOnStartup
+    ),
+    updateChannel: readUpdateChannel(rawSettings.updateChannel),
+  };
+}
+
+function normalizeSettingsVersion(settings: Settings): Settings {
+  return {
+    ...settings,
+    settingsVersion: CURRENT_SETTINGS_VERSION,
+  };
+}
+
 export function loadSettings(): Settings {
   try {
     if (!fs.existsSync(settingsPath)) {
@@ -40,7 +125,7 @@ export function loadSettings(): Settings {
     }
     const raw = fs.readFileSync(settingsPath, 'utf-8');
     const loaded = JSON.parse(raw);
-    return { ...defaultSettings, ...loaded };
+    return normalizeSettingsVersion(migrateSettings(loaded));
   } catch {
     return { ...defaultSettings };
   }
@@ -49,12 +134,16 @@ export function loadSettings(): Settings {
 export function saveSettings(
   newSettings: Partial<Settings>,
   mainWindow: Electron.BrowserWindow | null
-) {
+): boolean {
   try {
     const dir = path.dirname(settingsPath);
     if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-    const completeSettings = { ...defaultSettings, ...newSettings };
+    const existing = loadSettings();
+    const completeSettings = normalizeSettingsVersion(
+      migrateSettings({ ...existing, ...newSettings })
+    );
     fs.writeFileSync(settingsPath, JSON.stringify(completeSettings, null, 2));
+    return true;
   } catch (error) {
     log.error('Failed to save settings:', error);
     if (mainWindow && !mainWindow.isDestroyed()) {
@@ -63,5 +152,6 @@ export function saveSettings(
         `Failed to save settings: ${(error as Error).message}`
       );
     }
+    return false;
   }
 }
diff --git a/src/main/updater.ts b/src/main/updater.ts
index 02383ce..f4dee67 100644
--- a/src/main/updater.ts
+++ b/src/main/updater.ts
@@ -2,15 +2,27 @@ import type { BrowserWindow } from 'electron';
 import { app } from 'electron';
 import { autoUpdater, CancellationToken } from 'electron-updater';
 import log from 'electron-log/main';
-import type { Settings } from '../types';
+import type {
+  Settings,
+  UpdateDownloadResult,
+  UpdaterProgressEvent,
+  UpdaterStatusEvent,
+} from '../types';
 
 let updateDownloadCancellationToken: CancellationToken | null = null;
 
-function isBetaVersion(version: string): boolean {
+interface ParsedVersion {
+  major: number;
+  minor: number;
+  patch: number;
+  prerelease: string[];
+}
+
+export function isBetaVersion(version: string): boolean {
   return /-(beta|alpha|rc)/i.test(version);
 }
 
-function parseVersion(v: string) {
+export function parseVersion(v: string): ParsedVersion {
   const cleaned = v.trim().replace(/^v/i, '').split('+')[0];
   const match = cleaned.match(/^(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-([0-9A-Za-z.-]+))?/);
   if (!match) return { major: 0, minor: 0, patch: 0, prerelease: [] as string[] };
@@ -22,7 +34,7 @@ function parseVersion(v: string) {
   };
 }
 
-function comparePrerelease(a: string[], b: string[]): number {
+export function comparePrerelease(a: string[], b: string[]): number {
   if (a.length === 0 && b.length === 0) return 0;
   if (a.length === 0) return 1;
   if (b.length === 0) return -1;
@@ -45,7 +57,7 @@ function comparePrerelease(a: string[], b: string[]): number {
   return 0;
 }
 
-function compareVersions(a: string, b: string): number {
+export function compareVersions(a: string, b: string): number {
   const vA = parseVersion(a);
   const vB = parseVersion(b);
   if (vA.major !== vB.major) return vA.major > vB.major ? 1 : -1;
@@ -54,13 +66,13 @@ function compareVersions(a: string, b: string): number {
   return comparePrerelease(vA.prerelease, vB.prerelease);
 }
 
-function resolveUseBeta(channel: Settings['updateChannel']): boolean {
+export function resolveUseBeta(channel: Settings['updateChannel']): boolean {
   if (channel === 'beta') return true;
   if (channel === 'stable') return false;
   return isBetaVersion(app.getVersion());
 }
 
-function applyChannel(useBeta: boolean) {
+export function applyChannel(useBeta: boolean) {
   if (useBeta) {
     autoUpdater.channel = 'beta';
     autoUpdater.allowPrerelease = true;
@@ -81,15 +93,23 @@ export function setupAutoUpdater(
   const useBeta = resolveUseBeta(settings.updateChannel);
   applyChannel(useBeta);
 
-  const sendToWindow = (channel: string, data: unknown) => {
+  const sendToWindow = (channel: 'updater-status' | 'updater-progress', data: unknown) => {
     const win = getMainWindow();
     if (win && !win.isDestroyed()) {
       win.webContents.send(channel, data);
     }
   };
 
+  const sendStatus = (data: UpdaterStatusEvent) => {
+    sendToWindow('updater-status', data);
+  };
+
+  const sendProgress = (data: UpdaterProgressEvent) => {
+    sendToWindow('updater-progress', data);
+  };
+
   autoUpdater.on('checking-for-update', () => {
-    sendToWindow('updater-status', { status: 'checking' });
+    sendStatus({ status: 'checking' });
   });
 
   autoUpdater.on('update-available', (info) => {
@@ -97,7 +117,7 @@ export function setupAutoUpdater(
     const updateIsBeta = isBetaVersion(info.version);
 
     if (currentUseBeta && !updateIsBeta) {
-      sendToWindow('updater-status', {
+      sendStatus({
         status: 'not-available',
         version: app.getVersion(),
         isBeta: currentUseBeta,
@@ -105,7 +125,7 @@ export function setupAutoUpdater(
       return;
     }
     if (!currentUseBeta && updateIsBeta) {
-      sendToWindow('updater-status', {
+      sendStatus({
         status: 'not-available',
         version: app.getVersion(),
         isBeta: currentUseBeta,
@@ -118,7 +138,7 @@ export function setupAutoUpdater(
       log.info(
         `[AutoUpdater] Ignoring update ${info.version} — current ${currentVersion} is newer or equal`
       );
-      sendToWindow('updater-status', {
+      sendStatus({
         status: 'not-available',
         version: currentVersion,
         isBeta: currentUseBeta,
@@ -126,32 +146,32 @@ export function setupAutoUpdater(
       return;
     }
 
-    sendToWindow('updater-status', {
+    sendStatus({
       status: 'available',
       version: info.version,
-      releaseNotes: info.releaseNotes,
+      releaseNotes: info.releaseNotes ?? null,
       isBeta: updateIsBeta,
     });
   });
 
   autoUpdater.on('update-not-available', (info) => {
-    sendToWindow('updater-status', {
+    sendStatus({
       status: 'not-available',
-      version: info.version,
-      isBeta: isBetaVersion(info.version),
+      version: info.version ?? app.getVersion(),
+      isBeta: isBetaVersion(info.version ?? app.getVersion()),
     });
   });
 
   autoUpdater.on('error', (err) => {
     log.error('Auto-updater error:', err);
-    sendToWindow('updater-status', {
+    sendStatus({
       status: 'error',
       message: err.message,
     });
   });
 
   autoUpdater.on('download-progress', (progressObj) => {
-    sendToWindow('updater-progress', {
+    sendProgress({
       percent: progressObj.percent,
       bytesPerSecond: progressObj.bytesPerSecond,
       transferred: progressObj.transferred,
@@ -160,7 +180,7 @@ export function setupAutoUpdater(
   });
 
   autoUpdater.on('update-downloaded', (info) => {
-    sendToWindow('updater-status', {
+    sendStatus({
       status: 'downloaded',
       version: info.version,
     });
@@ -181,7 +201,7 @@ export async function checkForUpdates(isPackaged: boolean, loadSettings: () => S
   }
 }
 
-export async function downloadUpdate() {
+export async function downloadUpdate(): Promise<UpdateDownloadResult> {
   try {
     updateDownloadCancellationToken = new CancellationToken();
     await autoUpdater.downloadUpdate(updateDownloadCancellationToken);
@@ -202,7 +222,8 @@ export function cancelUpdateDownload(getMainWindow: () => BrowserWindow | null)
     updateDownloadCancellationToken = null;
     const win = getMainWindow();
     if (win && !win.isDestroyed()) {
-      win.webContents.send('updater-status', { status: 'cancelled' });
+      const cancelledEvent: UpdaterStatusEvent = { status: 'cancelled' };
+      win.webContents.send('updater-status', cancelledEvent);
     }
   }
 }
diff --git a/src/renderer/index.html b/src/renderer/index.html
index 18546b5..cc525a6 100644
--- a/src/renderer/index.html
+++ b/src/renderer/index.html
@@ -1,5 +1,5 @@
 <!doctype html>
-<html>
+<html lang="en">
   <head>
     <meta charset="UTF-8" />
     <meta
@@ -242,14 +242,14 @@ <h3 class="settings-section-title">Application</h3>
         </button>
         <div class="version-info">
           <a id="versionLink" href="#">Loading...</a>
-          <span id="betaBadge" class="beta-badge" style="display: none">BETA</span>
+          <span id="betaBadge" class="beta-badge hidden">BETA</span>
         </div>
       </div>
     </aside>
 
     <main class="main-content">
       <header class="top-bar">
-        <button id="settingsBtn" class="icon-btn" title="Settings">
+        <button id="settingsBtn" class="icon-btn" title="Settings" aria-label="Settings">
           <svg
             width="22"
             height="22"
@@ -276,7 +276,7 @@ <h3 class="settings-section-title">Application</h3>
         </div>
 
         <div class="top-bar-links">
-          <a href="#" id="helpLink" title="Help">
+          <a href="#" id="helpLink" title="Help" aria-label="Help">
             <svg
               width="20"
               height="20"
@@ -289,10 +289,10 @@ <h3 class="settings-section-title">Application</h3>
             >
               <circle cx="12" cy="12" r="10"></circle>
               <path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3" />
-              <line x1="12" y1="17" x2="12.01" y2="17" />
+              <circle cx="12" cy="17" r="0.5" />
             </svg>
           </a>
-          <a href="#" id="supportLink" title="Support">
+          <a href="#" id="supportLink" title="Support" aria-label="Support">
             <svg
               width="20"
               height="20"
@@ -339,7 +339,7 @@ <h1 class="download-title">Download Videos</h1>
                 autocomplete="off"
                 spellcheck="false"
               />
-              <button id="clearUrl" class="clear-btn" title="Clear" style="display: none">
+              <button id="clearUrl" class="clear-btn hidden" title="Clear" aria-label="Clear URL">
                 <svg
                   width="16"
                   height="16"
@@ -376,8 +376,8 @@ <h1 class="download-title">Download Videos</h1>
 
           <div id="progress-container" class="progress-container">
             <div class="progress-header">
-              <span id="progress-status" class="progress-status">Ready</span>
-              <span id="progress-percent" class="progress-percent"></span>
+              <span id="progress-status" class="progress-status" aria-live="polite">Ready</span>
+              <span id="progress-percent" class="progress-percent" aria-live="polite"></span>
             </div>
             <div class="progress-bar-wrapper">
               <div id="progress-bar" class="progress-bar"></div>
@@ -421,7 +421,13 @@ <h1 class="download-title">Download Videos</h1>
       </section>
 
       <section id="console-section" class="console-section">
-        <div class="console-header" id="consoleHeader">
+        <div
+          class="console-header"
+          id="consoleHeader"
+          role="button"
+          aria-expanded="false"
+          tabindex="0"
+        >
           <div class="console-header-left">
             <svg
               class="console-collapse-icon"
@@ -453,7 +459,12 @@ <h1 class="download-title">Download Videos</h1>
               Console Output
             </span>
           </div>
-          <button id="clearConsole" class="console-clear-btn" title="Clear console">
+          <button
+            id="clearConsole"
+            class="console-clear-btn"
+            title="Clear console"
+            aria-label="Clear console"
+          >
             <svg
               width="14"
               height="14"
@@ -495,7 +506,13 @@ <h1 class="download-title">Download Videos</h1>
       </footer>
     </main>
 
-    <div id="app-modal" class="modal-overlay">
+    <div
+      id="app-modal"
+      class="modal-overlay"
+      role="dialog"
+      aria-modal="true"
+      aria-labelledby="modal-title"
+    >
       <div class="modal-box">
         <h3 id="modal-title">Modal Title</h3>
         <div id="modal-message" class="modal-message">Modal message goes here...</div>
@@ -504,7 +521,13 @@ <h3 id="modal-title">Modal Title</h3>
       </div>
     </div>
 
-    <div id="licenses-overlay" class="modal-overlay">
+    <div
+      id="licenses-overlay"
+      class="modal-overlay"
+      role="dialog"
+      aria-modal="true"
+      aria-label="Open Source Licenses"
+    >
       <div class="licenses-container">
         <div class="licenses-header">
           <h3>Open Source Licenses</h3>
diff --git a/src/renderer/main.css b/src/renderer/main.css
index 0f9708a..561edad 100644
--- a/src/renderer/main.css
+++ b/src/renderer/main.css
@@ -2,6 +2,18 @@
   --font-sans: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
   --font-mono: 'SF Mono', 'Fira Code', 'Consolas', monospace;
 
+  --text-xs: 0.6rem;
+  --text-sm: 0.75rem;
+  --text-base: 0.9rem;
+  --text-md: 1rem;
+  --text-lg: 1.25rem;
+  --text-xl: 1.75rem;
+
+  --weight-normal: 400;
+  --weight-medium: 500;
+  --weight-semibold: 600;
+  --weight-bold: 700;
+
   --bg-gradient-start: #0f0a1a;
   --bg-gradient-mid: #1a1030;
   --bg-gradient-end: #2d1f4e;
@@ -16,7 +28,7 @@
 
   --text-primary: #ffffff;
   --text-secondary: rgba(255, 255, 255, 0.7);
-  --text-tertiary: rgba(255, 255, 255, 0.5);
+  --text-tertiary: rgba(255, 255, 255, 0.65);
   --text-muted: rgba(255, 255, 255, 0.35);
 
   --accent: #8b5cf6;
@@ -26,13 +38,24 @@
   --accent-subtle: rgba(139, 92, 246, 0.15);
 
   --success: #22c55e;
+  --success-light: #34d399;
   --success-subtle: rgba(34, 197, 94, 0.15);
   --warning: #f59e0b;
+  --warning-light: #fbbf24;
+  --warning-dark: #d97706;
   --warning-subtle: rgba(245, 158, 11, 0.15);
   --danger: #ef4444;
   --danger-subtle: rgba(239, 68, 68, 0.15);
 
+  --overlay-bg: rgba(0, 0, 0, 0.5);
+  --overlay-bg-heavy: rgba(0, 0, 0, 0.6);
+  --sidebar-bg-start: rgba(20, 15, 35, 0.98);
+  --sidebar-bg-end: rgba(15, 10, 26, 0.98);
+  --modal-bg-start: rgba(30, 25, 50, 0.98);
+  --modal-bg-end: rgba(20, 15, 35, 0.98);
   --console-bg: rgba(0, 0, 0, 0.4);
+  --console-header-bg: rgba(0, 0, 0, 0.3);
+  --console-header-hover-bg: rgba(0, 0, 0, 0.4);
   --console-text: #4ade80;
 
   --spacing-xs: 0.25rem;
@@ -46,6 +69,7 @@
   --radius-md: 10px;
   --radius-lg: 16px;
   --radius-xl: 24px;
+  --radius-full: 50%;
 
   --shadow-sm: 0 2px 8px rgba(0, 0, 0, 0.2);
   --shadow-md: 0 4px 16px rgba(0, 0, 0, 0.3);
@@ -56,6 +80,31 @@
   --transition-normal: 250ms ease;
   --transition-slow: 400ms cubic-bezier(0.16, 1, 0.3, 1);
 
+  --blur-sm: 4px;
+  --blur-md: 8px;
+  --blur-lg: 20px;
+
+  --icon-btn-size: 40px;
+  --icon-btn-size-sm: 36px;
+  --icon-btn-size-xs: 28px;
+  --toggle-width: 44px;
+  --toggle-height: 24px;
+  --toggle-dot: 18px;
+  --toggle-sm-width: 36px;
+  --toggle-sm-height: 20px;
+  --toggle-sm-dot: 14px;
+  --progress-bar-height: 8px;
+  --console-height: 150px;
+  --download-card-max-width: 640px;
+  --modal-max-width: 440px;
+  --licenses-max-width: 900px;
+  --scrollbar-width: 6px;
+
+  --z-sidebar-overlay: 998;
+  --z-sidebar: 999;
+  --z-modal: 1000;
+  --z-update-banner: 100;
+
   --sidebar-width: 320px;
 }
 
@@ -107,12 +156,12 @@ body.animate-bg {
 .sidebar-overlay {
   position: fixed;
   inset: 0;
-  background: rgba(0, 0, 0, 0.5);
-  backdrop-filter: blur(4px);
+  background: var(--overlay-bg);
+  backdrop-filter: blur(var(--blur-sm));
   opacity: 0;
   visibility: hidden;
   transition: var(--transition-normal);
-  z-index: 998;
+  z-index: var(--z-sidebar-overlay);
 }
 
 .sidebar-overlay.active {
@@ -126,12 +175,12 @@ body.animate-bg {
   left: 0;
   width: var(--sidebar-width);
   height: 100vh;
-  background: linear-gradient(180deg, rgba(20, 15, 35, 0.98) 0%, rgba(15, 10, 26, 0.98) 100%);
-  backdrop-filter: blur(20px);
+  background: linear-gradient(180deg, var(--sidebar-bg-start) 0%, var(--sidebar-bg-end) 100%);
+  backdrop-filter: blur(var(--blur-lg));
   border-right: 1px solid var(--border-subtle);
   transform: translateX(-100%);
   transition: transform var(--transition-slow);
-  z-index: 999;
+  z-index: var(--z-sidebar);
   display: flex;
   flex-direction: column;
   box-shadow: var(--shadow-lg);
@@ -150,14 +199,14 @@ body.animate-bg {
 }
 
 .sidebar-header h2 {
-  font-size: 1.25rem;
-  font-weight: 600;
+  font-size: var(--text-lg);
+  font-weight: var(--weight-semibold);
   color: var(--text-primary);
 }
 
 .sidebar-close {
-  width: 36px;
-  height: 36px;
+  width: var(--icon-btn-size-sm);
+  height: var(--icon-btn-size-sm);
   display: flex;
   align-items: center;
   justify-content: center;
@@ -182,7 +231,7 @@ body.animate-bg {
 }
 
 .sidebar-content::-webkit-scrollbar {
-  width: 6px;
+  width: var(--scrollbar-width);
 }
 
 .sidebar-content::-webkit-scrollbar-track {
@@ -204,7 +253,7 @@ body.animate-bg {
 
 .settings-section-title {
   font-size: 0.7rem;
-  font-weight: 600;
+  font-weight: var(--weight-semibold);
   text-transform: uppercase;
   letter-spacing: 0.08em;
   color: var(--text-tertiary);
@@ -238,8 +287,8 @@ body.animate-bg {
 
 .toggle-slider {
   position: relative;
-  width: 44px;
-  height: 24px;
+  width: var(--toggle-width);
+  height: var(--toggle-height);
   background: var(--surface-3);
   border-radius: 12px;
   flex-shrink: 0;
@@ -251,10 +300,10 @@ body.animate-bg {
   position: absolute;
   top: 3px;
   left: 3px;
-  width: 18px;
-  height: 18px;
+  width: var(--toggle-dot);
+  height: var(--toggle-dot);
   background: var(--text-secondary);
-  border-radius: 50%;
+  border-radius: var(--radius-full);
   transition: var(--transition-fast);
 }
 
@@ -264,11 +313,11 @@ body.animate-bg {
 
 .toggle-switch input:checked + .toggle-slider::after {
   transform: translateX(20px);
-  background: white;
+  background: var(--text-primary);
 }
 
 .toggle-text {
-  font-size: 0.9rem;
+  font-size: var(--text-base);
   color: var(--text-secondary);
   display: flex;
   align-items: center;
@@ -280,13 +329,13 @@ body.animate-bg {
 }
 
 .toggle-switch.small .toggle-slider {
-  width: 36px;
-  height: 20px;
+  width: var(--toggle-sm-width);
+  height: var(--toggle-sm-height);
 }
 
 .toggle-switch.small .toggle-slider::after {
-  width: 14px;
-  height: 14px;
+  width: var(--toggle-sm-dot);
+  height: var(--toggle-sm-dot);
 }
 
 .toggle-switch.small input:checked + .toggle-slider::after {
@@ -294,7 +343,7 @@ body.animate-bg {
 }
 
 .toggle-switch.small .toggle-text {
-  font-size: 0.85rem;
+  font-size: var(--text-sm);
 }
 
 #keepOriginalLabel,
@@ -344,7 +393,7 @@ body.animate-bg {
 }
 
 .select-label span {
-  font-size: 0.8rem;
+  font-size: var(--text-sm);
   color: var(--text-tertiary);
 }
 
@@ -357,7 +406,7 @@ body.animate-bg {
   border: 1px solid var(--border-subtle);
   border-radius: var(--radius-sm);
   color: var(--text-primary);
-  font-size: 0.9rem;
+  font-size: var(--text-base);
   cursor: pointer;
   transition: var(--transition-fast);
 }
@@ -383,7 +432,7 @@ select option {
 
 .settings-hint {
   font-size: 0.78rem;
-  color: var(--text-muted);
+  color: var(--text-tertiary);
   margin-top: calc(var(--spacing-xs) * -1);
   margin-bottom: var(--spacing-sm);
   padding-left: var(--spacing-xs);
@@ -396,9 +445,9 @@ select option {
   width: 18px;
   height: 18px;
   background: var(--accent-subtle);
-  border-radius: 50%;
+  border-radius: var(--radius-full);
   font-size: 0.7rem;
-  font-weight: 600;
+  font-weight: var(--weight-semibold);
   color: var(--accent-light);
   text-decoration: none;
   transition: var(--transition-fast);
@@ -406,7 +455,7 @@ select option {
 
 .help-icon:hover {
   background: var(--accent);
-  color: white;
+  color: var(--text-primary);
 }
 
 .settings-link-btn {
@@ -414,7 +463,7 @@ select option {
   border: 1px solid var(--border-subtle);
   border-radius: var(--radius-sm);
   color: var(--text-secondary);
-  font-size: 0.8rem;
+  font-size: var(--text-sm);
   cursor: pointer;
   padding: var(--spacing-xs) var(--spacing-sm);
   margin-left: var(--spacing-md);
@@ -438,7 +487,7 @@ select option {
   border: 1px solid var(--border-subtle);
   border-radius: var(--radius-md);
   color: var(--text-secondary);
-  font-size: 0.9rem;
+  font-size: var(--text-base);
   cursor: pointer;
   transition: var(--transition-fast);
   margin-bottom: var(--spacing-sm);
@@ -472,14 +521,14 @@ select option {
   border-radius: var(--radius-md);
   color: var(--danger);
   font-size: 0.85rem;
-  font-weight: 500;
+  font-weight: var(--weight-medium);
   cursor: pointer;
   transition: var(--transition-fast);
 }
 
 .reset-btn:hover {
   background: var(--danger);
-  color: white;
+  color: var(--text-primary);
 }
 
 .version-info {
@@ -492,7 +541,7 @@ select option {
 }
 
 .version-info a {
-  font-size: 0.8rem;
+  font-size: var(--text-sm);
   color: var(--text-muted);
   text-decoration: none;
   transition: var(--transition-fast);
@@ -503,23 +552,23 @@ select option {
 }
 
 .version-info a.beta-version {
-  color: #f59e0b;
+  color: var(--warning);
 }
 
 .version-info a.beta-version:hover {
-  color: #fbbf24;
+  color: var(--warning-light);
 }
 
 .beta-badge {
   display: inline-block;
-  font-size: 0.6rem;
-  font-weight: 700;
+  font-size: var(--text-xs);
+  font-weight: var(--weight-bold);
   letter-spacing: 0.05em;
   text-transform: uppercase;
   padding: 1px 6px;
   border-radius: 4px;
-  background: linear-gradient(135deg, #f59e0b, #d97706);
-  color: #fff;
+  background: linear-gradient(135deg, var(--warning), var(--warning-dark));
+  color: var(--text-primary);
   line-height: 1.4;
 }
 
@@ -541,8 +590,8 @@ select option {
 }
 
 .icon-btn {
-  width: 40px;
-  height: 40px;
+  width: var(--icon-btn-size);
+  height: var(--icon-btn-size);
   display: flex;
   align-items: center;
   justify-content: center;
@@ -574,8 +623,8 @@ select option {
 }
 
 .app-name {
-  font-size: 1.25rem;
-  font-weight: 700;
+  font-size: var(--text-lg);
+  font-weight: var(--weight-bold);
 }
 
 .char-white {
@@ -605,8 +654,8 @@ select option {
 }
 
 .top-bar-links a {
-  width: 36px;
-  height: 36px;
+  width: var(--icon-btn-size-sm);
+  height: var(--icon-btn-size-sm);
   display: flex;
   align-items: center;
   justify-content: center;
@@ -631,7 +680,7 @@ select option {
 
 .download-card {
   width: 100%;
-  max-width: 640px;
+  max-width: var(--download-card-max-width);
   padding: var(--spacing-2xl);
   background: var(--surface-1);
   border: 1px solid var(--border-subtle);
@@ -640,14 +689,11 @@ select option {
 }
 
 .download-title {
-  font-size: 1.75rem;
-  font-weight: 700;
+  font-size: var(--text-xl);
+  font-weight: var(--weight-bold);
   text-align: center;
   margin-bottom: var(--spacing-sm);
-  background: linear-gradient(135deg, var(--text-primary), var(--accent-light));
-  -webkit-background-clip: text;
-  -webkit-text-fill-color: transparent;
-  background-clip: text;
+  color: var(--text-primary);
 }
 
 .download-subtitle {
@@ -683,7 +729,7 @@ select option {
   border: 2px solid var(--border-subtle);
   border-radius: var(--radius-lg);
   color: var(--text-primary);
-  font-size: 1rem;
+  font-size: var(--text-md);
   transition: var(--transition-fast);
 }
 
@@ -701,8 +747,8 @@ select option {
 .clear-btn {
   position: absolute;
   right: var(--spacing-sm);
-  width: 28px;
-  height: 28px;
+  width: var(--icon-btn-size-xs);
+  height: var(--icon-btn-size-xs);
   display: flex;
   align-items: center;
   justify-content: center;
@@ -727,9 +773,9 @@ select option {
   background: linear-gradient(135deg, var(--accent), var(--accent-dark));
   border: none;
   border-radius: var(--radius-lg);
-  color: white;
-  font-size: 1rem;
-  font-weight: 600;
+  color: var(--text-primary);
+  font-size: var(--text-md);
+  font-weight: var(--weight-semibold);
   cursor: pointer;
   transition: var(--transition-fast);
   white-space: nowrap;
@@ -797,18 +843,18 @@ select option {
 }
 
 .progress-status {
-  font-size: 0.9rem;
+  font-size: var(--text-base);
   color: var(--text-secondary);
 }
 
 .progress-percent {
-  font-size: 0.9rem;
-  font-weight: 600;
+  font-size: var(--text-base);
+  font-weight: var(--weight-semibold);
   color: var(--accent-light);
 }
 
 .progress-bar-wrapper {
-  height: 8px;
+  height: var(--progress-bar-height);
   background: var(--surface-1);
   border-radius: 4px;
   overflow: hidden;
@@ -847,7 +893,7 @@ select option {
 
 .progress-details {
   margin-top: var(--spacing-sm);
-  font-size: 0.8rem;
+  font-size: var(--text-sm);
   color: var(--text-muted);
   text-align: center;
 }
@@ -877,7 +923,7 @@ select option {
   border: 1px solid var(--border-subtle);
   border-radius: var(--radius-md);
   color: var(--text-secondary);
-  font-size: 0.9rem;
+  font-size: var(--text-base);
   cursor: pointer;
   transition: var(--transition-fast);
   margin-bottom: var(--spacing-lg);
@@ -902,7 +948,7 @@ select option {
 }
 
 .format-select-label span {
-  font-size: 0.8rem;
+  font-size: var(--text-sm);
   color: var(--text-tertiary);
 }
 
@@ -913,7 +959,7 @@ select option {
   border: 1px solid var(--border-subtle);
   border-radius: var(--radius-sm);
   color: var(--text-primary);
-  font-size: 0.9rem;
+  font-size: var(--text-base);
   cursor: pointer;
   transition: var(--transition-fast);
 }
@@ -944,7 +990,7 @@ select option {
   align-items: center;
   justify-content: space-between;
   padding: var(--spacing-sm) var(--spacing-md);
-  background: rgba(0, 0, 0, 0.3);
+  background: var(--console-header-bg);
   border-bottom: 1px solid var(--border-subtle);
   cursor: pointer;
   user-select: none;
@@ -952,7 +998,7 @@ select option {
 }
 
 .console-header:hover {
-  background: rgba(0, 0, 0, 0.4);
+  background: var(--console-header-hover-bg);
 }
 
 .console-header-left {
@@ -976,7 +1022,7 @@ select option {
   display: flex;
   align-items: center;
   gap: var(--spacing-sm);
-  font-size: 0.8rem;
+  font-size: var(--text-sm);
   color: var(--text-tertiary);
 }
 
@@ -985,8 +1031,8 @@ select option {
 }
 
 .console-clear-btn {
-  width: 28px;
-  height: 28px;
+  width: var(--icon-btn-size-xs);
+  height: var(--icon-btn-size-xs);
   display: flex;
   align-items: center;
   justify-content: center;
@@ -1004,10 +1050,10 @@ select option {
 }
 
 .console-output {
-  height: 150px;
+  height: var(--console-height);
   padding: var(--spacing-md);
   font-family: var(--font-mono);
-  font-size: 0.8rem;
+  font-size: var(--text-sm);
   color: var(--console-text);
   overflow-y: auto;
   white-space: pre-wrap;
@@ -1044,7 +1090,7 @@ select option {
   justify-content: center;
   gap: var(--spacing-md);
   padding: var(--spacing-md);
-  font-size: 0.8rem;
+  font-size: var(--text-sm);
   color: var(--text-muted);
 }
 
@@ -1072,9 +1118,9 @@ select option {
   display: none;
   align-items: center;
   justify-content: center;
-  background: rgba(0, 0, 0, 0.6);
-  backdrop-filter: blur(8px);
-  z-index: 1000;
+  background: var(--overlay-bg-heavy);
+  backdrop-filter: blur(var(--blur-md));
+  z-index: var(--z-modal);
   opacity: 0;
   transition: opacity 0.2s ease;
 }
@@ -1094,9 +1140,9 @@ select option {
 
 .modal-box {
   width: 90%;
-  max-width: 440px;
+  max-width: var(--modal-max-width);
   padding: var(--spacing-xl);
-  background: linear-gradient(180deg, rgba(30, 25, 50, 0.98) 0%, rgba(20, 15, 35, 0.98) 100%);
+  background: linear-gradient(180deg, var(--modal-bg-start) 0%, var(--modal-bg-end) 100%);
   border: 1px solid var(--border-subtle);
   border-radius: var(--radius-xl);
   box-shadow: var(--shadow-lg), var(--shadow-glow);
@@ -1118,8 +1164,8 @@ select option {
 }
 
 .modal-box h3 {
-  font-size: 1.25rem;
-  font-weight: 600;
+  font-size: var(--text-lg);
+  font-weight: var(--weight-semibold);
   margin-bottom: var(--spacing-md);
   text-align: center;
 }
@@ -1150,8 +1196,8 @@ select option {
   border: 1px solid var(--border-subtle);
   border-radius: var(--radius-md);
   color: var(--text-secondary);
-  font-size: 0.9rem;
-  font-weight: 500;
+  font-size: var(--text-base);
+  font-weight: var(--weight-medium);
   cursor: pointer;
   transition: var(--transition-fast);
 }
@@ -1165,7 +1211,7 @@ select option {
 .modal-buttons button:first-child {
   background: linear-gradient(135deg, var(--accent), var(--accent-dark));
   border-color: transparent;
-  color: white;
+  color: var(--text-primary);
 }
 
 .modal-buttons button:first-child:hover {
@@ -1174,9 +1220,9 @@ select option {
 
 .licenses-container {
   width: 90%;
-  max-width: 900px;
+  max-width: var(--licenses-max-width);
   height: 80vh;
-  background: linear-gradient(180deg, rgba(30, 25, 50, 0.98) 0%, rgba(20, 15, 35, 0.98) 100%);
+  background: linear-gradient(180deg, var(--modal-bg-start) 0%, var(--modal-bg-end) 100%);
   border: 1px solid var(--border-subtle);
   border-radius: var(--radius-xl);
   box-shadow: var(--shadow-lg);
@@ -1195,13 +1241,13 @@ select option {
 
 .licenses-header h3 {
   font-size: 1.1rem;
-  font-weight: 600;
+  font-weight: var(--weight-semibold);
   margin: 0;
 }
 
 .modal-close-btn {
-  width: 36px;
-  height: 36px;
+  width: var(--icon-btn-size-sm);
+  height: var(--icon-btn-size-sm);
   display: flex;
   align-items: center;
   justify-content: center;
@@ -1240,13 +1286,13 @@ select option {
 
 .update-progress-bar {
   height: 100%;
-  background: linear-gradient(90deg, var(--success), #34d399);
+  background: linear-gradient(90deg, var(--success), var(--success-light));
   border-radius: 3px;
   transition: width 0.3s ease;
 }
 
 .update-progress-info {
-  font-size: 0.8rem;
+  font-size: var(--text-sm);
   color: var(--text-muted);
   text-align: center;
 }
@@ -1259,7 +1305,7 @@ select option {
   background: var(--surface-1);
   border-top: 1px solid var(--border-subtle);
   padding: var(--spacing-sm) var(--spacing-xl);
-  z-index: 100;
+  z-index: var(--z-update-banner);
   transform: translateY(100%);
   transition: transform 0.3s ease;
   pointer-events: none;
@@ -1280,7 +1326,7 @@ select option {
   font-size: 0.85rem;
   color: var(--text-secondary);
   white-space: nowrap;
-  font-weight: 500;
+  font-weight: var(--weight-medium);
 }
 
 .update-banner-progress {
@@ -1294,14 +1340,14 @@ select option {
 
 .update-banner-bar {
   height: 100%;
-  background: linear-gradient(90deg, var(--success), #34d399);
+  background: linear-gradient(90deg, var(--success), var(--success-light));
   border-radius: 2px;
   transition: width 0.3s ease;
   width: 0%;
 }
 
 .update-banner-info {
-  font-size: 0.8rem;
+  font-size: var(--text-sm);
   color: var(--text-muted);
   white-space: nowrap;
 }
@@ -1312,7 +1358,7 @@ select option {
   color: var(--text-secondary);
   padding: var(--spacing-xs) var(--spacing-sm);
   border-radius: var(--radius-sm);
-  font-size: 0.8rem;
+  font-size: var(--text-sm);
   cursor: pointer;
   white-space: nowrap;
   transition: var(--transition-fast);
@@ -1339,6 +1385,34 @@ select option {
   border: 0;
 }
 
+:focus-visible {
+  outline: 2px solid var(--accent);
+  outline-offset: 2px;
+}
+
+.icon-btn:focus-visible,
+.download-btn:focus-visible,
+.settings-btn:focus-visible,
+.reset-btn:focus-visible,
+.modal-buttons button:focus-visible,
+.fetch-formats-btn:focus-visible,
+.settings-link-btn:focus-visible,
+.update-banner-cancel:focus-visible,
+.modal-close-btn:focus-visible,
+.sidebar-close:focus-visible,
+.console-clear-btn:focus-visible,
+.clear-btn:focus-visible {
+  outline: 2px solid var(--accent);
+  outline-offset: 2px;
+  box-shadow: 0 0 0 4px var(--accent-subtle);
+}
+
+.toggle-switch:focus-within {
+  outline: 2px solid var(--accent);
+  outline-offset: 2px;
+  box-shadow: 0 0 0 4px var(--accent-subtle);
+}
+
 /* Responsive adjustments for smaller windows */
 @media (max-height: 800px) {
   .download-section {
@@ -1360,3 +1434,13 @@ select option {
     height: 100px;
   }
 }
+
+@media (prefers-reduced-motion: reduce) {
+  *,
+  *::before,
+  *::after {
+    animation-duration: 0.01ms !important;
+    animation-iteration-count: 1 !important;
+    transition-duration: 0.01ms !important;
+  }
+}
diff --git a/src/renderer/msStoreDetector.js b/src/renderer/msStoreDetector.js
index 200d799..f1798db 100644
--- a/src/renderer/msStoreDetector.js
+++ b/src/renderer/msStoreDetector.js
@@ -9,7 +9,5 @@
         }
       }
     }
-  } catch (e) {
-    // Silently ignore — detection is best-effort and non-critical
-  }
+  } catch (e) {}
 })();
diff --git a/src/renderer/rosiEngine.js b/src/renderer/rosiEngine.js
index fafb3b1..9be579f 100644
--- a/src/renderer/rosiEngine.js
+++ b/src/renderer/rosiEngine.js
@@ -47,9 +47,12 @@ function appendConsoleOutput(outputEl, text) {
 // Toggle console collapsed state
 function toggleConsoleCollapse() {
   const consoleSection = document.getElementById('console-section');
+  const consoleHeader = document.getElementById('consoleHeader');
   if (consoleSection) {
     consoleSection.classList.toggle('collapsed');
-    return consoleSection.classList.contains('collapsed');
+    const isCollapsed = consoleSection.classList.contains('collapsed');
+    if (consoleHeader) consoleHeader.setAttribute('aria-expanded', String(!isCollapsed));
+    return isCollapsed;
   }
   return false;
 }
@@ -87,9 +90,13 @@ function toggleSidebar() {
   if (isOpen) {
     sidebar.classList.remove('open');
     if (overlay) overlay.classList.remove('active');
+    const settingsBtn = document.getElementById('settingsBtn');
+    if (settingsBtn) settingsBtn.focus();
   } else {
     sidebar.classList.add('open');
     if (overlay) overlay.classList.add('active');
+    const closeBtn = document.getElementById('closeSidebar');
+    if (closeBtn) closeBtn.focus();
   }
 }
 
@@ -98,6 +105,8 @@ function closeSidebar() {
   const overlay = document.getElementById('sidebar-overlay');
   if (sidebar) sidebar.classList.remove('open');
   if (overlay) overlay.classList.remove('active');
+  const settingsBtn = document.getElementById('settingsBtn');
+  if (settingsBtn) settingsBtn.focus();
 }
 function toggleAdvancedUI(show) {
   const formatSection = document.getElementById('formatOptions');
@@ -113,7 +122,9 @@ function toggleAdvancedUI(show) {
 // Modal queue system
 const modalQueue = [];
 let isModalActive = false;
-let currentModalData = null; // Track modals
+let currentModalData = null;
+let previousFocus = null;
+let modalTrapHandler = null;
 
 function showModal({ title, message, buttons = [], priority = false, extra = null }) {
   const modalData = { title, message, buttons, priority, extra };
@@ -187,19 +198,56 @@ function displayNextModal() {
     };
     btnContainer.appendChild(btn);
   });
+
+  previousFocus = document.activeElement;
+
+  if (modalTrapHandler) {
+    modal.removeEventListener('keydown', modalTrapHandler);
+  }
+  modalTrapHandler = (e) => {
+    if (e.key !== 'Tab') return;
+    const focusable = modal.querySelectorAll('button');
+    if (focusable.length === 0) return;
+    const first = focusable[0];
+    const last = focusable[focusable.length - 1];
+    if (e.shiftKey) {
+      if (document.activeElement === first) {
+        e.preventDefault();
+        last.focus();
+      }
+    } else {
+      if (document.activeElement === last) {
+        e.preventDefault();
+        first.focus();
+      }
+    }
+  };
+  modal.addEventListener('keydown', modalTrapHandler);
+
+  requestAnimationFrame(() => {
+    const firstBtn = btnContainer.querySelector('button');
+    if (firstBtn) firstBtn.focus();
+  });
 }
 
 function hideModal(modal, action) {
   modal.classList.add('hiding');
-  currentModalData = null; // Clear current modal data
+  currentModalData = null;
+  if (modalTrapHandler) {
+    modal.removeEventListener('keydown', modalTrapHandler);
+    modalTrapHandler = null;
+  }
   setTimeout(() => {
     modal.classList.remove('active', 'hiding');
-    isModalActive = false; // Reset before action
+    isModalActive = false;
     if (typeof action === 'function') action();
-    // display next action if previous modal is done
     if (!isModalActive) {
       displayNextModal();
     }
+    if (!isModalActive && previousFocus && typeof previousFocus.focus === 'function') {
+      previousFocus.focus();
+      previousFocus = null;
+    }
   }, 200);
 }
 
@@ -536,7 +584,7 @@ function setupAutoUpdater() {
         case 'checking':
           break;
 
-        case 'available':
+        case 'available': {
           updateVersion = data.version;
           const wasManualCheck = isManualUpdateCheck;
           isManualUpdateCheck = false;
@@ -559,6 +607,7 @@ function setupAutoUpdater() {
             ],
           });
           break;
+        }
 
         case 'not-available':
           if (isManualUpdateCheck) {
@@ -646,21 +695,56 @@ function cleanupUpdaterListeners() {
   updaterCleanupFunctions = [];
 }
 
+let licensesPreviousFocus = null;
+let licensesTrapHandler = null;
+
 function showLicenses() {
   const licensesOverlay = document.getElementById('licenses-overlay');
   if (licensesOverlay) {
+    licensesPreviousFocus = document.activeElement;
     licensesOverlay.classList.add('active');
     document.body.style.overflow = 'hidden';
+
+    const closeBtn = licensesOverlay.querySelector('#close-licenses');
+    if (closeBtn) {
+      requestAnimationFrame(() => closeBtn.focus());
+    }
+
+    licensesTrapHandler = (e) => {
+      if (e.key !== 'Tab') return;
+      const focusable = licensesOverlay.querySelectorAll(
+        'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
+      );
+      if (focusable.length === 0) return;
+      const first = focusable[0];
+      const last = focusable[focusable.length - 1];
+      if (e.shiftKey && document.activeElement === first) {
+        e.preventDefault();
+        last.focus();
+      } else if (!e.shiftKey && document.activeElement === last) {
+        e.preventDefault();
+        first.focus();
+      }
+    };
+    licensesOverlay.addEventListener('keydown', licensesTrapHandler);
   }
 }
 
 function hideLicenses() {
   const licensesOverlay = document.getElementById('licenses-overlay');
   if (licensesOverlay) {
+    if (licensesTrapHandler) {
+      licensesOverlay.removeEventListener('keydown', licensesTrapHandler);
+      licensesTrapHandler = null;
+    }
     licensesOverlay.classList.remove('active');
     setTimeout(() => {
       document.body.style.overflow = '';
     }, 300);
+    if (licensesPreviousFocus) {
+      licensesPreviousFocus.focus();
+      licensesPreviousFocus = null;
+    }
   }
 }
 
@@ -740,7 +824,7 @@ async function checkDenoInstallation(settings) {
             label: "No, don't remind me",
             action: () => {
               settings.denoReminderDismissed = true;
-              window.api.saveSettings(settings);
+              void persistSettings();
             },
           },
         ],
@@ -757,6 +841,7 @@ document.addEventListener('DOMContentLoaded', async () => {
     settings = await window.api.getSettings();
   } catch (error) {
     settings = {
+      settingsVersion: 1,
       showConsoleOutput: false,
       advancedOptions: false,
       convertEnabled: false,
@@ -797,7 +882,7 @@ document.addEventListener('DOMContentLoaded', async () => {
       const isBeta = /-(beta|alpha|rc)/i.test(version);
       if (isBeta) {
         versionLink.classList.add('beta-version');
-        if (betaBadge) betaBadge.style.display = '';
+        if (betaBadge) betaBadge.classList.remove('hidden');
       }
     }
   } catch (e) {
@@ -809,6 +894,41 @@ document.addEventListener('DOMContentLoaded', async () => {
   } catch (e) {
     console.error('Failed to setup auto-updater:', e);
   }
+  let settingsSaveErrorShownAt = 0;
+
+  function showSettingsSaveError(message) {
+    const now = Date.now();
+    if (now - settingsSaveErrorShownAt < 5000) {
+      return;
+    }
+    settingsSaveErrorShownAt = now;
+    showModal({
+      title: 'Settings Save Failed',
+      message,
+      buttons: [{ label: 'OK' }],
+      priority: true,
+    });
+  }
+
+  async function persistSettings(silent = false) {
+    try {
+      const result = await window.api.saveSettings(settings);
+      if (!result || result.ok !== true) {
+        if (!silent) {
+          const message = result?.error?.message || 'Could not save settings.';
+          showSettingsSaveError(`${message}\nChanges may not persist after restart.`);
+        }
+        return false;
+      }
+      settings = result.data;
+      return true;
+    } catch (_error) {
+      if (!silent) {
+        showSettingsSaveError('Could not save settings due to an unexpected error.');
+      }
+      return false;
+    }
+  }
 
   const consoleToggle = document.getElementById('consoleToggle');
   const advancedToggle = document.getElementById('advancedToggle');
@@ -867,7 +987,7 @@ document.addEventListener('DOMContentLoaded', async () => {
     browserChoiceSelect.value = 'Firefox';
     if (settings.browserChoice !== 'Firefox') {
       settings.browserChoice = 'Firefox';
-      window.api.saveSettings(settings);
+      void persistSettings();
     }
   }
 
@@ -935,7 +1055,9 @@ document.addEventListener('DOMContentLoaded', async () => {
     // Restore console collapsed state
     if (settings.consoleCollapsed) {
       const consoleSection = document.getElementById('console-section');
+      const consoleHeaderEl = document.getElementById('consoleHeader');
       if (consoleSection) consoleSection.classList.add('collapsed');
+      if (consoleHeaderEl) consoleHeaderEl.setAttribute('aria-expanded', 'false');
     }
 
     toggleAdvancedUI(settings.advancedOptions);
@@ -991,15 +1113,15 @@ document.addEventListener('DOMContentLoaded', async () => {
     if (checkUpdatesOnStartupToggle) {
       checkUpdatesOnStartupToggle.checked = settings.checkUpdatesOnStartup ?? true;
       if (channel === 'msstore' && checkUpdatesOnStartupLabel) {
-        checkUpdatesOnStartupLabel.style.display = 'none';
+        checkUpdatesOnStartupLabel.classList.add('hidden');
       }
     }
 
     if (updateChannelSelect) {
       updateChannelSelect.value = settings.updateChannel ?? 'auto';
       if (channel === 'msstore') {
-        if (updateChannelContainer) updateChannelContainer.style.display = 'none';
-        if (showUpdateChannelBtn) showUpdateChannelBtn.style.display = 'none';
+        if (updateChannelContainer) updateChannelContainer.classList.add('hidden');
+        if (showUpdateChannelBtn) showUpdateChannelBtn.classList.add('hidden');
       }
     }
   };
@@ -1021,14 +1143,14 @@ document.addEventListener('DOMContentLoaded', async () => {
           action: () => {
             window.api.openExternal('https://rosie.run/support');
             settings.hideSupportModal = true;
-            window.api.saveSettings(settings);
+            void persistSettings();
           },
         },
         {
           label: 'No thanks',
           action: () => {
             settings.hideSupportModal = true;
-            window.api.saveSettings(settings);
+            void persistSettings();
           },
         },
       ],
@@ -1054,7 +1176,7 @@ document.addEventListener('DOMContentLoaded', async () => {
   bindExternalLink(helpLink, 'https://help.rosie.run/rosi/en-us/faq');
   bindExternalLink(supportLink, 'https://rosie.run/support');
   bindExternalLink(websiteLink, 'https://rosie.run');
-  bindExternalLink(supportProjectLink, 'https://rosie.run');
+  bindExternalLink(supportProjectLink, 'https://rosie.run/support');
 
   if (licensesLink) {
     licensesLink.addEventListener('click', (event) => {
@@ -1067,12 +1189,12 @@ document.addEventListener('DOMContentLoaded', async () => {
     clearUrlBtn.addEventListener('click', () => {
       urlInput.value = '';
       urlInput.focus();
-      clearUrlBtn.style.display = 'none';
+      clearUrlBtn.classList.add('hidden');
     });
     urlInput.addEventListener('input', () => {
-      clearUrlBtn.style.display = urlInput.value.length > 0 ? 'flex' : 'none';
+      clearUrlBtn.classList.toggle('hidden', urlInput.value.length === 0);
     });
-    clearUrlBtn.style.display = urlInput.value.length > 0 ? 'flex' : 'none';
+    clearUrlBtn.classList.toggle('hidden', urlInput.value.length === 0);
   }
 
   if (clearConsoleBtn && outputEl) {
@@ -1084,7 +1206,7 @@ document.addEventListener('DOMContentLoaded', async () => {
   if (consoleToggle)
     consoleToggle.addEventListener('change', (e) => {
       settings.showConsoleOutput = e.target.checked;
-      window.api.saveSettings(settings);
+      void persistSettings();
       updateConsoleVisibility(settings.showConsoleOutput);
     });
 
@@ -1092,12 +1214,19 @@ document.addEventListener('DOMContentLoaded', async () => {
   const consoleHeader = document.getElementById('consoleHeader');
   if (consoleHeader) {
     consoleHeader.addEventListener('click', (e) => {
-      // Don't collapse if clicking the clear button
       if (e.target.closest('#clearConsole')) return;
-
       const isCollapsed = toggleConsoleCollapse();
       settings.consoleCollapsed = isCollapsed;
-      window.api.saveSettings(settings);
+      void persistSettings();
+    });
+    consoleHeader.addEventListener('keydown', (e) => {
+      if (e.key === 'Enter' || e.key === ' ') {
+        e.preventDefault();
+        if (e.target.closest('#clearConsole')) return;
+        const isCollapsed = toggleConsoleCollapse();
+        settings.consoleCollapsed = isCollapsed;
+        void persistSettings();
+      }
     });
   }
 
@@ -1140,13 +1269,13 @@ document.addEventListener('DOMContentLoaded', async () => {
         }
       }
 
-      window.api.saveSettings(settings);
+      void persistSettings();
     });
   if (keepOriginalToggle)
     keepOriginalToggle.addEventListener('change', (e) => {
       if (!e.target.disabled) {
         settings.keepOriginalAfterConvert = e.target.checked;
-        window.api.saveSettings(settings);
+        void persistSettings();
       } else {
         e.preventDefault();
       }
@@ -1161,12 +1290,12 @@ document.addEventListener('DOMContentLoaded', async () => {
           browserChoiceContainer.classList.remove('visible');
         }
       }
-      window.api.saveSettings(settings);
+      void persistSettings();
     });
   if (browserChoiceSelect)
     browserChoiceSelect.addEventListener('change', (e) => {
       settings.browserChoice = e.target.value;
-      window.api.saveSettings(settings);
+      void persistSettings();
     });
   if (convertToggle)
     convertToggle.addEventListener('change', (e) => {
@@ -1185,12 +1314,12 @@ document.addEventListener('DOMContentLoaded', async () => {
         settings.keepOriginalAfterConvert = true;
         if (keepOriginalToggle) keepOriginalToggle.checked = true;
       }
-      window.api.saveSettings(settings);
+      void persistSettings();
     });
   if (convertFormatSelect)
     convertFormatSelect.addEventListener('change', (e) => {
       settings.convertFormat = e.target.value;
-      window.api.saveSettings(settings);
+      void persistSettings();
     });
   if (ffmpegPathInput) {
     ffmpegPathInput.addEventListener('input', (e) => {
@@ -1198,7 +1327,7 @@ document.addEventListener('DOMContentLoaded', async () => {
     });
     ffmpegPathInput.addEventListener('change', (e) => {
       settings.ffmpegPath = e.target.value;
-      window.api.saveSettings(settings);
+      void persistSettings();
     });
   }
   // GPU acceleration toggle
@@ -1212,13 +1341,13 @@ document.addEventListener('DOMContentLoaded', async () => {
           gpuTypeContainer.classList.remove('visible');
         }
       }
-      window.api.saveSettings(settings);
+      void persistSettings();
     });
   }
   if (gpuTypeSelect) {
     gpuTypeSelect.addEventListener('change', (e) => {
       settings.gpuType = e.target.value;
-      window.api.saveSettings(settings);
+      void persistSettings();
     });
   }
   // Animate Background toggle
@@ -1226,14 +1355,14 @@ document.addEventListener('DOMContentLoaded', async () => {
     animateBackgroundToggle.addEventListener('change', (e) => {
       settings.animateBackground = e.target.checked;
       updateBackgroundAnimation(e.target.checked);
-      window.api.saveSettings(settings);
+      void persistSettings();
     });
   }
 
   if (bestQualityToggle) {
     bestQualityToggle.addEventListener('change', (e) => {
       settings.bestQuality = e.target.checked;
-      window.api.saveSettings(settings);
+      void persistSettings();
     });
   }
 
@@ -1271,7 +1400,7 @@ document.addEventListener('DOMContentLoaded', async () => {
         }
       }
 
-      window.api.saveSettings(settings);
+      void persistSettings();
     });
   }
 
@@ -1279,7 +1408,7 @@ document.addEventListener('DOMContentLoaded', async () => {
   if (notificationsToggle) {
     notificationsToggle.addEventListener('change', (e) => {
       settings.notifications = e.target.checked;
-      window.api.saveSettings(settings);
+      void persistSettings();
     });
   }
 
@@ -1287,7 +1416,7 @@ document.addEventListener('DOMContentLoaded', async () => {
   if (checkUpdatesOnStartupToggle) {
     checkUpdatesOnStartupToggle.addEventListener('change', (e) => {
       settings.checkUpdatesOnStartup = e.target.checked;
-      window.api.saveSettings(settings);
+      void persistSettings();
     });
   }
 
@@ -1304,7 +1433,7 @@ document.addEventListener('DOMContentLoaded', async () => {
   if (updateChannelSelect) {
     updateChannelSelect.addEventListener('change', (e) => {
       settings.updateChannel = e.target.value;
-      window.api.saveSettings(settings);
+      void persistSettings();
     });
   }
 
@@ -1406,7 +1535,7 @@ document.addEventListener('DOMContentLoaded', async () => {
         const audioFormat = settings.advancedOptions ? audioSelect.value : null;
         const convertFormat = settings.convertEnabled ? convertFormatSelect.value : null;
         const keepOriginal = settings.convertEnabled ? keepOriginalToggle.checked : null;
-        window.api.downloadVideo({
+        const startResult = await window.api.downloadVideo({
           url,
           videoFormat,
           audioFormat,
@@ -1415,6 +1544,17 @@ document.addEventListener('DOMContentLoaded', async () => {
           keepOriginal,
           ffmpegPath: settings.ffmpegPath,
         });
+        if (!startResult || startResult.ok !== true) {
+          isDownloading = false;
+          setButtonLoading(downloadBtn, false);
+          hideProgressBar();
+          showModal({
+            title: 'Download Validation Error',
+            message:
+              startResult?.error?.message || 'Download request was rejected before starting.',
+            buttons: [{ label: 'OK' }],
+          });
+        }
       } catch (downloadError) {
         console.error('Unexpected error starting download:', downloadError);
         isDownloading = false;
@@ -1539,11 +1679,7 @@ document.addEventListener('DOMContentLoaded', async () => {
       }
     });
     cleanupUpdaterListeners();
-
-    if (saveSettingsTimeout) {
-      clearTimeout(saveSettingsTimeout);
-      window.api.saveSettings(settings);
-    }
+    void persistSettings(true);
   });
 
   // Check for updates on startup
@@ -1566,7 +1702,7 @@ document.addEventListener('DOMContentLoaded', async () => {
   if (settings.firstLaunch) {
     // Save immediately - change
     settings.firstLaunch = false;
-    window.api.saveSettings(settings);
+    void persistSettings();
 
     showModal({
       title: 'Dependency FFMPEG is Required for this app.',
diff --git a/src/renderer/splash.html b/src/renderer/splash.html
index a43d307..e18526a 100644
--- a/src/renderer/splash.html
+++ b/src/renderer/splash.html
@@ -1,5 +1,5 @@
 <!doctype html>
-<html>
+<html lang="en">
   <head>
     <meta charset="UTF-8" />
     <meta
@@ -16,6 +16,7 @@
     <style>
       :root {
         --font-sans: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+        --font-mono: 'SF Mono', 'Fira Code', 'Consolas', monospace;
         --bg-gradient-start: #0f0a1a;
         --bg-gradient-mid: #1a1030;
         --bg-gradient-end: #2d1f4e;
@@ -28,6 +29,15 @@
         --surface-1: rgba(255, 255, 255, 0.03);
         --surface-2: rgba(255, 255, 255, 0.06);
         --border-subtle: rgba(255, 255, 255, 0.08);
+        --text-xl: 1.75rem;
+        --text-sm: 0.75rem;
+        --text-base: 0.9rem;
+        --weight-normal: 400;
+        --weight-bold: 700;
+        --spacing-sm: 0.5rem;
+        --spacing-xl: 2rem;
+        --spacing-2xl: 3rem;
+        --radius-full: 50%;
       }
 
       *,
@@ -80,12 +90,12 @@
         flex-direction: column;
         align-items: center;
         text-align: center;
-        padding: 2rem;
+        padding: var(--spacing-xl);
       }
 
       .logo-wrapper {
         position: relative;
-        margin-bottom: 2rem;
+        margin-bottom: var(--spacing-xl);
       }
 
       .logo {
@@ -103,7 +113,7 @@
         width: 180px;
         height: 180px;
         background: radial-gradient(circle, var(--accent-glow) 0%, transparent 70%);
-        border-radius: 50%;
+        border-radius: var(--radius-full);
         animation: glowPulse 3s ease-in-out infinite;
         z-index: -1;
       }
@@ -132,20 +142,17 @@
 
       .app-title {
         font-size: 2.5rem;
-        font-weight: 700;
+        font-weight: var(--weight-bold);
         letter-spacing: 0.1em;
-        margin-bottom: 0.5rem;
-        background: linear-gradient(135deg, var(--text-primary) 0%, var(--accent-light) 100%);
-        -webkit-background-clip: text;
-        -webkit-text-fill-color: transparent;
-        background-clip: text;
+        margin-bottom: var(--spacing-sm);
+        color: var(--text-primary);
       }
 
       .app-subtitle {
         font-size: 0.95rem;
         color: var(--text-secondary);
-        font-weight: 400;
-        margin-bottom: 2.5rem;
+        font-weight: var(--weight-normal);
+        margin-bottom: var(--spacing-2xl);
       }
 
       .loading-container {
@@ -198,7 +205,7 @@
         width: 6px;
         height: 6px;
         background: var(--accent);
-        border-radius: 50%;
+        border-radius: var(--radius-full);
         animation: dotBounce 1.4s ease-in-out infinite;
       }
 
@@ -229,11 +236,21 @@
         position: absolute;
         bottom: 1.5rem;
         right: 1.5rem;
-        font-size: 0.75rem;
-        font-family: 'SF Mono', 'Fira Code', 'Consolas', monospace;
+        font-size: var(--text-sm);
+        font-family: var(--font-mono);
         color: var(--text-muted);
         letter-spacing: 0.05em;
       }
+
+      @media (prefers-reduced-motion: reduce) {
+        *,
+        *::before,
+        *::after {
+          animation-duration: 0.01ms !important;
+          animation-iteration-count: 1 !important;
+          transition-duration: 0.01ms !important;
+        }
+      }
     </style>
   </head>
   <body>
@@ -248,6 +265,6 @@ <h1 class="app-title">ROSI</h1>
         <div class="loading-bar"></div>
       </div>
     </div>
-    <div class="version" id="version-display">v3.4.2</div>
+    <div class="version" id="version-display">v3.5.0</div>
   </body>
 </html>
diff --git a/src/tests/commandBuilders.test.ts b/src/tests/commandBuilders.test.ts
new file mode 100644
index 0000000..7769c4e
--- /dev/null
+++ b/src/tests/commandBuilders.test.ts
@@ -0,0 +1,110 @@
+import { describe, it, expect } from 'vitest';
+import {
+  buildFfmpegArgs,
+  buildYtdlpArgs,
+  resolveVideoEncoder,
+} from '../main/download/commandBuilders';
+import type { Settings } from '../types';
+
+function createSettings(overrides: Partial<Settings> = {}): Settings {
+  return {
+    settingsVersion: 1,
+    showConsoleOutput: false,
+    consoleCollapsed: false,
+    advancedOptions: false,
+    audioOnly: false,
+    convertEnabled: false,
+    convertFormat: 'mp4',
+    keepOriginalAfterConvert: true,
+    firstLaunch: false,
+    hookBrowser: false,
+    browserChoice: 'Chrome',
+    animateBackground: true,
+    notifications: true,
+    denoReminderDismissed: false,
+    gpuAcceleration: false,
+    gpuType: 'auto',
+    bestQuality: false,
+    ffmpegPath: '',
+    hideSupportModal: false,
+    checkUpdatesOnStartup: true,
+    updateChannel: 'auto',
+    ...overrides,
+  };
+}
+
+describe('command builders', () => {
+  it('resolves GPU encoder based on settings', () => {
+    expect(resolveVideoEncoder(createSettings({ gpuAcceleration: false }))).toBe('copy');
+    expect(resolveVideoEncoder(createSettings({ gpuAcceleration: true, gpuType: 'nvidia' }))).toBe(
+      'h264_nvenc'
+    );
+    expect(resolveVideoEncoder(createSettings({ gpuAcceleration: true, gpuType: 'amd' }))).toBe(
+      'h264_amf'
+    );
+    expect(resolveVideoEncoder(createSettings({ gpuAcceleration: true, gpuType: 'intel' }))).toBe(
+      'h264_qsv'
+    );
+  });
+
+  it('builds ffmpeg args for audio extraction', () => {
+    const args = buildFfmpegArgs('input.mp4', 'output.mp3', 'mp3', 'copy');
+    expect(args).toEqual(['-i', 'input.mp4', '-vn', '-c:a', 'libmp3lame', '-y', 'output.mp3']);
+  });
+
+  it('builds ffmpeg args for video conversion', () => {
+    const args = buildFfmpegArgs('input.webm', 'output.mp4', 'mp4', 'h264_nvenc');
+    expect(args).toEqual([
+      '-i',
+      'input.webm',
+      '-c:v',
+      'h264_nvenc',
+      '-c:a',
+      'aac',
+      '-movflags',
+      '+faststart',
+      '-y',
+      'output.mp4',
+    ]);
+  });
+
+  it('builds yt-dlp args for selected audio/video formats', () => {
+    const result = buildYtdlpArgs({
+      normalizedDownloadDir: '/tmp/downloads',
+      url: 'https://example.com/video',
+      settings: createSettings({ hookBrowser: true, browserChoice: 'Firefox' }),
+      options: {
+        url: 'https://example.com/video',
+        outputPath: '/tmp/downloads',
+        videoFormat: '137',
+        audioFormat: '140',
+      },
+      ffmpegLocation: '/usr/bin/ffmpeg',
+    });
+
+    expect(result.args).toContain('--ffmpeg-location');
+    expect(result.args).toContain('/usr/bin/ffmpeg');
+    expect(result.args).toContain('--cookies-from-browser');
+    expect(result.args).toContain('Firefox');
+    expect(result.args).toContain('137+140');
+    expect(result.statusMessages).toContain('📹 Using formats: video=137, audio=140');
+  });
+
+  it('builds yt-dlp args for audio-only mode when no format override is provided', () => {
+    const result = buildYtdlpArgs({
+      normalizedDownloadDir: '/tmp/downloads',
+      url: 'https://example.com/video',
+      settings: createSettings({ audioOnly: true }),
+      options: {
+        url: 'https://example.com/video',
+        outputPath: '/tmp/downloads',
+      },
+      ffmpegLocation: null,
+    });
+
+    expect(result.args).toContain('-x');
+    expect(result.args).toContain('--audio-format');
+    expect(result.args).toContain('mp3');
+    expect(result.statusMessages).toContain('🎵 Audio-only mode enabled');
+  });
+});
diff --git a/src/tests/deno.test.ts b/src/tests/deno.test.ts
new file mode 100644
index 0000000..f426d9b
--- /dev/null
+++ b/src/tests/deno.test.ts
@@ -0,0 +1,141 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { EventEmitter } from 'events';
+
+const { existsSyncMock, spawnMock, showMessageBoxMock, getFocusedWindowMock, logErrorMock } =
+  vi.hoisted(() => {
+    return {
+      existsSyncMock: vi.fn(),
+      spawnMock: vi.fn(),
+      showMessageBoxMock: vi.fn(),
+      getFocusedWindowMock: vi.fn(),
+      logErrorMock: vi.fn(),
+    };
+  });
+
+vi.mock('fs', () => ({
+  existsSync: existsSyncMock,
+}));
+
+vi.mock('child_process', () => ({
+  spawn: spawnMock,
+}));
+
+vi.mock('electron', () => ({
+  BrowserWindow: {
+    getFocusedWindow: getFocusedWindowMock,
+  },
+  dialog: {
+    showMessageBox: showMessageBoxMock,
+  },
+}));
+
+vi.mock('../main/platform', () => ({
+  isWindows: process.platform === 'win32',
+}));
+
+vi.mock('electron-log/main', () => ({
+  default: {
+    error: logErrorMock,
+  },
+}));
+
+import { checkDenoInstalled, installDeno } from '../main/deno';
+
+function createProc() {
+  const proc = new EventEmitter() as EventEmitter & {
+    stdout: EventEmitter;
+    stderr: EventEmitter;
+    kill: () => void;
+  };
+  proc.stdout = new EventEmitter();
+  proc.stderr = new EventEmitter();
+  proc.kill = vi.fn();
+  return proc;
+}
+
+describe('deno helpers', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    getFocusedWindowMock.mockReturnValue(null);
+    showMessageBoxMock.mockResolvedValue({ response: 0 });
+  });
+
+  it('returns true when deno binary exists in known paths', async () => {
+    existsSyncMock.mockReturnValue(true);
+    const installed = await checkDenoInstalled();
+    expect(installed).toBe(true);
+    expect(spawnMock).not.toHaveBeenCalled();
+  });
+
+  it('falls back to shell lookup for deno presence', async () => {
+    existsSyncMock.mockReturnValue(false);
+    const proc = createProc();
+    spawnMock.mockReturnValue(proc);
+
+    const pending = checkDenoInstalled();
+    proc.emit('close', 0);
+    const installed = await pending;
+
+    expect(installed).toBe(true);
+    expect(spawnMock).toHaveBeenCalled();
+  });
+
+  it('returns cancelled when user declines deno install', async () => {
+    showMessageBoxMock.mockResolvedValue({ response: 1 });
+    const result = await installDeno(null);
+    expect(result).toEqual({ cancelled: true });
+  });
+
+  it('shows install dialog without parent window when none is available', async () => {
+    showMessageBoxMock.mockResolvedValue({ response: 1 });
+    await installDeno(null);
+
+    expect(showMessageBoxMock).toHaveBeenCalledTimes(1);
+    const call = showMessageBoxMock.mock.calls[0];
+    expect(call).toHaveLength(1);
+    expect(call[0]).toMatchObject({ type: 'warning' });
+  });
+
+  it('shows install dialog with focused parent window when available', async () => {
+    const focusedWindow = {} as any;
+    getFocusedWindowMock.mockReturnValue(focusedWindow);
+    showMessageBoxMock.mockResolvedValue({ response: 1 });
+    await installDeno(null);
+
+    expect(showMessageBoxMock).toHaveBeenCalledTimes(1);
+    const call = showMessageBoxMock.mock.calls[0];
+    expect(call).toHaveLength(2);
+    expect(call[0]).toBe(focusedWindow);
+    expect(call[1]).toMatchObject({ type: 'warning' });
+  });
+
+  it('resolves with success payload when installer exits successfully', async () => {
+    const proc = createProc();
+    spawnMock.mockReturnValue(proc);
+
+    const pending = installDeno(null);
+    await Promise.resolve();
+    proc.stdout.emit('data', Buffer.from('install complete'));
+    proc.emit('close', 0);
+
+    await expect(pending).resolves.toMatchObject({
+      success: true,
+      output: 'install complete',
+    });
+  });
+
+  it('rejects with installer error output when installer exits non-zero', async () => {
+    const proc = createProc();
+    spawnMock.mockReturnValue(proc);
+
+    const pending = installDeno(null);
+    await Promise.resolve();
+    proc.stderr.emit('data', Buffer.from('error output'));
+    proc.emit('close', 1);
+
+    await expect(pending).rejects.toMatchObject({
+      success: false,
+      error: 'error output',
+    });
+  });
+});
diff --git a/src/tests/downloader.fetchFormats.test.ts b/src/tests/downloader.fetchFormats.test.ts
new file mode 100644
index 0000000..59d5969
--- /dev/null
+++ b/src/tests/downloader.fetchFormats.test.ts
@@ -0,0 +1,335 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { EventEmitter } from 'events';
+
+const { existsSyncMock, statSyncMock, mkdirSyncMock, spawnWithEnvMock } = vi.hoisted(() => {
+  return {
+    existsSyncMock: vi.fn(),
+    statSyncMock: vi.fn(),
+    mkdirSyncMock: vi.fn(),
+    spawnWithEnvMock: vi.fn(),
+  };
+});
+
+vi.mock('fs', () => ({
+  existsSync: existsSyncMock,
+  statSync: statSyncMock,
+  mkdirSync: mkdirSyncMock,
+}));
+
+vi.mock('../main/platform', () => ({
+  spawnWithEnv: spawnWithEnvMock,
+  resolveFfmpegPath: vi.fn(() => null),
+  ytdlpBinary: 'yt-dlp',
+  isWindows: process.platform === 'win32',
+}));
+
+vi.mock('../main/settings', () => ({
+  loadSettings: vi.fn(() => ({
+    settingsVersion: 1,
+    showConsoleOutput: false,
+    consoleCollapsed: false,
+    advancedOptions: false,
+    audioOnly: false,
+    convertEnabled: false,
+    convertFormat: 'mp4',
+    keepOriginalAfterConvert: true,
+    firstLaunch: false,
+    hookBrowser: false,
+    browserChoice: 'Chrome',
+    animateBackground: true,
+    notifications: true,
+    denoReminderDismissed: false,
+    gpuAcceleration: false,
+    gpuType: 'auto',
+    bestQuality: false,
+    ffmpegPath: '',
+    hideSupportModal: false,
+    checkUpdatesOnStartup: true,
+    updateChannel: 'auto',
+  })),
+}));
+
+vi.mock('electron', () => ({
+  dialog: {
+    showMessageBox: vi.fn(),
+  },
+}));
+
+import {
+  cancelActiveSession,
+  cancelFormats,
+  fetchFormats,
+  startDownload,
+} from '../main/downloader';
+
+function createProc() {
+  const proc = new EventEmitter() as EventEmitter & {
+    stdout: EventEmitter;
+    stderr: EventEmitter;
+    kill: () => void;
+    killed: boolean;
+  };
+  proc.stdout = new EventEmitter();
+  proc.stderr = new EventEmitter();
+  proc.killed = false;
+  proc.kill = vi.fn(() => {
+    proc.killed = true;
+    setImmediate(() => proc.emit('close', 1));
+  });
+  return proc;
+}
+
+describe('downloader format fetch', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    existsSyncMock.mockReturnValue(true);
+    statSyncMock.mockReturnValue({ isDirectory: () => true });
+  });
+
+  afterEach(() => {
+    cancelFormats();
+    cancelActiveSession(false);
+    vi.useRealTimers();
+  });
+
+  it('rejects invalid URL values', async () => {
+    await expect(fetchFormats('/tmp/ytdlp', 'not-a-url')).rejects.toContain('Invalid URL');
+  });
+
+  it('rejects when yt-dlp binary is missing', async () => {
+    existsSyncMock.mockReturnValue(false);
+    await expect(fetchFormats('/missing/ytdlp', 'https://example.com')).rejects.toContain(
+      'binary not found'
+    );
+  });
+
+  it('resolves output when process exits successfully', async () => {
+    const proc = createProc();
+    spawnWithEnvMock.mockReturnValue(proc);
+
+    const pending = fetchFormats('/tmp/ytdlp', 'https://example.com');
+    proc.stdout.emit('data', 'format output');
+    proc.emit('close', 0);
+
+    await expect(pending).resolves.toContain('format output');
+  });
+
+  it('rejects with process details when process exits non-zero', async () => {
+    const proc = createProc();
+    spawnWithEnvMock.mockReturnValue(proc);
+
+    const pending = fetchFormats('/tmp/ytdlp', 'https://example.com');
+    proc.stdout.emit('data', 'output');
+    proc.stderr.emit('data', 'stderr output');
+    proc.emit('close', 2);
+
+    await expect(pending).rejects.toContain('yt-dlp exited with code 2');
+  });
+
+  it('supports cancellation via cancelFormats', async () => {
+    const proc = createProc();
+    spawnWithEnvMock.mockReturnValue(proc);
+
+    const pending = fetchFormats('/tmp/ytdlp', 'https://example.com');
+    cancelFormats();
+    await expect(pending).rejects.toContain('cancelled');
+  });
+
+  it('rejects on timeout', async () => {
+    vi.useFakeTimers();
+    const proc = createProc();
+    spawnWithEnvMock.mockReturnValue(proc);
+
+    const pending = fetchFormats('/tmp/ytdlp', 'https://example.com');
+    const rejection = expect(pending).rejects.toContain('timed out after 60 seconds');
+    await vi.advanceTimersByTimeAsync(60_000);
+    await rejection;
+  });
+
+  it('rejects startDownload with invalid URL', () => {
+    const send = vi.fn();
+    startDownload(
+      '/tmp/ytdlp',
+      {
+        isDestroyed: () => false,
+        send,
+      } as any,
+      { url: 'not-a-url', outputPath: '/tmp/downloads' },
+      null
+    );
+
+    expect(send).toHaveBeenCalledWith('progress', '⚠️ Invalid or missing URL.');
+    expect(send).toHaveBeenCalledWith('complete', '❌ Failed (Invalid URL).');
+  });
+
+  it('rejects startDownload with invalid folder', () => {
+    const send = vi.fn();
+    startDownload(
+      '/tmp/ytdlp',
+      {
+        isDestroyed: () => false,
+        send,
+      } as any,
+      { url: 'https://example.com', outputPath: '' },
+      null
+    );
+
+    expect(send).toHaveBeenCalledWith('progress', '⚠️ Invalid or missing download folder.');
+    expect(send).toHaveBeenCalledWith('complete', '❌ Failed (Invalid Folder).');
+  });
+
+  it('rejects startDownload when yt-dlp binary is missing', () => {
+    existsSyncMock.mockImplementation((target: string) => target !== '/missing/ytdlp');
+    const send = vi.fn();
+
+    startDownload(
+      '/missing/ytdlp',
+      {
+        isDestroyed: () => false,
+        send,
+      } as any,
+      { url: 'https://example.com', outputPath: '/tmp/downloads' },
+      null
+    );
+
+    expect(send).toHaveBeenCalledWith(
+      'progress',
+      '❌ Error: yt-dlp binary not found at /missing/ytdlp'
+    );
+    expect(send).toHaveBeenCalledWith('complete', '❌ Failed (Missing Dependency).');
+  });
+
+  it('rejects startDownload when output path is not a directory', () => {
+    statSyncMock.mockReturnValue({ isDirectory: () => false });
+    const send = vi.fn();
+
+    startDownload(
+      '/tmp/ytdlp',
+      {
+        isDestroyed: () => false,
+        send,
+      } as any,
+      { url: 'https://example.com', outputPath: '/tmp/not-a-dir' },
+      null
+    );
+
+    expect(send).toHaveBeenCalledWith(
+      'progress',
+      expect.stringContaining('Download path is not a directory')
+    );
+    expect(send).toHaveBeenCalledWith('complete', '❌ Failed (Invalid Folder).');
+  });
+
+  it('starts download and completes when conversion is disabled', () => {
+    const proc = createProc();
+    spawnWithEnvMock.mockReturnValue(proc);
+    const send = vi.fn();
+
+    startDownload(
+      '/tmp/ytdlp',
+      {
+        isDestroyed: () => false,
+        send,
+      } as any,
+      { url: 'https://example.com/video', outputPath: '/tmp/downloads' },
+      null
+    );
+
+    proc.stdout.emit('data', '[download] 10%\n');
+    proc.stdout.emit('data', '/tmp/downloads/video.mp4\n');
+    proc.emit('close', 0);
+
+    expect(send).toHaveBeenCalledWith('complete', '✅ Download complete (no conversion).');
+    expect(spawnWithEnvMock).toHaveBeenCalledWith(
+      '/tmp/ytdlp',
+      expect.arrayContaining(['https://example.com/video']),
+      expect.any(Object)
+    );
+  });
+
+  it('creates missing output directory before starting download', () => {
+    const proc = createProc();
+    spawnWithEnvMock.mockReturnValue(proc);
+    existsSyncMock.mockImplementation((target: string) => {
+      if (target === '/tmp/ytdlp') return true;
+      if (target.includes('new-downloads')) return false;
+      return true;
+    });
+    const send = vi.fn();
+
+    startDownload(
+      '/tmp/ytdlp',
+      {
+        isDestroyed: () => false,
+        send,
+      } as any,
+      { url: 'https://example.com/video', outputPath: '/tmp/new-downloads' },
+      null
+    );
+
+    proc.stdout.emit('data', '/tmp/new-downloads/video.mp4\n');
+    proc.emit('close', 0);
+    expect(mkdirSyncMock).toHaveBeenCalledWith(expect.stringContaining('new-downloads'), {
+      recursive: true,
+    });
+    expect(send).toHaveBeenCalledWith('complete', '✅ Download complete (no conversion).');
+  });
+
+  it('completes with failure when yt-dlp exits non-zero', () => {
+    const proc = createProc();
+    spawnWithEnvMock.mockReturnValue(proc);
+    const send = vi.fn();
+
+    startDownload(
+      '/tmp/ytdlp',
+      {
+        isDestroyed: () => false,
+        send,
+      } as any,
+      { url: 'https://example.com/video', outputPath: '/tmp/downloads' },
+      null
+    );
+
+    proc.emit('close', 2);
+    expect(send).toHaveBeenCalledWith('complete', '❌ Download failed.');
+  });
+
+  it('fails when yt-dlp does not emit a filepath', () => {
+    const proc = createProc();
+    spawnWithEnvMock.mockReturnValue(proc);
+    const send = vi.fn();
+
+    startDownload(
+      '/tmp/ytdlp',
+      {
+        isDestroyed: () => false,
+        send,
+      } as any,
+      { url: 'https://example.com/video', outputPath: '/tmp/downloads' },
+      null
+    );
+
+    proc.stdout.emit('data', ' ');
+    proc.emit('close', 0);
+    expect(send).toHaveBeenCalledWith('complete', '❌ Failed (File Path Error).');
+  });
+
+  it('completes with spawn error when yt-dlp process fails to start', () => {
+    const proc = createProc();
+    spawnWithEnvMock.mockReturnValue(proc);
+    const send = vi.fn();
+
+    startDownload(
+      '/tmp/ytdlp',
+      {
+        isDestroyed: () => false,
+        send,
+      } as any,
+      { url: 'https://example.com/video', outputPath: '/tmp/downloads' },
+      null
+    );
+
+    proc.emit('error', new Error('spawn failed'));
+    expect(send).toHaveBeenCalledWith('complete', '❌ Download failed (process spawn error).');
+  });
+});
diff --git a/src/tests/gpu.test.ts b/src/tests/gpu.test.ts
new file mode 100644
index 0000000..e65bfbf
--- /dev/null
+++ b/src/tests/gpu.test.ts
@@ -0,0 +1,99 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { EventEmitter } from 'events';
+
+const { loadSettingsMock, resolveFfmpegPathMock, spawnWithEnvMock, logErrorMock } = vi.hoisted(
+  () => {
+    return {
+      loadSettingsMock: vi.fn(),
+      resolveFfmpegPathMock: vi.fn(),
+      spawnWithEnvMock: vi.fn(),
+      logErrorMock: vi.fn(),
+    };
+  }
+);
+
+vi.mock('../main/settings', () => ({
+  loadSettings: loadSettingsMock,
+}));
+
+vi.mock('../main/platform', () => ({
+  resolveFfmpegPath: resolveFfmpegPathMock,
+  spawnWithEnv: spawnWithEnvMock,
+}));
+
+vi.mock('electron-log/main', () => ({
+  default: {
+    error: logErrorMock,
+  },
+}));
+
+import { detectGpu } from '../main/gpu';
+
+function createProc() {
+  const proc = new EventEmitter() as EventEmitter & {
+    stdout: EventEmitter;
+    stderr: EventEmitter;
+    kill: () => void;
+  };
+  proc.stdout = new EventEmitter();
+  proc.stderr = new EventEmitter();
+  proc.kill = vi.fn();
+  return proc;
+}
+
+describe('gpu detection', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    loadSettingsMock.mockReturnValue({
+      ffmpegPath: '',
+    });
+    resolveFfmpegPathMock.mockReturnValue(null);
+  });
+
+  it('detects supported GPU encoders from ffmpeg output', async () => {
+    const proc = createProc();
+    spawnWithEnvMock.mockReturnValue(proc);
+
+    const pending = detectGpu();
+    proc.stdout.emit('data', Buffer.from('h264_nvenc\nh264_qsv\n'));
+    proc.stderr.emit('data', Buffer.from('h264_amf\n'));
+    proc.emit('close', 0);
+
+    const result = await pending;
+    expect(result).toEqual({
+      nvidia: true,
+      amd: true,
+      intel: true,
+    });
+    expect(spawnWithEnvMock).toHaveBeenCalled();
+  });
+
+  it('returns all false on process error', async () => {
+    const proc = createProc();
+    spawnWithEnvMock.mockReturnValue(proc);
+
+    const pending = detectGpu();
+    proc.emit('error', new Error('spawn failed'));
+
+    const result = await pending;
+    expect(result).toEqual({
+      nvidia: false,
+      amd: false,
+      intel: false,
+    });
+  });
+
+  it('logs and returns default result if spawn throws', async () => {
+    spawnWithEnvMock.mockImplementation(() => {
+      throw new Error('unexpected');
+    });
+
+    const result = await detectGpu();
+    expect(result).toEqual({
+      nvidia: false,
+      amd: false,
+      intel: false,
+    });
+    expect(logErrorMock).toHaveBeenCalled();
+  });
+});
diff --git a/src/tests/ipcValidation.test.ts b/src/tests/ipcValidation.test.ts
new file mode 100644
index 0000000..2141b55
--- /dev/null
+++ b/src/tests/ipcValidation.test.ts
@@ -0,0 +1,157 @@
+import { describe, it, expect } from 'vitest';
+import {
+  errorResult,
+  okResult,
+  validateDownloadRequestPayload,
+  validateExternalUrlPayload,
+  validateFileLocationPayload,
+  validateNotificationPayload,
+  validateSettingsPatchPayload,
+} from '../utils/ipcValidation';
+
+describe('ipc validation helpers', () => {
+  it('builds typed ok and error result wrappers', () => {
+    expect(okResult({ started: true })).toEqual({
+      ok: true,
+      data: { started: true },
+    });
+
+    expect(errorResult('VALIDATION_ERROR', 'bad payload', 'details')).toEqual({
+      ok: false,
+      error: {
+        code: 'VALIDATION_ERROR',
+        message: 'bad payload',
+        details: 'details',
+      },
+    });
+  });
+
+  it('accepts valid download requests', () => {
+    const result = validateDownloadRequestPayload({
+      url: '  https://example.com/video  ',
+      outputPath: '  /tmp  ',
+      ffmpegPath: '  /usr/bin/ffmpeg  ',
+      convertFormat: '  mp4  ',
+      keepOriginal: true,
+      videoFormat: '  137  ',
+      audioFormat: '  140  ',
+    });
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.data.url).toBe('https://example.com/video');
+    expect(result.data.outputPath).toBe('/tmp');
+    expect(result.data.ffmpegPath).toBe('/usr/bin/ffmpeg');
+    expect(result.data.convertFormat).toBe('mp4');
+    expect(result.data.videoFormat).toBe('137');
+    expect(result.data.audioFormat).toBe('140');
+  });
+
+  it('rejects malformed download request payloads by field', () => {
+    expect(validateDownloadRequestPayload(null).ok).toBe(false);
+    expect(
+      validateDownloadRequestPayload({
+        url: 'javascript:alert(1)',
+        outputPath: '/tmp',
+      }).ok
+    ).toBe(false);
+    expect(
+      validateDownloadRequestPayload({
+        url: 'https://example.com',
+        outputPath: '',
+      }).ok
+    ).toBe(false);
+    expect(
+      validateDownloadRequestPayload({
+        url: 'https://example.com',
+        outputPath: '/tmp',
+        ffmpegPath: 42,
+      }).ok
+    ).toBe(false);
+    expect(
+      validateDownloadRequestPayload({
+        url: 'https://example.com',
+        outputPath: '/tmp',
+        convertFormat: 42,
+      }).ok
+    ).toBe(false);
+    expect(
+      validateDownloadRequestPayload({
+        url: 'https://example.com',
+        outputPath: '/tmp',
+        keepOriginal: 'yes',
+      }).ok
+    ).toBe(false);
+    expect(
+      validateDownloadRequestPayload({
+        url: 'https://example.com',
+        outputPath: '/tmp',
+        videoFormat: 137,
+      }).ok
+    ).toBe(false);
+    expect(
+      validateDownloadRequestPayload({
+        url: 'https://example.com',
+        outputPath: '/tmp',
+        audioFormat: 140,
+      }).ok
+    ).toBe(false);
+  });
+
+  it('validates settings patch payloads', () => {
+    expect(validateSettingsPatchPayload('bad').ok).toBe(false);
+
+    const valid = validateSettingsPatchPayload({
+      settingsVersion: 1,
+      showConsoleOutput: true,
+      browserChoice: 'Firefox',
+      updateChannel: 'stable',
+      gpuType: 'intel',
+      unknownField: 'ignored',
+    });
+    expect(valid.ok).toBe(true);
+    if (!valid.ok) return;
+    expect(valid.data.settingsVersion).toBe(1);
+    expect(valid.data.browserChoice).toBe('Firefox');
+    expect(Object.keys(valid.data)).not.toContain('unknownField');
+
+    expect(validateSettingsPatchPayload({ settingsVersion: 0 }).ok).toBe(false);
+    expect(validateSettingsPatchPayload({ audioOnly: 'true' }).ok).toBe(false);
+    expect(validateSettingsPatchPayload({ browserChoice: 123 }).ok).toBe(false);
+
+    const invalid = validateSettingsPatchPayload({
+      updateChannel: 'nightly',
+    });
+    expect(invalid.ok).toBe(false);
+  });
+
+  it('validates external URL and file path payloads', () => {
+    expect(validateExternalUrlPayload('  https://example.com  ').ok).toBe(true);
+    expect(validateExternalUrlPayload(42).ok).toBe(false);
+    expect(validateExternalUrlPayload('file:///tmp').ok).toBe(false);
+
+    const filePath = validateFileLocationPayload('  /tmp/file.mp4  ');
+    expect(filePath.ok).toBe(true);
+    if (filePath.ok) expect(filePath.data).toBe('/tmp/file.mp4');
+    expect(validateFileLocationPayload('').ok).toBe(false);
+  });
+
+  it('validates notification payload shape', () => {
+    const valid = validateNotificationPayload({
+      title: ' Done ',
+      body: ' Finished ',
+      filePath: ' /tmp/out.mp4 ',
+    });
+    expect(valid.ok).toBe(true);
+    if (valid.ok) {
+      expect(valid.data).toEqual({
+        title: 'Done',
+        body: 'Finished',
+        filePath: '/tmp/out.mp4',
+      });
+    }
+
+    expect(validateNotificationPayload('oops').ok).toBe(false);
+    expect(validateNotificationPayload({ title: 42 }).ok).toBe(false);
+  });
+});
diff --git a/src/tests/platform.resolveYtdlp.test.ts b/src/tests/platform.resolveYtdlp.test.ts
new file mode 100644
index 0000000..86f62fb
--- /dev/null
+++ b/src/tests/platform.resolveYtdlp.test.ts
@@ -0,0 +1,127 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+interface PlatformMocks {
+  existsSyncMock: ReturnType<typeof vi.fn>;
+  chmodSyncMock: ReturnType<typeof vi.fn>;
+  accessSyncMock: ReturnType<typeof vi.fn>;
+  mkdirSyncMock: ReturnType<typeof vi.fn>;
+  copyFileSyncMock: ReturnType<typeof vi.fn>;
+  showErrorBoxMock: ReturnType<typeof vi.fn>;
+  appQuitMock: ReturnType<typeof vi.fn>;
+  logInfoMock: ReturnType<typeof vi.fn>;
+  logErrorMock: ReturnType<typeof vi.fn>;
+}
+
+const initialResourcesPath = (process as NodeJS.Process & { resourcesPath?: string }).resourcesPath;
+
+async function loadPlatformModule(
+  isPackaged: boolean,
+  setup: (mocks: PlatformMocks) => void = () => {}
+) {
+  vi.resetModules();
+  const mocks: PlatformMocks = {
+    existsSyncMock: vi.fn(() => true),
+    chmodSyncMock: vi.fn(),
+    accessSyncMock: vi.fn(),
+    mkdirSyncMock: vi.fn(),
+    copyFileSyncMock: vi.fn(),
+    showErrorBoxMock: vi.fn(),
+    appQuitMock: vi.fn(),
+    logInfoMock: vi.fn(),
+    logErrorMock: vi.fn(),
+  };
+  setup(mocks);
+
+  vi.doMock('fs', () => ({
+    existsSync: mocks.existsSyncMock,
+    chmodSync: mocks.chmodSyncMock,
+    accessSync: mocks.accessSyncMock,
+    mkdirSync: mocks.mkdirSyncMock,
+    copyFileSync: mocks.copyFileSyncMock,
+    constants: { X_OK: 1 },
+  }));
+
+  vi.doMock('electron', () => ({
+    app: {
+      isPackaged,
+      getPath: vi.fn(() => '/tmp/rosi-tests'),
+      quit: mocks.appQuitMock,
+    },
+    dialog: {
+      showErrorBox: mocks.showErrorBoxMock,
+    },
+  }));
+
+  vi.doMock('electron-log/main', () => ({
+    default: {
+      info: mocks.logInfoMock,
+      error: mocks.logErrorMock,
+    },
+  }));
+
+  (process as NodeJS.Process & { resourcesPath?: string }).resourcesPath = '/app/resources';
+  const mod = await import('../main/platform');
+  return { mod, mocks };
+}
+
+afterEach(() => {
+  vi.clearAllMocks();
+  vi.resetModules();
+  (process as NodeJS.Process & { resourcesPath?: string }).resourcesPath = initialResourcesPath;
+});
+
+describe('platform resolveYtdlpPath', () => {
+  it('resolves non-packaged yt-dlp path', async () => {
+    const { mod } = await loadPlatformModule(false);
+
+    const resolved = mod.resolveYtdlpPath();
+    expect(resolved).toContain('assets');
+    expect(resolved).toContain(mod.ytdlpBinary);
+  });
+
+  it('resolves packaged yt-dlp path from expected locations', async () => {
+    const { mod, mocks } = await loadPlatformModule(true, (m) => {
+      m.existsSyncMock.mockImplementation((target: string) => target.includes('assets'));
+    });
+
+    const resolved = mod.resolveYtdlpPath();
+    expect(resolved.replace(/\\/g, '/')).toContain('/app/resources');
+    expect(mocks.logInfoMock).toHaveBeenCalled();
+  });
+
+  it('shows missing dependency error and quits when yt-dlp is absent', async () => {
+    const { mod, mocks } = await loadPlatformModule(true, (m) => {
+      m.existsSyncMock.mockReturnValue(false);
+    });
+
+    const resolved = mod.resolveYtdlpPath();
+    expect(resolved).toContain(mod.ytdlpBinary);
+    expect(mocks.showErrorBoxMock).toHaveBeenCalledWith(
+      'Missing Dependency',
+      expect.stringContaining('yt-dlp binary not found')
+    );
+    expect(mocks.appQuitMock).toHaveBeenCalled();
+  });
+
+  it('shows permission error and quits for non-recoverable chmod failures', async () => {
+    if (process.platform === 'win32') {
+      return;
+    }
+
+    const { mod, mocks } = await loadPlatformModule(false, (m) => {
+      m.existsSyncMock.mockReturnValue(true);
+      m.chmodSyncMock.mockImplementation(() => {
+        const err = new Error('chmod failed') as NodeJS.ErrnoException;
+        err.code = 'EINVAL';
+        throw err;
+      });
+    });
+
+    mod.resolveYtdlpPath();
+    expect(mocks.showErrorBoxMock).toHaveBeenCalledWith(
+      'Permission Error',
+      expect.stringContaining('Failed to set executable permissions')
+    );
+    expect(mocks.appQuitMock).toHaveBeenCalled();
+  });
+});
diff --git a/src/tests/platform.test.ts b/src/tests/platform.test.ts
new file mode 100644
index 0000000..3312067
--- /dev/null
+++ b/src/tests/platform.test.ts
@@ -0,0 +1,88 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+vi.mock('electron', () => ({
+  app: {
+    isPackaged: false,
+    getPath: vi.fn(() => path.join(os.tmpdir(), 'rosi-tests')),
+    quit: vi.fn(),
+  },
+  dialog: {
+    showErrorBox: vi.fn(),
+  },
+}));
+
+vi.mock('electron-log/main', () => ({
+  default: {
+    info: vi.fn(),
+    error: vi.fn(),
+  },
+}));
+
+import { buildEnhancedPath, isWindows, resolveFfmpegPath } from '../main/platform';
+
+describe('platform helpers', () => {
+  const originalPath = process.env.PATH;
+  const originalUserProfile = process.env.USERPROFILE;
+  const originalLocalAppData = process.env.LOCALAPPDATA;
+  const originalHome = process.env.HOME;
+
+  beforeEach(() => {
+    process.env.PATH = isWindows ? 'C:\\Windows\\System32' : '/usr/bin';
+    process.env.USERPROFILE = 'C:\\Users\\Tester';
+    process.env.LOCALAPPDATA = 'C:\\Users\\Tester\\AppData\\Local';
+    process.env.HOME = '/home/tester';
+  });
+
+  afterEach(() => {
+    process.env.PATH = originalPath;
+    process.env.USERPROFILE = originalUserProfile;
+    process.env.LOCALAPPDATA = originalLocalAppData;
+    process.env.HOME = originalHome;
+  });
+
+  it('builds an enhanced PATH that retains current PATH', () => {
+    const enhanced = buildEnhancedPath();
+    expect(enhanced).toContain(process.env.PATH || '');
+
+    if (isWindows) {
+      expect(enhanced).toContain('C:\\Program Files\\ffmpeg\\bin');
+      expect(enhanced).toContain('C:\\Users\\Tester\\.deno\\bin');
+      expect(enhanced.includes(';')).toBe(true);
+    } else {
+      expect(enhanced).toContain('/usr/local/bin');
+      expect(enhanced).toContain('/home/tester/.deno/bin');
+      expect(enhanced.includes(':')).toBe(true);
+    }
+  });
+
+  it('resolves ffmpeg binary from a directory path', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rosi-platform-'));
+    try {
+      const resolved = resolveFfmpegPath(tempDir);
+      const expected = path.join(tempDir, isWindows ? 'ffmpeg.exe' : 'ffmpeg');
+      expect(resolved).toBe(expected);
+    } finally {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  it('returns null for empty custom path', () => {
+    expect(resolveFfmpegPath(undefined)).toBeNull();
+    expect(resolveFfmpegPath('')).toBeNull();
+    expect(resolveFfmpegPath('   ')).toBeNull();
+  });
+
+  it('keeps explicit binary path when it exists', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rosi-platform-'));
+    const binaryPath = path.join(tempDir, isWindows ? 'ffmpeg.exe' : 'ffmpeg');
+    fs.writeFileSync(binaryPath, '');
+    try {
+      expect(resolveFfmpegPath(binaryPath)).toBe(binaryPath);
+    } finally {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+});
diff --git a/src/tests/settings.test.ts b/src/tests/settings.test.ts
new file mode 100644
index 0000000..7a1e64e
--- /dev/null
+++ b/src/tests/settings.test.ts
@@ -0,0 +1,124 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const {
+  existsSyncMock,
+  readFileSyncMock,
+  writeFileSyncMock,
+  mkdirSyncMock,
+  showErrorBoxMock,
+  logErrorMock,
+} = vi.hoisted(() => {
+  return {
+    existsSyncMock: vi.fn(),
+    readFileSyncMock: vi.fn(),
+    writeFileSyncMock: vi.fn(),
+    mkdirSyncMock: vi.fn(),
+    showErrorBoxMock: vi.fn(),
+    logErrorMock: vi.fn(),
+  };
+});
+
+vi.mock('fs', () => ({
+  existsSync: existsSyncMock,
+  readFileSync: readFileSyncMock,
+  writeFileSync: writeFileSyncMock,
+  mkdirSync: mkdirSyncMock,
+}));
+
+vi.mock('electron', () => ({
+  app: {
+    getPath: vi.fn(() => '/tmp/rosi-tests'),
+  },
+  dialog: {
+    showErrorBox: showErrorBoxMock,
+  },
+}));
+
+vi.mock('electron-log/main', () => ({
+  default: {
+    error: logErrorMock,
+  },
+}));
+
+import {
+  CURRENT_SETTINGS_VERSION,
+  getDefaultSettings,
+  loadSettings,
+  saveSettings,
+} from '../main/settings';
+
+describe('settings persistence', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    existsSyncMock.mockImplementation(() => true);
+    readFileSyncMock.mockReturnValue(JSON.stringify(getDefaultSettings()));
+  });
+
+  it('returns default settings when settings file is missing', () => {
+    existsSyncMock.mockImplementation((target: string) => !target.endsWith('settings.json'));
+    const loaded = loadSettings();
+    expect(loaded).toEqual(getDefaultSettings());
+  });
+
+  it('returns default settings when settings JSON is invalid', () => {
+    readFileSyncMock.mockReturnValue('{');
+    const loaded = loadSettings();
+    expect(loaded).toEqual(getDefaultSettings());
+  });
+
+  it('normalizes loaded settings version to current version', () => {
+    readFileSyncMock.mockReturnValue(
+      JSON.stringify({
+        ...getDefaultSettings(),
+        settingsVersion: 0,
+        updateChannel: 'beta',
+      })
+    );
+
+    const loaded = loadSettings();
+    expect(loaded.settingsVersion).toBe(CURRENT_SETTINGS_VERSION);
+    expect(loaded.updateChannel).toBe('beta');
+  });
+
+  it('saves merged settings payload with normalized schema', () => {
+    const result = saveSettings(
+      {
+        audioOnly: true,
+        updateChannel: 'stable',
+      },
+      null
+    );
+
+    expect(result).toBe(true);
+    expect(writeFileSyncMock).toHaveBeenCalledOnce();
+
+    const [, writtenPayload] = writeFileSyncMock.mock.calls[0];
+    const parsed = JSON.parse(writtenPayload);
+    expect(parsed.audioOnly).toBe(true);
+    expect(parsed.updateChannel).toBe('stable');
+    expect(parsed.settingsVersion).toBe(CURRENT_SETTINGS_VERSION);
+  });
+
+  it('creates settings directory when missing before save', () => {
+    existsSyncMock.mockImplementation((target: string) => target.endsWith('settings.json'));
+    const result = saveSettings({ audioOnly: true }, null);
+
+    expect(result).toBe(true);
+    expect(mkdirSyncMock).toHaveBeenCalledWith(expect.any(String), { recursive: true });
+  });
+
+  it('returns false and shows error when write fails', () => {
+    writeFileSyncMock.mockImplementation(() => {
+      throw new Error('disk full');
+    });
+    const mainWindow = { isDestroyed: () => false } as any;
+    const result = saveSettings({ audioOnly: true }, mainWindow);
+
+    expect(result).toBe(false);
+    expect(logErrorMock).toHaveBeenCalled();
+    expect(showErrorBoxMock).toHaveBeenCalledWith(
+      'Settings Save Error',
+      expect.stringContaining('disk full')
+    );
+  });
+});
diff --git a/src/tests/settingsMigration.test.ts b/src/tests/settingsMigration.test.ts
new file mode 100644
index 0000000..a404be7
--- /dev/null
+++ b/src/tests/settingsMigration.test.ts
@@ -0,0 +1,49 @@
+import { describe, it, expect, vi } from 'vitest';
+
+vi.mock('electron', () => ({
+  app: {
+    getPath: () => '/tmp/rosi-tests',
+  },
+  dialog: {
+    showErrorBox: vi.fn(),
+  },
+}));
+
+import { CURRENT_SETTINGS_VERSION, getDefaultSettings, migrateSettings } from '../main/settings';
+
+describe('settings migration', () => {
+  it('returns defaults for invalid payloads', () => {
+    expect(migrateSettings(null)).toEqual(getDefaultSettings());
+    expect(migrateSettings('invalid')).toEqual(getDefaultSettings());
+    expect(migrateSettings([])).toEqual(getDefaultSettings());
+  });
+
+  it('migrates legacy settings and enforces schema defaults', () => {
+    const migrated = migrateSettings({
+      showConsoleOutput: true,
+      audioOnly: true,
+      convertFormat: 'mp3',
+      updateChannel: 'beta',
+      gpuType: 'nvidia',
+      settingsVersion: 0,
+    });
+
+    expect(migrated.showConsoleOutput).toBe(true);
+    expect(migrated.audioOnly).toBe(true);
+    expect(migrated.convertFormat).toBe('mp3');
+    expect(migrated.updateChannel).toBe('beta');
+    expect(migrated.gpuType).toBe('nvidia');
+    expect(migrated.settingsVersion).toBe(CURRENT_SETTINGS_VERSION);
+  });
+
+  it('falls back on invalid enum fields', () => {
+    const defaults = getDefaultSettings();
+    const migrated = migrateSettings({
+      updateChannel: 'nightly',
+      gpuType: 'unknown',
+    });
+
+    expect(migrated.updateChannel).toBe(defaults.updateChannel);
+    expect(migrated.gpuType).toBe(defaults.gpuType);
+  });
+});
diff --git a/src/tests/updaterEvents.test.ts b/src/tests/updaterEvents.test.ts
new file mode 100644
index 0000000..f6474bd
--- /dev/null
+++ b/src/tests/updaterEvents.test.ts
@@ -0,0 +1,267 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const {
+  autoUpdaterMock,
+  listeners,
+  appGetVersionMock,
+  cancellationCancelMock,
+  logInfoMock,
+  logErrorMock,
+} = vi.hoisted(() => {
+  const eventListeners: Record<string, Array<(payload?: any) => void>> = {};
+  const cancellationCancel = vi.fn();
+  const autoUpdater = {
+    channel: 'latest',
+    allowPrerelease: false,
+    autoDownload: false,
+    autoInstallOnAppQuit: false,
+    on: vi.fn((event: string, callback: (payload?: any) => void) => {
+      eventListeners[event] ??= [];
+      eventListeners[event].push(callback);
+    }),
+    checkForUpdates: vi.fn(),
+    downloadUpdate: vi.fn(),
+    quitAndInstall: vi.fn(),
+  };
+
+  return {
+    autoUpdaterMock: autoUpdater,
+    listeners: eventListeners,
+    appGetVersionMock: vi.fn(() => '3.4.3'),
+    cancellationCancelMock: cancellationCancel,
+    logInfoMock: vi.fn(),
+    logErrorMock: vi.fn(),
+  };
+});
+
+vi.mock('electron', () => ({
+  app: {
+    getVersion: appGetVersionMock,
+  },
+}));
+
+vi.mock('electron-updater', () => ({
+  autoUpdater: autoUpdaterMock,
+  CancellationToken: class {
+    cancel() {
+      cancellationCancelMock();
+    }
+  },
+}));
+
+vi.mock('electron-log/main', () => ({
+  default: {
+    info: logInfoMock,
+    error: logErrorMock,
+  },
+}));
+
+import {
+  cancelUpdateDownload,
+  checkForUpdates,
+  downloadUpdate,
+  installUpdate,
+  setupAutoUpdater,
+} from '../main/updater';
+import type { Settings } from '../types';
+
+function createSettings(overrides: Partial<Settings> = {}): Settings {
+  return {
+    settingsVersion: 1,
+    showConsoleOutput: false,
+    consoleCollapsed: false,
+    advancedOptions: false,
+    audioOnly: false,
+    convertEnabled: false,
+    convertFormat: 'mp4',
+    keepOriginalAfterConvert: true,
+    firstLaunch: false,
+    hookBrowser: false,
+    browserChoice: 'Chrome',
+    animateBackground: true,
+    notifications: true,
+    denoReminderDismissed: false,
+    gpuAcceleration: false,
+    gpuType: 'auto',
+    bestQuality: false,
+    ffmpegPath: '',
+    hideSupportModal: false,
+    checkUpdatesOnStartup: true,
+    updateChannel: 'auto',
+    ...overrides,
+  };
+}
+
+function emit(event: string, payload?: any) {
+  for (const listener of listeners[event] ?? []) {
+    listener(payload);
+  }
+}
+
+describe('updater event wiring and control flow', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    Object.keys(listeners).forEach((key) => {
+      listeners[key] = [];
+    });
+    appGetVersionMock.mockReturnValue('3.4.3');
+  });
+
+  it('wires updater events to renderer channels', () => {
+    const sendMock = vi.fn();
+    setupAutoUpdater(
+      () =>
+        ({
+          isDestroyed: () => false,
+          webContents: { send: sendMock },
+        }) as any,
+      () => createSettings({ updateChannel: 'stable' })
+    );
+
+    emit('checking-for-update');
+    emit('update-not-available', { version: '3.4.3' });
+    emit('download-progress', {
+      percent: 50,
+      bytesPerSecond: 1000,
+      transferred: 100,
+      total: 200,
+    });
+    emit('update-downloaded', { version: '3.5.0' });
+    emit('error', new Error('network'));
+
+    expect(sendMock).toHaveBeenCalledWith('updater-status', { status: 'checking' });
+    expect(sendMock).toHaveBeenCalledWith('updater-status', {
+      status: 'not-available',
+      version: '3.4.3',
+      isBeta: false,
+    });
+    expect(sendMock).toHaveBeenCalledWith('updater-progress', {
+      percent: 50,
+      bytesPerSecond: 1000,
+      transferred: 100,
+      total: 200,
+    });
+    expect(sendMock).toHaveBeenCalledWith('updater-status', {
+      status: 'downloaded',
+      version: '3.5.0',
+    });
+    expect(sendMock).toHaveBeenCalledWith('updater-status', {
+      status: 'error',
+      message: 'network',
+    });
+  });
+
+  it('filters beta updates on stable channel', () => {
+    const sendMock = vi.fn();
+    setupAutoUpdater(
+      () =>
+        ({
+          isDestroyed: () => false,
+          webContents: { send: sendMock },
+        }) as any,
+      () => createSettings({ updateChannel: 'stable' })
+    );
+
+    emit('update-available', { version: '3.5.0-beta.1', releaseNotes: null });
+    expect(sendMock).toHaveBeenCalledWith('updater-status', {
+      status: 'not-available',
+      version: '3.4.3',
+      isBeta: false,
+    });
+  });
+
+  it('emits available status for valid newer updates', () => {
+    const sendMock = vi.fn();
+    setupAutoUpdater(
+      () =>
+        ({
+          isDestroyed: () => false,
+          webContents: { send: sendMock },
+        }) as any,
+      () => createSettings({ updateChannel: 'stable' })
+    );
+
+    emit('update-available', { version: '3.5.0', releaseNotes: 'notes' });
+    expect(sendMock).toHaveBeenCalledWith('updater-status', {
+      status: 'available',
+      version: '3.5.0',
+      releaseNotes: 'notes',
+      isBeta: false,
+    });
+  });
+
+  it('ignores updates that are not newer than current version', () => {
+    const sendMock = vi.fn();
+    setupAutoUpdater(
+      () =>
+        ({
+          isDestroyed: () => false,
+          webContents: { send: sendMock },
+        }) as any,
+      () => createSettings({ updateChannel: 'stable' })
+    );
+
+    emit('update-available', { version: '3.4.3', releaseNotes: null });
+    expect(logInfoMock).toHaveBeenCalled();
+    expect(sendMock).toHaveBeenCalledWith('updater-status', {
+      status: 'not-available',
+      version: '3.4.3',
+      isBeta: false,
+    });
+  });
+
+  it('handles checkForUpdates in dev and packaged modes', async () => {
+    autoUpdaterMock.checkForUpdates.mockResolvedValueOnce({ updateInfo: { version: '3.5.0' } });
+
+    await expect(checkForUpdates(false, () => createSettings())).resolves.toEqual({
+      error: 'dev-mode',
+      message: 'Update checking is not available in development mode.',
+    });
+
+    await expect(checkForUpdates(true, () => createSettings())).resolves.toEqual({
+      updateInfo: { version: '3.5.0' },
+    });
+  });
+
+  it('handles successful and error update download responses', async () => {
+    autoUpdaterMock.downloadUpdate.mockResolvedValueOnce(undefined);
+    await expect(downloadUpdate()).resolves.toEqual({ success: true });
+
+    autoUpdaterMock.downloadUpdate.mockRejectedValueOnce(new Error('cancelled by user'));
+    await expect(downloadUpdate()).resolves.toEqual({ cancelled: true });
+
+    autoUpdaterMock.downloadUpdate.mockRejectedValueOnce(new Error('network'));
+    await expect(downloadUpdate()).resolves.toEqual({ error: 'network' });
+  });
+
+  it('can cancel active update download and emit cancelled status', async () => {
+    const sendMock = vi.fn();
+    setupAutoUpdater(
+      () =>
+        ({
+          isDestroyed: () => false,
+          webContents: { send: sendMock },
+        }) as any,
+      () => createSettings({ updateChannel: 'stable' })
+    );
+
+    autoUpdaterMock.downloadUpdate.mockImplementationOnce(() => new Promise(() => {}));
+    void downloadUpdate();
+
+    cancelUpdateDownload(
+      () =>
+        ({
+          isDestroyed: () => false,
+          webContents: { send: sendMock },
+        }) as any
+    );
+
+    expect(cancellationCancelMock).toHaveBeenCalled();
+    expect(sendMock).toHaveBeenCalledWith('updater-status', { status: 'cancelled' });
+  });
+
+  it('invokes installUpdate quitAndInstall', () => {
+    installUpdate();
+    expect(autoUpdaterMock.quitAndInstall).toHaveBeenCalledWith(false, true);
+  });
+});
diff --git a/src/tests/updaterVersioning.test.ts b/src/tests/updaterVersioning.test.ts
new file mode 100644
index 0000000..a629456
--- /dev/null
+++ b/src/tests/updaterVersioning.test.ts
@@ -0,0 +1,84 @@
+import { describe, it, expect, vi } from 'vitest';
+
+const { mockAppGetVersion, mockAutoUpdater } = vi.hoisted(() => {
+  return {
+    mockAppGetVersion: vi.fn(() => '3.4.3'),
+    mockAutoUpdater: {
+      channel: 'latest',
+      allowPrerelease: false,
+      autoDownload: false,
+      autoInstallOnAppQuit: false,
+      on: vi.fn(),
+      checkForUpdates: vi.fn(),
+      downloadUpdate: vi.fn(),
+      quitAndInstall: vi.fn(),
+    },
+  };
+});
+
+vi.mock('electron', () => ({
+  app: {
+    getVersion: mockAppGetVersion,
+  },
+}));
+
+vi.mock('electron-updater', () => ({
+  autoUpdater: mockAutoUpdater,
+  CancellationToken: class {
+    cancel() {}
+  },
+}));
+
+import {
+  applyChannel,
+  comparePrerelease,
+  compareVersions,
+  isBetaVersion,
+  parseVersion,
+  resolveUseBeta,
+} from '../main/updater';
+
+describe('updater versioning helpers', () => {
+  it('detects prerelease versions', () => {
+    expect(isBetaVersion('3.4.3-beta.1')).toBe(true);
+    expect(isBetaVersion('3.4.3')).toBe(false);
+  });
+
+  it('parses semantic-like versions', () => {
+    expect(parseVersion('v4.1.2-beta.3')).toEqual({
+      major: 4,
+      minor: 1,
+      patch: 2,
+      prerelease: ['beta', '3'],
+    });
+  });
+
+  it('compares prerelease arrays in semver order', () => {
+    expect(comparePrerelease([], [])).toBe(0);
+    expect(comparePrerelease([], ['beta', '1'])).toBe(1);
+    expect(comparePrerelease(['beta', '1'], ['beta', '2'])).toBe(-1);
+  });
+
+  it('compares versions with prerelease precedence', () => {
+    expect(compareVersions('3.4.4', '3.4.3')).toBe(1);
+    expect(compareVersions('3.4.3-beta.2', '3.4.3-beta.1')).toBe(1);
+    expect(compareVersions('3.4.3', '3.4.3-beta.1')).toBe(1);
+    expect(compareVersions('3.4.3-beta.1', '3.4.3')).toBe(-1);
+  });
+
+  it('resolves update channel behavior', () => {
+    expect(resolveUseBeta('beta')).toBe(true);
+    expect(resolveUseBeta('stable')).toBe(false);
+    expect(resolveUseBeta('auto')).toBe(false);
+  });
+
+  it('applies updater channel settings', () => {
+    applyChannel(true);
+    expect(mockAutoUpdater.channel).toBe('beta');
+    expect(mockAutoUpdater.allowPrerelease).toBe(true);
+
+    applyChannel(false);
+    expect(mockAutoUpdater.channel).toBe('latest');
+    expect(mockAutoUpdater.allowPrerelease).toBe(false);
+  });
+});
diff --git a/src/tests/validation.test.ts b/src/tests/validation.test.ts
index 2115dd8..f55901d 100644
--- a/src/tests/validation.test.ts
+++ b/src/tests/validation.test.ts
@@ -36,6 +36,7 @@ describe('validation helpers', () => {
       expect(validation.isSafeExternalUrl('file:///tmp/test')).toBe(false);
       expect(validation.isSafeExternalUrl('javascript:alert(1)')).toBe(false);
       expect(validation.isSafeExternalUrl('mailto:support@example.com')).toBe(false);
+      expect(validation.isSafeExternalUrl('not a url')).toBe(false);
       expect(validation.isSafeExternalUrl('')).toBe(false);
       expect(validation.isSafeExternalUrl(undefined)).toBe(false);
     });
diff --git a/src/types.ts b/src/types.ts
index a0549d1..4311e24 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -1,4 +1,5 @@
 export interface Settings {
+  settingsVersion: number;
   showConsoleOutput: boolean;
   consoleCollapsed: boolean;
   advancedOptions: boolean;
@@ -18,9 +19,29 @@ export interface Settings {
   ffmpegPath: string;
   hideSupportModal: boolean;
   checkUpdatesOnStartup: boolean;
-  updateChannel: 'auto' | 'stable' | 'beta';
+  updateChannel: UpdateChannel;
 }
 
+export type UpdateChannel = 'auto' | 'stable' | 'beta';
+
+export type DistributionChannel = 'github' | 'msstore';
+
+export type IpcErrorCode =
+  | 'VALIDATION_ERROR'
+  | 'INVALID_URL'
+  | 'INVALID_PATH'
+  | 'NOT_SUPPORTED'
+  | 'NOT_AVAILABLE'
+  | 'INTERNAL_ERROR';
+
+export interface IpcErrorPayload {
+  code: IpcErrorCode;
+  message: string;
+  details?: string;
+}
+
+export type IpcResult<T = void> = { ok: true; data: T } | { ok: false; error: IpcErrorPayload };
+
 export interface DownloadLifecycleState {
   cancelled: boolean;
   completed: boolean;
@@ -54,3 +75,72 @@ export interface FormatsProcess {
   proc: import('child_process').ChildProcess;
   cancelled: boolean;
 }
+
+export interface NotificationRequest {
+  title?: string;
+  body?: string;
+  filePath?: string;
+}
+
+export type UpdaterStatusEvent =
+  | { status: 'checking' }
+  | {
+      status: 'available';
+      version: string;
+      releaseNotes: string | null | import('builder-util-runtime').ReleaseNoteInfo[];
+      isBeta: boolean;
+    }
+  | { status: 'not-available'; version: string; isBeta: boolean }
+  | { status: 'error'; message: string }
+  | { status: 'cancelled' }
+  | { status: 'downloaded'; version: string };
+
+export interface UpdaterProgressEvent {
+  percent: number;
+  bytesPerSecond: number;
+  transferred: number;
+  total: number;
+}
+
+export type UpdateCheckResponse = unknown | { error: string; message?: string };
+
+export interface UpdateDownloadResult {
+  success?: boolean;
+  cancelled?: boolean;
+  error?: string;
+}
+
+export interface RendererApi {
+  restartApp: () => Promise<void>;
+  getChannel: () => DistributionChannel;
+  getFormats: (url: string) => Promise<string>;
+  selectDownloadLocation: () => Promise<string | null>;
+  getSettings: () => Promise<Settings>;
+  saveSettings: (settings: Partial<Settings>) => Promise<IpcResult<Settings>>;
+  resetSettings: () => void;
+  openExternal: (url: string) => Promise<IpcResult<{ opened: boolean }>>;
+  downloadVideo: (options: DownloadRequestOptions) => Promise<IpcResult<{ started: boolean }>>;
+  cancelDownload: () => void;
+  cancelFormats: () => void;
+  getAppVersion: () => Promise<string>;
+  checkDenoInstalled: () => Promise<boolean>;
+  installDeno: () => Promise<{
+    success?: boolean;
+    cancelled?: boolean;
+    output?: string;
+    error?: string;
+  }>;
+  detectGpu: () => Promise<GpuDetectionResult>;
+  isPackaged: () => Promise<boolean>;
+  checkForUpdates: () => Promise<UpdateCheckResponse>;
+  downloadUpdate: () => Promise<UpdateDownloadResult>;
+  cancelUpdateDownload: () => void;
+  installUpdate: () => void;
+  onUpdaterStatus: (callback: (data: UpdaterStatusEvent) => void) => () => void;
+  onUpdaterProgress: (callback: (data: UpdaterProgressEvent) => void) => () => void;
+  onDownloadProgress: (callback: (data: Record<string, unknown>) => void) => () => void;
+  onProgress: (callback: (message: string) => void) => () => void;
+  onComplete: (callback: (message: string) => void) => () => void;
+  openFileLocation: (filePath: string) => Promise<IpcResult<{ opened: boolean }>>;
+  showNotification: (options: NotificationRequest) => Promise<IpcResult<{ shown: boolean }>>;
+}
diff --git a/src/utils/ipcValidation.ts b/src/utils/ipcValidation.ts
new file mode 100644
index 0000000..6f28e07
--- /dev/null
+++ b/src/utils/ipcValidation.ts
@@ -0,0 +1,286 @@
+import type {
+  DownloadRequestOptions,
+  IpcErrorCode,
+  IpcErrorPayload,
+  IpcResult,
+  NotificationRequest,
+  Settings,
+} from '../types';
+import { isSafeExternalUrl, isSafeHttpUrl } from './validation';
+
+const ALLOWED_GPU_TYPES = new Set(['auto', 'nvidia', 'amd', 'intel']);
+const ALLOWED_UPDATE_CHANNELS = new Set(['auto', 'stable', 'beta']);
+
+type ValidationResult<T> = { ok: true; data: T } | { ok: false; error: IpcErrorPayload };
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isOptionalString(value: unknown): value is string | undefined {
+  return value === undefined || typeof value === 'string';
+}
+
+function isBoolean(value: unknown): value is boolean {
+  return typeof value === 'boolean';
+}
+
+function isString(value: unknown): value is string {
+  return typeof value === 'string';
+}
+
+function buildError(code: IpcErrorCode, message: string, details?: string): IpcErrorPayload {
+  return { code, message, details };
+}
+
+export function okResult<T>(data: T): IpcResult<T> {
+  return { ok: true, data };
+}
+
+export function errorResult(
+  code: IpcErrorCode,
+  message: string,
+  details?: string
+): IpcResult<never> {
+  return { ok: false, error: buildError(code, message, details) };
+}
+
+export function validateExternalUrlPayload(value: unknown): ValidationResult<string> {
+  if (!isString(value) || !isSafeExternalUrl(value)) {
+    return {
+      ok: false,
+      error: buildError('INVALID_URL', 'Invalid external URL payload.'),
+    };
+  }
+  return { ok: true, data: value.trim() };
+}
+
+export function validateDownloadRequestPayload(
+  value: unknown
+): ValidationResult<DownloadRequestOptions> {
+  if (!isRecord(value)) {
+    return {
+      ok: false,
+      error: buildError('VALIDATION_ERROR', 'Download payload must be an object.'),
+    };
+  }
+
+  const { url, outputPath, ffmpegPath, convertFormat, keepOriginal, videoFormat, audioFormat } =
+    value;
+
+  if (!isString(url) || !isSafeHttpUrl(url)) {
+    return {
+      ok: false,
+      error: buildError('INVALID_URL', 'Download URL must be a valid http/https URL.'),
+    };
+  }
+
+  if (!isString(outputPath) || outputPath.trim() === '') {
+    return {
+      ok: false,
+      error: buildError('INVALID_PATH', 'Download outputPath must be a non-empty string path.'),
+    };
+  }
+
+  if (!isOptionalString(ffmpegPath)) {
+    return {
+      ok: false,
+      error: buildError('VALIDATION_ERROR', 'ffmpegPath must be a string when provided.'),
+    };
+  }
+  if (!isOptionalString(convertFormat)) {
+    return {
+      ok: false,
+      error: buildError('VALIDATION_ERROR', 'convertFormat must be a string when provided.'),
+    };
+  }
+  if (keepOriginal !== undefined && !isBoolean(keepOriginal)) {
+    return {
+      ok: false,
+      error: buildError('VALIDATION_ERROR', 'keepOriginal must be a boolean when provided.'),
+    };
+  }
+  if (!isOptionalString(videoFormat)) {
+    return {
+      ok: false,
+      error: buildError('VALIDATION_ERROR', 'videoFormat must be a string when provided.'),
+    };
+  }
+  if (!isOptionalString(audioFormat)) {
+    return {
+      ok: false,
+      error: buildError('VALIDATION_ERROR', 'audioFormat must be a string when provided.'),
+    };
+  }
+
+  return {
+    ok: true,
+    data: {
+      url: url.trim(),
+      outputPath: outputPath.trim(),
+      ffmpegPath: ffmpegPath?.trim() || undefined,
+      convertFormat: convertFormat?.trim() || undefined,
+      keepOriginal,
+      videoFormat: videoFormat?.trim() || undefined,
+      audioFormat: audioFormat?.trim() || undefined,
+    },
+  };
+}
+
+function isValidSettingsKey(key: string): key is keyof Settings {
+  return (
+    key === 'settingsVersion' ||
+    key === 'showConsoleOutput' ||
+    key === 'consoleCollapsed' ||
+    key === 'advancedOptions' ||
+    key === 'audioOnly' ||
+    key === 'convertEnabled' ||
+    key === 'convertFormat' ||
+    key === 'keepOriginalAfterConvert' ||
+    key === 'firstLaunch' ||
+    key === 'hookBrowser' ||
+    key === 'browserChoice' ||
+    key === 'animateBackground' ||
+    key === 'notifications' ||
+    key === 'denoReminderDismissed' ||
+    key === 'gpuAcceleration' ||
+    key === 'gpuType' ||
+    key === 'bestQuality' ||
+    key === 'ffmpegPath' ||
+    key === 'hideSupportModal' ||
+    key === 'checkUpdatesOnStartup' ||
+    key === 'updateChannel'
+  );
+}
+
+export function validateSettingsPatchPayload(value: unknown): ValidationResult<Partial<Settings>> {
+  if (!isRecord(value)) {
+    return {
+      ok: false,
+      error: buildError('VALIDATION_ERROR', 'Settings payload must be an object.'),
+    };
+  }
+
+  const patch: Partial<Settings> = {};
+  for (const [rawKey, rawValue] of Object.entries(value)) {
+    if (!isValidSettingsKey(rawKey)) continue;
+
+    if (rawKey === 'settingsVersion') {
+      if (typeof rawValue !== 'number' || !Number.isInteger(rawValue) || rawValue < 1) {
+        return {
+          ok: false,
+          error: buildError(
+            'VALIDATION_ERROR',
+            'settingsVersion must be an integer greater than or equal to 1.'
+          ),
+        };
+      }
+      patch.settingsVersion = rawValue;
+      continue;
+    }
+
+    if (
+      rawKey === 'showConsoleOutput' ||
+      rawKey === 'consoleCollapsed' ||
+      rawKey === 'advancedOptions' ||
+      rawKey === 'audioOnly' ||
+      rawKey === 'convertEnabled' ||
+      rawKey === 'keepOriginalAfterConvert' ||
+      rawKey === 'firstLaunch' ||
+      rawKey === 'hookBrowser' ||
+      rawKey === 'animateBackground' ||
+      rawKey === 'notifications' ||
+      rawKey === 'denoReminderDismissed' ||
+      rawKey === 'gpuAcceleration' ||
+      rawKey === 'bestQuality' ||
+      rawKey === 'hideSupportModal' ||
+      rawKey === 'checkUpdatesOnStartup'
+    ) {
+      if (!isBoolean(rawValue)) {
+        return {
+          ok: false,
+          error: buildError('VALIDATION_ERROR', `${rawKey} must be a boolean.`),
+        };
+      }
+      patch[rawKey] = rawValue;
+      continue;
+    }
+
+    if (rawKey === 'gpuType') {
+      if (!isString(rawValue) || !ALLOWED_GPU_TYPES.has(rawValue)) {
+        return {
+          ok: false,
+          error: buildError(
+            'VALIDATION_ERROR',
+            'gpuType must be one of: auto, nvidia, amd, intel.'
+          ),
+        };
+      }
+      patch.gpuType = rawValue as Settings['gpuType'];
+      continue;
+    }
+
+    if (rawKey === 'updateChannel') {
+      if (!isString(rawValue) || !ALLOWED_UPDATE_CHANNELS.has(rawValue)) {
+        return {
+          ok: false,
+          error: buildError('VALIDATION_ERROR', 'updateChannel must be auto, stable, or beta.'),
+        };
+      }
+      patch.updateChannel = rawValue as Settings['updateChannel'];
+      continue;
+    }
+
+    if (!isString(rawValue)) {
+      return {
+        ok: false,
+        error: buildError('VALIDATION_ERROR', `${rawKey} must be a string.`),
+      };
+    }
+    patch[rawKey] = rawValue;
+  }
+
+  return { ok: true, data: patch };
+}
+
+export function validateFileLocationPayload(value: unknown): ValidationResult<string> {
+  if (!isString(value) || value.trim() === '') {
+    return {
+      ok: false,
+      error: buildError('INVALID_PATH', 'File path must be a non-empty string.'),
+    };
+  }
+  return { ok: true, data: value.trim() };
+}
+
+export function validateNotificationPayload(value: unknown): ValidationResult<NotificationRequest> {
+  if (!isRecord(value)) {
+    return {
+      ok: false,
+      error: buildError('VALIDATION_ERROR', 'Notification payload must be an object.'),
+    };
+  }
+
+  const title = value.title;
+  const body = value.body;
+  const filePath = value.filePath;
+
+  if (!isOptionalString(title) || !isOptionalString(body) || !isOptionalString(filePath)) {
+    return {
+      ok: false,
+      error: buildError(
+        'VALIDATION_ERROR',
+        'Notification title, body, and filePath must be strings when provided.'
+      ),
+    };
+  }
+
+  return {
+    ok: true,
+    data: {
+      title: title?.trim(),
+      body: body?.trim(),
+      filePath: filePath?.trim(),
+    },
+  };
+}