Datasets:

omneity-labs
/

lid-benchmark

@@ -63,7 +63,7 @@ summary = load_dataset("omneity-labs/lid-benchmark", "results_summary", split="t
 |-------|:-:|:-:|:-:|:-:|
 | **GlotLID** | **0.9253** | 0.5648 | 0.7772 | 0.4977 |
 | OpenLID v2 | 0.8748 | 0.6262 | 0.7762 | 0.5735 |
-| OpenLID v3 | 0.8556 | — | 0.6619 | — |
 | **Gherbal v4** | 0.8500 | **0.6298** | **0.8699** | **0.6909** |
 | OpenLID v1 | 0.8425 | 0.5587 | 0.8296 | 0.4845 |
 | NLLB-LID | 0.8331 | 0.1052 | 0.7522 | 0.3348 |
@@ -197,7 +197,7 @@ print(comparison.round(4))
 | [NLLB-LID](https://huggingface.co/facebook/fasttext-language-identification) | FastText | 218 | Meta |
 | [OpenLID v1](https://huggingface.co/laurievb/OpenLID) | FastText | 201 | Laurie Burchell |
 | [OpenLID v2](https://huggingface.co/laurievb/OpenLID) | FastText | 201 | Laurie Burchell |
-| [OpenLID v3](https://huggingface.co/laurievb/OpenLID) | FastText | 201 | Laurie Burchell |
 | [FastLID-176](https://fasttext.cc/docs/en/language-identification.html) | FastText | 176 | Meta |
 ## Benchmarks

 |-------|:-:|:-:|:-:|:-:|
 | **GlotLID** | **0.9253** | 0.5648 | 0.7772 | 0.4977 |
 | OpenLID v2 | 0.8748 | 0.6262 | 0.7762 | 0.5735 |
+| OpenLID v3 (HPLT-LID) | 0.8556 | — | 0.6619 | — |
 | **Gherbal v4** | 0.8500 | **0.6298** | **0.8699** | **0.6909** |
 | OpenLID v1 | 0.8425 | 0.5587 | 0.8296 | 0.4845 |
 | NLLB-LID | 0.8331 | 0.1052 | 0.7522 | 0.3348 |
 | [NLLB-LID](https://huggingface.co/facebook/fasttext-language-identification) | FastText | 218 | Meta |
 | [OpenLID v1](https://huggingface.co/laurievb/OpenLID) | FastText | 201 | Laurie Burchell |
 | [OpenLID v2](https://huggingface.co/laurievb/OpenLID) | FastText | 201 | Laurie Burchell |
+| [OpenLID v3 (HPLT-LID)](https://huggingface.co/HPLT/hplt_lid_fl) | FastText | 201 | HPLT |
 | [FastLID-176](https://fasttext.cc/docs/en/language-identification.html) | FastText | 176 | Meta |
 ## Benchmarks

space/app.py CHANGED Viewed

@@ -2,476 +2,678 @@
 LID Benchmark — Language Identification Leaderboard
 Built by Omneity Labs · https://www.omneitylabs.com
 """
 import gradio as gr
 import pandas as pd
 import plotly.graph_objects as go
 from datasets import load_dataset
-# ── Brand colors (Omneity gold palette) ──────────────────────────────────────
-GOLD = "#C4962C"
-GOLD_LIGHT = "#E8C96A"
-GOLD_BG = "#FDF8ED"
-DARK = "#2A2520"
-MUTED = "#8A8078"
-TEAL = "#4A8C7A"
-NAVY = "#3A5A8C"
-WARM_ORANGE = "#C47A2C"
-TERRA = "#A05A3C"
-CHART_COLORS = [GOLD, TEAL, NAVY, WARM_ORANGE, TERRA,
-                "#7A6AAC", "#5A9A5A", "#C44A4A", "#4AC4C4", "#8A8A4A"]
-# ── Load data ─────────────────────────────────────────────────────────────────
-DATASET_ID = "omneity-labs/lid-benchmark"
 try:
-    df_summary = load_dataset(DATASET_ID, "results_summary", split="train").to_pandas()
-    df_agg = load_dataset(DATASET_ID, "results_aggregate", split="train").to_pandas()
-    df_lang = load_dataset(DATASET_ID, "results_per_language", split="train").to_pandas()
-except Exception:
-    # Fallback: load from local parquet (for dev)
-    df_summary = pd.read_parquet("../data/results_summary/train.parquet")
     df_agg = pd.read_parquet("../data/results_aggregate/train.parquet")
     df_lang = pd.read_parquet("../data/results_per_language/train.parquet")
-ALL_MODELS = sorted(df_summary["model"].unique())
-ALL_BENCHMARKS = sorted(df_summary["benchmark"].unique())
-ALL_SCOPES = sorted(df_agg["scope"].unique())
-ALL_LANGUAGES = sorted(df_lang["language"].unique())
-BENCHMARK_DISPLAY = {
-    "flores-devtest": "FLORES+ devtest",
-    "flores-dev": "FLORES+ dev",
-    "madar": "MADAR",
-    "gherbal-multi": "Gherbal-Multi",
-    "atlasia-lid": "ATLASIA-LID",
-    "wili-2018": "WiLI-2018",
-    "commonlid": "CommonLID",
-    "bouquet": "Bouquet",
 }
-MODEL_URLS = {
-    "gherbal-v4": "https://www.omneitylabs.com/models/gherbal",
-    "gherbal-v3": "https://www.omneitylabs.com/models/gherbal",
-    "gherbal-v2": "https://www.omneitylabs.com/models/gherbal",
-    "gherbal-v1": "https://www.omneitylabs.com/models/gherbal",
-    "glotlid": "https://huggingface.co/cis-lmu/glotlid",
-    "nllb-lid": "https://huggingface.co/facebook/fasttext-language-identification",
-    "openlid-v1": "https://huggingface.co/laurievb/OpenLID",
-    "openlid-v2": "https://huggingface.co/laurievb/OpenLID",
-    "openlid-v3": "https://huggingface.co/laurievb/OpenLID",
-    "fastlid-176": "https://fasttext.cc/docs/en/language-identification.html",
 }
-# ── Tab 1: Leaderboard ───────────────────────────────────────────────────────
-def build_leaderboard(benchmark, scope, metric):
-    if scope == "full":
-        src = df_summary[df_summary["benchmark"] == benchmark].copy()
-    else:
-        src = df_agg[(df_agg["benchmark"] == benchmark) & (df_agg["scope"] == scope)].copy()
-    if src.empty:
-        return pd.DataFrame({"Info": ["No data for this combination."]})
-    src = src.sort_values(metric, ascending=False).reset_index(drop=True)
-    src.index = src.index + 1
-    src.index.name = "Rank"
-    cols = ["model", metric, "f1_weighted", "n_samples", "n_classes"]
-    cols = [c for c in cols if c in src.columns]
-    display = src[cols].copy()
-    display.columns = ["Model", metric.replace("_", " ").title(),
-                        "F1 Weighted", "Samples", "Classes"][:len(cols)]
-    for col in display.columns[1:]:
-        if display[col].dtype == float:
-            display[col] = display[col].apply(lambda x: f"{x:.4f}" if pd.notna(x) else "—")
-    return display
-def leaderboard_chart(benchmark, scope, metric):
     if scope == "full":
-        src = df_summary[df_summary["benchmark"] == benchmark].copy()
-    else:
-        src = df_agg[(df_agg["benchmark"] == benchmark) & (df_agg["scope"] == scope)].copy()
-    src = src.sort_values(metric, ascending=True)
-    fig = go.Figure()
-    fig.add_trace(go.Bar(
-        y=src["model"], x=src[metric],
-        orientation="h",
-        marker_color=[GOLD if "gherbal" in m else MUTED for m in src["model"]],
-        text=src[metric].apply(lambda x: f"{x:.4f}"),
-        textposition="outside",
-    ))
-    fig.update_layout(
-        title=f"{BENCHMARK_DISPLAY.get(benchmark, benchmark)} — {metric.replace('_', ' ').title()}",
-        xaxis_title=metric.replace("_", " ").title(),
-        yaxis_title="",
-        plot_bgcolor="white",
-        paper_bgcolor="white",
-        font=dict(family="Inter, system-ui, sans-serif", size=13, color=DARK),
-        margin=dict(l=120, r=40, t=50, b=40),
-        height=max(350, len(src) * 40 + 80),
-        xaxis=dict(range=[0, min(1.05, src[metric].max() * 1.15)],
-                   gridcolor="#f0ece4"),
     )
     return fig
-# ── Tab 2: Per-Language Explorer ──────────────────────────────────────────────
-def per_language_table(models, benchmark, scope, min_samples):
-    mask = (
-        (df_lang["benchmark"] == benchmark) &
-        (df_lang["scope"] == scope) &
-        (df_lang["model"].isin(models)) &
-        (df_lang["n_samples"] >= min_samples)
-    )
-    subset = df_lang[mask].copy()
-    if subset.empty:
-        return pd.DataFrame({"Info": ["No data for this combination."]})
-    pivot = subset.pivot_table(
-        index="language", columns="model", values="accuracy"
-    ).reset_index()
-    # Add sample count
-    sample_counts = subset.groupby("language")["n_samples"].first()
-    pivot = pivot.merge(sample_counts.reset_index(), on="language", how="left")
-    # Sort by first model's accuracy descending
-    sort_col = models[0] if models[0] in pivot.columns else pivot.columns[1]
-    pivot = pivot.sort_values(sort_col, ascending=False, na_position="last")
-    # Rename
-    pivot = pivot.rename(columns={"language": "Language", "n_samples": "Samples"})
-    # Format floats
-    for col in pivot.columns:
-        if col not in ("Language", "Samples") and pivot[col].dtype == float:
-            pivot[col] = pivot[col].apply(lambda x: f"{x:.4f}" if pd.notna(x) else "—")
-    return pivot
-def per_language_chart(models, benchmark, scope, min_samples, top_n):
-    mask = (
-        (df_lang["benchmark"] == benchmark) &
-        (df_lang["scope"] == scope) &
-        (df_lang["model"].isin(models)) &
-        (df_lang["n_samples"] >= min_samples)
-    )
-    subset = df_lang[mask].copy()
-    if subset.empty:
-        return go.Figure()
-    # Get top_n languages by average accuracy across selected models
-    avg_acc = subset.groupby("language")["accuracy"].mean().sort_values(ascending=False)
-    top_langs = avg_acc.head(top_n).index.tolist()
-    subset = subset[subset["language"].isin(top_langs)]
-    fig = go.Figure()
-    for i, model in enumerate(models):
-        model_data = subset[subset["model"] == model].set_index("language")
-        model_data = model_data.reindex(top_langs)
         fig.add_trace(go.Bar(
-            name=model,
-            x=model_data.index,
-            y=model_data["accuracy"],
-            marker_color=CHART_COLORS[i % len(CHART_COLORS)],
         ))
-    fig.update_layout(
-        barmode="group",
-        title=f"Per-Language Accuracy — {BENCHMARK_DISPLAY.get(benchmark, benchmark)}",
-        yaxis_title="Accuracy",
-        xaxis_tickangle=-45,
-        plot_bgcolor="white",
-        paper_bgcolor="white",
-        font=dict(family="Inter, system-ui, sans-serif", size=12, color=DARK),
-        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
-        margin=dict(l=50, r=20, t=70, b=100),
-        height=500,
-        yaxis=dict(range=[0, 1.05], gridcolor="#f0ece4"),
-    )
     return fig
-# ── Tab 3: Confusion Explorer ────────────────────────────────────────────────
-def confusion_table(model, benchmark, scope, min_samples):
     mask = (
-        (df_lang["model"] == model) &
-        (df_lang["benchmark"] == benchmark) &
-        (df_lang["scope"] == scope) &
-        (df_lang["n_samples"] >= min_samples) &
-        (df_lang["top_confusion_1"].notna())
     )
-    subset = df_lang[mask][
         ["language", "accuracy", "n_samples",
          "top_confusion_1", "top_confusion_1_count",
          "top_confusion_2", "top_confusion_2_count",
          "top_confusion_3", "top_confusion_3_count"]
     ].copy()
-    subset = subset.sort_values("accuracy", ascending=True)
-    subset["accuracy"] = subset["accuracy"].apply(lambda x: f"{x:.4f}")
-    subset.columns = [
-        "Language", "Accuracy", "Samples",
         "Top Confusion", "Count",
         "2nd Confusion", "Count ",
         "3rd Confusion", "Count  ",
     ]
-    return subset
-# ── Tab 4: Model Comparison (Radar) ──────────────────────────────────────────
-def model_radar(models, scope):
-    benchmarks = ["flores-devtest", "madar", "gherbal-multi", "atlasia-lid"]
-    bench_labels = [BENCHMARK_DISPLAY.get(b, b) for b in benchmarks]
-    fig = go.Figure()
-    for i, model in enumerate(models):
-        values = []
-        for b in benchmarks:
             if scope == "full":
-                row = df_summary[(df_summary["model"] == model) & (df_summary["benchmark"] == b)]
             else:
-                row = df_agg[(df_agg["model"] == model) & (df_agg["benchmark"] == b) & (df_agg["scope"] == scope)]
-            val = row["accuracy"].values[0] if len(row) > 0 else 0
-            values.append(val)
-        values.append(values[0])  # close the polygon
         fig.add_trace(go.Scatterpolar(
-            r=values,
-            theta=bench_labels + [bench_labels[0]],
-            fill="toself",
-            name=model,
-            line_color=CHART_COLORS[i % len(CHART_COLORS)],
-            fillcolor=CHART_COLORS[i % len(CHART_COLORS)],
-            opacity=0.3,
         ))
-    fig.update_layout(
-        polar=dict(
-            radialaxis=dict(visible=True, range=[0, 1], gridcolor="#f0ece4"),
-            bgcolor="white",
-        ),
-        plot_bgcolor="white",
-        paper_bgcolor="white",
-        font=dict(family="Inter, system-ui, sans-serif", size=13, color=DARK),
-        title="Model Comparison",
-        margin=dict(l=60, r=60, t=60, b=40),
-        height=500,
-        legend=dict(orientation="h", yanchor="bottom", y=-0.15, xanchor="center", x=0.5),
-    )
     return fig
-# ── Custom CSS ────────────────────────────────────────────────────────────────
-CUSTOM_CSS = """
-.gradio-container {
-    max-width: 1200px !important;
-    font-family: 'Inter', system-ui, -apple-system, sans-serif !important;
-}
-.header-banner {
-    background: linear-gradient(135deg, #2A2520 0%, #3A3530 100%);
-    border-radius: 12px;
-    padding: 28px 32px;
-    margin-bottom: 16px;
-    color: white;
-}
-.header-banner h1 {
-    color: #E8C96A !important;
-    font-size: 1.6em !important;
-    margin-bottom: 4px !important;
-    font-weight: 700 !important;
-}
-.header-banner p {
-    color: #B8B0A8 !important;
-    font-size: 0.95em !important;
-    margin: 0 !important;
-}
-.header-banner a {
-    color: #E8C96A !important;
-    text-decoration: none;
-}
-.header-banner a:hover {
-    text-decoration: underline;
-}
-footer { display: none !important; }
-"""
-# ── Build the Gradio app ─────────────────────────────────────────────────────
 theme = gr.themes.Soft(
     primary_hue=gr.themes.Color(
-        c50="#FDF8ED", c100="#F8EDCC", c200="#F0DCA0",
-        c300="#E8C96A", c400="#D4AD3C", c500="#C4962C",
-        c600="#A07A20", c700="#7C5E18", c800="#584210", c900="#3A2C0A",
-        c950="#2A2008",
-    ),
     neutral_hue=gr.themes.Color(
-        c50="#FAF8F5", c100="#F0ECE4", c200="#E0D8CC",
-        c300="#C8BEB0", c400="#A89E90", c500="#8A8078",
-        c600="#6A6258", c700="#4A4440", c800="#2A2520",
-        c900="#1A1815", c950="#0A0908",
-    ),
     font=["Inter", "system-ui", "sans-serif"],
 )
-with gr.Blocks(theme=theme, css=CUSTOM_CSS, title="LID Benchmark") as demo:
-    gr.HTML("""
-    <div class="header-banner">
-        <h1>🌍 LID Benchmark</h1>
-        <p>
-            10 models · 8 benchmarks · 380 languages ·
-            Built by <a href="https://www.omneitylabs.com" target="_blank">Omneity Labs</a> ·
-            Model: <a href="https://www.omneitylabs.com/models/gherbal" target="_blank">Gherbal</a>
-        </p>
-    </div>
-    """)
     with gr.Tabs():
-        # ── TAB 1: Leaderboard ────────────────────────────────────────────
         with gr.Tab("Leaderboard"):
-            gr.Markdown("Compare all models on a benchmark. Select scope to control which languages are included.")
             with gr.Row():
-                lb_bench = gr.Dropdown(
-                    choices=ALL_BENCHMARKS, value="flores-devtest",
-                    label="Benchmark", scale=2)
-                lb_scope = gr.Dropdown(
-                    choices=ALL_SCOPES, value="full",
-                    label="Scope", scale=1)
-                lb_metric = gr.Dropdown(
-                    choices=["accuracy", "f1_macro", "f1_weighted",
-                             "precision_macro", "recall_macro"],
-                    value="accuracy", label="Metric", scale=1)
-            lb_chart = gr.Plot()
-            lb_table = gr.Dataframe(label="Results")
-            def update_leaderboard(bench, scope, metric):
-                return leaderboard_chart(bench, scope, metric), build_leaderboard(bench, scope, metric)
-            for inp in [lb_bench, lb_scope, lb_metric]:
-                inp.change(update_leaderboard, [lb_bench, lb_scope, lb_metric], [lb_chart, lb_table])
-            demo.load(update_leaderboard, [lb_bench, lb_scope, lb_metric], [lb_chart, lb_table])
-        # ── TAB 2: Per-Language ───────────────────────────────────────────
         with gr.Tab("Per-Language"):
-            gr.Markdown("Explore accuracy for individual languages. Compare how different models handle specific languages.")
             with gr.Row():
-                pl_models = gr.Dropdown(
-                    choices=ALL_MODELS,
-                    value=["gherbal-v4", "glotlid", "openlid-v2"],
-                    multiselect=True, label="Models", scale=3)
-                pl_bench = gr.Dropdown(
-                    choices=ALL_BENCHMARKS, value="flores-devtest",
-                    label="Benchmark", scale=2)
             with gr.Row():
-                pl_scope = gr.Dropdown(
-                    choices=ALL_SCOPES, value="full",
-                    label="Scope", scale=1)
-                pl_min_samples = gr.Slider(
-                    minimum=1, maximum=1000, value=50, step=10,
-                    label="Min samples", scale=1)
-                pl_top_n = gr.Slider(
-                    minimum=5, maximum=50, value=20, step=5,
-                    label="Top N (chart)", scale=1)
-            pl_chart = gr.Plot()
-            pl_table = gr.Dataframe(label="Per-Language Accuracy")
-            def update_per_lang(models, bench, scope, min_s, top_n):
-                if not models:
-                    return go.Figure(), pd.DataFrame({"Info": ["Select at least one model."]})
-                return (per_language_chart(models, bench, scope, min_s, top_n),
-                        per_language_table(models, bench, scope, min_s))
-            for inp in [pl_models, pl_bench, pl_scope, pl_min_samples, pl_top_n]:
-                inp.change(update_per_lang,
-                           [pl_models, pl_bench, pl_scope, pl_min_samples, pl_top_n],
-                           [pl_chart, pl_table])
-            demo.load(update_per_lang,
-                      [pl_models, pl_bench, pl_scope, pl_min_samples, pl_top_n],
-                      [pl_chart, pl_table])
-        # ── TAB 3: Confusion Analysis ─────────────────────────────────────
         with gr.Tab("Confusions"):
-            gr.Markdown("See which languages are most frequently confused with each other. Sorted worst-first.")
             with gr.Row():
-                cf_model = gr.Dropdown(
-                    choices=ALL_MODELS, value="gherbal-v4",
-                    label="Model", scale=2)
-                cf_bench = gr.Dropdown(
-                    choices=ALL_BENCHMARKS, value="flores-devtest",
-                    label="Benchmark", scale=2)
-                cf_scope = gr.Dropdown(
-                    choices=ALL_SCOPES, value="full",
-                    label="Scope", scale=1)
-                cf_min = gr.Slider(
-                    minimum=1, maximum=500, value=50, step=10,
-                    label="Min samples", scale=1)
-            cf_table = gr.Dataframe(label="Confusion Pairs (worst first)")
-            for inp in [cf_model, cf_bench, cf_scope, cf_min]:
-                inp.change(confusion_table, [cf_model, cf_bench, cf_scope, cf_min], cf_table)
-            demo.load(confusion_table, [cf_model, cf_bench, cf_scope, cf_min], cf_table)
-        # ── TAB 4: Model Comparison ───────────────────────────────────────
         with gr.Tab("Compare"):
-            gr.Markdown("Radar chart comparing selected models across core benchmarks.")
             with gr.Row():
-                mc_models = gr.Dropdown(
-                    choices=ALL_MODELS,
-                    value=["gherbal-v4", "glotlid", "nllb-lid"],
-                    multiselect=True, label="Models", scale=3)
-                mc_scope = gr.Dropdown(
-                    choices=ALL_SCOPES, value="full",
-                    label="Scope", scale=1)
-            mc_chart = gr.Plot()
-            def update_radar(models, scope):
-                if not models:
-                    return go.Figure()
-                return model_radar(models, scope)
-            for inp in [mc_models, mc_scope]:
-                inp.change(update_radar, [mc_models, mc_scope], mc_chart)
-            demo.load(update_radar, [mc_models, mc_scope], mc_chart)
-    gr.HTML("""
-    <div style="text-align: center; padding: 16px 0 8px; color: #8A8078; font-size: 0.85em;">
-        Data: <a href="https://huggingface.co/datasets/omneity-labs/lid-benchmark"
-                style="color: #C4962C;">omneity-labs/lid-benchmark</a> ·
-        Model: <a href="https://www.omneitylabs.com/models/gherbal"
-                 style="color: #C4962C;">Gherbal</a> ·
-        <a href="https://omarkamali.com" style="color: #C4962C;">Omar Kamali</a> ·
-        <a href="https://www.omneitylabs.com" style="color: #C4962C;">Omneity Labs</a>
-    </div>
-    """)
 if __name__ == "__main__":
-    demo.launch(ssr_mode=False)

 LID Benchmark — Language Identification Leaderboard
 Built by Omneity Labs · https://www.omneitylabs.com
 """
+import os
+os.environ["GRADIO_SSR_MODE"] = "false"
+import sys
+print("[startup] importing...", flush=True)
 import gradio as gr
 import pandas as pd
 import plotly.graph_objects as go
 from datasets import load_dataset
+print("[startup] imports done", flush=True)
+# ── Brand ─────────────────────────────────────────────────────────────────────
+GOLD, TEAL, NAVY = "#C4962C", "#4A8C7A", "#3A5A8C"
+WARM_ORANGE, TERRA, DARK, MUTED = "#C47A2C", "#A05A3C", "#2A2520", "#8A8078"
+COLORS = [GOLD, TEAL, NAVY, WARM_ORANGE, TERRA,
+          "#7A6AAC", "#5A9A5A", "#C44A4A", "#4AC4C4", "#8A8A4A"]
+# ── Data ──────────────────────────────────────────────────────────────────────
+DS = "omneity-labs/lid-benchmark"
+print("[startup] loading data...", flush=True)
 try:
+    df_sum = load_dataset(DS, "results_summary", split="train").to_pandas()
+    df_agg = load_dataset(DS, "results_aggregate", split="train").to_pandas()
+    df_lang = load_dataset(DS, "results_per_language", split="train").to_pandas()
+except Exception as e:
+    print(f"[startup] HF failed ({e}), local fallback", flush=True)
+    df_sum = pd.read_parquet("../data/results_summary/train.parquet")
     df_agg = pd.read_parquet("../data/results_aggregate/train.parquet")
     df_lang = pd.read_parquet("../data/results_per_language/train.parquet")
+print(f"[startup] {len(df_sum)}/{len(df_agg)}/{len(df_lang)} rows", flush=True)
+MODELS = sorted(df_sum["model"].unique())
+BENCHMARKS = sorted(df_sum["benchmark"].unique())
+SCOPES = sorted(df_agg["scope"].unique())
+BENCH_ALL = ["__average__"] + BENCHMARKS
+METRICS = ["accuracy", "f1_macro", "f1_weighted", "precision_macro", "recall_macro"]
+BNAME = {
+    "flores-devtest": "FLORES+ devtest", "flores-dev": "FLORES+ dev",
+    "madar": "MADAR", "gherbal-multi": "Gherbal-Multi",
+    "atlasia-lid": "ATLASIA-LID", "wili-2018": "WiLI-2018",
+    "commonlid": "CommonLID", "bouquet": "Bouquet",
+    "__average__": "Avg (all benchmarks)",
 }
+# ── Language names ────────────────────────────────────────────────────────────
+LN = {
+    "acm_Arab": "Mesopotamian Arabic", "acq_Arab": "Ta'izzi-Adeni Arabic",
+    "acw_Arab": "Hijazi Arabic", "acx_Arab": "Omani Arabic",
+    "aeb_Arab": "Tunisian Arabic", "afb_Arab": "Gulf Arabic",
+    "apc_Arab": "Levantine Arabic", "apd_Arab": "Sudanese Arabic",
+    "arb_Arab": "Modern Standard Arabic", "arb_Latn": "Arabic (Latn)",
+    "arq_Arab": "Algerian Arabic", "ars_Arab": "Najdi Arabic",
+    "ary_Arab": "Moroccan Arabic", "ary_Latn": "Moroccan Arabic (Latn)",
+    "arz_Arab": "Egyptian Arabic", "arz_Latn": "Egyptian Arabic (Latn)",
+    "ayl_Arab": "Libyan Arabic", "ayn_Arab": "Sanaani Arabic",
+    "ayp_Arab": "N. Mesopotamian Arabic",
+    "mey_Arab": "Hassaniya Arabic", "mey_Latn": "Hassaniya (Latn)",
+    "kab_Latn": "Kabyle", "taq_Latn": "Tamasheq (Latn)",
+    "taq_Tfng": "Tamasheq (Tifinagh)", "tzm_Tfng": "Central Atlas Tamazight",
+    "zgh_Tfng": "Std Moroccan Tamazight",
+    "eng_Latn": "English", "fra_Latn": "French", "deu_Latn": "German",
+    "spa_Latn": "Spanish", "por_Latn": "Portuguese", "ita_Latn": "Italian",
+    "nld_Latn": "Dutch", "pol_Latn": "Polish", "ron_Latn": "Romanian",
+    "cat_Latn": "Catalan", "eus_Latn": "Basque", "glg_Latn": "Galician",
+    "por_Latn_braz1246": "Brazilian Portuguese",
+    "rus_Cyrl": "Russian", "ukr_Cyrl": "Ukrainian", "bel_Cyrl": "Belarusian",
+    "srp_Cyrl": "Serbian", "bul_Cyrl": "Bulgarian", "mkd_Cyrl": "Macedonian",
+    "hrv_Latn": "Croatian", "slv_Latn": "Slovenian", "slk_Latn": "Slovak",
+    "ces_Latn": "Czech", "hun_Latn": "Hungarian", "lit_Latn": "Lithuanian",
+    "lvs_Latn": "Latvian", "ekk_Latn": "Estonian", "fin_Latn": "Finnish",
+    "swe_Latn": "Swedish", "dan_Latn": "Danish",
+    "nob_Latn": "Norwegian Bokm\u00e5l", "nno_Latn": "Norwegian Nynorsk",
+    "isl_Latn": "Icelandic",
+    "cmn_Hans": "Chinese (Simplified)", "cmn_Hant": "Chinese (Traditional)",
+    "zho_Hans": "Chinese (Simplified)", "jpn_Jpan": "Japanese",
+    "kor_Hang": "Korean (Hangul)", "kor_Kore": "Korean",
+    "hin_Deva": "Hindi", "urd_Arab": "Urdu", "ben_Beng": "Bengali",
+    "pan_Guru": "Punjabi", "guj_Gujr": "Gujarati", "mar_Deva": "Marathi",
+    "tam_Taml": "Tamil", "tel_Telu": "Telugu", "kan_Knda": "Kannada",
+    "mal_Mlym": "Malayalam", "sin_Sinh": "Sinhala", "npi_Deva": "Nepali",
+    "asm_Beng": "Assamese", "ory_Orya": "Odia",
+    "tha_Thai": "Thai", "vie_Latn": "Vietnamese", "ind_Latn": "Indonesian",
+    "zsm_Latn": "Malay", "fil_Latn": "Filipino", "khm_Khmr": "Khmer",
+    "mya_Mymr": "Burmese", "lao_Laoo": "Lao",
+    "tur_Latn": "Turkish", "azj_Latn": "Azerbaijani",
+    "kaz_Cyrl": "Kazakh", "uzn_Latn": "Uzbek", "kir_Cyrl": "Kyrgyz",
+    "tuk_Latn": "Turkmen", "tat_Cyrl": "Tatar",
+    "pes_Arab": "Persian", "prs_Arab": "Dari", "tgk_Cyrl": "Tajik",
+    "heb_Hebr": "Hebrew", "kat_Geor": "Georgian", "hye_Armn": "Armenian",
+    "ell_Grek": "Greek", "mlt_Latn": "Maltese",
+    "swh_Latn": "Swahili", "amh_Ethi": "Amharic", "tir_Ethi": "Tigrinya",
+    "som_Latn": "Somali", "gaz_Latn": "Oromo (West Central)",
+    "gax_Latn": "Oromo (Borana)", "hau_Latn": "Hausa",
+    "yor_Latn": "Yoruba", "ibo_Latn": "Igbo", "wol_Latn": "Wolof",
+    "fuc_Latn": "Pulaar", "fuv_Latn": "Nigerian Fulfulde",
+    "bam_Latn": "Bambara", "mos_Latn": "Mossi", "ewe_Latn": "Ewe",
+    "twi_Latn": "Twi", "fon_Latn": "Fon", "pcm_Latn": "Nigerian Pidgin",
+    "dyu_Latn": "Dyula", "kbp_Latn": "Kabiy\u00e8",
+    "zul_Latn": "Zulu", "xho_Latn": "Xhosa", "sot_Latn": "Southern Sotho",
+    "tsn_Latn": "Tswana", "ssw_Latn": "Swati", "nso_Latn": "Northern Sotho",
+    "tso_Latn": "Tsonga", "sna_Latn": "Shona", "nya_Latn": "Chichewa",
+    "ven_Latn": "Venda", "naq_Latn": "Nama", "xuu_Latn": "Khwedam",
+    "lin_Latn": "Lingala", "lua_Latn": "Luba-Kasai", "sag_Latn": "Sango",
+    "tum_Latn": "Tumbuka", "bem_Latn": "Bemba", "kmb_Latn": "Kimbundu",
+    "umb_Latn": "Umbundu", "kin_Latn": "Kinyarwanda",
+    "run_Latn": "Kirundi", "lug_Latn": "Luganda", "luo_Latn": "Dholuo",
+    "kam_Latn": "Kamba", "kik_Latn": "Kikuyu", "mas_Latn": "Maasai",
+    "guz_Latn": "Gusii", "jmc_Latn": "Machame", "enb_Latn": "Markweeta",
+    "dik_Latn": "SW Dinka", "nus_Latn": "Nuer",
+    "mlg": "Malagasy", "plt_Latn": "Plateau Malagasy",
+    "ckb_Arab": "Central Kurdish", "afr_Latn": "Afrikaans",
+    "hat_Latn": "Haitian Creole", "ceb_Latn": "Cebuano",
+    "jav_Latn": "Javanese", "sun_Latn": "Sundanese",
+    "tgl_Latn": "Tagalog", "war_Latn": "Waray",
+    "bre_Latn": "Breton", "bre": "Breton", "cym_Latn": "Welsh",
+    "gla_Latn": "Scottish Gaelic", "gle_Latn": "Irish",
+    "fry_Latn": "W Frisian", "fry": "W Frisian",
+    "oci_Latn": "Occitan", "ast_Latn": "Asturian",
+    "bod_Tibt": "Tibetan", "div_Thaa": "Dhivehi",
+    "fao_Latn": "Faroese", "ltz_Latn": "Luxembourgish",
+    "sme_Latn": "Northern Sami", "epo_Latn": "Esperanto",
+    "lat": "Latin", "san_Deva": "Sanskrit",
+    "bos_Latn": "Bosnian", "srd_Latn": "Sardinian",
+    "roh_Latn": "Romansh", "fur_Latn": "Friulian",
+    "snd_Arab": "Sindhi", "pnb_Arab": "W Punjabi",
+    "bho_Deva": "Bhojpuri", "mai_Deva": "Maithili",
+    "awa_Deva": "Awadhi", "mag_Deva": "Magahi",
+    "kmr_Latn": "N Kurdish", "diq_Latn": "Zazaki",
+    "nqo_Nkoo": "N'Ko", "ace_Latn": "Acehnese", "ban_Latn": "Balinese",
+    "bug_Latn": "Buginese", "min_Latn": "Minangkabau",
+    "ilo_Latn": "Ilocano", "pag_Latn": "Pangasinan",
+    "mri_Latn": "M\u0101ori", "smo_Latn": "Samoan", "fij_Latn": "Fijian",
+    "tpi_Latn": "Tok Pisin", "che_Cyrl": "Chechen", "bak_Cyrl": "Bashkir",
+    "chv_Cyrl": "Chuvash", "khk_Cyrl": "Mongolian", "uig_Arab": "Uyghur",
+    "ydd_Hebr": "Yiddish", "lij_Latn": "Ligurian", "lmo_Latn": "Lombard",
+    "vec_Latn": "Venetian", "scn_Latn": "Sicilian", "szl_Latn": "Silesian",
+    "als_Latn": "Albanian (Tosk)", "wuu_Hans": "Wu Chinese", "wuu": "Wu",
+    "yue_Hant": "Cantonese", "yue": "Cantonese",
+    "sat_Olck": "Santali", "quy_Latn": "Quechua",
 }
+def ld(code):
+    """Return 'Name (code)' for display."""
+    n = LN.get(code)
+    return f"{n} ({code})" if n else code
+# ── Regions ───────────────────────────────────────────────────────────────────
+ARABIC_16 = [
+    "acm_Arab", "acq_Arab", "acw_Arab", "acx_Arab", "aeb_Arab", "afb_Arab",
+    "apc_Arab", "apd_Arab", "arb_Arab", "arq_Arab", "ars_Arab", "ary_Arab",
+    "arz_Arab", "ayl_Arab", "ayn_Arab", "ayp_Arab",
+]
+NORTH_AFRICAN = [
+    "ary_Arab", "ary_Latn", "arq_Arab", "aeb_Arab", "ayl_Arab",
+    "arz_Arab", "arz_Latn", "mey_Arab", "mey_Latn",
+    "kab_Latn", "taq_Latn", "taq_Tfng", "tzm_Tfng", "zgh_Tfng", "arb_Arab",
+]
+AFRICAN = list(set(
+    ["swh_Latn", "amh_Ethi", "tir_Ethi", "som_Latn", "gaz_Latn", "gax_Latn",
+     "kin_Latn", "run_Latn", "lug_Latn", "luo_Latn", "nyn", "kam_Latn",
+     "kik_Latn", "mas_Latn", "guz_Latn", "jmc_Latn", "enb_Latn",
+     "hau_Latn", "yor_Latn", "ibo_Latn", "wol_Latn", "fuc_Latn", "fuv_Latn",
+     "bam_Latn", "mos_Latn", "ewe_Latn", "twi_Latn", "fon_Latn", "pcm_Latn",
+     "dyu_Latn", "kbp_Latn",
+     "zul_Latn", "xho_Latn", "sot_Latn", "tsn_Latn", "ssw_Latn", "nso_Latn",
+     "tso_Latn", "sna_Latn", "nya_Latn", "ven_Latn", "naq_Latn", "xuu_Latn",
+     "afr_Latn", "lin_Latn", "lua_Latn", "sag_Latn", "tum_Latn", "bem_Latn",
+     "kmb_Latn", "umb_Latn", "loa_Latn", "kwy_Latn", "cjk_Latn",
+     "mlg", "plt_Latn", "dik_Latn", "nus_Latn"]
+    + NORTH_AFRICAN
+))
+# ── Data helpers ──────────────────────────────────────────────────────────────
+def get_agg(bench, scope, metric):
+    """Model-level aggregated metric values."""
+    if bench == "__average__":
+        src = df_sum if scope == "full" else df_agg[df_agg["scope"] == scope]
+        return src.groupby("model")[metric].mean().reset_index()
     if scope == "full":
+        return df_sum[df_sum["benchmark"] == bench].copy()
+    return df_agg[(df_agg["benchmark"] == bench) & (df_agg["scope"] == scope)].copy()
+def get_lang(bench, scope, models, lang_filter=None):
+    """Per-language accuracy, optionally averaged across benchmarks."""
+    mask = (df_lang["scope"] == scope) & (df_lang["model"].isin(models))
+    if lang_filter is not None:
+        mask = mask & (df_lang["language"].isin(lang_filter))
+    if bench != "__average__":
+        mask = mask & (df_lang["benchmark"] == bench)
+    sub = df_lang[mask].copy()
+    if sub.empty:
+        return sub
+    if bench == "__average__":
+        return (sub.groupby(["model", "language"])
+                .agg(accuracy=("accuracy", "mean"), n_samples=("n_samples", "max"))
+                .reset_index())
+    return sub
+# ── Chart builders (using Figure constructor to ensure axis ranges) ───────────
+def make_hbar(labels, values, colors, title, height):
+    """Horizontal bar chart with LOCKED x-axis 0-1."""
+    # Convert everything to plain Python lists
+    labels = [str(l) for l in labels]
+    values = [float(v) if pd.notna(v) else 0.0 for v in values]
+    colors = list(colors)
+    texts = [f"{v:.4f}" for v in values]
+    fig = go.Figure(
+        data=[go.Bar(
+            y=labels, x=values, orientation="h",
+            marker_color=colors,
+            text=texts, textposition="inside",
+            insidetextanchor="end",
+            textfont=dict(color="white", size=12),
+        )],
+        layout=go.Layout(
+            title=dict(text=title, x=0),
+            xaxis=dict(
+                range=[0, 1.0], autorange=False, fixedrange=True,
+                title="", gridcolor="#f0ece4", zeroline=False,
+                dtick=0.1,
+            ),
+            yaxis=dict(automargin=True, fixedrange=True),
+            plot_bgcolor="white", paper_bgcolor="white",
+            font=dict(family="Inter, system-ui, sans-serif", size=13,
+                      color=DARK),
+            margin=dict(l=10, r=30, t=50, b=40),
+            height=height, bargap=0.25,
+        ),
     )
     return fig
+def make_vbar(categories, traces, title, height=500):
+    """Vertical grouped bar chart with LOCKED y-axis 0-1."""
+    categories = [str(c) for c in categories]
+    fig = go.Figure(layout=go.Layout(
+        title=dict(text=title, x=0),
+        barmode="group",
+        xaxis=dict(
+            tickangle=-45, automargin=True, fixedrange=True,
+            type="category",
+        ),
+        yaxis=dict(
+            range=[0, 1.05], autorange=False, fixedrange=True,
+            title="Accuracy", gridcolor="#f0ece4", zeroline=False,
+            dtick=0.2,
+        ),
+        plot_bgcolor="white", paper_bgcolor="white",
+        font=dict(family="Inter, system-ui, sans-serif", size=11, color=DARK),
+        legend=dict(orientation="h", yanchor="bottom", y=1.02,
+                    xanchor="right", x=1),
+        margin=dict(l=50, r=20, t=70, b=10),
+        height=height, bargap=0.15, bargroupgap=0.05,
+    ))
+    for name, vals, color in traces:
+        # Ensure plain Python floats, replace NaN with None
+        clean = [float(v) if pd.notna(v) else None for v in vals]
+        fig.add_trace(go.Bar(
+            name=name, x=categories, y=clean,
+            marker_color=color,
+        ))
+    return fig
+def make_hbar_grouped(categories, traces, title, height):
+    """Horizontal grouped bar chart with LOCKED x-axis 0-1."""
+    categories = [str(c) for c in categories]
+    fig = go.Figure(layout=go.Layout(
+        title=dict(text=title, x=0),
+        barmode="group",
+        xaxis=dict(
+            range=[0, 1.05], autorange=False, fixedrange=True,
+            title="Accuracy", gridcolor="#f0ece4", zeroline=False,
+            dtick=0.2,
+        ),
+        yaxis=dict(automargin=True, fixedrange=True),
+        plot_bgcolor="white", paper_bgcolor="white",
+        font=dict(family="Inter, system-ui, sans-serif", size=11, color=DARK),
+        legend=dict(orientation="h", yanchor="bottom", y=1.02,
+                    xanchor="right", x=1),
+        margin=dict(l=10, r=20, t=70, b=40),
+        height=height, bargap=0.2, bargroupgap=0.05,
+    ))
+    for name, vals, color in traces:
+        clean = [float(v) if pd.notna(v) else None for v in vals]
+        texts = [f"{v:.2f}" if v is not None else "" for v in clean]
         fig.add_trace(go.Bar(
+            name=name, y=categories, x=clean, orientation="h",
+            marker_color=color,
+            text=texts, textposition="inside",
+            insidetextanchor="end", textfont=dict(size=10),
         ))
+    return fig
+def empty_fig(msg="No data for this selection."):
+    fig = go.Figure(layout=go.Layout(
+        xaxis=dict(visible=False), yaxis=dict(visible=False),
+        plot_bgcolor="white", paper_bgcolor="white", height=300,
+        annotations=[dict(text=msg, xref="paper", yref="paper",
+                          x=0.5, y=0.5, showarrow=False,
+                          font=dict(size=16, color=MUTED))],
+    ))
     return fig
+# ── Tab logic ─────────────────────────────────────────────────────────────────
+def fn_leaderboard(bench, scope, metric):
+    src = get_agg(bench, scope, metric)
+    if src.empty:
+        return empty_fig(), pd.DataFrame({"Info": ["No data."]})
+    src = src.sort_values(metric, ascending=True).reset_index(drop=True)
+    labels = src["model"].tolist()
+    vals = src[metric].tolist()
+    clrs = [GOLD if "gherbal" in m else MUTED for m in labels]
+    title = f"{BNAME.get(bench, bench)} \u2014 {metric.replace('_',' ').title()}"
+    h = max(350, len(labels) * 42 + 100)
+    chart = make_hbar(labels, vals, clrs, title, h)
+    # Table
+    tbl = src.sort_values(metric, ascending=False).reset_index(drop=True)
+    tbl.index = tbl.index + 1
+    if bench == "__average__":
+        cols = ["model", metric]
+    else:
+        cols = [c for c in ["model", metric, "f1_weighted", "n_samples", "n_classes"]
+                if c in tbl.columns]
+    out = tbl[cols].copy()
+    out.columns = ["Model"] + [c.replace("_", " ").title() for c in cols[1:]]
+    for c in out.columns[1:]:
+        if out[c].dtype == float:
+            out[c] = out[c].map(lambda v: f"{v:.4f}" if pd.notna(v) else "\u2014")
+    return chart, out
+def fn_perlang(mdls, bench, scope, mins, topn):
+    if not mdls:
+        return empty_fig("Select at least one model."), pd.DataFrame()
+    sub = get_lang(bench, scope, mdls)
+    sub = sub[sub["n_samples"] >= mins]
+    if sub.empty:
+        return empty_fig(), pd.DataFrame()
+    # Top N languages by average accuracy
+    avg = sub.groupby("language")["accuracy"].mean().sort_values(ascending=False)
+    top = avg.head(int(topn)).index.tolist()
+    sub = sub[sub["language"].isin(top)]
+    cats = [ld(c) for c in top]
+    traces = []
+    for i, m in enumerate(mdls):
+        md = sub[sub["model"] == m].set_index("language")
+        vals = [md.loc[l, "accuracy"] if l in md.index else None for l in top]
+        traces.append((m, vals, COLORS[i % len(COLORS)]))
+    title = f"Per-Language Accuracy \u2014 {BNAME.get(bench, bench)}"
+    chart = make_vbar(cats, traces, title)
+    # Table
+    pivot = sub.pivot_table(index="language", columns="model",
+                            values="accuracy").reset_index()
+    sc = sub.groupby("language")["n_samples"].first()
+    pivot = pivot.merge(sc.reset_index(), on="language", how="left")
+    sort_col = mdls[0] if mdls[0] in pivot.columns else pivot.columns[1]
+    pivot = pivot.sort_values(sort_col, ascending=False, na_position="last")
+    pivot.insert(1, "Name", pivot["language"].map(lambda c: LN.get(c, "")))
+    pivot = pivot.rename(columns={"language": "Code", "n_samples": "Samples"})
+    for c in pivot.columns:
+        if c not in ("Code", "Name", "Samples") and pivot[c].dtype == float:
+            pivot[c] = pivot[c].map(
+                lambda v: f"{v:.4f}" if pd.notna(v) else "\u2014")
+    return chart, pivot
+def fn_region(lang_list, tab_name, mdls, bench, scope):
+    if not mdls:
+        return empty_fig("Select at least one model."), pd.DataFrame()
+    sub = get_lang(bench, scope, mdls, lang_filter=lang_list)
+    if sub.empty:
+        return empty_fig("No data."), pd.DataFrame()
+    order = (sub.groupby("language")["accuracy"].mean()
+             .sort_values(ascending=True).index.tolist())
+    cats = [ld(c) for c in order]
+    traces = []
+    for i, m in enumerate(mdls):
+        md = sub[sub["model"] == m].set_index("language")
+        vals = [md.loc[l, "accuracy"] if l in md.index else None for l in order]
+        traces.append((m, vals, COLORS[i % len(COLORS)]))
+    title = f"{tab_name} \u2014 {BNAME.get(bench, bench)}"
+    n = len(order)
+    h = max(400, n * 26 * max(1, len(mdls)) + 120)
+    chart = make_hbar_grouped(cats, traces, title, h)
+    # Table
+    pivot = sub.pivot_table(index="language", columns="model",
+                            values="accuracy").reset_index()
+    sc = sub.groupby("language")["n_samples"].first()
+    pivot = pivot.merge(sc.reset_index(), on="language", how="left")
+    sort_col = mdls[0] if mdls[0] in pivot.columns else pivot.columns[1]
+    pivot = pivot.sort_values(sort_col, ascending=False, na_position="last")
+    pivot.insert(1, "Name", pivot["language"].map(lambda c: LN.get(c, c)))
+    pivot = pivot.rename(columns={"language": "Code", "n_samples": "Samples"})
+    for c in pivot.columns:
+        if c not in ("Code", "Name", "Samples") and pivot[c].dtype == float:
+            pivot[c] = pivot[c].map(
+                lambda v: f"{v:.4f}" if pd.notna(v) else "\u2014")
+    return chart, pivot
+def fn_confusions(model, bench, scope, mins):
+    if bench == "__average__":
+        return pd.DataFrame({"Info": ["Pick a specific benchmark."]})
     mask = (
+        (df_lang["model"] == model) & (df_lang["benchmark"] == bench)
+        & (df_lang["scope"] == scope) & (df_lang["n_samples"] >= mins)
+        & (df_lang["top_confusion_1"].notna())
     )
+    out = df_lang[mask][
         ["language", "accuracy", "n_samples",
          "top_confusion_1", "top_confusion_1_count",
          "top_confusion_2", "top_confusion_2_count",
          "top_confusion_3", "top_confusion_3_count"]
     ].copy()
+    out = out.sort_values("accuracy", ascending=True)
+    out.insert(1, "Name", out["language"].map(lambda c: LN.get(c, "")))
+    out["accuracy"] = out["accuracy"].map(lambda v: f"{v:.4f}")
+    out.columns = [
+        "Code", "Name", "Accuracy", "Samples",
         "Top Confusion", "Count",
         "2nd Confusion", "Count ",
         "3rd Confusion", "Count  ",
     ]
+    return out
+def fn_compare(mdls, scope):
+    if not mdls:
+        return empty_fig("Select at least one model.")
+    labels = [BNAME.get(b, b) for b in BENCHMARKS]
+    fig = go.Figure(layout=go.Layout(
+        polar=dict(
+            radialaxis=dict(visible=True, range=[0, 1], gridcolor="#f0ece4"),
+            bgcolor="white",
+        ),
+        title=dict(text="Model Comparison \u2014 All 8 Benchmarks", x=0),
+        plot_bgcolor="white", paper_bgcolor="white",
+        font=dict(family="Inter, system-ui, sans-serif", size=12, color=DARK),
+        margin=dict(l=80, r=80, t=60, b=60), height=550,
+        legend=dict(orientation="h", yanchor="bottom", y=-0.2,
+                    xanchor="center", x=0.5),
+    ))
+    for i, m in enumerate(mdls):
+        vals = []
+        for b in BENCHMARKS:
             if scope == "full":
+                r = df_sum[(df_sum["model"] == m) & (df_sum["benchmark"] == b)]
             else:
+                r = df_agg[(df_agg["model"] == m) & (df_agg["benchmark"] == b)
+                           & (df_agg["scope"] == scope)]
+            vals.append(float(r["accuracy"].values[0]) if len(r) > 0 else 0.0)
+        vals.append(vals[0])
         fig.add_trace(go.Scatterpolar(
+            r=vals, theta=labels + [labels[0]],
+            fill="toself", name=m,
+            line_color=COLORS[i % len(COLORS)],
+            fillcolor=COLORS[i % len(COLORS)], opacity=0.3,
         ))
     return fig
+# ── CSS & Theme ───────────────────────────────────────────────────────────────
+CSS = (
+    ".gradio-container{max-width:1200px!important;"
+    "font-family:'Inter',system-ui,-apple-system,sans-serif!important}"
+    ".header-banner{background:linear-gradient(135deg,#2A2520 0%,#3A3530 100%);"
+    "border-radius:12px;padding:28px 32px;margin-bottom:16px;color:white}"
+    ".header-banner h1{color:#E8C96A!important;font-size:1.6em!important;"
+    "margin-bottom:4px!important;font-weight:700!important}"
+    ".header-banner p{color:#B8B0A8!important;font-size:.95em!important;margin:0!important}"
+    ".header-banner a{color:#E8C96A!important;text-decoration:none}"
+    ".header-banner a:hover{text-decoration:underline}"
+    "footer{display:none!important}"
+)
 theme = gr.themes.Soft(
     primary_hue=gr.themes.Color(
+        c50="#FDF8ED", c100="#F8EDCC", c200="#F0DCA0", c300="#E8C96A",
+        c400="#D4AD3C", c500="#C4962C", c600="#A07A20", c700="#7C5E18",
+        c800="#584210", c900="#3A2C0A", c950="#2A2008"),
     neutral_hue=gr.themes.Color(
+        c50="#FAF8F5", c100="#F0ECE4", c200="#E0D8CC", c300="#C8BEB0",
+        c400="#A89E90", c500="#8A8078", c600="#6A6258", c700="#4A4440",
+        c800="#2A2520", c900="#1A1815", c950="#0A0908"),
     font=["Inter", "system-ui", "sans-serif"],
 )
+# ── App ───────────────────────────────────────────────────────────────────────
+with gr.Blocks(theme=theme, css=CSS, title="LID Benchmark") as demo:
+    gr.HTML(
+        '<div class="header-banner">'
+        '<h1>\U0001f30d LID Benchmark</h1>'
+        '<p>10 models \u00b7 8 benchmarks \u00b7 380 languages \u00b7 '
+        'Built by <a href="https://www.omneitylabs.com" target="_blank">'
+        'Omneity Labs</a> \u00b7 Model: '
+        '<a href="https://www.omneitylabs.com/models/gherbal" '
+        'target="_blank">Gherbal</a></p></div>'
+    )
     with gr.Tabs():
+        # ── Leaderboard ──────────────────────────────────────────
         with gr.Tab("Leaderboard"):
+            gr.Markdown("Compare all models. *Average* = mean across all 8 benchmarks.")
             with gr.Row():
+                lb_b = gr.Dropdown(BENCH_ALL, value="__average__",
+                                   label="Benchmark", scale=2)
+                lb_s = gr.Dropdown(SCOPES, value="v4", label="Scope", scale=1)
+                lb_m = gr.Dropdown(METRICS, value="accuracy",
+                                   label="Metric", scale=1)
+            lb_c = gr.Plot()
+            lb_t = gr.Dataframe(label="Results")
+            for w in [lb_b, lb_s, lb_m]:
+                w.change(fn_leaderboard, [lb_b, lb_s, lb_m], [lb_c, lb_t])
+            demo.load(fn_leaderboard, [lb_b, lb_s, lb_m], [lb_c, lb_t])
+        # ── Per-Language ─────────────────────────────────────────
         with gr.Tab("Per-Language"):
+            gr.Markdown("Per-language accuracy across models.")
             with gr.Row():
+                pl_mod = gr.Dropdown(MODELS,
+                                     value=["gherbal-v4", "glotlid", "openlid-v2"],
+                                     multiselect=True, label="Models", scale=3)
+                pl_b = gr.Dropdown(BENCH_ALL, value="__average__",
+                                   label="Benchmark", scale=2)
             with gr.Row():
+                pl_s = gr.Dropdown(SCOPES, value="v4", label="Scope", scale=1)
+                pl_min = gr.Slider(1, 1000, 50, step=10,
+                                   label="Min samples", scale=1)
+                pl_top = gr.Slider(5, 50, 20, step=5,
+                                   label="Top N (chart)", scale=1)
+            pl_c = gr.Plot()
+            pl_t = gr.Dataframe(label="Per-Language Accuracy")
+            for w in [pl_mod, pl_b, pl_s, pl_min, pl_top]:
+                w.change(fn_perlang, [pl_mod, pl_b, pl_s, pl_min, pl_top],
+                         [pl_c, pl_t])
+            demo.load(fn_perlang, [pl_mod, pl_b, pl_s, pl_min, pl_top],
+                      [pl_c, pl_t])
+        # ── Arabic Dialects ──────────────────────────────────────
+        with gr.Tab("Arabic Dialects"):
+            gr.Markdown("All **16 Arabic dialect** variants.")
+            with gr.Row():
+                ad_m = gr.Dropdown(MODELS,
+                                   value=["gherbal-v4", "glotlid", "openlid-v2", "nllb-lid"],
+                                   multiselect=True, label="Models", scale=3)
+                ad_b = gr.Dropdown(BENCH_ALL, value="__average__",
+                                   label="Benchmark", scale=2)
+                ad_s = gr.Dropdown(SCOPES, value="v4", label="Scope", scale=1)
+            ad_c = gr.Plot()
+            ad_t = gr.Dataframe(label="Arabic Dialect Results")
+            def _ad(m, b, s):
+                return fn_region(ARABIC_16, "Arabic Dialects", m, b, s)
+            for w in [ad_m, ad_b, ad_s]:
+                w.change(_ad, [ad_m, ad_b, ad_s], [ad_c, ad_t])
+            demo.load(_ad, [ad_m, ad_b, ad_s], [ad_c, ad_t])
+        # ── North African ────────────────────────────────────────
+        with gr.Tab("North African"):
+            gr.Markdown("**Maghreb Arabic**, **Hassaniya**, **Amazigh/Berber**.")
+            with gr.Row():
+                na_m = gr.Dropdown(MODELS,
+                                   value=["gherbal-v4", "glotlid", "openlid-v2", "nllb-lid"],
+                                   multiselect=True, label="Models", scale=3)
+                na_b = gr.Dropdown(BENCH_ALL, value="__average__",
+                                   label="Benchmark", scale=2)
+                na_s = gr.Dropdown(SCOPES, value="v4", label="Scope", scale=1)
+            na_c = gr.Plot()
+            na_t = gr.Dataframe(label="North African Results")
+            def _na(m, b, s):
+                return fn_region(NORTH_AFRICAN, "North African", m, b, s)
+            for w in [na_m, na_b, na_s]:
+                w.change(_na, [na_m, na_b, na_s], [na_c, na_t])
+            demo.load(_na, [na_m, na_b, na_s], [na_c, na_t])
+        # ── African Languages ────────────────────────────────────
+        with gr.Tab("African Languages"):
+            gr.Markdown("Sub-Saharan, North African Arabic & Amazigh.")
+            with gr.Row():
+                af_m = gr.Dropdown(MODELS,
+                                   value=["gherbal-v4", "glotlid", "openlid-v2", "nllb-lid"],
+                                   multiselect=True, label="Models", scale=3)
+                af_b = gr.Dropdown(BENCH_ALL, value="__average__",
+                                   label="Benchmark", scale=2)
+                af_s = gr.Dropdown(SCOPES, value="v4", label="Scope", scale=1)
+            af_c = gr.Plot()
+            af_t = gr.Dataframe(label="African Language Results")
+            def _af(m, b, s):
+                return fn_region(AFRICAN, "African Languages", m, b, s)
+            for w in [af_m, af_b, af_s]:
+                w.change(_af, [af_m, af_b, af_s], [af_c, af_t])
+            demo.load(_af, [af_m, af_b, af_s], [af_c, af_t])
+        # ── Confusions ───────────────────────────────────────────
         with gr.Tab("Confusions"):
+            gr.Markdown("Most confused language pairs. Sorted worst-first.")
             with gr.Row():
+                cf_m = gr.Dropdown(MODELS, value="gherbal-v4",
+                                   label="Model", scale=2)
+                cf_b = gr.Dropdown(BENCHMARKS, value="flores-devtest",
+                                   label="Benchmark", scale=2)
+                cf_s = gr.Dropdown(SCOPES, value="v4", label="Scope", scale=1)
+                cf_min = gr.Slider(1, 500, 50, step=10,
+                                   label="Min samples", scale=1)
+            cf_t = gr.Dataframe(label="Confusion Pairs")
+            for w in [cf_m, cf_b, cf_s, cf_min]:
+                w.change(fn_confusions, [cf_m, cf_b, cf_s, cf_min], cf_t)
+            demo.load(fn_confusions, [cf_m, cf_b, cf_s, cf_min], cf_t)
+        # ── Compare ──────────────────────────────────────────────
         with gr.Tab("Compare"):
+            gr.Markdown("Radar chart across **all 8 benchmarks**.")
             with gr.Row():
+                mc_m = gr.Dropdown(MODELS,
+                                   value=["gherbal-v4", "glotlid", "openlid-v2", "nllb-lid"],
+                                   multiselect=True, label="Models", scale=3)
+                mc_s = gr.Dropdown(SCOPES, value="v4", label="Scope", scale=1)
+            mc_c = gr.Plot()
+            for w in [mc_m, mc_s]:
+                w.change(fn_compare, [mc_m, mc_s], mc_c)
+            demo.load(fn_compare, [mc_m, mc_s], mc_c)
+    gr.HTML(
+        '<div style="text-align:center;padding:16px 0 8px;color:#8A8078;'
+        'font-size:.85em;">'
+        'Data: <a href="https://huggingface.co/datasets/omneity-labs/'
+        'lid-benchmark" style="color:#C4962C;">omneity-labs/lid-benchmark</a>'
+        ' \u00b7 Model: <a href="https://www.omneitylabs.com/models/gherbal"'
+        ' style="color:#C4962C;">Gherbal</a>'
+        ' \u00b7 <a href="https://omarkamali.com" style="color:#C4962C;">'
+        'Omar Kamali</a>'
+        ' \u00b7 <a href="https://www.omneitylabs.com" style="color:#C4962C;">'
+        'Omneity Labs</a></div>'
+    )
 if __name__ == "__main__":
+    print("[startup] launching (SSR off)...", flush=True)
+    demo.launch(ssr_mode=False, server_name="0.0.0.0")