Rumble-2-Flash: Tiny open speech recognition model beats Whisper in 40+ languages

Amsterdam startup Reson8 has released its speech recognition model Rumble-2-Flash under the Apache 2.0 license. With just 0.5 billion parameters, it transcribes more than 40 languages and is said to keep up with models up to 60 times its size. It runs on modest hardware, too.

Model releases Try it yourself Nov 18, 2026 6 min read Source: Hugging Face Blog
Illustrative image, AI-generated

What's happening

Reson8 (officially Resonate Labs B.V.) is an Amsterdam startup focused on speech recognition, the technology that turns spoken language into text. On November 18, the company released its Rumble-2-Flash model as open weights under the Apache 2.0 license, which also permits commercial use. The model has just 0.5 billion parameters, understands more than 40 languages and can detect the language on its own if you want it to. You can download it on Hugging Face at Reson8/Rumble-2-Flash. It had already been available through Reson8's paid API since November 3.

According to the company, it goes up against models 3 to 60 times larger. It's mainly designed for fast transcription of pre-recorded audio files, not for real-time live captions.

Why the focus on languages other than English

Reson8 wants to fill a gap. According to SiliconANGLE, the company argues that leading speech models are trained mostly on English, even though only about one in 20 people speaks English as a first language. Accuracy drops sharply in other languages, especially for technical terms like drug names. Co-founder and CEO Raoul Ritter says:

"General-purpose speech models are built for English and make far more mistakes in other languages. Languages like Dutch, Swedish and German are spoken by millions, and yet they're an afterthought."

The company says its models are already in production: in meeting notes tools, AI phone receptionists, customer service voice bots, medical transcription and captioning. Reson8 was founded by Ritter, Thomas Kluiters (Chief AI Officer) and Jarno Verhagen. In March, it raised €5 million in pre-seed funding led by Balderton Capital.

How the model is built

Rumble-2-Flash uses the architecture of Qwen3-ASR, a speech recognition model family from Alibaba. The practical upside: if you use the Transformers library or the vLLM inference engine, you can use the model right away. You don't need a special build, and you don't have to run third-party code with trust_remote_code.

It was trained via distillation: a large "teacher" model, in this case Reson8's production model Rumble-2, passes its knowledge on to a small "student" model. Reson8 uses a variant called on-policy distillation. The student doesn't learn from transcripts the teacher produced. Instead, it transcribes the audio itself, and the teacher scores every single token, meaning every word piece. At each position, the teacher indicates how likely it considers each possible next token, and the student adjusts accordingly. That way the student gets corrected on exactly the mistakes it makes itself, and receives feedback on every word piece rather than just one overall grade per clip.

Normally, teacher and student have to use the same tokenizer, meaning the same method of splitting text into word pieces. That wasn't the case here, because the Qwen3-ASR architecture comes with its own vocabulary. A technique called GOLD works around this: wherever the two tokenizers split a text differently, tokens are merged so both models are compared over the same text. Tokens that appear in both vocabularies are compared directly, all others via their sorted probabilities.

Numbers and benchmarks

The metric is word error rate (WER), the share of incorrectly recognized words. Lower is better. On the multilingual track of Hugging Face's Open ASR Leaderboard, Rumble-2-Flash averages 6.96 percent across Chinese, German, French, Italian, Spanish, Portuguese, Hindi, Dutch and English, according to the blog post. That puts it ahead of Meta's omniASR-LLM 7B, which is 15 times larger, and OpenAI's Whisper large-v3. On the English track, it scores 6.6 percent.

SiliconANGLE cites slightly different figures from Reson8's own test runs: 7.09 percent across seven languages and around 5 percent on English. Where the difference comes from isn't clear. Most likely, different language selections or test sets were used. Another company claim stands out: across ten low-resource languages, such as Maltese and Basque, Rumble-2-Flash reportedly scores 17.6 percent, versus 39.82 percent for Whisper Large V3.

