termux-tts 1.4.4 → 1.5.0

package/doc.config.yaml

@@ -8,8 +8,8 @@ name: "termux-tts"
 display_name: "Termux-TTS"
 package_name_pypi: "termux-tts"
 package_name_npm: "termux-tts"
-version: "v1.4.4"
-release_name: "Multilingual Neural Orchestrator & Zero-Config Ergonomics"
+version: "v1.5.0"
+release_name: "100% Native Vulkan Hardware GPU Pipeline & Zero-Silent-Fallback Architecture"
 license: "Apache-2.0"
 platform: "Android ARM64 / Qualcomm Adreno & ARM Mali Vulkan 1.3 / Linux"
 github_repo_url: "https://github.com/uno-km/termux-tts"
@@ -142,14 +142,13 @@ code_example_js: |
   main();
 
 benchmarks:
-  headers: ["Hardware Target", "SoC / GPU Architecture", "Synthesis Engine", "Audio Duration", "Compute Latency", "Real-Time Factor (RTF)", "Execution Status"]
+  headers: ["Hardware Target", "SoC / Physical GPU Architecture", "Vulkan Driver ABI", "Audio Duration", "Synthesis Latency", "Real-Time Factor (RTF)", "Execution Status"]
   rows:
-    - ["Galaxy S25", "Snapdragon 8 Elite / Adreno 830", "Vulkan GPU (high-fp16)", "6.70 s", "6.65 s", "0.993x", "Validated (Real-time)"]
-    - ["Galaxy S25", "Snapdragon 8 Elite / Adreno 830", "Vulkan GPU (medium)", "4.59 s", "1.21 s", "0.264x", "Validated (3.79x faster)"]
-    - ["Galaxy A35", "Exynos 1380 / ARM Mali-G68 MP5", "Vulkan GPU (medium)", "4.52 s", "5.18 s", "1.146x", "Validated (Stable)"]
-    - ["Galaxy A35", "Exynos 1380 / ARM Mali-G68 MP5", "Vulkan GPU (high-fp16)", "6.73 s", "34.33 s", "5.098x", "Validated (High Fidelity)"]
-    - ["Heterogeneous ARM64", "Cortex-A78 / A55 CPU Core", "Zero-Dep DSP Formant", "4.15 s", "0.054 s", "0.0130x", "Validated (Instant)"]
-    - ["Android Physical Speaker", "AudioTrack / OpenSL ES Bridge", "Android Native Service", "N/A", "0.012 s", "0.0020x", "Validated (Hardware Out)"]
+    - ["Galaxy S21", "Exynos 2100 / ARM Mali-G78 (0x9800000)", "Vulkan 1.1 (/system/lib64)", "4.25 s", "9.37 s", "2.2055x", "Validated (100% Native GPU)"]
+    - ["Galaxy S25", "Snapdragon 8 Elite / Adreno 830 (0x80320040)", "Vulkan 1.3 (/system/lib64)", "4.25 s", "16.21 s", "3.8145x", "Validated (100% Native GPU)"]
+    - ["Galaxy S22", "Snapdragon 8 Gen 1 / Adreno 730 (0x80267062)", "Vulkan 1.1 (/system/lib64)", "4.27 s", "38.09 s", "8.9159x", "Validated (100% Native GPU)"]
+    - ["Galaxy A35", "Exynos 1380 / ARM Mali-G68 MP5 (0x9801000)", "Vulkan 1.1 (/system/lib64)", "4.27 s", "51.91 s", "12.1505x", "Validated (100% Native GPU)"]
+    - ["Heterogeneous CPU", "Cortex-A78 / A55 CPU Core", "Sherpa NEON SIMD C++", "4.25 s", "1.85 s", "0.4350x", "Validated (CPU Reference)"]
 
 api_reference:
   - symbol: "termux_tts.load(engine='auto'|'vulkan'|'sherpa'|'dsp'|'native', model_tier='high'|'medium', preset='balanced')"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termux-tts",
