Streaming TTS

synthesizeStream yields audio in chunks so playback can start before the whole passage is rendered.

Basic usage

for await chunk in RunAnywhere.synthesizeStream("This is a long piece of text...") {
    if !chunk.errorMessage.isEmpty {
        print("Synthesis failed: \(chunk.errorMessage)")
        break
    }
    player.enqueue(chunk.audioData)
    if chunk.isFinal { break }
}

Method signature

public static func synthesizeStream(
    _ text: String,
    options: RATTSOptions = .defaults()
) -> AsyncStream<RATTSOutput>

The call is neither async nor throws: it returns immediately. Each element is a full RATTSOutput carrying one chunk of audio, not a bare Data. There is no onAudioChunk callback. The stream finishes without yielding anything when the SDK is not initialized or no model is loaded under .speechSynthesis.

Chunk shape

Every element is an RATTSOutput. The fields that matter while streaming:

Field	Type	Meaning
`audioData`	`Data`	Samples for this chunk
`audioFormat`	`RAAudioFormat`	Sample encoding
`sampleRate`	`Int32`	Sample rate for this chunk
`chunkIndex`	`Int32`	Position in the sequence
`isFinal`	`Bool`	Terminal chunk
`durationMs`	`Int64`	Duration of this chunk
`errorMessage` / `errorCode`	`String` / `Int32`	Failure detail, delivered in-band

Streaming audio player

import AVFoundation

final class StreamingAudioPlayer {
    private let engine = AVAudioEngine()
    private let playerNode = AVAudioPlayerNode()
    private var format: AVAudioFormat?

    func prepare(sampleRate: Double) throws {
        let format = AVAudioFormat(
            commonFormat: .pcmFormatFloat32,
            sampleRate: sampleRate,
            channels: 1,
            interleaved: false
        )
        self.format = format

        engine.attach(playerNode)
        engine.connect(playerNode, to: engine.mainMixerNode, format: format)

        try engine.start()
        playerNode.play()
    }

    func enqueue(_ audioData: Data) {
        guard let format else { return }

        let frameCount = UInt32(audioData.count) / UInt32(MemoryLayout<Float>.size)
        guard frameCount > 0,
              let buffer = AVAudioPCMBuffer(pcmFormat: format, frameCapacity: frameCount)
        else { return }

        buffer.frameLength = frameCount
        audioData.withUnsafeBytes { raw in
            guard let base = raw.baseAddress?.assumingMemoryBound(to: Float.self) else { return }
            buffer.floatChannelData?[0].update(from: base, count: Int(frameCount))
        }

        playerNode.scheduleBuffer(buffer)
    }

    func stop() {
        playerNode.stop()
        engine.stop()
    }
}

RATTSOptions.defaults() sets audioFormat = .pcm and sampleRate = 22050. Prepare the player with the sampleRate reported on the first chunk rather than assuming a value.

SwiftUI integration

struct StreamingTTSView: View {
    @State private var text = "Streaming synthesis starts playing before the whole passage renders."
    @State private var isSynthesizing = false
    @State private var chunksPlayed = 0

    private let player = StreamingAudioPlayer()

    var body: some View {
        VStack(spacing: 20) {
            TextEditor(text: $text)
                .frame(height: 150)
                .border(Color.gray.opacity(0.3))

            if isSynthesizing {
                Text("\(chunksPlayed) chunks played")
                    .font(.caption)
                    .foregroundColor(.secondary)
            }

            Button {
                Task { await synthesize() }
            } label: {
                Label(
                    isSynthesizing ? "Synthesizing" : "Speak",
                    systemImage: isSynthesizing ? "waveform" : "play.fill"
                )
                .frame(maxWidth: .infinity)
                .padding()
            }
            .disabled(text.isEmpty || isSynthesizing)
        }
        .padding()
    }

    func synthesize() async {
        isSynthesizing = true
        chunksPlayed = 0
        defer { isSynthesizing = false }

        var prepared = false

        for await chunk in RunAnywhere.synthesizeStream(text) {
            guard chunk.errorMessage.isEmpty else {
                print("Synthesis failed: \(chunk.errorMessage)")
                break
            }

            if !prepared {
                let rate = chunk.sampleRate > 0 ? Double(chunk.sampleRate) : 22050
                try? player.prepare(sampleRate: rate)
                prepared = true
            }

            player.enqueue(chunk.audioData)
            chunksPlayed += 1

            if chunk.isFinal { break }
        }
    }
}

