Reverb-TTS clones voices right in your browser, no server required

Software Mansion has open-sourced Reverb-TTS, a model that clones voices without any extra training. It runs entirely on your own device, even in the browser via WebGPU, and the company says it hits roughly 17x real-time speed on an M4 Pro MacBook.

Model releases Try it yourself Nov 19, 2026 4 min read Source: Reddit r/LocalLLaMA
Illustrative image, AI-generated

What's new

On November 19, 2026, Polish software company Software Mansion, best known among developers for its React Native tooling, open-sourced the speech synthesis model Reverb-TTS. TTS stands for text-to-speech: you type in text and get spoken audio back. Reverb can also clone voices, and it does so zero-shot. All it needs is a short recording of the target voice. It doesn't have to be trained on that voice first.

The team's big selling point is that Reverb was built to run locally. It runs entirely on your own machine, and if you like, right inside your web browser. According to Software Mansion, nothing ever leaves the device. The weights, the Model Card (the model's technical description) and the benchmarks are on Hugging Face, where the model is billed as "state of the art" among open models. That's the company's own claim, and nobody has independently verified it yet.

How it runs in the browser

The browser support is the most interesting part technically. Reverb runs there on WebGPU, a fairly new web API that gives websites direct access to the graphics card, something that used to be reserved for installed apps. Software Mansion uses its own inference engine for this, called ruNNtime. An inference engine is the software that actually runs a trained model. ruNNtime is built on TypeGPU, another Software Mansion library that lets you write GPU programs in TypeScript.

On an M4 Pro MacBook, the company says Reverb generates speech at about 17x real-time speed. That means a minute of audio would be done in roughly three and a half seconds. The post doesn't say how fast it runs on other hardware, such as Windows laptops with integrated graphics or smartphones.

Documentation and examples for ruNNtime are at docs.swmansion.com/runntime.

The demo: three models on the GPU at once

To show what ruNNtime can do, Software Mansion built a demo that runs three models back to back on the graphics card:

  • LFM-3 describes what's happening in a video frame.
  • Whisper-small, a small speech recognition model from OpenAI, transcribes the reference recording. Reverb needs that transcript to clone the voice.
  • Reverb clones the voice and speaks the generated text.

The developers say the video frames go straight from the GPU into the model without a detour through the CPU. Copying data between video memory and system RAM is often a bottleneck, especially when several models run one after another. You can try a demo in the Hugging Face Space.

Mac users have a second option: the Nativ app from Neywa Labs can run Reverb locally. There's a guide on the Nativ blog.

What you need to try it

The browser is the easiest way in. You need a browser with WebGPU support, meaning a current version of Chrome or Edge. Other browsers only partly support WebGPU, depending on version and operating system. You also need a reasonably modern GPU. The company's benchmark figure comes from an Apple M4 Pro. The Reddit post doesn't say how big the model is or how much VRAM (video memory) it needs. Since it runs smoothly in a browser on a laptop, though, it's probably on the small side. That's our estimate, not an official spec. You don't need a dedicated Nvidia or AMD card, and Apple Silicon Macs are a good fit, according to the company. For voice cloning, you'll also need a short, clean recording of the voice you want to copy.

The post doesn't mention which license the weights are under. Check the Hugging Face page before using it commercially.

The bigger picture

There are a fair number of open voice cloning models by now, and the field moves fast. What sets Reverb apart is that it runs straight in the browser: no Python environment, no install, no server. That's handy for developers who want to add speech output to web apps without sending audio or text to cloud services. If privacy matters to you, it's a real alternative to paid cloud services.

Plenty is still unclear, though. The "SOTA" claim and the 17x real-time figure come from the company itself. There are no independent tests yet on audio quality, language support (for example, how well German works) or speed on weaker hardware. The technology also comes with the familiar risks: if you can convincingly recreate a voice from a few seconds of audio, you can also use it for fraud. Only clone voices whose owners have given their consent.

For Software Mansion, Reverb is also an ad for its own ruNNtime engine. If multiple models can work together in the browser without copying data between GPU and CPU, that could open the door to full local AI apps on the web that used to require a desktop program or a server.

Sources

#tts#voice-cloning#webgpu#open-source#browser
Read the original source

Try it yourself: Reverb-TTS

Explained step by step, no prior knowledge needed – on your own computer or free in your browser.

What can I do with it?

Reverb-TTS turns text into speech and can mimic any voice if you give it a short reference recording. What makes it special: it runs entirely on your device, even right in the browser via WebGPU, and no data is sent to a server. On an M4 Pro MacBook, the company says it generates speech about 17 times faster than real time. Software Mansion calls the quality top of the class among open models, but there are no independent comparisons yet. The post doesn't say which languages work well or how good German sounds. If that's documented anywhere, it's in the Model Card on Hugging Face. Compared with cloud services like ElevenLabs, it's free and your recordings stay private. Expect some trade-offs in expressiveness and fine control, though.

