---
title: "How to Run Underdog Woof TTS on a CPU (and Is It Free to Use?)"
url: "https://goremy.ai/blog/articles/how-to-run-underdog-woof-tts-on-cpu"
author: Luis Chavez-Mattos
editor: Luis Chavez-Mattos
editor_title: Director, Product
published: "2026-11-12T09:20:09.405Z"
updated: "2026-11-12T09:20:09.405Z"
topic: Local AI
description: Underdog Woof is a 40.6 MB English text-to-speech model that runs on a CPU with NumPy. Setup steps, voices, test results and the non-commercial license catch.
---

# How to Run Underdog Woof TTS on a CPU (and Is It Free to Use?)

> Underdog Woof is a 40.6 MB English text-to-speech model that runs on a CPU with NumPy. Setup steps, voices, test results and the non-commercial license catch.

Edited by Luis Chavez-Mattos, Director, Product · Published 2026-11-12

## How do I run Underdog Woof text-to-speech on a CPU, and can I use it commercially?

You install the prerequisites in a Python virtual environment, download the model's roughly 40.6 MB of files, and serve it with the command from its Hugging Face model card. A Gradio page on top gives you a text box and a play button. It needs no GPU, no API key and no large server. It runs on NumPy alone. Commercial use is the catch: the model is free for non-commercial use with credit, and the commercial terms are not as open as Apache 2.

## TL;DR

- Underdog Woof is a **40.6 MB English text-to-speech model** with two voices, Juno and Mira.
- It runs on an ordinary CPU using **only NumPy**, so there is no GPU, no API key and no cloud service involved.
- In one hands-on test on an Ubuntu virtual machine, the GPU sat idle and **CPU use stayed very low** while a sentence rendered in under 5 seconds in Juno's voice and a bit longer in Mira's.
- The model card reports a **1.42% word error rate** on a hard-cases test. That is the makers' own benchmark, and a reviewer's own tests found real slips on numbers and names.
- **Simple sentences work well. Dense text with codes, fractions and unusual names does not.**
- The license is **free for non-commercial use with credit**. Read the commercial terms before putting it in anything a business sells or runs.

## What is Underdog Woof?

Underdog Woof is a small English text-to-speech (TTS) model. TTS means software that reads text aloud in a synthetic voice. Most modern TTS models are large. Some models that are just as accurate are tens of gigabytes and want a GPU. Woof goes the other way. The whole download is about 40.6 MB, smaller than many phone photos taken in a burst.

It has two voices, Juno and Mira. The model card says it reads phone numbers, dates, prices and quotes the way people say them, and that it can run on any edge device (a small, low-power computer such as a single-board computer or an embedded device) with only NumPy. NumPy is a standard Python library for number crunching that most Python setups already include.

## How do you install and serve it?

The exact commands live on the model card, and they can change, so copy them from there. The overall shape is this:

1. **Create a virtual environment.** This is an isolated folder of Python packages, so the model's requirements do not collide with anything else on your machine.
2. **Install the prerequisites.** For this model that is a short list, since it leans on NumPy rather than a GPU toolkit.
3. **Download the model files.** About 40.6 MB, which takes seconds on most connections.
4. **Serve it with the command on the card.** Serving means starting a local process that accepts text and returns audio.
5. **Add a simple interface.** The reviewer who tested it wrote a small Gradio app on top. Gradio is a Python library that turns a function into a web page with a text box and an audio player.

Steps 1 and 5 look like this in a terminal on Linux or macOS:

```
python3 -m venv .venv
source .venv/bin/activate
pip install numpy gradio
```

Here is a skeleton for the Gradio page. The `synthesize` function is a placeholder. Fill it in using the usage example from the model card, because the model's own calls are not reproduced here.

```python
import gradio as gr

def synthesize(text, voice):
    # Replace with the call from the Underdog Woof model card.
    # Return (sample_rate, numpy_audio_array) for Gradio's Audio output.
    raise NotImplementedError

demo = gr.Interface(
    fn=synthesize,
    inputs=[gr.Textbox(label="Text"), gr.Radio(["Juno", "Mira"], label="Voice")],
    outputs=gr.Audio(label="Speech"),
)

demo.launch()
```

Run it, open the local address Gradio prints, type a sentence and press submit.

## How much computer does it need?

Very little. In the hands-on test, the machine was an Ubuntu virtual machine with no GPU in use, and the GPU monitor showed nothing at all. CPU use on the local system was minimal.

