@@ -58,8 +58,6 @@ def _patched_check_output(*args, **kwargs):
     subprocess.run = _patched_run
     subprocess.check_output = _patched_check_output
 
-from demucs import api as demucsApi
-
 from buzz.locale import _
 
 
@@ -189,6 +187,7 @@ def _extract_speech_streaming(conn, file_path: str, speech_path: str, device: st
     """Separate vocals window by window, writing them out as we go."""
     import numpy as np
     import torch
+    from demucs import api as demucsApi
 
     has_audio, duration = _probe_audio(file_path)
     if not has_audio:
@@ -315,11 +314,7 @@ def _speech_extraction_worker(conn, file_path: str, speech_path: str, device: st
 
 from buzz.model_loader import ModelType
 from buzz.transcriber.file_transcriber import FileTranscriber
-from buzz.transcriber.openai_whisper_api_file_transcriber import (
-    OpenAIWhisperAPIFileTranscriber,
-)
 from buzz.transcriber.transcriber import FileTranscriptionTask, Segment
-from buzz.transcriber.whisper_file_transcriber import WhisperFileTranscriber
 
 
 @dataclass
@@ -529,6 +524,13 @@ def _run_plugins(self) -> bool:
         return True
 
     def _create_transcriber(self):
+        # Imported here rather than at module level: they pull in openai, torch and
+        # transformers, which would otherwise add seconds to app startup.
+        from buzz.transcriber.openai_whisper_api_file_transcriber import (
+            OpenAIWhisperAPIFileTranscriber,
+        )
+        from buzz.transcriber.whisper_file_transcriber import WhisperFileTranscriber
+
         model_type = self.current.task.transcription_options.model.model_type
         if model_type == ModelType.OPEN_AI_WHISPER_API:
             self.current.transcriber = OpenAIWhisperAPIFileTranscriber(
 
@@ -42,7 +42,6 @@
     _certifi_ca_bundle = None
 
 import requests
-import whisper
 import huggingface_hub
 import zipfile
 from dataclasses import dataclass
@@ -764,6 +763,8 @@ def get_whisper_file_path(size: WhisperModelSize) -> str:
     if size == WhisperModelSize.CUSTOM:
         return os.path.join(root_dir, "custom")
 
+    import whisper  # imports torch, so keep it out of app startup
+
     url = whisper._MODELS[size.value]
     return os.path.join(root_dir, os.path.basename(url))
 
@@ -1010,6 +1011,8 @@ def _download_whisper_cpp(self) -> None:
             model_path, f"ggml-{model_name}.bin"))
 
     def _download_whisper(self) -> None:
+        import whisper
+
         url = whisper._MODELS[self.model.whisper_model_size.value]
         file_path = get_whisper_file_path(
             size=self.model.whisper_model_size)
 
@@ -10,8 +10,6 @@
 from pathlib import Path
 
 from PyQt6.QtCore import QObject, pyqtSignal, pyqtSlot
-from yt_dlp import YoutubeDL
-from yt_dlp.utils import DownloadCancelled
 
 from buzz import whisper_audio
 from buzz.assets import APP_BASE_DIR
@@ -138,6 +136,9 @@ def _identify_speakers(self, segments: List[Segment]) -> List[Segment]:
         )
 
     def _download_from_url(self) -> bool:
+        # Imported here as it is only needed for URL imports and slows app startup
+        from yt_dlp import YoutubeDL
+
         cookiefile = os.getenv("BUZZ_DOWNLOAD_COOKIEFILE")
 
         temp_dir = Path(tempfile.mkdtemp()).resolve()
@@ -266,6 +267,9 @@ def on_download_progress(self, data: dict):
         # yt-dlp calls this hook throughout the download and re-raises
         # DownloadCancelled out of extract_info, which aborts it cleanly.
         if self._download_canceled.is_set():
+            # yt-dlp is already loaded here, as it is the one calling this hook
+            from yt_dlp.utils import DownloadCancelled
+
             raise DownloadCancelled()
 
         if data.get("status") != "downloading":
 
@@ -15,14 +15,15 @@
 # Preload CUDA libraries before importing torch
 from buzz import cuda_setup  # noqa: F401
 
-import torch
+# torch, whisper, faster_whisper, transformers and openai are imported where they
+# are used: importing them all takes seconds, and opening the live recording window
+# would otherwise freeze the UI while only the selected backend needs its library.
 import numpy as np
 from buzz.transcriber.cuda_device import cuda_works
 import sounddevice
 from sounddevice import PortAudioError
 
 from buzz.audio_devices import registered_stream
-from openai import OpenAI
 from PyQt6.QtCore import QObject, pyqtSignal
 
 from buzz import whisper_audio
@@ -31,12 +32,8 @@
 from buzz.model_loader import ModelType, map_language_to_mms
 from buzz.settings.settings import Settings
 from buzz.transcriber.transcriber import TranscriptionOptions, Task, DEFAULT_WHISPER_TEMPERATURE
-from buzz.transformers_whisper import TransformersTranscriber
 from buzz.settings.recording_transcriber_mode import RecordingTranscriberMode
 