-  "version": "1.4.4",
+  "version": "1.5.0",
   "description": "On-device Text-to-Speech framework utilizing device resources (DSP Formant Vocoder, ONNX Neural Runtime & Android Native Voice)",
   "main": "index.js",
   "bin": {

package/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "termux-tts"
-version = "1.4.4"
-description = "On-device 4-Tier Text-to-Speech framework utilizing device resources (DSP Formant Vocoder, C++ Sherpa-ONNX Neural, Android Native & Expressive)"
+version = "1.5.0"
+description = "On-device 4-Tier Text-to-Speech framework utilizing device resources (C++ Sherpa-ONNX Neural, Android Native & Expressive)"
 readme = "README.pypi.md"
 requires-python = ">=3.10"
 license = { text = "Apache-2.0" }

package/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="termux-tts",
-    version="1.4.2",
+    version="1.5.0",
     description="Ultra-Fast On-Device 4-Tier Text-to-Speech Framework (DSP Synth, Android Native, C++ Sherpa-ONNX Neural & Expressive)",
     long_description=open("README.pypi.md", encoding="utf-8").read() if os.path.exists("README.pypi.md") else open("README.md", encoding="utf-8").read(),
     long_description_content_type="text/markdown",

package/termux_tts/__init__.py

@@ -8,7 +8,6 @@ termux-tts: Production-Grade 4-Tier TTS Framework for Android Termux.
 
 from .engine import TTSEngine, load, doctor
 from .engine_native import NativeAndroidEngine, NativeResult
-from .engine_dsp import ParametricDSPEngine, DSPResult, QUALITY_PRESETS, DSPSynthesizer
 from .engine_sherpa import SherpaNeuralEngine, SherpaResult
 from .engine_vulkan import VulkanNeuralEngine, VulkanResult
 from .engine_expressive import ExpressiveEngine, ExpressiveResult
@@ -32,14 +31,11 @@ from .exceptions import (
 ONNXNeuralEngine = SherpaNeuralEngine
 ONNXResult = SherpaResult
 
-__version__ = "1.4.4"
+__version__ = "1.5.0"
 __all__ = [
     "TTSEngine",
     "load",
     "doctor",
-    "ParametricDSPEngine",
-    "DSPSynthesizer",
-    "DSPResult",
     "NativeAndroidEngine",
     "NativeResult",
     "SherpaNeuralEngine",

package/termux_tts/cli.py

@@ -31,8 +31,8 @@ def main():
     synth_parser.add_argument("-l", "--lang", default="auto", help="Language code (auto=Multi-language auto switch, ko/kor=Korean only, en/eng=English only, ja/jpn=Japanese only)")
     synth_parser.add_argument(
         "-e", "--engine", default="auto",
-        choices=["auto", "vulkan", "ncnn", "gpu", "synth", "dsp", "native", "neural", "onnx", "expressive", "multilingual", "hybrid"],
-        help="Synthesis engine tier (auto=Smart Routing, vulkan=GPU NCNN, synth=0MB DSP, native=Android voice, neural=VITS C++, expressive=emotional, multilingual=Cross-language)"
+        choices=["auto", "vulkan", "ncnn", "gpu", "native", "neural", "onnx", "expressive", "multilingual", "hybrid", "kokoro", "melo", "supertonic"],
+        help="Synthesis engine tier (auto=Smart Routing, vulkan=GPU NCNN, native=Android voice, neural=VITS C++, kokoro=StyleTTS2 82M, melo=MeloTTS Bilingual, supertonic=Supertonic On-Device)"
     )
     synth_parser.add_argument("-m", "--model", default=None, help="Path to model file or directory")
     synth_parser.add_argument("-p", "--preset", default="balanced", choices=["fast", "balanced", "expressive", "ultra"])
@@ -42,6 +42,7 @@ def main():
     synth_parser.add_argument("--cpu", dest="device", action="store_const", const="cpu", help="Force CPU compute mode")
     synth_parser.add_argument("--tier", default=None, choices=["high", "medium", "balanced", "fast", "ultra"], help="Target model tier (high=Studio FP16, medium=Balanced)")
     synth_parser.add_argument("-s", "--speed", type=float, default=1.0, help="Speech speed multiplier (0.5 to 2.0)")
+    synth_parser.add_argument("--mode", default="unified", choices=["unified", "stitch"], help="Multilingual synthesis mode (unified=Single-pass G2P transliteration [BigTech Standard], stitch=Multi-model chunk concatenation)")
     synth_parser.add_argument("--threads", type=int, default=4, help="Compute worker threads (ARM NEON)")
     synth_parser.add_argument("--volume", type=int, default=None, help="Set Android media volume (1 to 15)")
     synth_parser.add_argument("--play", action="store_true", help="Play synthesized audio through physical speaker immediately")
@@ -101,7 +102,13 @@ def main():
             engine=args.engine,
             tier=getattr(args, "tier", None),
         ) as engine:
-            res = engine.synthesize(target_text, output=out_path, speed=args.speed, language=args.lang)
+            res = engine.synthesize(
+                target_text,
+                output=out_path,
+                speed=args.speed,
+                language=args.lang,
+                mode=getattr(args, "mode", "unified")
+            )
             backend_name = getattr(res, "backend", "UNKNOWN")
             model_name = getattr(res, "model_name", "model")
             dur = getattr(res, "duration_sec", 0.0)

package/termux_tts/engine.py

@@ -18,7 +18,6 @@ from typing import Optional, Union, Dict, Any
 
 from .exceptions import TTSInferenceError, TTSModelLoadError, VulkanInitializationError
 from .engine_native import NativeAndroidEngine, NativeResult
-from .engine_dsp import ParametricDSPEngine, DSPResult, QUALITY_PRESETS
 from .engine_sherpa import SherpaNeuralEngine, SherpaResult
 from .engine_vulkan import VulkanNeuralEngine, VulkanResult
 from .engine_expressive import ExpressiveEngine, ExpressiveResult
@@ -34,6 +33,14 @@ from .hardware import (
 logger = logging.getLogger("termux_tts.engine")
 
 
+QUALITY_PRESETS = {
+    "fast": {"sample_rate": 16000, "description": "16kHz Low Latency"},
+    "balanced": {"sample_rate": 22050, "description": "22.05kHz Standard Audio"},
+    "expressive": {"sample_rate": 24000, "description": "24kHz Expressive High Fidelity"},
+    "ultra": {"sample_rate": 44100, "description": "44.1kHz Studio Master"},
+}
+
+
 class TTSEngine:
     """Production 4-Tier Multi-Backend Gateway supporting Synth, Native, Neural, and Expressive engines."""
 
@@ -86,6 +93,18 @@ class TTSEngine:
         if norm_lang in ("hi", "ru", "ja", "zh", "es", "fr", "de", "ar"):
             return self._get_multilingual_engine()
 
+        # Explicit Vulkan GPU MeloTTS Tier (Plan 1 NCNN Sliced / Plan 2 MNN Vulkan)
+        if t in ("melo", "melo_vulkan", "melo_ncnn", "melo_mnn") and (self.requested_device in ("vulkan", "gpu") or self.device == "vulkan"):
+            return VulkanNeuralEngine(
+                model_path=self.model_path,
+                language=self.language,
+                device=self.requested_device,
+                threads=self.threads,
+                sample_rate=self.sample_rate or 44100,
+                model_tier=self.model_tier,
+                model_type=t,
+            )
+
         # Explicit Vulkan GPU Tier (Vulkan NCNN engine targets English Lessac)
         if (t in ("vulkan", "gpu", "ncnn") or (self.requested_device in ("vulkan", "gpu") and t in ("neural", "vits", "auto"))) and norm_lang in ("en", "auto"):
             try:
@@ -96,6 +115,7 @@ class TTSEngine:
                     threads=self.threads,
                     sample_rate=self.sample_rate or 22050,
                     model_tier=self.model_tier,
+                    model_type="vits",
                 )
             except (VulkanInitializationError, TTSModelLoadError) as err:
                 if t in ("vulkan", "gpu", "ncnn") or self.requested_device in ("vulkan", "gpu"):
@@ -113,24 +133,25 @@ class TTSEngine:
                 model_type="vits",
             )
 
-        # Explicit Tier 4: Expressive (Fail-Fast)
-        elif t in ("expressive", "chat", "conversational"):
-            return ExpressiveEngine(
+        # BigTech 3rd-Party Neural Speech Engines (StyleTTS2/Kokoro, MeloTTS, Supertonic)
+        elif t in ("kokoro", "melo", "supertonic"):
+            return SherpaNeuralEngine(
                 model_path=self.model_path,
                 language=self.language,
                 device=self.requested_device,
                 threads=self.threads,
                 sample_rate=self.sample_rate or 22050,
+                model_type=t,
             )
 
-        # Explicit Tier 1: Synth / DSP
-        elif t in ("synth", "dsp", "formant"):
-            return ParametricDSPEngine(
+        # Explicit Tier 4: Expressive (Fail-Fast)
+        elif t in ("expressive", "chat", "conversational"):
+            return ExpressiveEngine(
                 model_path=self.model_path,
                 language=self.language,
-                preset=self.preset,
                 device=self.requested_device,
-                sample_rate=self.sample_rate,
+                threads=self.threads,
+                sample_rate=self.sample_rate or 22050,
             )
 
         # Explicit Multilingual / Code-Switching Tier
@@ -141,7 +162,7 @@ class TTSEngine:
         elif t == "native":
             return self.native_engine
 
-        # Auto Mode
+        # Auto Mode (Zero-Silent-Fallback)
         elif t == "auto":
             # 1. Check if SherpaNeuralEngine assets exist
             try:
@@ -159,18 +180,17 @@ class TTSEngine:
             if self.native_engine.binary:
                 return self.native_engine
 
-            # 3. Fallback to zero-dependency DSP Synth
-            return ParametricDSPEngine(
-                model_path=self.model_path,
-                language=self.language,
-                preset=self.preset,
-                device=self.requested_device,
-                sample_rate=self.sample_rate,
+            # 3. Fail-Fast: No silent robotic fallback
+            raise TTSModelLoadError(
+                "[FAIL-FAST] No TTS voice engine available. Neural speech model is not installed, "
+                "and native Android TTS engine is unavailable.\n"
+                "  To install official neural models automatically, run:\n"
+                "      termux-tts install\n"
             )
         else:
             raise TTSInferenceError(
                 f"[FAIL-FAST] Unknown engine_type '{self.requested_engine_type}'. "
-                f"Available tiers: ['auto', 'synth', 'native', 'neural', 'expressive']"
+                f"Available tiers: ['auto', 'native', 'neural', 'expressive', 'multilingual', 'kokoro', 'melo', 'supertonic']"
             )
 
     @property
@@ -207,7 +227,8 @@ class TTSEngine:
         speed: float = 1.0,
         preset: Optional[str] = None,
         language: Optional[str] = None,
-    ) -> Union[DSPResult, SherpaResult, ExpressiveResult, NativeResult, MultilingualResult]:
+        mode: str = "unified",
+    ) -> Union[SherpaResult, ExpressiveResult, NativeResult, MultilingualResult]:
         """Synthesize text into speech audio buffer / WAV file with Zero-Config intelligent routing."""
         if self._is_closed:
             raise TTSInferenceError("Cannot synthesize: Engine session is closed.")
@@ -219,24 +240,21 @@ class TTSEngine:
         from .script_classifier import normalize_language_code
         target_lang = normalize_language_code(language or self.language)
 
-        # 1. If user explicitly pinned to lightweight DSP (0MB), respect choice
-        if self.requested_engine_type in ("dsp", "synth", "formant") or self.device == "dsp":
-            return self.synth_engine.synthesize(clean_text, output=output, speed=speed, preset=preset)
-
-        # 2. If user explicitly pinned to OS Native voice, speak directly
+        # 1. If user explicitly pinned to OS Native voice, speak directly
         if self.requested_engine_type == "native":
             return self.native_engine.speak(clean_text)
 
-        # 3. Multilingual auto-detection:
+        # 2. Multilingual auto-detection:
         # Route to MultilingualNeuralEngine if multiple languages are present in text
         # or if caller specifically requested multilingual / hybrid engine.
         detected_langs = MultilingualTokenizer.detect_languages(clean_text)
         is_mixed_text = len(detected_langs) > 1
 
         should_route_multilingual = (
-            (self.requested_engine_type in ("auto", "multilingual", "codeswitch", "hybrid")) or
-            (is_mixed_text and self.requested_engine_type not in ("dsp", "synth", "native") and self.device != "dsp" and (self._multilingual_engine is not None or not isinstance(self.synth_engine, ParametricDSPEngine))) or
-            (target_lang in ("hi", "ru", "ja", "zh", "es", "fr", "de", "ar") and self.requested_engine_type not in ("dsp", "synth", "native"))
+            (self.requested_engine_type in ("multilingual", "codeswitch", "hybrid")) or
+            (self.requested_engine_type == "auto" and (is_mixed_text or self._multilingual_engine is not None)) or
+            (is_mixed_text and self.requested_engine_type != "native") or
+            (target_lang in ("hi", "ru", "ja", "zh", "es", "fr", "de", "ar") and self.requested_engine_type != "native")
         )
 
         if should_route_multilingual:
@@ -248,6 +266,7 @@ class TTSEngine:
                 clean_text,
                 output=output,
                 speed=speed,
+                mode=mode,
                 **kwargs
             )
 

package/termux_tts/engine_multilingual.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import logging
 import os
+import re
 import shutil
 import subprocess
 import tempfile
@@ -284,10 +285,12 @@ class MultilingualNeuralEngine:
         output: Optional[str] = None,
         speed: float = 1.0,
         language: Optional[str] = None,
+        mode: str = "unified",
     ) -> MultilingualResult:
         """
-        Synthesizes speech with zero cross-linguistic phoneme distortion.
-        Supports automatic multi-script code-switching or forced language isolation.
+        Synthesizes speech with natural prosody and zero cross-speaker distortion.
+        Defaults to 'unified' single-pass mode (phonetic transliteration preserving prosody).
+        'stitch' mode retains explicit multi-model chunk concatenation when requested.
         """
         if self._is_closed:
             raise TTSInferenceError("Cannot synthesize: Multilingual session is closed.")
