FireRedASR2-AED · Fully Local Chinese (Including Dialects) Speech-to-Text
Give it a recording and this model turns it into text — Mandarin, more than twenty Chinese dialects, English, mixed Chinese-English, even sung lyrics — and it can tell who spoke when (multi-speaker diarization). All on your own computer. No cloud, free, private.
The model was built by Xiaohongshu's FireRedTeam and released under Apache-2.0 (FireRedASR2-AED, an attention encoder-decoder architecture).
This repo is not a new model: the capability belongs to FireRedTeam; the
lightweight (int8) ONNX conversion was done by the open-source project
ManySpeech / manyeyes; we (42ailab)
redistribute that offline-runnable build, include it in the
42model engine's curated selection, and ran end-to-end quality verification — what we did was make it work out of the box on your computer.
1. The problem it solves
Turning speech into text (ASR) is the first step of almost any audio or video work, but good Chinese transcription usually faces three hurdles:
- Dialects and accents: many models only handle standard Mandarin well and degrade noticeably on Cantonese, Sichuanese or Shanghainese;
- Whether to go to the cloud: meeting recordings, interviews and voice memos often carry privacy concerns that make uploading to someone else's server uncomfortable;
- Multi-speaker conversation: meetings, interviews and podcasts usually involve several people, and one undivided block of text is not enough — you need to know who spoke when.
This model addresses all three: dialect-friendly, fully local, and able to distinguish multiple speakers. It works on your commute, on a trip, offline, and in sensitive settings, with no per-use cost.
2. How it works
The capability comes from FireRedTeam's FireRedASR2-AED — an attention encoder-decoder speech recognition model: the encoder listens to the audio and turns it into an internal representation, then the decoder writes out the text token by token. It was trained on massive Chinese corpora (including extensive dialect data) and mixed Chinese-English speech, which makes it robust to accents and code-switching. Within the FireRedASR2 family it is the efficiency-focused tier, well suited to running on a personal computer.
The lightweight conversion comes from ManySpeech (manyeyes): the original weights were converted to int8-precision ONNX files (about 1.7 GB), sharply reducing memory and compute requirements so it runs smoothly on an ordinary CPU with no GPU needed.
What we did: redistributed this set of open-source files to a repository that downloads directly inside China, included it in the 42model engine's curated selection, and verified transcription quality end to end inside the engine (see below); the license remains upstream Apache-2.0, unchanged. It runs locally across macOS / Windows / Linux.
3. How well it performs
For the full evaluation of the model itself, refer to FireRedTeam's official report (
paper). Their data shows FireRedASR2-AED leading on several public Chinese test sets (lower is better):
| FireRedTeam official report | FireRedASR2-AED |
|---|
| Mandarin average character error rate (lower is better) | 3.05%, ahead of Chinese ASR models of the same size |
| Chinese dialects (20+) average character error rate | 11.67% |
(For the complete benchmarks and item-by-item comparison, refer to the upstream paper; the figures above are taken from FireRedTeam's official report.)
Our own verification (42model engine, CPU only):
| What we verified | Result |
|---|
| Transcribing the official sample recordings and comparing character by character against the reference implementation | Exactly identical (Mandarin, English and mixed Chinese-English samples all passed) |
| Hardware | No GPU required; an ordinary CPU suffices |
In other words: once this local build is wired into our engine, transcription output is character-for-character identical to the upstream reference implementation — quantization introduced no visible quality loss.
4. Limitations and what's next
- Dialects remain best-effort: upstream trained on twenty-odd dialects, but real accents vary enormously, and particular regions, strong accents or noisy environments can still produce errors; we keep verifying against real dialect material and tightening as we go.
- Split long recordings: very long continuous audio is more stable when cut into segments and transcribed separately (the 42model engine handles this automatically).
- Speaker diarization is built in: "who spoke when" is labeled locally (using the 42model engine's diarization pipeline). The clearer the conversation and the more each person speaks, the more accurate the separation; single-speaker or very short recordings will naturally yield just one speaker.
- Word-level timestamps are built in: the model's own timestamp head marks the start and end time of each character or word, returned along with the transcription request (useful for subtitles, word-level seeking and playback alignment). The recognized text still comes from the main transcription, with timestamps aligned to it; boundaries may be slightly off for unusual accents or extremely short audio.
- Automatic punctuation is still on the way: automatic sentence segmentation and punctuation will be enabled in a later version; this version focuses on getting high-quality transcription, speaker diarization and word-level timestamps solid first.
5. How to download and use it
This model is packaged for
42model, which is the recommended way to get it:
Desktop app: open Model Library → Smart Transcription, download FireRedASR2-AED, then click Start to turn recordings into text.
Files and license
| File | Role |
|---|
encoder.int8.onnx | Encoder (turns audio into an internal representation) |
decoder.int8.onnx | Decoder (writes out the text token by token) |
ctc.int8.onnx | Timestamp head (marks start/end times per character or word · word-level timestamps enabled) |
tokens.txt | Token vocabulary |
cmvn.ark | Feature normalization statistics |
Per-file sha256 values are on the repository Files page and can be verified independently. The table above covers this repo (the speech recognition model itself); speaker diarization uses a separate set of open-source models (segmentation + speaker embedding + clustering), which the 42model engine fetches alongside this model into the same folder — nothing for you to prepare manually.
License: the model itself is FireRedASR2-AED, © Xiaohongshu FireRedTeam,
Apache-2.0 (official sources:
GitHub ·
ModelScope ·
paper). The int8 ONNX conversion was done by
ManySpeech / manyeyes. This repo redistributes that local build and is likewise governed by
Apache-2.0. By using it you agree to the upstream license terms.
Citation
For the model itself, please cite upstream FireRedTeam:
1@article{xu2026fireredasr2s,
2 title={FireRedASR2S: A State-of-the-Art Industrial-Grade All-in-One Automatic Speech Recognition System},
3 author={Xu, Kaituo and Jia, Yan and Huang, Kai and Chen, Junjie and Li, Wenpeng and Liu, Kun and Xie, Feng-Long and Tang, Xu and Hu, Yao},
4 journal={arXiv preprint arXiv:2603.10420},
5 year={2026}
6}
For the int8 ONNX conversion, see
ManySpeech. If
this repo's local deployment packaging was useful to you, you may additionally cite:
1@misc{yang2026fireredasr2aedonnx,
2 title = {FireRedASR2-AED-ONNX: A Local On-Device Build of FireRedTeam's FireRedASR2-AED},
3 author = {Yang, Zhiping},
4 year = {2026},
5 howpublished = {\url{https://huggingface.co/42ailab/FireRedASR2-AED-ONNX}},
6 organization = {42ailab},
7 note = {Local deployment packaging and quality verification; the model itself is FireRedTeam's FireRedASR2-AED (Apache-2.0), int8 ONNX conversion from ManySpeech. Contact: contact@42ailab.com}
8}
About us
42ailab — an AI research lab exploring the boundaries of intelligence. Grounded in cognitive science, we work toward a deep integration of AI and human intelligence — to truly understand and augment intelligence, carbon-based and silicon-based alike.
42model — a high-performance local inference engine from 42ailab that runs translation, transcription, recognition, chat and coding on your own machine, free and private; with optional cloud compute for fine-tuning your own models and bringing them back to run locally.
