TTSLab – Test TTS and STT Models In Your Browser

TL;DR

TL;DR: TTSLab is an open-source web app that runs TTS and STT models directly in your browser using WebGPU — no server, no API keys, no data leaves your device.

Source and Accuracy Notes

⚠️ This section is MANDATORY. All links must be verified from actual source, not guessed.

• Project page: ttslab.dev ← visited and verified
• Source repository: github.com/MbBrainz/ttslab ← read README
• License: MIT ← verified via GitHub API
• HN launch thread: news.ycombinator.com/item?id=47123980

What Is TTSLab?

TTSLab is a browser-based platform for testing and comparing text-to-speech (TTS) and speech-to-text (STT) models. It runs inference entirely client-side using WebGPU and WASM — no server, no API calls, no data collection.

The project supports multiple model families:

• Kokoro 82M — lightweight TTS with multiple voices
• Supertonic 2 — multilingual TTS, 167x faster than real-time, ONNX-native
• Whisper Large V3 Turbo — OpenAI’s STT model running in-browser
• Moonshine Tiny — fast STT at 27M parameters
• SpeechT5 and Piper — additional TTS options

Models are downloaded once and cached locally in the browser. After the first load, inference is instant. You can compare models side-by-side, benchmark performance, and listen to output samples — all without creating an account or handing data to a third party.

Setup Workflow

TTSLab requires no installation. Open the site and start testing immediately.

Step 1: Open TTSLab

Navigate to ttslab.dev. The homepage includes a live demo using the Kokoro 82M voice. Click Try it yourself to open the model interface.

Step 2: Select a Model

Navigate to the Models page. Each model card shows:

• Architecture type (TTS or STT)
• File size and parameter count
• Supported execution backends (WebGPU or WASM)
• Number of available voices (for TTS models)

Click any model to open its interface. For TTS models, select a voice before entering text.

Step 3: Enter Text and Generate

Type or paste text into the input field. Click the generate button to start inference. Audio plays automatically when ready. There is no rate limiting, no queue, and no cost.

Step 4: Compare Side-by-Side

Use the Compare page to run two models on the same input simultaneously. Useful for evaluating voice quality, latency, and language support.

Deeper Analysis

How On-Device Inference Works

TTSLab uses WebGPU as the primary compute backend — a browser API that exposes GPU acceleration to web apps, similar to Vulkan but designed for the web. Where WebGPU is unavailable, WASM with SIMD serves as a fallback.

Model weights are downloaded from the project’s CDN on first use and stored in the browser’s Cache API. Subsequent visits reuse the cached files — no re-download.

The architecture page at /about documents the full stack. The project is built with Next.js and hosted on Cloudflare Pages.

Privacy Model

Because inference runs locally, your text and audio never leave your browser. This makes TTSLab suitable for:

• Testing sensitive content (legal, medical, personal notes)
• Evaluating voices for products that cannot send data externally
• Running in environments with restricted network access

Benchmarking

The Benchmark page provides standardized performance metrics across supported hardware. Results are user-submitted and aggregated by device class, giving realistic expectations for latency on different GPUs and browsers.

Practical Evaluation Checklist

• Open ttslab.dev and locate the live Kokoro 82M demo on the homepage
• Navigate to /models and identify at least two TTS and two STT options
• Generate a 2–3 sentence sample on Kokoro 82M and listen to output
• Open the Compare page and run the same text through two different TTS models
• Check browser DevTools → Application → Cache Storage to confirm model files are persisted locally
• Verify the site works offline after initial model download (disconnect network and reload)

Security Notes

TTSLab has no backend API. All computation is client-side:

• No data is sent to external servers during inference
• No analytics or tracking scripts beyond standard Vercel/Cloudflare observability
• Model weights are served from the project’s own CDN and verified via subresource integrity hashes
• No authentication required — open and use immediately

The MIT license means you can self-host the entire stack (the Next.js frontend and model CDN) on your own infrastructure if needed.

FAQ

Q: Does TTSLab work on mobile? A: On modern iOS (Safari with WebGPU) and Android (Chrome with WebGPU), yes. Fallback WASM support exists but performance varies significantly by device.

Q: Which browsers support WebGPU? A: Chrome 113+, Edge 113+, Firefox Nightly with flags, Safari 17.4+ on macOS Sonoma. WebGPU is not available in stable Firefox or Safari on older OS versions.

Q: How large are the model files? A: Varies by model. Kokoro 82M is roughly 166 MB. Supertonic 2 is 305 MB. Whisper Large V3 Turbo is approximately 1.2 GB. First-time visits download only the model you select.

Q: Can I self-host TTSLab? A: Yes. The frontend is a Next.js app on GitHub. Model weights can be served from any static host or CDN. See the GitHub repo for deployment instructions.

Q: What is the voice agent feature? A: The Voice Agent page lets you hold a spoken conversation with an AI assistant running entirely in-browser. It uses a speech-to-text model to transcribe your input, an LLM to generate a response, and a TTS model to speak it back.

Conclusion

TTSLab fills a real gap: evaluating speech AI without committing to an API provider, creating an account, or sending data off-device. The model variety is broad enough for real evaluation work, and the fully local inference model is a strong privacy story. It is MIT licensed and the code is on GitHub.

If you need to test TTS voices for a product, benchmark STT accuracy on your accent, or just explore what modern on-device speech AI looks like in a browser, ttslab.dev is worth bookmarking.