Run Orukeet locally: Python speech recognition

Watch the local example

Hear the sample, see the command and inspect what the model returned. This 39-second walkthrough uses a recorded Orukeet 0.1.1 run on Apple silicon with the native Q8 model and Metal runtime.

Use Orukeet in OpenWhispr

You can transcribe a file without a Python environment. OpenWhispr 1.10.0 includes Orukeet as its recommended local model. The steps below were checked in the macOS app with the model already downloaded.

1. Open Settings → Speech-to-Text → Audio Upload. Choose Local, then the Oruk tab. Download Orukeet if needed and select it so its card says Active.
2. Close Settings and open Upload. Check that the provider reads Using Orukeet.
3. Paste the public sample URL below into the audio URL field and choose Add link. Wait for the filename to appear.
4. Leave Speaker detection off and choose Transcribe. The app shows Transcribing locally…, then the result.

https://oruk.ai/samples/oruk-quickstart.wav

I am genuinely excited that this is finally working.

If Upload says No transcription provider set up, check the Audio Upload tab in Settings. Dictation, Note Recording and Audio Upload have separate selections; having Orukeet active for dictation does not configure file uploads. We encountered this during the check and resolved it by selecting Orukeet for Audio Upload.

Checked September 11, 2026 with the public quickstart recording and speaker detection off. This verifies one file-transcription workflow in the released app. It does not measure recognition accuracy, latency, speaker separation or a customer outcome.

Install the model and runtime

Start with Python 3.12 or newer. The commands below use a macOS or Linux shell. Allow space for the 714 MB Q8 model, the native runtime and Python dependencies. The prebuilt runtime does not require a compiler.

python3 --version  # Python 3.12 or newer
python3 -m venv .venv
source .venv/bin/activate
python -m pip install 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

The installer checks artifact hashes and saves absolute paths in installation.json. Automatic selection uses Metal on Apple silicon, CUDA when an NVIDIA device is detected, and CPU otherwise, subject to the published runtime support for your platform. The run recorded below used Metal on Apple silicon.

Installation downloads the weights and runtime. Keep those files and the receipt together; transcription then runs locally. If you move the installation to another computer, run the installer there to select its runtime and regenerate the paths.

Keep a local transcription server running

This optional example keeps one recognizer loaded for completed recordings from an editor or OpenAI-compatible client. After the installation steps above, run these commands in the same virtual environment and directory as installation.json. It reuses your downloaded model and runtime.

curl --fail --location --output local_server.py \
  https://raw.githubusercontent.com/Oruk-AI/orukeet/6b79841e22d88b066c94236ed4a36ab98eeef04d/examples/local_server.py
curl --fail --location --output local-server-requirements.txt \
  https://raw.githubusercontent.com/Oruk-AI/orukeet/6b79841e22d88b066c94236ed4a36ab98eeef04d/examples/local-server-requirements.txt
python -m pip install -r local-server-requirements.txt
python local_server.py --installation installation.json

Wait for Orukeet ready and the server startup message. Keep that terminal running, then send the sample recording from another terminal:

curl --fail-with-body http://127.0.0.1:8000/v1/audio/transcriptions \
  -F model=orukeet -F file=@sample.wav -F response_format=text

The server listens on 127.0.0.1:8000 and processes one recording at a time. By default it admits two requests total, limits each upload to 25 MiB and decoded audio to five minutes, and returns HTTP 429 when full. Send recordings sequentially or retry after the indicated delay. Run one server only: extra workers or reload processes each load another model. Responses contain final text; this example does not stream partial transcripts.

Full setup, limits and Emacs client settings · Pinned server source · Pinned requirements. The example is for local use; the setup document covers authentication when binding beyond your computer.

Use the ONNX export with sherpa-onnx

This is the published ONNX archive used by the OpenWhispr 1.10.0 integration. You can load it directly in Python without installing the desktop app. The example below uses the CPU provider, two threads and a fresh Python 3.12 environment on Apple silicon. It does not use the native Metal runtime.

