How to run Dia text-to-speech on a cloud GPU

Rent a GPU on Deploy, then open a terminal in JupyterLab or over SSH. Install Dia from the official nari-labs/dia repository, run example/simple.py or cli.py, and copy the audio off the instance before you destroy it, because destroying the instance deletes its disk.

Other speech pages: How to run Kokoro TTS on a cloud GPU, How to run Chatterbox TTS on a cloud GPU, How to run XTTS-v2 on a cloud GPU, How to run Spark-TTS on a cloud GPU, and How to run MeloTTS on a cloud GPU. The Spark-TTS README prints no GB figure. The MeloTTS README prints no GPU GB figure. If the process runs out of memory: How to fix CUDA out of memory on a cloud GPU. The tunnel for the Gradio app is How to use SSH port forwarding on a cloud GPU.

Use a reference clip you have the right to clone. The README disclaimer says not to produce audio resembling real individuals without permission, not to generate misleading content, and not to use the model for illegal or malicious activity. The repository LICENSE file is the Apache License, Version 2.0, and the appendix copyright line is Copyright 2025 Nari Labs. The GitHub license field on 2026-11-13 was Apache-2.0. The model card for nari-labs/Dia-1.6B-0626 the same day had license apache-2.0 and gated false, lastModified 2025-07-03T14:45:09.000Z. Read those files before you redistribute the program or the weights.

The commands below are copied from the upstream files named in each step. They were not run on a CloudGPU instance for this page. Anything this page adds around them is marked.

What the README and the model card say about memory

The README says Dia has been tested on GPUs only, with pytorch 2.0+ and CUDA 12.6, and that the speed table was benchmarked on an RTX 4090. The table, copied:

precision realtime factor w/ compile realtime factor w/o compile VRAM
bfloat16 x2.1 x1.5 ~4.4GB
float16 x2.2 x1.3 ~4.4GB
float32 x1 x0.9 ~7.9GB

The model card’s hardware section, read 2026-11-13, says the full version of Dia requires around 10GB of VRAM to run. It also says that on an A4000, Dia roughly generates 40 tokens/s, and that 86 tokens equals 1 second of audio. A4000 is not a name in gpu-prices.json. This page did not remeasure the table or the 40 tokens/s sentence. The two files do not print the same GB figure. This page does not pick one of them.

GET /v1/public/compute-capabilities does not list GPUs. It returns feature flags. The memory column is vram_gb from gpu-prices.json, updated_at 2026-11-13T06:05:49.853Z. GET /v1/public/gpu-catalog the same day (generated_at 2026-11-13T06:05:50.927Z) listed the same names and the same vram_gb values, plus Ascend 910B at 64, which is not in gpu-prices.json and is not listed here. The catalog response also includes an availability field. This page does not copy it. Every prices row has gpu_count 1. Catalog RTX 4090 is 24. That catalog number is not a cell in the README table. Catalog RTX 2080 is 8, which is below the model card’s “around 10GB” wording. Catalog RTX 3080 is 10. This page did not run Dia and does not mark a row as enough. Which listing you can start is on Deploy.

The catalog template list had no Dia template.

Catalog name vram_gb
RTX 2080 8
RTX 3080 10
RTX 2080 Ti 11
RTX 3080 Ti 12
V100 16G 16
A30 24
RTX 3090 24
RTX 4090 24
RTX 4090D 24
RTX 4080 SUPER 32G 32
RTX 5090 32
RTX 5090D 32
V100 32G 32
A100 40G 40
A800 40G 40
A40 48
RTX 4090 48G 48
RTX 4090D 48G 48
RTX A6000 48
NVIDIA RTX PRO 5000 72G 72
RTX PRO 5000 72G 72
A100 80G 80
A800 80G 80
H800 80
RTX 6000D 83
H20 96G 96
RTX PRO 6000 96G 96
RTX PRO 6000 Max-Q 96
H20-3e 141G 141

Install