The test with real phone calls is especially interesting. Phone audio is compressed and noisy, and speakers often have very different accents. On AppTek's call center benchmark (302 hours of hotline calls, 14 English accents, scored with AppTek's own script), Reson8 reports:

Model Size WER
Qwen3-ASR 1.7B 1.7B 7.4%
NVIDIA Nemotron 3.5 Transcribe 30B 7.78%
Rumble-2-Flash 0.5B 7.86%
Qwen3-ASR 0.6B 0.6B 8.7%

For speed, Reson8 claims more than 7,000 RTFx. That figure tells you how many times faster than real time the model transcribes. An hour of audio would be done in about half a second. That only holds when batches are full, though, meaning the model processes many files at once, as with the leaderboard's larger datasets. For a single short file, the speedup is much smaller.

Features, pricing and limits

You can control the output: numbers as digits or spelled out, keep or remove filler words like "um," transcribe repetitions verbatim, and force a specific language. As input, the model accepts local files, URLs, NumPy arrays or lists of them. Custom vocabularies with up to 50,000 terms that plug in without retraining are only available with the larger Rumble-2. If you use the API, you'll pay from €0.01 per hour of audio, according to SiliconANGLE. The servers are in the Netherlands, and Reson8 says audio and transcripts aren't stored. The company also cites ISO 27001 certification and compliance with GDPR and the EU AI Act.

What you need to try it

The model is so small that it runs almost anywhere. At full precision, it needs roughly 1 to 2 GB of VRAM (video memory). Practically any current Nvidia graphics card will do, and a Mac with an Apple Silicon chip should be enough too. Without a GPU, it also runs on the CPU, just slower, and not much is left of those 7,000 RTFx. 8 GB of RAM and a few gigabytes of disk space for Python, PyTorch and the model are enough. Google Colab with a free GPU is a convenient alternative. You'll need Python plus the packages torch, transformers and accelerate. The model loads via AutoModelForMultimodalLM. For large volumes, vLLM is the way to go. Reson8 hasn't announced a ready-made Ollama version or GGUF file.

Our take

Rumble-2-Flash is a good example of how far small models have come. A 0.5-billion-parameter model beating Whisper large-v3 and nearly matching a 30-billion-parameter NVIDIA model on phone calls is remarkable, if it holds up. For Europe, the focus on languages like German and Dutch, plus EU hosting, is attractive. The permissive license lets you use it in your own products.

That said, all the numbers come from the company, and they already differ between the blog post and press coverage. Independent tests are still pending, especially for the low-resource language figures. On the phone benchmark, the model it's based on, Qwen3-ASR 1.7B, still does better, though it's three times the size. And the most useful feature for professionals, custom vocabularies, is reserved for the paid larger model. Still, if you're running Whisper locally today, Rumble-2-Flash is definitely worth testing.

Sources

#speech recognition#open-source#transcription#hugging face#reson8
Read the original source

Try it yourself: Rumble-2-Flash

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

What can I do with it?

Rumble-2-Flash turns audio recordings into text in more than 40 languages, including German, English, French, Spanish, Dutch, Chinese and Hindi. It can detect the language on its own, or you can specify it. The output is configurable: numbers as digits or words, keep or drop filler words, transcribe repetitions verbatim. According to the company, it's more accurate than OpenAI's Whisper large-v3 and nearly keeps pace with a 60x larger NVIDIA model even on noisy phone calls. It's meant for finished recordings, not live captions. You can't plug in your own glossaries of technical terms; only the paid larger Rumble-2 model can do that. So far, all quality claims come from the company.

Who is it worth it for?

Worth it if you regularly need interviews, meetings, lectures, podcasts or voice memos transcribed, especially in German or other non-English languages, and want to do it locally without the cloud. Developers get a lean, permissively licensed Whisper alternative. If you're after text chat or need real-time dictation, this isn't for you.

Ideas: What you can do with it

