opencode-voice-dictation 0.6.2 → 0.7.1

package/docs/whispercpp.md

@@ -0,0 +1,143 @@
+# Dictado con whisper.cpp nativo (Linux)
+
+Guía para configurar el motor **whisper.cpp** del plugin en Ubuntu y otras
+distros Linux. Transcribe **audio a texto** en la CPU, sin WSL, sin Python y sin
+GPU.
+
+> Es el motor por defecto en Linux. En Windows no está disponible: usa
+> `Windows Voice Typing (Win+H)`, `System.Speech` o
+> [WhisperX](whisperx.md).
+
+## Requisitos
+
+- **OpenCode Desktop** en Linux (el plugin GUI no se carga en la consola/TUI).
+- **ffmpeg** en el `PATH`:
+  ```bash
+  sudo apt update && sudo apt install -y ffmpeg
+  ffmpeg -version
+  ```
+- **glibc** compatible con el binario oficial: Ubuntu 22.04 o posterior. En
+  distros muy antiguas habría que compilar `whisper.cpp` a mano.
+- **Internet la primera vez**: ~10 MB de binario y 57–180 MB de modelo.
+- Micrófono accesible por la app.
+
+No hace falta Python, `cmake` ni GPU.
+
+## Instalación desde el plugin
+
+1. Instala el plugin (`opencode plugin add opencode-voice-dictation`) y reinicia
+   OpenCode Desktop.
+2. Abre **Ajustes → Dictado por voz**. En Linux el motor es
+   `whisper.cpp (local, nativo)`.
+3. Elige el modelo:
+   - `base-q5_1` (57 MB): el más ligero; recomendado para portátiles modestos.
+   - `small-q5_1` (~180 MB): más preciso, consume más CPU y memoria.
+4. Pulsa **Descargar motor**. Se bajan el binario oficial y el modelo.
+5. Pulsa **Comprobar** para verificar que están instalados.
+6. Pulsa la píldora del micrófono, habla y vuelve a pulsarla: el texto se
+   inserta en el prompt.
+
+La descarga se guarda en:
+
+```
+~/.local/share/opencode-voice-dictation/whisper.cpp/
+├── whisper-bin-ubuntu-x64/        # o arm64
+│   ├── whisper-server
+│   └── lib*.so
+├── ggml-base-q5_1.bin
+└── ggml-small-q5_1.bin            # si lo descargaste
+```
+
+## Instalación manual (opcional)
+
+Si prefieres preparar los archivos a mano:
+
+```bash
+mkdir -p ~/.local/share/opencode-voice-dictation/whisper.cpp
+cd ~/.local/share/opencode-voice-dictation/whisper.cpp
+
+curl -L -o whisper-bin.tar.gz \
+  https://github.com/ggml-org/whisper.cpp/releases/download/v1.9.2/whisper-bin-ubuntu-x64.tar.gz
+tar xzf whisper-bin.tar.gz
+rm whisper-bin.tar.gz
+
+curl -L -O \
+  https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base-q5_1.bin
+```
+
+El plugin detecta el binario y el modelo en esa ruta; no necesitas configurar
+nada más.
+
+## Cómo funciona
+
+```
+Ventana (OpenCode Desktop)
+  getUserMedia + MediaRecorder  →  WebM/Opus base64
+        │ RPC whisperCppTranscribe
+        ▼
+Servidor del plugin
+  escribe /tmp/opencode-voice-dictation/whispercpp-*.webm
+  ffmpeg → WAV 16 kHz mono
+  POST http://127.0.0.1:<puerto>/inference
+        ▼
+whisper-server (proceso persistente)
+  modelo cargado una vez; responde {"text": "..."}
+```
+
+- `whisper-server` se arranca la primera vez y se mantiene vivo. Cargar el
+  modelo es lo lento; las frases siguientes son rápidas.
+- Si cambias de modelo o de idioma, el servidor se reinicia para aplicar el
+  cambio.
+- El puerto se elige al azar entre 18081 y 18580 y solo escucha en
+  `127.0.0.1`.
+- El audio temporal se borra después de cada transcripción.
+
+## Ajustes
+
+| Ajuste | Por defecto | Qué hace |
+|---|---|---|
+| Motor de dictado | `whisper.cpp` en Linux | Único motor disponible en Linux. |
+| Modelo | `base-q5_1` | `base-q5_1` (57 MB) o `small-q5_1` (~180 MB). |
+| Idioma | Automático | Autodetección o `es`, `en`, `pt`. |
+| Descargar motor | — | Baja el binario y el modelo seleccionado. |
+| Comprobar whisper.cpp | — | Indica si el servidor y el modelo están instalados. |
+
+## Rendimiento orientativo
+
+Depende de la CPU. Como referencia con `base-q5_1` y 4 hilos:
+
+| Equipo | Una frase de 5–10 s |
+|---|---|
+| Portátil moderno (4–8 núcleos) | ~1–3 s |
+| Portátil modesto (2 núcleos) | ~4–10 s |
+
+`small-q5_1` mejora la precisión y multiplica el tiempo por ~2–3. Si el equipo
+va justo, quédate en `base-q5_1`.
+
+## Solución de problemas
+
+| Síntoma | Causa / solución |
+|---|---|
+| «Whisper.cpp is not installed» | Pulsa **Descargar motor** en Ajustes. |
+| La descarga falla | Revisa internet, proxy o firewall hacia GitHub y Hugging Face. |
+| `ffmpeg` no encontrado | `sudo apt install ffmpeg` y comprueba `ffmpeg -version`. |
+| El binario no arranca | `glibc` antigua o arquitectura distinta; compila `whisper.cpp` para tu sistema o usa Ubuntu 22.04+. |
+| Se queda en «Transcribiendo…» | Mira el toast y el log del servidor de OpenCode; suele ser `ffmpeg` o el binario. |
+| El RPC devuelve 400 | El plugin server no cargó: Ajustes → Extensiones → Plugins → **Reload**. |
+| Tarda mucho | Usa `base-q5_1`; el primer dictado carga el modelo. |
+| No hay píldora | La API GUI solo existe en OpenCode Desktop, no en la consola/TUI. |
+
+## Privacidad
+
+El audio se escribe en `/tmp`, se convierte en local y se transcribe en tu CPU.
+No se envía a ningún servicio. Solo la primera descarga usa la red
+(GitHub para el binario y Hugging Face para el modelo).
+
+## Desktop y consola
+
+- **OpenCode Desktop**: carga `./gui-experimental`, así que tiene píldora,
+  atajo `Ctrl+Shift+M`, `/dictado` y ajustes. whisper.cpp funciona completo.
+- **OpenCode consola/TUI**: no carga la parte GUI. La parte servidor (RPC)
+  existe, pero no hay micrófono ni píldora. Para dictar en la consola haría
+  falta una parte `./tui` que grabara con `arecord`/`ffmpeg`; es un desarrollo
+  aparte y todavía no está incluido.