On Deploy, choose Raw GPU. The README says the model is a 1.6B parameter text-to-speech model and that it only supports English generation at the moment. The weights line in that file is nari-labs/Dia-1.6B-0626. The model card’s prose says the weights are hosted on nari-labs/Dia-1.6B. A request for that model API on 2026-11-13 returned HTTP 200. This page did not read that card. The code blocks below use nari-labs/Dia-1.6B-0626.

The README’s pip install, copied:

git clone https://github.com/nari-labs/dia.git
cd dia

python -m venv .venv && source .venv/bin/activate

pip install -e .

The same file also prints pip install git+https://github.com/nari-labs/dia.git and, if uv is installed, uv run example/simple.py after the clone. pyproject.toml sets name to nari-tts, version to 0.1.0, and requires-python to >=3.10. It pins torch==2.6.0, torchaudio==2.6.0, and gradio>=5.25.2, and it lists descript-audio-codec>=1.0.0. The uv index block points Linux and Windows torch wheels at https://download.pytorch.org/whl/cu126. The pip install -e . block does not print that URL. The README says the initial run takes longer because the Descript Audio Codec also needs to be downloaded. The commits API for the default branch main listed 876125e461a03b157ec905b0fe8b57a0f8b9e7a0, committed 2025-11-19T21:11:55Z. pyproject.toml was 655286e16a1dfc882e25c4d2925c48d9440c71b4, committed 2025-04-26T08:06:58Z. This page did not install the package.

The README says: if you are using a 5000 series GPU, use torch 2.8 nightly, and it points at issue #26. That issue was still open on 2026-11-13. Its title is “Support for 5000 series Nvidia GPU’s”. The issue body prints a nightly CUDA 12.8 pip line and then a dtype error from app.py. This page did not run that pip line. pyproject.toml still pins torch==2.6.0 and the cu126 index. The RTX 5090 guide says that card is compute capability 12.0 (sm_120) and that PyTorch 2.7 and later, on a build for CUDA 12.8 or newer, is the line that announced support. This page did not re-test Dia on an RTX 5090. Catalog RTX 5090 and RTX 5090D are 32. That is the catalog number only.

Speaker tags, the Python example, and the CLI

The README says to begin the transcript with [S1] and to alternate [S1] and [S2]. It says a short input corresponding to under 5s of audio will sound unnatural, and a very long input corresponding to over 20s of audio will make the speech unnaturally fast. For a clone clip it says 5~10 seconds, and it writes 1 second ≈ 86 tokens. The nonverbal tags it lists are (laughs), (clears throat), (sighs), (gasps), (coughs), (singing), (sings), (mumbles), (beep), (groans), (sniffs), (claps), (screams), (inhales), (exhales), (applause), (burps), (humming), (sneezes), (chuckle), and (whistles).

example/simple.py, copied:

from dia.model import Dia


model = Dia.from_pretrained("nari-labs/Dia-1.6B-0626", compute_dtype="float16")

text = "[S1] Dia is an open weights text to dialogue model. [S2] You get full control over scripts and voices. [S1] Wow. Amazing. (laughs) [S2] Try it now on Git hub or Hugging Face."

output = model.generate(
    text,
    use_torch_compile=False,
    verbose=True,
    cfg_scale=3.0,
    temperature=1.8,
    top_p=0.90,
    cfg_filter_top_k=50,
)

model.save_audio("simple.mp3", output)

The README’s command for that file is python example/simple.py, run from the repository after install. dia/model.py sets DEFAULT_SAMPLE_RATE = 44100. save_audio writes with that rate. from_pretrained defaults compute_dtype to ComputeDtype.FLOAT32 when the caller omits it. generate defaults temperature to 1.2. The commits API listed example/simple.py and dia/model.py at 65028e0c5f8466ea8fe9eaf704a38b9ce9ef9709 (2025-06-27T09:35:09Z). This page did not run the script.

example/voice_clone.py uses the same from_pretrained call with compute_dtype="float16". Its comments say to run simple.py first. It sets clone_from_audio = "simple.mp3" and passes clone_from_text + text_to_generate to generate with audio_prompt=clone_from_audio. It then calls model.save_audio("voice_clone.mp3", output). The same commit covers that file. This page did not run it.