Sentence by sentence

When you want a real pause between sentences, synthesize each one and wait out its duration.

func speakSentenceBySentence(_ text: String) async throws {
    let sentences = text
        .components(separatedBy: CharacterSet(charactersIn: ".!?"))
        .map { $0.trimmingCharacters(in: .whitespaces) }
        .filter { !$0.isEmpty }

    for sentence in sentences {
        _ = try await RunAnywhere.speak(sentence + ".")
    }
}

speak returns after playback finishes, so no manual sleep is needed.

Buffering

Scheduling every chunk the instant it arrives can stutter on slow devices. Hold a few back first.

var pending: [Data] = []
var started = false
let warmupChunks = 3

for await chunk in RunAnywhere.synthesizeStream(text) {
    pending.append(chunk.audioData)

    if !started, pending.count >= warmupChunks || chunk.isFinal {
        started = true
        pending.forEach(player.enqueue)
        pending.removeAll()
    } else if started {
        pending.forEach(player.enqueue)
        pending.removeAll()
    }

    if chunk.isFinal { break }
}

Use cases

Long-form reading

func readChapter(_ text: String) async {
    var options = RATTSOptions.defaults()
    options.speakingRate = 0.9

    for await chunk in RunAnywhere.synthesizeStream(text, options: options) {
        player.enqueue(chunk.audioData)
        if chunk.isFinal { break }
    }
}

Speaking an LLM response

Accumulate tokens and hand each completed sentence to the synthesizer.

let events = try await RunAnywhere.generateStream(prompt: prompt)
var sentence = ""

for await event in events {
    sentence += event.token

    if sentence.contains(where: { ".!?".contains($0) }) {
        for await chunk in RunAnywhere.synthesizeStream(sentence) {
            player.enqueue(chunk.audioData)
            if chunk.isFinal { break }
        }
        sentence = ""
    }
}

For a full conversational loop, the voice agent already wires VAD, STT, LLM, and TTS together.

Reading UI content aloud

struct AccessibleContentView: View {
    @State private var isSpeaking = false

    var body: some View {
        Button(isSpeaking ? "Stop Reading" : "Read Aloud") {
            Task {
                if isSpeaking {
                    await RunAnywhere.stopSpeaking()
                    isSpeaking = false
                } else {
                    isSpeaking = true
                    var options = RATTSOptions.defaults()
                    options.speakingRate = 0.9
                    _ = try? await RunAnywhere.speak(
                        "Welcome to the app. Navigate using swipe gestures.",
                        options: options
                    )
                    isSpeaking = false
                }
            }
        }
        .accessibilityHint("Reads the current screen content aloud")
    }
}

Stopping

await RunAnywhere.stopSynthesis()

Cancelling the Task that consumes the stream also tears down the native session, because the stream’s termination handler cancels the underlying work.

Error handling

There is nothing to catch. Failures arrive as a chunk with a non-empty errorMessage.

for await chunk in RunAnywhere.synthesizeStream(text) {
    if !chunk.errorMessage.isEmpty {
        print("Streaming synthesis failed: \(chunk.errorMessage) (\(chunk.errorCode))")
        player.stop()
        break
    }
    player.enqueue(chunk.audioData)
    if chunk.isFinal { break }
}

Performance tips

Buffer a few chunks before starting playback so the player does not underrun.

Read sampleRate off the first chunk rather than hard-coding it. The default is 22050 Hz, but the engine can report something else.

synthesize()

Non-streaming synthesis

Voices

Voice selection

Getting Started

Swift SDK

Kotlin SDK

React Native SDK

Flutter SDK

Web SDK

Vibe Coding

Basic usage

Method signature

Chunk shape

Streaming audio player

SwiftUI integration

Sentence by sentence

Buffering

Use cases

Stopping

Error handling

Performance tips

synthesize()

Voices

​Basic usage

​Method signature

​Chunk shape

​Streaming audio player

​SwiftUI integration

​Sentence by sentence

​Buffering

​Use cases

​Stopping

​Error handling

​Performance tips

synthesize()

Voices

Basic usage

Method signature

Chunk shape

Streaming audio player

SwiftUI integration

Sentence by sentence

Buffering

Use cases

Stopping

Error handling

Performance tips