turkish-stt

turkish-stt

Real-time, low-latency speech-to-text (STT) for Turkish.

Built for developers — download, integrate, ship. Turkish-only · streaming · CPU-friendly · runs on the edge. First community release.

Model: 66 M parameters · ~68 MB (int8) / ~264 MB (fp32) — small enough to sit on an edge device.

---

What it does

turkish-stt transcribes Turkish speech as it is spoken — low-latency and CPU-friendly, running in real time on an ordinary CPU (no GPU and no cloud required). It is built for real-time use cases such as IoT and edge devices, voice assistants, call centers, live captioning, and dictation.

Highlights

• 🇹🇷 Turkish-first — a single-language model, strong on natural and conversational Turkish
• ⚡ Streaming — emits partial results while you speak; very low latency
• 🚀 Super fast — RTF 0.128 on a single CPU thread, ~8× faster than real time
• 🖥️ CPU-friendly — runs faster than real time without special hardware
• 🏷️ Entity/brand aware — robust on proper nouns, brands, and numbers
• 🔌 Lightweight — easy to embed into voice-agent stacks

Why it's built this way. turkish-stt is deliberately focused: Turkish-only (every parameter serves one language, not ~100 languages), CPU-friendly (no GPU or cloud required), and super fast (real-time streaming, even on edge devices like a Raspberry Pi). That single-purpose focus is exactly what lets a compact 66 M model stay accurate on Turkish while running anywhere.

