From 9dc6202c176165c914d05ae86729c3f96260684c Mon Sep 17 00:00:00 2001
From: Egor <egor@philippov.ca>
Date: Sun, 21 Sep 2025 02:40:58 -0700
Subject: [PATCH] fix koboldai patches for release 1.99, fix update dialog from
 not triggering, speed up downloads (woah) which we accidentally slowed down,
 update advanced command modal for 1.99

---
 README.md                                     |   2 -
 package.json                                  |   2 +-
 src/components/App/UpdateAvailableModal.tsx   |   8 +-
 src/components/App/index.tsx                  |  38 ++-
 src/components/screens/Download.tsx           |  10 +-
 src/components/screens/Launch/AdvancedTab.tsx | 149 +++++-----
 .../Launch/CommandLineArgumentsModal.tsx      | 220 +++++++++++++-
 src/components/settings/GeneralTab.tsx        |  10 +-
 src/components/settings/VersionsTab.tsx       |  10 +-
 src/constants/patches.ts                      |   4 -
 src/hooks/useKoboldVersions.ts                | 276 ------------------
 src/hooks/useUpdateChecker.ts                 |  34 ++-
 src/main/modules/koboldcpp.ts                 |  65 +++--
 src/main/modules/window.ts                    |   6 +-
 src/stores/koboldVersions.ts                  | 182 ++++++++++++
 15 files changed, 582 insertions(+), 434 deletions(-)
 delete mode 100644 src/hooks/useKoboldVersions.ts
 create mode 100644 src/stores/koboldVersions.ts

diff --git a/README.md b/README.md
index f28575c..119e9e8 100644
--- a/README.md
+++ b/README.md
@@ -179,9 +179,7 @@ You can use the CLI mode on Windows in exactly the same way as in the Linux/macO
 
 ## Known Issues
 
-- automatic GPU layer detection does not currently work consistently accross all backends and platforms. It's advised to set this configuration manually if you are told in the launch terminal that your VRAM could not be detected. It should work correctly on all platforms after 1.99.0 of KoboldCpp gets released except for the Windows ROCm binary which was not written well.
 - Windows ROCm support is... problematic and currently requires for the user to manually add the installed ROCm bin directory to the system PATH. In particular "hipInfo.exe" must be present, which is not always the case for older verions of ROCm.
-- not specific to Gerbil, but the open sourced AMD GPU drivers for Linux likely won't work well for image gen. They are not throttled, unlike the proprietary AMD drivers, and are likely to result in system instability under heavy load, especially when running with the larger models. You will probably need to manually tweak your system, but dual-booting to Window is likely the easiest approach if you're experiencing crashes. User beware.
 
 ## Future Considerations
 
diff --git a/package.json b/package.json
index a078ab9..a47f900 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "gerbil",
   "productName": "Gerbil",
-  "version": "1.4.2",
+  "version": "1.4.3",
   "description": "Run Large Language Models locally",
   "main": "out/main/index.js",
   "homepage": "./",
diff --git a/src/components/App/UpdateAvailableModal.tsx b/src/components/App/UpdateAvailableModal.tsx
index bf3cd1f..ff0a1fa 100644
--- a/src/components/App/UpdateAvailableModal.tsx
+++ b/src/components/App/UpdateAvailableModal.tsx
@@ -12,7 +12,7 @@ import { Download, X, ExternalLink } from 'lucide-react';
 import { useState } from 'react';
 import type { DownloadItem } from '@/types/electron';
 import type { BinaryUpdateInfo } from '@/hooks/useUpdateChecker';
-import { useKoboldVersions } from '@/hooks/useKoboldVersions';
+import { useKoboldVersionsStore } from '@/stores/koboldVersions';
 import { getDisplayNameFromPath } from '@/utils/version';
 import { GITHUB_API } from '@/constants';
 import { safeExecute } from '@/utils/logger';
@@ -21,6 +21,7 @@ import { Modal } from '@/components/Modal';
 interface UpdateAvailableModalProps {
   opened: boolean;
   onClose: () => void;
+  onSkip: () => void;
   updateInfo?: BinaryUpdateInfo;
   onUpdate: (download: DownloadItem) => Promise<void>;
 }
