Update README.md to include Supertonic TTS in PyQt6 Desktop GUI features - Supertonic 3 support

Fixes #163

README.md

@@ -38,6 +38,8 @@ This method handles everything automatically - installing all dependencies inclu
 #### <b>OPTION 2: Install using uv</b>
 First, [install uv](https://docs.astral.sh/uv/getting-started/installation/) if you haven't already.
 
+The CUDA extras install both GPU-accelerated Kokoro (via PyTorch) and Supertonic (via onnxruntime-gpu).
+
 ```bash
 # For NVIDIA GPUs (CUDA 12.8) - Recommended
 uv tool install --python 3.12 abogen[cuda] --extra-index-url https://download.pytorch.org/whl/cu128 --index-strategy unsafe-best-match
@@ -65,6 +67,9 @@ venv\Scripts\activate
 # We need to use an older version of PyTorch (2.8.0) until this issue is fixed: https://github.com/pytorch/pytorch/issues/166628
 pip install torch==2.8.0+cu128 torchvision==0.23.0+cu128 torchaudio==2.8.0 --index-url https://download.pytorch.org/whl/cu128
 
+# Also install onnxruntime-gpu for Supertonic GPU acceleration:
+pip install onnxruntime-gpu
+
 # For AMD GPUs:
 # Not supported yet, because ROCm is not available on Windows. Use Linux if you have AMD GPU.
 
@@ -173,7 +178,7 @@ Abogen offers **two interfaces**, but currently they have different feature sets
 
 | Command | Interface | Features |
 |---------|-----------|----------|
-| `abogen` | PyQt6 Desktop GUI | Stable core features |
+| `abogen` | PyQt6 Desktop GUI | Stable core features + **Supertonic TTS**|
 | `abogen-web` | Flask Web UI | Core features + **Supertonic TTS**, **LLM Normalization**, **Audiobookshelf Integration** and more! |
 
 > **Note:** The Web UI is under active development. We are working to integrate these new features into the PyQt desktop app. until then, the Web UI provides the most feature-rich experience.

WINDOWS_INSTALL.bat

@@ -323,6 +323,13 @@ if /I "%IS_NVIDIA%"=="true" (
             pause
             exit /b
         )
+        echo Installing onnxruntime-gpu for Supertonic GPU acceleration...
+        %PYTHON_CONSOLE_PATH% -m uv pip install --system onnxruntime-gpu
+        if errorlevel 1 (
+            echo Failed to install onnxruntime-gpu.
+            pause
+            exit /b
+        )
     ) else (
         echo CUDA is available on NVIDIA GPU.
     )
@@ -348,6 +355,13 @@ if /I "%IS_NVIDIA%"=="true" (
             pause
             exit /b
         )
+        echo Installing onnxruntime-gpu for Supertonic GPU acceleration...
+        %PYTHON_CONSOLE_PATH% -m uv pip install --system onnxruntime-gpu
+        if errorlevel 1 (
+            echo Failed to install onnxruntime-gpu.
+            pause
+            exit /b
+        )
     )
 )
 

abogen/constants.py

@@ -29,6 +29,57 @@ LANGUAGE_DESCRIPTIONS = {
     "z": "Mandarin Chinese",
 }
 
+# Mapping from Kokoro single-letter language codes to ISO 3166-1 alpha-2 country codes
+# Used for loading flag icons
+KOKORO_LANG_TO_COUNTRY = {
+    "a": "us",  # American English -> United States
+    "b": "gb",  # British English -> United Kingdom
+    "e": "es",  # Spanish -> Spain
+    "f": "fr",  # French -> France
+    "h": "in",  # Hindi -> India
+    "i": "it",  # Italian -> Italy
+    "j": "jp",  # Japanese -> Japan
+    "p": "br",  # Brazilian Portuguese -> Brazil
+    "z": "cn",  # Mandarin Chinese -> China
+}
+
+# Mapping from Supertonic ISO 639-1 language codes to ISO 3166-1 alpha-2 country codes
+# Used for loading flag icons in the Supertonic language picker
+SUPERTONIC_LANG_TO_COUNTRY = {
+    "en": "gb",
+    "ko": "kr",
+    "ja": "jp",
+    "ar": "ae",
+    "bg": "bg",
+    "cs": "cz",
+    "da": "dk",
+    "de": "de",
+    "el": "gr",
+    "es": "es",
+    "et": "ee",
+    "fi": "fi",
+    "fr": "fr",
+    "hi": "in",
+    "hr": "hr",
+    "hu": "hu",
+    "id": "id",
+    "it": "it",
+    "lt": "lt",
+    "lv": "lv",
+    "nl": "nl",
+    "pl": "pl",
+    "pt": "pt",
+    "ro": "ro",
+    "ru": "ru",
+    "sk": "sk",
+    "sl": "si",
+    "sv": "se",
+    "tr": "tr",
+    "uk": "ua",
+    "vi": "vn",
+    "na": "na",
+}
+
 # Supported sound formats
 SUPPORTED_SOUND_FORMATS = [
     "wav",

abogen/pyqt/conversion.py

@@ -20,6 +20,7 @@ from abogen.constants import (
     SUPPORTED_SOUND_FORMATS,
     SUPPORTED_SUBTITLE_FORMATS,
 )
+from abogen.tts_supertonic import SupertonicPipeline, SUPERTONIC_AVAILABLE_LANGS, DEFAULT_SUPERTONIC_VOICES
 from abogen.voice_formulas import get_new_voice
 import abogen.hf_tracker as hf_tracker
 import static_ffmpeg
@@ -266,7 +267,10 @@ class ConversionThread(QThread):
         use_gpu=True,
         from_queue=False,
         save_base_path=None,
-    ):  # Add use_gpu parameter
+        tts_provider="kokoro",
+        supertonic_language="en",
+        supertonic_total_steps=8,
+    ):
         super().__init__()
         self._chapter_options_event = threading.Event()
         self._timestamp_response_event = threading.Event()
@@ -276,6 +280,10 @@ class ConversionThread(QThread):
         self.lang_code = lang_code
         self.speed = speed
         self.voice = voice
+        self.tts_provider = tts_provider
+        self.supertonic_language = supertonic_language
+        self.supertonic_total_steps = supertonic_total_steps
+        self.sample_rate = 44100 if tts_provider == "supertonic" else 24000
         self.save_option = save_option
         self.output_folder = output_folder
         self.subtitle_mode = subtitle_mode
@@ -427,6 +435,10 @@ class ConversionThread(QThread):
             )
             self.log_updated.emit(f"- Voice: {self.voice}")
             self.log_updated.emit(f"- Speed: {self.speed}")
+            tts_provider_label = self.tts_provider.capitalize()
+            if self.tts_provider == "supertonic":
+                tts_provider_label += f" (lang={self.supertonic_language}, steps={self.supertonic_total_steps})"
+            self.log_updated.emit(f"- TTS Engine: {tts_provider_label}")
             self.log_updated.emit(f"- Subtitle mode: {self.subtitle_mode}")
             self.log_updated.emit(f"- Output format: {self.output_format}")
             self.log_updated.emit(
@@ -499,6 +511,13 @@ class ConversionThread(QThread):
             else:
                 device = "cpu"
 
+            if self.tts_provider == "supertonic":
+                tts = SupertonicPipeline(
+                    sample_rate=self.sample_rate,
+                    lang=self.supertonic_language,
+                    total_steps=self.supertonic_total_steps,
+                )
+            else:
                 tts = self.KPipeline(
                     lang_code=self.lang_code, repo_id="hexgrad/Kokoro-82M", device=device
                 )
@@ -747,7 +766,7 @@ class ConversionThread(QThread):
                 merged_out_path = f"{base_filepath_no_ext}.{self.output_format}"
                 subtitle_entries = []
                 current_time = 0.0
-                rate = 24000
+                rate = self.sample_rate
                 subtitle_mode = self.subtitle_mode
                 self.etr_start_time = time.time()
                 self.processed_char_count = 0
@@ -763,7 +782,7 @@ class ConversionThread(QThread):
                     merged_out_file = sf.SoundFile(
                         merged_out_path,
                         "w",
-                        samplerate=24000,
+                        samplerate=self.sample_rate,
                         channels=1,
                         format=self.output_format,
                     )
@@ -785,51 +804,7 @@ class ConversionThread(QThread):
                             "-f",
                             "f32le",
                             "-ar",
-                        "24000",
+                            str(self.sample_rate),
-                        "-ac",
-                        "1",
-                        "-i",
-                        "pipe:0",
-                    ]
-                    if cover_path and os.path.exists(cover_path):
-                        cmd.extend(
-                            [
-                                "-i",
-                                cover_path,
-                                "-map",
-                                "0:a",
-                                "-map",
-                                "1",
-                                "-c:v",
-                                "copy",
-                                "-disposition:v",
-                                "attached_pic",
-                            ]
-                        )
-                    cmd.extend(
-                        [
-                            "-c:a",
-                            "aac",
-                            "-q:a",
-                            "2",
-                            "-movflags",
-                            "+faststart+use_metadata_tags",
-                        ]
-                    )
-                    cmd += metadata_options
-                    cmd.append(merged_out_path)
-                    ffmpeg_proc = create_process(cmd, stdin=subprocess.PIPE, text=False)
-                elif self.output_format == "opus":
-                    static_ffmpeg.add_paths()
-                    cmd = [
-                        "ffmpeg",
-                        "-y",
-                        "-thread_queue_size",
-                        "32768",
-                        "-f",
-                        "f32le",
-                        "-ar",
-                        "24000",
                             "-ac",
                             "1",
                             "-i",
@@ -916,7 +891,7 @@ class ConversionThread(QThread):
                 merged_out_path = None
                 subtitle_entries = []
                 current_time = 0.0
-                rate = 24000
+                rate = self.sample_rate
                 subtitle_mode = self.subtitle_mode
                 self.etr_start_time = time.time()
                 self.processed_char_count = 0
@@ -969,7 +944,7 @@ class ConversionThread(QThread):
                         chapter_out_file = sf.SoundFile(
                             chapter_out_path,
                             "w",
-                            samplerate=24000,
+                            samplerate=self.sample_rate,
                             channels=1,
                             format=separate_chapters_format,
                         )
@@ -984,7 +959,7 @@ class ConversionThread(QThread):
                             "-f",
                             "f32le",
                             "-ar",
-                            "24000",
+                            str(self.sample_rate),
                             "-ac",
                             "1",
                             "-i",
@@ -1366,7 +1341,7 @@ class ConversionThread(QThread):
                 # Add silence between chapters for merged output (except after the last chapter)
                 if merge_chapters_at_end and chapter_idx < total_chapters:
                     silence_samples = int(
-                        self.silence_duration * 24000
+                        self.silence_duration * self.sample_rate
                     )  # Silence duration at 24,000 Hz
                     silence_audio = self.np.zeros(silence_samples, dtype="float32")
                     silence_bytes = silence_audio.tobytes()
@@ -1597,7 +1572,7 @@ class ConversionThread(QThread):
                 parent_dir, f"{sanitized_base_name}{suffix}"
             )
             merged_out_path = f"{base_filepath_no_ext}.{self.output_format}"
-            rate = 24000
+            rate = self.sample_rate
 
             # Setup audio output
             merged_out_file, ffmpeg_proc = None, None
@@ -2447,6 +2422,9 @@ class VoicePreviewThread(QThread):
         speed,
         use_gpu=False,
         parent=None,
+        tts_provider="kokoro",
+        supertonic_language="en",
+        supertonic_total_steps=8,
     ):
         super().__init__(parent)
         self.np_module = np_module
@@ -2455,6 +2433,10 @@ class VoicePreviewThread(QThread):
         self.voice = voice
         self.speed = speed
         self.use_gpu = use_gpu
+        self.tts_provider = tts_provider
+        self.supertonic_language = supertonic_language
+        self.supertonic_total_steps = supertonic_total_steps
+        self.sample_rate = 44100 if tts_provider == "supertonic" else 24000
 
         # Cache location for preview audio
         self.cache_dir = get_user_cache_path("preview_cache")
@@ -2464,6 +2446,11 @@ class VoicePreviewThread(QThread):
 
     def _get_cache_path(self):
         """Generate a unique filename for the voice with its parameters"""
+        if self.tts_provider == "supertonic":
+            voice_id = self.voice or "M1"
+            filename = f"st_{voice_id}_{self.supertonic_language}_steps{self.supertonic_total_steps}_{self.speed:.2f}.wav"
+            return os.path.join(self.cache_dir, filename)
+
         # For a voice formula, use a hash of the formula
         if "*" in self.voice:
             voice_id = (
@@ -2478,25 +2465,42 @@ class VoicePreviewThread(QThread):
 
     def run(self):
         print(
-            f"\nVoice: {self.voice}\nLanguage: {self.lang_code}\nSpeed: {self.speed}\nGPU: {self.use_gpu}\n"
+            f"\nVoice: {self.voice}\nLanguage: {self.lang_code}\nSpeed: {self.speed}\nGPU: {self.use_gpu}\nTTS Provider: {self.tts_provider}\n"
         )
 
         # Generate the preview and save to cache
         try:
+            if self.tts_provider == "supertonic":
+                from abogen.tts_supertonic import SupertonicPipeline
 
+                tts = SupertonicPipeline(
+                    sample_rate=self.sample_rate,
+                    lang=self.supertonic_language,
+                    total_steps=self.supertonic_total_steps,
+                )
+                loaded_voice = self.voice or "M1"
+                sample_text = "Hello, this is a sample of the selected voice."
+                audio_segments = []
+                for result in tts(
+                    sample_text,
+                    voice=loaded_voice,
+                    speed=self.speed,
+                    split_pattern=None,
+                ):
+                    audio_segments.append(result.audio)
+            else:
                 # Set device based on use_gpu setting and platform
                 if self.use_gpu:
                     if platform.system() == "Darwin" and platform.processor() == "arm":
-                    device = "mps"  # Use MPS for Apple Silicon
+                        device = "mps"
                     else:
-                    device = "cuda"  # Use CUDA for other platforms
+                        device = "cuda"
                 else:
                     device = "cpu"
 
                 tts = self.kpipeline_class(
                     lang_code=self.lang_code, repo_id="hexgrad/Kokoro-82M", device=device
                 )
-            # Enable voice formula support for preview
                 if "*" in self.voice:
                     loaded_voice = get_new_voice(tts, self.voice, self.use_gpu)
                 else:
@@ -2507,10 +2511,10 @@ class VoicePreviewThread(QThread):
                     sample_text, voice=loaded_voice, speed=self.speed, split_pattern=None
                 ):
                     audio_segments.append(result.audio)
+
             if audio_segments:
                 audio = self.np_module.concatenate(audio_segments)
-                # Save directly to the cache path
+                sf.write(self.cache_path, audio, self.sample_rate)
-                sf.write(self.cache_path, audio, 24000)
                 self.temp_wav = self.cache_path
             self.finished.emit()
         except Exception as e:

abogen/pyqt/gui.py

@@ -9,6 +9,7 @@ from abogen.pyqt.queue_manager_gui import QueueManager
 from abogen.pyqt.queued_item import QueuedItem
 import abogen.hf_tracker as hf_tracker
 import hashlib  # Added for cache path generation
+from abogen.tts_supertonic import SUPERTONIC_AVAILABLE_LANGS, DEFAULT_SUPERTONIC_VOICES
 from PyQt6.QtWidgets import (
     QApplication,
     QWidget,
@@ -83,6 +84,8 @@ from abogen.constants import (
     PROGRAM_DESCRIPTION,
     LANGUAGE_DESCRIPTIONS,
     VOICES_INTERNAL,
+    KOKORO_LANG_TO_COUNTRY,
+    SUPERTONIC_LANG_TO_COUNTRY,
     SUPPORTED_LANGUAGES_FOR_SUBTITLE_GENERATION,
     COLORS,
     SUBTITLE_FORMATS,
@@ -970,6 +973,9 @@ class abogen(QWidget):
         self.fix_nonstandard_punctuation = self.config.get(
             "fix_nonstandard_punctuation", False
         )
+        self.tts_provider_config = self.config.get("tts_provider", "kokoro")
+        self.supertonic_language_config = self.config.get("supertonic_language", "en")
+        self.supertonic_total_steps_config = self.config.get("supertonic_total_steps", 8)
         self._pending_close_event = None
         self.gpu_ok = False  # Initialize GPU availability status
 
@@ -1018,6 +1024,16 @@ class abogen(QWidget):
                 else:
                     self.mixed_voice_state = entry
                     self.selected_lang = entry[0][0] if entry and entry[0] else None
+        # Restore TTS provider and supertonic settings from config
+        provider_text = "Supertonic" if self.tts_provider_config == "supertonic" else "Kokoro"
+        idx_st = self.provider_combo.findText(provider_text)
+        if idx_st >= 0:
+            self.provider_combo.setCurrentIndex(idx_st)
+        self.st_lang_combo.setCurrentText(self.supertonic_language_config)
+        idx_steps = self.st_steps_combo.findData(self.supertonic_total_steps_config)
+        if idx_steps >= 0:
+            self.st_steps_combo.setCurrentIndex(idx_steps)
+
         if self.save_option == "Choose output folder" and self.selected_output_folder:
             self.save_path_label.setText(self.selected_output_folder)
             self.save_path_row_widget.show()
@@ -1107,6 +1123,53 @@ class abogen(QWidget):
         speed_layout.addWidget(self.speed_label)
         controls_layout.addLayout(speed_layout)
         self.speed_slider.valueChanged.connect(self.update_speed_label)
+
+        # TTS Provider selection
+        provider_layout = QHBoxLayout()
+        provider_layout.setSpacing(7)
+        provider_label = QLabel("TTS Engine:", self)
+        provider_layout.addWidget(provider_label)
+        self.provider_combo = QComboBox(self)
+        self.provider_combo.addItem("Kokoro", "kokoro")
+        self.provider_combo.addItem("Supertonic", "supertonic")
+        self.provider_combo.setStyleSheet("QComboBox { min-height: 20px; padding: 6px 12px; }")
+        self.provider_combo.currentIndexChanged.connect(self.on_provider_changed)
+        provider_layout.addWidget(self.provider_combo)
+        controls_layout.addLayout(provider_layout)
+
+        # Supertonic-specific controls (language + steps), hidden by default
+        self.supertonic_row = QWidget()
+        supertonic_row_layout = QHBoxLayout(self.supertonic_row)
+        supertonic_row_layout.setContentsMargins(0, 0, 0, 0)
+        supertonic_row_layout.setSpacing(7)
+
+        st_lang_label = QLabel("Language:", self)
+        supertonic_row_layout.addWidget(st_lang_label)
+        self.st_lang_combo = QComboBox(self)
+        for code in SUPERTONIC_AVAILABLE_LANGS:
+            country_code = SUPERTONIC_LANG_TO_COUNTRY.get(code, code)
+            flag = get_resource_path("abogen.assets.flags", f"{country_code}.png")
+            icon_st = QIcon(flag) if flag and os.path.exists(flag) else QIcon()
+            self.st_lang_combo.addItem(icon_st, code, code)
+        self.st_lang_combo.setCurrentText("en")
+        self.st_lang_combo.setStyleSheet("QComboBox { min-height: 20px; padding: 6px 12px; }")
+        self.st_lang_combo.currentTextChanged.connect(self._on_st_lang_changed)
+        supertonic_row_layout.addWidget(self.st_lang_combo)
+
+        st_steps_label = QLabel("Steps:", self)
+        supertonic_row_layout.addWidget(st_steps_label)
+        self.st_steps_combo = QComboBox(self)
+        for val in range(2, 16):
+            self.st_steps_combo.addItem(str(val), val)
+        self.st_steps_combo.setCurrentIndex(self.st_steps_combo.findData(8))
+        self.st_steps_combo.setStyleSheet("QComboBox { min-height: 20px; padding: 6px 12px; }")
+        self.st_steps_combo.currentIndexChanged.connect(self._on_st_steps_changed)
+        supertonic_row_layout.addWidget(self.st_steps_combo)
+
+        supertonic_row_layout.addStretch()
+        self.supertonic_row.hide()
+        controls_layout.addWidget(self.supertonic_row)
+
         # Voice selection
         voice_layout = QHBoxLayout()
         voice_layout.setSpacing(7)
@@ -1764,6 +1827,12 @@ class abogen(QWidget):
         Update the enabled state of subtitle options based on the selected language.
         For non-English languages, only sentence-based and line-based modes are supported.
         """
+        provider = self.provider_combo.currentData()
+        if provider == "supertonic":
+            self.subtitle_combo.setEnabled(False)
+            self.subtitle_format_combo.setEnabled(False)
+            return
+
         # Check if current file is a subtitle file
         is_subtitle_input = False
         if self.selected_file and self.selected_file.lower().endswith(
@@ -1823,6 +1892,48 @@ class abogen(QWidget):
         # Enable/disable subtitle options based on language
         self.update_subtitle_options_availability()
 
+    def on_provider_changed(self, index):
+        provider = self.provider_combo.itemData(index)
+        self.config["tts_provider"] = provider
+        save_config(self.config)
+        is_supertonic = provider == "supertonic"
+
+        # Show/hide Supertonic controls
+        self.supertonic_row.setVisible(is_supertonic)
+
+        # Update subtitles availability
+        self.update_subtitle_options_availability()
+
+        # Repopulate voice list
+        self.populate_profiles_in_voice_combo()
+
+        # Clear/reset mixed voice state when switching provider
+        if is_supertonic:
+            self.mixed_voice_state = None
+            self.btn_voice_formula_mixer.setEnabled(False)
+            self.voice_combo.setToolTip(
+                "Supertonic voices:\n"
+                "M1-M5 = Male voices\n"
+                "F1-F5 = Female voices"
+            )
+        else:
+            self.btn_voice_formula_mixer.setEnabled(True)
+            self.voice_combo.setToolTip(
+                "The first character represents the language:\n"
+                '"a" => American English\n"b" => British English\n"e" => Spanish\n"f" => French\n"h" => Hindi\n"i" => Italian\n"j" => Japanese\n"p" => Brazilian Portuguese\n"z" => Mandarin Chinese\nThe second character represents the gender:\n"m" => Male\n"f" => Female'
+            )
+
+    def _on_st_lang_changed(self, lang):
+        self.config["supertonic_language"] = lang
+        save_config(self.config)
+        if self.provider_combo.currentData() == "supertonic":
+            self.selected_lang = lang
+            self.update_subtitle_options_availability()
+
+    def _on_st_steps_changed(self):
+        self.config["supertonic_total_steps"] = self.st_steps_combo.currentData()
+        save_config(self.config)
+
     def on_voice_combo_changed(self, index):
         data = self.voice_combo.itemData(index)
         if isinstance(data, str) and data.startswith("profile:"):
@@ -1831,8 +1942,24 @@ class abogen(QWidget):
             from abogen.voice_profiles import load_profiles
 
             entry = load_profiles().get(pname, {})
-            # set mixed voices and language
             if isinstance(entry, dict):
+                entry_provider = str(entry.get("provider", "")).strip().lower()
+                if entry_provider == "supertonic":
+                    # Switch provider to Supertonic if not already
+                    if self.provider_combo.currentData() != "supertonic":
+                        self.provider_combo.setCurrentIndex(1)
+                    self.mixed_voice_state = None
+                    self.selected_lang = entry.get("language", self.st_lang_combo.currentText())
+                    # Sync supertonic controls from profile
+                    profile_steps = entry.get("total_steps")
+                    if profile_steps is not None:
+                        idx_steps = self.st_steps_combo.findData(int(profile_steps))
+                        if idx_steps >= 0:
+                            self.st_steps_combo.setCurrentIndex(idx_steps)
+                    profile_lang = entry.get("language")
+                    if profile_lang and profile_lang in SUPERTONIC_AVAILABLE_LANGS:
+                        self.st_lang_combo.setCurrentText(profile_lang)
+                else:
                     self.mixed_voice_state = entry.get("voices", [])
                     self.selected_lang = entry.get("language")
             else:
@@ -1847,7 +1974,12 @@ class abogen(QWidget):
         else:
             self.mixed_voice_state = None
             self.selected_profile_name = None
-            self.selected_voice, self.selected_lang = data, data[0]
+            self.selected_voice = data
+            provider = self.provider_combo.currentData()
+            if provider == "supertonic":
+                self.selected_lang = self.st_lang_combo.currentText()
+            else:
+                self.selected_lang = data[0] if data else ""
             self.config["selected_voice"] = data
             if "selected_profile_name" in self.config:
                 del self.config["selected_profile_name"]
@@ -1866,16 +1998,37 @@ class abogen(QWidget):
     def populate_profiles_in_voice_combo(self):
         # preserve current voice or profile
         current = self.voice_combo.currentData()
+        provider = self.provider_combo.currentData()
         self.voice_combo.blockSignals(True)
         self.voice_combo.clear()
-        # re-add profiles
+        # re-add profiles matching current provider
         profile_icon = QIcon(get_resource_path("abogen.assets", "profile.png"))
-        for pname in load_profiles().keys():
+        for pname, entry in load_profiles().items():
+            entry_provider = ""
+            if isinstance(entry, dict):
+                entry_provider = str(entry.get("provider", "")).strip().lower()
+            if provider == "supertonic":
+                if entry_provider == "supertonic":
+                    self.voice_combo.addItem(profile_icon, pname, f"profile:{pname}")
+            else:
+                if entry_provider != "supertonic":
                     self.voice_combo.addItem(profile_icon, pname, f"profile:{pname}")
         # re-add voices
+        if provider == "supertonic":
+            for v in DEFAULT_SUPERTONIC_VOICES:
+                icon = QIcon()
+                if v.startswith("F"):
+                    icon_path = get_resource_path("abogen.assets", "female.png")
+                else:
+                    icon_path = get_resource_path("abogen.assets", "male.png")
+                if icon_path and os.path.exists(icon_path):
+                    icon = QIcon(icon_path)
+                self.voice_combo.addItem(icon, f"{v}", v)
+        else:
             for v in VOICES_INTERNAL:
                 icon = QIcon()
-            flag_path = get_resource_path("abogen.assets.flags", f"{v[0]}.png")
+                country_code = KOKORO_LANG_TO_COUNTRY.get(v[0], v[0])
+                flag_path = get_resource_path("abogen.assets.flags", f"{country_code}.png")
                 if flag_path and os.path.exists(flag_path):
                     icon = QIcon(flag_path)
                 self.voice_combo.addItem(icon, f"{v}", v)
@@ -2069,6 +2222,9 @@ class abogen(QWidget):
             save_base_path=save_base_path,
             save_chapters_separately=getattr(self, "save_chapters_separately", None),
             merge_chapters_at_end=getattr(self, "merge_chapters_at_end", None),
+            tts_provider=self.provider_combo.currentData(),
+            supertonic_language=self.st_lang_combo.currentText(),
+            supertonic_total_steps=self.st_steps_combo.currentData(),
         )
 
         # Prevent adding duplicate items to the queue
@@ -2212,6 +2368,15 @@ class abogen(QWidget):
                 self.config["replace_numerals"] = self.replace_numerals
                 self.config["fix_nonstandard_punctuation"] = self.fix_nonstandard_punctuation
 
+                # TTS provider settings
+                tts_provider = getattr(queued_item, "tts_provider", "kokoro")
+                self.provider_combo.setCurrentText("Supertonic" if tts_provider == "supertonic" else "Kokoro")
+                self.st_lang_combo.setCurrentText(getattr(queued_item, "supertonic_language", "en"))
+                steps_val = getattr(queued_item, "supertonic_total_steps", 8)
+                idx_steps = self.st_steps_combo.findData(steps_val)
+                if idx_steps >= 0:
+                    self.st_steps_combo.setCurrentIndex(idx_steps)
+
                 # Sync Voice/Profile in config
                 self.config["selected_voice"] = self.selected_voice
                 if "selected_profile_name" in self.config:
@@ -2234,6 +2399,8 @@ class abogen(QWidget):
             self.current_queue_index = 0  # Reset for next time
 
     def get_voice_formula(self) -> str:
+        if self.provider_combo.currentData() == "supertonic":
+            return self._get_supertonic_voice()
         if self.mixed_voice_state:
             formula_components = [
                 f"{name}*{weight}" for name, weight in self.mixed_voice_state
@@ -2243,6 +2410,8 @@ class abogen(QWidget):
             return self.selected_voice
 
     def get_selected_lang(self, voice_formula) -> str:
+        if self.provider_combo.currentData() == "supertonic":
+            return self.st_lang_combo.currentText()
         if self.selected_profile_name:
             from abogen.voice_profiles import load_profiles
 
@@ -2332,6 +2501,10 @@ class abogen(QWidget):
             # determine selected language: use profile setting if profile selected, else voice code
             selected_lang = self.get_selected_lang(voice_formula)
 
+            tts_provider = self.provider_combo.currentData()
+            supertonic_language = self.st_lang_combo.currentText()
+            supertonic_total_steps = self.st_steps_combo.currentData()
+
             self.conversion_thread = ConversionThread(
                 self.selected_file,
                 selected_lang,
@@ -2347,8 +2520,11 @@ class abogen(QWidget):
                 total_char_count=self.char_count,
                 use_gpu=self.gpu_ok,
                 from_queue=from_queue,
-                save_base_path=self.displayed_file_path,  # Pass the save base path (original file for EPUB)
+                save_base_path=self.displayed_file_path,
-            )  # Use gpu_ok status
+                tts_provider=tts_provider,
+                supertonic_language=supertonic_language,
+                supertonic_total_steps=supertonic_total_steps,
+            )
             # Pass the displayed file path to the log_updated signal handler in ConversionThread
             self.conversion_thread.display_path = display_path
             # Pass the file size string
@@ -2425,6 +2601,12 @@ class abogen(QWidget):
             # Store gpu_ok status to use when creating the conversion thread
             self.gpu_ok = gpu_ok
             self.update_log((gpu_msg, gpu_ok))
+            tts_provider = self.provider_combo.currentData()
+            if tts_provider == "supertonic":
+                # Supertonic doesn't need KPipeline, call callback directly
+                import numpy as np
+                pipeline_loaded_callback(np, None, None)
+            else:
                 self.update_log("Loading modules...")
                 load_thread = LoadPipelineThread(pipeline_loaded_callback)
                 load_thread.start()
@@ -2740,9 +2922,32 @@ class abogen(QWidget):
                 "Open File Error", f"Could not open file:\n{e}"
             )
 
+    def _get_supertonic_voice(self) -> str:
+        """Resolve the effective Supertonic voice from the current combo selection."""
+        if self.selected_profile_name:
+            from abogen.voice_profiles import load_profiles
+            entry = load_profiles().get(self.selected_profile_name, {})
+            if isinstance(entry, dict):
+                return str(entry.get("voice", "M1"))
+            return "M1"
+        current_data = self.voice_combo.currentData()
+        if current_data and isinstance(current_data, str) and not current_data.startswith("profile:"):
+            return current_data
+        return "M1"
+
     def _get_preview_cache_path(self):
         """Generate the expected cache path for the current voice settings."""
         speed = self.speed_slider.value() / 100.0
+        provider = self.provider_combo.currentData()
+
+        if provider == "supertonic":
+            voice_to_cache = self._get_supertonic_voice()
+            lang_to_cache = self.st_lang_combo.currentText()
+            steps = self.st_steps_combo.currentData()
+            cache_dir = get_user_cache_path("preview_cache")
+            filename = f"st_{voice_to_cache}_{lang_to_cache}_steps{steps}_{speed:.2f}.wav"
+            return os.path.join(cache_dir, filename)
+
         voice_to_cache = ""
         lang_to_cache = ""
 
@@ -2847,6 +3052,13 @@ class abogen(QWidget):
         self.btn_voice_formula_mixer.setEnabled(False)  # Disable mixer button
         self.btn_start.setEnabled(False)  # Disable start button during preview
 
+        # For Supertonic, skip KPipeline loading and use SupertonicPipeline directly
+        if self.provider_combo.currentData() == "supertonic":
+            import numpy as np
+            self.loading_movie.start()
+            self._on_pipeline_loaded_for_preview(np, None, None)
+            return
+
         # Start loading animation - ensure signal connection is always active
         if hasattr(self, "loading_movie"):
             # Disconnect previous connections to avoid multiple connections
@@ -2905,14 +3117,28 @@ class abogen(QWidget):
                     else None
                 )
         else:
-            lang = self.selected_voice[0]
+            if self.provider_combo.currentData() == "supertonic":
-            voice = self.selected_voice
+                voice = self._get_supertonic_voice()
+            else:
+                voice = self.selected_voice or ""
+
+        tts_provider = self.provider_combo.currentData()
+        supertonic_language = self.st_lang_combo.currentText()
+        supertonic_total_steps = self.st_steps_combo.currentData()
+
+        if tts_provider == "supertonic":
+            lang = supertonic_language
+        else:
+            lang = self.selected_voice[0] if self.selected_voice else ""
 
         # use same gpu/cpu logic as in conversion
         gpu_msg, gpu_ok = get_gpu_acceleration(self.use_gpu)
 
         self.preview_thread = VoicePreviewThread(
-            np_module, kpipeline_class, lang, voice, speed, gpu_ok
+            np_module, kpipeline_class, lang, voice, speed, gpu_ok,
+            tts_provider=tts_provider,
+            supertonic_language=supertonic_language,
+            supertonic_total_steps=supertonic_total_steps,
         )
         self.preview_thread.finished.connect(self._play_preview_audio)
         self.preview_thread.error.connect(self._preview_error)

abogen/pyqt/queued_item.py

@@ -26,3 +26,7 @@ class QueuedItem:
     replace_all_caps: bool = False
     replace_numerals: bool = False
     fix_nonstandard_punctuation: bool = False
+    # TTS Provider fields
+    tts_provider: str = "kokoro"
+    supertonic_language: str = "en"
+    supertonic_total_steps: int = 8

abogen/pyqt/voice_formula_gui.py

@@ -31,6 +31,7 @@ from abogen.constants import (
     VOICES_INTERNAL,
     SUPPORTED_LANGUAGES_FOR_SUBTITLE_GENERATION,
     LANGUAGE_DESCRIPTIONS,
+    KOKORO_LANG_TO_COUNTRY,
     COLORS,
 )
 import re
@@ -189,8 +190,9 @@ class VoiceMixer(QWidget):
         )  # Center the icons horizontally
 
         # Flag icon
+        country_code = KOKORO_LANG_TO_COUNTRY.get(language_code, language_code)
         flag_icon_path = get_resource_path(
-            "abogen.assets.flags", f"{language_code}.png"
+            "abogen.assets.flags", f"{country_code}.png"
         )
         gender_icon_path = get_resource_path(
             "abogen.assets", "female.png" if is_female else "male.png"
@@ -512,7 +514,8 @@ class VoiceFormulaDialog(QDialog):
         header_row.addWidget(QLabel("Language:"))
         self.language_combo = QComboBox()
         for code, desc in LANGUAGE_OPTIONS:
-            flag = get_resource_path("abogen.assets.flags", f"{code}.png")
+            country_code = KOKORO_LANG_TO_COUNTRY.get(code, code)
+            flag = get_resource_path("abogen.assets.flags", f"{country_code}.png")
             if flag and os.path.exists(flag):
                 self.language_combo.addItem(QIcon(flag), desc, code)
             else:

abogen/tts_supertonic.py

@@ -4,6 +4,7 @@ import ast
 from dataclasses import dataclass
 import logging
 import math
+import os
 import re
 from typing import Any, Iterable, Iterator, Optional
 
@@ -15,6 +16,13 @@ logger = logging.getLogger(__name__)
 
 DEFAULT_SUPERTONIC_VOICES = ("M1", "M2", "M3", "M4", "M5", "F1", "F2", "F3", "F4", "F5")
 
+SUPERTONIC_AVAILABLE_LANGS = [
+    "en", "ko", "ja", "ar", "bg", "cs", "da", "de", "el",
+    "es", "et", "fi", "fr", "hi", "hr", "hu", "id", "it",
+    "lt", "lv", "nl", "pl", "pt", "ro", "ru", "sk", "sl",
+    "sv", "tr", "uk", "vi", "na",
+]
+
 
 @dataclass
 class SupertonicSegment:
@@ -89,7 +97,7 @@ _UNSUPPORTED_CHARS_RE = re.compile(
 
 
 def _parse_unsupported_characters(error: BaseException) -> list[str]:
-    """Best-effort extraction of unsupported characters from SuperTonic errors."""
+    """Best-effort extraction of unsupported characters from Supertonic errors."""
 
     message = " ".join(
         str(part) for part in getattr(error, "args", ()) if part is not None
@@ -155,6 +163,7 @@ def _configure_supertonic_gpu() -> None:
     except Exception as exc:
         logger.warning("Could not configure supertonic GPU providers: %s", exc)
 
+SUPERTONIC_MAX_CHUNK_LENGTH = 500
 
 class SupertonicPipeline:
     """Minimal adapter that mimics Kokoro's pipeline iteration interface."""
@@ -165,11 +174,14 @@ class SupertonicPipeline:
         sample_rate: int,
         auto_download: bool = True,
         total_steps: int = 5,
-        max_chunk_length: int = 300,
+        max_chunk_length: int = SUPERTONIC_MAX_CHUNK_LENGTH,
+        lang: str = "en",
+        intra_op_num_threads: Optional[int] = None,
     ) -> None:
         self.sample_rate = int(sample_rate)
         self.total_steps = int(total_steps)
         self.max_chunk_length = int(max_chunk_length)
+        self.lang = str(lang or "en")
 
         # Configure GPU providers before importing TTS
         _configure_supertonic_gpu()
@@ -181,7 +193,8 @@ class SupertonicPipeline:
                 "Supertonic is not installed. Install it with `pip install supertonic`."
             ) from exc
 
-        self._tts = TTS(auto_download=auto_download)
+        threads = intra_op_num_threads if intra_op_num_threads is not None else os.cpu_count()
+        self._tts = TTS(auto_download=auto_download, intra_op_num_threads=threads)
 
     def __call__(
         self,
@@ -191,12 +204,14 @@ class SupertonicPipeline:
         speed: float,
         split_pattern: Optional[str] = None,
         total_steps: Optional[int] = None,
+        lang: Optional[str] = None,
     ) -> Iterator[SupertonicSegment]:
         voice_name = (voice or "").strip() or "M1"
         steps = int(total_steps) if total_steps is not None else self.total_steps
         steps = max(2, min(15, steps))
         speed_value = float(speed) if speed is not None else 1.0
         speed_value = max(0.7, min(2.0, speed_value))
+        language = str(lang or self.lang or "en")
 
         style = self._tts.get_voice_style(voice_name=voice_name)
         chunks = _split_text(
@@ -207,12 +222,13 @@ class SupertonicPipeline:
             removed: set[str] = set()
             last_exc: Exception | None = None
 
-            # SuperTonic can raise ValueError for unsupported characters; strip and retry.
+            # Supertonic can raise ValueError for unsupported characters; strip and retry.
             for attempt in range(3):
                 try:
                     wav, duration = self._tts.synthesize(
                         text=chunk_to_speak,
                         voice_style=style,
+                        lang=language,
                         total_steps=steps,
                         speed=speed_value,
                         max_chunk_length=self.max_chunk_length,
@@ -238,14 +254,14 @@ class SupertonicPipeline:
                     chunk_to_speak = sanitized
                     if not chunk_to_speak:
                         logger.warning(
-                            "SuperTonic: dropped a chunk after removing unsupported characters: %s",
+                            "Supertonic: dropped a chunk after removing unsupported characters: %s",
                             sorted(removed),
                         )
                         break
 
                     if attempt == 0:
                         logger.warning(
-                            "SuperTonic: removed unsupported characters %s and retried.",
+                            "Supertonic: removed unsupported characters %s and retried.",
                             sorted(removed),
                         )
             else:

abogen/webui/conversion_runner.py

@@ -59,7 +59,7 @@ def _supertonic_voice_from_spec(spec: Any, fallback: str) -> str:
     raw = str(spec or "").strip()
     fallback_raw = str(fallback or "").strip()
 
-    # SuperTonic voices are discrete IDs (M1/F3/...). If we see a Kokoro mix
+    # Supertonic voices are discrete IDs (M1/F3/...). If we see a Kokoro mix
     # formula (contains '*' or '+'), ignore it and fall back to a safe voice.
     if not raw or "*" in raw or "+" in raw:
         raw = fallback_raw
@@ -1584,7 +1584,7 @@ def run_conversion_job(job: Job) -> None:
                 pipelines[provider_norm] = SupertonicPipeline(
                     sample_rate=SAMPLE_RATE,
                     auto_download=True,
-                    total_steps=int(getattr(job, "supertonic_total_steps", 5) or 5),
+                    total_steps=int(getattr(job, "supertonic_total_steps", 8) or 8),
                 )
                 return pipelines[provider_norm]
 
@@ -1618,7 +1618,7 @@ def run_conversion_job(job: Job) -> None:
                 provider = str(entry.get("provider") or "kokoro").strip().lower() or "kokoro"
                 if provider == "supertonic":
                     voice = str(entry.get("voice") or getattr(job, "voice", "M1") or "M1").strip() or "M1"
-                    steps = int(entry.get("total_steps") or getattr(job, "supertonic_total_steps", 5) or 5)
+                    steps = int(entry.get("total_steps") or getattr(job, "supertonic_total_steps", 8) or 8)
                     speed = float(entry.get("speed") or getattr(job, "speed", 1.0) or 1.0)
                     return "supertonic", _supertonic_voice_from_spec(voice, getattr(job, "voice", "M1")), speed, steps
                 formula = _formula_from_kokoro_entry(entry)
@@ -1634,7 +1634,7 @@ def run_conversion_job(job: Job) -> None:
             """Resolve a raw voice spec into (provider, resolved_spec, choice, speed, steps).
 
             For Kokoro formulas, `choice` will be a resolved voice tensor (via `voice_formulas`).
-            For SuperTonic, `choice` will be a valid SuperTonic voice id.
+            For Supertonic, `choice` will be a valid Supertonic voice id.
             """
 
             provider, resolved, speed, steps = resolve_voice_target(raw_spec)
@@ -1857,7 +1857,7 @@ def run_conversion_job(job: Job) -> None:
                     voice=voice_name,
                     speed=float(speed_override if speed_override is not None else job.speed),
                     split_pattern=split_pattern,
-                    total_steps=int(supertonic_steps_override if supertonic_steps_override is not None else getattr(job, "supertonic_total_steps", 5)),
+                    total_steps=int(supertonic_steps_override if supertonic_steps_override is not None else getattr(job, "supertonic_total_steps", 8)),
                 )
             else:
                 kokoro_pipeline = get_pipeline("kokoro")
@@ -2448,7 +2448,7 @@ def _load_pipeline(job: Job):
         return SupertonicPipeline(
             sample_rate=SAMPLE_RATE,
             auto_download=True,
-            total_steps=int(getattr(job, "supertonic_total_steps", 5) or 5),
+            total_steps=int(getattr(job, "supertonic_total_steps", 8) or 8),
         )
 
     device = "cpu"
@@ -2610,7 +2610,7 @@ def _build_ffmpeg_command(path: Path, fmt: str, metadata: Optional[Dict[str, str
 def _resolve_voice(pipeline, voice_spec: str, use_gpu: bool):
     if "*" in voice_spec:
         # Voice formulas are a Kokoro-only feature (they require a pipeline that can
-        # load individual Kokoro voices). When running with SuperTonic (or when the
+        # load individual Kokoro voices). When running with Supertonic (or when the
         # pipeline is otherwise unavailable), treat the spec as a plain string and
         # allow downstream provider-specific resolution to choose a safe fallback.
         if pipeline is None or not hasattr(pipeline, "load_single_voice"):

abogen/webui/routes/api.py

@@ -162,7 +162,7 @@ def api_voice_profiles_preview() -> ResponseReturnValue:
     formula = str(payload.get("formula") or "").strip()
     profile_name = str(payload.get("profile") or "").strip()
     provider = str(payload.get("tts_provider") or payload.get("provider") or "").strip().lower() or None
-    supertonic_total_steps = int(payload.get("supertonic_total_steps") or payload.get("total_steps") or settings.get("supertonic_total_steps") or 5)
+    supertonic_total_steps = int(payload.get("supertonic_total_steps") or payload.get("total_steps") or settings.get("supertonic_total_steps") or 8)
 
     voice_spec = ""
     resolved_provider = provider or "kokoro"
@@ -224,7 +224,7 @@ def api_speaker_preview() -> ResponseReturnValue:
     speed_value = payload.get("speed")
     speed = coerce_float(speed_value, 1.0)
     tts_provider = str(payload.get("tts_provider") or "").strip().lower()
-    supertonic_total_steps = int(payload.get("supertonic_total_steps") or 5)
+    supertonic_total_steps = int(payload.get("supertonic_total_steps") or 8)
     
     settings = load_settings()
     use_gpu = settings.get("use_gpu", False)
@@ -269,7 +269,7 @@ def api_speaker_preview() -> ResponseReturnValue:
             use_gpu=use_gpu
             ,
             tts_provider=resolved_provider,
-            supertonic_total_steps=supertonic_total_steps or int(settings.get("supertonic_total_steps") or 5),
+            supertonic_total_steps=supertonic_total_steps or int(settings.get("supertonic_total_steps") or 8),
             pronunciation_overrides=pronunciation_overrides,
             manual_overrides=manual_overrides,
             speakers=speakers,

abogen/webui/routes/settings.py

@@ -43,8 +43,12 @@ def update_settings() -> ResponseReturnValue:
     current["language"] = (form.get("language") or "en").strip()
     current["default_speaker"] = (form.get("default_speaker") or "").strip()
     current["default_voice"] = (form.get("default_voice") or "").strip()
+    provider = str(form.get("tts_provider") or "kokoro").strip().lower()
+    if provider in {"kokoro", "supertonic"}:
+        current["tts_provider"] = provider
     try:
-        current["supertonic_total_steps"] = max(2, min(15, int(form.get("supertonic_total_steps", current.get("supertonic_total_steps", 5)))))
+        total_steps = int(form.get("supertonic_total_steps", current.get("supertonic_total_steps", 8)))
+        current["supertonic_total_steps"] = max(2, min(15, total_steps))
     except (TypeError, ValueError):
         pass
     try:

abogen/webui/routes/utils/form.py

@@ -577,7 +577,7 @@ def apply_book_step_form(
     # NOTE: Do not auto-set a global TTS provider at the book level based on the
     # narrator defaults. Provider is resolved per-speaker/per-chunk from the voice
     # spec (e.g. "speaker:Name" for saved speakers, or a Kokoro mix formula).
-    # This enables mixed-provider conversions (e.g. narrator=SuperTonic, characters=Kokoro).
+    # This enables mixed-provider conversions (e.g. narrator=Supertonic, characters=Kokoro).
     provider_value = str(form.get("tts_provider") or "").strip().lower()
     if provider_value in {"kokoro", "supertonic"}:
         pending.tts_provider = provider_value
@@ -913,6 +913,15 @@ def build_pending_job_from_extraction(
         else:
             normalization_overrides[key] = default_val
 
+    provider_value = str(form.get("tts_provider") or "").strip().lower()
+    if provider_value not in {"kokoro", "supertonic"}:
+        provider_value = settings.get("tts_provider", "kokoro")
+    try:
+        total_steps = int(form.get("supertonic_total_steps", settings.get("supertonic_total_steps", 8)))
+        supertonic_steps = max(2, min(15, total_steps))
+    except (TypeError, ValueError):
+        supertonic_steps = int(settings.get("supertonic_total_steps", 8))
+
     pending = PendingJob(
         id=uuid.uuid4().hex,
         original_filename=original_name,
@@ -928,6 +937,8 @@ def build_pending_job_from_extraction(
         replace_single_newlines=replace_single_newlines,
         subtitle_format=subtitle_format,
         total_characters=total_chars,
+        tts_provider=provider_value,
+        supertonic_total_steps=supertonic_steps,
         save_chapters_separately=save_chapters_separately,
         merge_chapters_at_end=merge_chapters_at_end,
         separate_chapters_format=separate_chapters_format,

abogen/webui/routes/utils/preview.py

@@ -92,7 +92,7 @@ def generate_preview_audio(
     speed: float,
     use_gpu: bool,
     tts_provider: str = "kokoro",
-    supertonic_total_steps: int = 5,
+    supertonic_total_steps: int = 8,
     max_seconds: float = 8.0,
     pronunciation_overrides: Optional[Iterable[Mapping[str, Any]]] = None,
     manual_overrides: Optional[Iterable[Mapping[str, Any]]] = None,
@@ -201,7 +201,7 @@ def synthesize_preview(
     speed: float,
     use_gpu: bool,
     tts_provider: str = "kokoro",
-    supertonic_total_steps: int = 5,
+    supertonic_total_steps: int = 8,
     max_seconds: float = 8.0,
     pronunciation_overrides: Optional[Iterable[Mapping[str, Any]]] = None,
     manual_overrides: Optional[Iterable[Mapping[str, Any]]] = None,

abogen/webui/routes/utils/service.py

@@ -25,7 +25,7 @@ def submit_job(pending: PendingJob) -> str:
         tts_provider=getattr(pending, "tts_provider", "kokoro"),
         voice=pending.voice,
         speed=pending.speed,
-        supertonic_total_steps=getattr(pending, "supertonic_total_steps", 5),
+        supertonic_total_steps=getattr(pending, "supertonic_total_steps", 8),
         use_gpu=pending.use_gpu,
         subtitle_mode=pending.subtitle_mode,
         output_format=pending.output_format,

abogen/webui/routes/utils/settings.py

@@ -175,7 +175,8 @@ def settings_defaults() -> Dict[str, Any]:
         "save_mode": "default_output" if has_output_override() else "save_next_to_input",
         "default_speaker": "",
         "default_voice": VOICES_INTERNAL[0] if VOICES_INTERNAL else "",
-        "supertonic_total_steps": 5,
+        "tts_provider": "kokoro",
+        "supertonic_total_steps": 8,
         "supertonic_speed": 1.0,
         "replace_single_newlines": False,
         "use_gpu": True,

abogen/webui/routes/utils/voice.py

@@ -666,7 +666,7 @@ def resolve_voice_choice(
 
         # Provider-aware behavior:
         # - Kokoro profiles typically represent mixes (formula strings).
-        # - SuperTonic profiles represent a discrete voice id + settings.
+        # - Supertonic profiles represent a discrete voice id + settings.
         #   In that case, we return a speaker reference so downstream can
         #   resolve provider per-speaker and allow mixed-provider casting.
         if provider == "supertonic":

abogen/webui/service.py

@@ -111,7 +111,7 @@ class Job:
     subtitle_format: str
     created_at: float
     tts_provider: str = "kokoro"
-    supertonic_total_steps: int = 5
+    supertonic_total_steps: int = 8
     save_chapters_separately: bool = False
     merge_chapters_at_end: bool = True
     separate_chapters_format: str = "wav"
@@ -204,7 +204,7 @@ class Job:
             "queue_position": self.queue_position,
             "options": {
                 "tts_provider": getattr(self, "tts_provider", "kokoro"),
-                "supertonic_total_steps": getattr(self, "supertonic_total_steps", 5),
+                "supertonic_total_steps": getattr(self, "supertonic_total_steps", 8),
                 "save_chapters_separately": self.save_chapters_separately,
                 "merge_chapters_at_end": self.merge_chapters_at_end,
                 "separate_chapters_format": self.separate_chapters_format,
@@ -552,7 +552,7 @@ class PendingJob:
     normalization_overrides: Dict[str, Any]
     created_at: float
     tts_provider: str = "kokoro"
-    supertonic_total_steps: int = 5
+    supertonic_total_steps: int = 8
     cover_image_path: Optional[Path] = None
     cover_image_mime: Optional[str] = None
     chapter_intro_delay: float = 0.5
@@ -621,7 +621,7 @@ class ConversionService:
         voice: str,
         speed: float,
         tts_provider: str = "kokoro",
-        supertonic_total_steps: int = 5,
+        supertonic_total_steps: int = 8,
         use_gpu: bool,
         subtitle_mode: str,
         output_format: str,
@@ -674,7 +674,7 @@ class ConversionService:
             voice=voice,
             speed=speed,
             tts_provider=tts_provider,
-            supertonic_total_steps=int(supertonic_total_steps or 5),
+            supertonic_total_steps=int(supertonic_total_steps or 8),
             use_gpu=use_gpu,
             subtitle_mode=subtitle_mode,
             output_format=output_format,
@@ -1147,7 +1147,7 @@ class ConversionService:
             "tts_provider": getattr(job, "tts_provider", "kokoro"),
             "voice": job.voice,
             "speed": job.speed,
-            "supertonic_total_steps": getattr(job, "supertonic_total_steps", 5),
+            "supertonic_total_steps": getattr(job, "supertonic_total_steps", 8),
             "use_gpu": job.use_gpu,
             "subtitle_mode": job.subtitle_mode,
             "output_format": job.output_format,
@@ -1275,7 +1275,7 @@ class ConversionService:
             replace_single_newlines=bool(payload.get("replace_single_newlines", False)),
             subtitle_format=payload.get("subtitle_format", "srt"),
             created_at=float(payload.get("created_at", time.time())),
-            supertonic_total_steps=int(payload.get("supertonic_total_steps", 5)),
+            supertonic_total_steps=int(payload.get("supertonic_total_steps", 8)),
             save_chapters_separately=bool(payload.get("save_chapters_separately", False)),
             merge_chapters_at_end=bool(payload.get("merge_chapters_at_end", True)),
             separate_chapters_format=payload.get("separate_chapters_format", "wav"),

abogen/webui/templates/partials/new_job_step_book.html

@@ -26,6 +26,26 @@
     {% set subtitle_value = settings_dict.get('subtitle_mode', 'Disabled') %}
   {% endif %}
 {% endif %}
+{% set tts_provider_value = form_values.get('tts_provider') if form_values else None %}
+{% if not tts_provider_value %}
+  {% if pending and pending.tts_provider %}
+    {% set tts_provider_value = pending.tts_provider %}
+  {% else %}
+    {% set tts_provider_value = settings_dict.get('tts_provider', 'kokoro') %}
+  {% endif %}
+{% endif %}
+{% set supertonic_steps_value = form_values.get('supertonic_total_steps') if form_values else None %}
+{% if supertonic_steps_value is none %}
+  {% if pending and pending.supertonic_total_steps is not none %}
+    {% set supertonic_steps_value = pending.supertonic_total_steps %}
+  {% else %}
+    {% set supertonic_steps_value = settings_dict.get('supertonic_total_steps', 8) %}
+  {% endif %}
+{% endif %}
+{% if supertonic_steps_value is not none and supertonic_steps_value is string %}
+  {% set supertonic_steps_value = supertonic_steps_value|int %}
+{% endif %}
+{% set is_supertonic = tts_provider_value == 'supertonic' %}
 {% set generate_flag = form_values.get('generate_epub3') if form_values else None %}
 {% if generate_flag is not none %}
   {% set generate_epub3 = True %}
@@ -273,6 +293,13 @@
       <div class="form-section__layout form-section__layout--split">
         <div class="form-section__group">
           <div class="field">
+            <label for="tts_provider">TTS Engine</label>
+            <select id="tts_provider" name="tts_provider" data-role="tts-provider" {{ 'disabled' if readonly else '' }}>
+              <option value="kokoro" {% if tts_provider_value == 'kokoro' %}selected{% endif %}>Kokoro</option>
+              <option value="supertonic" {% if tts_provider_value == 'supertonic' %}selected{% endif %}>Supertonic</option>
+            </select>
+          </div>
+          <div class="field" data-role="voice-profile-field">
             <label for="voice_profile">Voice profile</label>
             <select id="voice_profile" name="voice_profile" data-role="voice-profile" {{ 'disabled' if readonly else '' }}>
               <option value="__standard" {% if profile_value == '__standard' %}selected{% endif %}>Standard voice</option>
@@ -280,13 +307,13 @@
               {% if options.voice_profile_options %}
               <optgroup label="Saved mixes">
                 {% for profile in options.voice_profile_options %}
-                <option value="{{ profile.name }}" data-language="{{ profile.language }}" data-formula="{{ profile.formula|e }}" {% if profile_value == profile.name %}selected{% endif %}>{{ profile.name }}{% if profile.language %} ({{ profile.language|upper }}){% endif %}</option>
+                <option value="{{ profile.name }}" data-language="{{ profile.language }}" data-formula="{{ profile.formula|e }}" data-provider="{{ profile.provider|default('kokoro')|lower }}" {% if profile_value == profile.name %}selected{% endif %}>{{ profile.name }}{% if profile.language %} ({{ profile.language|upper }}){% endif %}{% if profile.provider and profile.provider|lower != 'kokoro' %} · {{ profile.provider|capitalize }}{% endif %}</option>
                 {% endfor %}
               </optgroup>
               {% endif %}
             </select>
           </div>
-          <div class="field" data-role="voice-field" {% if profile_value != '__standard' %}hidden aria-hidden="true"{% endif %}>
+          <div class="field" data-role="voice-field" data-provider="kokoro" {% if profile_value != '__standard' or is_supertonic %}hidden aria-hidden="true"{% endif %}>
             <label for="voice">Voice</label>
             <select id="voice" name="voice" data-role="voice-select" data-default="{{ narrator_voice or settings_dict.get('default_voice', '') }}" {{ 'disabled' if readonly else '' }}>
               {% for voice in options.voices %}
@@ -294,10 +321,23 @@
               {% endfor %}
             </select>
           </div>
-          <div class="field" data-conditional="formula" data-role="formula-field" {% if profile_value != '__formula' %}hidden aria-hidden="true"{% endif %}>
+          <div class="field" data-role="voice-field" data-provider="supertonic" {% if profile_value != '__standard' or not is_supertonic %}hidden aria-hidden="true"{% endif %}>
+            <label for="voice_st">Supertonic voice</label>
+            <select id="voice_st" name="voice" data-role="voice-select" data-default="{{ narrator_voice or 'M1' }}" {{ 'disabled' if readonly else '' }}>
+              {% for voice in ['M1','M2','M3','M4','M5','F1','F2','F3','F4','F5'] %}
+              <option value="{{ voice }}" {% if narrator_voice == voice and profile_value == '__standard' %}selected{% endif %}>{{ voice }}</option>
+              {% endfor %}
+            </select>
+          </div>
+          <div class="field" data-conditional="formula" data-role="formula-field" data-provider="kokoro" {% if profile_value != '__formula' or is_supertonic %}hidden aria-hidden="true"{% endif %}>
             <label for="voice_formula">Custom voice formula</label>
             <input type="text" id="voice_formula" name="voice_formula" placeholder="af_nova*0.4+am_liam*0.6" data-role="voice-formula" value="{{ voice_formula_value }}" {{ 'disabled' if readonly else '' }}>
           </div>
+          <div class="field" data-role="supertonic-steps-field" {% if not is_supertonic %}hidden aria-hidden="true"{% endif %}>
+            <label for="supertonic_total_steps">Supertonic quality (total steps)</label>
+            <input type="number" id="supertonic_total_steps" name="supertonic_total_steps" min="2" max="15" value="{{ supertonic_steps_value }}" {{ 'disabled' if readonly else '' }}>
+            <p class="hint">2 = fastest/lowest quality, 15 = slowest/highest quality.</p>
+          </div>
         </div>
         <div class="form-section__group">
           <div class="field field--slider">
@@ -423,3 +463,54 @@
     </div>
   </footer>
 </form>
+
+<script nonce="{{ csp_nonce() if csp_nonce else '' }}">
+(function() {
+  const form = document.querySelector('[data-wizard-form="true"][data-step="book"]');
+  if (!form) return;
+  const providerSelect = form.querySelector('[data-role="tts-provider"]');
+  if (!providerSelect) return;
+
+  function filterProfilesByProvider(provider) {
+    const profileSelect = form.querySelector('[data-role="voice-profile"]');
+    if (!profileSelect) return;
+    const options = profileSelect.querySelectorAll('option[data-provider]');
+    options.forEach(function(opt) {
+      const matches = !opt.dataset.provider || opt.dataset.provider === provider;
+      opt.hidden = !matches;
+      if (opt.selected && opt.hidden) {
+        opt.selected = false;
+      }
+    });
+    if (!profileSelect.value || profileSelect.selectedOptions[0]?.hidden) {
+      const firstVisible = profileSelect.querySelector('option:not([hidden])');
+      if (firstVisible) profileSelect.value = firstVisible.value;
+    }
+    profileSelect.dispatchEvent(new Event('change', { bubbles: true }));
+  }
+
+  function syncProviderUI(provider) {
+    var isSupertonic = provider === 'supertonic';
+    form.querySelectorAll('[data-role="voice-field"]').forEach(function(el) {
+      el.hidden = el.dataset.provider !== provider;
+      el.setAttribute('aria-hidden', el.hidden ? 'true' : 'false');
+    });
+    var formulaField = form.querySelector('[data-role="formula-field"]');
+    if (formulaField) {
+      formulaField.hidden = isSupertonic;
+      formulaField.setAttribute('aria-hidden', isSupertonic ? 'true' : 'false');
+    }
+    var stepsField = form.querySelector('[data-role="supertonic-steps-field"]');
+    if (stepsField) {
+      stepsField.hidden = !isSupertonic;
+      stepsField.setAttribute('aria-hidden', isSupertonic ? 'false' : 'true');
+    }
+    filterProfilesByProvider(provider);
+  }
+
+  providerSelect.addEventListener('change', function() {
+    syncProviderUI(providerSelect.value);
+  });
+  syncProviderUI(providerSelect.value);
+})();
+</script>

abogen/webui/templates/settings.html

@@ -61,6 +61,15 @@
               <p class="hint">Pick a saved speaker from Speaker Studio to use by default for new jobs.</p>
             </div>
 
+            <div class="field">
+              <label for="tts_provider">Default TTS Engine</label>
+              <select id="tts_provider" name="tts_provider">
+                <option value="kokoro" {% if settings.tts_provider == 'kokoro' %}selected{% endif %}>Kokoro</option>
+                <option value="supertonic" {% if settings.tts_provider == 'supertonic' %}selected{% endif %}>Supertonic</option>
+              </select>
+              <p class="hint">Select the default TTS engine for new jobs.</p>
+            </div>
+
             <div class="field field--wide">
               <p class="tag">Kokoro settings</p>
             </div>

pyproject.toml

@@ -30,7 +30,7 @@ dependencies = [
   "pip",
   "kokoro>=0.9.4",
   "misaki[zh]>=0.9.4",
-  "supertonic>=0.1.0",
+  "supertonic>=1.3.1",
   "ebooklib>=0.19",
   "beautifulsoup4>=4.13.4",
   "spacy>=3.8.7,<4.0",
@@ -111,11 +111,11 @@ filterwarnings = [
 
 [project.optional-dependencies]
 # NVIDIA GPU (Windows) (CUDA 12.6)       # uv tool install abogen[cuda126]
-cuda126 = ["torch"]
+cuda126 = ["torch", "onnxruntime-gpu>=1.26.0"]
 # NVIDIA GPU (Windows) (CUDA 12.8)       # uv tool install abogen[cuda]
-cuda = ["torch"]
+cuda = ["torch", "onnxruntime-gpu>=1.26.0"]
 # NVIDIA GPU (Windows) (CUDA 13.0)       # uv tool install abogen[cuda130]
-cuda130 = ["torch"]
+cuda130 = ["torch", "onnxruntime-gpu>=1.26.0"]
 # AMD GPU (Linux) (ROCm 6.4)             # uv tool install abogen[rocm]
 rocm = ["torch", "pytorch-triton-rocm"]
 # Development dependencies               # uv tool install abogen[dev]

tests/test_voice_formula_resolution.py

@@ -6,13 +6,13 @@ from abogen.tts_supertonic import DEFAULT_SUPERTONIC_VOICES
 
 def test_resolve_voice_formula_without_pipeline_does_not_crash() -> None:
     # This can happen when a previously-saved Kokoro mix formula is present
-    # but the active provider is SuperTonic (no Kokoro pipeline object).
+    # but the active provider is Supertonic (no Kokoro pipeline object).
     formula = "af_heart*0.5+af_sky*0.5"
     resolved = _resolve_voice(None, formula, use_gpu=False)
     assert resolved == formula
 
 
 def test_supertonic_voice_from_formula_falls_back_to_valid_voice() -> None:
-    # When a stale Kokoro mix formula is present, SuperTonic should not receive it.
+    # When a stale Kokoro mix formula is present, Supertonic should not receive it.
     chosen = _supertonic_voice_from_spec("af_heart*0.5+af_sky*0.5", "af_heart*1.0")
     assert chosen in DEFAULT_SUPERTONIC_VOICES