new ui

app.py

@@ -14,11 +14,9 @@ import gradio as gr
 import pandas as pd
 
 from ui import (
-    render_about,
-    render_benchmarks,
     render_footer,
     render_header,
-    render_home,
+    render_image_workspace,
 )
 
 # Visual tokens from https://www.pruna.ai/ and https://playground.pruna.ai/
@@ -165,7 +163,8 @@ body, .gradio-container {
 .benchmark-catalogue,
 .benchmark-detail,
 .benchmark-panel,
-.leaderboard-controls {
+.leaderboard-controls,
+.view-filters {
     max-width: 100% !important;
 }
 
@@ -388,7 +387,8 @@ button.theme-toggle[data-mode="light"] .theme-icon-moon { display: block !import
     .benchmark-catalogue,
     .benchmark-detail,
     .benchmark-panel,
-    .leaderboard-controls {
+    .leaderboard-controls,
+    .view-filters {
         min-width: 0 !important;
         max-width: 100% !important;
     }
@@ -471,12 +471,17 @@ button.theme-toggle[data-mode="light"] .theme-icon-moon { display: block !import
     }
     .leaderboard-controls,
     .leaderboard-controls.row,
-    .leaderboard-controls .form {
+    .leaderboard-controls .form,
+    .view-filters,
+    .view-filters.row,
+    .view-filters .form {
         flex-direction: column !important;
         align-items: stretch !important;
     }
     .leaderboard-controls > div,
-    .leaderboard-controls .form > div {
+    .leaderboard-controls .form > div,
+    .view-filters > div,
+    .view-filters .form > div {
         flex: 1 1 auto !important;
         width: 100% !important;
         max-width: 100% !important;
@@ -568,7 +573,58 @@ button.theme-toggle[data-mode="light"] .theme-icon-moon { display: block !import
     }
 }
 
-/* —— Benchmark view menu (Leaderboard / Graphs / Compare) —— */
+/* —— Benchmark view menu (Leaderboards / Pareto plots / Compare) —— */
+.view-filters {
+    display: flex !important;
+    flex-wrap: wrap !important;
+    align-items: end !important;
+    gap: 10px !important;
+    margin: 0 0 8px;
+}
+.view-filters > div {
+    min-width: 0 !important;
+}
+.view-filters > .block,
+.view-filters .form,
+.view-filters .block {
+    border: none !important;
+    background: transparent !important;
+    box-shadow: none !important;
+    padding: 0 !important;
+    --block-border-width: 0 !important;
+}
+.view-filters label {
+    color: var(--pruna-text-muted) !important;
+    font-size: 0.8rem !important;
+    font-weight: 500 !important;
+}
+.view-filters .wrap,
+.view-filters .wrap-inner,
+.view-filters .secondary-wrap {
+    min-height: 40px !important;
+    border: 1px solid var(--pruna-input-border) !important;
+    border-radius: 10px !important;
+    background: var(--pruna-input-bg) !important;
+    box-shadow: none !important;
+}
+.view-title,
+.view-title.block,
+.view-title .padded {
+    border: none !important;
+    background: transparent !important;
+    box-shadow: none !important;
+    padding: 0 !important;
+    margin: 0 0 8px !important;
+}
+.view-title h1,
+.view-title .prose h1,
+.gradio-container .view-title h1 {
+    margin: 0.35rem 0 0.4rem !important;
+    font-size: 1.45rem !important;
+}
+.workspace-back-btn,
+.workspace-back-btn.block,
+.workspace-back-btn .padded,
 .benchmark-back-btn,
 .benchmark-back-btn.block,
 .benchmark-back-btn .padded {
@@ -580,6 +636,10 @@ button.theme-toggle[data-mode="light"] .theme-icon-moon { display: block !import
     background: transparent !important;
     box-shadow: none !important;
 }
+.workspace-back-btn button,
+.workspace-back-btn button.secondary,
+.workspace-back-btn button.lg,
+.workspace-back-btn button.sm,
 .benchmark-back-btn button,
 .benchmark-back-btn button.secondary,
 .benchmark-back-btn button.lg,
@@ -603,6 +663,7 @@ button.theme-toggle[data-mode="light"] .theme-icon-moon { display: block !import
     letter-spacing: -0.01em !important;
     line-height: 1.4 !important;
 }
+.workspace-back-btn button:hover,
 .benchmark-back-btn button:hover {
     color: var(--pruna-link) !important;
     background: transparent !important;
@@ -2227,6 +2288,7 @@ def load_qwen_combined_dataframe(path):
         "P-Judge Overall",
         "Rapidata Elo",
         "Datapoint Elo",
+        "Benchmark.ai Elo",
     ]:
         if column in df.columns:
             df[column] = pd.to_numeric(df[column], errors="coerce")
@@ -2279,6 +2341,7 @@ oneig_display_columns = [
         "Endpoint Owner",
         "Model",
         "Optimized",
+        "OneIG Overall Score",
         *oneig_metric_columns,
         "OneIG Anime Elo",
         "OneIG Human Elo",
@@ -2293,8 +2356,6 @@ oneig_display_columns = [
     ]
     if col in oneig_df.columns
 ]
-# Top-level Leaderboard tab uses the same OneIG table.
-display_columns = oneig_display_columns
 
 oneig_combined_dir = _resolve_data_path(
     data_dir / "oneig_combined",
@@ -2310,87 +2371,152 @@ qwen_path = _resolve_data_path(
 )
 
 qwen_df = load_qwen_combined_dataframe(qwen_path)
-qwen_score_columns = [
+qwen_display_columns = [
     col
     for col in [
-        "P-Judge Overall",
+        "Model",
         "Datapoint Elo",
         "Rapidata Elo",
+        "P-Judge Overall",
+        "Raw Win Rate",
+        "Median Generation Time (s)",
+        "Min Generation Time (s)",
+        "Price / Image (USD)",
     ]
     if col in qwen_df.columns
 ]
-qwen_display_columns = [
+aa_display_columns = [
     col
     for col in [
         "Model",
-        *qwen_score_columns,
-        "Raw Win Rate",
+        "Benchmark.ai Elo",
         "Median Generation Time (s)",
         "Min Generation Time (s)",
         "Price / Image (USD)",
     ]
     if col in qwen_df.columns
 ]
-qwen_overall_column = (
-    "Datapoint Elo"
-    if "Datapoint Elo" in qwen_df.columns
-    else (qwen_score_columns[0] if qwen_score_columns else None)
-)
 
 oneig_samples = load_sample_comparison_data(oneig_combined_dir)
 qwen_samples = load_sample_comparison_data(qwen_combined_dir)
 
-# Dataset-first catalogue: each card is a prompt suite; metrics are leaderboard columns.
-benchmarks = [
+metrics = [
     {
-        "id": "oneig",
-        "title": "OneIG Alignment",
-        "emoji": "🎯",
-        "card_description": (
-            "Anime/stylization, portrait, and general-object alignment prompts: "
-            "alignment scores and Datapoint Elo (not the full OneIG suite), plus "
-            "side-by-side generations."
-        ),
-        "intro": (
-            "OneIG Alignment covers the alignment slice of OneIG (not every OneIG "
-            "dimension). The leaderboard shows category alignment scores and Datapoint "
-            "Elo columns; Compare samples uses the combined alignment generations."
+        "id": "datapoint_elo",
+        "name": "Datapoint ELO - Overall Metric",
+        "column": "Datapoint Elo",
+    },
+    {
+        "id": "rapidata_elo",
+        "name": "Rapidata ELO - Overall Metric",
+        "column": "Rapidata Elo",
+    },
+    {
+        "id": "pjudger",
+        "name": "P-Judger Overall Metric",
+        "column": "P-Judge Overall",
+    },
+    {
+        "id": "alignment_overall",
+        "name": "Alignment - Overall Metric",
+        "column": "OneIG Overall Score",
+    },
+    {
+        "id": "datapoint_elo_anime",
+        "name": "Datapoint ELO - Anime Metric",
+        "column": "OneIG Anime Elo",
+    },
+    {
+        "id": "datapoint_elo_human",
+        "name": "Datapoint ELO - Human Metric",
+        "column": "OneIG Human Elo",
+    },
+    {
+        "id": "datapoint_elo_object",
+        "name": "Datapoint ELO - Object Metric",
+        "column": "OneIG Object Elo",
+    },
+    {
+        "id": "aa_elo",
+        "name": "Artificial Analysis ELO Metric",
+        "column": "Benchmark.ai Elo",
+    },
+]
+
+
+def _metric_ids_for(data, metric_ids):
+    columns = getattr(data, "columns", [])
+    return [
+        metric_id
+        for metric_id in metric_ids
+        if any(metric["id"] == metric_id and metric["column"] in columns for metric in metrics)
+    ]
+
+
+qwen_metric_ids = _metric_ids_for(
+    qwen_df, ["datapoint_elo", "rapidata_elo", "pjudger"]
+)
+oneig_metric_ids = _metric_ids_for(
+    oneig_df,
+    [
+        "alignment_overall",
+        "rapidata_elo",
+        "pjudger",
+        "datapoint_elo_anime",
+        "datapoint_elo_human",
+        "datapoint_elo_object",
+    ],
+)
+aa_metric_ids = _metric_ids_for(qwen_df, ["aa_elo"])
+
+datasets = [
+    {
+        "id": "qwen",
+        "name": "Qwen Image Dataset",
+        "data": qwen_df,
+        "columns": qwen_display_columns,
+        "metric_ids": qwen_metric_ids,
+        "note": (
+            "> Ranked by the selected metric on the Qwen Image Dataset. "
+            "Rapidata Elo is a metric on this dataset, not a dataset of its own."
         ),
+        "samples": qwen_samples,
+    },
+    {
+        "id": "oneig",
+        "name": "OneIG Alignment Dataset",
         "data": oneig_df,
         "columns": oneig_display_columns,
-        "score_columns": oneig_metric_columns,
-        "overall_column": "OneIG Overall Score",
+        "metric_ids": oneig_metric_ids,
         "note": (
-            "> Rankings are ordered by the mean of the available alignment category "
-            "scores. Missing category scores are not included in that model's mean."
+            "> Alignment Overall is the mean of the available category scores. "
+            "Missing categories are skipped for that model."
         ),
         "samples": oneig_samples,
     },
     {
-        "id": "qwen_image_bench",
-        "title": "Qwen Image Bench",
-        "emoji": "🖼️",
-        "card_description": (
-            "Qwen image-bench prompts with P-Judger (Pruna's judge), Datapoint Elo, "
-            "and Rapidata Elo as metric columns, plus combined generations for comparison."
-        ),
-        "intro": (
-            "Qwen Image Bench is a shared prompt suite. The leaderboard joins every "
-            "available metric for this benchmark; Compare samples uses the combined "
-            "Qwen generations."
-        ),
+        "id": "artificial_analysis",
+        "name": "Artificial Analysis Dataset",
         "data": qwen_df,
-        "columns": qwen_display_columns,
-        "score_columns": qwen_score_columns,
-        "overall_column": qwen_overall_column,
+        "columns": aa_display_columns,
+        "metric_ids": aa_metric_ids,
         "note": (
-            "> Models are ordered by Datapoint Elo when available. Other metric "
-            "columns come from Pruna's P-Judger and the Rapidata evaluation on the "
-            "same prompt suite."
+            "> Ranked by Artificial Analysis Elo from the evaluation table."
         ),
         "samples": qwen_samples,
     },
 ]
+datasets = [dataset for dataset in datasets if dataset["metric_ids"]]
+
+DEFAULT_DATASET_ID = next(
+    (dataset["id"] for dataset in datasets if dataset["id"] == "qwen"),
+    datasets[0]["id"] if datasets else None,
+)
+DEFAULT_METRIC_ID = (
+    "datapoint_elo"
+    if DEFAULT_DATASET_ID == "qwen" and "datapoint_elo" in qwen_metric_ids
+    else (datasets[0]["metric_ids"][0] if datasets else None)
+)
 
 
 custom_head = """
@@ -2615,17 +2741,12 @@ with gr.Blocks(
     head=custom_head,
 ) as demo:
     render_header()
-    with gr.Tabs(elem_classes="main-tabs"):
-        with gr.TabItem("Home"):
-            render_home(benchmarks)
-        with gr.TabItem("About"):
-            render_about()
-        with gr.TabItem("Benchmarks") as benchmarks_tab:
-            reset_benchmarks, reset_benchmark_outputs = render_benchmarks(benchmarks)
-            benchmarks_tab.select(
-                reset_benchmarks,
-                outputs=reset_benchmark_outputs,
-            )
+    render_image_workspace(
+        datasets,
+        metrics,
+        DEFAULT_DATASET_ID,
+        DEFAULT_METRIC_ID,
+    )
     render_footer()
 
 

ui.py

@@ -24,18 +24,18 @@ ABOUT_OVERVIEW_CONTENT = """
 # About P-Bench
 
 P-Bench compares **text-to-image models**, including optimized or accelerated
-endpoints, on **quality, speed, and price**. Results are split by prompt suite;
-there is no single score across P-Bench.
+endpoints, on **quality, speed, and price**. Each view is a **dataset** scored
+with a **metric**, written as `Dataset | Metric`. There is no single score
+across P-Bench.
 
 ## How to read it
 
-1. Open a **prompt suite** on the Benchmarks tab.
-2. **Leaderboard**: sort by a quality or preference column. Price and generation
-   time sit in the same table.
-3. **Graphs**: Pareto plots mark models that are not beaten on both higher score
+1. Pick a **dataset** and a **metric**. The title is always Dataset | Metric.
+2. **Leaderboards**: ranked by that metric. Price and generation time sit in
+   the same table.
+3. **Pareto plots**: mark models that are not beaten on both higher score
    and lower price (or time).
-4. **Compare samples**: the same prompts, side by side. Sample images are
-   available for OneIG Alignment today.
+4. **Samples**: the same prompts, side by side.
 
 ## How a score is made
 
@@ -43,20 +43,26 @@ there is no single score across P-Bench.
 2. It generates one image per prompt when the run succeeds. Not every model
    has every prompt or every metric.
 3. Quality is scored automatically (OneIG alignment, P-Judger) and, where
-   available, by human preference (Datapoint Elo, Rapidata Elo).
+   available, by human preference (Datapoint Elo, Rapidata Elo) or by
+   Artificial Analysis Elo.
 4. Price per image and generation time are joined from the evaluation table.
 
-## Current prompt suites
+## Current datasets
 
-### OneIG Alignment
+### Qwen Image Dataset
+100 prompts from the 1,000-prompt Qwen Image Bench set, sampled for coverage
+across its fine-grained (L3) categories. Metrics include Datapoint Elo,
+Rapidata Elo, and P-Judger.
+
+### OneIG Alignment Dataset
 Prompt-image **alignment** on anime / stylization, human / portrait, and
 general object prompts (100 prompts each). This is the alignment slice of
-OneIG, not the full suite. Default rank is the mean of the alignment
-categories that exist for that row.
+OneIG, not the full suite. Alignment Overall is the mean of the category
+scores that exist for that row.
 
-### Qwen Image Bench
-100 prompts from the 1,000-prompt Qwen Image Bench set, sampled for coverage
-across its fine-grained (L3) categories.
+### Artificial Analysis Dataset
+Artificial Analysis Elo from the evaluation table. Rapidata is a **metric**,
+not a dataset.
 """
 
 ABOUT_DETAILS_CONTENT = """
@@ -72,16 +78,18 @@ ABOUT_DETAILS_CONTENT = """
 - **Datapoint Elo**: human-preference Elo from Datapoint pairwise comparisons.
 - **Rapidata Elo**: human-preference Elo from Rapidata pairwise comparisons.
   Rapidata rejects prompts over 400 characters, so this Elo is on a subset
-  of each suite (see Setup).
+  of each suite (see Setup). Rapidata is not a dataset.
+- **Artificial Analysis Elo**: preference Elo from Artificial Analysis, shown
+  as its own dataset.
 - **Generation time**: median and minimum generation time in seconds, as
   reported in the evaluation table. This is not a p95, and we do not state
   warm vs cold or concurrent load.
 - **Price**: USD per image in the evaluation table. We do not state list
   price vs amount paid, or whether failed generations are included.
 
-Scores from different suites or columns are **not interchangeable**. A high
+Scores from different datasets or metrics are **not interchangeable**. A high
 OneIG alignment score is not the same quantity as a Datapoint Elo. Compare
-models *within* a column.
+models *within* a Dataset | Metric view.
 
 ## Setup
 
@@ -89,7 +97,7 @@ models *within* a column.
 - **Update policy:** numbers come from evaluation snapshots in the tables,
   not a live API poll.
 - **Prompt counts:** OneIG Alignment uses the first 100 prompts from each of
-  the three categories (300 total). Qwen Image Bench uses 100 prompts sampled
+  the three categories (300 total). Qwen Image Dataset uses 100 prompts sampled
   from the 1,000-prompt pool for roughly even coverage of its fine-grained
   (L3) categories.
 - **Generation:** one image per prompt per endpoint when the run exists.
@@ -101,14 +109,14 @@ models *within* a column.
 - **Datapoint:** every model pair is compared on every prompt, with 10 votes
   per battle.
 - **Rapidata:** prompts longer than 400 characters are dropped, leaving 212
-  OneIG prompts and 85 Qwen Image Bench prompts. 4 votes per pair; about
-  26,000 votes on OneIG and 35,000 on Qwen Image Bench.
+  OneIG prompts and 85 Qwen Image Dataset prompts. 4 votes per pair; about
+  26,000 votes on OneIG and 35,000 on Qwen Image Dataset.
 
 ## Limits
 
 - Empty cells mean that track was not run or not reported for that model.
 - Rapidata Elo is not on the full prompt suite, so it is not directly
-  comparable to Datapoint Elo even on the same benchmark.
+  comparable to Datapoint Elo even on the same dataset.
 - Elo ratings can shift when the comparison pool changes: treat them as
   relative rankings for the snapshot, not absolute constants.
 - Close scores can be a tie in practice; the table does not show confidence
@@ -171,119 +179,83 @@ def render_header():
     )
 
 
-def _top_models(data, score_column, n=3):
-    if score_column not in data.columns or "Model" not in data.columns:
-        return []
-    ranked = (
-        data[["Model", score_column]]
-        .dropna(subset=[score_column])
-        .loc[lambda df: ~df["Model"].astype(str).str.startswith("#")]
-        .sort_values(score_column, ascending=False)
-        .head(n)
-    )
-    return [
-        (str(row["Model"]), float(row[score_column]))
-        for _, row in ranked.iterrows()
-    ]
+def _item(items, item_id):
+    for item in items:
+        if item["id"] == item_id:
+            return item
+    return items[0] if items else None
 
 
-def _home_highlights(benchmarks):
-    """Quality leaders per suite: more relevant than cheapest/fastest outliers."""
-    highlights = []
-    unique_models = set()
-    for benchmark in benchmarks:
-        data = benchmark.get("data")
-        if data is None or "Model" not in getattr(data, "columns", []):
-            continue
-        active = data[~data["Model"].astype(str).str.startswith("#")]
-        unique_models.update(active["Model"].astype(str).tolist())
-
-        score_column = benchmark.get("overall_column")
-        score_columns = benchmark.get("score_columns") or []
-        if not score_column or score_column not in data.columns:
-            score_column = score_columns[0] if score_columns else None
-        top = _top_models(data, score_column, n=1) if score_column else []
-        if not top:
-            continue
-        model, score = top[0]
-        highlights.append(
-            {
-                "label": f"BEST {benchmark['title'].upper()}",
-                "model": model,
-                "detail": f"{_display_label(score_column)} · {_format_score(score)}",
-            }
-        )
+def _dataset_choices(datasets):
+    return [(dataset["name"], dataset["id"]) for dataset in datasets]
 
-    if unique_models:
-        highlights.append(
-            {
-                "label": "MODELS SCORED",
-                "model": str(len(unique_models)),
-                "detail": "unique across prompt suites",
-            }
-        )
-    return highlights
 
+def _metric_choices(datasets, metrics, dataset_id):
+    dataset = _item(datasets, dataset_id)
+    if not dataset:
+        return []
+    allowed = set(dataset.get("metric_ids") or [])
+    data = dataset.get("data")
+    columns = getattr(data, "columns", [])
+    return [
+        (metric["name"], metric["id"])
+        for metric in metrics
+        if metric["id"] in allowed and metric["column"] in columns
+    ]
 
-def render_home(benchmarks):
-    highlights = _home_highlights(benchmarks)
 
-    gr.Markdown(
-        """
-        P-Bench ranks **text-to-image models** on quality, speed, and price using
-        the same prompt suites. Open a benchmark for tables, Pareto graphs, and
-        sample comparisons.
-        """,
-        elem_classes="home-intro",
-    )
+def _coerce_metric(datasets, metrics, dataset_id, metric_id):
+    choices = _metric_choices(datasets, metrics, dataset_id)
+    ids = [choice[1] for choice in choices]
+    if metric_id in ids:
+        return metric_id
+    return ids[0] if ids else None
 
-    if highlights:
-        callout_bits = [
-            f"<div><span>{escape(item['label'])}</span>"
-            f"<strong>{escape(item['model'])}</strong>"
-            f"<em>{escape(item['detail'])}</em></div>"
-            for item in highlights
-        ]
-        gr.HTML(
-            f'<div class="home-callouts">{"".join(callout_bits)}</div>',
-            padding=False,
-            elem_classes="home-callouts-host",
-        )
 
-    gr.Markdown("## Benchmark snapshots", elem_classes="home-section-title")
-    cards = []
-    for benchmark in benchmarks:
-        data = benchmark["data"]
-        score_column = benchmark.get("overall_column")
-        score_columns = benchmark.get("score_columns") or []
-        if not score_column or score_column not in data.columns:
-            score_column = score_columns[0] if score_columns else None
-        top = _top_models(data, score_column, n=3) if score_column else []
-        score_label = _display_label(score_column) if score_column else "Score"
-        rows_html = "".join(
-            f"<li><span class='home-rank'>{idx}</span>"
-            f"<span class='home-model'>{escape(model)}</span>"
-            f"<span class='home-score'>{_format_score(score)}</span></li>"
-            for idx, (model, score) in enumerate(top, start=1)
-        ) or "<li class='home-empty'>No scores yet.</li>"
-        cards.append(
-            "<article class='home-snap-card'>"
-            "<div class='home-snap-title'>"
-            f"<span class='home-snap-emoji' aria-hidden='true'>{escape(benchmark.get('emoji', '📊'))}</span>"
-            f"<span>{escape(benchmark['title'])}</span>"
-            "</div>"
-            f"<p class='home-snap-blurb'>{escape(benchmark.get('card_description', ''))}</p>"
-            "<div class='home-snap-top'>"
-            f"<div class='home-top-label'>Top 3 by {escape(score_label)}</div>"
-            f"<ol class='home-top-list'>{rows_html}</ol>"
-            "</div>"
-            "</article>"
-        )
-    gr.HTML(
-        f"<div class='home-snapshots-grid'>{''.join(cards)}</div>",
-        padding=False,
-        elem_classes="home-snapshots-host",
-    )
+def _model_choices(datasets, dataset_id):
+    dataset = _item(datasets, dataset_id)
+    data = dataset.get("data") if dataset else None
+    if data is None or "Model" not in getattr(data, "columns", []):
+        return []
+    return sorted(data["Model"].dropna().astype(str).unique().tolist())
+
+
+def _view_title(datasets, metrics, dataset_id, metric_id):
+    dataset = _item(datasets, dataset_id)
+    metric = _item(metrics, metric_id)
+    dataset_name = dataset["name"] if dataset else "Dataset"
+    metric_name = metric["name"] if metric else "Metric"
+    return f"{dataset_name} | {metric_name}"
+
+
+def _columns_for_metric(dataset, metric_column):
+    columns = list(dataset.get("columns") or [])
+    if metric_column and metric_column not in columns:
+        identity = {"Model", "Platform", "Endpoint Owner", "Optimized"}
+        insert_at = 0
+        for index, column in enumerate(columns):
+            if column in identity:
+                insert_at = index + 1
+        columns.insert(insert_at, metric_column)
+    return columns
+
+
+def resolve_view(datasets, metrics, dataset_id, metric_id):
+    dataset = _item(datasets, dataset_id)
+    metric_id = _coerce_metric(datasets, metrics, dataset_id, metric_id)
+    metric = _item(metrics, metric_id)
+    if not dataset or not metric:
+        return None
+    return {
+        "dataset": dataset,
+        "metric": metric,
+        "title": _view_title(datasets, metrics, dataset["id"], metric["id"]),
+        "data": dataset["data"],
+        "columns": _columns_for_metric(dataset, metric["column"]),
+        "score_column": metric["column"],
+        "samples": dataset.get("samples"),
+        "note": dataset.get("note"),
+    }
 
 
 def _format_leaderboard_cell(column, value):
@@ -390,121 +362,17 @@ def _leaderboard_html(data, columns, score_columns, overall_column):
     """
 
 
-def render_leaderboard(
-    data,
-    columns,
-    note=None,
-    score_columns=None,
-    overall_column=None,
-):
-    score_columns = list(score_columns or _infer_score_columns(columns))
-    overall_column = overall_column or _default_overall_column(score_columns)
-    platform_choices = _filter_choices(data, "Platform")
-    owner_choices = _filter_choices(data, "Endpoint Owner")
-    optimized_choices = _filter_choices(data, "Optimized")
-
-    if note:
-        gr.Markdown(note)
-
-    filter_inputs = []
-    with gr.Row(elem_classes="leaderboard-controls"):
-        search = gr.Textbox(
-            label="Search models",
-            placeholder="Type a model or provider name…",
-            scale=3,
-            max_lines=1,
-            elem_classes="leaderboard-search",
-        )
-        filter_inputs.append(search)
-        platform = None
-        owner = None
-        optimized = None
-        if platform_choices:
-            platform = gr.Dropdown(
-                choices=platform_choices,
-                value=[],
-                label="Providers",
-                multiselect=True,
-                scale=1,
-            )
-            filter_inputs.append(platform)
-        if owner_choices:
-            owner = gr.Dropdown(
-                choices=owner_choices,
-                value=[],
-                label="Endpoint owners",
-                multiselect=True,
-                scale=1,
-            )
-            filter_inputs.append(owner)
-        if optimized_choices:
-            optimized = gr.Dropdown(
-                choices=optimized_choices,
-                value=[],
-                label="Optimized",
-                multiselect=True,
-                scale=1,
-            )
-            filter_inputs.append(optimized)
-
-    ranking = gr.HTML(
-        _leaderboard_html(data, columns, score_columns, overall_column),
-        padding=False,
-        elem_classes="ranking-table-host",
-    )
-
-    def update_ranking(
-        search_term,
-        platform_value=None,
-        owner_value=None,
-        optimized_value=None,
-    ):
-        filtered_data = _filter_leaderboard(
-            data,
-            search_term,
-            platform_value or [],
-            owner_value or [],
-            optimized_value or [],
-        )
-        return _leaderboard_html(
-            filtered_data, columns, score_columns, overall_column
-        )
-
-    # Wire only the filters that actually exist for this table.
-    change_inputs = [search]
-    if platform is not None:
-        change_inputs.append(platform)
-    if owner is not None:
-        change_inputs.append(owner)
-    if optimized is not None:
-        change_inputs.append(optimized)
-
-    for component in filter_inputs:
-        component.change(
-            update_ranking,
-            inputs=change_inputs,
-            outputs=ranking,
-        )
-
-
-def _infer_score_columns(columns):
-    return [column for column in columns if column.startswith("OneIG (")]
-
-
-def _default_overall_column(score_columns):
-    if len(score_columns) == 1:
-        return score_columns[0]
-    return "OneIG Overall Score"
-
-
 def _filter_choices(data, column):
-    if column not in data.columns:
+    if data is None or column not in data.columns:
         return []
     return sorted(data[column].dropna().astype(str).unique().tolist())
 
 
-def _filter_leaderboard(data, search_term, platform, owner, optimized):
+def _filter_leaderboard(data, search_term, platform, owner, optimized, models=None):
     filtered = data.copy()
+    if models:
+        if "Model" in filtered.columns:
+            filtered = filtered[filtered["Model"].astype(str).isin(models)]
     if search_term:
         search_columns = [
             column
@@ -528,9 +396,7 @@ def _filter_leaderboard(data, search_term, platform, owner, optimized):
     return filtered
 
 
-def _leaderboard_dataframe(data, columns, score_columns, overall_column):
-    # Honor the caller-provided column list so extra metrics (e.g. Elo) are not
-    # dropped just because they are not part of the ranking score_columns.
+def _leaderboard_dataframe(data, columns, score_columns, overall_column):  # noqa: ARG001
     skip_columns = {"URL", "Rank"}
     preferred_prefix = [
         column
@@ -548,8 +414,6 @@ def _leaderboard_dataframe(data, columns, score_columns, overall_column):
         ]
         if column in data.columns
     ]
-    # Keep overall_column visible when the caller includes it (e.g. Datapoint Elo).
-    # Synthetic aggregates like OneIG Overall Score are simply omitted from `columns`.
     middle = [
         column
         for column in columns
@@ -558,6 +422,14 @@ def _leaderboard_dataframe(data, columns, score_columns, overall_column):
         and column not in preferred_prefix
         and column not in preferred_suffix
     ]
+    if (
+        overall_column
+        and overall_column in data.columns
+        and overall_column not in middle
+        and overall_column not in preferred_prefix
+        and overall_column not in preferred_suffix
+    ):
+        middle.insert(0, overall_column)
 
     ordered_columns = []
     seen = set()
@@ -568,7 +440,6 @@ def _leaderboard_dataframe(data, columns, score_columns, overall_column):
 
     leaderboard = data[ordered_columns].copy()
 
-    # Rank by overall when available, even if that column is not displayed.
     if overall_column and overall_column in data.columns:
         leaderboard = (
             leaderboard.assign(_sort_key=data[overall_column])
@@ -596,7 +467,7 @@ def _display_label(column):
         "P-Judge Overall": "P-Judger (Pruna)",
         "Datapoint Elo": "Datapoint Elo",
         "Rapidata Elo": "Rapidata Elo",
-        "Benchmark.ai Elo": "Benchmark.ai Elo",
+        "Benchmark.ai Elo": "Artificial Analysis Elo",
         "Raw Win Rate": "Raw win rate",
         "Median Generation Time (s)": "Median generation time",
         "Min Generation Time (s)": "Min generation time",
@@ -607,314 +478,10 @@ def _display_label(column):
     return labels.get(column, column)
 
 
-def _format_score(value):
-    return "-" if pd.isna(value) or value is None else f"{float(value):.3f}"
-
-
 def _format_price(value):
     return "-" if pd.isna(value) or value is None else f"${float(value):.3f}"
 
 
-def render_benchmark_detail(benchmark):
-    gr.Markdown(
-        f"""
-        # {benchmark["title"]}
-
-        {benchmark["intro"]}
-        """
-    )
-    view_menu = gr.Radio(
-        choices=["Leaderboard", "Graphs", "Compare samples"],
-        value="Leaderboard",
-        show_label=False,
-        container=False,
-        elem_classes="benchmark-view-menu",
-    )
-    with gr.Column(visible=True, min_width=0, elem_classes="benchmark-panel") as leaderboard_view:
-        render_leaderboard(
-            benchmark["data"],
-            benchmark["columns"],
-            note=benchmark.get("note"),
-            score_columns=benchmark.get("score_columns"),
-            overall_column=benchmark.get("overall_column"),
-        )
-    with gr.Column(visible=False, min_width=0, elem_classes="benchmark-panel") as graphs_view:
-        render_benchmark_graphs(benchmark)
-    with gr.Column(visible=False, min_width=0, elem_classes="benchmark-panel") as compare_view:
-        render_compare_samples(benchmark)
-
-    def switch_view(choice):
-        return (
-            gr.update(visible=choice == "Leaderboard"),
-            gr.update(visible=choice == "Graphs"),
-            gr.update(visible=choice == "Compare samples"),
-        )
-
-    view_menu.change(
-        switch_view,
-        inputs=view_menu,
-        outputs=[leaderboard_view, graphs_view, compare_view],
-    )
-
-
-def render_compare_samples(benchmark):
-    samples = benchmark.get("samples")
-    if not samples:
-        gr.Markdown(
-            """
-            Sample comparison is not available for this benchmark yet.
-
-            When generations are linked, you will be able to pick models and browse
-            side-by-side outputs for the same prompts.
-            """
-        )
-        return
-
-    models = samples["models"]
-    default_models = models[: min(2, len(models))]
-
-    gr.Markdown(
-        f"""
-        <p class="compare-samples-help">
-        Pick up to <strong>{MAX_COMPARE_MODELS}</strong> models to compare side by
-        side. Images come from the public generation URLs for this benchmark.
-        Prompts to show chooses how many shared prompts appear (1–{MAX_COMPARE_PROMPTS}).
-        </p>
-        """
-    )
-    with gr.Row(equal_height=False, elem_classes="compare-controls"):
-        model_picker = gr.Dropdown(
-            choices=models,
-            value=default_models,
-            multiselect=True,
-            max_choices=MAX_COMPARE_MODELS,
-            label="Models",
-            container=False,
-            scale=4,
-            min_width=220,
-            elem_classes="compare-models",
-        )
-        prompt_count = gr.Slider(
-            minimum=1,
-            maximum=MAX_COMPARE_PROMPTS,
-            value=DEFAULT_COMPARE_PROMPTS,
-            step=1,
-            label="Prompts to show",
-            container=False,
-            show_reset_button=False,
-            scale=1,
-            min_width=180,
-            elem_classes="compare-prompt-count",
-        )
-        shuffle_button = gr.Button(
-            "Shuffle prompts",
-            variant="primary",
-            scale=0,
-            min_width=140,
-            elem_classes="compare-shuffle",
-        )
-
-    gallery = gr.HTML(
-        value=_build_compare_samples_html(
-            samples,
-            default_models,
-            DEFAULT_COMPARE_PROMPTS,
-            seed=0,
-        ),
-        elem_classes="compare-gallery",
-    )
-    seed_state = gr.State(0)
-
-    def update_gallery(selected_models, num_prompts, seed):
-        return _build_compare_samples_html(
-            samples,
-            selected_models,
-            int(num_prompts),
-            seed=int(seed or 0),
-        )
-
-    def shuffle_gallery(selected_models, num_prompts, seed):
-        next_seed = int(seed or 0) + 1
-        return next_seed, _build_compare_samples_html(
-            samples,
-            selected_models,
-            int(num_prompts),
-            seed=next_seed,
-        )
-
-    model_picker.change(
-        update_gallery,
-        inputs=[model_picker, prompt_count, seed_state],
-        outputs=gallery,
-    )
-    prompt_count.change(
-        update_gallery,
-        inputs=[model_picker, prompt_count, seed_state],
-        outputs=gallery,
-    )
-    shuffle_button.click(
-        shuffle_gallery,
-        inputs=[model_picker, prompt_count, seed_state],
-        outputs=[seed_state, gallery],
-    )
-
-
-def _build_compare_samples_html(samples, selected_models, num_prompts, seed=0):
-    selected_models = [
-        model
-        for model in (selected_models or [])
-        if model in samples["images"]
-    ][:MAX_COMPARE_MODELS]
-
-    if not selected_models:
-        return (
-            '<div class="compare-empty">'
-            "Select at least one model to compare samples."
-            "</div>"
-        )
-
-    shared_prompt_ids = None
-    for model in selected_models:
-        model_prompt_ids = set(samples["images"][model])
-        shared_prompt_ids = (
-            model_prompt_ids
-            if shared_prompt_ids is None
-            else shared_prompt_ids & model_prompt_ids
-        )
-
-    shared_prompt_ids = sorted(shared_prompt_ids or [])
-    if not shared_prompt_ids:
-        return (
-            '<div class="compare-empty">'
-            "No shared prompts found for the selected models."
-            "</div>"
-        )
-
-    rng = random.Random(seed)
-    prompt_pool = list(shared_prompt_ids)
-    rng.shuffle(prompt_pool)
-    chosen = prompt_pool[: max(1, min(int(num_prompts), len(prompt_pool)))]
-
-    columns = len(selected_models)
-    blocks = []
-    for index, prompt_id in enumerate(chosen, start=1):
-        prompt_text = escape(samples["prompts"].get(prompt_id, ""))
-        cells = []
-        for model in selected_models:
-            image_url = escape(samples["images"][model][prompt_id], quote=True)
-            cells.append(
-                f"""
-                <div class="compare-cell">
-                    <div class="compare-model-label">{escape(model)}</div>
-                    <a href="{image_url}" target="_blank" rel="noopener noreferrer">
-                        <img src="{image_url}" alt="{escape(model)} sample" loading="lazy" />
-                    </a>
-                </div>
-                """
-            )
-        blocks.append(
-            f"""
-            <div class="compare-prompt-block">
-                <div class="compare-prompt-meta">
-                    <span>Prompt {index}</span>
-                    <span>{escape(prompt_id)}</span>
-                </div>
-                <p class="compare-prompt-text">{prompt_text}</p>
-                <div class="compare-row" style="grid-template-columns: repeat({columns}, minmax(0, 1fr));">
-                    {''.join(cells)}
-                </div>
-            </div>
-            """
-        )
-
-    return "\n".join(blocks)
-
-
-def render_benchmarks(benchmarks):
-    """Catalogue cards + detail pages; back button returns to the catalogue."""
-    open_buttons = []
-    detail_entries = []
-
-    with gr.Column(visible=True, elem_classes="benchmark-catalogue") as catalogue:
-        gr.Markdown(
-            """
-            # Benchmarks
-
-            Choose a prompt suite. Each one has a **Leaderboard** table, **Graphs**,
-            and **Compare samples**.
-            """
-        )
-        with gr.Row(equal_height=True, elem_classes="benchmark-catalogue-row"):
-            for benchmark in benchmarks:
-                with gr.Column(
-                    scale=1,
-                    min_width=280,
-                    elem_classes="benchmark-card-col",
-                ):
-                    gr.HTML(
-                        f"""
-                        <div class="benchmark-card-body">
-                          <div class="benchmark-card-title">
-                            <span class="benchmark-card-emoji" aria-hidden="true">{escape(benchmark.get("emoji", "📊"))}</span>
-                            <span>{escape(benchmark["title"])}</span>
-                          </div>
-                          <p class="benchmark-card-blurb">
-                            {escape(benchmark.get("card_description", ""))}
-                          </p>
-                        </div>
-                        """,
-                        padding=False,
-                    )
-                    open_buttons.append(
-                        (
-                            benchmark["id"],
-                            gr.Button(
-                                "View benchmark →",
-                                variant="primary",
-                                size="sm",
-                                elem_classes="benchmark-open-btn",
-                            ),
-                        )
-                    )
-
-    for benchmark in benchmarks:
-        with gr.Column(visible=False, min_width=0, elem_classes="benchmark-detail") as detail:
-            back_button = gr.Button(
-                "← All benchmarks",
-                elem_classes="benchmark-back-btn",
-            )
-            render_benchmark_detail(benchmark)
-            detail_entries.append((benchmark["id"], detail, back_button))
-
-    nav_outputs = [catalogue, *[detail for _, detail, _ in detail_entries]]
-
-    def show_catalogue(_evt=None):
-        return (
-            gr.Column(visible=True),
-            *[gr.Column(visible=False) for _ in detail_entries],
-        )
-
-    def show_detail(selected_id):
-        return (
-            gr.Column(visible=False),
-            *[
-                gr.Column(visible=(benchmark_id == selected_id))
-                for benchmark_id, _, _ in detail_entries
-            ],
-        )
-
-    for benchmark_id, button in open_buttons:
-        button.click(
-            lambda selected_id=benchmark_id: show_detail(selected_id),
-            outputs=nav_outputs,
-        )
-
-    for _, _, back_button in detail_entries:
-        back_button.click(show_catalogue, outputs=nav_outputs)
-
-    return show_catalogue, nav_outputs
-
-
 def _pareto_frontier_mask(x_values, scores):
     """True for non-dominated points when maximizing score and minimizing x."""
     n = len(x_values)
@@ -931,6 +498,31 @@ def _pareto_frontier_mask(x_values, scores):
     return mask
 
 
+def _empty_figure(message):
+    fig = go.Figure()
+    fig.add_annotation(
+        text=message,
+        xref="paper",
+        yref="paper",
+        x=0.5,
+        y=0.5,
+        showarrow=False,
+        font={"color": "#a3a3a3", "size": 14},
+    )
+    fig.update_layout(
+        title=None,
+        autosize=True,
+        height=420,
+        margin={"l": 56, "r": 28, "t": 28, "b": 80},
+        plot_bgcolor="#1d1429",
+        paper_bgcolor="#171021",
+        font={"color": "#d4d4d4", "size": 13},
+        xaxis={"visible": False},
+        yaxis={"visible": False},
+    )
+    return fig
+
+
 def _build_pareto_figure(
     data,
     score_column,
@@ -1013,7 +605,6 @@ def _build_pareto_figure(
             "bgcolor": "rgba(0,0,0,0)",
             "font": {"color": "#d4d4d4", "size": 12},
         },
-        # Match Pruna playground surfaces (#120b1b / #1d1429).
         plot_bgcolor="#1d1429",
         paper_bgcolor="#171021",
         font={"color": "#d4d4d4", "size": 13},
@@ -1039,110 +630,661 @@ def _build_pareto_figure(
     return fig
 
 
-def render_benchmark_graphs(benchmark):
-    data = benchmark["data"]
-    score_columns = [
-        column
-        for column in (benchmark.get("score_columns") or [])
-        if column in data.columns
-    ]
-    overall_column = benchmark.get("overall_column")
-
-    if not score_columns and overall_column and overall_column in data.columns:
-        score_columns = [overall_column]
-
-    if not score_columns:
-        gr.Markdown("No score data is available yet.")
-        return
-
-    # Pareto every displayed quality metric vs price.
-    # Skip only synthetic aggregates (e.g. OneIG mean), not real sort keys like Datapoint Elo.
-    pareto_skip = {
-        "Model",
-        "Platform",
-        "Endpoint Owner",
-        "Optimized",
-        "URL",
-        "Rank",
-        "Median Generation Time (s)",
-        "Min Generation Time (s)",
-        "Price / Image (USD)",
-        "Evaluation Date (UTC)",
-        "Date",
-        "Raw Win Rate",
-        "OneIG Overall Score",
-    }
-
-    display_columns = benchmark.get("columns") or []
-    pareto_columns = []
-    for column in [*score_columns, *display_columns]:
-        if (
-            column in data.columns
-            and column not in pareto_skip
-            and column not in pareto_columns
-            and pd.api.types.is_numeric_dtype(data[column])
-        ):
-            pareto_columns.append(column)
+def _pareto_pair(data, score_column):
+    if data is None or not score_column or score_column not in data.columns:
+        empty = _empty_figure("No score data is available yet.")
+        return empty, empty
 
     price_column = "Price / Image (USD)"
     time_column = "Min Generation Time (s)"
-    price_figures = []
-    time_figures = []
-    for plot_column in pareto_columns:
-        if price_column in data.columns:
-            price_fig = _build_pareto_figure(
-                data,
-                plot_column,
-                x_column=price_column,
-                x_title="Price per image (USD)",
-                x_hover_prefix="$",
-            )
-            if price_fig is not None:
-                price_figures.append((plot_column, price_fig))
-        if time_column in data.columns:
-            time_fig = _build_pareto_figure(
-                data,
-                plot_column,
-                x_column=time_column,
-                x_title="Min generation time (s)",
-                x_hover_suffix="s",
+    price_fig = None
+    time_fig = None
+    if price_column in data.columns:
+        price_fig = _build_pareto_figure(
+            data,
+            score_column,
+            x_column=price_column,
+            x_title="Price per image (USD)",
+            x_hover_prefix="$",
+        )
+    if time_column in data.columns:
+        time_fig = _build_pareto_figure(
+            data,
+            score_column,
+            x_column=time_column,
+            x_title="Min generation time (s)",
+            x_hover_suffix="s",
+        )
+    return (
+        price_fig or _empty_figure("No price data available."),
+        time_fig or _empty_figure("No min generation time data available."),
+    )
+
+
+def _samples_html(samples, selected_models, num_prompts, seed=0):
+    if not samples:
+        return (
+            '<div class="compare-empty">'
+            "Sample comparison is not available for this dataset yet."
+            "</div>"
+        )
+    models = list(selected_models or [])
+    available = samples.get("models") or []
+    models = [model for model in models if model in samples.get("images", {})]
+    if not models:
+        models = available[: min(2, len(available))]
+    return _build_compare_samples_html(samples, models, num_prompts, seed)
+
+
+def _build_compare_samples_html(samples, selected_models, num_prompts, seed=0):
+    selected_models = [
+        model
+        for model in (selected_models or [])
+        if model in samples["images"]
+    ][:MAX_COMPARE_MODELS]
+
+    if not selected_models:
+        return (
+            '<div class="compare-empty">'
+            "Select at least one model to compare samples."
+            "</div>"
+        )
+
+    shared_prompt_ids = None
+    for model in selected_models:
+        model_prompt_ids = set(samples["images"][model])
+        shared_prompt_ids = (
+            model_prompt_ids
+            if shared_prompt_ids is None
+            else shared_prompt_ids & model_prompt_ids
+        )
+
+    shared_prompt_ids = sorted(shared_prompt_ids or [])
+    if not shared_prompt_ids:
+        return (
+            '<div class="compare-empty">'
+            "No shared prompts found for the selected models."
+            "</div>"
+        )
+
+    rng = random.Random(seed)
+    prompt_pool = list(shared_prompt_ids)
+    rng.shuffle(prompt_pool)
+    chosen = prompt_pool[: max(1, min(int(num_prompts), len(prompt_pool)))]
+
+    columns = len(selected_models)
+    blocks = []
+    for index, prompt_id in enumerate(chosen, start=1):
+        prompt_text = escape(samples["prompts"].get(prompt_id, ""))
+        cells = []
+        for model in selected_models:
+            image_url = escape(samples["images"][model][prompt_id], quote=True)
+            cells.append(
+                f"""
+                <div class="compare-cell">
+                    <div class="compare-model-label">{escape(model)}</div>
+                    <a href="{image_url}" target="_blank" rel="noopener noreferrer">
+                        <img src="{image_url}" alt="{escape(model)} sample" loading="lazy" />
+                    </a>
+                </div>
+                """
             )
-            if time_fig is not None:
-                time_figures.append((plot_column, time_fig))
-
-    if price_figures or time_figures:
-        gr.Markdown(
-            "### Pareto frontiers\n\n"
-            "<span class='pareto-help'>"
-            "Green = on the frontier (lower cost or time at the same or better score). "
-            "Lavender = below the frontier."
-            "</span><br/>"
-            "<strong class='pareto-help-emphasis'>Hover a point to see which model it is.</strong>"
+        blocks.append(
+            f"""
+            <div class="compare-prompt-block">
+                <div class="compare-prompt-meta">
+                    <span>Prompt {index}</span>
+                    <span>{escape(prompt_id)}</span>
+                </div>
+                <p class="compare-prompt-text">{prompt_text}</p>
+                <div class="compare-row" style="grid-template-columns: repeat({columns}, minmax(0, 1fr));">
+                    {''.join(cells)}
+                </div>
+            </div>
+            """
+        )
+
+    return "\n".join(blocks)
+
+
+def _title_markdown(title):
+    return f"# {title}"
+
+
+def _note_markdown(note):
+    return note or ""
+
+
+def _filter_row(datasets, metrics, default_dataset_id, default_metric_id):
+    metric_choices = _metric_choices(datasets, metrics, default_dataset_id)
+    model_choices = _model_choices(datasets, default_dataset_id)
+    with gr.Row(elem_classes="view-filters"):
+        dataset_dd = gr.Dropdown(
+            choices=_dataset_choices(datasets),
+            value=default_dataset_id,
+            label="Dataset",
+            type="value",
+            scale=2,
+            min_width=160,
+        )
+        metric_dd = gr.Dropdown(
+            choices=metric_choices,
+            value=default_metric_id,
+            label="Metric",
+            type="value",
+            scale=2,
+            min_width=180,
         )
-        with gr.Row(equal_height=False, elem_classes="pareto-layout"):
-            with gr.Column(scale=1, min_width=320, elem_classes="pareto-col"):
-                gr.Markdown("#### Price vs score")
-                if not price_figures:
-                    gr.Markdown("_No price data available._")
-                for plot_column, pareto_fig in price_figures:
-                    gr.Markdown(f"**{_display_label(plot_column)}**")
-                    gr.Plot(
-                        value=pareto_fig,
+        models_dd = gr.Dropdown(
+            choices=model_choices,
+            value=[],
+            multiselect=True,
+            label="Models",
+            type="value",
+            scale=3,
+            min_width=200,
+        )
+    title = gr.Markdown(
+        _title_markdown(
+            _view_title(datasets, metrics, default_dataset_id, default_metric_id)
+        ),
+        elem_classes="view-title",
+    )
+    return dataset_dd, metric_dd, models_dd, title
+
+
+def render_image_workspace(datasets, metrics, default_dataset_id, default_metric_id):
+    default_metric_id = _coerce_metric(
+        datasets, metrics, default_dataset_id, default_metric_id
+    )
+    initial = resolve_view(datasets, metrics, default_dataset_id, default_metric_id)
+    initial_data = initial["data"]
+    initial_columns = initial["columns"]
+    initial_score = initial["score_column"]
+    initial_samples = initial.get("samples")
+    price_fig, time_fig = _pareto_pair(initial_data, initial_score)
+
+    with gr.Tabs(elem_classes="main-tabs"):
+        with gr.TabItem("Leaderboards"):
+            lb_dataset, lb_metric, lb_models, lb_title = _filter_row(
+                datasets, metrics, default_dataset_id, default_metric_id
+            )
+            lb_note = gr.Markdown(_note_markdown(initial.get("note")))
+            platform_choices = _filter_choices(initial_data, "Platform")
+            owner_choices = _filter_choices(initial_data, "Endpoint Owner")
+            optimized_choices = _filter_choices(initial_data, "Optimized")
+            with gr.Row(elem_classes="leaderboard-controls"):
+                search = gr.Textbox(
+                    label="Search models",
+                    placeholder="Type a model or provider name…",
+                    scale=3,
+                    max_lines=1,
+                    elem_classes="leaderboard-search",
+                )
+                platform = gr.Dropdown(
+                    choices=platform_choices,
+                    value=[],
+                    label="Providers",
+                    multiselect=True,
+                    scale=1,
+                    visible=bool(platform_choices),
+                )
+                owner = gr.Dropdown(
+                    choices=owner_choices,
+                    value=[],
+                    label="Endpoint owners",
+                    multiselect=True,
+                    scale=1,
+                    visible=bool(owner_choices),
+                )
+                optimized = gr.Dropdown(
+                    choices=optimized_choices,
+                    value=[],
+                    label="Optimized",
+                    multiselect=True,
+                    scale=1,
+                    visible=bool(optimized_choices),
+                )
+            ranking = gr.HTML(
+                _leaderboard_html(
+                    initial_data, initial_columns, [initial_score], initial_score
+                ),
+                padding=False,
+                elem_classes="ranking-table-host",
+            )
+
+        with gr.TabItem("Pareto Plots"):
+            pp_dataset, pp_metric, pp_models, pp_title = _filter_row(
+                datasets, metrics, default_dataset_id, default_metric_id
+            )
+            gr.Markdown(
+                "<span class='pareto-help'>"
+                "Green = on the frontier (lower cost or time at the same or better score). "
+                "Lavender = below the frontier."
+                "</span><br/>"
+                "<strong class='pareto-help-emphasis'>Hover a point to see which model it is.</strong>"
+            )
+            with gr.Row(equal_height=False, elem_classes="pareto-layout"):
+                with gr.Column(scale=1, min_width=320, elem_classes="pareto-col"):
+                    gr.Markdown("#### Price vs score")
+                    price_plot = gr.Plot(
+                        value=price_fig,
                         show_label=False,
                         elem_classes="pareto-plot",
                     )
-            with gr.Column(scale=1, min_width=320, elem_classes="pareto-col"):
-                gr.Markdown("#### Min generation time vs score")
-                if not time_figures:
-                    gr.Markdown("_No min generation time data available._")
-                for plot_column, pareto_fig in time_figures:
-                    gr.Markdown(f"**{_display_label(plot_column)}**")
-                    gr.Plot(
-                        value=pareto_fig,
+                with gr.Column(scale=1, min_width=320, elem_classes="pareto-col"):
+                    gr.Markdown("#### Min generation time vs score")
+                    time_plot = gr.Plot(
+                        value=time_fig,
                         show_label=False,
                         elem_classes="pareto-plot",
                     )
 
+        with gr.TabItem("Samples"):
+            sm_dataset, sm_metric, sm_models, sm_title = _filter_row(
+                datasets, metrics, default_dataset_id, default_metric_id
+            )
+            gr.Markdown(
+                f"""
+                <p class="compare-samples-help">
+                Filter models above (up to <strong>{MAX_COMPARE_MODELS}</strong> are
+                shown). If none are selected, two defaults appear. Images come from
+                the public generation URLs for this dataset. Prompts to show chooses
+                how many shared prompts appear (1–{MAX_COMPARE_PROMPTS}).
+                </p>
+                """
+            )
+            with gr.Row(equal_height=False, elem_classes="compare-controls"):
+                prompt_count = gr.Slider(
+                    minimum=1,
+                    maximum=MAX_COMPARE_PROMPTS,
+                    value=DEFAULT_COMPARE_PROMPTS,
+                    step=1,
+                    label="Prompts to show",
+                    container=False,
+                    show_reset_button=False,
+                    scale=1,
+                    min_width=180,
+                    elem_classes="compare-prompt-count",
+                )
+                shuffle_button = gr.Button(
+                    "Shuffle prompts",
+                    variant="primary",
+                    scale=0,
+                    min_width=140,
+                    elem_classes="compare-shuffle",
+                )
+            gallery = gr.HTML(
+                value=_samples_html(
+                    initial_samples, [], DEFAULT_COMPARE_PROMPTS, seed=0
+                ),
+                elem_classes="compare-gallery",
+            )
+            seed_state = gr.State(0)
+
+        with gr.TabItem("About"):
+            render_about()
+
+    def _synced_filters(dataset_id, metric_id, models):
+        metric_id = _coerce_metric(datasets, metrics, dataset_id, metric_id)
+        model_choices = _model_choices(datasets, dataset_id)
+        models = [model for model in (models or []) if model in model_choices]
+        metric_choices = _metric_choices(datasets, metrics, dataset_id)
+        title = _title_markdown(
+            _view_title(datasets, metrics, dataset_id, metric_id)
+        )
+        dataset_update = gr.update(value=dataset_id)
+        metric_update = gr.update(choices=metric_choices, value=metric_id)
+        models_update = gr.update(choices=model_choices, value=models)
+        return (
+            dataset_id,
+            metric_id,
+            models,
+            dataset_update,
+            dataset_update,
+            dataset_update,
+            metric_update,
+            metric_update,
+            metric_update,
+            models_update,
+            models_update,
+            models_update,
+            title,
+            title,
+            title,
+        )
+
+    def _leaderboard_extras(data, platform_value, owner_value, optimized_value):
+        platform_choices = _filter_choices(data, "Platform")
+        owner_choices = _filter_choices(data, "Endpoint Owner")
+        optimized_choices = _filter_choices(data, "Optimized")
+        platform_value = [
+            value for value in (platform_value or []) if value in platform_choices
+        ]
+        owner_value = [
+            value for value in (owner_value or []) if value in owner_choices
+        ]
+        optimized_value = [
+            value for value in (optimized_value or []) if value in optimized_choices
+        ]
+        return (
+            gr.update(
+                choices=platform_choices,
+                value=platform_value,
+                visible=bool(platform_choices),
+            ),
+            gr.update(
+                choices=owner_choices,
+                value=owner_value,
+                visible=bool(owner_choices),
+            ),
+            gr.update(
+                choices=optimized_choices,
+                value=optimized_value,
+                visible=bool(optimized_choices),
+            ),
+            platform_value,
+            owner_value,
+            optimized_value,
+        )
+
+    def _views(
+        dataset_id,
+        metric_id,
+        models,
+        search_term,
+        platform_value,
+        owner_value,
+        optimized_value,
+        num_prompts,
+        seed,
+    ):
+        view = resolve_view(datasets, metrics, dataset_id, metric_id)
+        data = view["data"]
+        filtered = _filter_leaderboard(
+            data,
+            search_term,
+            platform_value or [],
+            owner_value or [],
+            optimized_value or [],
+            models=models,
+        )
+        ranking_html = _leaderboard_html(
+            filtered,
+            view["columns"],
+            [view["score_column"]],
+            view["score_column"],
+        )
+        pareto_data = _filter_leaderboard(
+            data, "", [], [], [], models=models
+        )
+        next_price, next_time = _pareto_pair(pareto_data, view["score_column"])
+        samples_html = _samples_html(
+            view.get("samples"),
+            models,
+            int(num_prompts or DEFAULT_COMPARE_PROMPTS),
+            int(seed or 0),
+        )
+        return (
+            _note_markdown(view.get("note")),
+            ranking_html,
+            next_price,
+            next_time,
+            samples_html,
+        )
+
+    def on_dataset(
+        dataset_id,
+        metric_id,
+        models,
+        search_term,
+        platform_value,
+        owner_value,
+        optimized_value,
+        num_prompts,
+        seed,
+    ):
+        synced = _synced_filters(dataset_id, metric_id, models)
+        dataset_id, metric_id, models = synced[:3]
+        view = resolve_view(datasets, metrics, dataset_id, metric_id)
+        extras = _leaderboard_extras(
+            view["data"], platform_value, owner_value, optimized_value
+        )
+        views = _views(
+            dataset_id,
+            metric_id,
+            models,
+            search_term,
+            extras[3],
+            extras[4],
+            extras[5],
+            num_prompts,
+            seed,
+        )
+        return (*synced[3:], extras[0], extras[1], extras[2], *views)
+
+    def on_metric(
+        dataset_id,
+        metric_id,
+        models,
+        search_term,
+        platform_value,
+        owner_value,
+        optimized_value,
+        num_prompts,
+        seed,
+    ):
+        metric_id = _coerce_metric(datasets, metrics, dataset_id, metric_id)
+        title = _title_markdown(
+            _view_title(datasets, metrics, dataset_id, metric_id)
+        )
+        metric_update = gr.update(value=metric_id)
+        views = _views(
+            dataset_id,
+            metric_id,
+            models,
+            search_term,
+            platform_value,
+            owner_value,
+            optimized_value,
+            num_prompts,
+            seed,
+        )
+        return (metric_update, metric_update, metric_update, title, title, title, *views)
+
+    def on_models(
+        dataset_id,
+        metric_id,
+        models,
+        search_term,
+        platform_value,
+        owner_value,
+        optimized_value,
+        num_prompts,
+        seed,
+    ):
+        model_choices = _model_choices(datasets, dataset_id)
+        models = [model for model in (models or []) if model in model_choices]
+        models_update = gr.update(value=models)
+        views = _views(
+            dataset_id,
+            metric_id,
+            models,
+            search_term,
+            platform_value,
+            owner_value,
+            optimized_value,
+            num_prompts,
+            seed,
+        )
+        return (models_update, models_update, models_update, *views)
+
+    def on_leaderboard_filters(
+        dataset_id,
+        metric_id,
+        models,
+        search_term,
+        platform_value,
+        owner_value,
+        optimized_value,
+    ):
+        view = resolve_view(datasets, metrics, dataset_id, metric_id)
+        filtered = _filter_leaderboard(
+            view["data"],
+            search_term,
+            platform_value or [],
+            owner_value or [],
+            optimized_value or [],
+            models=models,
+        )
+        return _leaderboard_html(
+            filtered,
+            view["columns"],
+            [view["score_column"]],
+            view["score_column"],
+        )
+
+    def on_samples_controls(dataset_id, models, num_prompts, seed):
+        view = resolve_view(datasets, metrics, dataset_id, None)
+        return _samples_html(
+            view.get("samples") if view else None,
+            models,
+            int(num_prompts or DEFAULT_COMPARE_PROMPTS),
+            int(seed or 0),
+        )
+
+    def on_shuffle(dataset_id, models, num_prompts, seed):
+        next_seed = int(seed or 0) + 1
+        view = resolve_view(datasets, metrics, dataset_id, None)
+        return next_seed, _samples_html(
+            view.get("samples") if view else None,
+            models,
+            int(num_prompts or DEFAULT_COMPARE_PROMPTS),
+            next_seed,
+        )
+
+    dataset_inputs = [
+        lb_metric,
+        lb_models,
+        search,
+        platform,
+        owner,
+        optimized,
+        prompt_count,
+        seed_state,
+    ]
+    dataset_outputs = [
+        lb_dataset,
+        pp_dataset,
+        sm_dataset,
+        lb_metric,
+        pp_metric,
+        sm_metric,
+        lb_models,
+        pp_models,
+        sm_models,
+        lb_title,
+        pp_title,
+        sm_title,
+        platform,
+        owner,
+        optimized,
+        lb_note,
+        ranking,
+        price_plot,
+        time_plot,
+        gallery,
+    ]
+    for dataset_dd in (lb_dataset, pp_dataset, sm_dataset):
+        dataset_dd.change(
+            on_dataset,
+            inputs=[dataset_dd, *dataset_inputs],
+            outputs=dataset_outputs,
+        )
+
+    metric_outputs = [
+        lb_metric,
+        pp_metric,
+        sm_metric,
+        lb_title,
+        pp_title,
+        sm_title,
+        lb_note,
+        ranking,
+        price_plot,
+        time_plot,
+        gallery,
+    ]
+    for metric_dd in (lb_metric, pp_metric, sm_metric):
+        metric_dd.change(
+            on_metric,
+            inputs=[
+                lb_dataset,
+                metric_dd,
+                lb_models,
+                search,
+                platform,
+                owner,
+                optimized,
+                prompt_count,
+                seed_state,
+            ],
+            outputs=metric_outputs,
+        )
+
+    models_outputs = [
+        lb_models,
+        pp_models,
+        sm_models,
+        lb_note,
+        ranking,
+        price_plot,
+        time_plot,
+        gallery,
+    ]
+    for models_dd in (lb_models, pp_models, sm_models):
+        models_dd.change(
+            on_models,
+            inputs=[
+                lb_dataset,
+                lb_metric,
+                models_dd,
+                search,
+                platform,
+                owner,
+                optimized,
+                prompt_count,
+                seed_state,
+            ],
+            outputs=models_outputs,
+        )
+
+    for component in (search, platform, owner, optimized):
+        component.change(
+            on_leaderboard_filters,
+            inputs=[
+                lb_dataset,
+                lb_metric,
+                lb_models,
+                search,
+                platform,
+                owner,
+                optimized,
+            ],
+            outputs=ranking,
+        )
+
+    prompt_count.change(
+        on_samples_controls,
+        inputs=[sm_dataset, sm_models, prompt_count, seed_state],
+        outputs=gallery,
+    )
+    shuffle_button.click(
+        on_shuffle,
+        inputs=[sm_dataset, sm_models, prompt_count, seed_state],
+        outputs=[seed_state, gallery],
+    )
+
 
 def render_about():
     with gr.Row(elem_classes="about-layout", equal_height=False):