Voice Clone Studio: one Gradio app for six speech engines

Several speech engines share one tabbed interface

The premise of the project is consolidation. The README describes a multi-model, modular Gradio-based web UI covering voice cloning, voice design, multi-speaker conversation, voice conversion, voice training and sound effects, and summarises the goal as one app with many engines so you can tinker with them without juggling separate repositories and setups.

The engines named are VibeVoice, Qwen3-TTS, LuxTTS, Chatterbox, Fish Speech and MMAudio, with Qwen3-ASR, VibeVoice-ASR and Whisper handling automatic transcription. That breadth is the reason to look at this project rather than any single upstream model, and it is also the source of most of its rough edges, because each engine brings its own model sizes, its own parameter names and its own limitations.

For a tinkerer this is exactly the appeal. For a team that needs one voice, one model and a predictable output, the same breadth becomes a support surface.

Modules load dynamically and Settings switches them off

The architecture section is short but it carries the design. Voice Clone Studio is fully modular, the main file dynamically loads self-contained tools as tabs, and each tool can be enabled or disabled from Settings without touching any code.

The repository layout supports that description. The root holds voice_clone_studio.py as the entry point, a modules directory for the individual tools, a tests directory, a docs directory and a wheel directory, alongside platform setup scripts for Linux, macOS and Windows and the matching launch scripts. Each engine therefore arrives as its own module with its own dependencies, rather than as a monolithic application file.

The consequence for a user is that the Settings screen is the real configuration surface. Switching a module off is how you avoid loading a model you do not need, and since the modules are described as self-contained, an engine that fails to load should affect its own tab rather than the whole application. The documentation does not spell out that failure behaviour in detail, so the extent of the isolation is worth checking on your own hardware.

Choosing an engine changes which features you actually get

The voice clone tool lists several engines with their sizes: Qwen3-TTS in 0.6B and 1.7B, VibeVoice in 1.5B, Large and Large-4bit, LuxTTS, Chatterbox, and Fish Speech S2 Pro at 4B. The shared tooling around them includes voice prompt caching, so the first generation processes the sample and later ones are instant, seed control for reproducible results, 40 or more emotion presets with adjustable intensity, splitting by paragraph into separate clips with automatic naming and a combined preview, a Prompt Hub for reaching saved prompts from inside the tool, and metadata saved with each output.

One feature is engine specific and the app handles the mismatch. Fish Speech supports expression tags, with markers like `[whisper]`, `[laughing]` or `[excited]` embedded in the text and 15,000 or more supported tags, and the documentation states that Fish Speech tags are stripped automatically when another engine is used, so the same text works everywhere.

That is a thoughtful piece of glue, and it is also a sign of the general pattern. The interface is common, the engine capabilities are not, and the documentation is honest about which tab belongs to which model.

Conversation mode caps speakers at four and length at ninety minutes

The conversation tool builds multi-speaker dialogue, either with Qwen's premium voices or with your own samples through VibeVoice. The script format is shared between engines, using a `[N]:` prefix per line:

[1]: Hey, how's it going?
[2]: I'm doing great, thanks for asking!
[3]: Mind if I join this conversation?

Qwen mode mixes any of the 9 premium speakers, with a documented mapping from `[1]` to Vivian, `[2]` to Serena, `[3]` to Uncle_Fu, `[4]` to Dylan, `[5]` to Eric, `[6]` to Ryan, `[7]` to Aiden, `[8]` to Ono_Anna and `[9]` to Sohee, and lets you adjust the pause duration between lines.

VibeVoice mode is the long-form one: up to 90 minutes of continuous speech, up to 4 distinct speakers built from your own samples, cross-lingual support, and a stated tendency to add background music or sounds on its own for realism. The four-speaker ceiling is a real constraint, and the documentation is specific that numbers beyond 4 wrap around, so `[5]` maps to speaker 1 and `[8]` to speaker 4. A five-person script does not fail, it silently reuses speakers.

Conversion, training and design share the same app

Beyond cloning, the other tools extend the same interface to different jobs. The voice changer uses Chatterbox speech-to-speech voice conversion, which the README attributes to Resemble AI under the MIT licence, and it accepts a target voice sample taken from the same collection used for cloning, supports recording from a microphone, and ships an English model plus a multilingual model covering 23 languages.

Voice design creates a voice from a text description alone, through the Qwen3-TTS Voice Design Model, where you specify age, gender, emotion, accent and speaking style. No reference audio is needed, which makes it the quickest path to a voice when you have no sample of your own.