Transcribe interviews

Journalists, students and researchers can transcribe interview recordings locally. The data never leaves your computer. With the verbatim option, quotes stay exact.

Meeting minutes

Record a Teams or Zoom meeting and have it converted to text afterward. You can then have a language model summarize the text and pull out action items.

Video subtitles

If you make YouTube videos or club films, you can quickly create a transcript as the basis for subtitles, in several languages too. You may need another tool to add timestamps.

Make voice memos searchable

Collect voice memos from your phone in a folder and transcribe them in one go. Later, you can use full-text search to find ideas and appointments again.

Unlock your podcast archive

Podcasters can transcribe their entire archive in minutes, for show notes, blog posts or search engines. Thanks to batch processing, it's very fast on a GPU.

Analyze customer calls

Small businesses can transcribe recorded support calls (with consent) and search them for recurring problems. According to the company, the model is particularly strong on phone-quality audio.

Size0.5 B parameters
Download1.4 GB (about 2 min at 100 Mbit/s)
Licenseapache-2.0
TypeSpeech recognition (speech to text)

What your computer needs

Graphics card (NVIDIA) at least 2.5 GB VRAMThis value is calculated; the company doesn't specify one. The calculation is based on the main file model.safetensors (1.02 GB in bf16): 1.02 × 1.2 + 1 ≈ 2.2 GB. The CTC head (0.36 GB) isn't loaded with the standard instructions. More VRAM mainly helps with long recordings and many files at once. With only 0.5B parameters, the model should also run on the CPU, but the source doesn't say so.
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. 3.4 GB freeModel download plus programs

There's only one variant, with 0.5 billion parameters. You don't need quantization; the model runs at normal precision (bf16) with just around 1 to 2 GB of VRAM. It's fastest on an Nvidia GPU. It also works on Apple Silicon or CPU only, just slower. For lots of files at once, use vLLM instead of Transformers.

  • Roughly 1 to 2 GB of VRAM is enough; practically any current Nvidia card will do.
  • It also runs without a GPU on the CPU, but noticeably slower.
  • The advertised 7,000 RTFx (an hour of audio in half a second) only applies with full batches on a powerful GPU, not for individual files.
  • On Macs with Apple Silicon, it should run via PyTorch. Google Colab with a free GPU is an easy alternative.
  • Set aside a few gigabytes of disk space for PyTorch, Transformers and the model.
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. The commands below come from the Model Card and the developers' instructions.

Windows 10 / 11

Windows 10 / 11: not officially tested. The Model Card doesn't mention an operating system. The Transformers route should work on Windows but hasn't been tested. vLLM only runs on Windows via WSL2, a Linux subsystem for Windows.

  1. Install prerequisites. You need Python 3.10 or newer and Git. When installing Python, check the box “Add Python to PATH.” With an NVIDIA graphics card, you'll need a current NVIDIA driver. Then open PowerShell and check the versions.
    python --version
    git --version
  2. Create a working folder. Create a dedicated folder for the project and switch into it. There's no separate program repo; you only need Python packages and the model.
    mkdir rumble
    cd rumble
  3. Create a virtual environment. A virtual environment (venv) is an isolated folder for Python packages, so you won't clash with other programs. Once activated, (.venv) appears at the start of the line. If Windows says scripts can't be run, enter “Set-ExecutionPolicy -Scope CurrentUser RemoteSigned” once beforehand.
    python -m venv .venv
    .venv\Scripts\Activate.ps1
  4. Install packages. This installs PyTorch (the compute foundation), Transformers (loads and runs the model) and Accelerate (places it on the GPU or CPU). The model needs a very recent version of Transformers, which is why the command includes -U. Heads up: on Windows, “pip install torch” often installs only the CPU version. For your NVIDIA card, pick the CUDA install command on the PyTorch website.
    pip install -U torch transformers accelerate
  5. Download the model. This downloads the roughly 1.4 GB of model files from Hugging Face into your cache. You can skip this step; the script will then download the model automatically on first run.
    hf download Reson8/Rumble-2-Flash
  6. Create a test script. Open a text editor, paste this code and save it as demo.py in the rumble folder. The script transcribes an English sample audio clip about the weather in Barcelona. The file is hosted online.
    from transformers import AutoProcessor, AutoModelForMultimodalLM
    
    model_id = "Reson8/Rumble-2-Flash"
    processor = AutoProcessor.from_pretrained(model_id)
    model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")
    
    inputs = processor.apply_transcription_request(
        audio="https://hf.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3",
        language="English",
    ).to(model.device, dtype=model.dtype)
    
    output = model.generate(**inputs, max_new_tokens=512)
    generated = output[:, inputs["input_ids"].shape[-1]:]
    print(processor.decode(generated, return_format="transcription_only")[0])
  7. Run your first transcription. Run the script in the activated environment. After a short load time, the recognized English text appears in PowerShell. If Python says AutoModelForMultimodalLM doesn't exist, your Transformers version is too old. Run the pip command again.
    python demo.py
  8. Result. The terminal shows the English transcript of the sample recording about the weather in Barcelona.

