Jais-ASR-GGUF

[!NOTE] This repository contains GGUF versions of IFM/Jais-ASR for use with llama.cpp. Each configuration uses two files: a text decoder (Jais-ASR-*.gguf) and an audio encoder (mmproj-Jais-ASR-*.gguf); choose one in the table below. The Quickstart further down applies to the original model.

Compatibility: requires the MBZUAI-IFM fork of llama.cpp with llama.cpp-jais-asr.patch from this repository.

# 1. Build llama.cpp with Jais-ASR support (once)
git clone -b model/K2Horizon https://github.com/MBZUAI-IFM/llama.cpp.git && cd llama.cpp
git checkout 35999d101cf2233fc54f09c3c8d599da7303ce02
hf download IFM/Jais-ASR-GGUF llama.cpp-jais-asr.patch --local-dir . && git apply llama.cpp-jais-asr.patch
cmake -B build -DGGML_CUDA=ON && cmake --build build -j   # AMD: -DGGML_HIP=ON, CPU: no flag

# 2. Download one configuration (here 4-bit Medium)
hf download IFM/Jais-ASR-GGUF Jais-ASR-Q4_K_M.gguf mmproj-Jais-ASR-Q6_K.gguf --local-dir .

# 3. Start the server, wait until it is ready, then transcribe (add -F language=EG to pin the language or dialect)
./build/bin/llama-server -m Jais-ASR-Q4_K_M.gguf --mmproj mmproj-Jais-ASR-Q6_K.gguf --port 8080 &
until curl -s localhost:8080/health | grep -q ok; do sleep 1; done
curl localhost:8080/v1/audio/transcriptions -F file=@speech.wav

Quantized Configurations

WER / CER (%) are averaged over the six test sets, evaluated with llama.cpp (greedy decoding, code_switch=False, at most 256 generated tokens); lower is better. Size is the download size of both files (text decoder and audio encoder). GPU memory is the peak on one GPU.

The 8-bit configuration matches the original model's accuracy on the leaderboard (22.83% vs. 22.85% WER) while using about 39% less GPU memory.

Jais-ASR is IFM's state-of-the-art speech recognition model for Arabic as it is spoken: Modern Standard Arabic and dialects from 19 Arab countries, with natural code-switching into English, French, Spanish, and Italian. Based on Jais-3-4B, it adds optional diacritization, built-in language and dialect identification, and an explicit signal when there is no speech to transcribe. The weights are released under Apache 2.0 with a vLLM plugin, and quantized versions are available in the Jais Speech collection.

Jais-ASR Highlights

• Leading performance in Arabic ASR. Jais-ASR has the lowest average error rates on the Open Universal Arabic ASR Leaderboard, 22.85% WER and 8.37% CER, ahead of every open-weight model compared and the commercial APIs from Speechmatics and ElevenLabs. See Benchmark Results.
• Built for Arabic as it is spoken in real life. MSA and dialects across 19 countries, natural code-switching with English, French, Spanish, and Italian, and robust transcription in noisy, real-world recordings.
• Accurate and faithful. Optional diacritization, built-in language and dialect identification, and transcripts designed to avoid memorized boilerplate, repetition loops, and translating speech instead of transcribing it. When there is no speech, the model says so instead of inventing text.
• Ready for production. Run it with Transformers, or serve it with the included vLLM plugin behind an OpenAI-compatible /v1/audio/transcriptions endpoint. The bf16 weights are 11.4 GB.

Benchmark Results

The Open Universal Arabic ASR Leaderboard covers six public test sets spanning read speech, broadcast media, and conversational dialects, in clean and noisy conditions. Evaluated with the leaderboard's own protocol, Jais-ASR leads on both average metrics.

Error rates in %; lower is better. Average is the macro-average over the six test sets. Jais-ASR was measured with the leaderboard's evaluation script. Scores for the other open-weight models are taken from the leaderboard; Speechmatics Melia 1 and ElevenLabs Scribe v2 were measured by IFM.

Capabilities

Jais-ASR brings Arabic speech transcription, code-switching, diacritization, and language identification into one model, with controls to tailor the output to your application.

• Transcribe multilingual speech as spoken. Enable code_switch=True to keep English, French, Spanish, or Italian spans in their original script alongside Arabic, useful for interviews and everyday conversations.
• Add diacritics for clearer Arabic pronunciation. Enable diacritics=True to add vowel marks to Arabic transcripts, making them easier to read and supporting language learning. Diacritics and code-switching can be enabled together.
• Detect the language and dialect as you transcribe. Each transcript comes with its recognized language or dialect label, so you can organize recordings and route text to downstream tools without a separate identification model.
• Handle non-speech audio explicitly. When audio contains no speech (e.g., music or noise), the model returns [IFM-NoTranscript] with the flag refused=True instead of hallucinated content, giving applications a clear signal to handle the case separately.
• Process multiple recordings at once. Batch transcription supports files with different durations and sample rates.

