Arabic LLM Leaderboard - Broad (ABL)

Arabic LLM Leaderboard - Broad (ABL)

Ranks language models on an Arabic benchmark in a Gradio leaderboard, with code you can adapt to host your own board. Suits Arabic NLP researchers and teams comparing models.

Made by silma-ai on Hugging Face. These notes are Mindket's, written from its Space page and README; the app's own files and license are on Hugging Face.

About

What it is: This Space is a leaderboard for large language models on Arabic. It reads results files for each model and shows them in one table, and its dataset is the silma-ai arabic-broad-benchmark. The repository is also a template for running a leaderboard, with files for the table, for reading results and for handling submissions.

Who it suits: It suits people who build or choose language models for Arabic, and developers who want to host a leaderboard of their own.

Industry | Who uses it | How they use it | Example
Research | Arabic NLP researchers | Compare models on one Arabic benchmark | Read the table to see how a model ranks
Model development | Teams releasing Arabic models | Check where their model stands against others | Look up their model's results row
Product teams | Engineers choosing a model | Shortlist models for Arabic use cases | Compare two candidates in the table
Software | Developers | Reuse the code to host their own leaderboard | Change the path and tasks, then add results files

Skip it if you need to test a model yourself, since the board shows results files and does not run the benchmark for you.

Where to use it:

• A browser: open the Space's page on Hugging Face, with nothing to install
• A copy on Windows, macOS or Linux, using Python

Use case | Who | What they get back
Reading the rankings | Researchers | A table of models and their scores
Checking one model | Model teams | The results row for that model
Building a board | Developers | A working leaderboard layout to adapt

How to set it up: The online copy needs nothing. For a copy on your own computer, you need the following.

• Python with pip on Windows, macOS or Linux
• The Hugging Face hub client, which the first step installs
• The packages listed in requirements.txt

1. Install the Hugging Face hub client.
2. Download the Space's files into a local folder.
3. Move into that folder.
4. Install the Gradio version the Space pins.
5. Install the remaining packages from requirements.txt.
6. Start app.py.

pip install -U huggingface_hub
hf download silma-ai/Arabic-LLM-Leaderboard --repo-type space --local-dir Arabic-LLM-Leaderboard
cd Arabic-LLM-Leaderboard
pip install gradio==5.29.0
pip install -r requirements.txt
python app.py

To run a board of your own, change the path in src/env.py and the tasks in src/about.py. Each results file is a JSON file in this shape.

{
    "config": {
        "model_dtype": "torch.float16", # or torch.bfloat16 or 8bit or 4bit
        "model_name": "path of the model on the hub: org/model",
        "model_sha": "revision on the hub",
    },
    "results": {
        "task_name": {
            "metric_name": score,
        },
        "task_name2": {
            "metric_name": score,
        }
    }
}

How to use it: Online, open the Space's page and read the table. To run a copy, start it with the command below. Request files are created by the tool itself, so you do not write them.

python app.py

Tool | What it does
src/env.py | Holds most of the variables you change for a default leaderboard, including its path
src/about.py | Defines the tasks the board covers
src/display/utils.py | Sets the main table's column names and properties
src/leaderboard/read_evals.py | Reads results and request files and turns them into table rows
src/submission/submit.py | Handles submissions, with check_validity.py filtering them

Example: A team wants a board for its own models. It sets the path in src/env.py, lists its tasks in src/about.py, adds one results file per model, and starts the app. The table then shows each model's scores.

For newcomers and experts: If you are new, open the Space online and read the table first. Each row is one model, and its scores come from the results files behind it.

If you know the field, the layout follows the common Hugging Face leaderboard template. Results and request files are read into dataframe rows by the code in read_evals.py and populate.py, and submissions pass through validity checks first. If the Space misbehaves, restarting it clears the eval-queue and eval-results folders it created.

Results files are added for each model
The code reads them into table rows
The Gradio app shows the ranked table
Submissions are checked before they enter

Good to know: The source is a template-style README, so the benchmark's tasks and scoring are not described here.

• License: apache-2, as listed on Hugging Face
• Cost to run: no API key or paid service is named, and the online copy runs on cpu-basic hardware
• Data it reaches: the results and request files in the repository, and the benchmark dataset the Space names on Hugging Face
• Not for: the source lists no exclusions, and the board reports results rather than running the benchmark for you

On Hugging Face, 13 November 2026

• Likes: 58
• Built with: gradio
• License: apache-2.0

Links

• Space: https://huggingface.co/spaces/silma-ai/Arabic-LLM-Leaderboard
• Files: https://huggingface.co/spaces/silma-ai/Arabic-LLM-Leaderboard/tree/main

Try it

Open the Space in your browser, or copy it to your own Hugging Face account from its page. Nothing in this kit runs by itself.