@@ -28,10 +29,11 @@ interface UpdateAvailableModalProps {
 export const UpdateAvailableModal = ({
   opened,
   onClose,
+  onSkip,
   updateInfo,
   onUpdate,
 }: UpdateAvailableModalProps) => {
-  const { downloading, downloadProgress } = useKoboldVersions();
+  const { downloading, downloadProgress } = useKoboldVersionsStore();
   const currentVersion = updateInfo?.currentVersion;
   const availableUpdate = updateInfo?.availableUpdate;
   const [isUpdating, setIsUpdating] = useState(false);
@@ -141,7 +143,7 @@ export const UpdateAvailableModal = ({
         <Group justify="flex-end" gap="sm">
           <Button
             variant="outline"
-            onClick={onClose}
+            onClick={onSkip}
             disabled={isDownloading || isUpdating}
             leftSection={<X size={16} />}
           >
diff --git a/src/components/App/index.tsx b/src/components/App/index.tsx
index 88e7053..eae47d3 100644
--- a/src/components/App/index.tsx
+++ b/src/components/App/index.tsx
@@ -14,7 +14,7 @@ import { StatusBar } from '@/components/App/StatusBar';
 import { ErrorBoundary } from '@/components/App/ErrorBoundary';
 import { AppRouter } from '@/components/App/Router';
 import { useUpdateChecker } from '@/hooks/useUpdateChecker';
-import { useKoboldVersions } from '@/hooks/useKoboldVersions';
+import { useKoboldVersionsStore } from '@/stores/koboldVersions';
 import { usePreferencesStore } from '@/stores/preferences';
 import { STATUSBAR_HEIGHT, TITLEBAR_HEIGHT } from '@/constants';
 import type { DownloadItem } from '@/types/electron';
@@ -39,10 +39,11 @@ export const App = () => {
     updateInfo: binaryUpdateInfo,
     showUpdateModal,
     checkForUpdates,
-    dismissUpdate,
+    skipUpdate,
+    closeModal,
   } = useUpdateChecker();
 
-  const { handleDownload: sharedHandleDownload } = useKoboldVersions();
+  const { handleDownload, loadingRemote } = useKoboldVersionsStore();
 
   useEffect(() => {
     const checkInstallation = async () => {
@@ -52,20 +53,28 @@ export const App = () => {
       ]);
 
       determineScreen(currentVersion, hasSeenWelcome);
-
-      if (currentVersion) {
-        setTimeout(() => {
-          checkForUpdates();
-        }, 2000);
-      }
-
       setHasInitialized(true);
     };
 
     checkInstallation();
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
+  useEffect(() => {
+    const runUpdateCheck = async () => {
+      if (loadingRemote || !hasInitialized) return;
+
+      const currentVersion =
+        await window.electronAPI.kobold.getCurrentVersion();
+      if (currentVersion) {
+        setTimeout(() => {
+          checkForUpdates();
+        }, 1000);
+      }
+    };
+
+    runUpdateCheck();
+  }, [loadingRemote, hasInitialized, checkForUpdates]);
+
   const determineScreen = (
     currentVersion: unknown,
     hasSeenWelcome: boolean
@@ -80,14 +89,14 @@ export const App = () => {
   };
 
   const handleBinaryUpdate = async (download: DownloadItem) => {
-    const success = await sharedHandleDownload({
+    const success = await handleDownload({
       item: download,
       isUpdate: true,
       wasCurrentBinary: true,
     });
 
     if (success) {
-      dismissUpdate();
+      closeModal();
     }
   };
 
@@ -181,7 +190,8 @@ export const App = () => {
 
         <UpdateAvailableModal
           opened={showUpdateModal && !!binaryUpdateInfo}
-          onClose={dismissUpdate}
+          onClose={closeModal}
+          onSkip={skipUpdate}
           updateInfo={binaryUpdateInfo || undefined}
           onUpdate={handleBinaryUpdate}
         />
diff --git a/src/components/screens/Download.tsx b/src/components/screens/Download.tsx
index fd81af8..0e5bf68 100644
--- a/src/components/screens/Download.tsx
+++ b/src/components/screens/Download.tsx
@@ -4,7 +4,7 @@ import { DownloadCard } from '@/components/DownloadCard';
 import { getPlatformDisplayName } from '@/utils/platform';
 import { formatDownloadSize } from '@/utils/format';
 import { getAssetDescription } from '@/utils/assets';
-import { useKoboldVersions } from '@/hooks/useKoboldVersions';
+import { useKoboldVersionsStore } from '@/stores/koboldVersions';
 import type { DownloadItem } from '@/types/electron';
 
 interface DownloadScreenProps {
@@ -19,8 +19,8 @@ export const DownloadScreen = ({ onDownloadComplete }: DownloadScreenProps) => {
     loadingRemote,
     downloading,
     downloadProgress,
-    handleDownload: sharedHandleDownload,
-  } = useKoboldVersions();
+    handleDownload: handleDownloadFromStore,
+  } = useKoboldVersionsStore();
 
   const [downloadingAsset, setDownloadingAsset] = useState<string | null>(null);
   const downloadingItemRef = useRef<HTMLDivElement>(null);
@@ -31,7 +31,7 @@ export const DownloadScreen = ({ onDownloadComplete }: DownloadScreenProps) => {
     async (download: DownloadItem) => {
       setDownloadingAsset(download.name);
 
-      const success = await sharedHandleDownload({
+      const success = await handleDownloadFromStore({
         item: download,
         isUpdate: false,
         wasCurrentBinary: false,
@@ -47,7 +47,7 @@ export const DownloadScreen = ({ onDownloadComplete }: DownloadScreenProps) => {
 
       setDownloadingAsset(null);
     },
-    [sharedHandleDownload, onDownloadComplete]
+    [handleDownloadFromStore, onDownloadComplete]
   );
 
   useEffect(() => {
diff --git a/src/components/screens/Launch/AdvancedTab.tsx b/src/components/screens/Launch/AdvancedTab.tsx
index 4dc45c4..66ee854 100644
--- a/src/components/screens/Launch/AdvancedTab.tsx
+++ b/src/components/screens/Launch/AdvancedTab.tsx
@@ -5,6 +5,7 @@ import {
   TextInput,
   NumberInput,
   Button,
+  SimpleGrid,
 } from '@mantine/core';
 import { useState, useEffect } from 'react';
 import { InfoTooltip } from '@/components/InfoTooltip';
@@ -75,91 +76,83 @@ export const AdvancedTab = () => {
   return (
     <Stack gap="md">
       <div>
-        <Stack gap="md">
-          <Group gap="lg" align="flex-start" wrap="nowrap">
-            <CheckboxWithTooltip
-              checked={!noshift}
-              onChange={(checked) => handleNoshiftChange(!checked)}
-              label="Context Shift"
-              tooltip="Use Context Shifting to reduce reprocessing."
-            />
+        <SimpleGrid cols={3} spacing="lg" verticalSpacing="md">
+          <CheckboxWithTooltip
+            checked={!noshift}
+            onChange={(checked) => handleNoshiftChange(!checked)}
+            label="Context Shift"
+            tooltip="Use Context Shifting to reduce reprocessing."
+          />
 
-            <CheckboxWithTooltip
-              checked={noshift}
-              onChange={handleNoshiftChange}
-              label="No Shift"
-              tooltip="Don't use GPU layer shifting for incomplete offloads, which may reduce model performance."
-            />
-          </Group>
+          <CheckboxWithTooltip
+            checked={noshift}
+            onChange={handleNoshiftChange}
+            label="No Shift"
+            tooltip="Don't use GPU layer shifting for incomplete offloads, which may reduce model performance."
+          />
 
-          <Group gap="lg" align="flex-start" wrap="nowrap">
-            <CheckboxWithTooltip
-              checked={flashattention}
-              onChange={handleFlashattentionChange}
-              label="Flash Attention"
-              tooltip="Enable flash attention to reduce memory usage. May produce incorrect answers for some prompts, but improves performance."
-            />
+          <CheckboxWithTooltip
+            checked={noavx2}
+            onChange={handleNoavx2Change}
+            label="Disable AVX2"
+            tooltip={
+              !backendSupport?.noavx2 && !isLoading
+                ? 'This binary does not support the no-AVX2 mode.'
+                : 'Do not use AVX2 instructions, a slower compatibility mode for older devices.'
+            }
+            disabled={isLoading || !backendSupport?.noavx2}
+          />
 
-            <CheckboxWithTooltip
-              checked={usemmap}
-              onChange={handleUsemmapChange}
-              label="MMAP"
-              tooltip="Use MMAP to load models when enabled."
-            />
-          </Group>
+          <CheckboxWithTooltip
+            checked={usemmap}
+            onChange={handleUsemmapChange}
+            label="MMAP"
+            tooltip="Use MMAP to load models when enabled."
+          />
 
-          <Group gap="lg" align="flex-start" wrap="nowrap">
-            <CheckboxWithTooltip
-              checked={quantmatmul && isGpuBackend}
-              onChange={handleQuantmatmulChange}
-              label="QuantMatMul"
-              tooltip={
-                !isGpuBackend
-                  ? 'QuantMatMul is only available for CUDA and ROCm backends.'
-                  : 'Enable MMQ mode to use finetuned kernels instead of default CuBLAS/HipBLAS for prompt processing.'
-              }
-              disabled={!isGpuBackend}
-            />
+          <CheckboxWithTooltip
+            checked={quantmatmul && isGpuBackend}
+            onChange={handleQuantmatmulChange}
+            label="QuantMatMul"
+            tooltip={
+              !isGpuBackend
+                ? 'QuantMatMul is only available for CUDA and ROCm backends.'
+                : 'Enable MMQ mode to use finetuned kernels instead of default CuBLAS/HipBLAS for prompt processing.'
+            }
+            disabled={!isGpuBackend}
+          />
 
-            <CheckboxWithTooltip
-              checked={lowvram && isGpuBackend}
-              onChange={handleLowvramChange}
-              label="Low VRAM"
-              tooltip={
-                !isGpuBackend
-                  ? 'Low VRAM mode is only available for CUDA and ROCm backends.'
-                  : 'Avoid offloading KV Cache or scratch buffers to VRAM. Allows more layers to fit, but may result in a speed loss.'
-              }
-              disabled={!isGpuBackend}
-            />
-          </Group>
+          <CheckboxWithTooltip
+            checked={failsafe}
+            onChange={handleFailsafeChange}
+            label="Failsafe"
+            tooltip={
+              !backendSupport?.failsafe && !isLoading
+                ? 'This binary does not support failsafe mode.'
+                : 'Use failsafe mode, extremely slow CPU only compatibility mode that should work on all devices. Can be combined with useclblast if your device supports OpenCL.'
+            }
+            disabled={isLoading || !backendSupport?.failsafe}
+          />
 
-          <Group gap="lg" align="flex-start" wrap="nowrap">
-            <CheckboxWithTooltip
-              checked={noavx2}
-              onChange={handleNoavx2Change}
-              label="Disable AVX2"
-              tooltip={
-                !backendSupport?.noavx2 && !isLoading
-                  ? 'This binary does not support the no-AVX2 mode.'
-                  : 'Do not use AVX2 instructions, a slower compatibility mode for older devices.'
-              }
-              disabled={isLoading || !backendSupport?.noavx2}
-            />
+          <CheckboxWithTooltip
+            checked={flashattention}
+            onChange={handleFlashattentionChange}
+            label="Flash Attention"
+            tooltip="Enable flash attention to reduce memory usage. May produce incorrect answers for some prompts, but improves performance."
+          />
 
-            <CheckboxWithTooltip
-              checked={failsafe}
-              onChange={handleFailsafeChange}
-              label="Failsafe"
-              tooltip={
-                !backendSupport?.failsafe && !isLoading
-                  ? 'This binary does not support failsafe mode.'
-                  : 'Use failsafe mode, extremely slow CPU only compatibility mode that should work on all devices. Can be combined with useclblast if your device supports OpenCL.'
-              }
-              disabled={isLoading || !backendSupport?.failsafe}
-            />
-          </Group>
-        </Stack>
+          <CheckboxWithTooltip
+            checked={lowvram && isGpuBackend}
+            onChange={handleLowvramChange}
+            label="Low VRAM"
+            tooltip={
+              !isGpuBackend
+                ? 'Low VRAM mode is only available for CUDA and ROCm backends.'
+                : 'Avoid offloading KV Cache or scratch buffers to VRAM. Allows more layers to fit, but may result in a speed loss.'
+            }
+            disabled={!isGpuBackend}
+          />
+        </SimpleGrid>
       </div>
 
       <div>
diff --git a/src/components/screens/Launch/CommandLineArgumentsModal.tsx b/src/components/screens/Launch/CommandLineArgumentsModal.tsx
index a588aba..7a5d481 100644
--- a/src/components/screens/Launch/CommandLineArgumentsModal.tsx
+++ b/src/components/screens/Launch/CommandLineArgumentsModal.tsx
@@ -60,6 +60,7 @@ const UI_COVERED_ARGS = new Set([
   '--sdlora',
   '--sdflashattention',
   '--sdconvdirect',
+  '--tensor_split',
 ] as const) as ReadonlySet<string>;
 
 const IGNORED_ARGS = new Set([
@@ -67,6 +68,13 @@ const IGNORED_ARGS = new Set([
   '--version',
   '--launch',
   '--config',
+  '--showgui',
+  '--skiplauncher',
+  '--unpack',
+  '--exportconfig',
+  '--exporttemplate',
+  '--nomodel',
+  '--singleinstance',
 ] as const) as ReadonlySet<string>;
 
 const COMMAND_LINE_ARGUMENTS = [
@@ -241,7 +249,7 @@ const COMMAND_LINE_ARGUMENTS = [
   {
     flag: '--cli',
     description:
-      'Does not launch the HTTP server. Instead, enables input from the command line, accepting interactive console input and displaying responses to the terminal.',
+      'Does not launch KoboldCpp HTTP server. Instead, enables KoboldCpp from the command line, accepting interactive console input and displaying responses to the terminal.',
     type: 'boolean',
     category: 'Advanced',
   },
@@ -347,7 +355,7 @@ const COMMAND_LINE_ARGUMENTS = [
     description: 'How many tokens to draft per chunk before verifying results',
     metavar: '[tokens]',
     type: 'int',
-    default: 16,
+    default: 8,
     category: 'Speculative Decoding',
   },
   {
@@ -360,6 +368,14 @@ const COMMAND_LINE_ARGUMENTS = [
     default: 999,
     category: 'Speculative Decoding',
   },
+  {
+    flag: '--draftgpusplit',
+    description:
+      'GPU layer distribution ratio for draft model (default=same as main). Only works if multi-GPUs selected for MAIN model and tensor_split is set!',
+    metavar: '[Ratios]',
+    type: 'float[]',
+    category: 'Speculative Decoding',
+  },
   {
     flag: '--quantkv',
     description:
@@ -392,6 +408,114 @@ const COMMAND_LINE_ARGUMENTS = [
     type: 'boolean',
     category: 'Performance',
   },
+  {
+    flag: '--ratelimit',
+    description:
+      'If enabled, rate limit generative request by IP address. Each IP can only send a new request once per X seconds.',
+    metavar: '[seconds]',
+    type: 'int',
+    default: 0,
+    category: 'Advanced',
+  },
+  {
+    flag: '--ignoremissing',
+    description:
+      'Ignores all missing non-essential files, just skipping them instead.',
+    type: 'boolean',
+    category: 'Advanced',
+  },
+  {
+    flag: '--chatcompletionsadapter',
+    description:
+      'Select an optional ChatCompletions Adapter JSON file to force custom instruct tags.',
+    metavar: '[filename]',
+    default: 'AutoGuess',
+    category: 'Advanced',
+  },
+  {
+    flag: '--forceversion',
+    description:
+      'If the model file format detection fails (e.g. rogue modified model) you can set this to override the detected format (enter desired version, e.g. 401 for GPTNeoX-Type2).',
+    metavar: '[version]',
+    type: 'int',
+    default: 0,
+    category: 'Advanced',
+  },
+  {
+    flag: '--smartcontext',
+    description:
+      'Reserving a portion of context to try processing less frequently. Outdated. Not recommended.',
+    type: 'boolean',
+    category: 'Advanced',
+  },
+  {
+    flag: '--unpack',
+    description:
+      'Extracts the file contents of the KoboldCpp binary into a target directory.',
+    metavar: 'destination',
+    type: 'string',
+    default: '',
+    category: 'Advanced',
+  },
+  {
+    flag: '--exportconfig',
+    description:
+      'Exports the current selected arguments as a .kcpps settings file',
+    metavar: '[filename]',
+    type: 'string',
+    default: '',
+    category: 'Advanced',
+  },
+  {
+    flag: '--exporttemplate',
+    description:
+      'Exports the current selected arguments as a .kcppt template file',
+    metavar: '[filename]',
+    type: 'string',
+    default: '',
+    category: 'Advanced',
+  },
+  {
+    flag: '--nomodel',
+    description:
+      'Allows you to launch the GUI alone, without selecting any model.',
+    type: 'boolean',
+    category: 'Advanced',
+  },
+  {
+    flag: '--singleinstance',
+    description:
+      'Allows this KoboldCpp instance to be shut down by any new instance requesting the same port, preventing duplicate servers from clashing on a port.',
+    type: 'boolean',
+    category: 'Advanced',
+  },
+  {
+    flag: '--maxrequestsize',
+    description:
+      'Specify a max request payload size. Any requests to the server larger than this size will be dropped. Do not change if unsure.',
+    metavar: '[size in MB]',
+    type: 'int',
+    default: 32,
+    category: 'Advanced',
+  },
+  {
+    flag: '--overridekv',
+    aliases: ['--override-kv'],
+    description:
+      'Advanced option to override a metadata by key, same as in llama.cpp. Mainly for debugging, not intended for general use. Types: int, float, bool, str',
+    metavar: '[name=type:value]',
+    default: '',
+    category: 'Advanced',
+  },
+  {
+    flag: '--overridetensors',
+    aliases: ['--override-tensor', '-ot'],
+    description:
+      'Advanced option to override tensor backend selection, same as in llama.cpp.',
+    metavar: '[tensor name pattern=buffer type]',
+    default: '',
+    category: 'Advanced',
+  },
   {
     flag: '--admin',
     description:
@@ -436,6 +560,24 @@ const COMMAND_LINE_ARGUMENTS = [
     default: '',
     category: 'Horde Worker',
   },
+  {
+    flag: '--hordemaxctx',
+    description:
+      'Sets the maximum context length your worker will accept from an AI Horde job. If 0, matches main context limit.',
+    metavar: '[amount]',
+    type: 'int',
+    default: 0,
+    category: 'Horde Worker',
+  },
+  {
+    flag: '--hordegenlen',
+    description:
+      'Sets the maximum number of tokens your worker will generate from an AI horde job.',
+    metavar: '[amount]',
+    type: 'int',
+    default: 0,
+    category: 'Horde Worker',
+  },
   {
     flag: '--sdthreads',
     description:
@@ -455,6 +597,48 @@ const COMMAND_LINE_ARGUMENTS = [
     default: 0,
     category: 'Image Generation',
   },
+  {
+    flag: '--sdclamped',
+    description:
+      'If specified, limit generation steps and image size for shared use. Accepts an extra optional parameter that indicates maximum resolution (eg. 768 clamps to 768x768, min 512px, disabled if 0).',
+    metavar: '[maxres]',
+    type: 'int',
+    default: 0,
+    category: 'Image Generation',
+  },
+  {
+    flag: '--sdclampedsoft',
+    description:
+      'If specified, limit max image size to curb memory usage. Similar to --sdclamped, but less strict, allows trade-offs between width and height (e.g. 640 would allow 640x640, 512x768 and 768x512 images). Total resolution cannot exceed 1MP.',
+    metavar: '[maxres]',
+    type: 'int',
+    default: 0,
+    category: 'Image Generation',
+  },
+  {
+    flag: '--sdvaeauto',
+    description:
+      'Uses a built-in VAE via TAE SD, which is very fast, and fixed bad VAEs.',
+    type: 'boolean',
+    category: 'Image Generation',
+  },
+  {
+    flag: '--sdloramult',
+    description: 'Multiplier for the image LORA model to be applied.',
+    metavar: '[amount]',
+    type: 'float',
+    default: 1.0,
+    category: 'Image Generation',
+  },
+  {
+    flag: '--sdtiledvae',
+    description:
+      'Adjust the automatic VAE tiling trigger for images above this size. 0 disables vae tiling.',
+    metavar: '[maxres]',
+    type: 'int',
+    default: 768,
+    category: 'Image Generation',
+  },
   {
     flag: '--whispermodel',
     description:
@@ -476,6 +660,29 @@ const COMMAND_LINE_ARGUMENTS = [
     type: 'boolean',
     category: 'Audio',
   },
+  {
+    flag: '--ttswavtokenizer',
+    description: 'Specify the WavTokenizer GGUF model.',
+    metavar: '[filename]',
+    default: '',
+    category: 'Audio',
+  },
+  {
+    flag: '--ttsmaxlen',
+    description: 'Limit number of audio tokens generated with TTS.',
+    type: 'int',
+    default: 4096,
+    category: 'Audio',
+  },
+  {
+    flag: '--ttsthreads',
+    description:
+      'Use a different number of threads for TTS if specified. Otherwise, has the same value as --threads.',
+    metavar: '[threads]',
+    type: 'int',
+    default: 0,
+    category: 'Audio',
+  },
   {
     flag: '--embeddingsmodel',
     description:
@@ -491,6 +698,15 @@ const COMMAND_LINE_ARGUMENTS = [
     type: 'boolean',
     category: 'Embeddings',
   },
+  {
+    flag: '--embeddingsmaxctx',
+    description:
+      'Overrides the default maximum supported context of an embeddings model (defaults to trained context).',
+    metavar: '[amount]',
+    type: 'int',
+    default: 0,
+    category: 'Embeddings',
+  },
 ] as const;
 
 const AVAILABLE_ARGUMENTS = COMMAND_LINE_ARGUMENTS.filter(
diff --git a/src/components/settings/GeneralTab.tsx b/src/components/settings/GeneralTab.tsx
index 4bf2882..c3c3694 100644
--- a/src/components/settings/GeneralTab.tsx
+++ b/src/components/settings/GeneralTab.tsx
@@ -181,14 +181,7 @@ export const GeneralTab = ({
     }
   };
 
-  const handleFrontendPreferenceChange = async (value: string | null) => {
-    if (
-      !value ||
-      !['koboldcpp', 'sillytavern', 'openwebui', 'comfyui'].includes(value)
-    )
-      return;
-
-    await checkAllFrontendRequirements();
+  const handleFrontendPreferenceChange = (value: string | null) => {
     setFrontendPreference(value as FrontendPreference);
   };
 
@@ -268,7 +261,6 @@ export const GeneralTab = ({
           value={frontendPreference}
           onChange={handleFrontendPreferenceChange}
           disabled={isOnInterfaceScreen}
-          onClick={() => checkAllFrontendRequirements()}
           data={frontendConfigs.map((config) => ({
             value: config.value,
             label: config.label,
diff --git a/src/components/settings/VersionsTab.tsx b/src/components/settings/VersionsTab.tsx
index e2ce047..e0e66db 100644
--- a/src/components/settings/VersionsTab.tsx
+++ b/src/components/settings/VersionsTab.tsx
@@ -18,7 +18,7 @@ import {
 } from '@/utils/version';
 import { formatDownloadSize } from '@/utils/format';
 
-import { useKoboldVersions } from '@/hooks/useKoboldVersions';
+import { useKoboldVersionsStore } from '@/stores/koboldVersions';
 import type { InstalledVersion, ReleaseWithStatus } from '@/types/electron';
 
 interface VersionInfo {
@@ -40,9 +40,9 @@ export const VersionsTab = () => {
     loadingRemote,
     downloading,
     downloadProgress,
-    handleDownload: sharedHandleDownload,
+    handleDownload: handleDownloadFromStore,
     getLatestReleaseWithDownloadStatus,
-  } = useKoboldVersions();
+  } = useKoboldVersionsStore();
 
   const [installedVersions, setInstalledVersions] = useState<
     InstalledVersion[]
@@ -171,7 +171,7 @@ export const VersionsTab = () => {
     const download = availableDownloads.find((d) => d.name === version.name);
     if (!download) return;
 
-    const success = await sharedHandleDownload({
+    const success = await handleDownloadFromStore({
       item: download,
       isUpdate: false,
       wasCurrentBinary: false,
@@ -186,7 +186,7 @@ export const VersionsTab = () => {
     const download = availableDownloads.find((d) => d.name === version.name);
     if (!download) return;
 
-    const success = await sharedHandleDownload({
+    const success = await handleDownloadFromStore({
       item: download,
       isUpdate: true,
       wasCurrentBinary: version.isCurrent,
diff --git a/src/constants/patches.ts b/src/constants/patches.ts
index 8dcb60f..088a615 100644
--- a/src/constants/patches.ts
+++ b/src/constants/patches.ts
@@ -25,10 +25,6 @@ export const KLITE_CSS_OVERRIDE = `
   margin-left: 10px;
 }
 
-.topmenu {
-  padding: 10px;
-}
-
 #navbarNavDropdown {
   padding: 0;
 }
diff --git a/src/hooks/useKoboldVersions.ts b/src/hooks/useKoboldVersions.ts
deleted file mode 100644
index d982e5b..0000000
--- a/src/hooks/useKoboldVersions.ts
+++ /dev/null
@@ -1,276 +0,0 @@
-import { useState, useEffect, useCallback } from 'react';
-import { logError } from '@/utils/logger';
-import { getROCmDownload } from '@/utils/rocm';
-import { GITHUB_API } from '@/constants';
-import { filterAssetsByPlatform } from '@/utils/platform';
-import type {
-  DownloadItem,
-  GitHubRelease,
-  ReleaseWithStatus,
-  GitHubAsset,
-  InstalledVersion,
-} from '@/types/electron';
-import { sortDownloadsByType } from '@/utils/assets';
-
-interface CachedReleaseData {
-  releases: DownloadItem[];
-  timestamp: number;
-}
-
-interface HandleDownloadParams {
-  item: DownloadItem;
-  isUpdate?: boolean;
-  wasCurrentBinary?: boolean;
-}
-
-const CACHE_KEY = 'kobold-releases-cache';
-const CACHE_DURATION = 60000;
-
-const loadFromCache = (): CachedReleaseData | null => {
-  try {
-    const cached = localStorage.getItem(CACHE_KEY);
-    if (!cached) return null;
-
-    const data: CachedReleaseData = JSON.parse(cached);
-    const isExpired = Date.now() - data.timestamp > CACHE_DURATION;
-
-    return isExpired ? null : data;
-  } catch {
-    return null;
-  }
-};
-
-const saveToCache = (releases: DownloadItem[]) => {
-  try {
-    const data: CachedReleaseData = {
-      releases,
-      timestamp: Date.now(),
-    };
-    localStorage.setItem(CACHE_KEY, JSON.stringify(data));
-  } catch {}
-};
-
-const transformReleaseToDownloadItems = (
-  release: GitHubRelease,
-  platform: string
-) => {
-  const version = release.tag_name?.replace(/^v/, '') || 'unknown';
-  const platformAssets = filterAssetsByPlatform(release.assets, platform);
-
-  return platformAssets.map((asset) => ({
-    name: asset.name,
-    url: asset.browser_download_url,
-    size: asset.size,
-    version,
-  }));
-};
-
-const fetchLatestReleaseFromAPI = async (
-  platform: string
-): Promise<DownloadItem[]> => {
-  const response = await fetch(GITHUB_API.LATEST_RELEASE_URL);
-
-  if (!response.ok) {
-    if (response.status === 403) {
-      throw new Error('GitHub API rate limit reached');
-    }
-    throw new Error(`HTTP error! status: ${response.status}`);
-  }
-
-  const release: GitHubRelease = await response.json();
-  return transformReleaseToDownloadItems(release, platform);
-};
-
-const getLatestReleaseWithDownloadStatus =
-  async (): Promise<ReleaseWithStatus | null> => {
-    try {
-      const response = await fetch(GITHUB_API.LATEST_RELEASE_URL);
-      if (!response.ok) return null;
-
-      const latestRelease = await response.json();
-      if (!latestRelease) return null;
-
-      const installedVersions =
-        await window.electronAPI.kobold.getInstalledVersions();
-
-      const availableAssets = latestRelease.assets.map((asset: GitHubAsset) => {
-        const installedVersion = installedVersions.find(
-          (v: InstalledVersion) => {
-            const pathParts = v.path.split(/[/\\]/);
-            const launcherIndex = pathParts.findIndex(
-              (part) =>
-                part === 'koboldcpp-launcher' ||
-                part === 'koboldcpp-launcher.exe'
-            );
-
-            if (launcherIndex > 0) {
-              const directoryName = pathParts[launcherIndex - 1];
-              return directoryName === asset.name;
-            }
-
-            return false;
-          }
-        );
-
-        return {
-          asset,
-          isDownloaded: !!installedVersion,
-          installedVersion: installedVersion?.version,
-        };
-      });
-
-      return {
-        release: latestRelease,
-        availableAssets,
-      };
-    } catch (err) {
-      logError('Failed to fetch latest release with status:', err as Error);
-      return null;
-    }
-  };
-
-export const useKoboldVersions = () => {
-  const [platform, setPlatform] = useState('');
-
-  const [availableDownloads, setAvailableDownloads] = useState<DownloadItem[]>(
-    []
-  );
-
-  const [loadingPlatform, setLoadingPlatform] = useState(true);
-  const [loadingRemote, setLoadingRemote] = useState(true);
-
-  const [downloading, setDownloading] = useState<string | null>(null);
-  const [downloadProgress, setDownloadProgress] = useState<
-    Record<string, number>
-  >({});
-
-  const loadPlatform = useCallback(async () => {
-    setLoadingPlatform(true);
-
-    const platform = await window.electronAPI.kobold.getPlatform();
-
-    setPlatform(platform);
-    setLoadingPlatform(false);
-  }, []);
-
-  const loadRemoteVersions = useCallback(async () => {
-    if (!platform) return;
-
-    setLoadingRemote(true);
-
-    try {
-      const cached = loadFromCache();
-      if (cached) {
-        const rocm = await getROCmDownload();
-        const allDownloads: DownloadItem[] = [...cached.releases];
-        if (rocm) {
-          allDownloads.push(rocm);
-        }
-        setAvailableDownloads(sortDownloadsByType(allDownloads));
-        setLoadingRemote(false);
-        return;
-      }
-
-      const [releases, rocm] = await Promise.all([
-        fetchLatestReleaseFromAPI(platform),
-        getROCmDownload(),
-      ]);
-
-      saveToCache(releases);
-
-      const allDownloads: DownloadItem[] = [...releases];
-      if (rocm) {
-        allDownloads.push(rocm);
-      }
-
-      setAvailableDownloads(sortDownloadsByType(allDownloads));
-    } catch (err) {
-      logError('Failed to load remote versions:', err as Error);
-      const cached = loadFromCache();
-      if (cached) {
-        const rocm = await getROCmDownload().catch(() => null);
-        const allDownloads: DownloadItem[] = [...cached.releases];
-        if (rocm) {
-          allDownloads.push(rocm);
-        }
-        setAvailableDownloads(sortDownloadsByType(allDownloads));
-      }
-    } finally {
-      setLoadingRemote(false);
-    }
-  }, [platform]);
-
-  const handleDownload = useCallback(
-    async ({
-      item,
-      isUpdate = false,
-      wasCurrentBinary = false,
-    }: HandleDownloadParams): Promise<boolean> => {
-      const downloadName = item.name;
-
-      setDownloading(downloadName);
-      setDownloadProgress((prev) => ({ ...prev, [downloadName]: 0 }));
-
-      try {
-        const result = await window.electronAPI.kobold.downloadRelease({
-          name: item.name,
-          browser_download_url: item.url,
-          size: item.size,
-          version: item.version,
-          isUpdate,
-          wasCurrentBinary,
-        });
-
-        return result.success !== false;
-      } catch (err) {
-        logError(`Failed to download ${item.name}:`, err as Error);
-        return false;
-      } finally {
-        setDownloading(null);
-        setDownloadProgress((prev) => {
-          const newProgress = { ...prev };
-          delete newProgress[downloadName];
-          return newProgress;
-        });
-      }
-    },
-    []
-  );
-
-  useEffect(() => {
-    loadPlatform();
-  }, [loadPlatform]);
-
-  useEffect(() => {
-    if (platform) {
-      loadRemoteVersions();
-    }
-  }, [platform, loadRemoteVersions]);
-
-  useEffect(() => {
-    const handleProgress = (progress: number) => {
-      if (downloading) {
-        setDownloadProgress((prev) => ({
-          ...prev,
-          [downloading]: progress,
-        }));
-      }
-    };
-
-    const cleanup =
-      window.electronAPI.kobold.onDownloadProgress(handleProgress);
-
-    return cleanup;
-  }, [downloading]);
-
-  return {
-    platform,
-    availableDownloads,
-    loadingPlatform,
-    loadingRemote,
-    downloading,
-    downloadProgress,
-    handleDownload,
-    getLatestReleaseWithDownloadStatus,
-  };
-};
diff --git a/src/hooks/useUpdateChecker.ts b/src/hooks/useUpdateChecker.ts
index 13d11a5..73c1d8e 100644
--- a/src/hooks/useUpdateChecker.ts
+++ b/src/hooks/useUpdateChecker.ts
@@ -4,7 +4,7 @@ import {
   compareVersions,
   stripAssetExtensions,
 } from '@/utils/version';
-import { useKoboldVersions } from '@/hooks/useKoboldVersions';
+import { useKoboldVersionsStore } from '@/stores/koboldVersions';
 import { getROCmDownload } from '@/utils/rocm';
 import type { InstalledVersion, DownloadItem } from '@/types/electron';
 
@@ -20,10 +20,9 @@ export const useUpdateChecker = () => {
   const [dismissedUpdates, setDismissedUpdates] = useState<Set<string>>(
     new Set()
   );
-  const [dismissedUpdatesLoaded, setDismissedUpdatesLoaded] = useState(false);
-
-  const { availableDownloads: releases } = useKoboldVersions();
 
+  const { availableDownloads: releases, loadingRemote } =
+    useKoboldVersionsStore();
   useEffect(() => {
     const loadDismissedUpdates = async () => {
       const dismissed = (await window.electronAPI.config.get(
@@ -33,23 +32,17 @@ export const useUpdateChecker = () => {
       if (dismissed) {
         setDismissedUpdates(new Set(dismissed));
       }
-      setDismissedUpdatesLoaded(true);
     };
 
     loadDismissedUpdates();
   }, []);
 
-  const saveDismissedUpdates = useCallback((updates: Set<string>) => {
-    window.electronAPI.config.set('dismissedUpdates', Array.from(updates));
-  }, []);
-
   const checkForUpdates = useCallback(async () => {
-    if (!dismissedUpdatesLoaded || releases.length === 0) {
+    if (loadingRemote || releases.length === 0) {
       return;
     }
 
     setIsChecking(true);
-
     const [currentVersion, rocmDownload] = await Promise.all([
       window.electronAPI.kobold.getCurrentVersion(),
       getROCmDownload(),
@@ -92,24 +85,33 @@ export const useUpdateChecker = () => {
     }
 
     setIsChecking(false);
-  }, [dismissedUpdates, dismissedUpdatesLoaded, releases]);
+  }, [dismissedUpdates, releases, loadingRemote]);
 
-  const dismissUpdate = useCallback(async () => {
+  const skipUpdate = useCallback(() => {
     if (updateInfo) {
       const updateKey = `${updateInfo.currentVersion.path}-${updateInfo.availableUpdate.version}`;
       const newDismissedUpdates = new Set([...dismissedUpdates, updateKey]);
       setDismissedUpdates(newDismissedUpdates);
-      await saveDismissedUpdates(newDismissedUpdates);
+      window.electronAPI.config.set(
+        'dismissedUpdates',
+        Array.from(newDismissedUpdates)
+      );
     }
     setShowUpdateModal(false);
     setUpdateInfo(null);
-  }, [updateInfo, dismissedUpdates, saveDismissedUpdates]);
+  }, [updateInfo, dismissedUpdates]);
+
+  const closeModal = useCallback(() => {
+    setShowUpdateModal(false);
+    setUpdateInfo(null);
+  }, []);
 
   return {
     updateInfo,
     showUpdateModal,
     isChecking,
     checkForUpdates,
-    dismissUpdate,
+    skipUpdate,
+    closeModal,
   };
 };
diff --git a/src/main/modules/koboldcpp.ts b/src/main/modules/koboldcpp.ts
index 7052d06..a61ed04 100644
--- a/src/main/modules/koboldcpp.ts
+++ b/src/main/modules/koboldcpp.ts
@@ -78,9 +78,10 @@ async function removeDirectoryWithRetry(
 
 async function handleExistingDirectory(
   unpackedDirPath: string,
-  isUpdate: boolean
+  isUpdate: boolean,
+  wasCurrentBinary = false
 ) {
-  if (!isUpdate || !(await pathExists(unpackedDirPath))) {
+  if (!isUpdate) {
     return;
   }
 
@@ -91,7 +92,26 @@ async function handleExistingDirectory(
       await new Promise((resolve) => setTimeout(resolve, 2000));
     }
 
-    await removeDirectoryWithRetry(unpackedDirPath);
+    if (await pathExists(unpackedDirPath)) {
+      await removeDirectoryWithRetry(unpackedDirPath);
+    }
+
+    if (wasCurrentBinary) {
+      const currentBinaryPath = getCurrentKoboldBinary();
+      if (currentBinaryPath && (await pathExists(currentBinaryPath))) {
+        const oldVersionDir = currentBinaryPath
+          .split(/[/\\]/)
+          .slice(0, -1)
+          .join('/');
+        if (
+          oldVersionDir !== unpackedDirPath &&
+          (await pathExists(oldVersionDir))
+        ) {
+          await removeDirectoryWithRetry(oldVersionDir);
+          sendKoboldOutput(`Removed old version: ${oldVersionDir}`);
+        }
+      }
+    }
   } catch (error) {
     logError('Failed to remove existing directory for update:', error as Error);
     throw new Error(
@@ -104,21 +124,20 @@ async function handleExistingDirectory(
 
 async function downloadFile(asset: GitHubAsset, tempPackedFilePath: string) {
   const writer = createWriteStream(tempPackedFilePath);
-  let downloadedBytes = 0;
-
-  const response = await fetch(asset.browser_download_url);
-
-  if (!response.ok) {
-    throw new Error(`Download failed: ${response.statusText}`);
-  }
-
-  if (!response.body) {
-    throw new Error('Response body is null');
-  }
-
-  const totalBytes = asset.size;
   const mainWindow = getMainWindow();
 
+  let downloadedBytes = 0;
+  let lastProgressUpdate = 0;
+
+  const response = await fetch(asset.browser_download_url);
+  if (!response.ok || !response.body) {
+    throw new Error(`Failed to download: ${response.statusText}`);
+  }
+
+  const totalBytes = parseInt(
+    response.headers.get('content-length') || '0',
+    10
+  );
   const reader = response.body.getReader();
 
   const pump = async () => {
@@ -126,13 +145,18 @@ async function downloadFile(asset: GitHubAsset, tempPackedFilePath: string) {
 
     if (done) {
       writer.end();
+      mainWindow.webContents.send('download-progress', 100);
       return;
     }
 
     downloadedBytes += value.length;
     if (totalBytes > 0) {
       const progress = (downloadedBytes / totalBytes) * 100;
-      mainWindow.webContents.send('download-progress', progress);
+      const now = Date.now();
+      if (now - lastProgressUpdate > 100) {
+        mainWindow.webContents.send('download-progress', progress);
+        lastProgressUpdate = now;
+      }
     }
 
     writer.write(Buffer.from(value));
@@ -199,8 +223,13 @@ export async function downloadRelease(asset: GitHubAsset) {
   const unpackedDirPath = join(getInstallDir(), folderName);
 
   try {
-    await handleExistingDirectory(unpackedDirPath, Boolean(asset.isUpdate));
+    await handleExistingDirectory(
+      unpackedDirPath,
+      Boolean(asset.isUpdate),
+      Boolean(asset.wasCurrentBinary)
+    );
     await downloadFile(asset, tempPackedFilePath);
+
     await mkdir(unpackedDirPath, { recursive: true });
     await unpackKoboldCpp(tempPackedFilePath, unpackedDirPath);
     const launcherPath = await setupLauncher(
diff --git a/src/main/modules/window.ts b/src/main/modules/window.ts
index 131d51e..5f69b06 100644
--- a/src/main/modules/window.ts
+++ b/src/main/modules/window.ts
@@ -322,7 +322,11 @@ export function getMainWindow() {
 export const sendToRenderer = <T extends IPCChannel>(
   channel: T,
   ...args: IPCChannelPayloads[T]
-) => getMainWindow().webContents.send(channel, ...args);
+) => {
+  if (mainWindow && !mainWindow.isDestroyed()) {
+    mainWindow.webContents.send(channel, ...args);
+  }
+};
 
 export function sendKoboldOutput(message: string, raw?: boolean) {
   const cleanMessage = stripVTControlCharacters(message);
diff --git a/src/stores/koboldVersions.ts b/src/stores/koboldVersions.ts
new file mode 100644
index 0000000..d017f24
--- /dev/null
+++ b/src/stores/koboldVersions.ts
@@ -0,0 +1,182 @@
+import { create } from 'zustand';
+import { logError, safeExecute } from '@/utils/logger';
+import { getROCmDownload } from '@/utils/rocm';
+import { GITHUB_API } from '@/constants';
+import { filterAssetsByPlatform } from '@/utils/platform';
+import type {
+  DownloadItem,
+  GitHubRelease,
+  ReleaseWithStatus,
+  GitHubAsset,
+  InstalledVersion,
+} from '@/types/electron';
+import { sortDownloadsByType } from '@/utils/assets';
+
+interface HandleDownloadParams {
+  item: DownloadItem;
+  isUpdate?: boolean;
+  wasCurrentBinary?: boolean;
+}
+
+const transformReleaseToDownloadItems = (
+  release: GitHubRelease,
+  platform: string
+) => {
+  const version = release.tag_name?.replace(/^v/, '') || 'unknown';
+  const platformAssets = filterAssetsByPlatform(release.assets, platform);
+
+  return platformAssets.map((asset) => ({
+    name: asset.name,
+    url: asset.browser_download_url,
+    size: asset.size,
+    version,
+  }));
+};
+
+const fetchLatestReleaseFromAPI = async (platform: string) => {
+  const response = await fetch(GITHUB_API.LATEST_RELEASE_URL);
+
+  if (!response.ok) {
+    if (response.status === 403) {
+      throw new Error('GitHub API rate limit reached');
+    }
+    throw new Error(`HTTP error! status: ${response.status}`);
+  }
+
+  const release: GitHubRelease = await response.json();
+  return transformReleaseToDownloadItems(release, platform);
+};
+
+interface KoboldVersionsState {
+  platform: string;
+  availableDownloads: DownloadItem[];
+  loadingPlatform: boolean;
+  loadingRemote: boolean;
+  downloading: string | null;
+  downloadProgress: Record<string, number>;
+
+  initialize: () => Promise<void>;
+  handleDownload: (params: HandleDownloadParams) => Promise<boolean>;
+  getLatestReleaseWithDownloadStatus: () => Promise<ReleaseWithStatus | null>;
+}
+
+export const useKoboldVersionsStore = create<KoboldVersionsState>(
+  (set, get) => ({
+    platform: '',
+    availableDownloads: [],
+    loadingPlatform: true,
+    loadingRemote: true,
+    downloading: null,
+    downloadProgress: {},
+
+    initialize: async () => {
+      set({ loadingPlatform: true, loadingRemote: true });
+
+      try {
+        const platform = await window.electronAPI.kobold.getPlatform();
+        set({ platform, loadingPlatform: false });
+
+        const [releases, rocm] = await Promise.all([
+          fetchLatestReleaseFromAPI(platform),
+          getROCmDownload(),
+        ]);
+
+        const allDownloads: DownloadItem[] = [...releases];
+        if (rocm) {
+          allDownloads.push(rocm);
+        }
+
+        set({ availableDownloads: sortDownloadsByType(allDownloads) });
+      } catch (err) {
+        logError('Failed to initialize store:', err as Error);
+        set({ availableDownloads: [] });
+      } finally {
+        set({ loadingRemote: false });
+      }
+    },
+
+    handleDownload: async (params: HandleDownloadParams) => {
+      const { item, isUpdate = false, wasCurrentBinary = false } = params;
+      const { downloading } = get();
+
+      if (downloading) {
+        return false;
+      }
+
+      set({ downloading: item.name, downloadProgress: { [item.name]: 0 } });
+
+      const progressCleanup = window.electronAPI.kobold.onDownloadProgress(
+        (progress) => {
+          set({ downloadProgress: { [item.name]: progress } });
+        }
+      );
+
+      try {
+        const asset: GitHubAsset = {
+          name: item.name,
+          browser_download_url: item.url,
+          size: item.size,
+          version: item.version,
+          isUpdate,
+          wasCurrentBinary,
+        };
+
+        const result = await window.electronAPI.kobold.downloadRelease(asset);
+        return result.success;
+      } catch (err) {
+        logError('Download failed:', err as Error);
+        return false;
+      } finally {
+        progressCleanup();
+        set({ downloading: null, downloadProgress: {} });
+      }
+    },
+    getLatestReleaseWithDownloadStatus: async () =>
+      safeExecute(async () => {
+        const [response, installedVersions] = await Promise.all([
+          fetch(GITHUB_API.LATEST_RELEASE_URL),
+          window.electronAPI.kobold.getInstalledVersions(),
+        ]);
+
+        if (!response.ok) return null;
+
+        const latestRelease = await response.json();
+        if (!latestRelease) return null;
+
+        const availableAssets = latestRelease.assets.map(
+          (asset: GitHubAsset) => {
+            const installedVersion = installedVersions.find(
+              (v: InstalledVersion) => {
+                const pathParts = v.path.split(/[/\\]/);
+                const launcherIndex = pathParts.findIndex(
+                  (part) =>
+                    part === 'koboldcpp-launcher' ||
+                    part === 'koboldcpp-launcher.exe'
+                );
+
+                if (launcherIndex > 0) {
+                  const directoryName = pathParts[launcherIndex - 1];
+                  return directoryName === asset.name;
+                }
+
+                return false;
+              }
+            );
+
+            return {
+              asset,
+              isDownloaded: !!installedVersion,
+              installedVersion: installedVersion?.version,
+            };
+          }
+        );
+
+        return {
+          release: latestRelease,
+          availableAssets,
+        };
+      }, 'Failed to fetch latest release with status:'),
+  })
+);
+
+useKoboldVersionsStore.getState().initialize();