How to run Parler-TTS on a cloud GPU

Rent a GPU on Deploy, then open a terminal in JupyterLab or over SSH. Install Parler-TTS from the official huggingface/parler-tts repository, let from_pretrained download the checkpoint the README sample names, and run that sample. Copy parler_tts_out.wav 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 Dia text-to-speech on a cloud GPU, How to run MeloTTS on a cloud GPU, and How to run Zonos TTS on a cloud GPU. The MeloTTS README prints no GPU GB figure. The Dia README’s RTX 4090 table prints ~4.4GB and ~7.9GB, and the Dia model card says around 10GB. The Zonos README says 6GB+ VRAM. How published FLUX and SDXL weight sizes are read: How much VRAM do I need for FLUX and SDXL. If the process runs out of memory: How to fix CUDA out of memory on a cloud GPU.

The README says Parler-TTS is a reproduction of the paper “Natural language guidance of high-fidelity text-to-speech with synthetic annotations” by Dan Lyth and Simon King, and that sentence names their affiliations. The repository LICENSE file is the Apache License, Version 2.0. The appendix copyright line is Copyright [2024] [The HuggingFace Inc. team]. The README says the datasets, pre-processing, training code, and weights are released publicly under a permissive license. The GitHub license field on 2026-11-13 was Apache-2.0. The model cards for parler-tts/parler-tts-mini-v1 and parler-tts/parler-tts-large-v1 that day had cardData.license apache-2.0, top-level license null, and gated false, lastModified 2024-11-25T11:26:20.000Z and 2024-11-22T16:17:20.000Z. The card for parler-tts/dac_44khZ_8kbps had cardData.license mit, top-level license null, and gated false, lastModified 2024-04-10T11:43:09.000Z. Read the 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 says about memory

The README and the model cards this page read print no GPU GB figure (read 2026-11-13). The README’s 08/08/2024 note calls Parler-TTS Mini an 880M parameter model and Parler-TTS Large a 2.3B parameter model, and says those checkpoints were trained on 45k hours of audiobook data. The large model card calls the same checkpoint a 2.2B-parameters model and says it was trained on 45K hours of audio data. The mini model card says it was trained on 45K hours of audio data and does not print 880M. Those are parameter counts and training-data figures. This page does not treat them as GPU GB figures.

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-13T10:09:27.510Z. GET /v1/public/gpu-catalog the same day (generated_at 2026-11-13T10:09:28.527Z) 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. There is no upstream GB cutoff to match these values against. The smallest vram_gb in that file is 8, on RTX 2080. Catalog RTX 4090 is 24. This page did not run Parler-TTS and does not mark a row as enough. Which listing you can start is on Deploy.

The catalog template list had no Parler-TTS 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’s install line, copied. It does not print a separate clone. The URL is the repository.

pip install git+https://github.com/huggingface/parler-tts.git

The README’s follow-up for Apple Silicon, copied. It is the README’s CPU nightly line. It is not a CUDA install line.

pip3 install --pre torch torchaudio --index-url https://download.pytorch.org/whl/nightly/cpu

setup.py requires transformers>=4.46.1,<=4.46.1, torch with no version, sentencepiece, descript-audio-codec, descript-audiotools from git+https://github.com/descriptinc/audiotools, and protobuf>=4.0.0. The comment on the audiotools line says it is a temporary fix as long as 0.7.4 is not published. The commits API for the default branch main listed d108732cd57788ec86bc857d99a6cabd66663d68, committed 2024-12-10T08:28:12Z. README.md and INFERENCE.md were 7f97328cf777016d9f802a041bf2c8d71a9a4580, committed 2024-10-14T12:09:44Z. setup.py was 32736a74cca201ec2fe8242f93ebf768369f51bc, committed 2024-10-30T12:48:13Z.

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. setup.py depends on torch and does not pin a version. This page did not re-test Parler-TTS on an RTX 5090. Catalog RTX 5090 and RTX 5090D are 32. That is the catalog number only.

