Text-to-Speech with TTSKit

import TTSKit

Task {
    let tts = try await TTSKit()
    let result = try await tts.generate(text: "Hello from TTSKit!")
    print("Generated \(result.audioDuration)s of audio at \(result.sampleRate)Hz")
}

try await tts.play(text: "This starts playing before generation finishes.")

// Fast, works on all platforms (~1 GB)
let tts = try await TTSKit(
    TTSKitConfig(model: .qwen3TTS_0_6b)
)

// Higher quality, macOS only (~2.2 GB, supports style instructions)
let tts = try await TTSKit(
    TTSKitConfig(model: .qwen3TTS_1_7b)
)

let result = try await tts.generate(
    text: "Hello world",
    speaker: .ryan,    // or .aiden, .onoAnna, .sohee, .eric, .dylan, .serena, .vivian, .uncleFu
    language: .english
)

// Japanese
let result = try await tts.generate(
    text: "こんにちは世界",
    speaker: .onoAnna,
    language: .japanese
)

// Spanish
let result = try await tts.generate(
    text: "Hola mundo",
    speaker: .serena,
    language: .spanish
)

var options = GenerationOptions()
options.temperature = 0.9
options.topK = 50
options.repetitionPenalty = 1.05
options.maxNewTokens = 245

// Auto-split long text at sentence boundaries
options.chunkingStrategy = .sentence

// Run all chunks concurrently (nil = auto)
options.concurrentWorkerCount = nil

let result = try await tts.generate(
    text: longArticle,
    speaker: .ryan,
    language: .english,
    options: options
)

var options = GenerationOptions()
options.instruction = "Speak slowly and warmly, like a storyteller."

let result = try await tts.generate(
    text: "Once upon a time...",
    speaker: .ryan,
    options: options
)

// Auto: Measures first step, buffers just enough to avoid underruns
try await tts.play(
    text: "Long passage...",
    playbackStrategy: .auto
)

// Stream: Immediate playback, no pre-buffer
try await tts.play(
    text: "Real-time speech",
    playbackStrategy: .stream
)

// Buffered: Fixed pre-buffer duration
try await tts.play(
    text: "Smooth playback",
    playbackStrategy: .buffered(seconds: 2.0)
)

// GenerateFirst: Generate all audio first, then play
try await tts.play(
    text: "Complete before play",
    playbackStrategy: .generateFirst
)

let result = try await tts.generate(text: "Save me!")
let outputDir = FileManager.default.urls(
    for: .documentDirectory,
    in: .userDomainMask
)[0]

// Save as WAV
try await AudioOutput.saveAudio(
    result.audio,
    toFolder: outputDir,
    filename: "output",
    format: .wav
)

// Save as M4A (AAC)
try await AudioOutput.saveAudio(
    result.audio,
    toFolder: outputDir,
    filename: "output",
    format: .m4a
)

let result = try await tts.generate(
    text: "Hello!"
) { progress in
    print("Audio chunk: \(progress.audio.count) samples")
    
    if let stepTime = progress.stepTime {
        print("First step took \(stepTime)s")
    }
    
    // Return false to cancel early
    return true
}

import SwiftUI
import TTSKit

struct TTSView: View {
    @StateObject private var viewModel = TTSViewModel()
    @State private var inputText = "Hello from TTSKit!"
    @State private var selectedSpeaker: Qwen3Speaker = .ryan
    @State private var selectedLanguage: Qwen3Language = .english
    
    var body: some View {
        VStack(spacing: 20) {
            // Input
            TextEditor(text: $inputText)
                .frame(height: 100)
                .border(Color.gray, width: 1)
            
            // Voice selection
            HStack {
                Text("Speaker:")
                Picker("Speaker", selection: $selectedSpeaker) {
                    Text("Ryan").tag(Qwen3Speaker.ryan)
                    Text("Aiden").tag(Qwen3Speaker.aiden)
                    Text("Ono Anna").tag(Qwen3Speaker.onoAnna)
                    Text("Sohee").tag(Qwen3Speaker.sohee)
                }
            }
            
            // Language selection
            HStack {
                Text("Language:")
                Picker("Language", selection: $selectedLanguage) {
                    Text("English").tag(Qwen3Language.english)
                    Text("Japanese").tag(Qwen3Language.japanese)
                    Text("Spanish").tag(Qwen3Language.spanish)
                }
            }
            
            // Controls
            HStack {
                Button("Generate") {
                    Task {
                        await viewModel.generate(
                            text: inputText,
                            speaker: selectedSpeaker,
                            language: selectedLanguage
                        )
                    }
                }
                .disabled(viewModel.isGenerating)
                
                Button("Play") {
                    Task {
                        await viewModel.playGenerated()
                    }
                }
                .disabled(viewModel.audioSamples.isEmpty || viewModel.isPlaying)
            }
            
            // Waveform visualization
            if !viewModel.waveform.isEmpty {
                WaveformView(samples: viewModel.waveform)
                    .frame(height: 100)
            }
            
            // Status
            Text(viewModel.statusMessage)
                .foregroundColor(.secondary)
            
            if viewModel.isGenerating {
                ProgressView()
            }
        }
        .padding()
        .task {
            await viewModel.loadModel()
        }
    }
}

