Running a small text-to-speech model locally doesn't require a flagship GPU — it requires a GPU that comfortably clears the model's VRAM peak, which for many compact local TTS setups lands around 5GB. That single number does more to determine which card you need than clock speed, core count, or generation.
This synthesis maps that 5GB VRAM peak against publicly documented GPU specifications — VRAM capacity, memory bus width, and bandwidth from TechPowerUp's GPU database — plus how local TTS projects like Coqui's XTTS-v2, Suno's Bark, and Piper describe their own memory footprints. It does not report first-party inference-speed benchmarks; per-card timing numbers vary too much by quantization, batch size, and driver version to state as fixed figures, and no verified benchmark run backs specific per-second claims here. Where community reports exist, they're cited; where they don't, the honest answer is "varies by workload."
Why a 5GB VRAM Peak Is the Number That Matters
A "small" TTS model in local-inference terms usually means somewhere in the few-hundred-million to low-single-digit-billion parameter range — well below the LLMs covered in SpecPicks' best GPU for Llama 8B under $300 guide, but with its own memory profile shaped by mel-spectrogram generation, vocoder inference, and (for voice-cloning models) speaker-embedding extraction running in the same pass.
According to the model card for Coqui's XTTS-v2 and the project's own GitHub repository, VRAM use scales with precision and whether streaming or full-utterance synthesis is used — fp16 inference on shorter clips is what typically keeps peak usage in the mid-single-digit-gigabyte range that this topic describes. Lighter architectures like Piper run comfortably below that, while larger configurations of Bark can exceed it. A 5GB peak is a reasonable middle point for this class of model, not a universal constant.
The practical takeaway: a GPU with 6GB of VRAM is already cutting it close once you account for OS overhead, the CUDA/ROCm runtime, and whatever else is resident (a browser, a Discord overlay, a second model). 8GB is where most people stop worrying about it.
GPU VRAM Tiers for a 5GB TTS Workload
The table below groups current and previous-generation consumer GPUs by VRAM capacity and memory bandwidth, both pulled from TechPowerUp's GPU specifications database. Bandwidth is included because, once a card clears the VRAM bar, it's the number that most affects how fast data moves during inference — not raw VRAM capacity.
| Tier | Example GPUs | VRAM | Memory bus / bandwidth (approx.) | Fit for a 5GB peak |
|---|---|---|---|---|
| Marginal | GTX 1650 4GB, RX 6500 XT 4GB | 4GB | 128-bit, ~192-224 GB/s | Too tight — expect swapping or OOM on longer utterances |
| Adequate | GTX 1660 Super 6GB, RTX 2060 6GB | 6GB | 192-bit, ~336 GB/s | Workable with little headroom for anything else resident |
| Comfortable | RTX 3060 12GB, RX 6600/6600 XT 8GB, RX 7600 8GB, RTX 4060 8GB | 8-12GB | 128-192-bit, ~224-360 GB/s | Standard recommendation — clears the peak with real headroom |
| Overkill for this workload alone | RX 6700 XT 12GB, RX 7700 XT 12GB, RTX 4060 Ti 16GB | 12-16GB | 192-256-bit, ~360-450 GB/s | Only worth it if you're also running a larger LLM or SD model alongside TTS |
This mirrors the same headroom logic covered in SpecPicks' best GPU for Ollama on 12GB VRAM piece: buy for the largest model you'll realistically run, not the smallest one, because VRAM is the hard ceiling and bandwidth is the speed dial once you're above it.
Where More VRAM Stops Helping
Once a card's VRAM clears the model's peak with a comfortable margin, adding more capacity mostly buys you the ability to run longer batches, cache more audio, or run a second model concurrently — it does not meaningfully change per-utterance latency for a single 5GB-peak workload. That's a similar dynamic to what SpecPicks documented on the gaming side in How Running Out of VRAM Affects Your FPS: the penalty is a cliff when you're under the requirement, and a plateau once you're comfortably over it. There's no publicly benchmarked case for this specific workload showing a 12GB card meaningfully outperforming an 8GB card once both clear the VRAM bar — if you find one, treat any specific speed delta as workload- and driver-dependent rather than a fixed multiplier.
Architecture Notes: Older vs Newer Cards
Newer architectures generally bring higher memory bandwidth per VRAM tier and better software support in current CUDA/ROCm builds, both of which matter for inference throughput. But for a workload that peaks at 5GB, the architecture generation matters less than simply clearing the capacity threshold — a previous-generation 8GB card with mature driver support is a perfectly reasonable pick, and often cheaper than chasing the newest SKU in the same VRAM tier. If you're also considering a card for gaming or a small local LLM, weigh the generational bandwidth differences documented on TechPowerUp against your actual secondary workload rather than this TTS use case alone.
Budget Picks Under $300
For a TTS-only build, previous-generation 6-8GB cards are typically the best value, since current-gen pricing premiums buy bandwidth and features (frame generation, newer codecs) that don't move the needle for audio inference. The same reasoning SpecPicks applies in Best GPU for Llama 8B Under $300 holds here: buy the VRAM tier you need on the oldest architecture still receiving driver updates, and put the savings toward RAM or storage instead.
If you're building a whole machine around this rather than dropping a card into an existing rig, SpecPicks' Small Form Factor Gaming PC Build Guide covers case and PSU headroom considerations that apply just as much to a compact local-AI box.
No Discrete GPU? Other Paths for Local TTS
A 5GB-peak TTS model is also within reach of some integrated and CPU-only setups, just slower. SpecPicks' Running a 26B LLM Locally With No GPU and Running Local LLMs on the Ryzen 5 5600G iGPU pieces cover the tradeoffs of skipping a discrete card entirely — the same logic (accept higher latency in exchange for zero additional hardware cost) applies to TTS. For always-on, privacy-sensitive use cases like a local voice assistant, see Private Smart Home: Running a Local LLM Voice Assistant, and for non-NVIDIA hardware, IPEX-LLM + Ollama in Docker covers running local models on Intel GPUs specifically.
Benchmarking Your Own Card
Rather than relying on secondhand numbers for a workload as configuration-sensitive as TTS, the most reliable approach is measuring on your own hardware:
- Watch live VRAM usage with
nvidia-smi -l 1(NVIDIA) orrocm-smi(AMD) while running an inference pass, to confirm your actual peak against the model's stated footprint. - Time a fixed batch of utterances with Python's
timemodule around the inference call to get a real, reproducible per-utterance number for your exact model, precision, and driver combination. - If renting hardware to test before buying, cloud GPU marketplaces like Vast.ai let you spin up a range of card types by the hour to compare VRAM headroom and rough throughput on your specific model before committing to a purchase.
- Cross-check your results against community reports in r/LocalLLaMA, where users regularly post real hardware/model/precision combinations for TTS and other local-inference workloads.
Citations and sources
- https://www.techpowerup.com/gpu-specs/
- https://huggingface.co/coqui/XTTS-v2
- https://github.com/coqui-ai/TTS
- https://github.com/suno-ai/bark
- https://github.com/rhasspy/piper
- https://www.reddit.com/r/LocalLLaMA/
- https://vast.ai/pricing
This piece is editorial synthesis based on publicly available information. No independent first-party benchmarking is reported.