Kokoro is an unusual model to write a GPU guide about, because the honest headline is that it does not need one. Eighty-two million parameters, faster than real time on a laptop CPU, Apache 2.0 licensed. If you want to generate a few hundred words of speech, you do not need to rent anything.
So this guide covers two things: how to run it, and the more useful question of when a GPU actually earns its cost. The answer is about throughput, not capability.
What is Kokoro TTS?
Kokoro is an open-weights text-to-speech model published by hexgrad as Kokoro-82M. Its distinguishing feature is efficiency: at 82 million parameters it is a fraction of the size of most competitive TTS models, yet it reached the top of the TTS Arena leaderboard against models many times larger.
- Parameters: 82 million
- Voices: 54 across eight languages as of the v1.0 release
- Output: 24 kHz audio
- License: Apache 2.0, so commercial use is permitted without restriction
- Speed: faster than real time on CPU, and several times faster again on a GPU
The quality-to-size ratio is what makes it interesting. Most TTS models buy naturalness with parameters. Kokoro gets close to the larger models' output while staying small enough to run almost anywhere.
When do you actually need a GPU?
Being straightforward about this saves you money.
You do not need a GPU for: generating occasional narration, prototyping voice features, converting a handful of articles to audio, or anything where you are waiting on a human rather than a queue. CPU is fine, and it costs you nothing in GPU time.
A GPU earns its cost for:
- Batch conversion at volume. Turning a back catalogue of thousands of articles into audio is where CPU throughput becomes the bottleneck.
- Low-latency serving. If speech generation sits in a user-facing request path, GPU inference keeps response times low under concurrent load.
- Pipelines where TTS is one stage. If Kokoro follows an LLM that is already on a GPU, running both in one place avoids moving data around.
That last case is the most common good reason. Kokoro rarely justifies a GPU on its own, but as the final stage of a generation pipeline it comes along for free.
GPU requirements for Kokoro
Modest, because the model is tiny.
- Single-stream generation: RTX A5000 (24 GB) from $0.16/hr, or an L4 from $0.44/hr. Both are enormous overkill in memory terms.
- High-concurrency serving: RTX 4090 (24 GB) from $0.34/hr handles many parallel streams.
- Serverless endpoint: the 16 GB tier at $0.58/hr on Serverless is the natural fit, scaling to zero between requests.
Do not reach for anything larger. Kokoro will not use the memory, and you will be paying for capacity that sits idle.
Step 1: Create a Runpod account
Go to runpod.io and sign up with email, GitHub, or Google. Add credits or a payment method.
Step 2: Deploy
For batch work, deploy a pod. Open the Pods section, select an RTX A5000 or RTX 4090, choose a PyTorch template, and set container disk to 20 GB. The model weights are small, so first load is quick.
For a serving endpoint, containerize your Kokoro setup and deploy it to Runpod Serverless. Because generation is fast and the model is small, cold starts are far less painful here than with a large LLM.
Step 3: Generate speech
Install the Kokoro package, load a voice, and synthesize. The API is deliberately simple: pass text, choose a voice, get audio back at 24 kHz.
For batch conversion, loop over your input files and write the output to a network volume so results survive the pod being stopped. For serving, wrap generation in a handler that accepts text and returns audio bytes.
Pro tips
Benchmark CPU first. Run your actual workload on CPU and measure it. If it finishes fast enough, you have saved yourself the GPU cost entirely. This is the rare model where that is a real option.
Pick voices deliberately. With 54 to choose from, voice selection affects perceived quality more than any inference setting. Audition several against your actual copy rather than defaulting to the first.
Batch aggressively. Kokoro's small size means you can hold many concurrent streams on one GPU. If you are converting a catalogue, parallelism is where the speedup is.
Write output to a network volume. Pod storage is ephemeral, and losing a completed batch to a stopped pod is an avoidable irritation.
Stop your pod when you are done. Runpod bills by the second while a pod runs.
Wrapping up
Kokoro is a good argument that model size and usefulness came apart some time ago. For narration, audio versions of written content, or the voice stage of a larger pipeline, it delivers quality that used to require far more compute. Run it on CPU if that meets your needs, and move to a GPU when throughput becomes the constraint rather than capability.
Ready to try it? Deploy a pod for batch conversion, or build a Serverless endpoint if you are serving speech in an application.
FAQ
Do I need a GPU to run Kokoro TTS?
No. Kokoro runs faster than real time on CPU, which is sufficient for most individual use. A GPU is worth paying for when you need batch throughput, low latency under concurrent load, or when Kokoro is one stage in a pipeline already running on a GPU.
Is Kokoro free for commercial use?
Yes. Kokoro ships under Apache 2.0, which permits commercial use, modification, and redistribution without restriction.
How many voices does Kokoro have?
Fifty-four voices across eight languages as of the v1.0 release, with output at 24 kHz. Voice choice affects perceived quality significantly, so it is worth auditioning several against your own content.
What GPU should I use for Kokoro?
Something small. An RTX A5000 from $0.16/hr or an L4 from $0.44/hr is ample. The model is 82M parameters and will not use a large card's memory, so paying for one is waste.
How does Kokoro compare to larger TTS models?
It reached the top of the TTS Arena leaderboard against models many times its size, which is the clearest available signal on quality. Whether it fits your use case depends on the specific voice and language you need, so test against your own copy.