-import whisper
-import faster_whisper
-
 
 class RecordingTranscriber(QObject):
     transcription = pyqtSignal(str)
@@ -171,17 +168,6 @@ def start(self):
     def _load_model(self):
         model_path = self.model_path
 
-        force_cpu = os.getenv("BUZZ_FORCE_CPU", "false")
-        use_cuda = cuda_works() and force_cpu == "false"
-        self.use_cuda = use_cuda
-
-        if torch.cuda.is_available():
-            logging.debug(f"CUDA version detected: {torch.version.cuda}")
-
-        if self.transcription_options.model.model_type == ModelType.WHISPER:
-            device = "cuda" if use_cuda else "cpu"
-            return whisper.load_model(model_path, device=device)
-
         if self.transcription_options.model.model_type == ModelType.WHISPER_CPP:
             self.start_local_whisper_server()
             if self.openai_client is None:
@@ -193,7 +179,42 @@ def _load_model(self):
                     )
             return None
 
+        if self.transcription_options.model.model_type == ModelType.OPEN_AI_WHISPER_API:
+            from openai import OpenAI
+
+            custom_openai_base_url = self.settings.value(
+                key=Settings.Key.CUSTOM_OPENAI_BASE_URL, default_value="",
+            )
+            self.openai_client = OpenAI(
+                api_key=self.transcription_options.openai_access_token,
+                base_url=custom_openai_base_url if custom_openai_base_url else None,
+                max_retries=0,
+            )
+            logging.debug(
+                "Will use whisper API on %s, %s",
+                custom_openai_base_url, self.whisper_api_model,
+            )
+            return None
+
+        # Only the backends that run in this process need torch
+        import torch
+
+        force_cpu = os.getenv("BUZZ_FORCE_CPU", "false")
+        use_cuda = cuda_works() and force_cpu == "false"
+        self.use_cuda = use_cuda
+
+        if torch.cuda.is_available():
+            logging.debug(f"CUDA version detected: {torch.version.cuda}")
+
+        if self.transcription_options.model.model_type == ModelType.WHISPER:
+            import whisper
+
+            device = "cuda" if use_cuda else "cpu"
+            return whisper.load_model(model_path, device=device)
+
         if self.transcription_options.model.model_type == ModelType.FASTER_WHISPER:
+            import faster_whisper
+
             model_root_dir = user_cache_dir("Buzz")
             model_root_dir = os.path.join(model_root_dir, "models")
             model_root_dir = os.getenv("BUZZ_MODEL_ROOT", model_root_dir)
@@ -224,20 +245,7 @@ def _load_model(self):
                 cpu_threads=(os.cpu_count() or 8) // 2,
             )
 
-        if self.transcription_options.model.model_type == ModelType.OPEN_AI_WHISPER_API:
-            custom_openai_base_url = self.settings.value(
-                key=Settings.Key.CUSTOM_OPENAI_BASE_URL, default_value="",
-            )
-            self.openai_client = OpenAI(
-                api_key=self.transcription_options.openai_access_token,
-                base_url=custom_openai_base_url if custom_openai_base_url else None,
-                max_retries=0,
-            )
-            logging.debug(
-                "Will use whisper API on %s, %s",
-                custom_openai_base_url, self.whisper_api_model,
-            )
-            return None
+        from buzz.transformers_whisper import TransformersTranscriber
 
         return TransformersTranscriber(model_path)
 
@@ -260,6 +268,8 @@ def _transcribe(self, samples, model, initial_prompt):
         return self._transcribe_via_api(samples, initial_prompt)
 
     def _transcribe_whisper(self, samples, model, initial_prompt):
+        import whisper
+
         assert isinstance(model, whisper.Whisper)
         return model.transcribe(
             audio=samples,
@@ -272,6 +282,8 @@ def _transcribe_whisper(self, samples, model, initial_prompt):
         )
 
     def _transcribe_faster_whisper(self, samples, model, initial_prompt):