@MainActor
class TTSViewModel: ObservableObject {
    @Published var statusMessage = "Loading model..."
    @Published var isGenerating = false
    @Published var isPlaying = false
    @Published var audioSamples: [Float] = []
    @Published var waveform: [Float] = []
    @Published var audioDuration: TimeInterval = 0
    
    private var ttsKit: TTSKit?
    private var audioPlayer: AVAudioPlayer?
    
    func loadModel() async {
        do {
            ttsKit = try await TTSKit(TTSKitConfig(model: .qwen3TTS_0_6b))
            statusMessage = "Ready"
        } catch {
            statusMessage = "Failed to load model: \(error)"
        }
    }
    
    func generate(text: String, speaker: Qwen3Speaker, language: Qwen3Language) async {
        guard let ttsKit = ttsKit else { return }
        
        isGenerating = true
        statusMessage = "Generating..."
        waveform = []
        
        do {
            let result = try await ttsKit.generate(
                text: text,
                speaker: speaker,
                language: language
            ) { progress in
                // Collect waveform peaks
                let peak = progress.audio.reduce(Float(0)) { max($0, abs($1)) }
                Task { @MainActor in
                    self.waveform.append(peak)
                }
                return true
            }
            
            audioSamples = result.audio
            audioDuration = result.audioDuration
            statusMessage = String(format: "Generated %.1fs (RTF: %.2f)",
                                 result.audioDuration,
                                 result.timings.realTimeFactor)
        } catch {
            statusMessage = "Error: \(error)"
        }
        
        isGenerating = false
    }
    
    func playGenerated() async {
        guard let ttsKit = ttsKit, !audioSamples.isEmpty else { return }
        
        do {
            // Save to temporary file
            let tempURL = FileManager.default.temporaryDirectory
                .appendingPathComponent("temp_audio.wav")
            
            try await AudioOutput.saveAudio(
                audioSamples,
                toFolder: tempURL.deletingLastPathComponent(),
                filename: "temp_audio",
                format: .wav
            )
            
            // Play with AVAudioPlayer
            audioPlayer = try AVAudioPlayer(contentsOf: tempURL)
            audioPlayer?.play()
            isPlaying = true
            statusMessage = "Playing..."
            
            // Wait for playback to finish
            try await Task.sleep(for: .seconds(audioDuration))
            
            isPlaying = false
            statusMessage = "Playback complete"
            
        } catch {
            statusMessage = "Playback error: \(error)"
            isPlaying = false
        }
    }
}

struct WaveformView: View {
    let samples: [Float]
    
    var body: some View {
        GeometryReader { geometry in
            HStack(spacing: 1) {
                ForEach(samples.indices, id: \.self) { index in
                    RoundedRectangle(cornerRadius: 2)
                        .fill(Color.blue)
                        .frame(
                            width: 2,
                            height: CGFloat(samples[index]) * geometry.size.height
                        )
                }
            }
        }
    }
}

# Generate and play speech
swift run whisperkit-cli tts \
    --text "Hello from the command line" \
    --play

# Save to file
swift run whisperkit-cli tts \
    --text "Save to file" \
    --output-path output.wav

# Japanese with specific speaker
swift run whisperkit-cli tts \
    --text "日本語テスト" \
    --speaker ono-anna \
    --language japanese

# Use 1.7B model with style instruction
swift run whisperkit-cli tts \
    --text-file article.txt \
    --model 1.7b \
    --instruction "Read cheerfully"

# See all options
swift run whisperkit-cli tts --help

let config = TTSKitConfig(
    model: .qwen3TTS_0_6b,
    computeOptions: ComputeOptions(
        embedderComputeUnits: .cpuOnly,
        codeDecoderComputeUnits: .cpuAndNeuralEngine,
        multiCodeDecoderComputeUnits: .cpuAndNeuralEngine,
        speechDecoderComputeUnits: .cpuAndNeuralEngine
    )
)

let tts = try await TTSKit(config)

var options = GenerationOptions()

// Use 4 concurrent workers
options.concurrentWorkerCount = 4

// Or let TTSKit decide (recommended)
options.concurrentWorkerCount = nil