loom-py

Speech, audio and language models in a few lines of Python, from a GPU down to a Raspberry Pi Zero.
Python bindings for loom.cpp · published on PyPI as loom-py-rt

import loom

tts = loom.Model.from_pretrained("loom-ai-org/pocket-tts-loom", "pocket-tts-q8_0_pc.gguf")
tts.text2speech.infer("Hello from a Raspberry Pi!").save("hello.wav")

• 64 ready-to-run models on Hugging Face: speech recognition, text to speech, voice activity, speaker and language id, music, codecs and small language models.
• One call per task, the same for every model that does it, with long audio, timestamps, voices and chat templates handled for you.
• Fast on small boards. On a Raspberry Pi 4, loom's int8 is 1.2x to 9.3x faster than onnxruntime's. On a Pi Zero, wake-word features, VAD, tiny TTS voices and Citrinet ASR run faster than real time, and its GPU's 12 QPUs make them 1.1x to 3.4x faster still.
• No runtime dependencies. Audio goes in as any sequence of floats: a list, a NumPy array or a torch tensor.

Install

pip install "loom-py-rt[hub]"          # + from_pretrained() from the Hugging Face Hub

Wheels cover Linux x86-64 and ARM64 (Raspberry Pi 3/4/5 on 64-bit Raspberry Pi OS, Jetson, Graviton), and macOS on Apple Silicon and Intel, for CPython 3.10 to 3.13. The Raspberry Pi Zero / Zero W / Pi 1 wheel is a release asset, because PyPI does not accept ARMv6 wheels:

pip install https://github.com/loom-ai-org/loom-py/releases/latest/download/loom_py_rt-1.0.0rc20-cp311-cp311-linux_armv6l.whl

Windows is not supported yet. Which CPU kernels a machine gets, and every platform detail, is in docs/PLATFORMS.md.

What you can do with it

Every model answers through a door named for what goes in and what comes out. A model carries all of them, and the ones it doesn't do say so, naming what it does.

🗣️ Text to speech

tts = loom.Model.from_pretrained("loom-ai-org/pocket-tts-loom", "pocket-tts-q8_0_pc.gguf")
audio = tts.text2speech.infer("The quick brown fox jumps over the lazy dog.")
audio.sample_rate, audio.duration      # (24000, 3.04)
audio.save("fox.wav")

tts.voices                             # ['alba', 'anna', 'azelma', 'bill_boerst', ...]
tts.text2speech.infer("Good morning.", voice="marius").save("marius.wav")

🎙️ Speech recognition

import soundfile
audio, _ = soundfile.read("speech.wav")            # 16 kHz mono

asr = loom.Model.from_pretrained("loom-ai-org/whisper-small-loom")
result = asr.speech2text.infer(audio, language="en", timestamps=True)
result.text
for segment in result.segments:
    print(segment.start, segment.end, segment.text)

Long recordings are windowed for you, and each window starts where the model closed its last segment, so a sentence on a window edge comes back whole.

💬 Language models

lm = loom.Model.from_pretrained("loom-ai-org/gemma-3-270m-it-loom")
lm.text2text.chat("What is the capital of France?", temperature=0.0)
# 'The capital of France is Paris.'

base = loom.Model.from_pretrained("loom-ai-org/qwen3-0.6b-base-loom")
base.text2text.infer("The capital of France is", max_new_tokens=16)   # a plain completion

Decoding follows each checkpoint's own generation settings. Pass temperature, top_k, top_p or seed to override them.

🎧 Voice activity, language and speaker id

vad = loom.Model.from_pretrained("loom-ai-org/silero-vad-loom")
frames = vad.speech2class.infer(audio)            # one row per 32 ms frame
speech = frames.probability("speech")             # the speech curve, yours to threshold
frames.times[:3]                                  # [0.0, 0.032, 0.064]

lid = loom.Model.from_pretrained("loom-ai-org/ecapa-voxlingua107-loom")
lid.speech2class.infer(audio).top(3)              # [('en: English', 0.82), ('la: Latin', 0.03), ...]