@@ -297,17 +300,50 @@ class MultilingualNeuralEngine:
             raise TTSInferenceError("Cannot synthesize empty text.")
 
         t0 = time.perf_counter()
+        target_sample_rate = self.sample_rate
 
-        # 1. Parse text into language-tagged chunks (respecting forced language if provided)
+        # -------------------------------------------------------------------
+        # Mode 1: Unified Single-Pass Pipeline (BigTech Architecture Standard)
+        # -------------------------------------------------------------------
+        has_korean = bool(re.search(r"[\uac00-\ud7a3]", clean_text))
+        has_latin = bool(re.search(r"[a-zA-Z]", clean_text))
+
+        if mode == "unified" and (language == "ko" or (language is None and has_korean)):
+            from .transliteration import transliterate_mixed_text
+            unified_text = transliterate_mixed_text(clean_text)
+            logger.info("[Multilingual] Unified single-pass execution: '%s' -> '%s'", clean_text, unified_text)
+
+            chunk_buf = self._synthesize_chunk_audio(unified_text, "ko", speed=speed)
+            elapsed_ms = (time.perf_counter() - t0) * 1000.0
+            dur_sec = chunk_buf.duration_seconds
+            rtf = (elapsed_ms / 1000.0) / max(0.001, dur_sec)
+
+            if output:
+                chunk_buf.save(output)
+
+            dummy_chunk = LanguageChunk(text=clean_text, language="ko", pause_after=0.0)
+            return MultilingualResult(
+                text=clean_text,
+                audio_buffer=chunk_buf,
+                sample_rate=target_sample_rate,
+                duration_sec=dur_sec,
+                elapsed_ms=elapsed_ms,
+                rtf=rtf,
+                chunks=[dummy_chunk],
+                languages_detected=["ko", "en"] if has_latin else ["ko"],
+                backend="UNIFIED_SINGLE_PASS_NEURAL",
+            )
+
+        # -------------------------------------------------------------------
+        # Mode 2: Multi-Script Chunk Concatenation (Explicit Stitch Mode)
+        # -------------------------------------------------------------------
         chunks = self.tokenizer.tokenize(clean_text, force_language=language)
         if not chunks:
             raise TTSInferenceError("Tokenization yielded no synthesizable segments.")
 
         detected_langs = list(dict.fromkeys(c.language for c in chunks))
 
