How to Use Silero TTS: The Beginner's Guide (the Two-Packages Lesson, First Synthesis, the Speaker Lesson, and the CPU-Speed Arc)

CodexFuse Team · 2026-11-07T04:09:43.605Z · 19 min read min read

How Do I Use Silero TTS?

Learning how to use silero tts takes seven moves: pick one of the two packages, install it with pip, load a model by language and model ID, pick a speaker and a sample rate, synthesize your first sentence, batch-process files with the wrapper CLI, and wire the engine into Home Assistant or a Docker image when you want it as a service. Silero TTS is a free, local text-to-speech engine that turns written text into spoken audio on your own machine, with no account, no API key, and no cloud service in the loop. This silero tts tutorial follows the official documentation, the project repository, and the package pages, with every fact checked as of November 2026.

The engine is the pitch in one line: it runs on an ordinary CPU, it speaks several languages, and the English model alone carries 118 named voices. CodexFuse offers no Silero tool, so this guide teaches the real project on your own machine, not a web version of it. The two-packages confusion is the first thing to clear up, because installing the wrong package is the most common way a first attempt stalls.

The Docker beginner guide covers the container skills this guide leans on in the Docker section below, and this page opens the local-TTS lane in the ai-speech cluster. Silero is the CPU-efficient multilingual lane, and it draws its line once against the cloud-voice lane: nothing leaves your machine, and nothing bills you per character.

1. Pick one package: the official silero library or the community silero-tts wrapper.
2. Install it with pip and a current PyTorch.
3. Load a model by language and model ID.
4. Pick a speaker and a sample rate.
5. Synthesize your first sentence and save it as a WAV file.
6. Batch-process a folder of text files with the wrapper CLI.
7. Wire it into Home Assistant or your own Docker image when you want it as a service.

Which Silero Package Should I Install?

Install the official silero package if you want the library, and install the community silero-tts wrapper only if you want a command-line tool and batch file processing. The two packages share a name that differs by one hyphenated word, and that is the reader's number-one blocker, so pick one at install time and do not install both for the same job.

The official package is silero version 0.5.5, published on PyPI on 3 February 2026, 277 days ago, and it comes from the snakers4 team that builds the models. The community wrapper is silero-tts version 0.0.5, published on 18 October 2024, 750 days ago, and it sits on top of the official models to add a CLI, batch processing, and text preprocessing. The community wrapper has not been updated since October 2024, so its version number lags the official package by about two years.

repo_age_days = 2248
repo_age_years = round(repo_age_days / 365.25, 2)
stars_per_fork = round(6171 / 378, 2)
issues_per_100_stars = round(13 / 6171 * 100, 2)
days_since_release = 156
days_since_push = 23
days_since_silero_pypi = 277
days_since_wrapper_pypi = 750
days_since_coqui_push = 813
days_since_coqui_release = 1061
days_since_coqui_fork = 19
english_speakers = 117 - 0 + 1
coqui_stars_multiple = round(46188 / 6171, 2)
top3_docker_pulls = 23852 + 8708 + 2985
print(repo_age_days)
print(repo_age_years)
print(stars_per_fork)
print(issues_per_100_stars)
print(days_since_release)
print(days_since_push)
print(days_since_silero_pypi)
print(days_since_wrapper_pypi)
print(days_since_coqui_push)
print(days_since_coqui_release)
print(days_since_coqui_fork)
print(english_speakers)
print(coqui_stars_multiple)
print(top3_docker_pulls)

The repository is active, with a push 23 days ago and a release 156 days ago, and the current model generation is v5. The official package needs Python 3.7 or newer and torch 1.12 or newer, though the v4 and v5 models need torch 2.0 or newer, so install a current torch before you load a v5 model. Most Silero models are CC BY-NC 4.0, so check the license before commercial use.

How Do I Install Silero TTS?

Install Silero TTS with pip, and install a current PyTorch first if your machine does not have one yet. The silero tts python path starts with pip, and the whole install is two commands on most machines. The Git beginner guide covers cloning the repository when you want the model files and examples on disk instead of letting pip fetch them.

pip install torch torchaudio
pip install silero

