An hour of audio, transcribed in 12.6 seconds on a base 8 GB MacBook Air, by a model that was never trained to transcribe anything. That claim comes from Embedding Gemma Transcribe, a side project that turns Google's EmbeddingGemma 2 into a local speech-to-text engine. It's sitting at 430 points on Hacker News.
I read the project page, Google's model card and the whole HN thread to answer one question: can EmbeddingGemma 2 speech to text replace Whisper on your local machine? For most people, not yet. The trick behind it is clever enough that I'd still keep an eye on it.
One note up front: I haven't run it. Every number below comes from the project page, Google's docs, or people in the thread who did run it.
What EmbeddingGemma 2 is and why it shouldn't be able to do this
Google DeepMind released EmbeddingGemma 2 on October 6, 2026. It's an embedding model. You give it text, images, video or audio and it hands back a vector.
The model card breaks it down:
- 740M parameters total
- 270M text backbone (130M transformer + 140M embedder)
- optional 170M vision encoder and 300M audio encoder
- text + audio loaded together: 570M effective
- audio input: mono 16 kHz, 25 tokens per second, about 327 seconds max in the 8,192-token context
- license: Apache 2.0
Google lists audio use cases like "spoken-query search over audio archives" and audio event classification. The model card doesn't mention speech recognition at all.
How they turned an embedding model into speech-to-text
Per the project page, it works like this:
Only the reader was trained: under two hours on 8×H100 using openly licensed English speech. The author, Shahir, said on HN that it started as an experiment to check whether audio and text really share one vector space. Speed was a side effect. Nothing gets generated token by token, which explains both how fast it is and every weakness covered below.
Speed and accuracy vs Whisper and Parakeet
This is the speed table from the project page. The first two rows are the authors' own runs on the same Mac. The Parakeet rows come from FluidAudio's published benchmarks on different hardware, and the page itself calls them "a rough guide, not a like-for-like ranking."
| Model | Runs on | Mac | Speed (× real time) |
|---|---|---|---|
| Embedding Gemma Transcribe | Neural Engine | M3 Air, 8 GB | 288× (1 h in 12.6 s) |
| IBM Granite Speech 5.0 TurboCTC | GPU (MLX) | M3 Air, 8 GB | ~150× (1 h in 25.7 s) |
| Parakeet TDT 0.6B v3 (FluidAudio) | Neural Engine | M4 Pro | 156× |
| Parakeet TDT 0.6B v3 (FluidAudio) | Neural Engine | M5 Pro | 335× |
| Phonon-2 (Parakeet v3 fine-tune) | Neural Engine | M5 Pro | 480× |
On HN, bigtex ran a 33-minute file on an M4 Mac Mini with 24 GB: 6.75 seconds, against about 7.5 seconds with MacWhisper running Parakeet. Fast, but in Parakeet's ballpark, so speed alone isn't a reason to switch.
Accuracy is where it falls behind. The page says WER is "about 5% right now," compared with "2–3% for leading speech models." It doesn't say which test set the 5% comes from. armcat asked exactly that in the thread and I couldn't find an answer.
For reference, here are published numbers for the models you'd compare it against:
| Model | Params | English WER | License | Languages |
|---|---|---|---|---|
| Embedding Gemma Transcribe | not stated (base model 740M) | ~5%, unnamed test set | app: not stated; base model Apache 2.0 | English |
| Parakeet TDT 0.6B v3 | 600M | 6.34% Open ASR avg; 1.93% LibriSpeech clean, 3.59% other (card) | CC-BY-4.0 | 25 European |
| Whisper large-v3 | 1.55B | 7.44% Open ASR avg (table) | MIT | 100 |
Don't read that 5% as beating Parakeet's 6.34%. The Open ASR average covers several datasets, including messy ones. An unnamed 5% could easily come from clean audiobook speech, where Parakeet scores 1.93%.
The author did post some internal numbers in the thread. A letter-level CTC head they tried got 7.0 WER on clean audiobooks vs 8.2 for their current approach, but 16.5 vs 10.8 on a lecture. So the shipped design scores around 8 on clean audiobooks and around 11 on lecture audio, at least at the time those numbers were taken. That's further from "2–3%" than the headline suggests.
The 229,000-word ceiling
Snapping every slice to a fixed English word list has consequences, and the thread found them quickly:
- Proper nouns and new words. drakirus asked for WER on out-of-vocabulary words, since a fixed list can't produce a word it doesn't contain. The author's answer: you can embed new words and add them, but "when a new word is very close to a known one, it tends to fall to it."
- Other languages. motoboi fed it Portuguese and got English back, adding that "the overall transcription quality is very low." The author said the reader was trained on English and would need multilingual training. No date for that.
- Context. The reader sees about 20 words around each slice. That's enough for dictation and falls short for long-range disambiguation.
For English Slack dictation that's fine. For a podcast about Kubernetes operators with a guest named Siobhán, it isn't.
License: Apache 2.0 only covers the model
As cstever pointed out on HN, the Apache 2.0 license belongs to EmbeddingGemma 2. The transcription app has no stated license and no public source. The trained reader, the 229k-word index and the punctuation model aren't on Hugging Face. The author wrote "I will opensource the whole thing soon. Might need a few days though."
Until that ships, you can't pip install it, run it on Linux, or check the WER yourself.
How to run EmbeddingGemma 2 speech-to-text locally
Today there's one way to run it:
- You need macOS 14 or later on Apple Silicon. No minimum RAM is stated; the benchmarks above used an 8 GB M3 Air.
- Download the app (v1.6 at the time of writing) from eg2.haku.sh. It fetches 715 MB of models on first launch.
- Drag an audio file onto the window, or hold Right Option, speak, and release to dictate into any app. Audio stays on the machine.
If you're on Linux or Windows, you can pull google/embeddinggemma-2 from Hugging Face. Without the reader, though, all you get out of it is vectors. For a sense of footprint, Google quotes about 567 MB of RAM for the full quantized multimodal model on a Pixel 11 Pro. The model card recommends bfloat16 (or float32 on most CPUs) and warns that float16 can silently return NaNs.
What I'd actually use today
On a Mac, in English, when you want it fast and accurate, I'd pick Parakeet TDT 0.6B v3. It's open weights, has a published per-dataset WER, and it's already inside MacWhisper and FluidAudio. In Python, via Transformers (the model card says you need Transformers installed from source until Parakeet TDT lands in a release):
pip install git+https://github.com/huggingface/transformersfrom transformers import pipeline
pipe = pipeline("automatic-speech-recognition", model="nvidia/parakeet-tdt-0.6b-v3")
out = pipe("path/to/audio.wav") # 16 kHz mono .wav or .flac
print(out)If you'd rather use NVIDIA's own toolkit, the card's NeMo route starts with pip install -U nemo_toolkit['asr'].
For any other OS, any other language, or a box without much RAM, use whisper.cpp. Pick the model to fit your RAM. Per the README, tiny needs ~273 MB, base ~388 MB, small ~852 MB, medium ~2.1 GB and large ~3.9 GB.
git clone https://github.com/ggml-org/whisper.cpp.git
cd whisper.cpp
sh ./models/download-ggml-model.sh base.en
cmake -B build
cmake --build build -j --config Release
./build/bin/whisper-cli -f samples/jfk.wavEmbedding Gemma Transcribe is worth a try if you're on a Mac and want push-to-talk dictation in plain English. I'd keep it away from anything you'll quote, publish or bill a client for until there's a WER on a named benchmark and the code is public.
I care less about the speed, since Parakeet already matches it. The part that surprised me is that a frozen embedding model plus a reader trained in under two hours gets you usable English transcription. A multilingual version with an open reader would be worth watching. The current closed-source, Mac-only, English-only app doesn't replace Whisper.
What do you run for local transcription right now: Whisper, Parakeet, Apple's built-in model, something else? Would a ~5% WER, English-only model be good enough for your use, or is that a dealbreaker?
Sources
- Embedding Gemma Transcribe project page: https://eg2.haku.sh/
- Hacker News discussion: https://news.ycombinator.com/item?id=50069971
- Google blog, EmbeddingGemma 2: https://blog.google/innovation-and-ai/technology/developers-tools/embeddinggemma-2/
- EmbeddingGemma 2 model card: https://ai.google.dev/gemma/docs/embeddinggemma/model_card_2
- Parakeet TDT 0.6B v3 model card: https://huggingface.co/nvidia/parakeet-tdt-0.6b-v3
- whisper.cpp README: https://github.com/ggml-org/whisper.cpp
- Whisper large-v3 Open ASR average: https://localaimaster.com/blog/best-local-speech-to-text-models