package/docs/whisperx.md

@@ -6,7 +6,8 @@ de lectura.
 
 > Este motor es **avanzado**. Para un usuario sin WSL, Python y GPU NVIDIA, usa
 > `Windows Voice Typing (Win+H)` o un motor en la nube. La integración con
-> `whisper.cpp` nativo (sin WSL) está en el roadmap.
+> `whisper.cpp` nativo (sin WSL) ya está disponible para Linux; ver
+> [la guía de whisper.cpp](whispercpp.md).
 
 ## Requisitos
 
@@ -164,7 +165,7 @@ La idea es añadir más motores de dictado con la misma interfaz:
 | Windows Voice Typing (Win+H) | Disponible | Cero configuración, online |
 | System.Speech | Disponible | Offline, calidad antigua |
 | WhisperX local (WSL) | Disponible | Avanzado, NVIDIA + WSL |
-| `whisper.cpp` nativo | Planeado | Sin WSL/Python; binario + modelo |
+| `whisper.cpp` nativo | Disponible | Linux, sin WSL ni Python; ver [la guía](whispercpp.md) |
 | Google Cloud Speech-to-Text | Planeado | API key, online |
 | OpenAI (`gpt-4o-transcribe` / `whisper-1`) | Planeado | API key, online |
 | Deepgram / AssemblyAI | Planeado | API key, online |

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-voice-dictation",
-  "version": "0.6.2",
-  "description": "Offline voice dictation and read-aloud for OpenCode Desktop on Windows",
+  "version": "0.7.1",
+  "description": "Offline voice dictation and read-aloud for OpenCode Desktop on Windows and Linux",
   "license": "MIT",
   "author": "Fran Carlos <francarlos803@gmail.com>",
   "homepage": "https://github.com/evious/opencode-voice-dictation#readme",