The documented Python sample

The random-voice sample, copied. The description is a text prompt. It writes parler_tts_out.wav.

import torch
from parler_tts import ParlerTTSForConditionalGeneration
from transformers import AutoTokenizer
import soundfile as sf

device = "cuda:0" if torch.cuda.is_available() else "cpu"

model = ParlerTTSForConditionalGeneration.from_pretrained("parler-tts/parler-tts-mini-v1").to(device)
tokenizer = AutoTokenizer.from_pretrained("parler-tts/parler-tts-mini-v1")

prompt = "Hey, how are you doing today?"
description = "A female speaker delivers a slightly expressive and animated speech with a moderate speed and pitch. The recording is of very high quality, with the speaker's voice sounding clear and very close up."

input_ids = tokenizer(description, return_tensors="pt").input_ids.to(device)
prompt_input_ids = tokenizer(prompt, return_tensors="pt").input_ids.to(device)

generation = model.generate(input_ids=input_ids, prompt_input_ids=prompt_input_ids)
audio_arr = generation.cpu().numpy().squeeze()
sf.write("parler_tts_out.wav", audio_arr, model.config.sampling_rate)

The README’s 08/08/2024 note also names parler-tts/parler-tts-large-v1. The sample above loads the mini id. configuration_parler_tts.py defines sampling_rate as a property that returns self.audio_encoder.sampling_rate. This page did not load a checkpoint, so it does not print a numeric rate. That file was 32736a74cca201ec2fe8242f93ebf768369f51bc, committed 2024-10-30T12:48:13Z.

The specific-speaker sample uses the same two calls and the same output filename. Its description is Jon's voice is monotone yet slightly fast in delivery, with a very close recording that almost has no background noise. The README says the checkpoint was trained on 34 speakers and lists Laura, Gary, Jon, Lea, Karen, Rick, Brenda, David, Eileen, Jordan, Mike, Yann, Joy, James, Eric, Lauren, Rose, Will, Jason, Aaron, Naomie, Alisa, Patrick, Jerry, Tina, Jenna, Bill, Tom, Carol, Barbara, Rebecca, Anna, Bruce, Emily. INFERENCE.md prints the same names and adds the word “and” before Emily. It also ranks speakers by similarity scores. This page does not copy those tables. This page did not run the samples.

Speed-up options

INFERENCE.md says Parler-TTS benefits from optimizations that can make the model up to 4x faster, and that you can achieve time-to-first audio in under 500ms on a modern GPU. It says SDPA is used by default and speeds generation by up to 1.4x compared with eager attention. It says compiling the forward method can speed generation by up to 4.5x. The prose says mode=default brings a speed-up of 1.4 times compared with no compilation, while mode="reduce-overhead" brings much faster generation. The compile sample’s comment says to choose reduce-overhead for a 3 to 4x speed-up. Those sentences are the file’s. This page did not remeasure them. The under-500ms sentence is that file’s inference sentence.

The attention switch, copied. The comments are the file’s.

from parler_tts import ParlerTTSForConditionalGeneration

torch_device = "cuda:0" # use "mps" for Mac
torch_dtype = torch.bfloat16
model_name = "parler-tts/parler-tts-mini-v1"

attn_implementation = "eager" # "sdpa" or "flash_attention_2"

model = ParlerTTSForConditionalGeneration.from_pretrained(
    model_name,
    attn_implementation=attn_implementation
).to(torch_device, dtype=torch_dtype)

Installing FlashAttention on a rented GPU is How to install FlashAttention on a cloud GPU. This page did not install it and did not pass flash_attention_2.

The streaming section says each set of generated audio codes corresponds to 0.011 seconds, and that 1720 decoding steps generate 20 seconds of audio. It names the DAC model parler-tts/dac_44khZ_8kbps. The streaming sample yields chunks and does not itself call a write. The batch sample writes sample_out.wav and sample_out_2.wav with feature_extractor.sampling_rate. The README sample uses model.config.sampling_rate. This page did not check that those three attributes return the same number.