The README’s CLI block is python cli.py --help. cli.py requires a positional text argument and --output. The default --repo-id is nari-labs/Dia-1.6B-0626. --audio-prompt is the optional wav for cloning. --temperature is stored as default=1.3, and the help string says default: 0.7. The write uses soundfile at sample_rate = 44100. The commits API listed cli.py at 02951bc4ac8860a378398b2239e1b1a2dd15dbed (2025-06-28T11:48:24Z). The README does not print a full cli.py invocation. This line uses only arguments that file defines, with the transcript from example/simple.py. It was not run:

python cli.py "[S1] Dia is an open weights text to dialogue model. [S2] You get full control over scripts and voices. [S1] Wow. Amazing. (laughs) [S2] Try it now on Git hub or Hugging Face." --output simple.wav

The README’s Transformers block installs pip install git+https://github.com/huggingface/transformers.git and saves example.mp3 from processor.save_audio. The model card’s Transformers block instead prints pip install "transformers[torch]" and saves example.wav. This page follows the README block and did not run either one.

Gradio

The README’s UI commands, copied:

python app.py

uv run app.py

app.py loads nari-labs/Dia-1.6B-0626 and, when the device type is cuda, passes compute_dtype="float16". It calls demo.launch(share=args.share). The comment above that call says GRADIO_SERVER_NAME and GRADIO_SERVER_PORT override the default values, and it names GRADIO_SERVER_NAME=0.0.0.0 for Docker. The file does not assign a port number. --share turns on Gradio sharing. This page does not pass --share. An uploaded prompt is written to a NamedTemporaryFile with suffix .wav. The generated clip is returned to the audio widget. The commits API listed app.py at the same commit as cli.py. This page did not start the UI. Forward the local URL the process prints with how to use SSH port forwarding on a cloud GPU.

The README does not link a ComfyUI install. The ComfyUI examples top-level directory list on 2026-11-13 had no directory named for this project. Examples HEAD was f9431bb000ce792094ff345446e22cac1ea6cef3. This page does not add a ComfyUI install.

When it fails

CUDA out of memory. The README table and the model card print the GB figures above and no flag that lowers them. If the process raises that error, use how to fix CUDA out of memory on a cloud GPU.

“CUDA error: no kernel image is available for execution on the device” on an RTX 5090. See the 5000-series paragraph in the install section. This page did not re-test the package on that card.

Save the audio, then destroy

Copy simple.mp3, voice_clone.mp3, or the --output path you passed, before you destroy the instance. The Gradio widget’s download is separate from those paths. Save your work before you destroy a cloud GPU is the checklist. The terms say data on local instance storage is permanently deleted when the instance is destroyed.

The pricing page FAQ states the billing rule in these words:

Per-minute options have a 1-minute minimum; unused prepaid minutes are refunded when you destroy the instance. Some configurations use whole-hour billing with a 1-hour minimum; unused time within a charged hour is not refunded on voluntary stop. The billing period, minimum charge and initial prepayment are shown before confirmation. No subscription.

Frequently asked questions

Which VRAM figures do the Dia README and the model card print?

The README says the speed table was benchmarked on an RTX 4090. The VRAM column is ~4.4GB for bfloat16, ~4.4GB for float16, and ~7.9GB for float32. The model card says the full version of Dia requires around 10GB of VRAM to run, and it names an A4000 for a 40 tokens/s figure. A4000 is not a name in gpu-prices.json. Catalog RTX 4090 is 24, which is the catalog number, not the VRAM cell. Catalog RTX 2080 is 8, which is below the model card’s around 10GB wording. This page did not run Dia and does not mark a catalog row as enough. Which listing you can start is on https://cloudgpu.app/deploy.

How do the documented examples use speaker tags and voice cloning?

The README says to begin input text with [S1] and to alternate [S1] and [S2]. example/simple.py uses those tags and saves simple.mp3. example/voice_clone.py says to run simple.py first, sets the prompt audio to simple.mp3, and passes the prompt transcript plus the new transcript to generate with audio_prompt. The README says a clone clip of 5~10 seconds is for the best results, and it writes 1 second ≈ 86 tokens. Use a clip you have the right to clone. The README forbids producing audio that resembles a real person without permission.