@@ -20,6 +20,8 @@
     "speech-to-text",
     "text-to-speech",
     "windows",
+    "linux",
+    "whisper.cpp",
     "offline"
   ],
   "type": "module",

package/src/gui/definition.ts

@@ -4,12 +4,12 @@ import { Plugin, Store } from "@opencode/plugin/gui"
 /**
  * Declarations read by the desktop app before either setup runs.
  *
- * `os: ["windows"]` keeps the plugin from loading on macOS/Linux, where
- * System.Speech does not exist. Settings shows it as not available instead of
- * failing.
+ * Windows uses Win+H, System.Speech and WhisperX. Linux uses whisper.cpp
+ * natively; the window reads the server capabilities and offers only the
+ * engines that exist on each OS.
  */
 export const definition = Plugin.define({
-  os: ["windows"],
+  os: ["windows", "linux"],
   stores: {
     prefs: Store.global(
       Schema.Struct({
@@ -67,6 +67,16 @@ export const definition = Plugin.define({
         language: "",
       },
     ),
+    whispercpp: Store.global(
+      Schema.Struct({
+        model: Schema.String,
+        language: Schema.String,
+      }),
+      {
+        model: "base-q5_1",
+        language: "auto",
+      },
+    ),
   },
   i18n: {
     en: {
@@ -90,13 +100,14 @@ export const definition = Plugin.define({
       "error.unknown": "Dictation failed ({code}).",
       "toast.discarded": "Dictation discarded: the active session changed.",
       "settings.title": "Voice dictation",
-      "settings.description": "Offline dictation with the Windows speech recognizer. The text is inserted into the prompt; it is never sent automatically.",
+      "settings.description": "Offline dictation on Windows and Linux. The text is inserted into the prompt; it is never sent automatically.",
       "settings.section": "Dictation",
       "settings.engine": "Dictation engine",
-      "settings.engine.description": "Windows uses Windows 11 voice typing (Win+H), which is more accurate. System.Speech works offline but is less precise.",
+      "settings.engine.description": "Windows offers Win+H and System.Speech; Linux uses whisper.cpp locally.",
       "engine.windows": "Windows Voice Typing (Win+H)",
       "engine.system": "System.Speech (offline)",
       "engine.whisper": "WhisperX local (WSL)",
+      "engine.whispercpp": "whisper.cpp (local, native)",
       "pill.recording": "Recording…",
       "pill.transcribing": "Transcribing…",
       "pill.whisper": "Record and transcribe with WhisperX",
@@ -115,6 +126,29 @@ export const definition = Plugin.define({
       "whisper.test.ready": "WhisperX ready: {model} ({device})",
       "whisper.test.error": "WhisperX is not ready: {error}",
       "whisper.empty": "WhisperX returned no text.",
+      "pill.whispercpp": "Record and transcribe with whisper.cpp",
+      "error.whispercpp": "whisper.cpp could not transcribe the audio.",
+      "whispercpp.section": "whisper.cpp (local, native)",
+      "whispercpp.description": "Runs on the CPU without WSL or Python. The first time you need to download the server (~10 MB) and the model.",
+      "whispercpp.model": "Model",
+      "whispercpp.model.description": "base-q5_1 is the lightest model (57 MB) and works on modest laptops. small-q5_1 is more accurate but uses more CPU and memory.",
+      "whispercpp.language": "Language",
+      "whispercpp.language.description": "Automatic detects the language of each recording.",
+      "whispercpp.language.auto": "Automatic",
+      "whispercpp.install": "Download engine",
+      "whispercpp.install.description": "Downloads the official whisper.cpp server and the selected model to ~/.local/share/opencode-voice-dictation. Needs internet once.",
+      "whispercpp.install.run": "Download",
+      "whispercpp.install.busy": "Downloading…",
+      "whispercpp.install.ok": "whisper.cpp installed: {model}",
+      "whispercpp.install.error": "Could not install whisper.cpp: {error}",
+      "whispercpp.test": "Check whisper.cpp",
+      "whispercpp.test.description": "Reports whether the server and the selected model are installed.",
+      "whispercpp.test.run": "Check",
+      "whispercpp.test.ready": "whisper.cpp ready: {model}",
+      "whispercpp.test.missing": "whisper.cpp is not installed. Download the engine first.",
+      "whispercpp.test.error": "whisper.cpp is not ready: {error}",
+      "whispercpp.empty": "whisper.cpp returned no text.",
+      "whispercpp.linux": "whisper.cpp is only available on Linux. On Windows use Win+H, System.Speech or WhisperX.",
       "settings.winh": "Test Win+H",
       "settings.winh.description": "Sends the Windows voice typing shortcut. If the floating bar appears, it works.",
       "settings.winh.run": "Test Win+H",
@@ -152,7 +186,7 @@ export const definition = Plugin.define({
       "read.noSession": "Open a conversation to read its last message.",
       "read.empty": "The last message has no text to read.",
       "read.error": "The last message could not be read.",
-      "read.noVoices": "Windows has no voices installed for reading.",
+      "read.noVoices": "The system has no voices installed for reading.",
       "speech.section": "Read aloud",
       "speech.engine": "Voice engine",
       "speech.engine.description": "Edge neural sounds much more natural but needs internet. System uses the installed Windows voices, offline.",
@@ -196,13 +230,14 @@ export const definition = Plugin.define({
       "error.unknown": "El dictado falló ({code}).",
       "toast.discarded": "Dictado descartado: la sesión activa cambió.",
       "settings.title": "Dictado por voz",
-      "settings.description": "Dictado offline con el reconocedor de voz de Windows. El texto se inserta en el prompt; nunca se envía solo.",
+      "settings.description": "Dictado offline en Windows y Linux. El texto se inserta en el prompt; nunca se envía solo.",
       "settings.section": "Dictado",
       "settings.engine": "Motor de dictado",
-      "settings.engine.description": "Windows usa el dictado de Windows 11 (Win+H), más preciso. System.Speech funciona sin Windows 11 pero es menos exacto.",
+      "settings.engine.description": "Windows ofrece Win+H y System.Speech; Linux usa whisper.cpp en local.",
       "engine.windows": "Windows Voice Typing (Win+H)",
       "engine.system": "System.Speech (offline)",
       "engine.whisper": "WhisperX local (WSL)",
+      "engine.whispercpp": "whisper.cpp (local, nativo)",
       "pill.recording": "Grabando…",
       "pill.transcribing": "Transcribiendo…",
       "pill.whisper": "Grabar y transcribir con WhisperX",
@@ -221,6 +256,29 @@ export const definition = Plugin.define({
       "whisper.test.ready": "WhisperX listo: {model} ({device})",
       "whisper.test.error": "WhisperX no está listo: {error}",
       "whisper.empty": "WhisperX no devolvió texto.",
+      "pill.whispercpp": "Grabar y transcribir con whisper.cpp",
+      "error.whispercpp": "whisper.cpp no pudo transcribir el audio.",
+      "whispercpp.section": "whisper.cpp (local, nativo)",
+      "whispercpp.description": "Funciona en CPU sin WSL ni Python. La primera vez hay que descargar el servidor (~10 MB) y el modelo.",
+      "whispercpp.model": "Modelo",
+      "whispercpp.model.description": "base-q5_1 es el más ligero (57 MB) y va bien en portátiles modestos. small-q5_1 es más preciso pero consume más CPU y memoria.",
+      "whispercpp.language": "Idioma",
+      "whispercpp.language.description": "Automático detecta el idioma de cada grabación.",
+      "whispercpp.language.auto": "Automático",
+      "whispercpp.install": "Descargar motor",
+      "whispercpp.install.description": "Descarga el servidor oficial de whisper.cpp y el modelo elegido en ~/.local/share/opencode-voice-dictation. Solo necesita internet una vez.",
+      "whispercpp.install.run": "Descargar",
+      "whispercpp.install.busy": "Descargando…",
+      "whispercpp.install.ok": "whisper.cpp instalado: {model}",
+      "whispercpp.install.error": "No se pudo instalar whisper.cpp: {error}",
+      "whispercpp.test": "Comprobar whisper.cpp",
+      "whispercpp.test.description": "Indica si el servidor y el modelo elegido están instalados.",
+      "whispercpp.test.run": "Comprobar",
+      "whispercpp.test.ready": "whisper.cpp listo: {model}",
+      "whispercpp.test.missing": "whisper.cpp no está instalado. Descarga el motor primero.",
+      "whispercpp.test.error": "whisper.cpp no está listo: {error}",
+      "whispercpp.empty": "whisper.cpp no devolvió texto.",
+      "whispercpp.linux": "whisper.cpp solo está disponible en Linux. En Windows usa Win+H, System.Speech o WhisperX.",
       "settings.winh": "Probar Win+H",
       "settings.winh.description": "Envía el atajo del dictado de Windows. Si aparece la barra flotante, funciona.",
       "settings.winh.run": "Probar Win+H",
@@ -257,10 +315,10 @@ export const definition = Plugin.define({
       "read.noSession": "Abre una conversación para leer su último mensaje.",
       "read.empty": "El último mensaje no tiene texto para leer.",
       "read.error": "No se pudo leer el último mensaje.",
-      "read.noVoices": "Windows no tiene voces instaladas para la lectura.",
+      "read.noVoices": "El sistema no tiene voces instaladas para la lectura.",
       "speech.section": "Lectura en voz alta",
       "speech.engine": "Motor de voz",
-      "speech.engine.description": "Edge neuronal suena mucho más natural pero necesita internet. Sistema usa las voces instaladas de Windows, sin conexión.",
+      "speech.engine.description": "Edge neuronal suena mucho más natural pero necesita internet. Sistema usa las voces instaladas del equipo, sin conexión.",
       "speech.engine.edge": "Edge neuronal (online)",
       "speech.engine.system": "Sistema (offline)",
       "error.edge": "No se pudo usar la voz de Edge. Revisa la conexión o cambia a la voz del sistema.",

package/src/gui/settings.tsx

@@ -31,24 +31,57 @@ export function VoiceSettings(props: { speaker: Speaker }) {
   const ttsPrefs = ctx.stores.tts
   const enginePrefs = ctx.stores.engine
   const whisperPrefs = ctx.stores.whisper
+  const whisperCppPrefs = ctx.stores.whispercpp
   const dictation = ctx.main(Dictation)
   const voiceTyping = ctx.main(VoiceTyping)
 
   const [locales, setLocales] = createSignal<readonly string[]>([])
   const [busy, setBusy] = createSignal(false)
   const [whisperBusy, setWhisperBusy] = createSignal(false)
+  const [whisperCppBusy, setWhisperCppBusy] = createSignal(false)
+  const [whisperCppCheckBusy, setWhisperCppCheckBusy] = createSignal(false)
+  const [platform, setPlatform] = createSignal("")
 
   onMount(() => {
     props.speaker.setConfig({ engine: ttsPrefs.value.engine, voice: ttsPrefs.value.voice })
-    void dictation
-      .diagnose()
-      .then((result) => {
-        if (result.locales.length > 0) setLocales(result.locales)
+
+    const loadLocales = () => {
+      void dictation
+        .diagnose()
+        .then((result) => {
+          if (result.locales.length > 0) setLocales(result.locales)
+        })
+        .catch(() => {})
+    }
+
+    void ctx.client
+      .rpc(VoiceRpc)
+      .capabilities({})
+      .then((value) => {
+        const caps = value as { platform: string; engines: string[] }
+        setPlatform(caps.platform)
+        if (!caps.engines.includes(enginePrefs.value.mode) && caps.engines.length > 0) {
+          patchEngine(caps.engines[0] ?? "windows")
+        }
+        if (caps.platform !== "linux") loadLocales()
       })
-      .catch(() => {})
+      .catch(() => loadLocales())
+
     void props.speaker.refreshVoices()
   })
 
+  const engineOptions = () => {
+    if (platform() === "linux") {
+      return [{ value: "whispercpp", label: ctx.t("engine.whispercpp") }]
+    }
+
+    return [
+      { value: "windows", label: ctx.t("engine.windows") },
+      { value: "system", label: ctx.t("engine.system") },
+      { value: "whisper", label: ctx.t("engine.whisper") },
+    ]
+  }
+
   const localeOptions = () => {
     const list = locales()
     const current = prefs.value.locale
@@ -107,6 +140,88 @@ export function VoiceSettings(props: { speaker: Speaker }) {
     })
   }
 
+  const patchWhisperCpp = (change: { model?: string; language?: string }) => {
+    whisperCppPrefs.update((draft) => {
+      if (change.model !== undefined) draft.model = change.model
+      if (change.language !== undefined) draft.language = change.language
+    })
+  }
+
+  const installWhisperCpp = async () => {
+    setWhisperCppBusy(true)
+    try {
+      const result = (await ctx.client.rpc(VoiceRpc).whisperCppInstall({
+        model: whisperCppPrefs.value.model,
+      })) as { ok: boolean; model: string; error: string }
+
+      if (result.ok) {
+        ctx.toast.show({
+          variant: "success",
+          title: ctx.t("pill.title"),
+          description: ctx.t("whispercpp.install.ok", { model: result.model }),
+        })
+      } else {
+        ctx.toast.show({
+          variant: "error",
+          title: ctx.t("pill.title"),
+          description: ctx.t("whispercpp.install.error", { error: result.error || "?" }),
+          persistent: true,
+        })
+      }
+    } catch (cause) {
+      ctx.toast.show({
+        variant: "error",
+        title: ctx.t("pill.title"),
+        description: ctx.t("whispercpp.install.error", {
+          error: cause instanceof Error ? cause.message : String(cause),
+        }),
+        persistent: true,
+      })
+    } finally {
+      setWhisperCppBusy(false)
+    }
+  }
+
+  const checkWhisperCpp = async () => {
+    setWhisperCppCheckBusy(true)
+    try {
+      const status = (await ctx.client.rpc(VoiceRpc).whisperCppStatus({
+        model: whisperCppPrefs.value.model,
+      })) as { installed: boolean; ready: boolean; model: string; error: string }
+
+      if (status.error) {
+        ctx.toast.show({
+          variant: "error",
+          title: ctx.t("pill.title"),
+          description: ctx.t("whispercpp.test.error", { error: status.error }),
+          persistent: true,
+        })
+      } else if (!status.installed) {
+        ctx.toast.show({
+          variant: "default",
+          title: ctx.t("pill.title"),
+          description: ctx.t("whispercpp.test.missing"),
+        })
+      } else {
+        ctx.toast.show({
+          variant: "success",
+          title: ctx.t("pill.title"),
+          description: ctx.t("whispercpp.test.ready", { model: status.model }),
+        })
+      }
+    } catch (cause) {
+      ctx.toast.show({
+        variant: "error",
+        title: ctx.t("pill.title"),
+        description: ctx.t("whispercpp.test.error", {
+          error: cause instanceof Error ? cause.message : String(cause),
+        }),
+      })
+    } finally {
+      setWhisperCppCheckBusy(false)
+    }
+  }
+
   const testWhisper = async () => {
     setWhisperBusy(true)
     try {
@@ -232,11 +347,7 @@ export function VoiceSettings(props: { speaker: Speaker }) {
           <ui.Select
             label={ctx.t("settings.engine")}
             value={enginePrefs.value.mode}
-            options={[
-              { value: "windows", label: ctx.t("engine.windows") },
-              { value: "system", label: ctx.t("engine.system") },
-              { value: "whisper", label: ctx.t("engine.whisper") },
-            ]}
+            options={engineOptions()}
             onChange={(value) => patchEngine(value)}
           />
         </ui.SettingsRow>
@@ -310,6 +421,62 @@ export function VoiceSettings(props: { speaker: Speaker }) {
           </ui.SettingsRow>
         </Show>
 
+        <Show when={enginePrefs.value.mode === "whispercpp"}>
+          <ui.SettingsRow
+            id="whispercpp-model"
+            title={ctx.t("whispercpp.model")}
+            description={ctx.t("whispercpp.model.description")}
+          >
+            <ui.Select
+              label={ctx.t("whispercpp.model")}
+              value={whisperCppPrefs.value.model}
+              options={[
+                { value: "base-q5_1", label: "base-q5_1 · 57 MB" },
+                { value: "small-q5_1", label: "small-q5_1 · 180 MB" },
+              ]}
+              onChange={(value) => patchWhisperCpp({ model: value })}
+            />
+          </ui.SettingsRow>
+
+          <ui.SettingsRow
+            id="whispercpp-language"
+            title={ctx.t("whispercpp.language")}
+            description={ctx.t("whispercpp.language.description")}
+          >
+            <ui.Select
+              label={ctx.t("whispercpp.language")}
+              value={whisperCppPrefs.value.language}
+              options={[
+                { value: "auto", label: ctx.t("whispercpp.language.auto") },
+                { value: "es", label: "Español" },
+                { value: "en", label: "English" },
+                { value: "pt", label: "Português" },
+              ]}
+              onChange={(value) => patchWhisperCpp({ language: value })}
+            />
+          </ui.SettingsRow>
+
+          <ui.SettingsRow
+            id="whispercpp-install"
+            title={ctx.t("whispercpp.install")}
+            description={ctx.t("whispercpp.install.description")}
+          >
+            <ui.Button busy={whisperCppBusy()} onClick={() => void installWhisperCpp()}>
+              {ctx.t("whispercpp.install.run")}
+            </ui.Button>
+          </ui.SettingsRow>
+
+          <ui.SettingsRow
+            id="whispercpp-test"
+            title={ctx.t("whispercpp.test")}
+            description={ctx.t("whispercpp.test.description")}
+          >
+            <ui.Button busy={whisperCppCheckBusy()} onClick={() => void checkWhisperCpp()}>
+              {ctx.t("whispercpp.test.run")}
+            </ui.Button>
+          </ui.SettingsRow>
+        </Show>
+
         <Show when={enginePrefs.value.mode === "system"}>
           <ui.SettingsRow
             id="language"
@@ -439,13 +606,15 @@ export function VoiceSettings(props: { speaker: Speaker }) {
         </ui.SettingsRow>
       </ui.SettingsSection>
 
-      <ui.SettingsSection title={ctx.t("settings.test.section")}>
-        <ui.SettingsRow id="test" title={ctx.t("settings.test")} description={ctx.t("settings.test.description")}>
-          <ui.Button busy={busy()} onClick={() => void test()}>
-            {ctx.t("settings.test.run")}
-          </ui.Button>
-        </ui.SettingsRow>
-      </ui.SettingsSection>
+      <Show when={platform() !== "linux"}>
+        <ui.SettingsSection title={ctx.t("settings.test.section")}>
+          <ui.SettingsRow id="test" title={ctx.t("settings.test")} description={ctx.t("settings.test.description")}>
+            <ui.Button busy={busy()} onClick={() => void test()}>
+              {ctx.t("settings.test.run")}
+            </ui.Button>
+          </ui.SettingsRow>
+        </ui.SettingsSection>
+      </Show>
     </ui.SettingsLayout>
   )
 }