@@ -519,13 +519,18 @@ def start_local_whisper_server(self):
 
         logging.debug(f"Starting Whisper server with command: {' '.join(cmd)}")
 
+        # Imported here, as whisper_cpp probes Vulkan devices on import
+        from buzz.transcriber.whisper_cpp import WhisperCpp
+
+        env = WhisperCpp._whisper_env()
         try:
             if sys.platform == "win32":
                 self.process = subprocess.Popen(
                     cmd,
                     stdout=subprocess.DEVNULL,
                     stderr=subprocess.PIPE,
                     shell=False,
+                    env=env,
                     creationflags=subprocess.CREATE_NO_WINDOW
                 )
             else:
@@ -534,6 +539,7 @@ def start_local_whisper_server(self):
                     stdout=subprocess.DEVNULL,
                     stderr=subprocess.PIPE,
                     shell=False,
+                    env=env,
                 )
         except Exception as e:
             error_msg = f"Failed to start whisper-server subprocess: {str(e)}"
 
@@ -14,10 +14,40 @@
 
 
 IS_VULKAN_SUPPORTED = False
+# Index of the first discrete GPU in Vulkan's physical device list, if any.
+# whisper-cli defaults to device 0, which on hybrid laptops is usually the
+# integrated GPU, so the discrete one is selected via GGML_VK_VISIBLE_DEVICES.
+DISCRETE_GPU_INDEX: Optional[int] = None
+
+
+def _create_vulkan_instance(vk):
+    """Create a Vulkan instance that lists physical devices in ggml-vulkan's order."""
+    # The loader can order physical devices differently for 1.0 and 1.1+ instances
+    # (e.g. discrete GPU first for 1.0, integrated first for 1.1+). ggml-vulkan creates
+    # its instance at the loader's highest version, so the same version is used here,
+    # otherwise the index would point at a different GPU in GGML_VK_VISIBLE_DEVICES.
+    app_info = vk.VkApplicationInfo(apiVersion=vk.vkEnumerateInstanceVersion())
+    return vk.vkCreateInstance(vk.VkInstanceCreateInfo(pApplicationInfo=app_info), None)
+
+
+def _find_discrete_gpu_index(vk, instance) -> Optional[int]:
+    """Index of the first discrete GPU in the instance's physical device list."""
+    for index, device in enumerate(vk.vkEnumeratePhysicalDevices(instance)):
+        properties = vk.vkGetPhysicalDeviceProperties(device)
+        if properties.deviceType == vk.VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
+            logging.debug("Discrete Vulkan GPU %s: %s", index, properties.deviceName)
+            return index
+    return None
+
+
 try:
     import vulkan
 
-    instance = vulkan.vkCreateInstance(vulkan.VkInstanceCreateInfo(), None)
+    instance = _create_vulkan_instance(vulkan)
+    try:
+        DISCRETE_GPU_INDEX = _find_discrete_gpu_index(vulkan, instance)
+    except Exception as e:
+        logging.debug(f"Vulkan device enumeration error: {e}")
     vulkan.vkDestroyInstance(instance, None)
     vulkan_version = vulkan.vkEnumerateInstanceVersion()
     major = (vulkan_version >> 22) & 0x3FF
@@ -252,9 +282,18 @@ def _build_command(task, file_to_process, language, vad_enabled) -> list:
         print(f"Running Whisper CLI: {' '.join(cmd)}")
         return cmd
 
+    @staticmethod
+    def _whisper_env() -> dict:
+        """Environment for whisper-cli, steering ggml-vulkan to the discrete GPU."""
+        env = (app_env if sys.platform == "win32" else os.environ).copy()
+        if DISCRETE_GPU_INDEX is not None and "GGML_VK_VISIBLE_DEVICES" not in env:
+            env["GGML_VK_VISIBLE_DEVICES"] = str(DISCRETE_GPU_INDEX)
+        return env
+
     @staticmethod
     def _run_whisper(cmd) -> tuple:
         """Run whisper-cli subprocess, returning (return code, tail of stderr)."""
+        env = WhisperCpp._whisper_env()
         if sys.platform == "win32":
             si = subprocess.STARTUPINFO()
             si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
@@ -267,7 +306,7 @@ def _run_whisper(cmd) -> tuple:
                 encoding="utf-8",
                 errors="replace",
                 startupinfo=si,