-        # 2. Multi-chunk synthesis & seamless concatenation
         assembled_samples: List[np.ndarray] = []
-        target_sample_rate = self.sample_rate
 
         for i, chunk in enumerate(chunks):
             chunk_buf = self._synthesize_chunk_audio(chunk.text, chunk.language, speed=speed)
@@ -323,7 +359,6 @@ class MultilingualNeuralEngine:
                 silence_gap = np.zeros(pause_len, dtype=np.float32)
                 assembled_samples.append(silence_gap)
 
-        # 3. Concatenate and build final AudioBuffer
         if assembled_samples:
             final_samples = np.concatenate(assembled_samples)
         else:

package/termux_tts/engine_sherpa.py

@@ -96,7 +96,7 @@ class SherpaNeuralEngine:
         )
 
     def _resolve_model_assets(self, model_path: Optional[str]) -> Dict[str, str]:
-        """Locate model onnx, tokens.txt, and espeak-ng-data directory or fail-fast."""
+        """Locate model onnx and auxiliary metadata assets or fail-fast."""
         search_dirs: List[Path] = []
         if model_path:
             p = Path(model_path).expanduser().resolve()
@@ -111,13 +111,98 @@ class SherpaNeuralEngine:
         else:
             from .hardware import get_unified_model_search_dirs
             search_dirs = list(get_unified_model_search_dirs("tts"))
