Haas-ja-v1.0 GGUF for speech.cpp

These files run only in speech.cpp 0.9.4 or later. Their layout is speech.cpp's own, so llama.cpp, LM Studio, Ollama and other programs that read GGUF cannot run them. speech.cpp 0.9.3 fetches the files of revision 3168c92 of this repository, which hold the same weights without the settings of the custom vocabulary.

It holds Third Intelligence's Haas-ja-v1.0, a FastConformer recognizer of Japanese whose TDT decoder's prediction network is made of Kimi Delta Attention layers, in one file, and decodes greedily as NeMo does by default. It runs on macOS with Metal, on Windows and Linux with Vulkan, and on the CPU alone, where the official code needs an NVIDIA GPU.

Use

Install speech.cpp (install), then:

speech asr haas-ja-v1.0 utterance.wav
speech asr haas-ja-v1.0 --timestamps utterance.wav
speech asr haas-ja-v1.0 --vad silero-vad meeting.wav
speech asr haas-ja-v1.0 --keywords $'Haas=ハース\nAIモデル' utterance.wav
speech serve haas-ja-v1.0 --open

haas-ja-v1.0 is the name speech.cpp gives this model; speech fetches the Q8_0 file from this repository the first time, and haas-ja-v1.0:q4_k or another type of the table below fetches that type instead. A path to a downloaded file works as well. A recording longer than about 30 seconds is best recognized by the regions where someone speaks, with --vad silero-vad. The options, the worker and the HTTP API are in speech.cpp's documentation: FastConformer, command line and server.

A custom vocabulary

--keywords gives Haas-ASR's custom vocabulary, the words or phrases to recognize more often, one a line, each its written form followed by = and its readings separated by commas where it is read otherwise (Third Intelligence=サードインテリジェンス). As Haas-ASR does, speech.cpp boosts the keywords' readings while decoding, keeps a change only where it holds a whole keyword (--keywords-guard=false keeps every change) and writes each keyword found in its written form. --keywords-alpha sets how strongly the keywords are boosted, 2 by default. The worker takes them as keywords, keywords_alpha and keywords_guard, and the HTTP server takes OpenAI's keywords, a string a keyword, in a transcription and a Realtime session. A recognition with keywords decodes twice and gives the text alone, without times, so it takes no --timestamps. speech.cpp 0.9.4 names the three options words, words_alpha and words_guard; 0.10.0 and later name them as above.

Files

File	Contents	Size	speech.cpp from	SHA-256
`Haas-616M-ja-v1.0-F16.gguf`	the frontend, the encoder, the prediction network, the joint and the vocabulary; the matrices of the linear layers and the token embedding in F16	1.23 GB (1,233,128,832 bytes)	0.9.4	`f752e02f68c1dfff795900e40aa82e5302976fb5360080fcbd330d8b3c992cd8`
`Haas-616M-ja-v1.0-Q8_0.gguf` (the file the name fetches)	the frontend, the encoder, the prediction network, the joint and the vocabulary; the matrices of the linear layers and the token embedding in Q8_0	0.66 GB (656,381,472 bytes)	0.9.4	`cd5f60b2f1c411404b83fca4a65e3ce30a26d9e951b6a346529e65f22758afeb`
`Haas-616M-ja-v1.0-Q6_K.gguf`	the frontend, the encoder, the prediction network, the joint and the vocabulary; the matrices of the linear layers and the token embedding in Q6_K	0.51 GB (508,898,848 bytes)	0.9.4	`19b33195b691abda293648a02702086754e1392728871d0dafcd3d50682f5dc3`
`Haas-616M-ja-v1.0-Q5_K.gguf`	the frontend, the encoder, the prediction network, the joint and the vocabulary; the matrices of the linear layers and the token embedding in Q5_K	0.43 GB (428,021,280 bytes)	0.9.4	`880ee2d3068b98834d88cff5794442a7f36f1808a6b365a5f6188a060b689658`
`Haas-616M-ja-v1.0-Q4_K.gguf`	the frontend, the encoder, the prediction network, the joint and the vocabulary; the matrices of the linear layers and the token embedding in Q4_K	0.35 GB (351,901,216 bytes)	0.9.4	`d24d53f29b75214a933ff482b0de1217e0a800f4118cca39ad6cf03609a89d6f`
`Haas-616M-ja-v1.0-F16.gguf.json`	the output of `speech info --json` for the F16 file	1061 bytes		`4234aee7ceac3d59c8dc7cc788ce537c52117d6ab291cac9020004e32c44b4b1`
`Haas-616M-ja-v1.0-Q8_0.gguf.json`	the output of `speech info --json` for the Q8_0 file	1059 bytes		`58813b7e4d7c3ad66287d3aaedf329181b630f8dd4f7706445d0f196eef6ed97`
`Haas-616M-ja-v1.0-Q6_K.gguf.json`	the output of `speech info --json` for the Q6_K file	1059 bytes		`d08c7edadeb8da68eacd06b58b2b9d6fb196f6c4ffbafed441a6fb7276183480`
`Haas-616M-ja-v1.0-Q5_K.gguf.json`	the output of `speech info --json` for the Q5_K file	1059 bytes		`c2bd879806e48d10592484d84f3d5beba1883f3bcb31878ca52d24c5a0e776ea`
`Haas-616M-ja-v1.0-Q4_K.gguf.json`	the output of `speech info --json` for the Q4_K file	1059 bytes		`c5a8c040b78d05b58b7bb835bb2ca19649c7a191da17fa8ffefe02fe6b492964`
`LICENSE`	the Apache License 2.0, Haas-ja-v1.0's	11,358 bytes		`cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30`