-                env=app_env,
+                env=env,
                 creationflags=subprocess.CREATE_NO_WINDOW
             )
         else:
@@ -278,6 +317,7 @@ def _run_whisper(cmd) -> tuple:
                 text=True,
                 encoding="utf-8",
                 errors="replace",
+                env=env,
             )
 
         stderr_tail = []
@@ -522,6 +562,7 @@ def detect_language(file_path: str, model_path: str) -> Optional[str]:
 
         print(f"Running Whisper CLI language detection: {' '.join(cmd)}")
 
+        env = WhisperCpp._whisper_env()
         try:
             if sys.platform == "win32":
                 si = subprocess.STARTUPINFO()
@@ -534,7 +575,7 @@ def detect_language(file_path: str, model_path: str) -> Optional[str]:
                     encoding="utf-8",
                     errors="replace",
                     startupinfo=si,
-                    env=app_env,
+                    env=env,
                     creationflags=subprocess.CREATE_NO_WINDOW,
                 )
             else:
@@ -544,6 +585,7 @@ def detect_language(file_path: str, model_path: str) -> Optional[str]:
                     text=True,
                     encoding="utf-8",
                     errors="replace",
+                    env=env,
                 )
 
             # whisper-cli writes the detection line to stderr, e.g.:
 
@@ -1,3 +1,4 @@
+import os
 import threading
 from unittest.mock import MagicMock, patch, PropertyMock
 
@@ -7,6 +8,7 @@
 
 from buzz.model_loader import TranscriptionModel, ModelType, WhisperModelSize
 from buzz.settings.recording_transcriber_mode import RecordingTranscriberMode
+from buzz.transcriber import whisper_cpp
 from buzz.transcriber.recording_transcriber import RecordingTranscriber
 from buzz.transcriber.transcriber import TranscriptionOptions, Task
 
@@ -417,6 +419,25 @@ def test_success_creates_openai_client(self):
         assert "--language" in cmd and "auto" in cmd
         assert any("transcription" in m.lower() for m in emitted)
 
+    def test_server_runs_on_discrete_gpu(self, monkeypatch):
+        monkeypatch.delitem(os.environ, "GGML_VK_VISIBLE_DEVICES", raising=False)
+        monkeypatch.delitem(whisper_cpp.app_env, "GGML_VK_VISIBLE_DEVICES", raising=False)
+        t = make_transcriber()
+
+        process = MagicMock()
+        process.poll.return_value = None
+        process.stderr = []
+
+        with patch("buzz.transcriber.recording_transcriber.subprocess.Popen", return_value=process) as popen, \
+             patch("buzz.transcriber.recording_transcriber.time.sleep"), \
+             patch("buzz.transcriber.recording_transcriber._", lambda s: s), \
+             patch("buzz.transcriber.whisper_cpp.DISCRETE_GPU_INDEX", 1), \
+             patch("openai.OpenAI"):
+            t.is_running = True
+            t.start_local_whisper_server()
+
+        assert popen.call_args.kwargs["env"]["GGML_VK_VISIBLE_DEVICES"] == "1"
+
     def test_failure_emits_error_message(self):
         t = make_transcriber()
         emitted = []
 
@@ -2,6 +2,7 @@
 import json
 import os
 import subprocess
+import sys
 
 import pytest
 
@@ -12,11 +13,17 @@
     FileTranscriptionTask,
     FileTranscriptionOptions,
 )
+from buzz.transcriber import whisper_cpp
 from buzz.transcriber.whisper_cpp import WhisperCpp, _is_cli_safe_path
 from tests.audio import test_audio_path, test_multibyte_utf8_audio_path
 from tests.model_loader import get_model_path
 
 
