diff --git a/Documentation/TTS/Qwen3TTS.md b/Documentation/TTS/Qwen3TTS.md
new file mode 100644
index 000000000..ee70c5ee0
--- /dev/null
+++ b/Documentation/TTS/Qwen3TTS.md
@@ -0,0 +1,104 @@
+# Qwen3-TTS: Multilingual Text-to-Speech (Beta)
+
+## Overview
+
+Qwen3-TTS is an LLM-based multilingual TTS backend built on the Qwen3 language model. It supports 10 languages including English and Chinese, producing natural speech at 24 kHz via a 4-stage CoreML pipeline.
+
+> **Beta.** Qwen3-TTS is in early beta. It does not yet include a built-in text tokenizer — input must be pre-tokenized externally (e.g., via the Python `qwen-tts` package). If you run into issues or have feedback, please open an issue. We'd love help testing across languages and hardware configs.
+
+## Quick Start
+
+### CLI
+
+```bash
+# English
+swift run fluidaudiocli tts --backend qwen3 \
+  "Hello world, this is a test of the text to speech system." \
+  --output hello.wav
+
+# Chinese
+swift run fluidaudiocli tts --backend qwen3 \
+  "你好世界，这是一个文字转语音系统的测试。" \
+  --output chinese.wav
+```
+
+Models are auto-downloaded from HuggingFace on first run.
+
+### Swift
+
+```swift
+import FluidAudio
+
+let manager = Qwen3TtsManager()
+try await manager.loadIfNeeded()
+
+// Token IDs must be generated externally (e.g., via Python qwen-tts processor)
+let tokenIds = [9707, 1879, 11, 419, 374, 264, 1273, 315, 279, 1467, 4686, 1331, 39586, 1849, 13]
+let result = try await manager.synthesize(text: "Hello world", tokenIds: tokenIds)
+
+let outputURL = URL(fileURLWithPath: "/tmp/qwen3_output.wav")
+try result.audio.write(to: outputURL)
+```
+
+## Pipeline
+
+```
+text tokens ──► Prefill ──► LM Decode Loop ──► Audio Decoder ──► WAV
+                  │              │
+                  │         ┌────┴────┐
+                  │         │ CB0     │ (greedy with repetition penalty)
+                  │         │ CB1-15  │ (code predictor, temperature sampling)
+                  │         └─────────┘
+                  │
+             role_ids + text_ids + speaker_embed + TTS special tokens
+```
+
+### Stages
+
+| Stage | Model | Description |
+|-------|-------|-------------|
+| 1. Prefill | `qwen3_tts_lm_prefill_v9` | Encodes text context → initial logits, KV cache, past hidden state |
+| 2. LM Decode | `qwen3_tts_lm_decode_v10` | Autoregressive loop generating CB0 tokens (main codebook) |
+| 3. Code Predictor | `qwen3_tts_cp_prefill` + `qwen3_tts_cp_decode` | Generates CB1-15 from past hidden + CB0 per step |
+| 4. Audio Decoder | `qwen3_tts_decoder_10s` | Converts 16-layer codebook frames to 24 kHz waveform |
+
+## Files
+
+| File | Role |
+|------|------|
+| `Qwen3TtsManager.swift` | Public API — `loadIfNeeded()`, `synthesize()` |
+| `Qwen3TtsSynthesizer.swift` | Core inference pipeline — prefill, decode loop, code predictor, audio decoder |
+| `Qwen3TtsModelStore.swift` | Loads and stores 5 CoreML models + embeddings from `.npy` files |
+| `Qwen3TtsConstants.swift` | Model dimensions, special token IDs, sampling parameters |
+| `Qwen3TtsResourceDownloader.swift` | Auto-downloads models from HuggingFace |
+
+## Sampling
+
+CB0 (main language model) uses greedy decoding with logit processors:
+- Repetition penalty (1.05) on all previously generated CB0 tokens
+- Token suppression: tokens 2048-3071 masked except EOS (2150)
+- `min_new_tokens`: EOS suppressed for first 2 steps
+
+CB1-15 (code predictor) uses temperature sampling:
+- Temperature: 0.9
+- Top-K: 50
+- Greedy code prediction produces silent/broken audio; temperature sampling is required.
+
+## Languages
+
+Qwen3-TTS supports 10 languages: Chinese, English, Japanese, Korean, German, French, Russian, Portuguese, Spanish, Italian.
+
+Language IDs are embedded via the codec embedding table during prefill (e.g., English = 2050, Chinese = 2055).
+
+## Limitations
+
+- **No built-in tokenizer.** Text must be pre-tokenized using the Qwen3 tokenizer externally. The CLI currently supports two hardcoded test sentences.
+- **Max 128 text tokens.** Longer inputs are truncated.
+- **Max 125 codec frames.** Generates up to ~10 seconds of audio per call.
+- **CPU+GPU compute.** Models run on `cpuAndGPU` compute units (no ANE optimization yet).
+
+## Model Source
+
+Models are hosted at [alexwengg/qwen3-tts-coreml](https://huggingface.co/alexwengg/qwen3-tts-coreml) on HuggingFace.
+
+Based on [Qwen/Qwen3-TTS-12Hz-0.6B-Base](https://huggingface.co/Qwen/Qwen3-TTS-12Hz-0.6B-Base).
diff --git a/Sources/FluidAudio/DownloadUtils.swift b/Sources/FluidAudio/DownloadUtils.swift
index 5191aae21..883474383 100644
--- a/Sources/FluidAudio/DownloadUtils.swift
+++ b/Sources/FluidAudio/DownloadUtils.swift
@@ -329,6 +329,7 @@ public class DownloadUtils {
                         shouldInclude =
                             patterns.isEmpty || patterns.contains { itemPath.hasPrefix($0) }
                             || itemPath.hasSuffix(".json") || itemPath.hasSuffix(".txt")
+                            || itemPath.hasSuffix(".npy") || itemPath.hasSuffix(".bin")
                     }
                     if shouldInclude {
                         let fileSize = item["size"] as? Int ?? -1
diff --git a/Sources/FluidAudio/ModelNames.swift b/Sources/FluidAudio/ModelNames.swift
index 05160cbf7..0859e6170 100644
--- a/Sources/FluidAudio/ModelNames.swift
+++ b/Sources/FluidAudio/ModelNames.swift
@@ -17,6 +17,7 @@ public enum Repo: String, CaseIterable {
     case pocketTts = "FluidInference/pocket-tts-coreml"
     case qwen3Asr = "FluidInference/qwen3-asr-0.6b-coreml/f32"
     case qwen3AsrInt8 = "FluidInference/qwen3-asr-0.6b-coreml/int8"
+    case qwen3Tts = "alexwengg/qwen3-tts-coreml"
 
     /// Repository slug (without owner)
     public var name: String {
@@ -51,6 +52,8 @@ public enum Repo: String, CaseIterable {
             return "qwen3-asr-0.6b-coreml/f32"
         case .qwen3AsrInt8:
             return "qwen3-asr-0.6b-coreml/int8"
+        case .qwen3Tts:
+            return "qwen3-tts-coreml"
         }
     }
 
@@ -69,6 +72,8 @@ public enum Repo: String, CaseIterable {
             return "FluidInference/ls-eend-coreml"
         case .qwen3Asr, .qwen3AsrInt8:
             return "FluidInference/qwen3-asr-0.6b-coreml"
+        case .qwen3Tts:
+            return "alexwengg/qwen3-tts-coreml"
         default:
             return "FluidInference/\(name)"
         }
@@ -109,6 +114,8 @@ public enum Repo: String, CaseIterable {
             return "ls-eend"
         case .pocketTts:
             return "pocket-tts"
+        case .qwen3Tts:
+            return "qwen3-tts"
         default:
             return name
         }
@@ -423,6 +430,35 @@ public enum ModelNames {
         ]
     }
 
+    /// Qwen3-TTS model names (LLM-based multilingual TTS)
+    public enum Qwen3TTS {
+        public static let textProjector = "TextProjector"
+        public static let codeEmbedder = "CodeEmbedder"
+        public static let multiCodeEmbedder = "MultiCodeEmbedder"
+        public static let codeDecoder = "CodeDecoder"
+        public static let multiCodeDecoder = "MultiCodeDecoder"
+        public static let speechDecoder = "SpeechDecoder"
+
+        public static let textProjectorFile = textProjector + ".mlmodelc"
+        public static let codeEmbedderFile = codeEmbedder + ".mlmodelc"
+        public static let multiCodeEmbedderFile = multiCodeEmbedder + ".mlmodelc"
+        public static let codeDecoderFile = codeDecoder + ".mlmodelc"
+        public static let multiCodeDecoderFile = multiCodeDecoder + ".mlmodelc"
+        public static let speechDecoderFile = speechDecoder + ".mlmodelc"
+
+        /// Optional speaker embedding file.
+        public static let speakerEmbeddingFile = "speaker_embedding_official.npy"
+
+        public static let requiredModels: Set<String> = [
+            textProjectorFile,
+            codeEmbedderFile,
+            multiCodeEmbedderFile,
+            codeDecoderFile,
+            multiCodeDecoderFile,
+            speechDecoderFile,
+        ]
+    }
+
     /// Multilingual G2P (CharsiuG2P ByT5) model names
     public enum MultilingualG2P {
         public static let encoder = "MultilingualG2PEncoder"
@@ -540,6 +576,8 @@ public enum ModelNames {
             return ModelNames.LSEEND.requiredModels
         case .qwen3Asr, .qwen3AsrInt8:
             return ModelNames.Qwen3ASR.requiredModelsFull
+        case .qwen3Tts:
+            return ModelNames.Qwen3TTS.requiredModels
         }
     }
 }
diff --git a/Sources/FluidAudio/TTS/Kokoro/Pipeline/Synthesize/KokoroSynthesizer.swift b/Sources/FluidAudio/TTS/Kokoro/Pipeline/Synthesize/KokoroSynthesizer.swift
index 5ca3f5bf5..40a7f2071 100644
--- a/Sources/FluidAudio/TTS/Kokoro/Pipeline/Synthesize/KokoroSynthesizer.swift
+++ b/Sources/FluidAudio/TTS/Kokoro/Pipeline/Synthesize/KokoroSynthesizer.swift
@@ -304,7 +304,22 @@ public struct KokoroSynthesizer {
             zeroFill: true
         )
 
+        // Source noise for newer Kokoro models
+        let maxSeconds = variant.maxDurationSeconds
+        let noiseLength = TtsConstants.audioSampleRate * maxSeconds
+        let sourceNoise = try await multiArrayPool.rent(
+            shape: [1, noiseLength, 9],
+            dataType: .float16,
+            zeroFill: false
+        )
+        let noisePointer = sourceNoise.dataPointer.bindMemory(to: UInt16.self, capacity: noiseLength * 9)
+        for i in 0..<(noiseLength * 9) {
+            let randomValue = Float.random(in: -1...1)
+            noisePointer[i] = Float16(randomValue).bitPattern
+        }
+
         func recycleModelArrays() async {
+            await multiArrayPool.recycle(sourceNoise, zeroFill: false)
             await multiArrayPool.recycle(phasesArray, zeroFill: true)
             await multiArrayPool.recycle(attentionMask, zeroFill: false)
             await multiArrayPool.recycle(inputArray, zeroFill: false)
@@ -338,6 +353,7 @@ public struct KokoroSynthesizer {
             "attention_mask": attentionMask,
             "ref_s": refStyle,
             "random_phases": phasesArray,
+            "source_noise": sourceNoise,
         ])
 
         let predictionStart = Date()
diff --git a/Sources/FluidAudio/TTS/Qwen3TTS/Qwen3TtsConstants.swift b/Sources/FluidAudio/TTS/Qwen3TTS/Qwen3TtsConstants.swift
new file mode 100644
index 000000000..b1ac9db14
--- /dev/null
+++ b/Sources/FluidAudio/TTS/Qwen3TTS/Qwen3TtsConstants.swift
@@ -0,0 +1,90 @@
+import Foundation
+
+/// Constants for the Qwen3-TTS 6-model CoreML pipeline.
+public enum Qwen3TtsConstants {
+
+    // MARK: - Audio
+
+    public static let audioSampleRate: Int = 24_000
+
+    /// Audio samples per codec frame (80ms at 24kHz).
+    public static let samplesPerFrame: Int = 1_920
+
+    // MARK: - Model dimensions
+
+    public static let hiddenSize: Int = 1024
+    public static let numCodebooks: Int = 16
+    public static let codecVocabSize: Int = 2048
+
+    // MARK: - CodeDecoder KV cache
+
+    /// Fixed KV cache sequence length for CodeDecoder.
+    /// key_cache / value_cache shape: [1, 28672, 1, 256] float16
+    public static let cdKvLen: Int = 256
+
+    /// Consolidated KV dimension for CodeDecoder (28 layers).
+    public static let cdKvDim: Int = 28_672
+
+    // MARK: - MultiCodeDecoder KV cache
+
+    /// Fixed KV cache sequence length for MultiCodeDecoder.
+    /// key_cache / value_cache shape: [1, 5120, 1, 16] float16
+    public static let mcdKvLen: Int = 16
+
+    /// Consolidated KV dimension for MultiCodeDecoder (5 layers).
+    public static let mcdKvDim: Int = 5_120
+
+    // MARK: - Codec special token IDs
+
+    public static let codecPadId: Int = 2148
+    public static let codecBosId: Int = 2149
+    public static let codecEosId: Int = 2150
+    public static let codecThinkId: Int = 2154
+    public static let codecNoThinkId: Int = 2155
+    public static let codecThinkBosId: Int = 2156
+    public static let codecThinkEosId: Int = 2157
+
+    // MARK: - Language IDs
+
+    public static let languageIds: [String: Int] = [
+        "english": 2050,
+        "chinese": 2055,
+        "german": 2053,
+        "italian": 2070,
+        "portuguese": 2071,
+        "spanish": 2054,
+        "japanese": 2058,
+        "korean": 2064,
+        "french": 2061,
+        "russian": 2069,
+    ]
+
+    // MARK: - TTS special token IDs
+
+    public static let ttsPadTokenId: Int = 151_671
+    public static let ttsBosTokenId: Int = 151_672
+    public static let ttsEosTokenId: Int = 151_673
+
+    // MARK: - Role prefix tokens
+
+    /// [im_start, assistant, newline]
+    public static let rolePrefixTokens: [Int] = [151_644, 77_091, 198]
+
+    // MARK: - Generation parameters
+
+    public static let maxCodecTokens: Int = 125
+    public static let temperature: Float = 0.9
+    public static let topK: Int = 50
+    public static let repetitionPenalty: Float = 1.05
+    public static let minNewTokens: Int = 2
+
+    // MARK: - SpeechDecoder
+
+    /// Fixed input time dimension for SpeechDecoder: [1, 16, 125].
+    public static let speechDecoderFrames: Int = 125
+
+    // MARK: - Defaults
+
+    public static let defaultVoice: String = "default"
+    public static let defaultLanguage: String = "english"
+}
diff --git a/Sources/FluidAudio/TTS/Qwen3TTS/Qwen3TtsManager.swift b/Sources/FluidAudio/TTS/Qwen3TTS/Qwen3TtsManager.swift
new file mode 100644
index 000000000..e99736d34
--- /dev/null
+++ b/Sources/FluidAudio/TTS/Qwen3TTS/Qwen3TtsManager.swift
@@ -0,0 +1,132 @@
+import Foundation
+import OSLog
+
+/// Manages text-to-speech synthesis using Qwen3-TTS CoreML models.
+///
+/// - Important: **Beta.** Qwen3-TTS does not yet include a built-in text tokenizer.
+///   Input must be pre-tokenized externally (e.g., via the Python `qwen-tts` package).
+///
+/// Qwen3-TTS is a large language model-based TTS system that supports
+/// multiple languages including English and Chinese. It uses a 4-stage
+/// pipeline: prefill → LM decode → code predictor → audio decoder.
+///
+/// Example usage:
+/// ```swift
+/// let manager = Qwen3TtsManager()
+/// try await manager.loadFromDirectory(modelDirectory)
+/// let audioData = try await manager.synthesize(text: "Hello world", tokenIds: [...])
+/// ```
+public actor Qwen3TtsManager {
+
+    private let logger = AppLogger(category: "Qwen3TtsManager")
+    private let modelStore: Qwen3TtsModelStore
+    private var isInitialized = false
+
+    /// Creates a new Qwen3-TTS manager.
+    public init() {
+        self.modelStore = Qwen3TtsModelStore()
+    }
+
+    public var isAvailable: Bool {
+        isInitialized
+    }
+
+    /// Download models from HuggingFace and initialize.
+    public func initialize() async throws {
+        try await modelStore.loadIfNeeded()
+        isInitialized = true
+        logger.notice("Qwen3TtsManager initialized (auto-download)")
+    }
+
+    /// Load models from a local directory.
+    ///
+    /// - Parameter directory: Path to directory containing CoreML model bundles.
+    public func loadFromDirectory(_ directory: URL) async throws {
+        try await modelStore.loadFromDirectory(directory)
+        isInitialized = true
+        logger.notice("Qwen3TtsManager initialized from \(directory.lastPathComponent)")
+    }
+
+    /// Synthesize text to WAV audio data.
+    ///
+    /// - Parameters:
+    ///   - text: The text to synthesize (for logging purposes).
+    ///   - tokenIds: Pre-tokenized text IDs from Qwen3 tokenizer.
+    ///   - useSpeaker: Whether to use speaker embedding (default: true).
+    ///   - language: Language for synthesis (default: "english").
+    /// - Returns: WAV audio data at 24kHz.
+    public func synthesize(
+        text: String,
+        tokenIds: [Int],
+        useSpeaker: Bool = true,
+        language: String = Qwen3TtsConstants.defaultLanguage
+    ) async throws -> Data {
+        guard isInitialized else {
+            throw TTSError.modelNotFound("Qwen3-TTS models not initialized")
+        }
+
+        return try await Qwen3TtsSynthesizer.withModelStore(modelStore) {
+            let result = try await Qwen3TtsSynthesizer.synthesize(
+                text: text,
+                tokenIds: tokenIds,
+                useSpeaker: useSpeaker,
+                language: language
+            )
+            return result.audio
+        }
+    }
+
+    /// Synthesize text and return detailed results.
+    public func synthesizeDetailed(
+        text: String,
+        tokenIds: [Int],
+        useSpeaker: Bool = true,
+        language: String = Qwen3TtsConstants.defaultLanguage
+    ) async throws -> Qwen3TtsSynthesizer.SynthesisResult {
+        guard isInitialized else {
+            throw TTSError.modelNotFound("Qwen3-TTS models not initialized")
+        }
+
+        return try await Qwen3TtsSynthesizer.withModelStore(modelStore) {
+            try await Qwen3TtsSynthesizer.synthesize(
+                text: text,
+                tokenIds: tokenIds,
+                useSpeaker: useSpeaker,
+                language: language
+            )
+        }
+    }
+
+    /// Synthesize text and write the result directly to a file.
+    public func synthesizeToFile(
+        text: String,
+        tokenIds: [Int],
+        outputURL: URL,
+        useSpeaker: Bool = true,
+        language: String = Qwen3TtsConstants.defaultLanguage
+    ) async throws {
+        if FileManager.default.fileExists(atPath: outputURL.path) {
+            try FileManager.default.removeItem(at: outputURL)
+        }
+
+        let audioData = try await synthesize(
+            text: text,
+            tokenIds: tokenIds,
+            useSpeaker: useSpeaker,
+            language: language
+        )
+
+        try audioData.write(to: outputURL)
+        logger.notice("Saved synthesized audio to: \(outputURL.lastPathComponent)")
+    }
+
+    /// Get the underlying model store for advanced usage.
+    public func getModelStore() -> Qwen3TtsModelStore {
+        modelStore
+    }
+
+    public func cleanup() async {
+        await modelStore.reset()
+        isInitialized = false
+    }
+}
diff --git a/Sources/FluidAudio/TTS/Qwen3TTS/Qwen3TtsModelStore.swift b/Sources/FluidAudio/TTS/Qwen3TTS/Qwen3TtsModelStore.swift
new file mode 100644
index 000000000..21d999b89
--- /dev/null
+++ b/Sources/FluidAudio/TTS/Qwen3TTS/Qwen3TtsModelStore.swift
@@ -0,0 +1,225 @@
+@preconcurrency import CoreML
+import Foundation
+import OSLog
+
+/// Actor-based store for the 6 Qwen3-TTS CoreML models.
+///
+/// Models:
+/// - TextProjector — text token → embedding
+/// - CodeEmbedder — codec token → embedding
+/// - MultiCodeEmbedder — linearized codebook token → embedding
+/// - CodeDecoder — 28-layer transformer with KV cache (generates CB0)
+/// - MultiCodeDecoder — 5-layer transformer with KV cache (generates CB1-CB15)
+/// - SpeechDecoder — codec frames → audio waveform
+public actor Qwen3TtsModelStore {
+
+    private let logger = AppLogger(category: "Qwen3TtsModelStore")
+
+    private var textProjectorModel: MLModel?
+    private var codeEmbedderModel: MLModel?
+    private var multiCodeEmbedderModel: MLModel?
+    private var codeDecoderModel: MLModel?
+    private var multiCodeDecoderModel: MLModel?
+    private var speechDecoderModel: MLModel?
+    private var speakerEmbedding: [Float]?
+    private var repoDirectory: URL?
+
+    public init() {}
+
+    /// Download models from HuggingFace and load them.
+    public func loadIfNeeded() async throws {
+        guard textProjectorModel == nil else { return }
+
+        let repoDir = try await Qwen3TtsResourceDownloader.ensureModels()
+        try await loadFromDirectory(repoDir)
+    }
+
+    /// Load all CoreML models from a local directory.
+    public func loadFromDirectory(_ directory: URL) async throws {
+        guard textProjectorModel == nil else { return }
+
+        self.repoDirectory = directory
+
+        logger.info("Loading Qwen3-TTS CoreML models from \(directory.path)...")
+
+        // Embedding models and SpeechDecoder use CPU+GPU (float32)
+        let f32Config = MLModelConfiguration()
+        f32Config.computeUnits = .cpuAndGPU
+
+        // CodeDecoder also uses CPU+GPU to prevent inf/NaN from ANE float16 overflow
+        let allConfig = MLModelConfiguration()
+        allConfig.computeUnits = .cpuAndGPU
+
+        let loadStart = Date()
+
+        textProjectorModel = try loadModel(
+            at: directory.appendingPathComponent(ModelNames.Qwen3TTS.textProjectorFile),
+            config: f32Config, name: "TextProjector")
+        codeEmbedderModel = try loadModel(
+            at: directory.appendingPathComponent(ModelNames.Qwen3TTS.codeEmbedderFile),
+            config: f32Config, name: "CodeEmbedder")
+        multiCodeEmbedderModel = try loadModel(
+            at: directory.appendingPathComponent(ModelNames.Qwen3TTS.multiCodeEmbedderFile),
+            config: f32Config, name: "MultiCodeEmbedder")
+        codeDecoderModel = try loadModel(
+            at: directory.appendingPathComponent(ModelNames.Qwen3TTS.codeDecoderFile),
+            config: allConfig, name: "CodeDecoder")
+        // MultiCodeDecoder MUST use CPU_ONLY (all other configs produce NaN)
+        let mcdConfig = MLModelConfiguration()
+        mcdConfig.computeUnits = .cpuOnly
+        multiCodeDecoderModel = try loadModel(
+            at: directory.appendingPathComponent(ModelNames.Qwen3TTS.multiCodeDecoderFile),
+            config: mcdConfig, name: "MultiCodeDecoder")
+        speechDecoderModel = try loadModel(
+            at: directory.appendingPathComponent(ModelNames.Qwen3TTS.speechDecoderFile),
+            config: f32Config, name: "SpeechDecoder")
+
+        // Load optional speaker embedding
+        let speakerURL = directory.appendingPathComponent(
+            ModelNames.Qwen3TTS.speakerEmbeddingFile)
+        if FileManager.default.fileExists(atPath: speakerURL.path) {
+            speakerEmbedding = try loadNumpyFloatArray(from: speakerURL)
+            logger.info("Loaded speaker embedding (\(speakerEmbedding!.count) floats)")
+        }
+
+        let elapsed = Date().timeIntervalSince(loadStart)
+        logger.info("All Qwen3-TTS models loaded in \(String(format: "%.2f", elapsed))s")
+    }
+
+    // MARK: - Accessors
+
+    public func textProjector() throws -> MLModel {
+        guard let model = textProjectorModel else {
+            throw TTSError.modelNotFound("TextProjector model not loaded")
+        }
+        return model
+    }
+
+    public func codeEmbedder() throws -> MLModel {
+        guard let model = codeEmbedderModel else {
+            throw TTSError.modelNotFound("CodeEmbedder model not loaded")
+        }
+        return model
+    }
+
+    public func multiCodeEmbedder() throws -> MLModel {
+        guard let model = multiCodeEmbedderModel else {
+            throw TTSError.modelNotFound("MultiCodeEmbedder model not loaded")
+        }
+        return model
+    }
+
+    public func codeDecoder() throws -> MLModel {
+        guard let model = codeDecoderModel else {
+            throw TTSError.modelNotFound("CodeDecoder model not loaded")
+        }
+        return model
+    }
+
+    public func multiCodeDecoder() throws -> MLModel {
+        guard let model = multiCodeDecoderModel else {
+            throw TTSError.modelNotFound("MultiCodeDecoder model not loaded")
+        }
+        return model
+    }
+
+    public func speechDecoder() throws -> MLModel {
+        guard let model = speechDecoderModel else {
+            throw TTSError.modelNotFound("SpeechDecoder model not loaded")
+        }
+        return model
+    }
+
+    public func speaker() -> [Float]? {
+        speakerEmbedding
+    }
+
+    public func repoDir() throws -> URL {
+        guard let dir = repoDirectory else {
+            throw TTSError.modelNotFound("Qwen3-TTS repository not loaded")
+        }
+        return dir
+    }
+
+    public var isLoaded: Bool {
+        textProjectorModel != nil && codeEmbedderModel != nil
+            && multiCodeEmbedderModel != nil && codeDecoderModel != nil
+            && multiCodeDecoderModel != nil && speechDecoderModel != nil
+    }
+
+    public func reset() {
+        textProjectorModel = nil
+        codeEmbedderModel = nil
+        multiCodeEmbedderModel = nil
+        codeDecoderModel = nil
+        multiCodeDecoderModel = nil
+        speechDecoderModel = nil
+        speakerEmbedding = nil
+        repoDirectory = nil
+    }
+
+    // MARK: - Private Helpers
+
+    private func loadModel(
+        at url: URL,
+        config: MLModelConfiguration,
+        name: String
+    ) throws -> MLModel {
+        let ext = url.pathExtension
+
+        if ext == "mlpackage" {
+            logger.info("Compiling \(name) model...")
+            let compiledURL = try MLModel.compileModel(at: url)
+            let model = try MLModel(contentsOf: compiledURL, configuration: config)
+            logger.info("Loaded \(name) model (compiled)")
+            return model
+        }
+
+        let model = try MLModel(contentsOf: url, configuration: config)
+        logger.info("Loaded \(name) model")
+        return model
+    }
+
+    /// Load a numpy .npy file containing float32 array.
+    private func loadNumpyFloatArray(from url: URL) throws -> [Float] {
+        let data = try Data(contentsOf: url)
+
+        guard data.count >= 12 else {
+            throw TTSError.processingFailed("Invalid NPY file: too small")
+        }
+
+        let magic = data.prefix(6)
+        guard magic == Data([0x93, 0x4E, 0x55, 0x4D, 0x50, 0x59]) else {
+            throw TTSError.processingFailed("Invalid NPY magic number")
+        }
+
+        let majorVersion = data[6]
+
+        let headerLen: Int
+        let headerOffset: Int
+        if majorVersion == 1 {
+            headerLen = Int(data[8]) | (Int(data[9]) << 8)
+            headerOffset = 10
+        } else {
+            headerLen =
+                Int(data[8]) | (Int(data[9]) << 8) | (Int(data[10]) << 16)
+                | (Int(data[11]) << 24)
+            headerOffset = 12
+        }
+
+        let dataOffset = headerOffset + headerLen
+
+        let floatData = data.dropFirst(dataOffset)
+        let count = floatData.count / 4
+        var result = [Float](repeating: 0, count: count)
+
+        floatData.withUnsafeBytes { buffer in
+            let floatBuffer = buffer.bindMemory(to: Float.self)
+            for i in 0..<count {
+                result[i] = floatBuffer[i]
+            }
+        }
+
+        return result
+    }
+}
diff --git a/Sources/FluidAudio/TTS/Qwen3TTS/Qwen3TtsResourceDownloader.swift b/Sources/FluidAudio/TTS/Qwen3TTS/Qwen3TtsResourceDownloader.swift
new file mode 100644
index 000000000..b334a23cf
--- /dev/null
+++ b/Sources/FluidAudio/TTS/Qwen3TTS/Qwen3TtsResourceDownloader.swift
@@ -0,0 +1,58 @@
+import Foundation
+import OSLog
+
+/// Downloads Qwen3-TTS models and data files from HuggingFace.
+public enum Qwen3TtsResourceDownloader {
+
+    private static let logger = AppLogger(category: "Qwen3TtsResourceDownloader")
+
+    /// Ensure all Qwen3-TTS models are downloaded and return the cache directory.
+    public static func ensureModels() async throws -> URL {
+        let cacheDirectory = try cacheDirectory()
+        let modelsDirectory = cacheDirectory.appendingPathComponent("Models")
+
+        let repoDir = modelsDirectory.appendingPathComponent(Repo.qwen3Tts.folderName)
+
+        // Check that all required files exist
+        let requiredModels = ModelNames.Qwen3TTS.requiredModels
+        let allPresent = requiredModels.allSatisfy { model in
+            FileManager.default.fileExists(
+                atPath: repoDir.appendingPathComponent(model).path)
+        }
+
+        if !allPresent {
+            logger.info("Downloading Qwen3-TTS models from HuggingFace...")
+            try await DownloadUtils.downloadRepo(.qwen3Tts, to: modelsDirectory)
+        } else {
+            logger.info("Qwen3-TTS models found in cache")
+        }
+
+        return repoDir
+    }
+
+    // MARK: - Private
+
+    private static func cacheDirectory() throws -> URL {
+        let baseDirectory: URL
+        #if os(macOS)
+        baseDirectory = FileManager.default.homeDirectoryForCurrentUser
+            .appendingPathComponent(".cache")
+        #else
+        guard
+            let first = FileManager.default.urls(
+                for: .cachesDirectory, in: .userDomainMask
+            ).first
+        else {
+            throw TTSError.processingFailed("Failed to locate caches directory")
+        }
+        baseDirectory = first
+        #endif
+
+        let cacheDirectory = baseDirectory.appendingPathComponent("fluidaudio")
+        if !FileManager.default.fileExists(atPath: cacheDirectory.path) {
+            try FileManager.default.createDirectory(
+                at: cacheDirectory, withIntermediateDirectories: true)
+        }
+        return cacheDirectory
+    }
+}
diff --git a/Sources/FluidAudio/TTS/Qwen3TTS/Qwen3TtsSynthesizer.swift b/Sources/FluidAudio/TTS/Qwen3TTS/Qwen3TtsSynthesizer.swift
new file mode 100644
index 000000000..5adad8fcc
--- /dev/null
+++ b/Sources/FluidAudio/TTS/Qwen3TTS/Qwen3TtsSynthesizer.swift
@@ -0,0 +1,850 @@
+@preconcurrency import CoreML
+import Foundation
+import OSLog
+
+/// Qwen3-TTS 6-model CoreML synthesizer.
+///
+/// Pipeline (Argmax-style, matching `inference.py`):
+/// 1. Build prefill embeddings: TextProjector(text) + CodeEmbedder(codec) per position
+/// 2. CodeDecoder prefill: feed each embedding one at a time with KV cache
+/// 3. Autoregressive decode loop:
+///    a. MultiCodeDecoder: hidden_states + CB0 → CB1-CB15
+///    b. Sum all 16 codec embeddings + tts_pad → CodeDecoder step → next CB0
+/// 4. SpeechDecoder: all codec frames → audio waveform
+public struct Qwen3TtsSynthesizer {
+
+    static let logger = AppLogger(category: "Qwen3TtsSynthesizer")
+
+    private enum Context {
+        @TaskLocal static var modelStore: Qwen3TtsModelStore?
+    }
+
+    static func withModelStore<T>(
+        _ store: Qwen3TtsModelStore,
+        operation: () async throws -> T
+    ) async rethrows -> T {
+        try await Context.$modelStore.withValue(store) {
+            try await operation()
+        }
+    }
+
+    static func currentModelStore() throws -> Qwen3TtsModelStore {
+        guard let store = Context.modelStore else {
+            throw TTSError.processingFailed(
+                "Qwen3TtsSynthesizer requires a model store context.")
+        }
+        return store
+    }
+
+    // MARK: - Public Types
+
+    /// Result of a Qwen3-TTS synthesis operation.
+    public struct SynthesisResult: Sendable {
+        /// WAV audio data (24kHz).
+        public let audio: Data
+        /// Raw Float32 audio samples.
+        public let samples: [Float]
+        /// Number of codec tokens generated.
+        public let tokenCount: Int
+    }
+
+    // MARK: - Public API
+
+    /// Synthesize audio from text.
+    ///
+    /// - Parameters:
+    ///   - text: The text to synthesize.
+    ///   - tokenIds: Pre-tokenized text IDs.
+    ///   - useSpeaker: Whether to use speaker embedding (default: true).
+    ///   - language: Language for synthesis (default: "english").
+    /// - Returns: A synthesis result containing WAV audio data.
+    public static func synthesize(
+        text: String,
+        tokenIds: [Int]? = nil,
+        useSpeaker: Bool = true,
+        language: String = Qwen3TtsConstants.defaultLanguage
+    ) async throws -> SynthesisResult {
+        let store = try currentModelStore()
+
+        logger.info("Qwen3-TTS synthesizing: '\(text)'")
+
+        guard let textTokens = tokenIds else {
+            throw TTSError.processingFailed(
+                "Qwen3-TTS requires pre-tokenized input. Please provide tokenIds.")
+        }
+
+        // 1. Build prefill embeddings
+        let prefillStart = Date()
+        let prefillEmbeds = try await buildPrefillEmbeddings(
+            textTokens: textTokens,
+            useSpeaker: useSpeaker,
+            language: language,
+            store: store
+        )
+        let prefillBuildTime = Date().timeIntervalSince(prefillStart)
+        logger.info("Built \(prefillEmbeds.count) prefill embeddings in \(String(format: "%.2f", prefillBuildTime))s")
+
+        // 2. CodeDecoder prefill
+        let cdPrefillStart = Date()
+        var cdState = CodeDecoderKVState()
+        var lastOutput: CodeDecoderOutput!
+
+        for emb in prefillEmbeds {
+            lastOutput = try await runCodeDecoderStep(
+                inputEmbeds: emb, state: &cdState, store: store)
+        }
+        let cdPrefillTime = Date().timeIntervalSince(cdPrefillStart)
+        logger.info(
+            "CodeDecoder prefill: \(prefillEmbeds.count) positions in \(String(format: "%.2f", cdPrefillTime))s"
+        )
+
+        // 3. Sample first CB0 from prefill logits
+        var logits = extractFloatArray(from: lastOutput.logits)
+
+        suppressControlTokens(&logits)
+        suppressEos(&logits)  // min_new_tokens: suppress EOS for step 0
+        let firstCb0 = sampleTopK(logits: &logits)
+        var generatedCb0s: [Int] = [firstCb0]
+
+        logger.info("First CB0: \(firstCb0)")
+
+        // 4. Autoregressive decode loop
+        let decodeStart = Date()
+        var allFrames: [[Int]] = []
+        var currentCb0 = firstCb0
+        var currentHidden = lastOutput.hiddenStates
+
+        // Cache tts_pad embedding for decode loop
+        let textProjector = try await store.textProjector()
+        let ttsPadEmbed = try runTextProjector(textProjector, tokenId: Qwen3TtsConstants.ttsPadTokenId)
+        let codeEmbedder = try await store.codeEmbedder()
+        let multiCodeEmbedder = try await store.multiCodeEmbedder()
+
+        // PERFORMANCE: No KV cache template needed - each frame will create fresh arrays
+        // The first frame will call getModelStridedKVCaches(), subsequent frames will
+        // reuse the model's output arrays from the previous frame's final position.
+        var mcdKeyTemplate: MLMultiArray? = nil
+        var mcdValTemplate: MLMultiArray? = nil
+
+        for step in 0..<Qwen3TtsConstants.maxCodecTokens {
+            // MultiCodeDecoder: hidden + CB0 → CB1-CB15
+            let (cb1to15, newKeyTemplate, newValTemplate) = try await runMultiCodeDecoder(
+                hiddenStates: currentHidden,
+                cb0Token: currentCb0,
+                codeEmbedder: codeEmbedder,
+                multiCodeEmbedder: multiCodeEmbedder,
+                kvKeyTemplate: mcdKeyTemplate,
+                kvValTemplate: mcdValTemplate,
+                store: store
+            )
+            // Save the output KV caches as templates for next frame
+            mcdKeyTemplate = newKeyTemplate
+            mcdValTemplate = newValTemplate
+
+            let frame = [currentCb0] + cb1to15
+            allFrames.append(frame)
+
+            // Build decode input: sum(all 16 codec embeddings) + tts_pad
+            let cb0Embed = try runCodeEmbedder(codeEmbedder, tokenId: currentCb0)
+            var codecSum = extractFloatArray(from: cb0Embed)
+
+            for cbIdx in 0..<15 {
+                let linIdx = cbIdx * Qwen3TtsConstants.codecVocabSize + cb1to15[cbIdx]
+                let cbEmbed = try runMultiCodeEmbedder(multiCodeEmbedder, linearizedId: linIdx)
+                let cbFloats = extractFloatArray(from: cbEmbed)
+                for i in 0..<codecSum.count {
+                    codecSum[i] += cbFloats[i]
+                }
+            }
+
+            // Add tts_pad overlay
+            let padFloats = extractFloatArray(from: ttsPadEmbed)
+            for i in 0..<codecSum.count {
+                codecSum[i] += padFloats[i]
+            }
+
+            // Create input_embeds MLMultiArray [1, 1024, 1, 1]
+            let decodeInput = try createEmbedding(from: codecSum)
+
+            // CodeDecoder step
+            let cdOutput = try await runCodeDecoderStep(
+                inputEmbeds: decodeInput, state: &cdState, store: store)
+            currentHidden = cdOutput.hiddenStates
+
+            // Sample next CB0
+            var nextLogits = extractFloatArray(from: cdOutput.logits)
+            suppressControlTokens(&nextLogits)
+            if step >= 1 {
+                // Allow EOS after min_new_tokens=2 (step 0 was first token, step 1 is second)
+            } else {
+                suppressEos(&nextLogits)
+            }
+            applyRepetitionPenalty(&nextLogits, generatedIds: generatedCb0s)
+            let nextCb0 = sampleTopK(logits: &nextLogits)
+
+            if nextCb0 == Qwen3TtsConstants.codecEosId {
+                logger.info("EOS at step \(step + 1)")
+                break
+            }
+
+            if cdState.position >= Qwen3TtsConstants.cdKvLen - 1 {
+                logger.info("KV cache full at step \(step + 1)")
+                break
+            }
+
+            generatedCb0s.append(nextCb0)
+            currentCb0 = nextCb0
+        }
+
+        let decodeTime = Date().timeIntervalSince(decodeStart)
+        let fps = Double(allFrames.count) / max(decodeTime, 0.001)
+        logger.info(
+            "Decoded \(allFrames.count) frames in \(String(format: "%.2f", decodeTime))s"
+                + " (\(String(format: "%.1f", fps)) frames/s)"
+        )
+
+        // 5. SpeechDecoder: codes → audio
+        let speechStart = Date()
+        let audioSamples = try await runSpeechDecoder(
+            allFrames: allFrames, store: store)
+        let speechTime = Date().timeIntervalSince(speechStart)
+        logger.info("SpeechDecoder: \(String(format: "%.2f", speechTime))s")
+
+        // 6. Trim to actual frame count
+        let expectedSamples = allFrames.count * Qwen3TtsConstants.samplesPerFrame
+        let frameTrimmed: [Float]
+        if expectedSamples < audioSamples.count {
+            frameTrimmed = Array(audioSamples.prefix(expectedSamples))
+        } else {
+            frameTrimmed = audioSamples
+        }
+
+        // Strip leading/trailing silence
+        let trimmedSamples = trimSilence(
+            frameTrimmed, sampleRate: Qwen3TtsConstants.audioSampleRate)
+
+        // 7. Encode as WAV
+        let audioData = try AudioWAV.data(
+            from: trimmedSamples,
+            sampleRate: Double(Qwen3TtsConstants.audioSampleRate)
+        )
+
+        let duration = Double(trimmedSamples.count) / Double(Qwen3TtsConstants.audioSampleRate)
+        logger.info("Audio duration: \(String(format: "%.2f", duration))s")
+
+        return SynthesisResult(
+            audio: audioData,
+            samples: trimmedSamples,
+            tokenCount: allFrames.count
+        )
+    }
+
+    // MARK: - Prefill Embedding Construction
+
+    /// Build dual-embedding prefill sequence matching inference.py.
+    ///
+    /// Layout: role(3) + control(4) + speaker?(0-1) + bos(1) + text(N) + eos(1) + final(1)
+    private static func buildPrefillEmbeddings(
+        textTokens: [Int],
+        useSpeaker: Bool,
+        language: String,
+        store: Qwen3TtsModelStore
+    ) async throws -> [MLMultiArray] {
+        let textProjector = try await store.textProjector()
+        let codeEmbedder = try await store.codeEmbedder()
+
+        var embeds: [MLMultiArray] = []
+
+        // [0:3] Role: text_proj only (no codec overlay)
+        for tokenId in Qwen3TtsConstants.rolePrefixTokens {
+            embeds.append(try runTextProjector(textProjector, tokenId: tokenId))
+        }
+
+        // Cache tts_pad, tts_bos, tts_eos embeddings
+        let ttsPad = try runTextProjector(textProjector, tokenId: Qwen3TtsConstants.ttsPadTokenId)
+        let ttsBos = try runTextProjector(textProjector, tokenId: Qwen3TtsConstants.ttsBosTokenId)
+        let ttsEos = try runTextProjector(textProjector, tokenId: Qwen3TtsConstants.ttsEosTokenId)
+
+        // [3:7] Control: tts_pad + codec_emb([think, think_bos, lang, think_eos])
+        let langId =
+            Qwen3TtsConstants.languageIds[language] ?? Qwen3TtsConstants.languageIds["english"]!
+        let codecCtrlTokens = [
+            Qwen3TtsConstants.codecThinkId,
+            Qwen3TtsConstants.codecThinkBosId,
+            langId,
+            Qwen3TtsConstants.codecThinkEosId,
+        ]
+        for ctok in codecCtrlTokens {
+            let codecEmb = try runCodeEmbedder(codeEmbedder, tokenId: ctok)
+            embeds.append(try addEmbeddings(ttsPad, codecEmb))
+        }
+
+        // [7] Optional speaker embedding
+        if useSpeaker, let speakerData = await store.speaker() {
+            let speakerEmbed = try createEmbedding(from: speakerData)
+            embeds.append(try addEmbeddings(ttsPad, speakerEmbed))
+        }
+
+        // Control: tts_bos + codec_emb(codec_pad)
+        let codecPadEmb = try runCodeEmbedder(codeEmbedder, tokenId: Qwen3TtsConstants.codecPadId)
+        embeds.append(try addEmbeddings(ttsBos, codecPadEmb))
+
+        // Text: text_proj(token) + codec_emb(codec_pad) for each token
+        for tokenId in textTokens {
+            let textEmb = try runTextProjector(textProjector, tokenId: tokenId)
+            embeds.append(try addEmbeddings(textEmb, codecPadEmb))
+        }
+
+        // EOS: text_proj(tts_eos) + codec_emb(codec_pad)
+        embeds.append(try addEmbeddings(ttsEos, codecPadEmb))
+
+        // Final: tts_pad + codec_emb(codec_bos)
+        let codecBosEmb = try runCodeEmbedder(
+            codeEmbedder, tokenId: Qwen3TtsConstants.codecBosId)
+        embeds.append(try addEmbeddings(ttsPad, codecBosEmb))
+
+        return embeds
+    }
+
+    // MARK: - CodeDecoder
+
+    /// KV cache state for the CodeDecoder (28-layer transformer).
+    private struct CodeDecoderKVState {
+        var keyCache: MLMultiArray
+        var valueCache: MLMultiArray
+        var position: Int = 0
+
+        init() {
+            // [1, 28672, 1, 256] float16
+            let shape: [NSNumber] = [
+                1, NSNumber(value: Qwen3TtsConstants.cdKvDim), 1,
+                NSNumber(value: Qwen3TtsConstants.cdKvLen),
+            ]
+            keyCache = try! MLMultiArray(shape: shape, dataType: .float16)
+            valueCache = try! MLMultiArray(shape: shape, dataType: .float16)
+        }
+    }
+
+    private struct CodeDecoderOutput {
+        let logits: MLMultiArray
+        let hiddenStates: MLMultiArray
+    }
+
+    /// Run a single CodeDecoder step (prefill or decode).
+    private static func runCodeDecoderStep(
+        inputEmbeds: MLMultiArray,
+        state: inout CodeDecoderKVState,
+        store: Qwen3TtsModelStore
+    ) async throws -> CodeDecoderOutput {
+        let model = try await store.codeDecoder()
+        let pos = state.position
+        let kvLen = Qwen3TtsConstants.cdKvLen
+
+        // key_padding_mask [1, 256] float16: 0..pos = 0.0, rest = -10000.0
+        let keyMask = try MLMultiArray(shape: [1, NSNumber(value: kvLen)], dataType: .float16)
+        for i in 0..<kvLen {
+            keyMask[i] = NSNumber(value: i <= pos ? Float(0.0) : Float(-10000.0))
+        }
+
+        // kv_cache_update_mask [1, 256] float16: only pos = 1.0
+        let updateMask = try MLMultiArray(shape: [1, NSNumber(value: kvLen)], dataType: .float16)
+        for i in 0..<kvLen {
+            updateMask[i] = NSNumber(value: i == pos ? Float(1.0) : Float(0.0))
+        }
+
+        let cacheLenArr = try MLMultiArray(shape: [1], dataType: .int32)
+        cacheLenArr[0] = NSNumber(value: pos)
+
+        // Cast input_embeds to float16
+        let f16Input = try toFloat16(inputEmbeds)
+
+        let features = try MLDictionaryFeatureProvider(dictionary: [
+            "input_embeds": f16Input,
+            "cache_length": cacheLenArr,
+            "key_padding_mask": keyMask,
+            "kv_cache_update_mask": updateMask,
+            "key_cache": state.keyCache,
+            "value_cache": state.valueCache,
+        ])
+
+        let output = try await model.compatPrediction(from: features, options: MLPredictionOptions())
+
+        guard let newKeyCache = output.featureValue(for: "new_key_cache")?.multiArrayValue,
+            let newValueCache = output.featureValue(for: "new_value_cache")?.multiArrayValue,
+            let hiddenStates = output.featureValue(for: "hidden_states")?.multiArrayValue,
+            let logits = output.featureValue(for: "logits")?.multiArrayValue
+        else {
+            throw TTSError.processingFailed("Missing CodeDecoder outputs")
+        }
+
+        state.keyCache = newKeyCache
+        state.valueCache = newValueCache
+        state.position += 1
+
+        return CodeDecoderOutput(logits: logits, hiddenStates: hiddenStates)
+    }
+
+    // MARK: - MultiCodeDecoder
+
+    /// Run MultiCodeDecoder to generate CB1-CB15 from hidden_states + CB0.
+    ///
+    /// Returns: (CB tokens, final key cache, final value cache)
+    /// The final KV caches can be reused as templates for the next frame.
+    private static func runMultiCodeDecoder(
+        hiddenStates: MLMultiArray,
+        cb0Token: Int,
+        codeEmbedder: MLModel,
+        multiCodeEmbedder: MLModel,
+        kvKeyTemplate: MLMultiArray?,
+        kvValTemplate: MLMultiArray?,
+        store: Qwen3TtsModelStore
+    ) async throws -> ([Int], MLMultiArray, MLMultiArray) {
+        let model = try await store.multiCodeDecoder()
+        let kvLen = Qwen3TtsConstants.mcdKvLen
+
+        // Get initial KV caches: either from cached template (subsequent frames)
+        // or from warmup prediction (first frame only)
+        var (mcdKey, mcdVal): (MLMultiArray, MLMultiArray)
+        if let keyTemplate = kvKeyTemplate, let valTemplate = kvValTemplate {
+            // Reuse previous frame's final KV caches as template, then zero them
+            mcdKey = keyTemplate
+            mcdVal = valTemplate
+            // Zero in-place
+            for i in 0..<mcdKey.count { mcdKey[i] = NSNumber(value: Float(0.0)) }
+            for i in 0..<mcdVal.count { mcdVal[i] = NSNumber(value: Float(0.0)) }
+        } else {
+            // First frame: run warmup prediction to get properly-strided arrays
+            (mcdKey, mcdVal) = try await getModelStridedKVCaches(model: model, kvLen: kvLen)
+        }
+
+        // Position 0: feed hidden_states
+        let (mask0, umask0) = try makeMcdMasks(pos: 0, kvLen: kvLen)
+        let cacheLen0 = try MLMultiArray(shape: [1], dataType: .int32)
+        cacheLen0[0] = NSNumber(value: 0)
+
+        let f16Hidden = try toFloat16(hiddenStates)
+        let feat0 = try MLDictionaryFeatureProvider(dictionary: [
+            "input_embeds": f16Hidden,
+            "cache_length": cacheLen0,
+            "key_cache": mcdKey,
+            "value_cache": mcdVal,
+            "key_padding_mask": mask0,
+            "kv_cache_update_mask": umask0,
+        ])
+        let out0 = try await model.compatPrediction(from: feat0, options: MLPredictionOptions())
+        mcdKey = out0.featureValue(for: "new_key_cache")!.multiArrayValue!
+        mcdVal = out0.featureValue(for: "new_value_cache")!.multiArrayValue!
+
+        // Position 1: feed CB0 embedding → lm_head[0] → CB1
+        let cb0Emb = try runCodeEmbedder(codeEmbedder, tokenId: cb0Token)
+        let (mask1, umask1) = try makeMcdMasks(pos: 1, kvLen: kvLen)
+        let cacheLen1 = try MLMultiArray(shape: [1], dataType: .int32)
+        cacheLen1[0] = NSNumber(value: 1)
+
+        let f16Cb0 = try toFloat16(cb0Emb)
+        let feat1 = try MLDictionaryFeatureProvider(dictionary: [
+            "input_embeds": f16Cb0,
+            "cache_length": cacheLen1,
+            "key_cache": mcdKey,
+            "value_cache": mcdVal,
+            "key_padding_mask": mask1,
+            "kv_cache_update_mask": umask1,
+        ])
+        let out1 = try await model.compatPrediction(from: feat1, options: MLPredictionOptions())
+        mcdKey = out1.featureValue(for: "new_key_cache")!.multiArrayValue!
+        mcdVal = out1.featureValue(for: "new_value_cache")!.multiArrayValue!
+
+        // CB1 from lm_head[0]
+        let allLogits1 = out1.featureValue(for: "all_logits")!.multiArrayValue!
+        var cb1Logits = extractSliceLogits(allLogits1, sliceIndex: 0)
+
+        let cb1 = sampleTopK(logits: &cb1Logits)
+        var cbTokens = [cb1]
+
+        // Positions 2-15: autoregressive decode for CB2-CB15
+        for cbStep in 1..<15 {
+            let prevCb = cbTokens.last!
+            let linIdx = (cbStep - 1) * Qwen3TtsConstants.codecVocabSize + prevCb
+            let cbEmb = try runMultiCodeEmbedder(multiCodeEmbedder, linearizedId: linIdx)
+
+            let mcdPos = cbStep + 1
+            let (mask, umask) = try makeMcdMasks(pos: mcdPos, kvLen: kvLen)
+            let cacheLen = try MLMultiArray(shape: [1], dataType: .int32)
+            cacheLen[0] = NSNumber(value: mcdPos)
+
+            let f16Emb = try toFloat16(cbEmb)
+            let feat = try MLDictionaryFeatureProvider(dictionary: [
+                "input_embeds": f16Emb,
+                "cache_length": cacheLen,
+                "key_cache": mcdKey,
+                "value_cache": mcdVal,
+                "key_padding_mask": mask,
+                "kv_cache_update_mask": umask,
+            ])
+            let out = try await model.compatPrediction(from: feat, options: MLPredictionOptions())
+            mcdKey = out.featureValue(for: "new_key_cache")!.multiArrayValue!
+            mcdVal = out.featureValue(for: "new_value_cache")!.multiArrayValue!
+
+            let allLogits = out.featureValue(for: "all_logits")!.multiArrayValue!
+            var cbLogits = extractSliceLogits(allLogits, sliceIndex: cbStep)
+            cbTokens.append(sampleTopK(logits: &cbLogits))
+        }
+
+        // Return CB tokens AND final KV caches (for reuse as templates in next frame)
+        return (cbTokens, mcdKey, mcdVal)
+    }
+
+    /// Create key_padding_mask and kv_cache_update_mask for MultiCodeDecoder.
+    private static func makeMcdMasks(
+        pos: Int, kvLen: Int
+    ) throws -> (MLMultiArray, MLMultiArray) {
+        let mask = try MLMultiArray(shape: [1, NSNumber(value: kvLen)], dataType: .float16)
+        let umask = try MLMultiArray(shape: [1, NSNumber(value: kvLen)], dataType: .float16)
+
+        for i in 0..<kvLen {
+            mask[i] = NSNumber(value: i <= pos ? Float(0.0) : Float(-10000.0))
+            umask[i] = NSNumber(value: i == pos ? Float(1.0) : Float(0.0))
+        }
+
+        return (mask, umask)
+    }
+
+    /// Get zero-initialized KV caches with the model's expected stride layout.
+    ///
+    /// CoreML compiled models use specific non-contiguous memory layouts.
+    /// The only reliable way to get properly-strided arrays is to run a
+    /// prediction and use the output KV caches, then zero them for reuse.
+    private static func getModelStridedKVCaches(
+        model: MLModel, kvLen: Int
+    ) async throws -> (MLMultiArray, MLMultiArray) {
+        // Create minimal inputs for a warmup prediction
+        let kvDim = Qwen3TtsConstants.mcdKvDim
+        let shape: [NSNumber] = [1, NSNumber(value: kvDim), 1, NSNumber(value: kvLen)]
+
+        // Use zero inputs — the output stride layout is what matters
+        let dummyInput = try MLMultiArray(shape: [1, 1024, 1, 1], dataType: .float16)
+        let dummyKey = try MLMultiArray(shape: shape, dataType: .float16)
+        let dummyVal = try MLMultiArray(shape: shape, dataType: .float16)
+        let mask = try MLMultiArray(shape: [1, NSNumber(value: kvLen)], dataType: .float16)
+        for i in 0..<kvLen {
+            mask[i] = NSNumber(value: Float(-10000.0))
+        }
+        let umask = try MLMultiArray(shape: [1, NSNumber(value: kvLen)], dataType: .float16)
+        let cacheLen = try MLMultiArray(shape: [1], dataType: .int32)
+
+        let feat = try MLDictionaryFeatureProvider(dictionary: [
+            "input_embeds": dummyInput,
+            "cache_length": cacheLen,
+            "key_cache": dummyKey,
+            "value_cache": dummyVal,
+            "key_padding_mask": mask,
+            "kv_cache_update_mask": umask,
+        ])
+
+        let out = try await model.compatPrediction(from: feat, options: MLPredictionOptions())
+        let outKey = out.featureValue(for: "new_key_cache")!.multiArrayValue!
+        let outVal = out.featureValue(for: "new_value_cache")!.multiArrayValue!
+
+        // Zero the caches while preserving their stride layout
+        for i in 0..<outKey.count { outKey[i] = NSNumber(value: Float(0.0)) }
+        for i in 0..<outVal.count { outVal[i] = NSNumber(value: Float(0.0)) }
+
+        return (outKey, outVal)
+    }
+
+    // MARK: - SpeechDecoder
+
+    /// Run the SpeechDecoder on all codec frames.
+    private static func runSpeechDecoder(
+        allFrames: [[Int]],
+        store: Qwen3TtsModelStore
+    ) async throws -> [Float] {
+        let model = try await store.speechDecoder()
+        let fixedLen = Qwen3TtsConstants.speechDecoderFrames  // 125
+        let numCb = Qwen3TtsConstants.numCodebooks  // 16
+
+        // Build codes tensor [1, 16, 125] int32
+        let codes = try MLMultiArray(
+            shape: [1, NSNumber(value: numCb), NSNumber(value: fixedLen)],
+            dataType: .int32
+        )
+
+        // Initialize to zero (pad) using subscript for stride safety
+        for i in 0..<(numCb * fixedLen) {
+            codes[i] = NSNumber(value: Int32(0))
+        }
+
+        // Fill: codes[0, cb, t] = allFrames[t][cb]
+        for t in 0..<min(allFrames.count, fixedLen) {
+            let frame = allFrames[t]
+            for cb in 0..<min(frame.count, numCb) {
+                codes[cb * fixedLen + t] = NSNumber(value: Int32(frame[cb]))
+            }
+        }
+
+        let features = try MLDictionaryFeatureProvider(dictionary: [
+            "audio_codes": codes
+        ])
+
+        let output = try await model.compatPrediction(from: features, options: MLPredictionOptions())
+
+        guard let audioArray = output.featureValue(for: "audio")?.multiArrayValue else {
+            throw TTSError.processingFailed("Missing SpeechDecoder output")
+        }
+
+        return extractFloatArray(from: audioArray)
+    }
+
+    // MARK: - Model Runners
+
+    /// TextProjector: text_token → embedding [1, 1024, 1, 1].
+    private static func runTextProjector(_ model: MLModel, tokenId: Int) throws -> MLMultiArray {
+        let inputIds = try MLMultiArray(shape: [1], dataType: .int32)
+        inputIds[0] = NSNumber(value: tokenId)
+
+        let features = try MLDictionaryFeatureProvider(dictionary: ["input_ids": inputIds])
+        let output = try model.prediction(from: features, options: MLPredictionOptions())
+
+        guard let embeds = output.featureValue(for: "input_embeds")?.multiArrayValue else {
+            throw TTSError.processingFailed("Missing TextProjector output")
+        }
+        return embeds
+    }
+
+    /// CodeEmbedder: codec_token → embedding [1, 1024, 1, 1].
+    private static func runCodeEmbedder(_ model: MLModel, tokenId: Int) throws -> MLMultiArray {
+        let inputIds = try MLMultiArray(shape: [1], dataType: .int32)
+        inputIds[0] = NSNumber(value: tokenId)
+
+        let features = try MLDictionaryFeatureProvider(dictionary: ["input_ids": inputIds])
+        let output = try model.prediction(from: features, options: MLPredictionOptions())
+
+        guard let embeds = output.featureValue(for: "input_embeds")?.multiArrayValue else {
+            throw TTSError.processingFailed("Missing CodeEmbedder output")
+        }
+        return embeds
+    }
+
+    /// MultiCodeEmbedder: linearized CB index → embedding [1, 1024, 1, 1].
+    private static func runMultiCodeEmbedder(
+        _ model: MLModel, linearizedId: Int
+    ) throws -> MLMultiArray {
+        let inputIds = try MLMultiArray(shape: [1], dataType: .int32)
+        inputIds[0] = NSNumber(value: linearizedId)
+
+        let features = try MLDictionaryFeatureProvider(dictionary: ["input_ids": inputIds])
+        let output = try model.prediction(from: features, options: MLPredictionOptions())
+
+        guard let embeds = output.featureValue(for: "input_embeds")?.multiArrayValue else {
+            throw TTSError.processingFailed("Missing MultiCodeEmbedder output")
+        }
+        return embeds
+    }
+
+    // MARK: - Sampling
+
+    /// Suppress control tokens [2048, 3072) except EOS (2150).
+    private static func suppressControlTokens(_ logits: inout [Float]) {
+        let eosToken = Qwen3TtsConstants.codecEosId
+        let vocabSize = Qwen3TtsConstants.codecVocabSize
+
+        // Save EOS logit before suppression
+        let eosLogit = eosToken < logits.count ? logits[eosToken] : -Float.infinity
+
+        // Suppress [2048, 3072)
+        for i in vocabSize..<min(3072, logits.count) {
+            logits[i] = -.infinity
+        }
+
+        // Restore EOS
+        if eosToken < logits.count {
+            logits[eosToken] = eosLogit
+        }
+    }
+
+    /// Suppress EOS token (for min_new_tokens enforcement).
+    private static func suppressEos(_ logits: inout [Float]) {
+        let eosToken = Qwen3TtsConstants.codecEosId
+        if eosToken < logits.count {
+            logits[eosToken] = -.infinity
+        }
+    }
+
+    /// Apply repetition penalty to already-generated tokens.
+    private static func applyRepetitionPenalty(
+        _ logits: inout [Float], generatedIds: [Int]
+    ) {
+        let penalty = Qwen3TtsConstants.repetitionPenalty
+        guard penalty != 1.0 else { return }
+
+        let seen = Set(generatedIds)
+        for tokenId in seen {
+            guard tokenId < logits.count else { continue }
+            if logits[tokenId] > 0 {
+                logits[tokenId] /= penalty
+            } else {
+                logits[tokenId] *= penalty
+            }
+        }
+    }
+
+    /// Sample from logits with temperature + top-k.
+    private static func sampleTopK(
+        logits: inout [Float],
+        temperature: Float = Qwen3TtsConstants.temperature,
+        topK: Int = Qwen3TtsConstants.topK
+    ) -> Int {
+        let count = logits.count
+        guard count > 0 else { return 0 }
+
+        // Apply temperature
+        for i in 0..<count {
+            logits[i] /= temperature
+        }
+
+        // Top-k filtering
+        if topK > 0 && topK < count {
+            var sorted = logits
+            sorted.sort(by: >)
+            let threshold = sorted[topK - 1]
+            for i in 0..<count where logits[i] < threshold {
+                logits[i] = -.infinity
+            }
+        }
+
+        // Softmax
+        let maxLogit = logits.max() ?? 0
+        var expSum: Float = 0
+        var expLogits = [Float](repeating: 0, count: count)
+        for i in 0..<count {
+            let e = exp(logits[i] - maxLogit)
+            expLogits[i] = e
+            expSum += e
+        }
+
+        // Multinomial sampling
+        let r = Float.random(in: 0..<1)
+        var cumulative: Float = 0
+        for i in 0..<count {
+            cumulative += expLogits[i] / expSum
+            if cumulative >= r {
+                return i
+            }
+        }
+
+        return count - 1
+    }
+
+    /// Extract logits for a specific lm_head slice from all_logits.
+    ///
+    /// all_logits shape from MultiCodeDecoder: [1, 15, 2048].
+    /// We extract [0, sliceIndex, :] and return as [Float].
+    private static func extractSliceLogits(
+        _ allLogits: MLMultiArray, sliceIndex: Int
+    ) -> [Float] {
+        let vocabSize = Qwen3TtsConstants.codecVocabSize
+        let offset = sliceIndex * vocabSize
+
+        var result = [Float](repeating: 0, count: vocabSize)
+        for i in 0..<vocabSize {
+            result[i] = allLogits[offset + i].floatValue
+        }
+        return result
+    }
+
+    // MARK: - Audio Post-Processing
+
+    /// Trim leading and trailing silence from audio samples.
+    private static func trimSilence(
+        _ samples: [Float],
+        sampleRate: Int,
+        threshold: Float = 0.005,
+        windowMs: Int = 10,
+        padMs: Int = 20
+    ) -> [Float] {
+        let windowSize = sampleRate * windowMs / 1000
+        let padSize = sampleRate * padMs / 1000
+        guard samples.count > windowSize else { return samples }
+
+        // Find first non-silent window
+        var start = 0
+        for i in stride(from: 0, to: samples.count - windowSize, by: windowSize) {
+            var sum: Float = 0
+            for j in i..<(i + windowSize) {
+                sum += samples[j] * samples[j]
+            }
+            let rms = (sum / Float(windowSize)).squareRoot()
+            if rms > threshold {
+                start = max(0, i - padSize)
+                break
+            }
+        }
+
+        // Find last non-silent window
+        let bigWindow = sampleRate / 5
+        var end = samples.count
+        for i in stride(from: samples.count - bigWindow, through: 0, by: -windowSize) {
+            let windowEnd = min(i + bigWindow, samples.count)
+            var sum: Float = 0
+            for j in i..<windowEnd {
+                sum += samples[j] * samples[j]
+            }
+            let rms = (sum / Float(windowEnd - i)).squareRoot()
+            if rms > threshold {
+                end = min(samples.count, windowEnd + padSize)
+                break
+            }
+        }
+
+        guard start < end else { return samples }
+        return Array(samples[start..<end])
+    }
+
+    // MARK: - MLMultiArray Helpers
+
+    /// Extract Float array from MLMultiArray using subscript access (stride-safe).
+    private static func extractFloatArray(from array: MLMultiArray) -> [Float] {
+        let count = array.count
+        var result = [Float](repeating: 0, count: count)
+        for i in 0..<count {
+            result[i] = array[i].floatValue
+        }
+        return result
+    }
+
+    /// Create [1, 1024, 1, 1] float32 embedding from Float array.
+    private static func createEmbedding(from data: [Float]) throws -> MLMultiArray {
+        let dim = data.count
+        let array = try MLMultiArray(
+            shape: [1, NSNumber(value: dim), 1, 1], dataType: .float32)
+        for (i, value) in data.enumerated() {
+            array[i] = NSNumber(value: value)
+        }
+        return array
+    }
+
+    /// Add two embedding MLMultiArrays element-wise.
+    private static func addEmbeddings(_ a: MLMultiArray, _ b: MLMultiArray) throws -> MLMultiArray {
+        let count = a.count
+        let result = try MLMultiArray(shape: a.shape, dataType: .float32)
+        for i in 0..<count {
+            result[i] = NSNumber(value: a[i].floatValue + b[i].floatValue)
+        }
+        return result
+    }
+
+    /// Convert MLMultiArray to float16, preserving stride layout.
+    ///
+    /// If already float16, returns as-is. CoreML models expect their own output
+    /// stride layout, so we must not make non-contiguous arrays contiguous.
+    private static func toFloat16(_ array: MLMultiArray) throws -> MLMultiArray {
+        if array.dataType == .float16 { return array }
+        let count = array.count
+        let result = try MLMultiArray(shape: array.shape, dataType: .float16)
+        for i in 0..<count {
+            result[i] = array[i]
+        }
+        return result
+    }
+
+}
diff --git a/Sources/FluidAudio/TTS/TtsBackend.swift b/Sources/FluidAudio/TTS/TtsBackend.swift
index e230bc4cc..e03871ad8 100644
--- a/Sources/FluidAudio/TTS/TtsBackend.swift
+++ b/Sources/FluidAudio/TTS/TtsBackend.swift
@@ -6,4 +6,6 @@ public enum TtsBackend: Sendable {
     case kokoro
     /// PocketTTS — flow-matching language model, autoregressive streaming synthesis.
     case pocketTts
+    /// Qwen3-TTS — large language model-based multilingual TTS (English, Chinese).
+    case qwen3Tts
 }
diff --git a/Sources/FluidAudio/TTS/TtsModels.swift b/Sources/FluidAudio/TTS/TtsModels.swift
index b4d4b2996..5fe33c8bd 100644
--- a/Sources/FluidAudio/TTS/TtsModels.swift
+++ b/Sources/FluidAudio/TTS/TtsModels.swift
@@ -152,11 +152,25 @@ public struct TtsModels: Sendable {
                 randomPhases[index] = NSNumber(value: Float(0))
             }
 
+            // Source noise for newer Kokoro models
+            let maxSeconds = variant.maxDurationSeconds
+            let noiseLength = TtsConstants.audioSampleRate * maxSeconds
+            let sourceNoise = try MLMultiArray(
+                shape: [1, NSNumber(value: noiseLength), 9],
+                dataType: .float16
+            )
+            let noisePointer = sourceNoise.dataPointer.bindMemory(to: UInt16.self, capacity: noiseLength * 9)
+            for i in 0..<(noiseLength * 9) {
+                let randomValue = Float.random(in: -1...1)
+                noisePointer[i] = Float16(randomValue).bitPattern
+            }
+
             let features = try MLDictionaryFeatureProvider(dictionary: [
                 "input_ids": inputIds,
                 "attention_mask": attentionMask,
                 "ref_s": refStyle,
                 "random_phases": randomPhases,
+                "source_noise": sourceNoise,
             ])
 
             let options: MLPredictionOptions = optimizedPredictionOptions()
diff --git a/Sources/FluidAudioCLI/Commands/TTSCommand.swift b/Sources/FluidAudioCLI/Commands/TTSCommand.swift
index b3dd4b765..2542e635f 100644
--- a/Sources/FluidAudioCLI/Commands/TTSCommand.swift
+++ b/Sources/FluidAudioCLI/Commands/TTSCommand.swift
@@ -143,6 +143,7 @@ public struct TTS {
         var benchmarkMode = false
         var deEss = true
         var backend: TtsBackend = .kokoro
+        var lang = "english"
         var cloneVoicePath: String? = nil
         var voiceFilePath: String? = nil
         var saveVoicePath: String? = nil
@@ -200,11 +201,18 @@ public struct TTS {
                         backend = .kokoro
                     case "pocket", "pockettts":
                         backend = .pocketTts
+                    case "qwen3", "qwen3tts":
+                        backend = .qwen3Tts
                     default:
                         logger.warning("Unknown backend '\(arguments[i + 1])'; using kokoro")
                     }
                     i += 1
                 }
+            case "--lang":
+                if i + 1 < arguments.count {
+                    lang = arguments[i + 1].lowercased()
+                    i += 1
+                }
             case "--auto-download":
                 // No-op: downloads are always ensured by the CLI
                 ()
@@ -262,6 +270,11 @@ public struct TTS {
             return
         }
 
+        if backend == .qwen3Tts {
+            await runQwen3Tts(text: text, output: output, language: lang, metricsPath: metricsPath)
+            return
+        }
+
         do {
             // Timing buckets
             let tStart = Date()
@@ -640,6 +653,154 @@ public struct TTS {
         }
     }
 
+    private static func runQwen3Tts(
+        text: String,
+        output: String,
+        language: String = "english",
+        metricsPath: String?
+    ) async {
+        do {
+            let tStart = Date()
+
+            // Qwen3 TTS requires pre-tokenized input
+            // For now, use hardcoded token IDs for common test sentences
+            // TODO: Add proper tokenizer support
+            let tokenIds: [Int]
+            let normalizedText = text.lowercased()
+
+            if normalizedText.contains("hello world") && normalizedText.contains("test") {
+                // "Hello world, this is a test of the text to speech system."
+                // Token IDs from Qwen3 tokenizer (verified via Python tokenize())
+                tokenIds = [9707, 1879, 11, 419, 374, 264, 1273, 315, 279, 1467, 311, 8806, 1849, 13]
+            } else if text.contains("你好世界") {
+                // "你好世界，这是一个文字转语音系统的测试。"
+                // Token IDs from Qwen3 processor for Chinese test sentence
+                tokenIds = [108386, 99489, 3837, 105464, 87335, 46670, 105761, 105743, 81705, 1773]
+            } else {
+                logger.error(
+                    "Qwen3-TTS requires pre-tokenized input. Supported test sentences:\n"
+                        + "  English: 'Hello world, this is a test of the text to speech system.'\n"
+                        + "  Chinese: '你好世界，这是一个文字转语音系统的测试。'")
+                exit(1)
+            }
+
+            let manager = Qwen3TtsManager()
+
+            let tLoad0 = Date()
+            if let envPath = ProcessInfo.processInfo.environment["QWEN3_TTS_MODEL_DIR"] {
+                let modelDir = URL(fileURLWithPath: envPath)
+                logger.info("Loading Qwen3-TTS models from: \(modelDir.path)")
+                try await manager.loadFromDirectory(modelDir)
+            } else {
+                logger.info("Downloading/loading Qwen3-TTS models from HuggingFace...")
+                try await manager.initialize()
+            }
+            let tLoad1 = Date()
+
+            let tSynth0 = Date()
+            let wav = try await manager.synthesize(
+                text: text,
+                tokenIds: tokenIds,
+                useSpeaker: true,
+                language: language
+            )
+            let tSynth1 = Date()
+
+            let outURL = {
+                let expanded = (output as NSString).expandingTildeInPath
+                if expanded.hasPrefix("/") {
+                    return URL(fileURLWithPath: expanded)
+                }
+                let cwd = URL(
+                    fileURLWithPath: FileManager.default.currentDirectoryPath,
+                    isDirectory: true)
+                return cwd.appendingPathComponent(expanded)
+            }()
+
+            try FileManager.default.createDirectory(
+                at: outURL.deletingLastPathComponent(),
+                withIntermediateDirectories: true)
+            try wav.write(to: outURL)
+
+            let loadS = tLoad1.timeIntervalSince(tLoad0)
+            let synthS = tSynth1.timeIntervalSince(tSynth0)
+            let totalS = tSynth1.timeIntervalSince(tStart)
+            let sampleRate = Double(Qwen3TtsConstants.audioSampleRate)
+            let payload = max(0, wav.count - 44)
+            let audioSecs = Double(payload) / (sampleRate * 2.0)
+            let rtfx = synthS > 0 ? audioSecs / synthS : 0
+
+            logger.info("Qwen3-TTS synthesis complete")
+            logger.info("  Load: \(String(format: "%.3f", loadS))s")
+            logger.info("  Synthesis: \(String(format: "%.3f", synthS))s")
+            logger.info("  Audio: \(String(format: "%.3f", audioSecs))s")
+            logger.info("  RTFx: \(String(format: "%.2f", rtfx))x")
+            logger.info("  Total: \(String(format: "%.3f", totalS))s")
+            logger.info("  Output: \(outURL.path)")
+
+            // ASR round-trip evaluation
+            var asrHypothesis: String? = nil
+            var werValue: Double? = nil
+
+            if metricsPath != nil {
+                logger.info("--- Running ASR for TTS→STT evaluation ---")
+                do {
+                    let asrModels = try await AsrModels.downloadAndLoad()
+                    let asr = AsrManager()
+                    try await asr.initialize(models: asrModels)
+
+                    let transcription = try await asr.transcribe(outURL)
+                    asrHypothesis = transcription.text
+
+                    let werMetrics = WERCalculator.calculateWERMetrics(
+                        hypothesis: transcription.text, reference: text)
+                    werValue = werMetrics.wer
+
+                    logger.info("Reference:  \(text)")
+                    logger.info("Hypothesis: \(transcription.text)")
+                    logger.info(String(format: "WER: %.1f%%", werValue! * 100))
+
+                    asr.cleanup()
+                } catch {
+                    logger.warning("ASR evaluation failed: \(error.localizedDescription)")
+                }
+            }
+
+            if let metricsPath {
+                var metricsDict: [String: Any] = [
+                    "backend": "qwen3tts",
+                    "text": text,
+                    "output": outURL.path,
+                    "model_load_time_s": loadS,
+                    "inference_time_s": synthS,
+                    "audio_duration_s": audioSecs,
+                    "realtime_speed": rtfx,
+                    "total_time_s": totalS,
+                ]
+                if let asrHypothesis {
+                    metricsDict["asr_hypothesis"] = asrHypothesis
+                }
+                if let werValue {
+                    metricsDict["wer"] = werValue
+                }
+
+                let artifactsRoot = try ensureArtifactsRoot()
+                let mURL = resolveOutputURL(
+                    metricsPath, artifactsRoot: artifactsRoot, expectsDirectory: false)
+                try FileManager.default.createDirectory(
+                    at: mURL.deletingLastPathComponent(), withIntermediateDirectories: true)
+                let json = try JSONSerialization.data(
+                    withJSONObject: metricsDict, options: [.prettyPrinted])
+                try json.write(to: mURL)
+                logger.info("Metrics saved: \(mURL.path)")
+            }
+        } catch {
+            logger.error("Qwen3-TTS Error: \(error)")
+            print("Qwen3-TTS failed: \(error)")
+            exit(1)
+        }
+    }
+
     private static func printUsage() {
         print(
             """
@@ -648,7 +809,7 @@ public struct TTS {
             Options:
               --output, -o         Output WAV path (default: output.wav)
               --voice, -v          Voice name (default: af_heart for Kokoro, alba for PocketTTS)
-              --backend            TTS backend: kokoro (default) or pocket
+              --backend            TTS backend: kokoro (default), pocket, or qwen3
               --lexicon, -l        Custom pronunciation lexicon file (word=phonemes format, Kokoro only)
               --benchmark          Run a predefined benchmarking suite with multiple sentences
               --variant            Force Kokoro 5s or 15s model (values: 5s,15s)
@@ -663,6 +824,12 @@ public struct TTS {
               --voice-file FILE    Load previously saved voice .bin file
               --save-voice FILE    Save cloned voice to .bin file for later use
 
+            Qwen3-TTS Options:
+              --lang               Language: english (default), chinese, german, french, etc.
+              Models auto-download from HuggingFace on first use (~1GB)
+              Set QWEN3_TTS_MODEL_DIR env var to use a local model directory instead
+              Currently only supports pre-tokenized test sentences
+
             Lexicon file format:
               # Comments start with #
               kokoro=kəkˈɔɹO
diff --git a/Tests/FluidAudioTests/ASR/ModelNamesTests.swift b/Tests/FluidAudioTests/ASR/ModelNamesTests.swift
index fb73b1284..8f108a879 100644
--- a/Tests/FluidAudioTests/ASR/ModelNamesTests.swift
+++ b/Tests/FluidAudioTests/ASR/ModelNamesTests.swift
@@ -8,10 +8,12 @@ final class ModelNamesTests: XCTestCase {
     // MARK: - Repo
 
     func testRepoRemotePathContainsOwner() {
+        let validOwners = ["FluidInference/", "alexwengg/"]
         for repo in Repo.allCases {
+            let hasValidOwner = validOwners.contains(where: { repo.remotePath.contains($0) })
             XCTAssertTrue(
-                repo.remotePath.contains("FluidInference/"),
-                "\(repo) remotePath should contain 'FluidInference/'"
+                hasValidOwner,
+                "\(repo) remotePath should contain a valid owner prefix"
             )
         }
     }
@@ -48,7 +50,7 @@ final class ModelNamesTests: XCTestCase {
     }
 
     func testModelFileExtensions() {
-        let validExtensions: Set<String> = [".mlmodelc", ".json", ".bin"]
+        let validExtensions: Set<String> = [".mlmodelc", ".json", ".bin", ".npy"]
         let validDirectories: Set<String> = ["constants_bin"]
 
         for repo in Repo.allCases {
diff --git a/Tests/FluidAudioTests/TTS/Qwen3TtsTests.swift b/Tests/FluidAudioTests/TTS/Qwen3TtsTests.swift
new file mode 100644
index 000000000..a99489d0e
--- /dev/null
+++ b/Tests/FluidAudioTests/TTS/Qwen3TtsTests.swift
@@ -0,0 +1,125 @@
+import Foundation
+import XCTest
+
+@testable import FluidAudio
+
+final class Qwen3TtsConstantsTests: XCTestCase {
+
+    // MARK: - Constants Validation
+
+    func testAudioSampleRate() {
+        XCTAssertEqual(Qwen3TtsConstants.audioSampleRate, 24_000)
+    }
+
+    func testSamplesPerFrame() {
+        XCTAssertEqual(Qwen3TtsConstants.samplesPerFrame, 1_920)
+    }
+
+    func testMaxCodecTokens() {
+        XCTAssertGreaterThan(Qwen3TtsConstants.maxCodecTokens, 0)
+        XCTAssertEqual(Qwen3TtsConstants.maxCodecTokens, 125)
+    }
+
+    func testCodecEosId() {
+        XCTAssertEqual(Qwen3TtsConstants.codecEosId, 2150)
+    }
+
+    func testCodecSpecialTokens() {
+        XCTAssertEqual(Qwen3TtsConstants.codecPadId, 2148)
+        XCTAssertEqual(Qwen3TtsConstants.codecBosId, 2149)
+        XCTAssertEqual(Qwen3TtsConstants.codecEosId, 2150)
+        XCTAssertEqual(Qwen3TtsConstants.codecThinkId, 2154)
+        XCTAssertEqual(Qwen3TtsConstants.codecNoThinkId, 2155)
+        XCTAssertEqual(Qwen3TtsConstants.codecThinkBosId, 2156)
+        XCTAssertEqual(Qwen3TtsConstants.codecThinkEosId, 2157)
+    }
+
+    func testLanguageIds() {
+        XCTAssertEqual(Qwen3TtsConstants.languageIds["english"], 2050)
+        XCTAssertEqual(Qwen3TtsConstants.languageIds["chinese"], 2055)
+        XCTAssertEqual(Qwen3TtsConstants.languageIds.count, 10)
+    }
+
+    func testKvCacheDimensions() {
+        // CodeDecoder
+        XCTAssertEqual(Qwen3TtsConstants.cdKvLen, 256)
+        XCTAssertEqual(Qwen3TtsConstants.cdKvDim, 28_672)
+        // MultiCodeDecoder
+        XCTAssertEqual(Qwen3TtsConstants.mcdKvLen, 16)
+        XCTAssertEqual(Qwen3TtsConstants.mcdKvDim, 5_120)
+    }
+
+    func testModelDimensions() {
+        XCTAssertEqual(Qwen3TtsConstants.hiddenSize, 1024)
+        XCTAssertEqual(Qwen3TtsConstants.numCodebooks, 16)
+        XCTAssertEqual(Qwen3TtsConstants.codecVocabSize, 2048)
+    }
+
+    func testSamplingParameters() {
+        XCTAssertEqual(Qwen3TtsConstants.temperature, 0.9)
+        XCTAssertEqual(Qwen3TtsConstants.topK, 50)
+        XCTAssertGreaterThan(Qwen3TtsConstants.repetitionPenalty, 1.0)
+    }
+
+    func testMinNewTokensIsReasonable() {
+        XCTAssertGreaterThanOrEqual(Qwen3TtsConstants.minNewTokens, 0)
+        XCTAssertLessThan(Qwen3TtsConstants.minNewTokens, Qwen3TtsConstants.maxCodecTokens)
+    }
+
+    func testSpeechDecoderFrames() {
+        XCTAssertEqual(Qwen3TtsConstants.speechDecoderFrames, 125)
+    }
+
+    // MARK: - Model Names
+
+    func testQwen3TtsRequiredModelsNonEmpty() {
+        XCTAssertFalse(ModelNames.Qwen3TTS.requiredModels.isEmpty)
+    }
+
+    func testQwen3TtsRequiredModelsContainCoreModels() {
+        let required = ModelNames.Qwen3TTS.requiredModels
+        XCTAssertTrue(required.contains(ModelNames.Qwen3TTS.textProjectorFile))
+        XCTAssertTrue(required.contains(ModelNames.Qwen3TTS.codeEmbedderFile))
+        XCTAssertTrue(required.contains(ModelNames.Qwen3TTS.multiCodeEmbedderFile))
+        XCTAssertTrue(required.contains(ModelNames.Qwen3TTS.codeDecoderFile))
+        XCTAssertTrue(required.contains(ModelNames.Qwen3TTS.multiCodeDecoderFile))
+        XCTAssertTrue(required.contains(ModelNames.Qwen3TTS.speechDecoderFile))
+    }
+
+    func testQwen3TtsRequiredModelsCount() {
+        XCTAssertEqual(ModelNames.Qwen3TTS.requiredModels.count, 6)
+    }
+
+    func testQwen3TtsModelFilesHaveExtensions() {
+        for model in ModelNames.Qwen3TTS.requiredModels {
+            XCTAssertTrue(model.hasSuffix(".mlmodelc"), "Model '\(model)' should have .mlmodelc extension")
+        }
+    }
+
+    func testQwen3TtsSpeakerEmbeddingNotInRequired() {
+        let required = ModelNames.Qwen3TTS.requiredModels
+        XCTAssertFalse(required.contains(ModelNames.Qwen3TTS.speakerEmbeddingFile))
+    }
+
+    // MARK: - Repo
+
+    func testQwen3TtsRepoName() {
+        XCTAssertEqual(Repo.qwen3Tts.name, "qwen3-tts-coreml")
+    }
+
+    func testQwen3TtsRepoRemotePath() {
+        XCTAssertTrue(Repo.qwen3Tts.remotePath.contains("qwen3-tts-coreml"))
+    }
+
+    func testQwen3TtsRepoFolderName() {
+        XCTAssertFalse(Repo.qwen3Tts.folderName.isEmpty)
+    }
+
+    // MARK: - Manager
+
+    func testQwen3TtsManagerInitialState() async {
+        let manager = Qwen3TtsManager()
+        let available = await manager.isAvailable
+        XCTAssertFalse(available, "Manager should not be available before loading models")
+    }
+}