Allow about 487 MB for the archive and 672 MB for its extracted files, plus the Python environment. The download is pinned to a model revision; the extraction step checks its SHA-256 before unpacking it. Keep the included weight license and attribution with the model. Use Python 3.12 for the pinned package versions shown here.

python3.12 -m venv .venv-onnx
source .venv-onnx/bin/activate
python -m pip install sherpa-onnx==1.13.4 numpy==2.2.6
curl --fail --location --output orukeet-onnx.tar.bz2 \
  https://huggingface.co/oruk/orukeet/resolve/55a984d46f68323301837194ce647c702f55facc/onnx/sherpa-onnx-orukeet-v0.1.0-int8.tar.bz2
python - <<'PY'
import hashlib
import tarfile
with open("orukeet-onnx.tar.bz2", "rb") as archive:
    digest = hashlib.file_digest(archive, "sha256").hexdigest()
if digest != "f9191f30178cc9122ce2f023bf9fefafc822028307b0efa4caff645ba3fe8d0a":
    raise SystemExit("Archive checksum mismatch; download it again.")
with tarfile.open("orukeet-onnx.tar.bz2", "r:bz2") as archive:
    archive.extractall(filter="data")
PY

curl --fail --location --output oruk-quickstart.wav https://oruk.ai/samples/oruk-quickstart.wav
curl --fail --location --output orukeet-onnx.py https://oruk.ai/examples/orukeet-onnx.py
python orukeet-onnx.py oruk-quickstart.wav \
  --model-dir sherpa-onnx-orukeet-v0.1.0-int8

{
  "file": "oruk-quickstart.wav",
  "text": "I am genuinely excited that this is finally working.",
  "duration_seconds": 4.053877551020408,
  "runtime": "sherpa-onnx",
  "provider": "cpu"
}

Recorded September 11, 2026. This checks the released archive, loader and one recording; it does not measure accuracy or compare runtime speed. Environment, hashes and verification · Download the output. The desktop app check above was run separately.

The runner accepts mono, 16-bit PCM WAV files from 0.1 to 30 seconds, at 8–48 kHz. It passes the recording’s actual sample rate to sherpa-onnx, which resamples to the model’s 16 kHz input. The supplied recording is 22.05 kHz. Invalid formats, truncated files and missing model files produce an error instead of an empty transcript.

Pass several WAV paths to reuse one recognizer. The loader needs feature_dim=128 and model_type="nemo_transducer"; ordinary loader defaults are not sufficient. The downloadable runner sets both. This full-context model does not become a streaming recognizer by accepting small audio chunks. For longer recordings, use the native worker above or implement and evaluate your application’s segmentation.

The same recordings through four local runtimes

On September 12, we compared Orukeet r3 with stock Parakeet TDT v3 on the first 20 FLEURS validation recordings in English, German, Spanish, French, Russian and Ukrainian. Each comparison used the same 120 clips and 2,433 reference words. On September 17, we rechecked their audio hashes and recomputed these historical tables from the saved transcripts. A separate fresh CPU reproduction below downloads the pinned inputs and runs both ONNX exports again.

These are our integration checks, not an independent holdout. The r3 research protocol discloses benchmark selection and adaptation overlap. This small sample does not establish performance on unseen audio, the other 19 local languages or the hosted API.

The tested ONNX export reduced pooled errors. The native Q8 comparisons did not: LocalAI CPU tied, and Orukeet made two more errors on LocalAI Metal and five more on Handy Metal. English and Spanish improved in those native comparisons, but that did not produce a pooled advantage. Choose and evaluate the export you will actually deploy.

Warm timing depends on what you measure

These runs used an Apple M5 Max with 128 GiB RAM and macOS 26.4.1. Each model processed every recording three times after warmup. LocalAI includes HTTP upload, server decoding and JSON response parsing; sherpa-onnx and the Handy runtime exclude file decoding and model loading. The rows therefore cannot establish a speedup between runtimes.