Web UI

The README links a hosted demo and does not document a local server command. The repository also contains helpers/gradio_demo/app.py. That file sets repo_id to parler-tts/parler_tts_mini_v0.1 and calls block.launch(share=True). It does not set a server port. That repo id is not the README sample’s parler-tts/parler-tts-mini-v1. The model API for parler-tts/parler_tts_mini_v0.1 on 2026-11-13 returned gated false and cardData.license apache-2.0, lastModified 2024-04-30T18:17:59.000Z. The file was 862f84181589ea980d41d279ec53841bc8e178d2, committed 2024-08-07T11:26:03Z. This page did not start it. Because the file does not set a port, this page does not add a tunnel step for it. A tunnel for a server that does bind a port is How to use SSH port forwarding on a cloud GPU.

The README’s training section prints this command. It was not run.

accelerate launch ./training/run_parler_tts_training.py ./helpers/training_configs/starting_point_v1.json

ComfyUI

The README does not document 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, committed 2025-11-26T20:33:58Z. Installing ComfyUI itself is How to install ComfyUI and ComfyUI-Manager on a cloud GPU. This page does not add a ComfyUI install.

When it fails

CUDA out of memory. The files this page read do not print a GPU GB figure or a low-memory flag. 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 install section. This page did not re-test the package on that card.

Mini and large parameter counts. The README says 2.3B for the large checkpoint. The large model card says 2.2B. This page does not pick one of those counts as a VRAM figure.

Two output names. The README sample writes parler_tts_out.wav. The batch sample in INFERENCE.md writes sample_out.wav and sample_out_2.wav.

Save the audio, then destroy

The README sample writes parler_tts_out.wav in the working directory. The batch sample writes sample_out.wav and sample_out_2.wav. The streaming sample yields chunks and does not itself write a file. Copy the wav before you destroy the instance. 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

What GPU requirement and which model sizes does the Parler-TTS README state?

The README and the model cards this page read print no GPU GB figure. The README 08/08/2024 note calls Parler-TTS Mini an 880M parameter model and Parler-TTS Large a 2.3B parameter model, and says those checkpoints were trained on 45k hours of audiobook data. The large model card calls the same checkpoint a 2.2B-parameters model and says it was trained on 45K hours of audio data. Those are parameter counts and training-data figures, not GPU GB figures. The sample loads parler-tts/parler-tts-mini-v1. The note also names parler-tts/parler-tts-large-v1. There is no upstream GB cutoff to match against gpu-prices.json (updated_at 2026-11-13T10:09:27.510Z). The smallest vram_gb in that file is 8, on RTX 2080. Catalog RTX 4090 is 24. This page did not run Parler-TTS and does not mark a row as enough. Which listing you can start is on https://cloudgpu.app/deploy.

Which sample writes the wav, and which speed-up options does INFERENCE.md document?

The README sample calls sf.write with parler_tts_out.wav, the squeezed generation, and model.config.sampling_rate. configuration_parler_tts.py defines sampling_rate as a property that returns audio_encoder.sampling_rate. This page did not load that value. The INFERENCE.md batch example writes sample_out.wav and sample_out_2.wav with feature_extractor.sampling_rate. Its streaming example yields chunks and does not itself call a write. INFERENCE.md says the optimizations can make the model up to 4x faster, and that you can achieve time-to-first audio in under 500ms on a modern GPU. It says SDPA is the default and speeds generation by up to 1.4x compared with eager attention, and that compiling the forward method can speed generation by up to 4.5x. The compile sample comments that mode reduce-overhead is for a 3 to 4x speed-up, and the prose says mode=default brings 1.4 times compared with no compilation. Those sentences are the file. This page did not remeasure them. The under-500ms sentence is that file inference sentence.

