Quick Start

import WhisperKit

Task {
    // Initialize WhisperKit with default settings
    let pipe = try? await WhisperKit()
    
    // Transcribe audio file
    let result = try? await pipe!.transcribe(
        audioPath: "path/to/your/audio.wav"
    )
    
    // Print transcription
    if let result = result {
        print(result.first?.text ?? "")
    }
}

// Use a specific model by name
let pipe = try await WhisperKit(
    model: "large-v3"
)

// Use glob patterns for fuzzy matching
let pipe = try await WhisperKit(
    model: "distil*large-v3"  // Matches distil-large-v3
)

let pipe = try await WhisperKit()

// Detect language from file
let (language, langProbs) = try await pipe.detectLanguage(
    audioPath: "audio.wav"
)

print("Detected language: \(language)")
print("Confidence scores: \(langProbs)")
// Output: Detected language: en
// Confidence scores: ["en": 0.98, "es": 0.01, ...]

let pipe = try await WhisperKit()

let audioPaths = [
    "audio1.wav",
    "audio2.mp3",
    "audio3.m4a"
]

// Transcribe all files with concurrent processing
var options = DecodingOptions()
options.concurrentWorkerCount = 3  // Process 3 files at once

let results = await pipe.transcribe(
    audioPaths: audioPaths,
    decodeOptions: options
)

// Results maintain input order
for (path, result) in zip(audioPaths, results) {
    if let transcription = result?.first?.text {
        print("\(path): \(transcription)")
    }
}

import WhisperKit

// Load from custom HuggingFace repo
let config = WhisperKitConfig(
    model: "large-v3",
    modelRepo: "username/your-model-repo"  // Your HF repo
)

let pipe = try await WhisperKit(config)

import TTSKit

Task {
    // Initialize TTSKit (auto-downloads 0.6B model on first run)
    let tts = try await TTSKit()
    
    // Generate speech
    let result = try await tts.generate(
        text: "Hello from TTSKit!"
    )
    
    print("Generated \(result.audioDuration)s of audio")
    print("Sample rate: \(result.sampleRate)Hz")
    print("Audio samples: \(result.audio.count)")
}

import TTSKit

let tts = try await TTSKit()

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

import TTSKit

let tts = try await TTSKit()

// Starts playing before generation finishes
try await tts.play(
    text: "This starts playing immediately as audio is generated."
)

// Control buffering strategy
try await tts.play(
    text: "Long passage with custom buffering...",
    playbackStrategy: .auto  // Auto-calculates optimal buffer
)

import TTSKit

let tts = try await TTSKit()

// Configure generation options
var options = GenerationOptions()
options.temperature = 0.9           // Randomness (0.0-1.0)
options.topK = 50                   // Top-K sampling
options.repetitionPenalty = 1.05    // Reduce repetition
options.maxNewTokens = 245          // Max length per chunk

// Text chunking for long content
options.chunkingStrategy = .sentence  // Split at sentence boundaries
options.concurrentWorkerCount = nil   // Auto-select based on device

let result = try await tts.generate(
    text: "Long article or book chapter...",
    options: options
)

import TTSKit

let tts = try await TTSKit(model: .qwen3TTS_1_7b)  // Requires 1.7B model

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
)

import TTSKit
import Foundation

let tts = try await TTSKit()
let result = try await tts.generate(text: "Save me!")

// Get documents directory
let outputDir = FileManager.default.urls(
    for: .documentDirectory, 
    in: .userDomainMask
)[0]

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

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

print("Saved to: \(outputDir.path)/output.m4a")

import TTSKit

let tts = try await TTSKit()

let result = try await tts.generate(
    text: "Hello from TTSKit!"
) { progress in
    print("Audio chunk: \(progress.audio.count) samples")
    
    // First step timing (useful for estimating total time)
    if let stepTime = progress.stepTime {
        print("First step took \(stepTime)s")
    }
    
    // Chunk progress (when using multi-chunk generation)
    if let chunk = progress.chunkIndex, let total = progress.totalChunks {
        print("Chunk \(chunk + 1)/\(total)")
    }
    
    return true  // Return false to cancel generation
}

print("Final timings:")
print("  Total: \(result.timings.fullPipeline)s")
print("  Time to first audio: \(result.timings.timeToFirstBuffer)s")
print("  Decoding: \(result.timings.decodingLoop)s")