drama-3-int4 Multi-Speaker TTS Model: 32GB+ VRAM, File List

Sample outputs are available on the model card.
- 1. At a Glance
- 2. Overview
- 3. Specifications
- 4. Performance and Quality
- 5. Strengths and Use Cases
- 6. Hardware Requirements
- 7. Can You Run It Locally?
- 8. Our Own Measurements
- 9. Distributed Files
- 10. How to Get It
- 11. Quantized and Converted Variants
- 12. Other Models for the Same Task
- 13. What to Read Next
- 14. Sources
At a Glance
| Item | Value |
|---|---|
| Repository | fishaudio/drama-3-int4 |
| Family guide | drama-3 guide (1 articles) |
| Publisher guide | Fish Audio: models and licenses |
| Published | 2026-10-15 |
| License | fish-audio-community-license |
| Formats | PyTorch (pth) / safetensors |
| Source type | Unverified (not confirmed by a primary source) |
Values determined by this site’s code when the information was collected. Dates are JST.
Overview
It is reported that drama-3-int4, an int4 quantized variant of Fish Audio’s multi-speaker speech synthesis model drama-3, has been released. Note, however, that this repository is not official from Fish Audio, but rather an unofficial quantized version by a third party. The input is text (and an optional reference audio clip), and the output is multi-language, multi-speaker speech.
Specifications
- The base model is reported to be an MoE text backbone with a total of 35B parameters and 3B active parameters, featuring a hybrid architecture of full attention and linear attention.
- The audio decoder is reported to use a “Codebook-MTP" approach that causally decodes 10 codebooks across the entire sequence.
- In this quantization (hybrid W4A16), it is reported that int4 is applied to the experts, q/k/v/o in attention, and input/output projections of deltanet, while the shared-expert MLP and audio decoder/codec are kept in bf16. It is explained that quantizing the shared-expert MLP to int4 passed numerical checks, but caused an issue where audio frames became zero during serving, so it was dropped.
- The quantization method is reported to be RTN (round-to-nearest) plus group-wise (group 128) clip search, without using calibration data.
- According to the distributor’s tags, supported languages are multilingual including en/zh/ja/ko (the base model’s tags include even more languages).
- As recommended serving settings,
--tts_engine.gpu_memory_fraction 0.62and--vocoder.gpu_memory_fraction 0.2on an A100-80GB are exemplified. - The license is listed as “license: other" for the quantized version tag and “fish-audio-research-license" for the base model, confirming a difference in names between the two, though specific conditions such as commercial usability cannot be read from this documentation.
Performance and Quality
It is reported that the distributor of the quantized version measured WER using Whisper large-v3 and speaker similarity using resemblyzer, comparing it across 8 prompts with another community quantized version (darioooooo0o/drama-3-w4a16-32gb, int8 dense, 24.5GB).
| mean WER ↓ | mean WER excl. zh ↓ | speaker sim ↑ | |
|---|---|---|---|
| This repository (int4 hybrid, 22.1GB) | 0.197 | 0.082 | 0.846 |
| Comparison target (int8 dense, 24.5GB) | 0.259 | 0.154 | 0.846 |
WER is an indicator showing that lower values mean fewer transcription errors, and this repository is lower (better) than the comparison target. On the other hand, speaker similarity is tied at 0.846 with no difference. Per-prompt, there was an example where the comparison target generated hallucinations at the end of a long paragraph (WER 0.667 vs. this repository 0.028), while this repository had an example where a single sentence with tags was cut off at the end (0.333 vs. comparison target 0.25), indicating pros and cons, according to the report. Note that Chinese prompts resulted in WER 1.0 due to jiwer tokenization quirks, which is explained as a measurement artifact rather than a model difference.
Keep in mind that these figures are measured by the distributor of the quantized version themselves and are not official benchmarks from Fish Audio.
Strengths and Use Cases
Reported as an unofficial quantized version, this model is said to be extremely well suited for producing dialogue scenes featuring multiple characters and long-form audio content like podcasts. Inheriting the design philosophy of the original model, inserting specific tags into the text makes it possible to voice up to 16 different characters within a single audio file. This is expected to streamline the production of complex audio dramas and similar content.
Voice cloning capabilities are also a major feature. By inputting just a few seconds of reference audio, you can generate speech mimicking that person’s voice quality. Furthermore, emotional expression control is reportedly possible by inserting tags like [sighs] and [laughs] into the text to reproduce natural emotional shifts according to the context.
Additionally, the “continuation" feature, which allows continuous editing of the generation process, is a major practical advantage. By using the previous_takes parameter, you can generate new text while keeping previously generated audio tokens as context. This makes it possible to modify only part of a sentence or incrementally generate a long story while maintaining consistency.
Regarding supported languages, the repository tags explicitly list four languages: English, Chinese, Japanese, and Korean. According to the base model specifications, broad multilingual support including Spanish, French, German, Italian, and others is also anticipated, aiming for global applications.
As an advantage unique to this quantized version, hardware compatibility is also mentioned. While the FP8 version of the original model requires GPUs from the latest Hopper generation (like H100) or Ada Lovelace generation (like RTX 40 series), this int4 version is designed to run on Ampere generation (like A100) GPUs as well, potentially making the latest speech synthesis technology available in a wider range of server environments.
Hardware Requirements
Estimated requirements (calculated by Local Model Watch) — 35.9B parameters (taken from the base model fishaudio/drama-3)
| Your VRAM | Quantization | File size | Est. memory needed |
|---|---|---|---|
| 32GB (RTX 5090, etc.) | INT4 | 20.6GB | 24.7GB |
Inference engine support (architecture name matched against each project’s own model registry in its source code, checked 2026-11-17): llama.cpp: registered, vLLM: not registered, MLX (mlx-lm): not registered. “Not registered" means the name is absent from that registry today, not that the model cannot run.
Memory estimates add a 20% runtime overhead (KV cache, etc.) to the actual size of the distributed files. Actual usage varies with context length, batch size and inference engine. These figures are computed by this site from file sizes, not published by the model’s authors. Compare with other models in our VRAM quick reference. What the quantization names mean: glossary.
Can You Run It Locally?
The publisher distributes this model as PyTorch (pth) / safetensors.
License — fish-audio-community-license: A custom license from the publisher. Check the original terms directly, including whether commercial use is permitted.
Compression: the INT4 build measures 4.93 bits per weight — about 31% the size of the original 16-bit weights, calculated by this site from the actual file sizes.
Compiled by this site’s code from the published formats and the license field. License summaries are not legal advice — check the publisher’s original terms before relying on them.
Our Own Measurements
Measurements We Did Not Take
We have not confirmed that this site meets the commercial-use terms of this model’s license (fish-audio-community-license). Because this site carries advertising, we did not run the model (no CPU run, answers, quantization comparison, conversion or generation).
Distributed Files
Weight files published in fishaudio/drama-3-int4, listed by this site from the Hugging Face API. Sizes are the actual file sizes.
| File | Size |
|---|---|
codec.pth |
1.87GB |
model-*-of-00012.safetensors |
22.10GB (12 split files) |
How to Get It
This model is distributed in safetensors format and is available from the Hugging Face repository fishaudio/drama-3-int4. At this time, no license gate is set for access.
For inference and serving, it is recommended to use SGLang-Omni. The installation steps are as follows. First, clone the repository and install dependencies using uv.
git clone https://github.com/sgl-project/sglang-omni.git && cd sglang-omni
uv venv -p 3.12.venv &&..venv/bin/activate
uv pip install --prerelease=allow -e ".[fishaudio]"
uv pip install ninja
Next, you need to download the model and run apply_patch.py included in the repository to apply a patch that registers the quantization method. It is explained that this patch is mandatory to correctly load the weights of specific modules.
# Example of downloading the model
hf download fishaudio/drama-3-int4 --local-dir drama-3-int4
# Applying the patch
python drama-3-int4/apply_patch.py.
The server is started with the following command. As an execution example on an A100-80GB, options specifying GPU memory allocation rates are shown.
sgl-omni serve --model-path drama-3-int4 --port 8000 \
--tts_engine.gpu_memory_fraction 0.62 --vocoder.gpu_memory_fraction 0.2
Once started, it is reported that text input, reference audio designation, emotion tag usage, and editing functions via previous_takes become available through the standard Drama 3 API (/v1/audio/speech).
Quantized and Converted Variants
→ Scroll horizontally to see all columns
| Added | Publisher | Format | Repository | Smallest VRAM tier (build, est. memory) |
|---|---|---|---|---|
| 2026-11-16 | ggml-org | GGUF | ggml-org/drama-3-GGUF | Q4_K_M 23.0GB (fits in 24GB VRAM) |
File sizes of each build:
- Available builds in ggml-org/drama-3-GGUF: Q4_K_M 19.1GB / Q8_0 34.4GB / BF16 64.6GB
In addition, 2 converted build(s) from other uploaders exist on Hugging Face; this site lists only builds from the model’s publisher or established quantization maintainers.
This section is appended automatically by Local Model Watch when a converted build of this model appears after publication. Memory figures are estimated from the size of the distributed files. What the quantization names mean: glossary.
Other Models for the Same Task
Recent audio models covered by Local Model Watch, newest first. Grouped by the task each publisher declares on Hugging Face (pipeline_tag); the smallest VRAM tier is this site’s estimate.
- TTS-V5 Chinese TTS Model: 4GB+ VRAM, File List (4GB)
- TTS-V4 Chinese Text-to-Speech Model: 8GB+ VRAM, File List (1.9B, 8GB)
- tiny-voca English Text-to-Speech Model: 4GB+ VRAM, File List (4GB)
- TTS-V3 Phone-Dialogue Specialized TTS Model: 8GB+ VRAM, File List (1.9B)
What to Read Next
- Find models by VRAM (This model needs at least 32GB) → VRAM quick reference
- Explore the same model family → drama-3 family overview (1 articles, 1 converted builds)
- What INT4 mean and where to get this model → GGUF format guide and models / Quantization and model-format glossary
- Learn about the publisher → Fish Audio: models, licenses and articles
- How to read WER → Benchmark glossary
Sources
This article contains unverified information. We will append an update note once it is confirmed by a primary source.