+def _whisper_env_source() -> dict:
+    # On Windows _whisper_env() copies the app_env snapshot, not os.environ
+    return whisper_cpp.app_env if sys.platform == "win32" else os.environ
+
+
 class TestWhisperCpp:
     def test_transcribe(self):
         transcription_options = TranscriptionOptions(
@@ -617,3 +624,69 @@ def test_parse_word_level_timings_filters_aborted_superseded_fragments(self):
         segments = WhisperCpp._parse_word_level_timings(mock_result, language="en", vad_enabled=False)
         words = [s.text for s in segments]
         assert words == ["Hello", "world", "Goodbye", "all"]
+
+    def test_whisper_env_selects_discrete_gpu(self, monkeypatch):
+        monkeypatch.delitem(_whisper_env_source(), "GGML_VK_VISIBLE_DEVICES", raising=False)
+        with patch("buzz.transcriber.whisper_cpp.DISCRETE_GPU_INDEX", 1):
+            assert WhisperCpp._whisper_env()["GGML_VK_VISIBLE_DEVICES"] == "1"
+
+    def test_whisper_env_keeps_user_device_choice(self, monkeypatch):
+        monkeypatch.setitem(_whisper_env_source(), "GGML_VK_VISIBLE_DEVICES", "0")
+        with patch("buzz.transcriber.whisper_cpp.DISCRETE_GPU_INDEX", 1):
+            assert WhisperCpp._whisper_env()["GGML_VK_VISIBLE_DEVICES"] == "0"
+
+    def test_detect_language_uses_discrete_gpu(self, monkeypatch):
+        monkeypatch.delitem(_whisper_env_source(), "GGML_VK_VISIBLE_DEVICES", raising=False)
+        completed = MagicMock(stderr="auto-detected language: en (p = 0.9)\n", stdout="")
+        with patch(
+            "buzz.transcriber.whisper_cpp.subprocess.run", return_value=completed
+        ) as run_mock, patch(
+            "buzz.transcriber.whisper_cpp.get_whisper_cli_path",
+            return_value="/fake/whisper-cli",
+        ), patch("buzz.transcriber.whisper_cpp.DISCRETE_GPU_INDEX", 1):
+            WhisperCpp.detect_language("/fake/audio.wav", "/fake/model.bin")
+
+        assert run_mock.call_args.kwargs["env"]["GGML_VK_VISIBLE_DEVICES"] == "1"
+
+    def test_whisper_env_without_discrete_gpu(self, monkeypatch):
+        monkeypatch.delitem(_whisper_env_source(), "GGML_VK_VISIBLE_DEVICES", raising=False)
+        with patch("buzz.transcriber.whisper_cpp.DISCRETE_GPU_INDEX", None):
+            assert "GGML_VK_VISIBLE_DEVICES" not in WhisperCpp._whisper_env()
+
+    def test_vulkan_instance_uses_loader_api_version(self):
+        # ggml-vulkan creates its instance at the loader's highest API version, and the
+        # device order can differ between versions, so the probe must use the same one
+        vk = MagicMock()
+        vk.vkEnumerateInstanceVersion.return_value = 4206592  # 1.3.0
+
+        instance = whisper_cpp._create_vulkan_instance(vk)
+
+        vk.VkApplicationInfo.assert_called_once_with(apiVersion=4206592)
+        vk.VkInstanceCreateInfo.assert_called_once_with(
+            pApplicationInfo=vk.VkApplicationInfo.return_value
+        )
+        vk.vkCreateInstance.assert_called_once_with(vk.VkInstanceCreateInfo.return_value, None)
+        assert instance is vk.vkCreateInstance.return_value
+
+    @staticmethod
+    def _fake_vulkan(device_types):
+        vk = MagicMock()
+        vk.VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1
+        vk.VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2
+        vk.VK_PHYSICAL_DEVICE_TYPE_CPU = 4
+        devices = [MagicMock(deviceType=t, deviceName=f"gpu{i}") for i, t in enumerate(device_types)]
+        vk.vkEnumeratePhysicalDevices.return_value = list(range(len(devices)))
+        vk.vkGetPhysicalDeviceProperties.side_effect = lambda index: devices[index]
+        return vk
+
+    def test_find_discrete_gpu_index_after_integrated(self):
+        vk = self._fake_vulkan([1, 2, 4])
+        assert whisper_cpp._find_discrete_gpu_index(vk, MagicMock()) == 1
+
+    def test_find_discrete_gpu_index_returns_first_discrete(self):
+        vk = self._fake_vulkan([2, 1, 2])
+        assert whisper_cpp._find_discrete_gpu_index(vk, MagicMock()) == 0
+
+    def test_find_discrete_gpu_index_without_discrete(self):
+        vk = self._fake_vulkan([1, 4])
+        assert whisper_cpp._find_discrete_gpu_index(vk, MagicMock()) is None