spk = loom.Model.from_pretrained("loom-ai-org/titanet-large-loom")
embedding = spk.speech2embeddings.infer(audio)    # 192 floats; compare two with cosine similarity

🏷️ Text classification

ner = loom.Model.from_pretrained("loom-ai-org/distilbert-ner-loom")
[(t.piece, t.label) for t in ner.text2class.infer("Wolfgang lives in Berlin")]
# [('Wolfgang', 'B-PER'), ('lives', 'O'), ('in', 'O'), ('Berlin', 'B-LOC')]

🎵 Codec models: dialogue, music and voice cloning

Some models write codec tokens, and a second file turns those into audio:

dia = loom.Model.from_pretrained("loom-ai-org/dia-1.6b-loom")
dac = loom.Model.from_pretrained("loom-ai-org/dac-44khz-loom")
codes = dia.text2codes.infer("[S1] Hello world.")
dac.codes2speech.infer(codes).save("dialogue.wav")

MusicGen + EnCodec, Qwen3-TTS + its tokenizer and MOSS-TTS + its codec pair the same way.

🔧 The layer underneath

Each file embeds its own driver script, and model.infer(...) passes your arguments straight to it, for the knobs a door doesn't name:

vits = loom.Model.from_pretrained("loom-ai-org/vits-piper-en-gb-miro-loom")
vits.task, vits.capabilities       # ('text-to-speech', ('text2speech',))
print(vits.driver_source)          # the driver, with a header documenting every argument it takes
samples = vits.infer(tokens=vits.tokenize("həˈloʊ"), seed=1, noise_scale_w=0.8)

docs/GUIDE.md covers every door in depth: what each returns, and why.

Models

Every model on huggingface.co/loom-ai-org loads by id. A few to start with:

The full catalogue, with sizes and languages, is in the loom.cpp README. Each model card on the Hub has a ready-to-run example.

Performance on a Raspberry Pi

Both engines were run on the same board, at the same precision, with the same thread count, inputs and output length. A bar past the dashed line means loom is faster:

Distilled Pocket TTS on a Pi 4 synthesises 4.8 s of speech in 0.59 s (2M), 1.07 s (7M) and 1.44 s (18M) at int8. The tiny models run faster than real time even on a Pi Zero, and its GPU speeds every one of them up: on a board booted without vc4-kms-v3d, device="auto" runs the convolutions and matrix products on its 12 QPUs (ggml-vc4) and the rest on the CPU.

_{Pi Zero: each device's faster precision (F32 or Q8_0_PC), the median of three launches with the order reversed every round; the same outputs on every launch. Pi 4: onnxruntime 1.28.0 (PyPI wheel), paired medians of five launches, with the board cooled to 60 °C before each one; both engines did the same work. Pocket TTS is measured against the community ONNX export KevinAHM/pocket-tts-onnx, since there is no official one, and Citrinet's onnxruntime time starts from precomputed mel features where loom's includes its front end. Every number, with its protocol and provenance: loom.cpp's docs/BENCHMARKS.md.}

Choosing a device

loom.Model.from_file("model.gguf")                 # the best device available (or $LOOM_DEVICE)
loom.Model.from_file("model.gguf", device="cpu")   # pin the CPU
loom.Model.from_file("model.gguf", device="gpu")   # require a GPU; raises if there is none
loom.devices()                                     # what this install can reach

Install a GPU backend with pip install "loom-py-rt[vulkan]" (or [cuda], [metal]). Anything a backend cannot run falls back to the CPU on its own.

Contributing

Clone with --recursive, since the engine is a submodule:

git clone --recursive https://github.com/loom-ai-org/loom-py
cd loom-py && pip install -e .
pytest tests/ci        # the Python layer, no model needed (what CI runs)
pytest tests/gate      # end to end on a real GGUF: LOOM_TEST_MODEL=... (+ LOOM_TEST_MODEL_INPUTS as JSON)

Design notes, decisions and open work for all three repos live in loom.cpp's docs. Packaging and wheels are in packaging/README.md.

Licence

MIT, see LICENSE. Each model on the Hub keeps the licence of the checkpoint it was exported from.