macOS

macOS: not officially tested. The Model Card doesn't mention macOS. Via Transformers, the model should run on Apple Silicon Macs, either on Apple's GPU (MPS) or on the CPU. This hasn't been tested. vLLM isn't meant for the Mac.

  1. Install prerequisites. You need Python 3.10 or newer, Git and the Xcode command line tools. Install the tools in Terminal with the first command, then check the versions.
    xcode-select --install
    python3 --version
    git --version
  2. Create a working folder. Create a dedicated folder for the project and switch into it. You don't need a separate program repo.
    mkdir rumble
    cd rumble
  3. Create a virtual environment. A virtual environment (venv) is an isolated folder for Python packages. Once activated, (.venv) appears at the start of the line. You'll need to repeat the activation in every new terminal.
    python3 -m venv .venv
    source .venv/bin/activate
  4. Install packages. This installs PyTorch, Transformers and Accelerate. The model needs a very recent version of Transformers, which is why the command includes -U.
    pip install -U torch transformers accelerate
  5. Download the model. This downloads about 1.4 GB from Hugging Face. If you skip this step, the script will download the model automatically on first run.
    hf download Reson8/Rumble-2-Flash
  6. Create a test script. This command creates the file demo.py with the sample code from the Model Card. The script transcribes an English sample audio clip hosted online.
    cat > demo.py << 'EOF'
    from transformers import AutoProcessor, AutoModelForMultimodalLM
    
    model_id = "Reson8/Rumble-2-Flash"
    processor = AutoProcessor.from_pretrained(model_id)
    model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")
    
    inputs = processor.apply_transcription_request(
        audio="https://hf.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3",
        language="English",
    ).to(model.device, dtype=model.dtype)
    
    output = model.generate(**inputs, max_new_tokens=512)
    generated = output[:, inputs["input_ids"].shape[-1]:]
    print(processor.decode(generated, return_format="transcription_only")[0])
    EOF
  7. Run your first transcription. Run the script. After loading, the recognized English text appears in Terminal. If you get an error about AutoModelForMultimodalLM, Transformers is too old. Run the pip command again.
    python3 demo.py
  8. Result. The terminal shows the English transcript of the sample recording about the weather in Barcelona.

Linux

