Orukeet

Orukeet

Transcribes speech in 25 languages, as a modified version of NVIDIA's Parakeet TDT model with a lower word error rate in the authors' tests. It suits teams that transcribe recordings in bulk or live.

Made by oruk on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Orukeet is a speech recognizer for 25 languages. It starts from NVIDIA's Parakeet TDT 0.6B v3 model. The authors swapped half of the encoder's depthwise filters for fixed, pre-fitted Gabor kernels, then trained the other parameters on multilingual and multi-accent data.

Who it suits: It suits teams that turn spoken audio into text, from single recordings to batch jobs and live apps. The card names media files, server workers and interactive apps as typical uses.

Industry | Who uses it | How they use it | Example
Media | Editors and producers | Transcribe recordings and media files | Getting text from a recorded interview
Software | Developers of voice apps | Run speech recognition in a server worker or an interactive app | Adding live captions to an application
Operations | Data teams | Transcribe audio in batches | Converting a folder of call recordings into text
Research | Speech researchers | Compare a filter-modified model with its base | Reading the word error rates on public test sets

People who need speech in languages outside its 25 can skip it.

Where to use it:

• NeMo, in a CUDA-enabled PyTorch environment
• Transformers, through a standard FP32 export that needs no custom remote code
• ONNX INT8, native Q8 and native F16 builds
• Buzz, through its Hugging Face model option

Use case | Who | What they get back
Recording transcription | Editors | Text for each audio file
Batch transcription | Data teams | Transcripts for many files at once
Interactive transcription | App developers | Text produced for live use

How to set it up:

• Python on your computer
• A CUDA-capable PyTorch setup for NeMo, plus the nemo_toolkit package at version 3.0.0 with its asr extra, and huggingface-hub
• About 2.5 GB of disk for the F32 weights

1. Install the Hugging Face hub package.
2. Download the model files.
3. Install the NeMo packages, or use the Transformers export instead.

pip install -U huggingface_hub

hf download oruk/orukeet

How to use it: In NeMo, download the checkpoint, restore it as a speech recognition model, set it to evaluation mode and call transcribe on your audio file. The card also names an orukeet fetch source command that retrieves the same hash-checked checkpoint.

from huggingface_hub import hf_hub_download
from nemo.collections.asr.models import ASRModel

checkpoint = hf_hub_download(
    "oruk/orukeet", "orukeet-v0.1.0.nemo",
    revision="555136b50265a132d4cea0d35560c26fc4f657ab",
)
asr = ASRModel.restore_from(checkpoint)
asr.eval()
print(asr.transcribe(["recording.wav"], return_hypotheses=True)[0].text)

Tool | What it does
ASRModel.restore_from | Loads the downloaded NeMo checkpoint
transcribe | Turns your audio files into text
Transformers export | Runs the model through ParakeetForTDT with no custom code

Example: You have a recording named recording.wav. You load the checkpoint in NeMo and call transcribe on that file with hypotheses returned. The printed text is the transcript of the audio.

For newcomers and experts: Speech recognition turns audio into written words. A first small step is to run the NeMo sample on one short recording and read the text it prints.

It leaves the base model's size unchanged at about 627 million parameters. The encoder still has 24 FastConformer layers, and the decoder is the same token-and-duration transducer. The Gabor kernels are fitted once and frozen, and the rest of the model trains normally. The card says it beats Parakeet on 61 of 74 tested splits.

Audio file comes in
FastConformer encoder with Gabor filters
Token-and-duration transducer decodes
Transcript text comes out

Good to know:

• License: CC BY-SA 4.0.
• Cost to run: none named. NeMo needs a CUDA-capable GPU of your own.
• Data it reaches: it downloads files from the Hugging Face Hub, then processes the audio you give it.
• Not for: languages outside the 25 it supports. The card's own test scores are not independent proof.

Title: Word error rate in percent, lower is better
Orukeet on LibriSpeech test-clean: 1.46 percent
Parakeet on LibriSpeech test-clean: 1.53 percent
Orukeet on LibriSpeech test-other: 2.86 percent
Parakeet on LibriSpeech test-other: 3.14 percent
Orukeet on FLEURS English: 3.82 percent
Parakeet on FLEURS English: 4.28 percent
Orukeet on all 25 FLEURS languages: 9.85 percent
Parakeet on all 25 FLEURS languages: 11.01 percent

On Hugging Face, 13 November 2026

• Task: automatic speech recognition
• Library: nemo
• Parameters: 627M
• Weights: about 2.5 GB in F32; about 314 MB at 4-bit (estimate)
• Formats: Safetensors, GGUF
• Downloads in the last 30 days: 35,262
• Likes: 110
• License: cc-by-sa-4.0
• Languages: bg, hr, cs, da, nl, en, et, fi
• Based on: nvidia/parakeet-tdt-0.6b-v3
• Quantized versions: 5
• Fine-tunes: 1
• Tags: nemo, onnx, safetensors, gguf, parakeet_tdt, parakeet, sherpa-onnx, multilingual, speech-recognition, gabor, fastconformer, automatic-speech-recognition

Links

• Model: https://huggingface.co/oruk/orukeet
• Files: https://huggingface.co/oruk/orukeet/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download oruk/orukeet

Then follow the usage in its model card. Nothing in this kit runs by itself.