loom-ai-org/oruk-loop-153m-loom

oruk-loop-153M

Oruk AI's oruk-loop-153M English speech recognizer -- Qwen3-ASR-1.7B distilled into one encoder block run 24 times and one decoder block run 28 times, each depth with its own low-rank adapter -- exported for loom.cpp with the loop kept, in two precisions.

This is a loom.cpp export: a single self-describing GGUF that carries its own graph topologies, tokenizer (if any) and driver script, produced by loom-exporter.

Original model

Exported from oruk/oruk-loop-153M. The F32 file carries the same parameters unmodified, in loom.cpp's GGUF format; the others are quantized from them (see Files).

License

PolyForm Small Business 1.0.0 or PolyForm Noncommercial 1.0.0 -- inherited from the base model above.

Language(s)

en

Usage

Run it with loom-py -- loom-py-rt on PyPI:

pip install -U "loom-py-rt[hub]"

Needs loom-py-rt 1.0.0rc20 or later. This file uses long audio cut at quiet points into pieces it decodes one at a time, new in that release: an older engine decodes the clip in one pass, which this file's cache holds only for short audio -- past it, the call stops with an error naming loom.kv_cache_size.

import loom

# This repo holds more than one precision of the model; name the file you want (see "Files" below).
model = loom.Model.from_pretrained("loom-ai-org/oruk-loop-153m-loom", "oruk-loop-153m-f32.gguf")

# Audio is a mono float list at 16 kHz. This model decodes in the one language it was trained for and
# takes no `language=` argument -- passing one warns and is ignored, because nothing in its decode
# could act on it.
result = model.speech2text.infer(audio)
print(result.text)

The layer underneath

The call above is the high-level door: one per task, named for the modality pair it maps between, with the windowing, sampling and assembly this model needs already applied. Under it, model.infer(...) passes your arguments straight to the driver this GGUF embeds -- which is where you go for a knob the door does not name.

model.driver_source prints that driver, including a header comment documenting every argument it accepts for this model, and is the authority on it. See loom-py for the API and loom.cpp for what the engine does between the two.

Known limitations

License: not for every commercial use. The weights are free for personal, research, educational and other noncommercial use, and for any use by a small business (fewer than 100 people and under US$1M revenue); other commercial use needs a license from Oruk AI. These GGUFs are the same weights converted, under the same terms -- see LICENSE-WEIGHTS.md. Some of the training corpora carry non-commercial terms of their own; the upstream card lists them.

English only, with the language forced. The prompt is the one the upstream card's numbers come from (apply_transcription_request(language="English") in transformers 5.17): the answer is pre-filled with language English, so the model writes only the transcript. It takes no language= argument. The output keeps the teacher's casing and punctuation.

Long audio is cut the way the upstream transcribe cuts it -- into pieces of at most 30 s, each ending in the quietest 100 ms of its last 5 s, decoded one at a time and joined with spaces; each piece may write min(448, 10 per second + 24) tokens. That needs loom 1.0.0-rc20 or later (see Usage): the cache holds one piece, so an older engine, which decodes the clip in one pass, refuses one longer than about 55 s.

Small on disk, not in arithmetic. Every frame still passes through 24 encoder and 28 decoder layers at the teacher's width, so it costs about what Qwen3-ASR-1.7B costs to run: on a 4-thread laptop-class CPU 11 s of speech took about 20 s. The files also hold 200M parameters rather than the upstream 153M: the token table, factorised in the checkpoint, is stored as the 36,974 rows it multiplies out to -- the rows the checkpoint itself computes when it loads -- and token ids are renumbered to those rows, so the file's vocabulary is the kept 36,974 tokens, not Qwen's 151,936. No timestamps: segments is one span covering the whole clip. Mono 16 kHz.

Files

One model in several precisions; every file carries the same graph and driver. The quantized ones pack the convolution and projection weights (loom-export --quantize <type>), so their numbers differ from the original model's by the amount noted.

• oruk-loop-153m-f32.gguf -- full precision, 802 MB. On 73 LibriSpeech clips every transcript is the checkpoint's own (its modeling code, greedy), word for word; WER 5.13%.
• oruk-loop-153m-q8_0.gguf -- 243 MB. WER 5.39% on the same clips, 69 of 73 transcripts identical to F32; about half the memory (669 MB peak on an 11 s clip, against 1.35 GB).
• LICENSE-WEIGHTS.md -- the weights' license (PolyForm Small Business 1.0.0 or PolyForm Noncommercial 1.0.0, at your option), with Oruk AI's Required Notice. It travels with every copy of these files, converted or not.
• NOTICE.md -- the attribution to Qwen3-ASR-1.7B (Apache-2.0), which this model derives from.