The official README lists three flavours: PyTorch Hub, the pip package, and manual model caching. The pip package and PyTorch Hub share the same code, so every torch.hub.load example in the docs works with the pip package after a small import change. Models download on demand the first time you load one, and invoking a model once caches it for later runs.

The standalone path needs only PyTorch 1.12 or newer and the Python standard library, and it loads a downloaded model file directly instead of going through the Hub. The wrapper adds its own dependencies, including torchaudio, loguru, and tqdm, and it needs Python 3.9 or newer. No terminal outputs in this guide were executed in a live testbed, so treat every command as documentation quoted from the official README, not as output from a run on this machine.

How Do I Run My First Synthesis?

Your first synthesis needs three knobs and nothing else: the language, the speaker, and the sample rate. The language picks the model family, the speaker picks the voice inside that model, and the sample rate picks the audio quality of the output file. Set all three in one call, and the model returns audio you can play or save.

The PyTorch Hub call below loads the English model v3_en with speaker en_0 at 48000 Hz on the CPU, and it synthesizes one sentence. The load call returns the model and an example sentence the model ships with, and apply_tts turns your own text into audio. The first load downloads the model file, and later loads read it from the cache.

import torch

language = 'en'
model_id = 'v3_en'
sample_rate = 48000
speaker = 'en_0'
device = torch.device('cpu')

model, example_text = torch.hub.load(repo_or_dir='snakers4/silero-models',
                                     model='silero_tts',
                                     language=language,
                                     speaker=model_id)
model.to(device)

audio = model.apply_tts(text='Hello world, this is Silero speaking.',
                        speaker=speaker,
                        sample_rate=sample_rate)

The pip package does the same job with a shorter import, and save_wav writes the audio straight to a file instead of returning it in memory. The Whisper beginner guide covers the reverse direction, turning speech into text, and it pairs naturally with Silero in a voice pipeline. The sample-rate table below shows the three rates every model supports, and 48000 Hz is the default in the wrapper CLI.

from silero import silero_tts

model, example_text = silero_tts(language='en',
                                 speaker='v3_en')
audio = model.apply_tts(text='Hello world, this is Silero speaking.')
audio_paths = model.save_wav(text='Hello world, this is Silero speaking.',
                             speaker='en_0',
                             sample_rate=48000)

The 8000 Hz rate is the legacy telephone rate, and the 48000 Hz rate is the one to use when quality matters and file size does not. The model does not care which rate you pick, and the same speaker keeps its voice at any rate, only cleaner at the higher ones. Pick 48000 Hz for your first synthesis, and drop to a lower rate only when a device or a file-size limit forces you to.

How Do I Pick a Speaker and a Model?

Pick the model by language first, then pick the speaker inside that model, because the speaker list belongs to the model and not to the language. The English model is v3_en, the Russian models run from v5_ru to v5_6_ru, and there is no v4 or v5 English model in the README as of this run. The v3_en speaker list runs en_0 through en_117, which is 118 named speakers, plus a random option that picks a different voice on each call.

The silero tts voices for English live in that one model, and the fastest way to find a voice you like is to synthesize the same sentence with en_0, en_1, and en_2 and keep the one that fits. The Russian models carry five named speakers, aidar, baya, kseniya, xenia, and eugene, and the v5_4_ru model drops eugene from its list. The Spanish model carries three numbered speakers and the French model carries six, and the German speaker count is not enumerated in the README.

The current generation is v5, and the v5_6_ru model adds questions, emphasis, and exclamations on top of the auto-stress and homograph handling the Russian models are known for. The v5_cis_base models are the exception on licensing, since they ship under MIT while the rest of the models sit under CC BY-NC 4.0. The v5_cis_base models also need manual stress marks, written with a plus sign before the vowel, because they do not guess stress for you.

How Fast Is Silero TTS on CPU?

Silero TTS runs on an ordinary CPU with no GPU, and that is the whole pitch. The silero tts cpu story is the README default: every code example loads the model onto the CPU, and the GPU is an option you switch on, not a requirement you must meet. The minimum hardware is a PyTorch-compatible system with a modern AVX2 processor on x86_64, and the examples set four CPU threads for the synthesis call.