Speed was reasonable for a CPU. A long test sentence in Juno's voice came back in under 5 seconds. Mira's version took a bit longer than expected, so treat 5 to 10 seconds as a realistic range for a sentence of that length on a modest virtual machine. Your hardware will differ, so time it yourself.

No API key means no per-character fees, no rate limits and no text leaving your machine. For anything private, such as drafts, internal notes or customer details, that last point matters more than the price.

## How good does it sound?

Good for its size, not perfect. The model card reports a 1.42% word error rate on the Gradio TTS hard cases test. Word error rate is the share of words the system gets wrong. That figure comes from the model card, not an independent lab, and the reviewer said that in his testing so far it was holding up pretty well given the size.

Here is what the hands-on tests found:

| Test | Result |
|---|---|
| Date, time, phone number, price and codes in one sentence (Juno) | Mostly right. Skipped the dashes in the phone number and paused awkwardly on it. |
| Same sentence (Mira) | A few slips on the numbers. |
| Abbreviations, a title, a fraction, a unit and an email address | Several mistakes, including the fraction. |
| Big numbers, percentages, ordinals, decimals, a Roman numeral, a long sentence | Two to three mistakes. |

The pattern is clear. Plain sentences are fine. As soon as you add unusual names, codes, fractions and long strings of digits, errors creep in. The reviewer also preferred Juno over Mira.

On the makers' size-versus-accuracy chart, Woof sits in the small-and-accurate corner. Models that score similarly on accuracy, such as Fish, are tens of gigabytes. A model close to Woof in size, Kitten Nano, made far more mistakes on the same test. The reviewer found Fish or U-Drama 3 clearly better in his own testing, which is what you would expect from a model hundreds of times larger. Compare Woof with small models, not with the biggest ones.

## Can you use Underdog Woof commercially?

Not without checking first. The model is free for non-commercial use with credit. The terms for commercial use are not open the way an Apache 2 license is. Apache 2 is the permissive license many open models use, and it allows business use with few conditions.

In practice:

- **Personal projects, learning, hobby tools:** fine, as long as you give credit as the license requires.
- **Anything inside a company that earns money or supports a product:** read the full license text on the model page first. If it is unclear, ask the model's authors or your legal team.
- **Customer-facing products:** treat the license as a possible blocker. If it does not clearly allow what you want, pick a model with a permissive license instead.

Do not rely on this article or a video summary for a legal answer. The license file is the source of truth.

## Who is this for, and what can you do with it?

Woof suits people who want a voice without infrastructure.

- **Tinkerers and students** who want to see how local TTS works on a laptop or old server.
- **Privacy-minded users** who want text read aloud without sending it to a cloud service.
- **Makers of small devices** who need a voice on low-power hardware.

A good first test is to run three sentences of your own: a plain one, one with a date and price, and one with a name that is hard to pronounce. You will see where it holds up in about two minutes. If your real use involves invoice numbers, tracking codes or technical vocabulary, expect to correct mistakes or pick a bigger model.

## Could you build a tool around text to speech without managing models?

If what you want is a small internal tool that talks, such as a form that turns announcements into audio or a status page that reads out alerts, you do not have to wire up the model yourself. With [Remy](https://goremy.ai), you describe the tool in plain English and it builds and deploys the full-stack app. Remy apps can include a voice agent and draw on a catalog of nearly 400 AI models, including voice models, with no API keys to manage. That is a different route from running Woof locally, since those are hosted models and not a 40 MB file on your own CPU. It does skip the setup and the license question for a business tool.

## Frequently Asked Questions

### Does Underdog Woof need a GPU?

No. It runs on a CPU and needs only NumPy. In the hands-on test, nothing registered on the GPU and CPU use was minimal.

### How many voices does it have, and in what language?

Two voices, Juno and Mira, both for English. The model is English only, so it is not a fit for other languages.

### How big is the download?

About 40.6 MB in total, according to the model card. That is small enough to run on edge devices.

### Is the 1.42% word error rate reliable?

It is the makers' own number from their own hard test set. Hands-on tests showed more mistakes on numbers, abbreviations, fractions and unusual names. Use it as a rough guide for simple text and test your own content.

### Can I use it in a paid product?

Check the license first. It is free for non-commercial use with credit, and the commercial terms are not as open as Apache 2. Read the license on the model page before building anything commercial on it.