How to Run Local TTS Without a GPU on Low-End Systems

Local text-to-speech is often presented as a GPU workload. That is true for some large speech models, but it is not true for every useful TTS system. If your computer has an older CPU, integrated graphics, limited memory, or no dedicated GPU at all, you can still generate natural speech locally by choosing a compact model and keeping the workflow lean.

Supertonic 3 is now the best all-round choice for this job. It combines a compact 99-million- parameter model, fast ONNX inference, 31 languages, stable long-form reading, and preset voices. PocketTTS is still the better specialist choice when you need responsive streaming or voice cloning in its six supported languages. Kokoro-82M remains useful when the smallest parameter count and an Apache 2.0 model license matter.

See the complete Supertonic 3 model overview for its supported languages, OpenVox features, and platform requirements.

The best model for a low-end system is not simply the smallest one. It is the model that produces acceptable speech without exhausting your memory, overheating the machine, or making you wait longer than the audio itself.

Can local TTS really run without a GPU?

Yes. Speech generation still requires computation, but compact models can run entirely on a CPU. A GPU may improve some workloads, yet it is not a requirement for these models. Supertonic 3 runs through ONNX Runtime and its official project demonstrates local use on desktops, browsers, mobile devices, Raspberry Pi, and e-readers. The release is designed specifically for low-overhead, on-device inference.

PocketTTS is also built around CPU efficiency and uses only two CPU cores in Kyutai's published reference measurements. Kokoro is smaller at 82 million parameters. Actual speed depends on your processor, available memory, operating system, text length, and software backend, so treat published demonstrations as examples rather than guarantees for your machine.

Supertonic 3 vs PocketTTS vs Kokoro

What hardware should you expect to need?

There is no universal minimum because CPU generations vary enormously. A recent low-power laptop can outperform an older desktop processor while consuming far less energy. As a practical starting point, aim for a 64-bit operating system, at least 8 GB of RAM, a few gigabytes of free storage, and a modern Python installation if you plan to run the models directly.

• Use a 64-bit version of Windows, macOS, or Linux.
• Close memory-heavy browsers, games, and creative apps before generating long audio.
• Keep the computer plugged in and disable aggressive battery-saving modes.
• Generate a short paragraph first instead of beginning with an entire book.
• Store models on an SSD when possible; a slow hard drive increases loading time.

Option 1: Run Supertonic 3 on CPU

Supertonic 3 is the first model to try on a low-end system. Its public ONNX assets total about 99 million parameters, it supports 31 languages, and it generates 44.1 kHz audio without an external upsampler. The Python package downloads the model assets automatically on first use:

pip install supertonic

from supertonic import TTS

tts = TTS(auto_download=True)
style = tts.get_voice_style(voice_name="M1")
wav, duration = tts.synthesize(
    text="Supertonic is generating this speech locally on my CPU.",
    lang="en",
    voice_style=style,
)
tts.save_audio(wav, "supertonic-output.wav")

Supertonic 3 is particularly strong for Select and Read, articles, ebooks, narration, and accessibility. The release improves repeat and skip behavior across short and long passages, and includes expression tags such as <laugh>, <breath>, and <sigh>. Its main tradeoff is voice cloning: the open-weight package uses fixed styles, while custom styles require a separately created Voice Builder JSON.

If reading accuracy matters for your language, compare the published WER and CER results in our guide to how TTS models are benchmarked, then listen to several voices before committing to a long project.

Option 2: Run PocketTTS on CPU

PocketTTS supports Python 3.10 through 3.14 and requires PyTorch 2.5 or later. Kyutai explicitly states that the GPU build of PyTorch is not required. The quickest command-line test uses the packaged CLI:

pip install pocket-tts
pocket-tts generate --text "This speech is being generated locally on my CPU."

The command writes a WAV file locally. You can select one of the provided voices or pass a clean WAV recording as the voice prompt. Because PocketTTS reproduces characteristics of the reference audio, background noise, clipping, room echo, and music in the sample can also affect the generated result.

PocketTTS is especially useful when you want playback to begin before a long passage is completely synthesized. Its streaming architecture can return an initial audio chunk quickly, while its long-input support reduces the amount of manual text splitting required for articles, assistants, and continuous reading.

