Orukeet

Nathan Roll^1,2 · Irene Yi^1,2 · Büşra Marşan^1,2
Vianney Grenez¹ · Gabriel Stein⁴ · Momcilo Mrkaic⁵
Pavle Padjin⁵ · Vladimir Zeljkovic⁵ · Calbert Graham^1,3

¹ Oruk AI

Orukeet is a 25-language speech recognizer built from NVIDIA Parakeet TDT 0.6B v3. It replaces half of the encoder's temporal depthwise filters with 12,288 fitted, frozen Gabor kernels and trains the remaining parameters on multilingual and multi-accent data.

Orukeet outperforms Parakeet on 61 of 74 tested splits, including LibriSpeech test-clean (1.46% vs. 1.53% WER), test-other (2.86% vs. 3.14%), and FLEURS English (3.82% vs. 4.28%). Across all 25 FLEURS languages, pooled WER is 9.85% vs. 11.01%, a 10.6% relative reduction. Final adaptation and checkpoint selection use LibriSpeech test-other.

Use Orukeet for recordings, media, batch transcription, server workers and interactive applications. NeMo, ONNX INT8, native Q8 and native F16 all derive from the same r3 release checkpoint (031c8ddab484).

Model card · Weights · Technical report

Use Orukeet in a desktop app

OpenWhispr 1.10.0 ships Orukeet as its recommended local model. In the local model picker, choose Oruk → Orukeet and download the model. This integration uses the ONNX export through OpenWhispr’s existing sherpa-onnx runtime.

Follow the file-upload walkthrough for the exact settings and a public sample with its observed transcript. Audio Upload needs its own model selection even when Orukeet is active for dictation.

TapTalk 0.4.0 is an open-source macOS dictation app with an Orukeet Core ML engine. Download Orukeet from its Models page; to switch between installed engines, use Settings → Local model. Orukeet transcribes completed recordings in this release; TapTalk's optional live typing uses Parakeet. See the TapTalk repository for setup and support.

Run speech recognition

Follow the local deployment tutorial for a fresh Python environment, a supplied recording, actual output and a reusable file runner. The tutorial includes the tested package version and artifact hashes.

Watch the 39-second recorded example to hear the input and inspect the native Q8 / Metal output. The walkthrough is edited for readability; it is not a speed or accuracy benchmark.

Use Python 3.12+ in an activated virtual environment. Install the prebuilt v0.1.1 package and download its verified model and native runtime:

python -m pip install --upgrade \
  https://github.com/Oruk-AI/orukeet/releases/download/v0.1.1/orukeet-0.1.1-py3-none-any.whl
orukeet install --device auto --cache ./orukeet-cache --output installation.json

Automatic selection installs the optimized Metal runtime on Apple silicon, CUDA on a detected NVIDIA device, or CPU. The installer verifies the Q8 weights and SDK hashes. Installing the prebuilt SDK requires no CMake, Ninja or compiler.

Model weights come from oruk/orukeet on Hugging Face, at pinned revisions. GitHub hosts the Python package and native SDKs. Cached weights are reused, and transcription runs offline.

Use the saved installation receipt to transcribe locally:

import json
from pathlib import Path
from orukeet import Orukeet

config = json.loads(Path("installation.json").read_text(encoding="utf-8-sig"))
with Orukeet(config["model"], config["runtime"], device=config["device"]) as asr:
    print(asr.transcribe("recording.wav")["text"])

A persistent worker keeps the model loaded across files. Input is decoded to mono 16 kHz and split into bounded windows for long recordings. Existing users should upgrade the package and rerun orukeet install to regenerate their installation receipt with the new runtime.

Local OpenAI-compatible server keeps one model loaded for multipart uploads from curl, the OpenAI Python client or Emacs.

Usage and application workers · NeMo inference and fine-tuning

To compile the runtime yourself, build the Metal SDK from source. The kernel patches, attention/cache changes and pinned build script live in runtime/.

Metal performance

Hoid developed Orukeet's Metal kernel and attention/cache optimizations. On Apple M4 Pro with 24 GiB RAM, the patches reduced warm native median latency by 42.4% (1.74× speedup) while preserving every transcript in a fixed 24-clip LibriSpeech test-clean benchmark.

These measurements use 5–30-second clips, exclude model loading and warmup, and describe the patch benchmark. The packaged v0.1.1 SDK has separate installation and transcript checks; its full timed benchmark has not been rerun. Measurement details and results.

Evaluation

Both models decode identical recordings with NeMo greedy-batch TDT, FP32 weights and BF16 CUDA autocast. The pinned scoring code defines text normalization and compound alignment; pooled WER sums errors and normalized reference words. Lower is better.

