Text to speech that runs on your machine.

Hear it

28 voices, ten languages. All included.

English, Spanish, French, German, Italian, Portuguese, Polish, Dutch, Swedish and Danish. Every voice is enrolled from a consented donation or a CC0 / CC-BY corpus, with the source named.

Hear two now.

Sophie and Oscar read the same greeting with loudr-1, seed 7.

OscarEnglish · male

SophieEnglish · female

One seeded sample per voice, playable in the browser. The sources and the licences are on the same page. Open the demo to hear each enrollment recording next to the speech it produced, and the full gallery, with all 28 voices included in both models.

We have evaluated English by ear. We do not speak the other nine languages well enough to judge them reliably, so feedback from native speakers is very welcome.

Where it runs

Laptops, GPUs and edge devices.

Faster than real time on datacentre GPUs, on desktop GPUs, on Apple Silicon and on an embedded board. Every figure is one run of tools/bench.py or a port runner on the named machine. The hardware, the method and the commands.

requires an NVIDIA GPU

NVIDIA CUDA

13.05×real time with loudr-1-turbo, RTX 3090 with CUDA graphs; loudr-1 runs 8.55×

PyTorch, from an embedded board to a datacentre card. Both models, CUDA graphs on.

Part	loudr-1	loudr-1-turbo
RTX 3090	8.55×	13.05×
L4	7.50×	11.93×
A100	7.68×	11.87×
T4	5.16×	7.95×
GTX 1080 Ti	2.26×	4.64× *
Jetson Orin Nano	1.85×	2.50×

 * Pascal cannot capture graphs: the 1080 Ti figures are its eager path. Eager figures and time to first audio for every part are on the benchmark page.

Batch throughput, RTX 3090 with CUDA graphs, loudr-1-turbo

Many texts at once. Each number is the total audio produced per second of wall clock across the whole batch, not the speed of one synthesis. loudr-1 runs 16.7× at batch 1 and 57.3× at batch 64 on the same card.

42.0×batch 1

121.8×batch 8

145.5×batch 16

154.2×batch 32

155.0×batch 64

What it measures, and the full table. The highest measured aggregate is 223.6×, turbo on an A100 at batch 64.

requires Apple Silicon

Apple GPU

5.77×real time with loudr-1-turbo, M3 Pro laptop, --device mps; loudr-1 runs 3.29×

The generator runs on the CPU and the renderer on the GPU. Swift’s CoreML renderer runs 3.44× with turbo and 2.49× with loudr-1 on the same laptop.

requires no PyTorch

ONNX Runtime

1.59×real time with loudr-1-turbo, same laptop, CPU provider, fp32 graphs; loudr-1 runs 1.14×

Runs without PyTorch, on ONNX Runtime, in Python, Go, Rust and TypeScript.

an embedded NVIDIA GPU

Jetson Orin Nano

2.50×real time with loudr-1-turbo, --device cuda --cuda-graphs, measured on the board; loudr-1 runs 1.85×

The same engine, the same conformance fixture, on a board with no discrete GPU.

Every figure is a multiple of real time. 3× real time means one minute of audio in twenty seconds. Under 1× is slower than real time. Every figure was measured on 0.1.1 with both models and is quoted from the benchmark page, which records the machines, the versions and the commands.

Five languages, one engine

Ports, not wrappers.

Python is the reference implementation. Swift, Go, Rust and TypeScript are full ports of it, and all five are held to the same conformance fixture, so the same text and the same voice give the same speech tokens in every one.

PythonPyTorch, ONNX Runtime or CoreML backendreference

SwiftCoreML backendSwift Package Manager

GoONNX Runtime backendgo get

RustONNX Runtime backendcargo

TypeScriptONNX Runtime backendnpm i

Install

Install, then speak.

Add the package, load the model by name, pick a voice, get a waveform. Every language fetches the release on the first load, verifies it, and runs offline after that.

Python

pip install "loudkit[torch,audio,hub]"

import loudkit as lk

engine = lk.load("loudreader/loudr-1")
voice = engine.voice("joe")
engine.synthesize("Hello from loudkit.", voice, seed=7).save("hello.wav")

TypeScript

npm i loudkit@0.1.1

import { Engine } from "loudkit";

const engine = await Engine.load("loudreader/loudr-1");
const voice = engine.voice("joe");
(await engine.synthesize("Hello from loudkit.", voice, { seed: 7 })).saveWav("hello.wav");
await engine.close();

Go

go get github.com/loudreader/loudkit/go@v0.1.1

eng, err := loudkit.Load("loudreader/loudr-1")
if err != nil { log.Fatal(err) }
defer eng.Close()
v, err := eng.Voice("joe")
if err != nil { log.Fatal(err) }
res, err := eng.Synthesize("Hello from loudkit.", v, loudkit.Options{Seed: 7})
if err != nil { log.Fatal(err) }
if err := res.SaveWav("hello.wav"); err != nil { log.Fatal(err) }

Rust

loudkit = "0.1.1"

use loudkit::{Engine, Options};

let mut engine = Engine::load("loudreader/loudr-1")?;
let voice = engine.voice("joe")?;
let options = Options { seed: 7, ..Default::default() };
engine.synthesize("Hello from loudkit.", &voice, &options)?.save_wav("hello.wav")?;

Swift

Package.swift

.package(url: "https://github.com/loudreader/loudkit", from: "0.1.1")

import LoudKit

let engine = try await Engine.load("loudreader/loudr-1")
let voice = try engine.voice(named: "joe")
try engine.synthesize("Hello from loudkit.", voice: voice, seed: 7).saveWav("hello.wav")

The same seed and voice give the same speech tokens in all five. Go and Rust need libonnxruntime on the machine; each guide says where its port looks for it. loudreader/loudr-1 runs everywhere; loudreader/loudr-1-turbo is supported by all five ports in 0.1.1. All 28 voices are included in both model downloads and load by name.

Where to go next

What it promises.

Documentation indexThe twelve pages a user needs, then the reference, the platforms and the model.What 0.1 supportsWhat is supported, what is experimental, and what 0.1 does not attempt.Identity contractSame text, same voice, same seed. What that guarantees, and where it stops.BenchmarksMeasured figures, the hardware, and the command that reproduces each row.Model cardWhat loudr-1 is, where it came from, its limits and what each download contains.DemoEnrollment reference and generated speech side by side, plus all 28 voices.Run it in the browserType a sentence, hear the voices, or clone one from your own microphone. No install.

Responsible use.

The tool clones a voice from ten seconds of audio and writes a machine-readable note about how the audio was made into saved WAVs by default. Consent is yours to obtain. Read the terms.

LoudReader, the iOS reading app, runs on this engine. loudkit is the engine it ships.