Where is the audio file saved, and which command starts Gradio?

example/simple.py calls model.save_audio(“simple.mp3”, output). example/voice_clone.py writes voice_clone.mp3. dia/model.py sets DEFAULT_SAMPLE_RATE to 44100, and save_audio writes with that rate. cli.py requires --output and writes that path with soundfile at 44100. The README starts the UI with python app.py or uv run app.py. app.py calls demo.launch(share=args.share) and does not set a port. The comment above that call names GRADIO_SERVER_NAME and GRADIO_SERVER_PORT. This page did not start the UI and does not pass --share.

Which license covers the Dia code and the weights?

The repository LICENSE file is the Apache License, Version 2.0, with the copyright line Copyright 2025 Nari Labs. The GitHub license field on 2026-11-13 was Apache-2.0. The model card for nari-labs/Dia-1.6B-0626 the same day had license apache-2.0 and gated false. The README disclaimer says the model is intended for research and educational use and forbids identity misuse, deceptive content, and illegal or malicious use. Read those files before you redistribute the program or the weights.

Sources (read 2026-11-13, Asia/Shanghai)

  • nari-labs/dia README (install, python example/simple.py, python cli.py --help, python app.py, speaker tags, 5~10 seconds, 1 second ≈ 86 tokens, RTX 4090 VRAM table, 5000-series note, Apache-2.0, disclaimer): https://github.com/nari-labs/dia/blob/main/README.md commit 876125e461a03b157ec905b0fe8b57a0f8b9e7a0. That commit is also repository HEAD, 2025-11-19T21:11:55Z
  • example/simple.py and example/voice_clone.py (compute_dtype="float16", simple.mp3, voice_clone.mp3): commit 65028e0c5f8466ea8fe9eaf704a38b9ce9ef9709
  • dia/model.py (DEFAULT_SAMPLE_RATE = 44100, from_pretrained default FLOAT32, generate default temperature 1.2): same commit
  • cli.py (--output required, --temperature default 1.3, help text default: 0.7, sample_rate = 44100): commit 02951bc4ac8860a378398b2239e1b1a2dd15dbed
  • app.py (compute_dtype float16 on cuda, demo.launch(share=args.share), GRADIO_SERVER_NAME comment): same commit
  • pyproject.toml (torch==2.6.0, gradio>=5.25.2, cu126 index, descript-audio-codec): commit 655286e16a1dfc882e25c4d2925c48d9440c71b4
  • LICENSE (Apache-2.0, Copyright 2025 Nari Labs): commit 51e5405949cd9fc5e9713fce22d77c34a833db5e. GitHub license field Apache-2.0
  • Issue #26 (open on 2026-11-13, title “Support for 5000 series Nvidia GPU’s”): https://github.com/nari-labs/dia/issues/26
  • Model card nari-labs/Dia-1.6B-0626 (license apache-2.0, gated false, around 10GB, A4000 at 40 tokens/s): https://huggingface.co/nari-labs/Dia-1.6B-0626 read 2026-11-13, lastModified 2025-07-03T14:45:09.000Z. The card’s prose also names nari-labs/Dia-1.6B. That model API returned HTTP 200 the same day. This page did not read that card
  • ComfyUI examples top-level directories (no Dia directory): https://github.com/comfyanonymous/ComfyUI_examples commit f9431bb000ce792094ff345446e22cac1ea6cef3
  • Public GPU memory: https://cloudgpu.app/gpu-prices.json (updated_at 2026-11-13T06:05:49.853Z) and https://cloudgpu.app/v1/public/gpu-catalog (generated_at 2026-11-13T06:05:50.927Z). GET /v1/public/compute-capabilities returned feature flags and no GPU list. The catalog had no Dia template

Cards you can start are on the Deploy page. Prices are on https://cloudgpu.app/pricing and are not repeated here.

Last updated: 2026-11-13 (Asia/Shanghai).