Who is it worth it for?

A good fit for developers who want to add speech output to web apps, and for anyone who wants to clone voices without a cloud service, for example for audiobooks, videos or accessibility. If you just want a polished, professional-sounding voice and don't mind using the cloud, commercial providers may serve you better.

Ideas: What you can do with it

Voice your podcast intro

Record your own voice cleanly once, then let Reverb read intros, ad breaks or corrections in it. No more re-recording every little fix.

Bedtime stories

Have stories you've written read aloud in a parent's voice, for example when someone's away on a trip. Since everything runs locally, your family recordings don't end up in the cloud.

Speech output for web apps

Developers can build Reverb straight into a website via ruNNtime, for read-aloud features or voice assistants. There are no server costs.

Accessible documents

Have long texts, articles or study materials read aloud for people with visual impairments or reading difficulties. The content never leaves the device.

Videos and presentations

Generate voiceovers for explainer videos or presentations in a consistent voice, without having to speak into the mic every time.

Download3.1 GB (about 4 min at 100 Mbit/s)
Licensecc-by-nc-4.0
TypeSpeech output (text to speech)

What your computer needs

Graphics card (NVIDIA) at least 1.5 GB VRAMThe company doesn't give a VRAM figure. This number is calculated: by default, the package loads the int8 weights at 0.31 GB, so 0.31 × 1.2 + 1 GB ≈ 1.5 GB (the small 22M-parameter audio decoder is included). With more memory, you can load the more precise fp16 or fp32 variants or generate many sentences at once (the batch-32 benchmarks ran on an RTX 5090).
Mac (Apple Silicon M1–M5) from 8 GB unified memoryThe GPU and CPU share the memory – the model can use about 70% of it
Storage approx. 5.1 GB freeModel download plus programs
In the browser Online demo availabletry it on Hugging Face, no installation needed

The post only mentions one version. The easiest way to start is the browser demo in the Hugging Face Space, which needs no installation. On a Mac, you can also use the Nativ app from Neywa Labs. Developers can integrate the model into their own web apps via ruNNtime.

  • In the browser, you need WebGPU support, which is most reliable in current versions of Chrome or Edge.
  • The company's benchmark (about 17x real time) comes from an M4 Pro MacBook, so Apple Silicon Macs are a good fit.
  • You don't need a dedicated Nvidia card. A modern integrated GPU will probably do. The source gives no specific VRAM figures.
  • Everything runs locally, so you don't need the cloud. You only need an internet connection for the initial model download.
How do I find out what my computer has?
  • Windows: Press Ctrl + Shift + Esc → Task Manager → Performance tab → click GPU on the left. At the bottom you'll see Dedicated GPU memory (that's your VRAM). You'll find system memory under Memory.
  • Mac: Apple menu at the top left → About This Mac. You'll see your chip (e.g. M2) and memory (e.g. 16 GB). On Apple chips, graphics and processor share this memory.
  • Linux: Type nvidia-smi in the terminal (shows your graphics card and its memory) and free -h for system memory.

Guide

This model runs with its developers' own program (software-mansion-labs/Reverb-TTS on GitHub). The commands below come from the Model Card and the developers' instructions.

In the browser (no installation)

The developers have an online demo on Hugging Face. You can try the model right away there without installing anything. Sometimes you have to wait a moment for the demo to wake up.

Open online demo

Windows 10 / 11