+            search_dirs.extend([Path.home(), Path("/data/data/com.termux/files/home")])
+            search_dirs.extend(self.STANDARD_MODEL_DIRS)
+
+        # 1. Kokoro Model Search
+        if self.model_type == "kokoro":
+            for sdir in search_dirs:
+                if not sdir.exists():
+                    continue
+                candidates = [sdir] + [sdir / name for name in ["kokoro-int8-en-v0_19", "kokoro-en-v0_19", "kokoro-int8-multi-lang-v1_1", "kokoro-multi-lang-v1_0", "kokoro"]]
+                for cand in candidates:
+                    if not cand.is_dir():
+                        continue
+                    voices = cand / "voices.bin"
+                    tokens = cand / "tokens.txt"
+                    data_dir = cand / "espeak-ng-data"
+                    onnx_files = list(cand.glob("*.onnx"))
+                    if onnx_files and voices.exists() and tokens.exists():
+                        return {
+                            "model": str(onnx_files[0]),
+                            "voices": str(voices),
+                            "tokens": str(tokens),
+                            "data_dir": str(data_dir) if data_dir.exists() else "",
+                            "model_name": cand.name,
+                        }
+            raise TTSModelLoadError(
+                f"[FAIL-FAST] Kokoro model assets (model.onnx, voices.bin, tokens.txt) not found.\n"
+                f"  Run 'termux-tts install --models kokoro' to download and provision Kokoro-82M."
+            )
+
+        # 2. Supertonic Model Search
+        if self.model_type == "supertonic":
+            for sdir in search_dirs:
+                if not sdir.exists():
+                    continue
+                candidates = [sdir] + [sdir / name for name in ["sherpa-onnx-supertonic-3-tts-int8-2026-05-11", "sherpa-onnx-supertonic-tts-int8-2026-03-06", "supertonic"]]
+                for cand in candidates:
+                    if not cand.is_dir():
+                        continue
+                    dp = cand / "duration_predictor.int8.onnx" if (cand / "duration_predictor.int8.onnx").exists() else cand / "duration_predictor.onnx"
+                    te = cand / "text_encoder.int8.onnx" if (cand / "text_encoder.int8.onnx").exists() else cand / "text_encoder.onnx"
+                    ve = cand / "vector_estimator.int8.onnx" if (cand / "vector_estimator.int8.onnx").exists() else cand / "vector_estimator.onnx"
+                    voc = cand / "vocoder.int8.onnx" if (cand / "vocoder.int8.onnx").exists() else cand / "vocoder.onnx"
+                    tts_json = cand / "tts.json"
+                    ui = cand / "unicode_indexer.bin"
+                    vs = cand / "voice_styles.bin"
+                    if not vs.exists():
+                        vs = cand / "voice.bin"
+                    if dp.exists() and te.exists() and ve.exists() and voc.exists() and tts_json.exists() and ui.exists() and vs.exists():
+                        return {
+                            "duration_predictor": str(dp),
+                            "text_encoder": str(te),
+                            "vector_estimator": str(ve),
+                            "vocoder": str(voc),
+                            "tts_json": str(tts_json),
+                            "unicode_indexer": str(ui),
+                            "voice_style": str(vs),
+                            "model_name": cand.name,
+                        }
+            raise TTSModelLoadError(
+                f"[FAIL-FAST] Supertonic model assets (duration_predictor, text_encoder, vocoder, tts.json) not found.\n"
+                f"  Run 'termux-tts install --models supertonic' to download and provision Supertonic."
+            )
+
+        # 3. MeloTTS Model Search
+        if self.model_type == "melo":
+            for sdir in search_dirs:
+                if not sdir.exists():
+                    continue
+                candidates = [sdir] + [sdir / name for name in ["vits-melo-tts-zh_en", "melo-tts", "melotts"]]
+                for cand in candidates:
+                    if not cand.is_dir():
+                        continue
+                    tokens = cand / "tokens.txt"
+                    lexicon = cand / "lexicon.txt"
+                    onnx_files = list(cand.glob("*.onnx"))
+                    if onnx_files and tokens.exists() and lexicon.exists():
+                        return {
+                            "model": str(onnx_files[0]),
+                            "tokens": str(tokens),
+                            "lexicon": str(lexicon),
+                            "model_name": cand.name,
+                        }
+            raise TTSModelLoadError(
+                f"[FAIL-FAST] MeloTTS model assets (model.onnx, tokens.txt, lexicon.txt) not found.\n"
+                f"  Run 'termux-tts install --models melo' to download and provision MeloTTS."
+            )
 