Orukeet improves 25 of 27 complete LibriSpeech/FLEURS splits and 36 of 47 accent/domain splits, including all 20 English accent/domain splits. The accent/domain sample contains 256 recordings per split and all 230 Lesbos recordings; the preceding adaptation includes 6,118 sampled recordings. Read speech and accents/domains have separate pooled results. Every recording contributes to the scores.

All 74 paired WER/CER scores and edit counts · Methods · Technical report

Architecture

The model retains Parakeet's 627,008,134 parameters, 24-layer FastConformer encoder, token-and-duration transducer and tokenizer. Each encoder block contains 1,024 nine-tap temporal depthwise filters. A selected filter stores its own fitted Gabor function:

$$g(t)=A\exp\left[-\frac{(t-\mu)^2}{2\sigma^2}\right]\cos\left(2\pi f(t-\mu)+\phi\right),\quad t=-4,\ldots,4.$$

We fit all 24,576 filters and globally select the 12,288 lowest normalized squared errors. This selects 175–748 kernels per layer, with 6.32% median relative RMS error and a 13.30% cutoff. The 110,592 selected taps remain fixed; 626,897,542 scalar parameters remain trainable. Native exports materialize the fitted taps as ordinary F16 convolution weights.

Construction

Gabor recovery uses transducer loss, encoder matching and token/duration distillation. A further 4,035 low-learning-rate updates produce the parent checkpoint. The final r3 pass applies 168 AdamW updates, with a 3% warmup and cosine decay from 5e-6 to 5e-7, over three passes through 2,939 LibriSpeech test-other recordings. Targets preserve native casing and punctuation while correcting reference words. The same split supplies checkpoint selection. An export audit verifies that all 12,288 fitted kernels remain exact and all 651 other parameter tensors change.

Fit and freeze recipe · Final adaptation · Training lineage

sherpa-onnx inference

From this repository checkout, download the pinned archive and its verification manifest from Hugging Face:

python -m pip install "huggingface-hub>=0.34,<2"
python examples/download_onnx.py --cache ./orukeet-cache
tar -xjf ./orukeet-cache/models/onnx/sherpa-onnx-orukeet-v0.1.0-int8.tar.bz2

The downloader verifies the manifest's SHA-256, then checks the archive's size and SHA-256 against it. Repeat runs reuse the Hub cache; add --local-files-only for an offline check. Download sources and counting.

The ONNX INT8 archive uses the standard Parakeet TDT v3 layout: encoder.int8.onnx, decoder.int8.onnx, joiner.int8.onnx and tokens.txt. It also includes the BPE vocabulary, weight license and attribution. Gabor filters are ordinary convolution weights; the model uses sherpa-onnx's existing offline transducer loader.

The optimized encoder evaluates 24 quantized depthwise convolutions with exactly equivalent FP32 arithmetic using operators already in ONNX Runtime. Execution details and receipts.

Archive SHA-256: f9191f30178cc9122ce2f023bf9fefafc822028307b0efa4caff645ba3fe8d0a.

Export and loader instructions · Conversion evidence

Model files

All formats derive from r3. NeMo and native files are pinned to revision 555136b50265a132d4cea0d35560c26fc4f657ab; the ONNX archive is pinned to 55a984d46f68323301837194ce647c702f55facc. The ONNX package occupies 671,619,800 bytes after extraction.

• NeMo SHA-256: 031c8ddab4845aeced904a7cde8e8aa57993b2e344716cf83a545b079c473b56
• Q8 SHA-256: 93ce19c6d8244acbfea980eeaf970531d4f216171578ef8e041dcc2d070a45bd
• F16 SHA-256: de53fb8ec251fb07ade15baabe17b00774ae3f1112f8618b062337f90fb49194

Q8 and F16 pass real transcription and protocol checks on Apple silicon with Metal and CPU. Conversion audits verify all 12,288 fitted kernels after F16 rounding. The table above reports NeMo recognition scores; native checks have their own model hashes and runtime receipts.

Artifact catalog · Native conversion and validation

License and attribution

Code: MIT. Weights and fitted kernels: CC BY-SA 4.0, retaining NVIDIA's foundation attribution. Transcript-free metric records: CC BY 4.0. Dataset audio is obtained from its original providers under their terms.

Data provenance · Attribution

Citation

@article{roll2026orukeet,
  title = {{Orukeet}: Multilingual {ASR} with Frozen {Gabor} Kernels},
  author = {Roll, Nathan and
            Yi, Irene and
            Mar{\c{s}}an, B{\"u}{\c{s}}ra and
            Grenez, Vianney and
            Stein, Gabriel and
            Mrkaic, Momcilo and
            Padjin, Pavle and
            Zeljkovic, Vladimir and
            Graham, Calbert},
  journal = {arXiv preprint arXiv:2609.10054},
  year = {2026},
  url = {https://arxiv.org/abs/2609.10054}
}

Download BibTeX · Citation metadata