Training is where the project stops being a demo. The training tool fine-tunes custom voice models with Qwen3-TTS or with VibeVoice LoRA finetuning, keeps training samples in the `datasets/` folder, converts audio automatically to 24kHz 16-bit mono, and runs a three-step pipeline of validation, code extraction and training. You can compare checkpoints from different epochs, watch live training logs with loss values, stop a run mid-way and keep a clean status, and then use the trained voices in the presets tool.

The container asks for one GPU and a CUDA 12.8 base

The Docker path is the one the repository supports in full, with a Dockerfile and a docker-compose.yaml. The image is built on `nvidia/cuda:12.8.1-runtime-ubuntu24.04`, installs Python 3.12, ffmpeg, sox and the audio libraries, creates a non-root user with id 1001, and pulls the CUDA 12.8 builds of Torch, torchaudio and torchvision pinned to 2.9.1 and 0.24.1. The Python layer installs Gradio 6.5.1, soundfile, librosa, numpy 1.26.4, diffusers, deepfilternet, qwen-tts, scipy, huggingface_hub and modelscope. A Rust toolchain is also installed alongside the Python dependencies.

The compose file mounts your working directories and reserves a GPU:

    ports:
      - "7860:7860"
    environment:
      - "GRADIO_SERVER_NAME=0.0.0.0"
      - "HF_HOME=${HF_CACHE_CONTAINER_PATH:-/home/user/app/.cache/huggingface}"
      - "NVIDIA_VISIBLE_DEVICES=all"
      - "NVIDIA_DRIVER_CAPABILITIES=compute,utility"
    volumes:
      - "./temp:/home/user/app/temp"
      - "./datasets:/home/user/app/datasets"
      - "./models:/home/user/app/models"
      - "./samples:/home/user/app/samples"
      - "./output:/home/user/app/output"

The device reservation block asks Docker for a single NVIDIA GPU with compute capability, which is the hard requirement in practice: the compose file will not start cleanly on a CPU-only host, and the multi-GPU work described in the release history is a separate matter from the single-device reservation in this file.

Transcription and prompt generation are pluggable too

Two more subsystems are offered alongside the engines, and each has more than one implementation. Automatic transcription can run on Whisper, VibeVoice-ASR or Qwen3-ASR, which means a generated clip can be turned back into text inside the same tool rather than in a separate application.

Prompt generation and prompt saving are handled by llama.cpp or by Ollama, and the prompt saving layer is based on the ComfyUI Prompt-Manager project. The distinction between the two is deployment shape: The Dockerfile installs a Rust toolchain as part of the image build, while Ollama is a service you would run outside this repository.

This is also the most useful comparison the documentation supports, because every other engine in the list is a model you download, whereas these two are about where the language model that writes your prompts actually runs. The README does not document how the choice between llama.cpp and Ollama is made in the interface, so that detail is worth checking before you settle on a setup.

Releases track engine features, and the branch is where the work is

The recent release names read like a changelog of model capabilities. v1.12.5 in April 2026 was about Fish Speech with a compilation speed-up, v1.10.0 in March 2026 added VibeVoice LoRA support, VibeVoice preset voices on the 0.5B model and Qwen3.5 LLM support, and v1.9.0 in March 2026 was about CUDA Graphs acceleration and multi-GPU support.

That last one explains a detail in the compose file, which reserves a single device even though the release notes describe multi-GPU work. The repository is not archived and the last push was on 2026-05-18, so the branch is ahead of the newest tag. The licence is Apache-2.0, with the LICENSE file at the root.

One documentation gap is worth flagging. In the conversation tool's engine list, the LuxTTS entry is left empty, so the features specific to that engine are not described anywhere in the README. Anyone planning to use LuxTTS for dialogue has to work that out from the upstream project rather than from this one.

Editorial conclusion

Voice Clone Studio suits a tinkerer or a small team that wants to compare speech models side by side in one place, with training, conversion and transcription included, and who has a CUDA GPU to spend on it. It is the wrong choice for a production service that needs a single predictable model, since the feature set changes with the engine and the Docker image carries Torch, Diffusers, Gradio and a Rust toolchain. Verify first that you can supply one GPU, that the volumes in docker-compose.yaml point at writable paths for datasets, models and output, and which engine you are actually committing to before you build up a trained voice around it.

Frequently asked questions

Official sources

1. FranckyB/Voice-Clone-Studio on GitHub
2. Issues
3. License: Apache-2.0
4. README
5. Releases