The v5.6 release notes claim the models run at 100 times real time under ideal conditions. The x100 RT speed figure is the vendor's own claim, so read it as a best-case number and not as a promise for your machine. No independent CPU benchmark table was found in the README on this run, and the speed page the README links to is in Russian and was not fetched for this guide.

The standalone path is the lightest way to run the engine, because it loads a downloaded model file directly with no Hub call and no extra packages beyond PyTorch. The four-thread setting in the standalone example is the only performance knob the README shows, and it is the one to tune when synthesis feels slow. The Home Assistant integration caches downloaded models in RAM, which is why it can switch voices in milliseconds after the first download.

How Do I Process Files in Batch?

Batch processing is the community wrapper's job, because the official README documents no batch call of its own. The wrapper CLI reads one text file, a whole directory of text files, or a single sentence from the command line, and it writes one audio file per input. The three flags to learn are input-file, input-dir, and output-dir, and the language flag is required on every call.

pip install silero-tts
python -m silero_tts --language en --text 'Hello world!' --speaker en_2 --sample-rate 48000
python -m silero_tts --language en --input-file input.txt --output-file output.wav
python -m silero_tts --language es --input-dir texts --output-dir audio
python -m silero_tts --list-models

The wrapper also lists the models and speakers for a language, so you can check what is available before you pick one. The library form of the wrapper takes the same choices as constructor arguments, with methods to change the language, model, speaker, and sample rate between calls. The batch habit that scales is one text file per output file, with the file name carrying the voice and the model, so a re-run never overwrites a voice you liked.

Can I Run Silero TTS in Docker?

Yes, but you build the image yourself, because there is no official Silero image to pull. There is no official Silero Docker image, and the snakers4 organization publishes no image on Docker Hub that a search of the registry found. A silero tts docker setup therefore starts from a plain Python image plus pip, and the Dockerfile below is the shape of that build.

FROM python:3.12-slim
WORKDIR /app
RUN pip install torch torchaudio silero
COPY app.py /app/app.py
CMD ["python", "app.py"]

The community images on Docker Hub are the other route, and the most-pulled one has 23,852 pulls, but its GitHub repository is gone. The most-pulled community Docker image's repository returns a 404, so no verified run command exists for it, and this guide publishes none. The three most-pulled community images together hold 35,545 pulls, which shows real demand, and it also shows that every one of those images is an unverified third-party build.

The Ollama beginner guide covers the other local model on your machine, a large language model that can write the text Silero then speaks. The VPS hosting guide covers renting a server when your laptop is not the right home for a voice service. A container you build yourself stays yours to update, and you can pin the torch and silero versions in the Dockerfile so a rebuild never surprises you.

Silero vs Coqui: Which One Fits Your Project?

Silero fits the lightweight local job, and Coqui fits the voice-cloning and model-variety job, so the choice turns on what you need the voice to do. Silero vs Coqui is the comparison most readers ask about, and the honest answer starts with maintenance: Silero is active, and the original Coqui repository is dormant. Coqui's original repository has not had a release since December 2023, 1,061 days ago, and its last push was 813 days ago, so point new projects at the maintained fork instead.

The maintained fork is idiap/coqui-ai-TTS, and its PyPI package coqui-tts reached version 0.28.0 on 19 October 2026, 19 days ago. The original Coqui repository holds 46,188 stars, which is 7.48 times the 6,171 stars on the Silero repository, and that gap reflects Coqui's longer history rather than a current recommendation. The fork is the install to use, and the original TTS package name is the stale one to avoid.

The license split matters as much as the features, because both projects carry non-commercial limits on their most interesting models. Silero's models are mostly CC BY-NC 4.0, and Coqui's XTTS v2 weights are CPML, which is non-commercial only, so check both licenses before you ship anything that earns money. The choice is simple: pick Silero when you want a small CPU model with a fixed voice list, and pick the Coqui fork when you need cloning or a wider model zoo.

How Does Silero TTS Work With Home Assistant?

