---

license: apache-2.0

base_model:

- Qwen/Qwen3-ForcedAligner-0.6B

base_model_relation: quantized

pipeline_tag: automatic-speech-recognition

library_name: gguf

language:

- zh

- en

tags:

- forced-alignment

- word-timestamps

- asr

- qwen3

- gguf

- 42model

---

<!--

README for the Hugging Face repo 42ailab/Qwen3-ForcedAligner-0.6B-GGUF, uploaded with the package by

scripts/publish-forcedaligner.sh. Editing this file changes the repo landing page.

-->

Qwen3-ForcedAligner-0.6B · Fully Local Word-Level Timestamps





English | 简体中文 · Also on ModelScope · 42ailab.com

Give it an audio clip and its transcript, and this model marks which second every character or word was spoken at (to 80-millisecond precision) — entirely on your own computer. No cloud, free, private.

> The model was built by Alibaba's Qwen team and released under Apache-2.0 (Qwen3-ForcedAligner, part of the Qwen3-ASR family). This repo is not a new model — we converted it into a GGUF build that runs offline on your computer. It is an enhancement model and does not transcribe on its own: transcription is still done by Qwen3-ASR, and this model adds precise word-level timing on top.

1. The problem it solves

Speech recognition (ASR) tells you what was said, but usually not which second each word was said at. Many use cases depend precisely on that timing:

• Generating subtitles: SRT / VTT subtitles need each line aligned to exact start and end times;
• Audio/video editing and search: jump to the audio position for a piece of text, or cut a specific sentence precisely;
• Accessibility and learning: word-by-word highlighting for read-along and listen-and-read study.

Getting accurate word-level timing used to depend on a cloud service — uploading your audio to someone else's server, with the privacy concerns and possible costs that entails. This model keeps that step entirely local.

2. How it works

• Input "audio + transcript", output the start and end time of every character or word (at 80-millisecond frame granularity).
• It carries its own audio encoder, so it does not care which ASR you use — download it once and pair it with any Qwen3-ASR (0.6B / 1.7B alike), instead of storing separate alignment weights per size.
• A single forward pass suffices (non-autoregressive), which makes it fast; it runs locally across macOS / Windows / Linux.

3. How well it performs

On an Apple M3 Max, using a Chinese multi-speaker meeting recording (55 seconds / ~150 words / 300 word-level time points), compared point by point against the ground truth from the reference implementation (PyTorch, full precision):

| Metric | Result |

|---|---|

| Time points exactly matching the reference | 84.3% |

| Within ±1 frame (80 ms) of the reference | 98.7% |

| Tokenization exactly aligned with the reference | 100% |

| Processing speed (RTF) | 0.0063 (55 s of audio in about 300 ms) |

The remaining differences come from numerical differences between local half precision and the reference's full precision, not from alignment errors — 84% exact matches rules out systematic drift, 98.7% within one frame rules out path errors, and 100% tokenization alignment rules out misplaced boundaries.

4. Limitations and what's next

• Requires a transcription model: this model only adds timestamps and does not transcribe; use it together with Qwen3-ASR.
• Language support: Chinese and space-delimited languages (English and others) are verified; Japanese / Korean need dedicated tokenizers, so for now the model degrades automatically and emits no word-level timestamps for them (we would rather withhold them than give you wrong ones); support will come in a later version.
• Next: broaden language coverage and keep improving numerical consistency.

5. How to download and use it

This model is packaged for 42model, which is the recommended way to get it:

Desktop app

1. Download Qwen3-ForcedAligner from the Model Library;
2. In the parameter settings of whichever Qwen3-ASR transcription model you use, turn on Word-level timestamps.

Transcription will then emit start and end times for every character or word.

Files and license

| File | Role |

|---|---|

| aligner-backbone-f16.gguf | Alignment backbone |

| aligner-mmproj-f16.gguf | Audio encoder |

| aligner-head.bin | Word-level classification head |

Per-file sha256 values are in the bundled manifest.json and on the Files page, and can be verified independently.

License: the model itself is Qwen3-ForcedAligner-0.6B, © Alibaba Qwen team, Apache-2.0 (official sources: Hugging Face · ModelScope · technical report). This repo is a GGUF build converted from it 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 the upstream Alibaba Qwen team (the Qwen3-ASR technical report):

@article{Qwen3-ASR,
  title   = {Qwen3-ASR Technical Report},
  author  = {Xian Shi and Xiong Wang and Zhifang Guo and Yongqi Wang and Pei Zhang and Xinyu Zhang and Zishan Guo and Hongkun Hao and Yu Xi and Baosong Yang and Jin Xu and Jingren Zhou and Junyang Lin},
  journal = {arXiv preprint arXiv:2601.21337},
  year    = {2026}
}

If this repo's GGUF build was useful to you, you may additionally cite:

@misc{yang2026qwen3forcedalignergguf,
  title        = {Qwen3-ForcedAligner-0.6B-GGUF: A Local Build of Qwen's Qwen3-ForcedAligner},
  author       = {Yang, Zhiping},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/42ailab/Qwen3-ForcedAligner-0.6B-GGUF}},
  organization = {42ailab},
  note         = {GGUF conversion and local deployment packaging; the model itself is Alibaba Qwen team's Qwen3-ForcedAligner (Apache-2.0). Contact: contact@42ailab.com}
}

Contact us: contact@42ailab.com

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.