Important PocketTTS limitations

• It supports English, Spanish, French, German, Portuguese, and Italian.
• The Hugging Face model requires accepting its access conditions.
• Voice cloning must only use your voice or a voice you have explicit lawful permission to use.
• Adding explicit silence through the text input is not currently supported by the reference project.
• Kyutai reports no GPU speedup in its tested batch-one workflow, so CPU use is not merely a fallback.

Option 3: Run Kokoro-82M locally

Kokoro has an even smaller parameter count and a straightforward Python package. The official setup also uses espeak-ng for fallback phonemization and some non-English languages. A minimal Python example looks like this:

pip install "kokoro>=0.9.4" soundfile

from kokoro import KPipeline
import soundfile as sf

pipeline = KPipeline(lang_code="a")
generator = pipeline(
    "Kokoro is generating this speech locally without a dedicated GPU.",
    voice="af_heart",
)

for index, (_, _, audio) in enumerate(generator):
    sf.write(f"speech-{index}.wav", audio, 24000)

The language code must match the chosen voice. Kokoro's documented pipelines include American and British English, Spanish, French, Hindi, Italian, Japanese, Brazilian Portuguese, and Mandarin Chinese. Some languages require additional Misaki packages, so check the official setup instructions before assuming every pipeline is installed by default.

Kokoro is a strong choice for narration, accessibility tools, article reading, batch generation, and projects that need a permissive deployment license. Its official weights are Apache 2.0 licensed, but you should still check the terms attached to any separate voice assets you use.

How to improve performance on a slow CPU

1. Keep the model loaded

Model startup can take longer than generating a short sentence. If you are processing multiple passages, keep one process running and reuse the loaded model rather than launching Python for every line.

2. Process sensible chunks

Smaller chunks make failures easier to recover from and keep memory use predictable. Split at paragraph or sentence boundaries instead of cutting text at an arbitrary character count. PocketTTS can handle very long inputs, but chunking is still useful when you need separate files or resumable batch jobs.

3. Avoid unnecessary sample-rate conversion

Generate and save at the model's native sample rate when possible. Repeated resampling and format conversion add CPU work without improving the original synthesis.

4. Limit parallel jobs

Running several generations simultaneously can make a low-end system slower overall and may push it into swap. Start with one job. Add concurrency only after watching memory and CPU usage during a full generation.

5. Prefer WAV during generation

WAV is simple to write and avoids real-time compression overhead. Convert completed files to MP3, M4A, or another compressed format afterward if storage size matters.

6. Use clean text

Remove duplicated whitespace, navigation text, page numbers, broken PDF headers, and unusual symbols before synthesis. Cleaner input reduces pronunciation surprises and prevents wasting CPU time on content you did not want spoken.

Which model should you choose?

• Choose Supertonic 3 first for the best balance of speed, reading stability, preset voices, and 31-language coverage on ordinary or low-end hardware.
• Choose PocketTTS when your content is in English, Spanish, French, German, Portuguese, or Italian and you want voice cloning or responsive streaming.
• Choose Kokoro when you want a very compact general-purpose model, preset voices, multiple language pipelines, or Apache-licensed weights.
• Test the finalists on your own hardware when possible. Parameter count alone does not predict the speed of the complete text-processing and audio-generation pipeline.

The easier route: use OpenVox

Direct Python setup is useful for developers, but it introduces package versions, model downloads, command-line tools, phonemizers, audio dependencies, and scripts that need ongoing maintenance. OpenVox packages local voice workflows into a desktop interface and supports Supertonic 3, PocketTTS, and Kokoro alongside larger models for cases where your hardware and quality requirements allow them.

With OpenVox, you can download the model once, generate speech locally, manage voices and history, and export audio without sending your text to a cloud TTS provider. Start with Supertonic 3 for fast everyday reading and narration. Switch to PocketTTS when you need CPU-friendly cloning, or Kokoro when its voices and licensing fit your project better.

Official model resources

• Supertonic 3 model card and benchmarks
• Supertonic official repository and runtime examples
• Kyutai PocketTTS model card
• Kokoro-82M model card