In the Q6_K, Q5_K and Q4_K files the prediction network's and the joint's matrices, whose rows of 64 and 640 values are not whole blocks of 256, are Q8_0. A request needs the GGUF file alone; the JSON file lets a program show the model or choose a file without downloading it.

Language

The model recognizes Japanese (ja). A request's language is only checked against it. A rare character its vocabulary lacks is written from its UTF-8 bytes, as its tokenizer does.

Accuracy

Every stage is checked against the official code, NeMo 2.7.3 with Haas-ASR, whose prediction network runs flash-linear-attention's kernels on a CUDA GPU, on 5 utterances of FLEURS' ja_jp test split, 6 to 26 s, two of them with characters written from their bytes: the CPU in F32 and F16 and Metal on an Apple M5 give its text, the frames and durations of its tokens and its segments on all five. With a custom vocabulary, 11 utterances of the same split with each of 5 vocabularies give NeMo's tokens without and with the words and Haas-ASR's text, on the CPU in F32, Metal in F32 and F16 on the M5, and Vulkan in F16 on an RTX 2080.

Each type, measured by speech-bench on 2026-10-31 on an Apple M5 with Metal and an RTX 2080 with Vulkan, on the 650 utterances of FLEURS' Japanese test split, which the upstream card says the model was not trained on, trimmed to the voice. The CER is the M5's, and the RTX 2080's is within 0.05 points of it. The memory is the peak memory footprint of speech for one request on the M5, whose GPU shares it, and the VRAM the video memory in use on the RTX 2080.

Type	Size	Memory, M5	VRAM, RTX 2080	CER	CER, other spellings accepted
F16	1.23 GB	1.29 GiB	1.32 GiB	4.40%	2.87%
Q8_0	0.66 GB	0.74 GiB	0.78 GiB	4.39%	2.86%
Q6_K	0.51 GB	0.61 GiB	0.65 GiB	4.35%	2.83%
Q5_K	0.43 GB	0.53 GiB	0.58 GiB	4.47%	2.87%
Q4_K	0.35 GB	0.46 GiB	0.50 GiB	4.42%	2.84%

On the same utterances on 2026-10-30, in Q8_0, parakeet-tdt_ctc-0.6b-ja gives 5.00% (2.82%) and reazonspeech-nemo-v2 7.95% (5.70%).

Speed

speech-bench on 2026-10-31, the same 650 utterances, Q8_0, one request at a time.

Device	Median	p90	RTFx
Apple M5, Metal	0.042 s	0.063 s	205
RTX 2080, Vulkan	0.097 s	0.130 s	98

On the RTX 2080 the F16 file, which decodes on the GPU by default, took about as long as the Q8_0 file, which decodes on the CPU: a median of 0.090 s and RTFx 98. decode_on_cpu sets where a request decodes.

Source

Converted by speech.cpp's reference/fastconformer/convert.py Haas-ja-v1.0, whose environment reference/fastconformer/haas pins Haas-ASR at e72638b6e352010c800ffd550af3a51b29e3dbb1 with NeMo 2.7.3 and flash-linear-attention 0.5.2, from third-intelligence/Haas-ja-v1.0 at 660728d39019e5e065046154beca44ac9a66a540, to F32, from which speech quantize --type <type> wrote each file. Every constant the C++ reads is in the file, from the checkpoint or, where it has none, from the official code. speech.cpp also runs NVIDIA's parakeet-tdt_ctc-0.6b-ja and parakeet-tdt-0.6b-v3 and reazon-research's reazonspeech-nemo-v2 through the same port.

Thanks

Thanks to Third Intelligence for releasing Haas-ja-v1.0 openly, and to ほーりーふぉっくす (@Holy_fox_LLM), who first ran it on Mac and Windows in a fork of speech.cpp.

License

Haas-ja-v1.0 is released by Third Intelligence under the Apache License 2.0 (LICENSE).

Haas-ja-v1.0-GGUF