English | 简体中文

---

No terminal needed. Install the app, drop in an audio file, and get your transcript — everything runs on your machine.

This repository is the Apache-2.0 open core behind the desktop app: a Rust CLI, a local OpenAI-compatible HTTP API, and the ggml inference engine. The desktop app wraps the same engine in a native GUI — no hidden network calls.

---

What it does

• Transcribe audio files — single files or entire folders, output as plain text, SRT/VTT subtitles, or JSON with word-level timestamps
• Live captions — real-time transcription from your microphone with streaming partial results
• System audio capture — caption meetings, lectures, and podcasts by recording what your computer plays
• Speaker separation — automatically label who said what
• Translation — transcribe and translate to English in one step
• Local API — OpenAI-compatible /v1/audio/transcriptions endpoint, works with existing SDKs

Why OpenASR

Private. In the default local mode, audio stays on your machine. Remote compute is available only when you explicitly pair and enable it; see SECURITY.md. No telemetry, no silent uploads, and no silent network fallback. The engine either produces a real transcript or tells you why it can't.

Broad. 30 models across 16 families — Whisper, Qwen3-ASR, Parakeet, SenseVoice, FireRed, Dolphin, Moonshine, Granite Speech, Fun-ASR-Nano, and more. Pick the one that fits your language and workload. All run through one binary on CPU and Apple Metal.

Open. The engine is Apache-2.0. Each model pack ships under its own upstream license as recorded in the registry and pack metadata. Every model download is verified against a signed catalog before it runs.

---

For developers

CLI quickstart

# Option A: Homebrew (macOS / Linux)
brew install quintinshaw/tap/openasr

# Option B: one-line installer (macOS / Linux)
curl -fsSL https://dl.openasr.org/install.sh | sh

# Option C: grab a prebuilt binary from Releases
# https://github.com/QuintinShaw/openasr/releases

# Transcribe a file (first run offers to download a model — you confirm first)
openasr transcribe recording.wav

# Live mic captions
openasr live

# SRT subtitles with speaker labels
openasr transcribe meeting.wav -f srt --diarize

# Align an existing manuscript onto audio (SRT/VTT/JSON)
openasr align recording.wav --transcript script.txt -f srt -o recording.srt

See Quickstart for a guided walkthrough, or run openasr --help.

Local API

openasr serve

curl http://127.0.0.1:8080/v1/audio/transcriptions \
  -F file=@audio.wav -F model=qwen3-asr-0.6b

Drop-in compatible with OpenAI SDKs (base_url="http://127.0.0.1:8080/v1") for transcription. Forced alignment of a user-supplied manuscript is OpenASR-native: POST /v1/audio/precise-timeline with file + transcript (not an OpenAI endpoint). Offline native requests are serial by default. Operators can set --max-native-sessions-per-model N; N is both the admission limit and, for eligible direct-GPU Cohere, Moonshine, Qwen, and Whisper jobs, the source for an internal batch width capped at 8. CPU, scheduler, adapter, realtime, FireRed-AED, and FireRed2 paths remain serial; translations follow the offline policy. See Agent Integration for API key setup and agent workflows.

Docker

Published images track each core release on Docker Hub (runtime binary + model-registry metadata only; pull models at runtime into a volume mounted at /data). They do not include bench-suite fixtures or committed baselines under perf/; run openasr bench-suite from a git checkout. The HTTP server never auto-downloads a pack — install one first:

docker pull quintinshaw/openasr:latest
docker run --rm -d --name openasr \
  -p 8080:8080 -v openasr-data:/data quintinshaw/openasr:latest
docker logs openasr
# pairing admin token: <token> (saved at /data/pairing-admin-token)
docker exec openasr openasr pull whisper-small --yes

# NVIDIA GPU (requires NVIDIA Container Toolkit; sm_75 / Turing+)
docker pull quintinshaw/openasr:cuda-latest
docker run --rm -d --name openasr-cuda --gpus all \
  -p 8080:8080 -v openasr-data:/data quintinshaw/openasr:cuda-latest

The default command listens on 0.0.0.0:8080 with HTTPS (--tls-self-signed) and device pairing. Unauthenticated /v1/* calls return 401 until a client is paired; GET /health stays a liveness probe. Use curl -k (or pin the self-signed certificate) when talking to the container directly.

Token. On first start, if OPENASR_PAIRING_ADMIN_TOKEN is unset, the server generates a random token, writes it owner-only to /data/pairing-admin-token, and prints pairing admin token: … (saved at /data/…) to stdout on that first generate. Later starts reuse the file and do not reprint the secret. Supply your own with -e OPENASR_PAIRING_ADMIN_TOKEN=…. Reuse a volume at /data so the generated token and pairing registry survive restarts.

Pair a client. In the desktop app, add this server as a remote and approve with the admin token. Over the API: POST /v1/pairing/requests with a device name, then POST /v1/pairing/requests/{id}/approve with Authorization: Bearer <token>. Transcription then uses the issued device credential, not the admin token.

Behind a TLS-terminating reverse proxy. Override the command to drop --tls-self-signed and set OPENASR_ALLOW_INSECURE_NON_LOOPBACK=1. That env only waives TLS, and only on a trusted boundary; device pairing stays mandatory. Do not set it on an untrusted network.

docker run --rm -d --name openasr \
  -p 8080:8080 -v openasr-data:/data \
  -e OPENASR_ALLOW_INSECURE_NON_LOOPBACK=1 \
  quintinshaw/openasr:latest \
  serve --addr 0.0.0.0:8080 --pairing-admin-token-file /data/pairing-admin-token

Vulkan, ROCm, and musl builds ship as GitHub Release archives only (not as images). Local source builds: Dockerfile / Dockerfile.cuda and compose.yaml. Longer guide (tags, compose, networking): openasr.org/docs/docker.

Building from source

git clone --recurse-submodules https://github.com/QuintinShaw/openasr.git
cd openasr
cargo build --release -p openasr-cli

Requires Rust (pinned via rust-toolchain.toml), CMake, and a C/C++ toolchain. Full build setup and development workflow in CONTRIBUTING.md.

Models

30 models across 16 families, from tiny English-only models that run faster than real-time to large multilingual models covering 100+ languages. Browse them at openasr.org/models or from the CLI:

openasr search            # browse available models
openasr pull whisper-small  # install one

Benchmarks from the committed performance baseline are in Performance.

Documentation

Contributing

Contributions welcome. See CONTRIBUTING.md for build setup, branch naming, the PR checklist, and DCO sign-off.

License

Apache License 2.0. See NOTICE for attribution.

The ggml inference backend is MIT-licensed. Each model pack's license is defined by its registry entry and pack metadata; packs may use Apache-2.0, MIT, CC-BY, FunASR, or other upstream terms. This is not an exhaustive license guarantee. See ACKNOWLEDGMENTS.md for the projects and model authors OpenASR builds on.

Trademarks and branding

The OpenASR name, logo, and official app icons are reserved. Apache-2.0 covers the code, not the brand. Third-party products may say “Powered by OpenASR” and must not use OpenASR as their primary product name or imply official endorsement. Official apps are published only by the project operators.

• TRADEMARKS.md — name, logo, and official-app reservation
• BRANDING.md — practical product-identity checklist
• XCFRAMEWORK-DISTRIBUTION.md — shipping iOS/macOS apps that embed the SDK