Soprano TTS Stream

Soprano's headline feature is streaming: the model can start spitting out audio after only a handful of tokens, with latency the author pegs at under 15 milliseconds - an order of magnitude better than the other realtime TTS models he benchmarks against. The Stream node is the ComfyUI front door to that path. If you're building anything interactive - a chatbot that speaks, a live narration tool, a voiceover that needs to start before the whole sentence is synthesized - this is the node you want. But it has one hard requirement you need to know before you wire it up, and it's the entire ballgame: it only works on the lmdeploy backend.

How it works

The node feeds your text to infer_stream on the loaded model, which generates audio in chunks rather than as one long pass. chunk_size controls how many tokens each chunk covers (1–10, default 1). The chunks are collected and concatenated into a single waveform, returned as a standard 32,000 Hz mono AUDIO output.

One honest caveat: this is streaming generation, not a live audio pipe. In ComfyUI, the node still waits for the whole generation to finish and hands you one finished audio file - you can't play the beginning while the end is still synthesizing. What you're actually getting is the low-latency, chunked inference path that Soprano is famous for, inside the graph. If your workflow needs real interleaved play-while-generating, that's beyond what a single node return can do; the value here is that the lmdeploy path is dramatically faster to first audio than the transformers path, which matters when you're regenerating a line and waiting on it.

The inputs that matter

• model - the SOPRANO_MODEL from the Soprano TTS Loader, and this is where the backend choice happens. The Loader's backend must be lmdeploy. If it's transformers, the Stream node raises a clear error and tells you to use the regular Soprano TTS node instead.
• text - the line to speak, multiline so you can paste a paragraph. Stream is best suited to shorter utterances; for long-form, the Batch node is the better tool.
• chunk_size (1–10, default 1) - tokens per audio chunk. Smaller = more granular streaming, larger = fewer, bigger chunks. The default of 1 is fine; this is a tuning knob for latency vs. overhead, not something you'll usually touch.
• temperature (0–2, default 0.3), top_p (0–1, default 0.95), repetition_penalty (1–2, default 1.2) - the same sampling trio the other generation nodes in this pack use, with the same sensible defaults. Leave them alone unless you have a reason.

Output is audio (AUDIO) - wire it to SaveAudio, PreviewAudio, or a video node's audio input.

Installing it

Same pack as the other two. ComfyUI Manager: search "SopranoTTS" and install. Or:

cd ComfyUI/custom_nodes
git clone https://github.com/jo-nike/ComfyUI-SopranoTTS.git
cd ComfyUI-SopranoTTS
pip install -r requirements.txt

Restart after installing. Dependencies are soprano-tts plus torch; weights download on first use.

Where people get burned

The one that bites everyone is the backend. Streaming raises a NotImplementedError on the transformers backend, which the node converts into a runtime error spelling out the fix - so if you hit a red error right after adding this node, the diagnosis is already on screen: switch the Loader to lmdeploy. The catch is that lmdeploy doesn't support Blackwell (RTX 50xx, compute capability 12.0) yet, per the README. So if you're on a 5080 and wanted streaming, you're out of luck for now - the model still works great, you just use the regular Soprano TTS node instead. And note that switching the Loader from transformers to lmdeploy triggers a full model reload, so expect a pause on that first run. Get the backend right once and the Stream node is genuinely the fast, low-latency path Soprano promises.