¹ LocalAI CPU timing overlapped other work. Earlier Handy timings also overlapped other work and were replaced by the alternating paired run above. sherpa-onnx used two CPU threads and separate warmed model blocks; LocalAI and Handy Metal alternated model order per recording. A first LocalAI Metal attempt failed when disk space ran out; its incomplete run is excluded, with the failure retained in the archive. These measurements support comparable native speed on this machine, not a general acceleration claim.

Check the arithmetic without installing a model

curl --fail --location --output orukeet-integrations.zip \
  https://oruk.ai/benchmarks/orukeet-integrations-2026-09-12.zip
python3 -m zipfile -e orukeet-integrations.zip .
cd orukeet-integrations-2026-09-12
python3 replay.py --check

The archive includes every recording’s saved output, all three timed repetitions, the fixed manifest, model and runtime provenance, original protocols, and a dependency-free scorer. It also retains unpaired Handy CPU and NeMo source checks as diagnostics, without inventing a comparison. The replay checks file hashes and recomputes every table above; it makes no API calls.

This archive verifies the saved results and preserves the original protocols. The new package below closes pinned acquisition and fresh inference for the ONNX CPU pair. Native runtime reproduction remains unfinished, including the missing historical LocalAI CPU backend digest. Audio and model weights are not included. FLEURS reference excerpts are credited to Conneau and colleagues under CC BY 4.0.

Download the complete replay archive · Protocol, failures and limitations · Recording manifest · Complete scores · Model and runtime provenance

Re-run the CPU comparison from pinned downloads

On September 17, we downloaded the six immutable FLEURS shards and both published ONNX exports into a new directory, installed a hash-locked Python environment, and ran the comparison again. All 120 audio hashes, recording IDs, original references and sample counts matched the old manifest. Every new transcript matched its model’s historical output, and all repeated transcripts were stable: 960 successful receipts, including warmup, with no inference failures. French regressed from 29 errors with stock Parakeet to 35 with Orukeet; the pooled improvement does not imply a gain in every language.

The run used an M5 Max with 128 GiB RAM, macOS 26.4.1 and two CPU threads per model. Both models were loaded before warmup, then decoded sequentially in alternating order over three shuffled passes: 360 timed observations per model. Timing excludes downloads, WAV decoding, model loading and result writing. Task-owned heavy work was paused; normal background activity remained. The older ONNX run used separate model blocks, so these numbers do not establish an improvement over that run or a speedup against a different runtime.

This establishes that the published artifacts can reproduce these outputs. It reuses a development integration sample, whose unseen status is unverified. The r3 protocol discloses benchmark use for checkpoint selection and adaptation overlap. This is not independent accuracy evidence or a hosted API measurement. The stock ONNX files are pinned; the exporter’s exact NVIDIA source-checkpoint attestation remains unavailable. The package records that provenance gap and the applicable model-card terms.

curl --fail --location --output orukeet-reproduction.zip \
  https://oruk.ai/benchmarks/orukeet-reproduction-2026-09-17.zip
python3 -m zipfile -e orukeet-reproduction.zip .
cd orukeet-reproduction-2026-09-17
python3 verify.py
python3 replay.py --check

To run new inference, continue in the extracted directory on macOS arm64. Install uv first if it is not already available. The download is about 2.64 GB; allow at least 5 GB free. No API key is needed. Record the actual workload conditions in the note and choose a new output directory. Any changed file hash, missing recording, failed decode or unstable repeated output prevents a complete comparison.

uv venv --python 3.11.15 .venv
uv pip install --python .venv/bin/python --require-hashes --only-binary :all: -r requirements.txt
.venv/bin/python fetch.py --work ../orukeet-inputs
.venv/bin/python run.py --work ../orukeet-inputs --output runs/my-reproduction \
  --note 'Describe your actual background workload here.'
.venv/bin/python score.py runs/my-reproduction --check

Download the reproduction package · Exact protocol and license terms · Pinned acquisition sources · All 960 receipts · Scores and per-recording outputs