From b176ca47fc190e27d17a81f71863350e67b02f3c Mon Sep 17 00:00:00 2001
From: nephalemsec <nephalem.sec@protonmail.com>
Date: Fri, 12 Jun 2026 20:41:17 +1000
Subject: [PATCH 01/10] feat(linux): window decorations toggle with custom
 close button
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add a `window_decorations` general-setting (default on). When toggled off on
Linux the native titlebar is removed and a custom in-app close button
(WindowControls, in the Settings titlebar) takes over — useful on tiling WMs.

- config: window_decorations field (serde default true)
- capability: core:window:allow-set-decorations (+ minimize/maximize); without
  it setDecorations() silently no-ops
- lib.rs: apply the saved preference at startup (Linux)
- Overview: a "Window Decorations" Switch beside "Show in Dock" (Linux only)
- Settings: custom close button shown when decorations are off
---
 src-tauri/capabilities/default.json      |  4 ++
 src-tauri/src/config.rs                  |  6 +++
 src-tauri/src/lib.rs                     | 11 ++++++
 src/lib/components/OverviewPane.svelte   | 29 ++++++++++++++
 src/lib/components/WindowControls.svelte | 49 ++++++++++++++++++++++++
 src/lib/stores/config.svelte.ts          |  6 +++
 src/lib/windows/Settings.svelte          | 20 ++++++++++
 7 files changed, 125 insertions(+)
 create mode 100644 src/lib/components/WindowControls.svelte

diff --git a/src-tauri/capabilities/default.json b/src-tauri/capabilities/default.json
index 82af4f9..7099050 100644
--- a/src-tauri/capabilities/default.json
+++ b/src-tauri/capabilities/default.json
@@ -16,6 +16,10 @@
     "core:window:allow-center",
     "core:window:allow-set-position",
     "core:window:allow-set-size",
+    "core:window:allow-set-decorations",
+    "core:window:allow-minimize",
+    "core:window:allow-maximize",
+    "core:window:allow-toggle-maximize",
     "global-shortcut:default",
     "dialog:default",
     "fs:default",
diff --git a/src-tauri/src/config.rs b/src-tauri/src/config.rs
index 944f310..99f964a 100644
--- a/src-tauri/src/config.rs
+++ b/src-tauri/src/config.rs
@@ -325,6 +325,10 @@ pub struct GeneralConfig {
     pub show_recording_indicator: bool,
     /// Visual style for the recording indicator
     pub indicator_style: IndicatorStyle,
+    /// Show native window decorations (Linux). When off, a custom in-app close
+    /// button is shown instead. macOS uses native traffic lights regardless.
+    #[serde(default = "default_true")]
+    pub window_decorations: bool,
     /// App version recorded on the most recent run.
     ///
     /// Used to detect that an update has been applied: when this differs from
@@ -345,6 +349,7 @@ impl Default for GeneralConfig {
             check_for_updates: true,
             show_recording_indicator: true,
             indicator_style: IndicatorStyle::default(),
+            window_decorations: true,
             last_run_version: None,
         }
     }
@@ -998,6 +1003,7 @@ mod tests {
                 check_for_updates: true,
                 show_recording_indicator: true,
                 indicator_style: IndicatorStyle::CursorDot,
+                window_decorations: true,
                 last_run_version: None,
             },
             recorder: RecorderConfig {
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 029ef73..4daf5d4 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -278,6 +278,17 @@ pub fn run() {
                 #[cfg(target_os = "linux")]
                 text_insert::emit_linux_typing_advisory(&app_handle);
 
+                // Linux: apply the saved window-decoration preference at startup.
+                // With decorations off, the custom in-app close button (the
+                // WindowControls component) takes over.
+                #[cfg(target_os = "linux")]
+                if !cfg.general.window_decorations {
+                    if let Some(window) = app.get_webview_window("main") {
+                        let _ = window.set_decorations(false);
+                        tracing::info!("Window decorations disabled per config");
+                    }
+                }
+
                 // Start the Local Control API if enabled in config. The API and
                 // MCP server default on, so a fresh config arrives here enabled
                 // but with no token — generate and persist one so it just works
diff --git a/src/lib/components/OverviewPane.svelte b/src/lib/components/OverviewPane.svelte
index 66fd004..079cfae 100644
--- a/src/lib/components/OverviewPane.svelte
+++ b/src/lib/components/OverviewPane.svelte
@@ -7,6 +7,7 @@
    */
   import { onMount, onDestroy } from 'svelte';
   import { invoke } from '@tauri-apps/api/core';
+  import { getCurrentWindow } from '@tauri-apps/api/window';
   import { listen, type UnlistenFn } from '@tauri-apps/api/event';
   import { getVersion } from '@tauri-apps/api/app';
   import { enable, disable, isEnabled } from '@tauri-apps/plugin-autostart';
@@ -97,6 +98,10 @@
   let showInDock = $state(false);
   let dockLoading = $state(false);
 
+  /** Window decorations (Linux): native titlebar vs. custom close button */
+  const isLinux = /Linux/.test(navigator.userAgent);
+  let windowDecorations = $state(configStore.general.windowDecorations ?? true);
+
   /** Permission states */
   let microphonePermission = $state<'unknown' | 'granted' | 'denied' | 'not_determined'>('unknown');
   let accessibilityPermission = $state<'unknown' | 'granted' | 'denied' | 'stale'>('unknown');
@@ -175,6 +180,18 @@
     }
   }
 