Windows 10 / 11: not officially tested. The source doesn't mention Windows, but the Python package should run there too. Without a compatible NVIDIA graphics card, it automatically falls back to the CPU, which is slower. If you'd rather skip the install, you can try Reverb in the online demo on Hugging Face using Chrome or Edge.

  1. Install the prerequisites. You need Python 3.10 or later. During installation, check the "Add Python to PATH" box. If you have an NVIDIA graphics card, install the latest driver. Then run the command below in PowerShell to check that a version number shows up.
    python --version
  2. Create a working folder. Create a dedicated folder for Reverb and switch into it. Your script and audio files will go here.
    mkdir reverb
    cd reverb
  3. Create a virtual environment. A virtual environment (venv) is an isolated space for Python packages, so nothing clashes with other programs. If Windows blocks activation, run "Set-ExecutionPolicy -Scope CurrentUser RemoteSigned" once. If it worked, you'll see (.venv) at the start of the line.
    python -m venv .venv
    .venv\Scripts\Activate.ps1
  4. Install Reverb. This command installs the reverb-tts package along with everything it needs. It can take a few minutes. At the end, you should see "Successfully installed".
    pip install reverb-tts
  5. Create a test script. Open a text editor, paste in the code and save it in the reverb folder as demo.py. The script uses a preset voice that ships with the package, so you don't need your own recording for the test.
    import soundfile as sf
    from reverb_tts import TTS
    
    tts = TTS.from_pretrained("software-mansion/Reverb-TTS")
    print(tts.preset_voices())
    voice = tts.preset_voice("en_male_narrator_1")
    audio = tts.generate("Hello! This is a preset voice speaking.", voice, language="en")
    sf.write("output.wav", audio, tts.sample_rate)
  6. Generate your first speech. Run the script. The first time, it downloads the weights from Hugging Face (int8 by default, about 300 MB). After that, you'll see a list of all preset voices, and the file output.wav will appear in the folder.
    python demo.py
  7. Clone your own voice. Record 3 to 10 seconds of clean speech from a single person, for example with the Sound Recorder app, and save it as reference.wav in the folder. Write down exactly what's said, word for word. Then replace the preset_voice line in demo.py with the line below and fill in your transcript. Only clone voices you have permission to use.
    voice = tts.voice("reference.wav", "The exact transcript of the reference recording.", language="en")
  8. Result. Your folder now contains a file called output.wav with a voice speaking your sample sentence.

macOS