+        import faster_whisper
+
         assert isinstance(model, faster_whisper.WhisperModel)
         segments, _ = model.transcribe(
             audio=samples,
@@ -290,6 +302,8 @@ def _transcribe_faster_whisper(self, samples, model, initial_prompt):
         return {"text": " ".join(segment.text for segment in segments)}
 
     def _transcribe_hugging_face(self, samples, model):
+        from buzz.transformers_whisper import TransformersTranscriber
+
         assert isinstance(model, TransformersTranscriber)
         if model.is_mms_model:
             language = map_language_to_mms(
@@ -371,7 +385,9 @@ def _transcribe_via_api(self, samples, initial_prompt):
     def _cleanup_model(self, model):
         if model:
             del model
-        if torch.cuda.is_available():
+        # Nothing to free if no backend imported torch (whisper.cpp and the API)
+        torch = sys.modules.get("torch")
+        if torch is not None and torch.cuda.is_available():
             torch.cuda.empty_cache()
 
         self.finished.emit()
@@ -558,6 +574,8 @@ def start_local_whisper_server(self):
 
             return
 
+        from openai import OpenAI
+
         self.openai_client = OpenAI(
             api_key="not-used",
             base_url=f"http://127.0.0.1:{self._whisper_server_port}",
 
@@ -4,7 +4,6 @@
 import queue
 
 from typing import Optional, List, Tuple
-from openai import OpenAI
 from PyQt6.QtCore import QObject, pyqtSignal
 
 from buzz.settings.settings import Settings
@@ -47,15 +46,26 @@ def __init__(
                 key=Settings.Key.CUSTOM_OPENAI_BASE_URL, default_value=""
             )
         )
-        openai_api_key = os.getenv(
+        self.openai_api_key = os.getenv(
             "BUZZ_TRANSLATION_API_KEY",
             get_password(Key.OPENAI_API_KEY)
         )
-        self.openai_client = OpenAI(
-            api_key=openai_api_key,
-            base_url=custom_openai_base_url if custom_openai_base_url else None,
-            max_retries=0
-        )
+        self.openai_base_url = custom_openai_base_url if custom_openai_base_url else None
+        self._openai_client = None
+
+    @property
+    def openai_client(self):
+        # Created on the first translation, as importing openai takes about
+        # half a second and every transcription viewer creates a Translator
+        if self._openai_client is None:
+            from openai import OpenAI
+
+            self._openai_client = OpenAI(
+                api_key=self.openai_api_key,
+                base_url=self.openai_base_url,
+                max_retries=0
+            )
+        return self._openai_client
 
     def _translate_single(self, transcript: str, transcript_id: int) -> Tuple[str, int]:
         """Translate a single transcript via the API. Returns (translation, transcript_id)."""
 
@@ -665,14 +665,16 @@ def _maybe_show_cuda_prompt(self):
             return
         if not cuda_manager.should_offer_cuda_prompt():
             return
+        # Checked before is_cuda_torch_installed(), which imports torch and would
+        # otherwise add about a second to every launch after the first.
+        if self.settings.value(Settings.Key.CUDA_PROMPT_SHOWN, False):
+            return
         # The packaged builds all ship CPU-only torch, so this only ever fires
         # for a pip or source install where the user set up CUDA themselves.
         # Offering them a second, shadowing torch would be worse than useless.
         if cuda_manager.is_cuda_torch_installed():
             logging.debug("CUDA torch already available; not offering the install")
             return
-        if self.settings.value(Settings.Key.CUDA_PROMPT_SHOWN, False):
-            return
         self.settings.set_value(Settings.Key.CUDA_PROMPT_SHOWN, True)
 
         from PyQt6.QtCore import QTimer
 
@@ -18,7 +18,6 @@
     TRASH_ICON_PATH,
     UPDATE_ICON_PATH,
 )
-from buzz.widgets.recording_transcriber_widget import RecordingTranscriberWidget
 from buzz.widgets.toolbar import ToolBar
 
 
@@ -114,9 +113,16 @@ def reset_shortcuts(self):
         )
 
     def on_record_action_triggered(self):
+        # Imported on demand: the recording transcriber loads torch, whisper and
+        # transformers, which would otherwise add seconds to app startup.
+        from buzz.widgets.recording_transcriber_widget import RecordingTranscriberWidget
+
         recording_transcriber_window = RecordingTranscriberWidget(
             self, flags=Qt.WindowType.Window
         )
+        # Otherwise every closed window stays alive until the app exits, and
+        # tearing it down then crashes in PyQt's exit cleanup
+        recording_transcriber_window.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
         recording_transcriber_window.show()
 
     def set_stop_transcription_action_enabled(self, enabled: bool):
 
@@ -1,6 +1,6 @@
 import platform
 import webbrowser
-from typing import Optional
+from typing import Optional, TYPE_CHECKING
 
 from PyQt6.QtCore import pyqtSignal
 from PyQt6.QtGui import QAction, QKeySequence
@@ -12,9 +12,9 @@
 from buzz.settings.shortcuts import Shortcuts
 from buzz.widgets.about_dialog import AboutDialog
 from buzz.widgets.preferences_dialog.models.preferences import Preferences
-from buzz.widgets.preferences_dialog.preferences_dialog import (
-    PreferencesDialog,
-)
+
+if TYPE_CHECKING:
+    from buzz.widgets.preferences_dialog.preferences_dialog import PreferencesDialog
 
 
 class MenuBar(QMenuBar):
@@ -24,7 +24,7 @@ class MenuBar(QMenuBar):
     shortcuts_changed = pyqtSignal()
     openai_api_key_changed = pyqtSignal(str)
     preferences_changed = pyqtSignal(Preferences)
-    preferences_dialog: Optional[PreferencesDialog] = None
+    preferences_dialog: Optional["PreferencesDialog"] = None
 
     def __init__(
         self,
@@ -83,6 +83,9 @@ def on_about_action_triggered(self):
         about_dialog.open()
 
     def on_preferences_action_triggered(self):
+        # Imported on demand: the dialog pulls in openai, which slows app startup.
+        from buzz.widgets.preferences_dialog.preferences_dialog import PreferencesDialog
+
         preferences_dialog = PreferencesDialog(
             shortcuts=self.shortcuts,
             preferences=self.preferences,