Soprano TTS Loader

The Soprano TTS Loader is the node every other node in this pack hangs off, and honestly it's the most important one to get right. Soprano is Eugene Kwek's on-device text-to-speech model - roughly 80M parameters, under 1GB of VRAM, Apache 2.0, fast enough that the author's own claims (2000x realtime on GPU) made r/StableDiffusion sit up. The wrapper here is the community's ComfyUI front end for it. And the Loader is the single point where all of that either works or falls apart, because it's the only node that touches the model itself.

How it works

Under the hood the Loader does one unglamorous thing: it instantiates SopranoTTS from the soprano-tts package and hands you the object. The trick is caching. The node keeps the loaded model in a class-level variable, so the expensive load happens exactly once - subsequent runs, and every generation node that shares this Loader, reuse it instead of re-instantiating. It only reloads if you change the backend, KV cache size, or decoder batch size; change nothing and ComfyUI skips straight to "using cached model" in the console.

One thing to know before you wire anything: the Loader hardcodes device='cuda'. There's no CPU fallback in this node, so if you're on a machine without a working CUDA setup, the model load will fail before you ever type a line of text.

The inputs that matter

There are only three, and you'll realistically touch one of them:

• backend (transformers / lmdeploy / auto, default transformers) - this is the big lever. transformers is the safe default the author recommends for newer GPUs. lmdeploy is the fast path and the only backend the Stream node works with. auto lets the package pick.
• cache_size_mb (1–100, default 10) - the KV cache size for LMDeploy. Only meaningful if you're on that backend; leave it alone otherwise.
• decoder_batch_size (1–16, default 1) - batch size for Soprano's vocoder-based audio decoder. Crank it if you're doing long-form batch work and have VRAM to spare.

The output and what it wires into

One output, model, typed SOPRANO_MODEL. It feeds the three generation nodes in this pack: Soprano TTS, Soprano TTS Batch, and Soprano TTS Stream. One Loader can feed all of them at once - that's the whole point of the shared model handle.

Installing it

ComfyUI Manager is the easy path: search for "SopranoTTS" and hit install. Or do it by hand:

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

Then restart ComfyUI. The requirements.txt is just two lines - soprano-tts and torch - and the soprano-tts package pulls the model weights in on first load, so there's no separate checkpoint to hunt down. The first generation will look like it's hanging while those ~80M weights download; it isn't.

Where people get burned

• Backend mismatch with your GPU. The README is explicit: on RTX 50xx / Blackwell (compute capability 12.0), lmdeploy doesn't work yet - use transformers. On RTX 40xx and 30xx, either is fine.
• Changing backend makes it reload. Toggling from transformers to lmdeploy invalidates the cache, so you'll eat a full load. Not a bug, but it surprises people.
• Switching to the Stream node without switching backends. Streaming raises a clear error on the transformers backend - see that node's page for the fix.

The Loader is 30 seconds of setup that everything else depends on. Set the backend right for your card, let it cache, and you'll forget it's there - which is exactly how a good loader should feel.