Jais-ASR-MLX-4bit

This repository contains the 4-bit MLX version of IFM/Jais-ASR for Apple silicon, for use with mlx-vlm. The 8-bit version is IFM/Jais-ASR-MLX-8bit; see the table below. For NVIDIA or AMD GPUs, use IFM/Jais-ASR-GGUF. The Quickstart further down applies to the original model.

Compatibility: requires mlx-vlm at commit 6ecadd7 with mlx-vlm-jais-asr.patch from this repository, and PyTorch (used by the audio processor).

# 1. Install mlx-vlm with Jais-ASR support (once)
git clone https://github.com/Blaizzy/mlx-vlm.git && cd mlx-vlm
git checkout 6ecadd767ca1c7c54763289c750dd180d7945037
# Recommended: use a dedicated environment (Python 3.10+).
# Skip the next line if you already activated one with conda, uv, pyenv, etc.
python3 -m venv .venv && source .venv/bin/activate
pip install -e . torch
hf download IFM/Jais-ASR-MLX-4bit mlx-vlm-jais-asr.patch --local-dir . && git apply mlx-vlm-jais-asr.patch && cd ..

# 2. Transcribe (the model downloads on first use)
mlx_vlm.generate --model IFM/Jais-ASR-MLX-4bit --trust-remote-code --audio speech.wav --prompt "" \
  --temperature 0 --repetition-penalty 1.05 --max-tokens 256

# 3. Optional: set the language in advance (ar, msa, EG, MA, ...; see Language and Dialect Settings)
mlx_vlm.generate --model IFM/Jais-ASR-MLX-4bit --trust-remote-code --audio speech.wav --prompt "" \
  --temperature 0 --repetition-penalty 1.05 --max-tokens 256 --language EG

MLX Configurations

Configuration	Repository	Text decoder	Audio encoder	WER %	CER %	Size (GB)
Original model (BF16)	IFM/Jais-ASR	BF16	BF16	22.85	8.37	11.46
8-bit	IFM/Jais-ASR-MLX-8bit	8-bit (same values as Jais-ASR-Q8_0.gguf)	BF16	22.76	8.30	7.03
4-bit GPTQ	IFM/Jais-ASR-MLX-4bit	4-bit GPTQ (same values as Jais-ASR-Q4_K_S.gguf)	BF16	22.94	8.34	4.50

WER / CER (%) are averaged over the six test sets, evaluated with mlx-vlm (greedy decoding, repetition penalty 1.05, code_switch=False, at most 256 generated tokens); lower is better. The original model row reports its published scores. Size is the total download size of each repository.

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.

		Open-weight models						Closed models
	Jais-ASR	Audar-ASR-V1-Turbo	cohere-transcribe-arabic-07-2026	omniASR-LLM-7B	Qwen3-Omni-30B-A3B	Qwen3-ASR-1.7B	Voxtral-Small-24B	Melia 1 Speechmatics	Scribe v2 ElevenLabs
Word error rate (WER, %) ↓
Average Macro-average, six test sets	22.85	23.17	25.87	28.32	30.71	33.36	34.47	23.51	24.54
SADA Saudi dialectal broadcast	30.85	28.92	37.47	41.61	44.82	45.53	50.82	34.74	33.96
Common Voice 18 MSA read speech	8.56	8.09	5.82	8.75	11.46	16.90	15.25	5.19	8.71
MASC clean MSA lectures, clean	16.12	16.73	19.60	19.69	21.47	24.37	23.96	16.23	16.91
MASC noisy MSA lectures, noisy	25.44	27.19	27.07	29.29	30.85	34.29	34.43	25.89	27.15
MGB-2 MSA broadcast news	9.59	11.08	15.54	14.13	13.09	16.57	16.03	12.61	10.30
Casablanca 8 dialects, conversational	46.56	47.02	49.71	56.46	62.55	64.47	66.30	46.41	50.20
Character error rate (CER, %) ↓
Average Macro-average, six test sets	8.37	9.23	11.80	12.52	13.67	12.33	15.29	10.62	9.96
SADA Saudi dialectal broadcast	14.33	13.40	23.53	24.95	26.11	19.90	28.85	21.21	16.48
Common Voice 18 MSA read speech	2.70	2.46	1.62	2.71	4.28	5.06	5.54	1.62	3.00
MASC clean MSA lectures, clean	3.76	5.32	6.45	5.76	5.59	5.72	7.06	5.11	4.97
MASC noisy MSA lectures, noisy	7.51	9.78	10.13	10.66	11.28	10.84	12.22	9.47	9.36
MGB-2 MSA broadcast news	3.92	5.64	8.40	7.10	6.20	6.25	7.41	5.88	4.78
Casablanca 8 dialects, conversational	18.02	18.75	20.66	23.96	28.53	26.23	30.64	20.41	21.18

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.

Language	Setting
Arabic, including all supported dialects	ar
Modern Standard Arabic	msa
English	en
French	fr
Spanish	es
Italian	it

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.

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},
}