macOS: supported. On Macs with Apple chips, the package automatically uses the GPU via MPS (Apple's interface for GPU computing). The company benchmarked it on an M4 Pro, where the model runs 12 times faster than real time. Alternatively, you can run Reverb on a Mac in the Nativ app from Neywa Labs.

  1. Install the prerequisites. You need Python 3.10 or later, for example via the installer from python.org. Then open Terminal and run the command below to check that a version number shows up. If the developer tools are missing, install them with "xcode-select --install".
    python3 --version
  2. Create a working folder. Create a dedicated folder for Reverb and switch into it.
    mkdir reverb
    cd reverb
  3. Create a virtual environment. A virtual environment (venv) keeps Reverb's Python packages separate from the rest of your system. If activation worked, you'll see (.venv) at the start of the line.
    python3 -m venv .venv
    source .venv/bin/activate
  4. Install Reverb. This command installs the reverb-tts package and its dependencies. At the end, you should see "Successfully installed".
    pip install reverb-tts
  5. Create a test script. This command creates the file demo.py. The script uses a preset voice that ships with the package, so you don't need your own recording yet.
    cat > demo.py << 'EOF'
    import soundfile as sf
    from reverb_tts import TTS
    
    tts = TTS.from_pretrained("software-mansion/Reverb-TTS")
    print(tts.preset_voices())
    voice = tts.preset_voice("en_male_narrator_1")
    audio = tts.generate("Hello! This is a preset voice speaking.", voice, language="en")
    sf.write("output.wav", audio, tts.sample_rate)
    EOF
  6. Generate your first speech. Run the script. The first time, it downloads the weights from Hugging Face (int8 by default, about 300 MB). After that, you'll see the list of preset voices, and output.wav will appear in the folder. Type "open output.wav" to listen to it.
    python3 demo.py
  7. Clone your own voice. Record 3 to 10 seconds of clean speech from a single person, for example with QuickTime. Save it as reference.wav in the folder and write down exactly what's said. Then replace the preset_voice line in demo.py with the line below. Only clone voices you have permission to use.
    voice = tts.voice("reference.wav", "The exact transcript of the reference recording.", language="en")
  8. Result. Your folder now contains a file called output.wav with a voice speaking your sample sentence.

Linux

Linux: supported. With an NVIDIA graphics card, the package automatically uses CUDA, NVIDIA's compute platform. The company's benchmarks include an RTX 5090 and an H200. Without a compatible graphics card, it automatically falls back to the CPU, which is slower.

  1. Install the prerequisites. You need Python 3.10 or later, including the venv module. If you have an NVIDIA graphics card, install the latest NVIDIA driver. The commands below check your Python version and whether your graphics card is detected.
    python3 --version
    nvidia-smi
  2. Create a working folder. Create a dedicated folder for Reverb and switch into it.
    mkdir reverb
    cd reverb
  3. Create a virtual environment. A virtual environment (venv) keeps Reverb's Python packages separate from the rest of your system. If activation worked, you'll see (.venv) at the start of the line.
    python3 -m venv .venv
    source .venv/bin/activate
  4. Install Reverb. This command installs the reverb-tts package along with PyTorch and other dependencies. It can take a few minutes. At the end, you should see "Successfully installed".
    pip install reverb-tts
  5. Create a test script. This command creates the file demo.py. The script uses a preset voice that ships with the package, so you don't need your own recording yet.
    cat > demo.py << 'EOF'
    import soundfile as sf
    from reverb_tts import TTS
    
    tts = TTS.from_pretrained("software-mansion/Reverb-TTS")
    print(tts.preset_voices())
    voice = tts.preset_voice("en_male_narrator_1")
    audio = tts.generate("Hello! This is a preset voice speaking.", voice, language="en")
    sf.write("output.wav", audio, tts.sample_rate)
    EOF
  6. Generate your first speech. Run the script. The first time, it downloads the weights from Hugging Face (int8 by default, about 300 MB). After that, you'll see the list of preset voices, and output.wav will appear in the folder. You can play it with any media player.
    python3 demo.py
  7. Clone your own voice. Record 3 to 10 seconds of clean speech from a single person. Save it as reference.wav in the folder and write down exactly what's said, word for word. Then replace the preset_voice line in demo.py with the line below. Only clone voices you have permission to use.
    voice = tts.voice("reference.wav", "The exact transcript of the reference recording.", language="en")
  8. Result. Your folder now contains a file called output.wav with a voice speaking your sample sentence.

What to do after your first result

  • Try German: pick the voice "de_female_standard" or "de_male_standard" and write, for example, tts.generate("Hallo! Das ist meine geklonte Stimme.", voice, language="de"). Every voice can speak all seven languages: English, German, French, Spanish, Italian, Polish and Portuguese.
  • TTS.from_pretrained("software-mansion/Reverb-TTS", variant="int4") loads the smallest variant. variant="fp16" or "fp32" gets you the most precise weights. According to the company, int8 loses no quality compared with fp32.
  • The package automatically converts numbers, dates and abbreviations into words, and it splits long texts at sentence boundaries on its own. Reverb and background noise in your recording end up in the output too, so record somewhere as quiet and dry as possible. Recordings longer than 15 seconds sound worse.
  • For a no-install option, use the "Reverb-TTS-runntime" online demo on Hugging Face. It runs on WebGPU in Chrome or Edge. Important: the weights are licensed under CC BY-NC 4.0, so you may only use them non-commercially and with attribution.

Try it

Hi, great to have you here! Today I'm trying out an AI voice for the very first time.
Welcome to episode twelve of our podcast. Today we're asking why cats love sitting in cardboard boxes so much.
Attention please: the train to Boston will depart from platform seven today. Please note the changed car order.
Once upon a time, there was a little dragon who was afraid of fire. Every evening, he sat at the edge of the forest and watched the stars.
Quarterly results show revenue up 4.7 percent, driven mainly by business in Southern Europe.

Tips for better results

  • Use a clean reference recording a few seconds long with natural intonation. The mood of the recording carries over into the result.
  • Long texts usually sound better if you split them into paragraphs and generate them one at a time.
  • When in doubt, spell out numbers, abbreviations and foreign words (e.g. "four point seven percent") for cleaner pronunciation.
  • Check the Model Card on Hugging Face to see which languages are officially supported before expecting good results in a given language.

If something goes wrong

If the demo won't start, your browser probably doesn't support WebGPU. Use a current version of Chrome or Edge and make sure hardware acceleration is turned on.

The first launch takes longer because the model has to download first.

A noisy or echoey reference recording makes the cloned voice noticeably worse. Record in a quiet room.

The announcement post doesn't mention the license. Check it on the Hugging Face page before using it commercially.

Only clone voices whose owners have given consent. Imitating someone else's voice can have legal consequences.

“out of memory,” a crash, or your computer freezes

The model is too big for your VRAM (video memory). Pick a smaller variant from the table above and close other programs, especially games and browsers with lots of tabs.

It runs, but extremely slowly

Your CPU is probably doing the work instead of your graphics card. In Ollama, the PROCESSOR column of ollama ps shows how much runs on the GPU. If it says "100% CPU", update your graphics driver or pick a smaller variant that fits entirely into VRAM (video memory).

“ollama” or “python” is not found

Close the terminal window and open it again so it recognizes the newly installed program. For Python on Windows: reinstall it and check Add python.exe to PATH.

Windows: "Running scripts is disabled on this system"

Run the script with exactly the command above: powershell -ExecutionPolicy Bypass -File try_windows.ps1. This allows execution for this one time only.

Error message when loading the model (version, "trust_remote_code", unknown architecture)

Brand-new models often need the latest software version. With Ollama: update Ollama. With Python: pip install -U transformers in the activated environment. The Model Card usually lists the exact version.

Tokenstrom generates the scripts and notebook automatically. Please take a quick look before running them – they're plain, readable text. Mind the model's license: cc-by-nc-4.0.

Ask the AI assistant

Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.

Connecting …

The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.

Comments

What do you think? Already tried it? Write it here, no sign-up needed.

  1. Loading comments …

Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.