+  async function handleDecorationToggle(checked: boolean) {
+    windowDecorations = checked;
+    try {
+      await getCurrentWindow().setDecorations(checked);
+      configStore.general.windowDecorations = checked;
+      await configStore.save();
+    } catch (error) {
+      console.error('Failed to toggle window decorations:', error);
+      windowDecorations = !checked; // revert on failure
+    }
+  }
+
   let permissionChangedUnlisten: UnlistenFn | null = null;
 
   async function checkPermissions() {
@@ -763,6 +780,12 @@
         <span class="text-sm text-muted-foreground">Show in Dock</span>
         <Switch checked={showInDock} disabled={dockLoading} onCheckedChange={handleDockToggle} />
       </div>
+      {#if isLinux}
+        <div class="flex items-center justify-between py-1.5">
+          <span class="text-sm text-muted-foreground">Window Decorations</span>
+          <Switch checked={windowDecorations} onCheckedChange={handleDecorationToggle} />
+        </div>
+      {/if}
     </div>
   </details>
 {:else if stats}
@@ -1029,6 +1052,12 @@
           <span class="status-label">Show in Dock</span>
           <Switch checked={showInDock} disabled={dockLoading} onCheckedChange={handleDockToggle} />
         </div>
+        {#if isLinux}
+          <div class="autostart-row">
+            <span class="status-label">Window Decorations</span>
+            <Switch checked={windowDecorations} onCheckedChange={handleDecorationToggle} />
+          </div>
+        {/if}
       </div>
     </div>
   </section>
diff --git a/src/lib/components/WindowControls.svelte b/src/lib/components/WindowControls.svelte
new file mode 100644
index 0000000..cfe4e5a
--- /dev/null
+++ b/src/lib/components/WindowControls.svelte
@@ -0,0 +1,49 @@
+<script lang="ts">
+  /**
+   * Custom window controls for when native decorations are disabled (Linux).
+   * Just a close button — it hides the window to tray, matching the native
+   * close behaviour (the main window is never destroyed, only hidden).
+   */
+  import { getCurrentWindow } from '@tauri-apps/api/window';
+  import X from '@lucide/svelte/icons/x';
+
+  async function close() {
+    await getCurrentWindow().close();
+  }
+</script>
+
+<div class="window-controls" style="-webkit-app-region: no-drag; app-region: no-drag">
+  <button class="wc-btn wc-close" onclick={close} title="Close">
+    <X size={14} />
+  </button>
+</div>
+
+<style>
+  .window-controls {
+    display: flex;
+    align-items: center;
+  }
+
+  /* button.wc-btn for higher specificity than any global `button` reset */
+  button.wc-btn {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 28px;
+    height: 28px;
+    padding: 0;
+    border: none;
+    border-radius: 6px;
+    background: transparent;
+    color: var(--muted-foreground);
+    cursor: pointer;
+    transition:
+      background 0.15s,
+      color 0.15s;
+  }
+
+  button.wc-close:hover {
+    background: #e53935;
+    color: #fff;
+  }
+</style>
diff --git a/src/lib/stores/config.svelte.ts b/src/lib/stores/config.svelte.ts
index ab7f1ac..943cc30 100644
--- a/src/lib/stores/config.svelte.ts
+++ b/src/lib/stores/config.svelte.ts
@@ -105,6 +105,8 @@ export interface GeneralConfig {
   showRecordingIndicator: boolean;
   /** Visual style for the recording indicator */
   indicatorStyle: IndicatorStyle;
+  /** Show native window decorations (Linux); custom close button when off */
+  windowDecorations: boolean;
 }
 
 /** Recorder window position options */
@@ -192,6 +194,7 @@ interface ConfigRaw {
     check_for_updates: boolean;
     show_recording_indicator: boolean;
     indicator_style: IndicatorStyle;
+    window_decorations: boolean;
   };
   recorder: {
     position: RecorderPosition;
@@ -251,6 +254,7 @@ function parseConfig(raw: ConfigRaw): Config {
       checkForUpdates: raw.general.check_for_updates,
       showRecordingIndicator: raw.general.show_recording_indicator,
       indicatorStyle: raw.general.indicator_style,
+      windowDecorations: raw.general.window_decorations ?? true,
     },
     recorder: {
       position: raw.recorder.position,
@@ -311,6 +315,7 @@ function serialiseConfig(config: Config): ConfigRaw {
       check_for_updates: config.general.checkForUpdates,
       show_recording_indicator: config.general.showRecordingIndicator,
       indicator_style: config.general.indicatorStyle,
+      window_decorations: config.general.windowDecorations,
     },
     recorder: {
       position: config.recorder.position,
@@ -371,6 +376,7 @@ function getDefaultConfig(): Config {
       checkForUpdates: true,
       showRecordingIndicator: true,
       indicatorStyle: 'cursor-dot',
+      windowDecorations: true,
     },
     recorder: {
       position: 'top-right',
diff --git a/src/lib/windows/Settings.svelte b/src/lib/windows/Settings.svelte
index cba9f52..cc4eb75 100644
--- a/src/lib/windows/Settings.svelte
+++ b/src/lib/windows/Settings.svelte
@@ -39,6 +39,7 @@
   import { soundStore } from '../stores/sound.svelte';
   import { Button } from '$components/ui/button';
   import { Switch } from '$components/ui/switch';
+  import WindowControls from '../components/WindowControls.svelte';
 
   /** Settings pane definition */
   interface SettingsPane {
@@ -75,6 +76,10 @@
   /** About dialog visibility */
   let showAbout = $state(false);
 
+  /** Linux only — show the custom close button when decorations are disabled. */
+  const isLinux = /Linux/.test(navigator.userAgent);
+  const showWindowControls = $derived(isLinux && !configStore.general.windowDecorations);
+
   /** Map of shortcut IDs to their pending (unsaved) accelerators */
   const pendingChanges = $state<Map<string, string>>(new Map());
 
@@ -260,6 +265,11 @@
     {:else if pipelineStore.isProcessing}
       <span class="processing-indicator">Processing...</span>
     {/if}
+    {#if showWindowControls}
+      <div class="title-bar-controls">
+        <WindowControls />
+      </div>
+    {/if}
   </header>
 
   <div class="main-area">
@@ -719,6 +729,16 @@
     user-select: none;
   }
 
+  /* Pinned to the right edge so the centred title stays centred. */
+  .title-bar-controls {
+    position: absolute;
+    right: 8px;
+    top: 50%;
+    transform: translateY(-50%);
+    display: flex;
+    align-items: center;
+  }
+
   .main-area {
     display: flex;
     flex: 1;

From 12ece40b97989422dd69cfe70769e9bb7d77fcce Mon Sep 17 00:00:00 2001
From: nephalemsec <nephalem.sec@protonmail.com>
Date: Fri, 12 Jun 2026 20:41:17 +1000
Subject: [PATCH 02/10] fix(dev): keep Tailwind out of Svelte component styles
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Under Vite 8 + @tailwindcss/vite 4.3 + vite-plugin-svelte 7, the Tailwind
transform matches Svelte's `&lang.css` virtual modules and intermittently
receives the raw `.svelte` source, throwing `Invalid declaration: \`invoke\``
500s in the dev server. Exclude `.svelte?` modules from Tailwind's transform —
no component style uses Tailwind directives (sole entry is src/app.css), so
output is unchanged.
---
 vite.config.ts | 31 ++++++++++++++++++++++++++++++-
 1 file changed, 30 insertions(+), 1 deletion(-)

diff --git a/vite.config.ts b/vite.config.ts
index b157e31..3d131fe 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -1,13 +1,42 @@
 import { defineConfig } from 'vite';
 import { sveltekit } from '@sveltejs/kit/vite';
 import tailwindcss from '@tailwindcss/vite';
+import type { Plugin } from 'vite';
 
 // @ts-expect-error process is a nodejs global
 const host = process.env.TAURI_DEV_HOST;
 
+/**
+ * Keep Tailwind out of Svelte's scoped component styles.
+ *
+ * A Svelte `<style>` block compiles to a virtual module whose id ends in
+ * `&lang.css` (e.g. `Settings.svelte?svelte&type=style&lang.css`). The
+ * `@tailwindcss/vite` transform filter matches `&lang.css`, so it treats every
+ * component style as a Tailwind entrypoint. Under Vite 8 + vite-plugin-svelte 7
+ * the dev server intermittently hands the plugin the raw `.svelte` source (the
+ * `<script>` block) before Svelte has extracted the CSS, so Tailwind's CSS
+ * parser blows up on the first JS token — the `Invalid declaration: \`invoke\``
+ * 500s seen in the dev log.
+ *
+ * No component style in this project uses Tailwind directives
+ * (@apply/@reference/@tailwind/@variant) — the sole Tailwind entry is
+ * `src/app.css` — so excluding component-style virtual modules from Tailwind's
+ * transform is a no-op for output: Svelte still serves the scoped CSS untouched.
+ */
+function tailwindSkippingSvelteStyles(): Plugin[] {
+  const plugins = tailwindcss() as Plugin[];
+  for (const plugin of plugins) {
+    const transform = plugin.transform as { filter?: { id?: { exclude?: RegExp[] } } } | undefined;
+    if (plugin.name?.startsWith('@tailwindcss/vite:generate') && transform?.filter?.id) {
+      transform.filter.id.exclude = [...(transform.filter.id.exclude ?? []), /\.svelte\?/];
+    }
+  }
+  return plugins;
+}
+
 // https://vite.dev/config/
 export default defineConfig(async () => ({
-  plugins: [tailwindcss(), sveltekit()],
+  plugins: [...tailwindSkippingSvelteStyles(), sveltekit()],
 
   // Vite options tailored for Tauri development and only applied in `tauri dev` or `tauri build`
   //

From 159d0136c585f57efc845e67b2160f2e47d44045 Mon Sep 17 00:00:00 2001
From: nephalemsec <nephalem.sec@protonmail.com>
Date: Fri, 12 Jun 2026 21:31:25 +1000
Subject: [PATCH 03/10] feat(linux): optional GPU (CUDA) Parakeet via
 sherpa-onnx CUDA prebuilt
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds an opt-in `parakeet-cuda` feature that runs Parakeet on an NVIDIA GPU
through sherpa-onnx's CUDA execution provider. Default builds are unchanged
(Parakeet stays CPU; macOS stays CoreML).

- Cargo: `parakeet-cuda = ["parakeet", "sherpa-onnx/shared"]`. sherpa-onnx is
  now `default-features = false` so the link mode is explicit — the default
  `parakeet` feature still resolves to static CPU (sherpa-onnx-sys defaults to
  static when no link feature is set), so nothing changes for current builds.
- parakeet.rs: under `parakeet-cuda` on Linux, request the `cuda` provider and
  fall back to CPU if the EP can't initialise (mirrors the macOS CoreML path).
- flake: a `cuda` dev shell fetches the k2-fsa CUDA prebuilt (CUDA 12 / cuDNN 9)
  and wires SHERPA_ONNX_LIB_DIR + LD_LIBRARY_PATH (sherpa libs, cuDNN, cudart,
  cublas, driver) so the CUDA provider loads at build and runtime.

Build/run:
  nix develop .#cuda
  pnpm tauri dev --no-default-features --features parakeet-cuda,vulkan

Verified: links against the CUDA sherpa-onnx (libonnxruntime_providers_cuda.so)
and the default CPU build is unaffected. Real GPU engagement should be confirmed
on-device with `nvidia-smi` during a transcription — onnxruntime silently falls
back to CPU if cuDNN/driver libs aren't found.
---
 flake.nix                               | 198 ++++++++++++++----------
 src-tauri/Cargo.toml                    |  15 +-
 src-tauri/src/transcription/parakeet.rs |  22 ++-
 3 files changed, 151 insertions(+), 84 deletions(-)

diff --git a/flake.nix b/flake.nix
index e52e911..beaa96c 100644
--- a/flake.nix
+++ b/flake.nix
@@ -29,18 +29,108 @@
         # CUDA packages for whisper.cpp GPU acceleration
         cudaPackages = pkgs.cudaPackages_12;
 
-      in {
-        devShells.default = pkgs.mkShell {
-          # Platform-specific library paths (Linux)
+        # CUDA-enabled sherpa-onnx prebuilt (k2-fsa release) for GPU Parakeet.
+        # The `parakeet-cuda` cargo feature links sherpa-onnx as `shared`, and
+        # SHERPA_ONNX_LIB_DIR points it here instead of downloading the CPU build.
+        # This archive ships libsherpa-onnx-c-api.so + libonnxruntime.so with the
+        # CUDA execution provider (libonnxruntime_providers_cuda.so). cuDNN/cudart
+        # are supplied via LD_LIBRARY_PATH in the `cuda` dev shell below.
+        sherpaOnnxCuda = pkgs.stdenvNoCC.mkDerivation {
+          pname = "sherpa-onnx-cuda";
+          version = "1.13.2";
+          src = pkgs.fetchurl {
+            url = "https://github.com/k2-fsa/sherpa-onnx/releases/download/v1.13.2/sherpa-onnx-v1.13.2-cuda-12.x-cudnn-9.x-linux-x64-gpu.tar.bz2";
+            hash = "sha256-vRE8k6GLoPm24MrEaramoXYGvde3cbbq7gy9b5bOY/4=";
+          };
+          dontConfigure = true;
+          dontBuild = true;
+          installPhase = "mkdir -p $out && cp -r lib $out/lib";
+        };
+
+        # Dev-shell packages (shared by both shells).
+        commonPackages = with pkgs; [
+          # Rust / Tauri
+          rustToolchain
+          cargo
+          rustc
+          rust-analyzer
+
+          # Tauri dependencies (platform-specific)
+          openssl
+          pkg-config
+        ] ++ pkgs.lib.optionals pkgs.stdenv.isLinux [
+          # Linux-only Tauri dependencies
+          webkitgtk_4_1
+          libappindicator-gtk3
+          librsvg
+          alsa-lib
+          # whisper.cpp needs libclang for bindgen
+          llvmPackages.libclang
+          # X11 development libraries for x11rb (mouse tracking, display detection)
+          libx11
+          libxcursor
+          libxrandr
+          libxi
+          # Vulkan for whisper.cpp GPU acceleration (AMD & NVIDIA)
+          vulkan-loader
+          vulkan-headers
+          vulkan-tools
+          # Shader compiler for Vulkan
+          shaderc
+          # CUDA toolkit for whisper.cpp CUDA acceleration (NVIDIA GPUs)
+          cudaPackages.cudatoolkit
+          cudaPackages.cuda_nvcc
+          cudaPackages.cuda_cudart
+          cudaPackages.cuda_cccl
+          cudaPackages.libcublas
+          # GCC for CUDA compilation
+          gcc
+        ] ++ pkgs.lib.optionals pkgs.stdenv.isDarwin [
+          # macOS: applesoft libraries (via Xcode) are used automatically
+          libiconv
+          # libclang for bindgen (whisper.cpp)
+          llvmPackages.libclang
+        ] ++ [
+          # Frontend
+          nodejs_22
+          pnpm
+
+          # Build tools
+          cmake
+        ] ++ pkgs.lib.optionals pkgs.stdenv.isLinux [
+          glib
+          libsecret
+          # Native Wayland keyboard simulation (alternative to X11-based enigo)
+          wtype
+        ];
+
+        # whisper-rs-sys runs bindgen over ggml-vulkan.h. bindgen invokes libclang
+        # directly, bypassing the nix cc-wrapper, so it cannot find the libc headers
+        # (stdio.h) or clang's own builtin headers (stddef.h). bindgen then errors and
+        # whisper-rs-sys SILENTLY falls back to its bundled no-Vulkan bindings, so the
+        # ggml_backend_vk_* symbols go missing and whisper-rs fails to compile its
+        # Vulkan module (issue #64). Feed bindgen the cc-wrapper's libc flags plus
+        # clang's resource dir. A standard apt system finds these in /usr/include and
+        # lib/clang, so CI does not need this.
+        bindgenHook = pkgs.lib.optionalString pkgs.stdenv.isLinux ''
+
+          export BINDGEN_EXTRA_CLANG_ARGS="$(< ${pkgs.stdenv.cc}/nix-support/libc-cflags) -idirafter ${pkgs.llvmPackages.libclang.lib}/lib/clang/${pkgs.lib.versions.major pkgs.llvmPackages.libclang.version}/include"
+        '';
+
+        # One dev-shell definition, optionally wired for GPU Parakeet (CUDA).
+        mkThothShell = { gpuParakeet ? false }: pkgs.mkShell ({
+          # Platform-specific library paths (Linux). With gpuParakeet, also expose
+          # the CUDA sherpa-onnx libs + cuDNN so the CUDA execution provider loads.
           LD_LIBRARY_PATH = pkgs.lib.optionalString pkgs.stdenv.isLinux
             (pkgs.lib.makeLibraryPath ([
               pkgs.libappindicator-gtk3
               pkgs.vulkan-loader
-            ] ++ pkgs.lib.optionals pkgs.stdenv.isLinux [
-              # CUDA runtime libraries for whisper.cpp linking
               cudaPackages.cuda_cudart
               cudaPackages.cuda_cccl
               cudaPackages.libcublas
+            ] ++ pkgs.lib.optionals gpuParakeet [
+              sherpaOnnxCuda       # libsherpa-onnx-c-api.so + onnxruntime CUDA EP
+              cudaPackages.cudnn   # libcudnn.so.9 the CUDA EP needs
             ]) + ":/run/opengl-driver/lib");  # NVIDIA driver (libcuda.so)
 
           # Workaround for webkit2gtk Wayland issues (Linux only)
@@ -57,71 +147,24 @@
           # Linker search path for CUDA driver (libcuda.so)
           RUSTFLAGS = pkgs.lib.optionalString pkgs.stdenv.isLinux "-L /run/opengl-driver/lib";
 
-          packages = with pkgs; [
-            # Rust / Tauri
-            rustToolchain
-            cargo
-            rustc
-            rust-analyzer
-
-            # Tauri dependencies (platform-specific)
-            openssl
-            pkg-config
-          ] ++ lib.optionals stdenv.isLinux [
-            # Linux-only Tauri dependencies
-            webkitgtk_4_1
-            libappindicator-gtk3
-            librsvg
-            alsa-lib
-            # whisper.cpp needs libclang for bindgen
-            llvmPackages.libclang
-            # X11 development libraries for x11rb (mouse tracking, display detection)
-            libx11
-            libxcursor
-            libxrandr
-            libxi
-            # Vulkan for whisper.cpp GPU acceleration (AMD & NVIDIA)
-            vulkan-loader
-            vulkan-headers
-            vulkan-tools
-            # Shader compiler for Vulkan
-            shaderc
-            # CUDA toolkit for whisper.cpp CUDA acceleration (NVIDIA GPUs)
-            cudaPackages.cudatoolkit
-            cudaPackages.cuda_nvcc
-            cudaPackages.cuda_cudart
-            cudaPackages.cuda_cccl
-            cudaPackages.libcublas
-            # GCC for CUDA compilation
-            gcc
-          ] ++ lib.optionals stdenv.isDarwin [
-            # macOS: applesoft libraries (via Xcode) are used automatically
-            libiconv
-            # libclang for bindgen (whisper.cpp)
-            llvmPackages.libclang
-          ] ++ [
-            # Frontend
-            nodejs_22
-            pnpm
-
-            # Build tools
-            cmake
-
-            # Useful utilities (Linux-only)
-          ] ++ lib.optionals stdenv.isLinux [
-            glib
-            libsecret
-            # Native Wayland keyboard simulation (alternative to X11-based enigo)
-            wtype
-          ];
+          packages = commonPackages
+            ++ pkgs.lib.optionals (gpuParakeet && pkgs.stdenv.isLinux) [ cudaPackages.cudnn ];
 
           shellHook = ''
-            echo "𓅝 Thoth Development Environment"
+            echo "𓅝 Thoth Development Environment${pkgs.lib.optionalString gpuParakeet " (GPU Parakeet / CUDA)"}"
             echo "================================"
             echo "  Rust: $(rustc --version)"
             echo "  Node: $(node --version)"
             echo "  pnpm: $(pnpm --version)"
             echo ""
+          '' + (if gpuParakeet then ''
+            echo "GPU Parakeet (NVIDIA CUDA) is wired up. Build/run with:"
+            echo "  pnpm tauri dev --no-default-features --features parakeet-cuda,vulkan"
+            echo "  pnpm tauri build --no-default-features --features parakeet-cuda,vulkan"
+            echo ""
+            echo "Then transcribe and watch 'nvidia-smi' to confirm the GPU engages."
+            echo "Logs show 'Attempting CUDA provider...' / 'CUDA provider initialised'."
+          '' else ''
             echo "Commands:"
             echo "  pnpm install        - Install dependencies"
             echo "  pnpm tauri dev      - Start development build"
@@ -130,22 +173,17 @@
             echo "  cargo test          - Run Rust tests (from src-tauri/)"
             echo ""
             echo "GPU Acceleration (Linux):"
-            echo "  --features cuda     - NVIDIA GPUs (requires CUDA drivers)"
-            echo "  --features hipblas  - AMD GPUs (requires ROCm)"
-            echo "  --features vulkan   - Cross-platform (experimental)"
-          '' + pkgs.lib.optionalString pkgs.stdenv.isLinux ''
-
-            # whisper-rs-sys runs bindgen over ggml-vulkan.h. bindgen invokes
-            # libclang directly, bypassing the nix cc-wrapper, so it cannot find
-            # the libc headers (stdio.h) or clang's own builtin headers
-            # (stddef.h). bindgen then errors and whisper-rs-sys SILENTLY falls
-            # back to its bundled no-Vulkan bindings, so the ggml_backend_vk_*
-            # symbols go missing and whisper-rs fails to compile its Vulkan
-            # module (issue #64). Feed bindgen the cc-wrapper's libc flags plus
-            # clang's resource dir. A standard apt system finds these in
-            # /usr/include and lib/clang, so CI does not need this.
-            export BINDGEN_EXTRA_CLANG_ARGS="$(< ${pkgs.stdenv.cc}/nix-support/libc-cflags) -idirafter ${pkgs.llvmPackages.libclang.lib}/lib/clang/${pkgs.lib.versions.major pkgs.llvmPackages.libclang.version}/include"
-          '';
-        };
+            echo "  --features cuda     - NVIDIA GPUs (Whisper)"
+            echo "  --features vulkan   - Cross-platform (Whisper)"
+            echo "  nix develop .#cuda  - GPU Parakeet (NVIDIA, via sherpa-onnx CUDA)"
+          '') + bindgenHook;
+        } // pkgs.lib.optionalAttrs gpuParakeet {
+          # Make sherpa-onnx-sys link the CUDA libs instead of downloading CPU ones.
+          SHERPA_ONNX_LIB_DIR = "${sherpaOnnxCuda}/lib";
+        });
+
+      in {
+        devShells.default = mkThothShell { };
+        devShells.cuda = mkThothShell { gpuParakeet = true; };
       });
 }
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index 7110994..721cdd9 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -36,9 +36,12 @@ webrtc-vad = "0.4"
 symphonia = { version = "0.6", features = ["mp3", "aac", "ogg", "vorbis", "flac", "wav", "pcm", "isomp4"] }
 
 # Transcription
-# Official k2-fsa crate; static + auto-download by default; macOS Parakeet TDT fallback
-# (Linux CI builds without the parakeet feature).
-sherpa-onnx = { version = "1.13", optional = true }
+# Official k2-fsa crate. default-features = false drops its built-in `static`
+# marker; sherpa-onnx-sys still defaults to static linking when no link feature
+# is set (= the `parakeet` feature → CPU, unchanged). The `parakeet-cuda` feature
+# switches it to `shared` so a GPU build can link a CUDA-enabled sherpa-onnx via
+# the SHERPA_ONNX_LIB_DIR env var. (Linux CI builds without the parakeet feature.)
+sherpa-onnx = { version = "1.13", default-features = false, optional = true }
 # fluidaudio-rs: Apple Neural Engine backend via CoreML (macOS-only, Apple Silicon).
 # WHY fork, not crates.io: the upstream crate lacks platform compile-guards (fails to
 # build on Linux/Windows); the fork wraps the implementation in
@@ -127,6 +130,12 @@ objc2-core-foundation = { version = "0.3", features = ["CFString"] }
 [features]
 default = ["parakeet", "fluidaudio"]
 parakeet = ["dep:sherpa-onnx"]
+# GPU Parakeet (NVIDIA): links a CUDA-enabled sherpa-onnx (shared). Build with
+#   cargo build --no-default-features --features "parakeet-cuda,vulkan"
+# and point SHERPA_ONNX_LIB_DIR at the k2-fsa CUDA prebuilt's lib dir. At runtime
+# the recognizer requests the `cuda` provider and falls back to CPU if the EP
+# isn't available. See flake.nix's `cuda` dev shell which wires this up.
+parakeet-cuda = ["parakeet", "sherpa-onnx/shared"]
 fluidaudio = ["dep:fluidaudio-rs"]
 # GPU acceleration for whisper.cpp (mutually exclusive, only use one)
 # Use: cargo build --features cuda      for NVIDIA GPUs
diff --git a/src-tauri/src/transcription/parakeet.rs b/src-tauri/src/transcription/parakeet.rs
index 11a9598..1b0c8a7 100644
--- a/src-tauri/src/transcription/parakeet.rs
+++ b/src-tauri/src/transcription/parakeet.rs
@@ -85,7 +85,27 @@ impl TranscriptionService {
             }
         };
 
-        #[cfg(not(target_os = "macos"))]
+        // Linux/Windows: with the `parakeet-cuda` feature, try the CUDA execution
+        // provider (NVIDIA GPU) first and fall back to CPU. Without it, CPU only.
+        // Note: onnxruntime silently falls back to CPU if the CUDA EP/libs aren't
+        // present, so confirm real GPU use via `nvidia-smi` during a transcription.
+        #[cfg(all(not(target_os = "macos"), feature = "parakeet-cuda"))]
+        let recognizer = {
+            tracing::info!("Attempting CUDA provider for GPU acceleration");
+            match OfflineRecognizer::create(&build_config(Some("cuda".into()))) {
+                Some(r) => {
+                    tracing::info!("CUDA provider initialised (verify GPU use with nvidia-smi)");
+                    r
+                }
+                None => {
+                    tracing::warn!("CUDA provider failed, falling back to CPU");
+                    OfflineRecognizer::create(&build_config(Some("cpu".into())))
+                        .ok_or_else(|| anyhow!("Failed to create Parakeet recognizer with CPU"))?
+                }
+            }
+        };
+
+        #[cfg(all(not(target_os = "macos"), not(feature = "parakeet-cuda")))]
         let recognizer = {
             tracing::info!("Using CPU provider");
             OfflineRecognizer::create(&build_config(Some("cpu".into())))

From 41309f186813672f033471884e3cd8ac700af349 Mon Sep 17 00:00:00 2001
From: nephalemsec <nephalem.sec@protonmail.com>
Date: Fri, 12 Jun 2026 21:47:40 +1000
Subject: [PATCH 04/10] fix(nix): supply full CUDA math-lib set for the
 Parakeet CUDA EP

The onnxruntime CUDA provider dlopen()s libcublasLt/cublas/curand/cufft/cudart/
cudnn; a single missing one aborts the process (no CPU fallback). The cuda dev
shell only had cudnn/cudart/cublas, so it failed on libcurand.so.10. Add
libcurand, libcufft, libcusparse to LD_LIBRARY_PATH (cublasLt ships with cublas).
---
 flake.nix | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/flake.nix b/flake.nix
index beaa96c..7c3c9c4 100644
--- a/flake.nix
+++ b/flake.nix
@@ -129,8 +129,14 @@
               cudaPackages.cuda_cccl
               cudaPackages.libcublas
             ] ++ pkgs.lib.optionals gpuParakeet [
-              sherpaOnnxCuda       # libsherpa-onnx-c-api.so + onnxruntime CUDA EP
-              cudaPackages.cudnn   # libcudnn.so.9 the CUDA EP needs
+              sherpaOnnxCuda           # libsherpa-onnx-c-api.so + onnxruntime CUDA EP
+              cudaPackages.cudnn       # libcudnn.so.9
+              # The onnxruntime CUDA execution provider dlopen()s the full CUDA
+              # math-library set; a single missing one makes it abort (no CPU
+              # fallback), so provide all of them.
+              cudaPackages.libcurand   # libcurand.so.10
+              cudaPackages.libcufft    # libcufft.so.11
+              cudaPackages.libcusparse # libcusparse.so.12
             ]) + ":/run/opengl-driver/lib");  # NVIDIA driver (libcuda.so)
 
           # Workaround for webkit2gtk Wayland issues (Linux only)

From 0996ca86be903d8ba860a1d63df1292899a55833 Mon Sep 17 00:00:00 2001
From: nephalemsec <nephalem.sec@protonmail.com>
Date: Fri, 12 Jun 2026 22:21:32 +1000
Subject: [PATCH 05/10] fix(linux): paste via wl-copy + hyprctl on
 Hyprland/Wayland

main pastes by setting the clipboard with arboard and synthesising a
wtype/enigo keystroke. On wlroots compositors (Hyprland) arboard's clipboard
isn't readable by other clients and the synthetic keystroke doesn't land, so
paste silently fails. On Wayland, set the clipboard with wl-copy and dispatch
the paste through the compositor: Hyprland uses 'hyprctl dispatch sendshortcut
CTRL,v' for GUI apps and wtype Ctrl+Shift+V for terminals (detected via
hyprctl activewindow); other compositors keep the wtype/enigo path.
---
 src-tauri/src/text_insert.rs | 137 ++++++++++++++++++++++++++++++++++-
 1 file changed, 136 insertions(+), 1 deletion(-)

diff --git a/src-tauri/src/text_insert.rs b/src-tauri/src/text_insert.rs
index e0381b7..cb06d79 100644
--- a/src-tauri/src/text_insert.rs
+++ b/src-tauri/src/text_insert.rs
@@ -120,7 +120,31 @@ impl TextInsertService {
     fn insert_by_paste(&self, text: &str) -> Result<(), String> {
         debug!("Inserting {} characters by paste", text.len());
 
-        // Set clipboard to new text
+        // On Wayland, arboard doesn't reliably serve clipboard content to other
+        // clients, and wtype/enigo paste keystrokes don't land in many apps on
+        // wlroots compositors. Use wl-copy for the clipboard and the compositor's
+        // own paste dispatch (hyprctl on Hyprland) instead.
+        #[cfg(target_os = "linux")]
+        if is_wayland() {
+            if !Self::wl_copy_set_clipboard(text) {
+                return Err("Failed to set clipboard via wl-copy".to_string());
+            }
+            let pasted = if is_hyprland() {
+                Self::paste_with_hyprctl()
+            } else {
+                Self::try_paste_with_wtype() || Self::paste_with_enigo().is_ok()
+            };
+            if pasted {
+                info!(
+                    "Inserted {} characters via wl-copy + Wayland paste",
+                    text.len()
+                );
+                return Ok(());
+            }
+            return Err("Failed to paste on Wayland".to_string());
+        }
+
+        // macOS / Linux X11: arboard clipboard + keystroke paste.
         let mut clipboard =
             arboard::Clipboard::new().map_err(|e| format!("Failed to access clipboard: {}", e))?;
 
@@ -399,6 +423,117 @@ impl TextInsertService {
         debug!("Pasted via enigo (Ctrl+Shift+V)");
         Ok(())
     }
+
+    /// Set the Wayland clipboard via `wl-copy` (serves content to all clients,
+    /// unlike arboard's ownership-based clipboard which other apps can't read).
+    #[cfg(target_os = "linux")]
+    fn wl_copy_set_clipboard(text: &str) -> bool {
+        use std::io::Write;
+        use std::process::{Command, Stdio};
+
+        let mut child = match Command::new("wl-copy")
+            .stdin(Stdio::piped())
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .spawn()
+        {
+            Ok(c) => c,
+            Err(e) => {
+                warn!("Failed to spawn wl-copy: {}", e);
+                return false;
+            }
+        };
+
+        if let Some(mut stdin) = child.stdin.take() {
+            if stdin.write_all(text.as_bytes()).is_err() {
+                return false;
+            }
+        }
+
+        let ok = child.wait().map(|s| s.success()).unwrap_or(false);
+        if ok {
+            thread::sleep(Duration::from_millis(20));
+        }
+        ok
+    }
+
+    /// Paste on Hyprland: GUI apps via `hyprctl dispatch sendshortcut CTRL,v`
+    /// (avoids the layout-change notification a synthetic keypress can trigger);
+    /// terminals via `wtype` Ctrl+Shift+V (their paste binding).
+    #[cfg(target_os = "linux")]
+    fn paste_with_hyprctl() -> bool {
+        use std::process::{Command, Stdio};
+
+        if Self::active_window_is_terminal() {
+            Command::new("wtype")
+                .args([
+                    "-M", "ctrl", "-M", "shift", "v", "-m", "shift", "-m", "ctrl",
+                ])
+                .status()
+                .map(|s| s.success())
+                .unwrap_or(false)
+        } else {
+            Command::new("hyprctl")
+                .args(["dispatch", "sendshortcut", "CTRL,v,activewindow"])
+                .stdout(Stdio::null())
+                .stderr(Stdio::null())
+                .status()
+                .map(|s| s.success())
+                .unwrap_or(false)
+        }
+    }
+
+    /// Whether the active Hyprland window is a terminal emulator (terminals
+    /// paste with Ctrl+Shift+V, GUI apps with Ctrl+V).
+    #[cfg(target_os = "linux")]
+    fn active_window_is_terminal() -> bool {
+        use std::process::Command;
+
+        let output = match Command::new("hyprctl")
+            .args(["activewindow", "-j"])
+            .output()
+        {
+            Ok(o) if o.status.success() => o.stdout,
+            _ => return false,
+        };
+        let json: serde_json::Value = match serde_json::from_slice(&output) {
+            Ok(v) => v,
+            Err(_) => return false,
+        };
+        let class = json
+            .get("class")
+            .and_then(|v| v.as_str())
+            .unwrap_or("")
+            .to_lowercase();
+        [
+            "kitty",
+            "alacritty",
+            "foot",
+            "wezterm",
+            "terminal",
+            "konsole",
+            "xterm",
+            "terminator",
+            "ghostty",
+        ]
+        .iter()
+        .any(|t| class.contains(t))
+    }
+}
+
+/// Whether the current session is Wayland (Linux only).
+#[cfg(target_os = "linux")]
+fn is_wayland() -> bool {
+    std::env::var_os("WAYLAND_DISPLAY").is_some()
+        || std::env::var("XDG_SESSION_TYPE")
+            .map(|s| s.eq_ignore_ascii_case("wayland"))
+            .unwrap_or(false)
+}
+
+/// Whether the compositor is Hyprland (Linux only).
+#[cfg(target_os = "linux")]
+fn is_hyprland() -> bool {
+    std::env::var_os("HYPRLAND_INSTANCE_SIGNATURE").is_some()
 }
 
 impl Default for TextInsertService {

From 353d3a94c07abbe5ffee6e6e1b64ea74df62652f Mon Sep 17 00:00:00 2001
From: nephalemsec <nephalem.sec@protonmail.com>
Date: Fri, 12 Jun 2026 22:33:17 +1000
Subject: [PATCH 06/10] =?UTF-8?q?fix(ui):=20poll=20transcription=20readine?=
 =?UTF-8?q?ss=20so=20the=20status=20leaves=20'Loading=E2=80=A6'?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The Overview System status checked is_transcription_ready once at mount; if the
model was downloaded but the warm-up thread hadn't finished, it stuck on
'Loading…' until the next pane visit. Poll every 1s (max 30s) until ready.
---
 src/lib/components/OverviewPane.svelte | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/src/lib/components/OverviewPane.svelte b/src/lib/components/OverviewPane.svelte
index 079cfae..fa9694f 100644
--- a/src/lib/components/OverviewPane.svelte
+++ b/src/lib/components/OverviewPane.svelte
@@ -467,6 +467,26 @@
     setupState = transcriptionReady ? 'ready' : 'needed';
     isLoading = false;
 
+    // Poll for transcription readiness if the model is downloaded but not yet
+    // loaded (the backend warm-up thread may still be initialising). Without
+    // this the status sticks on "Loading…" until the next pane visit.
+    if (modelDownloaded && !transcriptionReady) {
+      const pollInterval = setInterval(async () => {
+        try {
+          const ready = await invoke<boolean>('is_transcription_ready');
+          if (ready) {
+            transcriptionReady = true;
+            setupState = 'ready';
+            clearInterval(pollInterval);
+          }
+        } catch {
+          clearInterval(pollInterval);
+        }
+      }, 1000);
+      // Stop polling after 30 seconds regardless.
+      setTimeout(() => clearInterval(pollInterval), 30000);
+    }
+
     // Ollama check runs separately to avoid blocking (30s timeout)
     if (!configStore.enhancement.enabled) {
       ollamaStatus = 'not-configured';

From d1ee8f26216ce793727f59f9d01dcc6084b5a03b Mon Sep 17 00:00:00 2001
From: nephalemsec <nephalem.sec@protonmail.com>
Date: Fri, 12 Jun 2026 22:44:25 +1000
Subject: [PATCH 07/10] fix(linux): native Hyprland global shortcuts via
 hyprctl + FIFO
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

On Hyprland the XDG GlobalShortcuts portal registers a shortcut but never binds
a key (the binding comes back empty in the activation log), so global hotkeys
never fire. Detect Hyprland (HYPRLAND_INSTANCE_SIGNATURE) and bind the
configured accelerators with 'hyprctl keyword bind/bindr', whose exec dispatcher
writes the shortcut id to a FIFO; a listener thread routes each id through
manager::dispatch_shortcut_action — the same dispatcher used by the X11/macOS
plugin callback. Modifier-only keys (e.g. Right Shift) use bindr + keycodes.
---
 src-tauri/src/shortcuts/hyprland.rs | 162 ++++++++++++++++++++++++++++
 src-tauri/src/shortcuts/linux.rs    |  12 ++-
 src-tauri/src/shortcuts/mod.rs      |   2 +
 3 files changed, 174 insertions(+), 2 deletions(-)
 create mode 100644 src-tauri/src/shortcuts/hyprland.rs

diff --git a/src-tauri/src/shortcuts/hyprland.rs b/src-tauri/src/shortcuts/hyprland.rs
new file mode 100644
index 0000000..1003d67
--- /dev/null
+++ b/src-tauri/src/shortcuts/hyprland.rs
@@ -0,0 +1,162 @@
+//! Native Hyprland global shortcuts via `hyprctl` binds + a FIFO.
+//!
+//! On Hyprland the XDG GlobalShortcuts portal registers a shortcut but never
+//! actually binds a key (the binding comes back empty), so global hotkeys never
+//! fire. Instead we bind directly with `hyprctl keyword bind`, whose `exec`
+//! dispatcher writes the shortcut id to a FIFO we listen on; each id is then
+//! routed through [`super::manager::dispatch_shortcut_action`] — the same
+//! dispatcher the X11/macOS plugin callback uses, so behaviour is identical.
+
+use std::process::Command;
+use tauri::{AppHandle, Runtime};
+
+/// Whether the current session is Hyprland.
+pub fn is_hyprland() -> bool {
+    std::env::var_os("HYPRLAND_INSTANCE_SIGNATURE").is_some()
+}
+
+fn fifo_path() -> String {
+    match std::env::var("XDG_RUNTIME_DIR") {
+        Ok(dir) if !dir.is_empty() => format!("{dir}/thoth-shortcuts.fifo"),
+        _ => format!("/tmp/thoth-shortcuts-{}.fifo", std::process::id()),
+    }
+}
+
+/// Set up native Hyprland binds and the FIFO listener.
+pub fn setup<R: Runtime>(app: &AppHandle<R>) {
+    start_fifo_listener(app.clone());
+    bind_shortcuts();
+}
+
+/// Convert a Tauri accelerator ("CommandOrControl+Shift+Space", "ShiftRight")
+/// into a Hyprland "MODS, key" bind string. Modifier-only keys use keycodes,
+/// which are more reliable than key names across keyboard layouts.
+fn accelerator_to_hyprland_bind(accel: &str) -> String {
+    let mut modifiers = Vec::new();
+    let mut key = String::new();
+    for part in accel.split('+') {
+        match part {
+            "CommandOrControl" | "CmdOrCtrl" | "Control" | "Ctrl" => modifiers.push("CTRL"),
+            "Shift" => modifiers.push("SHIFT"),
+            "Alt" | "Option" => modifiers.push("ALT"),
+            "Meta" | "Super" | "Command" | "Cmd" => modifiers.push("SUPER"),
+            "ShiftRight" => key = "code:62".to_string(),
+            "ShiftLeft" => key = "code:42".to_string(),
+            "ControlRight" => key = "code:97".to_string(),
+            "ControlLeft" => key = "code:29".to_string(),
+            "AltRight" => key = "code:100".to_string(),
+            "AltLeft" => key = "code:56".to_string(),
+            other => key = other.to_lowercase(),
+        }
+    }
+    format!("{}, {}", modifiers.join(" "), key)
+}
+
+/// Modifier-only accelerators fire on release, so they need `bindr`, not `bind`.
+fn is_modifier_only(accel: &str) -> bool {
+    matches!(
+        accel,
+        "ShiftRight" | "ShiftLeft" | "ControlRight" | "ControlLeft" | "AltRight" | "AltLeft"
+    )
+}
+
+/// Bind the configured shortcuts through `hyprctl`.
+fn bind_shortcuts() {
+    use crate::shortcuts::manager::shortcut_ids;
+
+    let cfg = match crate::config::get_config() {
+        Ok(c) => c,
+        Err(e) => {
+            tracing::error!("Hyprland binds: failed to load config: {e}");
+            return;
+        }
+    };
+
+    let fifo = fifo_path();
+    let mut binds: Vec<(&str, String)> = vec![(
+        shortcut_ids::TOGGLE_RECORDING,
+        cfg.shortcuts.toggle_recording.clone(),
+    )];
+    if let Some(alt) = cfg.shortcuts.toggle_recording_alt.clone() {
+        binds.push((shortcut_ids::TOGGLE_RECORDING_ALT, alt));
+    }
+    if let Some(copy) = cfg.shortcuts.copy_last.clone() {
+        binds.push((shortcut_ids::COPY_LAST_TRANSCRIPTION, copy));
+    }
+
+    for (id, accel) in binds {
+        if accel.is_empty() {
+            continue;
+        }
+        let bind = accelerator_to_hyprland_bind(&accel);
+        let bind_type = if is_modifier_only(&accel) {
+            "bindr"
+        } else {
+            "bind"
+        };
+
+        // Clear any stale binds (both variants) before rebinding.
+        for unbind in ["unbind", "unbindr"] {
+            let _ = Command::new("hyprctl")
+                .args(["keyword", unbind, &bind])
+                .output();
+        }
+
+        let dispatch = format!("{bind}, exec, echo {id} > {fifo}");
+        match Command::new("hyprctl")
+            .args(["keyword", bind_type, &dispatch])
+            .output()
+        {
+            Ok(o) if o.status.success() => {
+                tracing::info!("Hyprland bind '{id}' -> {bind} ({bind_type})");
+            }
+            Ok(o) => tracing::error!(
+                "hyprctl {bind_type} failed for '{id}': {}",
+                String::from_utf8_lossy(&o.stderr)
+            ),
+            Err(e) => tracing::error!("hyprctl {bind_type} failed for '{id}': {e}"),
+        }
+    }
+}
+
+/// Create the FIFO and route each id written to it through the dispatcher.
+fn start_fifo_listener<R: Runtime>(app: AppHandle<R>) {
+    use std::fs;
+    use std::io::{BufRead, BufReader};
+
+    let path = fifo_path();
+    let _ = fs::remove_file(&path);
+    match Command::new("mkfifo").arg(&path).status() {
+        Ok(s) if s.success() => {}
+        Ok(s) => {
+            tracing::error!("mkfifo failed with status {s}");
+            return;
+        }
+        Err(e) => {
+            tracing::error!("Failed to run mkfifo: {e}");
+            return;
+        }
+    }
+    tracing::info!("Hyprland shortcut FIFO listening at {path}");
+
+    std::thread::spawn(move || {
+        loop {
+            // Opening blocks until a writer (the hyprctl `exec`) opens the FIFO.
+            let file = match fs::File::open(&path) {
+                Ok(f) => f,
+                Err(e) => {
+                    tracing::error!("Failed to open FIFO for reading: {e}");
+                    return;
+                }
+            };
+            for line in BufReader::new(file).lines().map_while(Result::ok) {
+                let id = line.trim();
+                if id.is_empty() {
+                    continue;
+                }
+                crate::shortcuts::manager::dispatch_shortcut_action(&app, id);
+            }
+            // Writer closed (EOF) — loop back, reopen, wait for the next write.
+        }
+    });
+}
diff --git a/src-tauri/src/shortcuts/linux.rs b/src-tauri/src/shortcuts/linux.rs
index 539dd40..94abb97 100644
--- a/src-tauri/src/shortcuts/linux.rs
+++ b/src-tauri/src/shortcuts/linux.rs
@@ -91,8 +91,16 @@ pub fn get_display_server() -> DisplayServer {
 /// the frontend via the `wayland-shortcuts-status` event.
 pub fn init_global_shortcuts(app: &AppHandle) {
     if get_display_server() == DisplayServer::Wayland {
-        tracing::info!("Wayland session: setting up the XDG GlobalShortcuts portal");
-        super::wayland_portal::setup(app);
+        // On Hyprland the XDG GlobalShortcuts portal registers a shortcut but
+        // never binds a key (the binding comes back empty), so hotkeys never
+        // fire. Use native hyprctl binds + a FIFO there instead of the portal.
+        if super::hyprland::is_hyprland() {
+            tracing::info!("Hyprland detected: using native hyprctl binds (skipping portal)");
+            super::hyprland::setup(app);
+        } else {
+            tracing::info!("Wayland session: setting up the XDG GlobalShortcuts portal");
+            super::wayland_portal::setup(app);
+        }
     }
 }
 
diff --git a/src-tauri/src/shortcuts/mod.rs b/src-tauri/src/shortcuts/mod.rs
index b464484..40b1415 100644
--- a/src-tauri/src/shortcuts/mod.rs
+++ b/src-tauri/src/shortcuts/mod.rs
@@ -14,6 +14,8 @@
 pub mod conflict;
 pub mod manager;
 
+#[cfg(target_os = "linux")]
+pub mod hyprland;
 #[cfg(target_os = "linux")]
 pub mod linux;
 #[cfg(target_os = "linux")]

From a34733c571c0aacfe62c5f9da0b71091f946c9c2 Mon Sep 17 00:00:00 2001
From: nephalemsec <nephalem.sec@protonmail.com>
Date: Fri, 12 Jun 2026 22:58:47 +1000
Subject: [PATCH 08/10] build(nix): expose an importable package (GPU Parakeet
 + Whisper Vulkan)

Adds packages.default so the flake is consumable as an input:
  inputs.thoth.url = "github:poodle64/thoth";
  environment.systemPackages = [ inputs.thoth.packages.${system}.default ];

buildRustPackage with parakeet-cuda + vulkan, linking the pinned CUDA
sherpa-onnx via SHERPA_ONNX_LIB_DIR; the binary is wrapped with wl-clipboard,
wtype, gsettings, canberra and the CUDA/Vulkan runtime libraries (hyprctl is
taken from the host PATH). pnpmDeps hash pinned; cargoHash left as a one-time
TODO (crates.io rate-limited the vendor fetch where this was authored).
---
 flake.nix | 126 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 126 insertions(+)

diff --git a/flake.nix b/flake.nix
index 7c3c9c4..414ed15 100644
--- a/flake.nix
+++ b/flake.nix
@@ -188,7 +188,133 @@
           SHERPA_ONNX_LIB_DIR = "${sherpaOnnxCuda}/lib";
         });
 
+        # Runtime libraries the wrapped binary loads (CUDA EP + Vulkan + tray).
+        runtimeLibs = [
+          pkgs.libappindicator-gtk3
+          pkgs.vulkan-loader
+          sherpaOnnxCuda
+          cudaPackages.cudnn
+          cudaPackages.libcurand
+          cudaPackages.libcufft
+          cudaPackages.libcusparse
+          cudaPackages.cuda_cudart
+          cudaPackages.libcublas
+        ];
+
+        # ---------------------------------------------------------------------
+        # Installable, importable package:
+        #   inputs.thoth.packages.${system}.default
+        #
+        # Builds GPU Parakeet (CUDA, via the prebuilt sherpa-onnx pinned above)
+        # plus Whisper (Vulkan). The binary is wrapped with the Wayland runtime
+        # tools (wl-clipboard, wtype) and the CUDA/Vulkan libraries it dlopen()s.
+        # `hyprctl` is taken from the user's PATH (present on any Hyprland system).
+        #
+        # Refresh the two hashes whenever Cargo.lock / pnpm-lock.yaml change:
+        # set both to lib.fakeHash, run `nix build`, paste the reported pnpmDeps
+        # hash, run again, paste the cargoHash, run once more to compile.
+        # ---------------------------------------------------------------------
+        thothPackage = pkgs.rustPlatform.buildRustPackage (finalAttrs: {
+          pname = "thoth";
+          version = "2026.6.3";
+          src = ./.;
+
+          cargoRoot = "src-tauri";
+          buildAndTestSubdir = "src-tauri";
+          # TODO(one-time): run `nix build .#packages.x86_64-linux.default`, then
+          # paste the `got:` hash it reports here. (Couldn't be pre-computed where
+          # this was authored — crates.io rate-limited the vendor fetch.)
+          cargoHash = "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
+
+          # GPU Parakeet (sherpa-onnx CUDA via SHERPA_ONNX_LIB_DIR) + Whisper (Vulkan).
+          # No default features (drops fluidaudio, a macOS-only git dep, and the
+          # CPU `parakeet` link mode).
+          buildNoDefaultFeatures = true;
+          buildFeatures = [ "parakeet-cuda" "vulkan" ];
+
+          pnpmDeps = pkgs.fetchPnpmDeps {
+            inherit (finalAttrs) pname version src;
+            fetcherVersion = 3;
+            hash = "sha256-dDxzWfpqs2wuT6rSojfP7r0neOnCbkB3ha2fA45Icws=";
+          };
+
+          nativeBuildInputs = with pkgs; [
+            cargo-tauri.hook
+            nodejs
+            pnpmConfigHook
+            pnpm
+            pkg-config
+            cmake
+            git
+            llvmPackages.libclang
+            shaderc # glslc — compiles whisper.cpp's Vulkan shaders
+            wrapGAppsHook4
+            makeWrapper
+          ];
+
+          buildInputs = with pkgs; [
+            openssl
+            webkitgtk_4_1
+            glib
+            glib-networking
+            libsecret
+            libappindicator-gtk3
+            alsa-lib
+            librsvg
+            libx11
+            libxcursor
+            libxrandr
+            libxi
+            vulkan-loader
+            vulkan-headers
+            shaderc
+            sherpaOnnxCuda # Parakeet C API, linked via SHERPA_ONNX_LIB_DIR
+          ];
+
+          env = {
+            LIBCLANG_PATH = "${pkgs.llvmPackages.libclang.lib}/lib";
+            WEBKIT_DISABLE_COMPOSITING_MODE = "1";
+            SHERPA_ONNX_LIB_DIR = "${sherpaOnnxCuda}/lib";
+          };
+
+          # whisper-rs-sys bindgen needs the cc-wrapper libc flags + clang headers
+          # (issue #64); `$(< … )` must run at build time, so it lives here.
+          preConfigure = bindgenHook;
+
+          # No updater signing key in the sandbox.
+          preBuild = ''
+            substituteInPlace src-tauri/tauri.conf.json \
+              --replace-fail '"createUpdaterArtifacts": true' '"createUpdaterArtifacts": false'
+          '';
+
+          postFixup = ''
+            wrapProgram $out/bin/thoth \
+              --prefix PATH : ${pkgs.lib.makeBinPath [
+                pkgs.wl-clipboard      # wl-copy / wl-paste
+                pkgs.wtype             # Wayland keyboard simulation
+                pkgs.glib.bin          # gsettings (theme detection)
+                pkgs.libcanberra-gtk3  # canberra-gtk-play (sound feedback)
+              ]} \
+              --prefix LD_LIBRARY_PATH : ${pkgs.lib.makeLibraryPath runtimeLibs}:/run/opengl-driver/lib \
+              --set WEBKIT_DISABLE_COMPOSITING_MODE 1
+          '';
+
+          doCheck = false; # tests need audio hardware
+
+          meta = with pkgs.lib; {
+            description = "Privacy-first, offline-capable voice transcription (GPU Parakeet + Whisper)";
+            homepage = "https://github.com/poodle64/thoth";
+            license = licenses.mit;
+            platforms = [ "x86_64-linux" ];
+            mainProgram = "thoth";
+          };
+        });
+
       in {
+        # `nix build` / `inputs.thoth.packages.${system}.default`
+        packages.default = thothPackage;
+        packages.thoth = thothPackage;
+
         devShells.default = mkThothShell { };
         devShells.cuda = mkThothShell { gpuParakeet = true; };
       });

From 01623fbe4250760c73acf0da8196761dc28d1279 Mon Sep 17 00:00:00 2001
From: nephalemsec <nephalem.sec@protonmail.com>
Date: Fri, 12 Jun 2026 23:13:42 +1000
Subject: [PATCH 09/10] build(nix): vendor via cargoLock to dodge crates.io
 rate-limit 403s
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

buildRustPackage's default cargoHash uses fetch-cargo-vendor-util, which bulk-
fetches every crate from crates.io's api/v1 download endpoint in parallel and
gets random 403s (rate-limiting) — the whole vendor FOD then fails and re-fetches
from scratch. Switch to cargoLock: each crate is its own fetchurl derivation, so
successful fetches cache and only failures retry. Build with --max-jobs 2 to
stay under the limit. No cargoHash needed (registry checksums come from
Cargo.lock); the one git dep (fluidaudio-rs) is pinned in outputHashes.
---
 flake.nix | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/flake.nix b/flake.nix
index 414ed15..035d624 100644
--- a/flake.nix
+++ b/flake.nix
@@ -221,10 +221,17 @@
 
           cargoRoot = "src-tauri";
           buildAndTestSubdir = "src-tauri";
-          # TODO(one-time): run `nix build .#packages.x86_64-linux.default`, then
-          # paste the `got:` hash it reports here. (Couldn't be pre-computed where
-          # this was authored — crates.io rate-limited the vendor fetch.)
-          cargoHash = "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
+          # crates.io rate-limits the bulk vendor fetch (random 403s), so use
+          # cargoLock instead of cargoHash: each crate becomes its own fetchurl
+          # derivation — cached individually and retried by nix — so a throttled
+          # `nix build --max-jobs 2` makes steady progress through the limit.
+          # Registry checksums come from Cargo.lock; only the git dep needs a hash.
+          cargoLock = {
+            lockFile = ./src-tauri/Cargo.lock;
+            outputHashes = {
+              "fluidaudio-rs-0.10.0" = "sha256-z7c8tibtfevefrYAwh3hJM/sr/OWnbSrxjDS4Tda8+k=";
+            };
+          };
 
           # GPU Parakeet (sherpa-onnx CUDA via SHERPA_ONNX_LIB_DIR) + Whisper (Vulkan).
           # No default features (drops fluidaudio, a macOS-only git dep, and the

From dc62ccd1d2663d5a301fd10fca5c5ea79dffb6cf Mon Sep 17 00:00:00 2001
From: nephalemsec <nephalem.sec@protonmail.com>
Date: Fri, 12 Jun 2026 23:30:49 +1000
Subject: [PATCH 10/10] build(nix): build the package with the rust-overlay
 toolchain

pkgs.rustPlatform uses the pinned nixpkgs' rustc, which is too old for some deps
(libsqlite3-sys 0.38.1 uses the cfg_select! macro). Build with the same newer
rust-overlay toolchain the dev shell uses, via makeRustPlatform.
---
 flake.nix | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/flake.nix b/flake.nix
index 035d624..9c84166 100644
--- a/flake.nix
+++ b/flake.nix
@@ -26,6 +26,14 @@
           extensions = [ "rust-src" "rust-analyzer" ];
         };
 
+        # Build the package with this newer toolchain too — nixpkgs' default rustc
+        # (from the pinned nixpkgs) is too old for some deps (e.g. libsqlite3-sys
+        # uses the `cfg_select!` macro).
+        rustPlatform = pkgs.makeRustPlatform {
+          cargo = rustToolchain;
+          rustc = rustToolchain;
+        };
+
         # CUDA packages for whisper.cpp GPU acceleration
         cudaPackages = pkgs.cudaPackages_12;
 
@@ -214,7 +222,7 @@
         # set both to lib.fakeHash, run `nix build`, paste the reported pnpmDeps
         # hash, run again, paste the cargoHash, run once more to compile.
         # ---------------------------------------------------------------------
-        thothPackage = pkgs.rustPlatform.buildRustPackage (finalAttrs: {
+        thothPackage = rustPlatform.buildRustPackage (finalAttrs: {
           pname = "thoth";
           version = "2026.6.3";
           src = ./.;