Language and Dialect Settings

Automatic language and dialect detection is enabled by default. If the language of the audio is known in advance, set it with one of the codes below: ar allows Modern Standard Arabic and all 19 supported dialects, msa selects Modern Standard Arabic, and a dialect code such as EG selects that dialect.

The 19 Arabic dialect codes are:

Algerian (DZ) · Bahraini (BH) · Egyptian (EG) · Emirati (AE) · Iraqi (IQ) · Jordanian (JO) · Kuwaiti (KW) · Lebanese (LB) · Libyan (LY) · Mauritanian (MR) · Moroccan (MA) · Omani (OM) · Palestinian (PS) · Qatari (QA) · Saudi (SA) · Sudanese (SD) · Syrian (SY) · Tunisian (TN) · Yemeni (YE)

Quickstart

Install PyTorch for your hardware, then install the inference dependencies:

pip install 'transformers==5.16.1' accelerate soundfile soxr

The examples below use a GPU with bfloat16 support. The bf16 weights are 11.4 GB; plan on roughly 12 GB of GPU memory.

Transformers Pipeline

import torch
from transformers import pipeline

asr = pipeline(
    "automatic-speech-recognition",
    model="IFM/Jais-ASR",
    trust_remote_code=True,
    device_map="auto",
    dtype=torch.bfloat16,
)
result = asr("speech.wav", max_new_tokens=256)
print(result["text"])

The pipeline accepts an audio file path or a waveform dictionary such as {"array": waveform, "sampling_rate": 16000}. For batches and structured metadata, use the model and processor directly as shown below.

Batch Transcription

This example transcribes two files together, including clips with different durations or sample rates.

import soundfile as sf
import torch
from transformers import AutoModelForCausalLM, AutoProcessor

model_id = "IFM/Jais-ASR"
processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
processor.tokenizer.padding_side = "left"
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    trust_remote_code=True,
    device_map="auto",
    dtype=torch.bfloat16,
).eval()

paths = ["speech_1.wav", "speech_2.wav"]
audio = [sf.read(path, dtype="float32") for path in paths]
waveforms = [waveform for waveform, _ in audio]
sample_rates = [sample_rate for _, sample_rate in audio]

prompt = processor.tokenizer.apply_chat_template(
    [{"role": "user", "content": [{"type": "audio"}]}],
    tokenize=False,
    add_generation_prompt=True,
    # diacritics=True,   # Add Arabic vowel marks.
    # code_switch=True,  # Keep other languages in their original script.
)
inputs = processor(
    text=[prompt] * len(waveforms),
    audio=waveforms,
    sampling_rate=sample_rates,
    padding=True,
    return_tensors="pt",
).to(model.device)

with torch.inference_mode():
    output = model.generate(
        **inputs,
        do_sample=False,
        max_new_tokens=256,
        # language="EG",  # Set the target language to override automatic detection.
    )

transcripts = processor.post_process_transcription(
    output, input_lengths=inputs["input_ids"].shape[1],
)
for path, result in zip(paths, transcripts):
    print(path, {
        "text": result.text,
        "language": result.language,
        "refused": result.refused,
    })

language contains a language or dialect label, such as msa, EG, or en. When the model emits [IFM-NoTranscript], postprocessing sets refused=True and returns an empty transcript. Uncomment either prompt option above to request diacritics or code-switching; both can be enabled together.

[!TIP] Pass each recording's original sample rate; the processor resamples it to 16 kHz automatically. Increase max_new_tokens for longer recordings: a result with truncated=True means generation ended before the transcript was complete.

Serving with vLLM

Jais-ASR ships with a vLLM plugin in vllm_plugin/. Install it in its own environment, then start the server:

pip install 'vllm==0.23.0' 'transformers==5.5.4' accelerate soundfile soxr
hf download IFM/Jais-ASR --include "vllm_plugin/*" --local-dir Jais-ASR
pip install ./Jais-ASR/vllm_plugin
vllm serve IFM/Jais-ASR --trust-remote-code --reasoning-parser jais_asr_tag --max-model-len 2048

Transcribe a file through the OpenAI-compatible endpoint:

curl http://localhost:8000/v1/audio/transcriptions \
  -F file=@clip.wav \
  -F model=IFM/Jais-ASR

Citation

@misc{jaisasr2026,
  title  = {Introducing Jais-ASR: Arabic Speech Recognition for Every Dialect},
  author = {{IFM Team}},
  year   = {2026},
  url    = {https://huggingface.co/IFM/Jais-ASR},
}