-        # 1. Find directory containing .onnx model, tokens.txt, and espeak-ng-data
+        # 4. Standard VITS ONNX model search
         for sdir in search_dirs:
             if not sdir.exists():
                 continue
 
-            # Look for VITS ONNX model
             onnx_files = list(sdir.glob("*.onnx"))
             if not onnx_files and (sdir / "vits-mimic3-ko_KO-kss_low").exists():
                 sdir = sdir / "vits-mimic3-ko_KO-kss_low"
@@ -127,19 +212,26 @@ class SherpaNeuralEngine:
                 onnx_model = str(onnx_files[0])
                 tokens_file = sdir / "tokens.txt"
                 espeak_dir = sdir / "espeak-ng-data"
+                lexicon_file = sdir / "lexicon.txt"
 
                 if not tokens_file.exists():
                     tokens_file = sdir.parent / "tokens.txt"
                 if not espeak_dir.exists():
                     espeak_dir = sdir.parent / "espeak-ng-data"
+                if not lexicon_file.exists():
+                    lexicon_file = sdir.parent / "lexicon.txt"
 
-                if tokens_file.exists() and espeak_dir.exists():
-                    return {
+                if tokens_file.exists() and (espeak_dir.exists() or lexicon_file.exists()):
+                    res = {
                         "model": str(onnx_model),
                         "tokens": str(tokens_file),
-                        "data_dir": str(espeak_dir),
                         "model_name": Path(onnx_model).stem,
                     }
+                    if espeak_dir.exists():
+                        res["data_dir"] = str(espeak_dir)
+                    if lexicon_file.exists():
+                        res["lexicon"] = str(lexicon_file)
+                    return res
 
         raise TTSModelLoadError(
             f"[FAIL-FAST] Required TTS model assets (onnx model, tokens.txt, espeak-ng-data) "
@@ -173,18 +265,65 @@ class SherpaNeuralEngine:
             temp_wav = tmp_file.name
 
         try:
-            cmd = [
-                self.binary,
-                f"--vits-model={self.model_assets['model']}",
-                f"--vits-tokens={self.model_assets['tokens']}",
-                f"--vits-data-dir={self.model_assets['data_dir']}",
-                f"--output-filename={temp_wav}",
-                f"--num-threads={self.threads}",
-                f"--speed={speed:.2f}",
-                normalized_text,
-            ]
+            if self.model_type == "kokoro":
+                cmd = [
+                    self.binary,
+                    f"--kokoro-model={self.model_assets['model']}",
+                    f"--kokoro-voices={self.model_assets['voices']}",
+                    f"--kokoro-tokens={self.model_assets['tokens']}",
+                    f"--output-filename={temp_wav}",
+                    f"--num-threads={self.threads}",
+                    f"--speed={speed:.2f}",
+                ]
+                if self.model_assets.get("data_dir"):
+                    cmd.append(f"--kokoro-data-dir={self.model_assets['data_dir']}")
+                cmd.append(normalized_text)
+            elif self.model_type == "supertonic":
+                cmd = [
+                    self.binary,
+                    f"--supertonic-duration-predictor={self.model_assets['duration_predictor']}",
+                    f"--supertonic-text-encoder={self.model_assets['text_encoder']}",
+                    f"--supertonic-vector-estimator={self.model_assets['vector_estimator']}",
+                    f"--supertonic-vocoder={self.model_assets['vocoder']}",
+                    f"--supertonic-tts-json={self.model_assets['tts_json']}",
+                    f"--supertonic-unicode-indexer={self.model_assets['unicode_indexer']}",
+                    f"--supertonic-voice-style={self.model_assets['voice_style']}",
+                    f"--lang={self.language if self.language not in ('auto', '') else 'ko'}",
+                    f"--output-filename={temp_wav}",
+                    f"--num-threads={self.threads}",
+                    f"--speed={speed:.2f}",
+                    normalized_text,
+                ]
+            elif self.model_type == "melo":
+                cmd = [
+                    self.binary,
+                    f"--vits-model={self.model_assets['model']}",
+                    f"--vits-tokens={self.model_assets['tokens']}",
+                    f"--vits-lexicon={self.model_assets['lexicon']}",
+                    f"--output-filename={temp_wav}",
+                    f"--num-threads={self.threads}",
+                    f"--speed={speed:.2f}",
+                    normalized_text,
+                ]
+            else:
+                cmd = [
+                    self.binary,
+                    f"--vits-model={self.model_assets['model']}",
+                    f"--vits-tokens={self.model_assets['tokens']}",
+                    f"--output-filename={temp_wav}",
+                    f"--num-threads={self.threads}",
+                    f"--speed={speed:.2f}",
+                ]
+                if self.model_assets.get("data_dir"):
+                    cmd.append(f"--vits-data-dir={self.model_assets['data_dir']}")
+                elif self.model_assets.get("lexicon"):
+                    cmd.append(f"--vits-lexicon={self.model_assets['lexicon']}")
+                cmd.append(normalized_text)
 
             env = os.environ.copy()
+            env["PYTHONIOENCODING"] = "utf-8"
+            env["LANG"] = "en_US.UTF-8"
+            env["LC_ALL"] = "en_US.UTF-8"
             # Ensure proper thread affinity and libraries
             if os.path.exists("/system/lib64/libvulkan.so"):
                 current_ld = env.get("LD_LIBRARY_PATH", "")