Does the repository ship a local web UI, and does it document ComfyUI?

The README links a hosted demo and does not document a local server command. The repository contains helpers/gradio_demo/app.py, which loads parler-tts/parler_tts_mini_v0.1 and calls block.launch with share=True. It does not set a server port. That repo id is not the README sample id parler-tts/parler-tts-mini-v1. The model API for parler-tts/parler_tts_mini_v0.1 on 2026-11-13 returned gated false and cardData.license apache-2.0. This page did not start the helper. The README does not document ComfyUI. The ComfyUI examples top-level directory list on 2026-11-13 had no directory named for this project. Examples HEAD was f9431bb000ce792094ff345446e22cac1ea6cef3.

Which license covers Parler-TTS?

The repository LICENSE file is the Apache License, Version 2.0, and the appendix copyright line is Copyright [2024] [The HuggingFace Inc. team]. The README says the datasets, pre-processing, training code, and weights are released publicly under a permissive license. The GitHub license field on 2026-11-13 was Apache-2.0. The cards for parler-tts/parler-tts-mini-v1 and parler-tts/parler-tts-large-v1 had cardData.license apache-2.0, top-level license null, and gated false. The card for parler-tts/dac_44khZ_8kbps had cardData.license mit, top-level license null, and gated false. Section 2 of the Apache file grants a no-charge, royalty-free copyright license. That wording is the upstream license, not a CloudGPU price and not a storage allowance. Read the files before you redistribute the program or the weights.

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

  • Parler-TTS README (install URL, random-voice sample, parler_tts_out.wav, mini 880M, large 2.3B, 45k hours, 34 speaker names, parler-tts/parler-tts-mini-v1, parler-tts/parler-tts-large-v1): https://github.com/huggingface/parler-tts/blob/main/README.md commit 7f97328cf777016d9f802a041bf2c8d71a9a4580. Repository HEAD d108732cd57788ec86bc857d99a6cabd66663d68, committed 2024-12-10T08:28:12Z
  • INFERENCE.md (SDPA, Flash Attention 2, compile speed sentences, the under-500ms sentence, parler-tts/dac_44khZ_8kbps, sample_out.wav): commit 7f97328cf777016d9f802a041bf2c8d71a9a4580
  • setup.py (transformers>=4.46.1,<=4.46.1, unpinned torch, descript-audio-codec): commit 32736a74cca201ec2fe8242f93ebf768369f51bc
  • parler_tts/configuration_parler_tts.py (sampling_rate property): commit 32736a74cca201ec2fe8242f93ebf768369f51bc
  • helpers/gradio_demo/app.py (parler-tts/parler_tts_mini_v0.1, block.launch(share=True)): commit 862f84181589ea980d41d279ec53841bc8e178d2
  • LICENSE (Apache-2.0, Copyright [2024] [The HuggingFace Inc. team]): commit fa0d258d365601c4c3174b89352dd27cd80b54bd. GitHub license field Apache-2.0
  • Model cards parler-tts/parler-tts-mini-v1 and parler-tts/parler-tts-large-v1 (apache-2.0, gated false; the large card says 2.2B), parler-tts/dac_44khZ_8kbps (mit, gated false), and parler-tts/parler_tts_mini_v0.1 (apache-2.0, gated false), read 2026-11-13
  • ComfyUI examples top-level directories (no Parler-TTS directory): https://github.com/comfyanonymous/ComfyUI_examples commit f9431bb000ce792094ff345446e22cac1ea6cef3
  • Public GPU memory: https://cloudgpu.app/gpu-prices.json (updated_at 2026-11-13T10:09:27.510Z) and https://cloudgpu.app/v1/public/gpu-catalog (generated_at 2026-11-13T10:09:28.527Z). GET /v1/public/compute-capabilities returned feature flags and no GPU list. The catalog had no Parler-TTS 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).