The Problem

ComfyUI users need a single extension that can drive many TTS and voice‑conversion back‑ends, keep subtitle timing, and expose the results as nodes. Without a unified wrapper each engine must be wired manually, model files are scattered, and SRT handling is duplicated across projects.

What This Does

TTS‑Audio‑Suite bundles 12 inference engines (e.g., F5‑TTS, ChatterBox, Qwen3‑TTS, CosyVoice3, VibeVoice, RVC) plus a set of audio‑processing utilities and ComfyUI nodes.

  • Engine adapters live under engines/ – each engine has its own sub‑folder (engines/f5_tts/, engines/chatterbox/, …) containing a model/ package, a CLI (cli.py), and Docker support where needed.
  • Shared helpers such as utils/audio/processing.py, utils/models/unified_model_interface.py and utils/voice/discovery.py provide a hub that 46–48 modules import; they handle model loading, device selection, and audio post‑processing.
  • Node definitions (nodes/) expose the adapters to ComfyUI, e.g. nodes/chatterbox/chatterbox_srt_node.py which builds an SRT from generated audio.

The suite therefore lets a user drop a single “TTS” node into a workflow, select an engine, and obtain timed subtitles without writing custom glue code.

How It Is Wired

Execution starts at the CLI entry point engines/index_tts/indextts/cli.py::main. The call chain is:

  1. main parses arguments and builds an IndexTTS engine instance.
  2. Engine creation triggers utils/models/unified_model_interface (the most‑connected module, Ca = 23, Ce = 32, part of a circular import). This module discovers the appropriate model files via utils/voice/discovery.
  3. Model weights are loaded (load_state_dict) and moved to the device selected by utils/device/__init__.
  4. Input text is passed to the engine’s forward method, which eventually calls low‑level audio ops in utils/audio/processing.py (stft, pad, cat, normalize). These functions are invoked from 87 different places, making the file a high‑blast‑radius component.
  5. The resulting waveform is written to disk (open/write in utils/audio/processing.py) or streamed back to ComfyUI via the node’s process method.

A separate path for subtitle generation runs nodes/chatterbox/chatterbox_srt_node.py, which calls parse_pause_tags (10 callers) and print (87 callers) to emit an SRT file. The only external interaction observed is a subprocess call to is_available (used by several wrappers) that launches engine‑specific binaries.

The import graph contains 14 modules in cycles; the most problematic cycle involves utils/models/unified_model_interface.py, utils/models/comfyui_model_wrapper/base_wrapper.py, and engines/f5_tts/model/__init__.py. Breaking these cycles would reduce coupling and simplify future engine additions.

How To Use It

# 1. Clone the repo (URL must be verbatim)
git clone https://github.com/moses-y/TTS-Audio-Suite
cd TTS-Audio-Suite

# 2. Install Python dependencies (pip reads the top‑level pyproject.toml)
pip install -r requirements.txt   # lockfile missing – see Code Health

# 3. Build the optional Triton server for F5‑TTS (if you need GPU inference)
cd engines/f5_tts/runtime/triton_trtllm
docker compose up -d   # uses Dockerfile.server

# 4. Run the CLI for a quick test (IndexTTS example)
python engines/index_tts/indextts/cli.py \
    --engine index_tts \
    --text "Hello world, this is a test." \
    --output out.wav

ComfyUI integration is automatic: after installing the extension, the nodes appear under the “TTS Audio Suite” category. No additional configuration files are required beyond placing model weights in the directories described in docs/MODEL_LAYOUTS.md.

Real‑World Use

A post‑production pipeline can replace a manual subtitle‑editing step with a single node chain:

# In a ComfyUI workflow (JSON representation)
{
  "nodes": [
    {"type": "TTSAudioSuite/ChatterBoxSRTNode", "engine": "chatterbox", "text": "..."},
    {"type": "TTSAudioSuite/AudioExportNode", "format": "wav"}
  ]
}

The node sends the transcript to the selected engine, receives a waveform, writes output.wav, and simultaneously produces output.srt with accurate timestamps, ready for video editors.

Code Health & Issues

  • High – Pin third‑party GitHub Actions to commit SHAs (.github/workflows/*).
  • High – Add a lockfile for engines/f5_tts/pyproject.toml.
  • High – CI never runs the test suite; insert a pytest step.
  • Medium – Declare least‑privilege GITHUB_TOKEN permissions.
  • Medium – Enable Dependabot (.github/dependabot.yml).
  • Medium – Pin Docker base image by digest in engines/f5_tts/runtime/triton_trtllm/Dockerfile.server.
  • Medium – Add a dependency‑vulnerability scan to CI.
  • Medium – Move large binaries (>5 MiB) to Git LFS (bst.t7, waveanalgif.gif).
  • Medium – Expand test coverage (currently 17 files for 1 270 source files).
  • Low – Set timeout-minutes on workflow jobs.

No secrets were found; a license file exists. The repository includes a full test suite (52 files) but CI does not execute them.

The Bottom Line

TTS‑Audio‑Suite delivers a pragmatic, multi‑engine TTS/VC layer for ComfyUI, with clear node boundaries and reusable utilities. The codebase is large and tightly coupled around a few hub modules, which raises maintenance risk, and the CI pipeline needs tightening. It is suitable for teams comfortable navigating Python import cycles and willing to add missing lockfiles and CI steps.