How it works (from the user's side)

1. You feed the model an audio stream (microphone or phone line).
2. It listens chunk by chunk and emits a partial transcript while speech continues.
3. As sentences complete, the transcript finalizes — no waiting, fully streaming.
4. The output is plain text you can wire directly into voice-agent / call-center flows.

In short: audio in → real-time Turkish text out. Super fast — the fastest accurate system that runs on CPU in our benchmarks, ~8× faster than real time on a single CPU core (see Benchmarks).

Benchmarks

Every number below was measured in-house — we do not quote published figures. All systems were run on the same two machines, over the same audio, with one identical scoring pipeline. Nothing is estimated; where a configuration is impractical to run it is labelled as such, not filled in.

Test machines

These are the rented benchmark hosts, not deployment requirements. All CPU timings use a single thread (num_threads=1) and turkish-stt's int8 footprint is only ~68 MB — the host's core count and RAM are irrelevant, and the same model runs on a Raspberry-Pi-class device.

turkish-stt and Vosk are CPU-only streaming models (no GPU build); the Whisper family is timed on GPU (fp16) where it is actually usable, and also on CPU (int8, one thread) for reference.

1. Latency (single stream)

RTF (real-time factor) = decode time ÷ audio duration. Below 1.0 = faster than the audio plays. p50 / p95 = median and 95th-percentile wall-clock per clip. CPU column is single-thread (num_threads=1); GPU column is fp16 on the RTX 4090. FLEURS-TR clips, 16 kHz mono.

What this means. On a single CPU thread, turkish-stt runs at RTF 0.128 — ~8× faster than real time — and is the only accurate option that stays real-time on CPU alongside Vosk. Every Whisper model is slower than real time on CPU (RTF 1.1–6.1: it cannot keep pace with the audio and needs a GPU in practice). On a GPU the Whisper family is very fast, but that is a different, more expensive hardware class — turkish-stt is built to avoid the GPU entirely.

2. Concurrency (many streams at once)

Here C = number of audio streams transcribed simultaneously on one machine (one shared model). Throughput ×real-time = total seconds of audio processed per second of wall-clock, across all streams.

CPU box (EPYC 7282):

GPU box (RTX 4090, fp16):

What this means. On CPU, turkish-stt sustains ~25 concurrent real-time streams on a single box, while Whisper cannot serve even one (it is already slower than real time at C=1, so higher C is not run). Vosk pushes slightly more raw throughput at high C — because its lighter decoding is cheaper per stream — but at more than double the word-error rate (see below). Whisper reaches high throughput only on a GPU. Note that throughput drops from C=10 to C=100 on CPU: 100 threads over 16 cores over-subscribe the machine, so the practical sweet spot is ~10–20 concurrent streams per CPU box. Per-stream latency also rises with C (queuing), but accuracy does not change — the transcript is identical at any C.

3. Accuracy (WER / CER)

Accuracy is a property of the model, so it is the same on CPU or GPU and at any concurrency. Our primary benchmark is FLEURS-TR — the Turkish test split of Google's public FLEURS (743 clips of genuine human read speech the model never trained on). Every hypothesis and reference passes through one identical normalization before scoring — Turkish-aware lower-casing (dotted/dotless İ/ı, plus Ş/ş, Ğ/ğ, Ü/ü, Ö/ö, Ç/ç), punctuation removal, and digit ↔ word unification ("3" = "üç"). Then WER (word error rate) and CER (character error rate) are computed — lower is better. All systems were run in-house on the same audio under the same normalization.

FLEURS-TR (743 clips) — real human speech:

What this means. Among streaming, CPU-deployable systems — the class turkish-stt actually competes in — it more than halves Vosk's error (13.90% vs 34.09% WER), at a comparable size. The much larger offline Whisper large/turbo lead on general read speech (they have ~20× the parameters and far more data), but they cannot stream and are not real-time on CPU. turkish-stt occupies the practical sweet spot: Whisper-small-level accuracy while being streaming, CPU-native, and a fraction of the size.

Domain / entity accuracy. On a separate held-out automotive brand-entity set, turkish-stt reaches 88% brand-word accuracy versus 68% for Whisper large-v3 — it is purpose-built to get Turkish brand and entity names right.

Reproducible synthetic probe. As a fully-reproducible, shareable check we also evaluate on 81 diverse Turkish sentences generated on-the-fly by mihu's own TTS on EU servers (voice: Aysu), where turkish-stt scores 15.37% WER / 3.57% CER — in line with its FLEURS-TR result (~14%), i.e. the model behaves consistently on synthetic and real speech. The audio, reference transcripts, and eval script are published under eval/ so anyone can reproduce the number exactly (verified with sherpa-onnx 1.13.4). Note: this is synthetic (TTS) speech, provided only as a self-contained reproducibility check; the real-human FLEURS-TR numbers above are the primary benchmark.

Primary benchmark is public: google/fleurs (tr_tr test). All accuracy numbers are for the streaming model at int8, computed under the matched normalization above.

Test data & reproducibility

The primary benchmark uses a public, held-out Turkish test set — audio the model never trained on — so anyone can reproduce it without our private data. No in-house recordings are used for the real-speech evaluation.

To reproduce: transcribe each clip, then apply one identical normalization to both hypothesis and reference — Turkish-aware lower-casing (dotted/dotless İ/ı, plus Ş/ş, Ğ/ğ, Ü/ü, Ö/ö, Ç/ç), punctuation removal, and digit ↔ word unification ("3" ⇄ "üç") — and compute WER/CER (e.g. with jiwer; see eval/run_eval.py). Latency and concurrency are reported on the two machines listed under Test machines; accuracy is machine- and concurrency-independent.

Usage

Install the package — the model weights and the sherpa-onnx runtime are pulled in automatically on first use. Runs on the CPU, no GPU or cloud:

pip install turkish-stt

One-shot — transcribe a file (or a numpy array):

import mihu_stt

text = mihu_stt.transcribe("audio.wav")   # 16 kHz mono
print(text)

Streaming — feed audio chunk by chunk and read partial results live, with automatic turn-end detection (microphone, phone call, or a LiveKit / Pipecat pipeline):

from mihu_stt import StreamingSTT

stt = StreamingSTT()
for chunk in mic_frames():                    # 16 kHz mono float32 [-1,1] (or PCM16 bytes)
    text, is_final = stt.accept_float32(chunk)
    print(("final:" if is_final else "partial:"), text)

Ready-made LiveKit and Pipecat integrations ship in the code repository under examples/.

Use cases

• Edge & IoT — on-device Turkish STT on single-board computers (e.g. Raspberry Pi), embedded devices, and offline/private deployments (small int8 footprint, real-time CPU inference, no GPU or cloud required)
• Voice assistants and telephone voice agents
• Call-center live transcription
• Live captioning / dictation
• Turkish voice interfaces

License

mihu Community License — see LICENSE for full terms.