Home Assistant gets Silero through Silero TTS Enhanced, a two-part community project that pairs an add-on engine with a HACS integration interface. A silero tts home assistant setup installs the add-on first, then the HACS integration, and it configures everything in the UI with no YAML file to write. The add-on runs the engine on port 8014, and the integration points at it with your Home Assistant address.

The project is small and young, with 7 stars on each repository, and both repositories were created on 26 May 2026, 165 days ago. The add-on repository last pushed 147 days ago, and the HACS repository last pushed 142 days ago, so the project is quiet but not abandoned. The integration supports every current model from the official Silero repository, and its model and language fields accept custom input, so a future model works without an integration update.

service: tts.speak
target:
  entity_id: tts.silero_tts_enhanced
data:
  media_player_entity_id: media_player.living_room_speaker
  message: 'Hello, the smart home system is ready.'

The integration speaks to Home Assistant Assist, the built-in voice assistant, and it lets one automation override the model, speaker, language, and text preprocessing on a single call. The pronunciation fix is a plus sign before a vowel, which marks the stress and fixes homograph mistakes in Russian text. The RAM cache is the feature that makes the whole thing feel instant, because switching voices after the first download takes milliseconds rather than a fresh model load.

Seven Mistakes Beginners Make With Silero TTS

The seven mistakes below are the ones that cost beginners the most time, and each one has a one-line fix. The pattern behind most of them is the same: the project has two packages, several model generations, and no official Docker image, so the defaults are easy to get wrong. Read the table once before your first synthesis, and keep it open while you install.

Sources

The repository facts in this guide come from the GitHub API for snakers4/silero-models, including the release page for v5.6 and the tag list, and the model tables come from the project README on the master branch. The package versions come from the PyPI JSON pages for silero, silero-tts, and coqui-tts, all fetched on 7 November 2026. The Home Assistant facts come from the Silero TTS Enhanced thread on the Home Assistant community forum, and the Coqui shutdown background comes from Local AI Master, PromptQuorum, and the rip.so shutdown tracker.

The Docker facts come from the Docker Hub search API and a direct check of the snakers4/silero-tts repository page, which returns an object-not-found message. The speaker counts come from the README model tables, with the English count worked out by hand from the en_0 through en_117 range. The wrapper CLI flags and the Home Assistant YAML example come from the wrapper README and the community thread, and every computed number in this guide was re-run in Python on 7 November 2026.

This guide states no Silero Cloud prices, because the project sells no cloud service, and it promises no CodexFuse Silero tool. The version numbers, dates, and counts in this guide reflect the project on 7 November 2026, and the project moves, so check the README and the PyPI pages again before you install. Per the standing order, no Facebook promotion applies to this article.

Frequently Asked Questions

Is Silero TTS free?

Yes, the models are free to download and run on your own machine, with no account and no per-character billing. Most models sit under CC BY-NC 4.0, which covers non-commercial use, while the v5_cis_base models ship under MIT. Check the license for the model you pick before you use it in anything that earns money.

Does Silero TTS need a GPU?

No, the engine is CPU-first, and every README example loads the model onto the CPU by default. The only hardware rule is a modern AVX2 processor on x86_64, and the examples set four CPU threads for synthesis. A GPU is an option you can switch on, not a requirement.

How many voices does Silero TTS have for English?

The English model v3_en lists speakers en_0 through en_117, which is 118 named speakers, plus a random option that picks a different voice on each call. The Home Assistant community thread rounds the same list to 117 voices, which is why you will see both numbers online. The exact range is en_0 through en_117, so count 118 when you need the precise figure.

What is the difference between silero and silero-tts?

The silero package is the official library from the snakers4 team, and the silero-tts package is a community wrapper that adds a command-line tool and batch file processing. The wrapper sits on top of the official models, and it has not been updated since October 2024, while the official package reached version 0.5.5 in February 2026. Install the official package for the library, and install the wrapper only when you want its CLI.

Can I use Silero TTS in Home Assistant?

Yes, through the community project Silero TTS Enhanced, which pairs an add-on engine with a HACS integration interface. Install the add-on, install the HACS integration, and configure it in the UI with your Home Assistant address and port 8014. The integration works with Home Assistant Assist, and it caches models in RAM so voice switches feel instant.