Linux: supported. The Model Card offers two routes: Transformers for beginners and vLLM as a fast server. The benchmark figures come from an NVIDIA H200 running vLLM. These instructions use the simpler Transformers route.

  1. Install prerequisites. You need Python 3.10 or newer, Git and, for the GPU, a current NVIDIA driver. Check in the terminal. nvidia-smi shows your graphics card and its memory.
    python3 --version
    git --version
    nvidia-smi
  2. Create a working folder. Create a dedicated folder for the project and switch into it. You don't need a separate program repo, just Python packages.
    mkdir rumble
    cd rumble
  3. Create a virtual environment. A virtual environment (venv) is an isolated folder for Python packages. Once activated, (.venv) appears at the start of the line.
    python3 -m venv .venv
    source .venv/bin/activate
  4. Install packages. This installs PyTorch (the compute foundation), Transformers (runs the model) and Accelerate (automatically places it on the GPU). The model needs a very recent version of Transformers, which is why the command includes -U. The Model Card uses “uv pip install,” but regular pip works just as well.
    pip install -U torch transformers accelerate
  5. Download the model. This downloads about 1.4 GB from Hugging Face. If you skip this step, the script will download the model automatically on first run.
    hf download Reson8/Rumble-2-Flash
  6. Create a test script. This command creates the file demo.py with the sample code from the Model Card. The script transcribes an English sample audio clip about the weather in Barcelona.
    cat > demo.py << 'EOF'
    from transformers import AutoProcessor, AutoModelForMultimodalLM
    
    model_id = "Reson8/Rumble-2-Flash"
    processor = AutoProcessor.from_pretrained(model_id)
    model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")
    
    inputs = processor.apply_transcription_request(
        audio="https://hf.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3",
        language="English",
    ).to(model.device, dtype=model.dtype)
    
    output = model.generate(**inputs, max_new_tokens=512)
    generated = output[:, inputs["input_ids"].shape[-1]:]
    print(processor.decode(generated, return_format="transcription_only")[0])
    EOF
  7. Run your first transcription. Run the script. After loading, the recognized English text appears in the terminal. If you get an error about AutoModelForMultimodalLM, Transformers is too old. Run the pip command again.
    python3 demo.py
  8. Result. The terminal shows the English transcript of the sample recording about the weather in Barcelona.

What to do after your first result

  • Your own recordings: in demo.py, replace the web address after audio= with the path to your file, e.g. "my_recording.wav". Multiple files work too, as a list.
  • Recognize German: set language="German". If you leave out language, the model detects the language itself. In that case, use return_format="parsed" when decoding. The model supports 45 languages.
  • More options from the Model Card: digits=False writes numbers as words, filler=True keeps filler words like “um,” and verbatim=False collapses repeated words.
  • For many files and high speed on Linux: install vLLM with pip install "vllm[audio]" openai and start a server with vllm serve Reson8/Rumble-2-Flash --max-model-len 4096. Then talk to it through the OpenAI-compatible API, as shown in the Model Card example.

Try it

Transcribe the voice memo memo.m4a in German (parameter language="German").
Automatically detect the language of this recording and output both language and text (omit language, return_format="parsed").
Transcribe this interview and output all numbers as digits, e.g. “€1,250” instead of “one thousand two hundred fifty euros.”
Transcribe the meeting verbatim, including filler words like “um” and repetitions.
Process the entire folder of 50 podcast episodes in one pass as a list of file paths.

Tips for better results

  • If you know the language, set it explicitly. That prevents misdetection on short or mixed-language recordings.
  • With many files, batch processing (a list of paths or vLLM) gives you the biggest speed boost.
  • Use the output options deliberately: verbatim for research and quotes, no filler words for readable minutes.
  • Test it against Whisper on technical terms like drug or product names. That's where differences are most likely to show.

If something goes wrong

The model loads via AutoModelForMultimodalLM, not the usual Whisper pipeline. Use a current version of Transformers, or Qwen3-ASR support will be missing.

For transcription, you use processor.apply_transcription_request. With automatic language detection, set return_format="parsed", or the detected language won't be cleanly separated.

max_new_tokens caps the text length. For long recordings, raise the value or split the audio into chunks, or the text will get cut off.

For MP3 or M4A files, you may need an audio backend like ffmpeg on your system.

There's no Ollama or GGUF version yet, so Ollama and LM Studio won't work with it directly.

“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: apache-2.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.