cleaning and updating about

README.md

@@ -14,71 +14,32 @@ tags:
 
 # P-Bench
 
-Evaluate the quality and efficiency of image gen api's.
+Compare text-to-image models on quality, speed, and price. This repo is the
+Gradio dashboard: leaderboards, Pareto plots, and side-by-side samples.
 
-## Installation
+The live Space is [PrunaAI/P-Bench](https://huggingface.co/spaces/PrunaAI/P-Bench).
 
-### Install dependencies
+## Run locally
 
-Install dependencies with conda like that:
-```
-conda env create -f environment.yml
-```
-
-### Install uv
-
-Install uv with pip like that:
-
-```
-uv venv --python 3.12
-```
-
-Then activate the environment:
+From the repo root:
 
 ```
+python -m venv .venv
 source .venv/bin/activate
+pip install "gradio==5.19.0" pandas -r requirements.txt
+python app.py
 ```
 
-Then install the dependencies with uv:
+The app is served at `http://127.0.0.1:7860`.
 
-```
-uv sync --all-groups
-```
+`requirements.txt` lists Plotly. Gradio and pandas are required locally;
+Hugging Face Spaces installs Gradio from the YAML `sdk_version` above.
 
-## Usage
+## Deploy
 
-Create .env file with all the credentials you will need.
+`origin` is the Space (`https://huggingface.co/spaces/PrunaAI/P-Bench`).
+Publish the current branch to the live app with:
 
-This is how you can generate the images.
-```
-python sample.py replicate draw_bench genai_bench geneval hps parti
-```
-
-This is how you would evaluate the benchmarks once you have all images:
-```
-python evaluate.py replicate draw_bench genai_bench geneval hps parti
 ```
-
-## Leaderboard
-
-The leaderboard is [hosted on Hugging Face](https://huggingface.co/spaces/PrunaAI/InferBench/tree/main) with gradio.
-
-To run the dashboard locally, you can use the following command:
-
-```
-python dashboard/app.py
-```
-
-To deploy the dashboard to Hugging Face, you can use the following commands:
-
-First, add the remote:
-
-```
-git remote add hf https://huggingface.co/spaces/PrunaAI/InferBench
-```
-
-Then push the changes of your branch to the remote:
-
+git push origin HEAD:main
 ```
-git push hf $(git rev-parse --abbrev-ref HEAD):main --force
-```

app.py

@@ -1914,18 +1914,11 @@ def load_sample_comparison_data(folder):
     }
 
 
-def format_url_links(value):
-    if pd.isna(value) or not value:
-        return ""
-
-    links = [url.strip() for url in str(value).split(",") if url.strip()]
-    if not links:
-        return ""
-
-    return " ".join(
-        f'<a target="_blank" href="{url}" style="color: var(--link-text-color); text-decoration: underline;text-decoration-style: dotted;">run {idx}</a>'
-        for idx, url in enumerate(links, start=1)
-    )
+def _as_numeric(df, columns):
+    for column in columns:
+        if column in df.columns:
+            df[column] = pd.to_numeric(df[column], errors="coerce")
+    return df
 
 
 def load_oneig_dataframe(path):
@@ -1933,7 +1926,6 @@ def load_oneig_dataframe(path):
     df = df.rename(
         columns={
             "Owner": "Endpoint Owner",
-            "Optimization": "Optimization Details",
             "Anime Alignment Score": "OneIG (Anime Alignment)",
             "Human Alignment Score": "OneIG (Human Alignment)",
             "Object Alignment Score": "OneIG (Object Alignment)",
@@ -1942,63 +1934,34 @@ def load_oneig_dataframe(path):
             "OneIG (General Object) (Alignment Score)": "OneIG (Object Alignment)",
         }
     )
-    if "URL" in df.columns:
-        df["URL"] = df["URL"].apply(format_url_links)
+    df = df.drop(
+        columns=[
+            column
+            for column in ("URL", "Device", "Optimization", "Optimization Details")
+            if column in df.columns
+        ]
+    )
     if "Optimized" in df.columns:
         df["Optimized"] = df["Optimized"].map(
             {True: "Yes", False: "No", "TRUE": "Yes", "FALSE": "No"}
         ).fillna(df["Optimized"])
 
-    for column in [
-        "Price / Image (USD)",
-        "Median Generation Time (s)",
-        "Min Generation Time (s)",
-        "OneIG (Anime Alignment)",
-        "OneIG (Human Alignment)",
-        "OneIG (Object Alignment)",
-        "OneIG Anime Elo",
-        "OneIG Human Elo",
-        "OneIG Object Elo",
-        "P-Judge Overall",
-        "Rapidata Elo",
-    ]:
-        if column in df.columns:
-            df[column] = pd.to_numeric(df[column], errors="coerce")
-
-    preferred_columns = [
-        "Platform",
-        "Endpoint Owner",
-        "Device",
-        "Model",
-        "Optimized",
-        "Optimization Details",
-        "OneIG (Anime Alignment)",
-        "OneIG (Human Alignment)",
-        "OneIG (Object Alignment)",
-        "OneIG Anime Elo",
-        "OneIG Human Elo",
-        "OneIG Object Elo",
-        "Median Generation Time (s)",
-        "Min Generation Time (s)",
-        "Price / Image (USD)",
-        "Evaluation Date (UTC)",
-        "URL",
-    ]
-    present_preferred_columns = [col for col in preferred_columns if col in df.columns]
-    df = df[
-        present_preferred_columns
-        + [col for col in df.columns.tolist() if col not in present_preferred_columns]
-    ]
-
-    if "OneIG (Human Alignment)" in df.columns:
-        df = df.sort_values(
-            by="OneIG (Human Alignment)", ascending=False, na_position="last"
-        )
-
-    numeric_cols = df.select_dtypes(include=[float, int]).columns.tolist()
-    for col in numeric_cols:
-        df[col] = df[col].apply(lambda x: round(x, 4) if pd.notna(x) else x)
-    return df
+    return _as_numeric(
+        df,
+        [
+            "Price / Image (USD)",
+            "Median Generation Time (s)",
+            "Min Generation Time (s)",
+            "OneIG (Anime Alignment)",
+            "OneIG (Human Alignment)",
+            "OneIG (Object Alignment)",
+            "OneIG Anime Elo",
+            "OneIG Human Elo",
+            "OneIG Object Elo",
+            "P-Judge Overall",
+            "Rapidata Elo",
+        ],
+    )
 
 
 def load_artificial_analysis_dataframe(path):
@@ -2012,17 +1975,9 @@ def load_artificial_analysis_dataframe(path):
         }
     )
     df["Model"] = df["Model"].astype(str).str.strip()
-    for column in ["Artificial Analysis Elo", "Price / Image (USD)"]:
-        if column in df.columns:
-            df[column] = pd.to_numeric(df[column], errors="coerce")
-    if "Artificial Analysis Elo" in df.columns:
-        df = df.sort_values(
-            by="Artificial Analysis Elo", ascending=False, na_position="last"
-        )
-    numeric_cols = df.select_dtypes(include=[float, int]).columns.tolist()
-    for col in numeric_cols:
-        df[col] = df[col].apply(lambda x: round(x, 4) if pd.notna(x) else x)
-    return df.reset_index(drop=True)
+    return _as_numeric(
+        df, ["Artificial Analysis Elo", "Price / Image (USD)"]
+    ).reset_index(drop=True)
 
 
 ARENA_CATEGORY_COLUMNS = {
@@ -2054,13 +2009,7 @@ def load_arena_ai_dataframe(path):
         for column in ["Arena Elo", *ARENA_CATEGORY_COLUMNS.values()]
         if column in df.columns
     ]
-    for column in score_columns:
-        df[column] = pd.to_numeric(df[column], errors="coerce")
-    if "Arena Elo" in df.columns:
-        df = df.sort_values(by="Arena Elo", ascending=False, na_position="last")
-    numeric_cols = df.select_dtypes(include=[float, int]).columns.tolist()
-    for col in numeric_cols:
-        df[col] = df[col].apply(lambda x: round(x, 4) if pd.notna(x) else x)
+    df = _as_numeric(df, score_columns)
     ordered = ["Model", *score_columns]
     return df[[column for column in ordered if column in df.columns]].reset_index(
         drop=True
@@ -2077,36 +2026,17 @@ def load_qwen_combined_dataframe(path):
     df = df[~df["Model"].astype(str).str.startswith("#")].copy()
     df["Model"] = df["Model"].astype(str).str.strip()
 
-    for column in [
-        "Price / Image (USD)",
-        "Median Generation Time (s)",
-        "Min Generation Time (s)",
-        "P-Judge Overall",
-        "Rapidata Elo",
-        "Datapoint Elo",
-    ]:
-        if column in df.columns:
-            df[column] = pd.to_numeric(df[column], errors="coerce")
-
-    sort_column = next(
-        (
-            col
-            for col in [
-                "Datapoint Elo",
-                "P-Judge Overall",
-                "Rapidata Elo",
-            ]
-            if col in df.columns
-        ),
-        None,
-    )
-    if sort_column:
-        df = df.sort_values(by=sort_column, ascending=False, na_position="last")
-
-    numeric_cols = df.select_dtypes(include=[float, int]).columns.tolist()
-    for col in numeric_cols:
-        df[col] = df[col].apply(lambda x: round(x, 4) if pd.notna(x) else x)
-    return df.reset_index(drop=True)
+    return _as_numeric(
+        df,
+        [
+            "Price / Image (USD)",
+            "Median Generation Time (s)",
+            "Min Generation Time (s)",
+            "P-Judge Overall",
+            "Rapidata Elo",
+            "Datapoint Elo",
+        ],
+    ).reset_index(drop=True)
 
 
 df = load_oneig_dataframe(oneig_path)
@@ -2125,9 +2055,6 @@ if oneig_metric_columns:
     oneig_df["OneIG Overall Score"] = oneig_df[oneig_metric_columns].mean(
         axis=1, skipna=True
     )
-    oneig_df = oneig_df.sort_values(
-        by="OneIG Overall Score", ascending=False, na_position="last"
-    )
 
 oneig_display_columns = [
     col
@@ -2147,7 +2074,6 @@ oneig_display_columns = [
         "Median Generation Time (s)",
         "Min Generation Time (s)",
         "Price / Image (USD)",
-        "URL",
     ]
     if col in oneig_df.columns
 ]
@@ -2213,86 +2139,22 @@ oneig_samples = load_sample_comparison_data(oneig_combined_dir)
 qwen_samples = load_sample_comparison_data(qwen_combined_dir)
 
 metrics = [
-    {
-        "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": "Artificial Analysis Elo",
-    },
-    {
-        "id": "arena_elo",
-        "name": "Arena ELO - Overall Metric",
-        "column": "Arena Elo",
-    },
-    {
-        "id": "arena_branding",
-        "name": "Arena ELO - Branding / Commercial Metric",
-        "column": "Arena Branding / Commercial Elo",
-    },
-    {
-        "id": "arena_3d",
-        "name": "Arena ELO - 3D Imaging Metric",
-        "column": "Arena 3D Imaging Elo",
-    },
-    {
-        "id": "arena_cartoon",
-        "name": "Arena ELO - Cartoon / Anime Metric",
-        "column": "Arena Cartoon / Anime Elo",
-    },
-    {
-        "id": "arena_photo",
-        "name": "Arena ELO - Photorealistic Metric",
-        "column": "Arena Photorealistic Elo",
-    },
-    {
-        "id": "arena_art",
-        "name": "Arena ELO - Art Metric",
-        "column": "Arena Art Elo",
-    },
-    {
-        "id": "arena_portraits",
-        "name": "Arena ELO - Portraits Metric",
-        "column": "Arena Portraits Elo",
-    },
-    {
-        "id": "arena_text",
-        "name": "Arena ELO - Text Rendering Metric",
-        "column": "Arena Text Rendering Elo",
-    },
+    {"id": "datapoint_elo", "column": "Datapoint Elo"},
+    {"id": "rapidata_elo", "column": "Rapidata Elo"},
+    {"id": "pjudger", "column": "P-Judge Overall"},
+    {"id": "alignment_overall", "column": "OneIG Overall Score"},
+    {"id": "datapoint_elo_anime", "column": "OneIG Anime Elo"},
+    {"id": "datapoint_elo_human", "column": "OneIG Human Elo"},
+    {"id": "datapoint_elo_object", "column": "OneIG Object Elo"},
+    {"id": "aa_elo", "column": "Artificial Analysis Elo"},
+    {"id": "arena_elo", "column": "Arena Elo"},
+    {"id": "arena_branding", "column": "Arena Branding / Commercial Elo"},
+    {"id": "arena_3d", "column": "Arena 3D Imaging Elo"},
+    {"id": "arena_cartoon", "column": "Arena Cartoon / Anime Elo"},
+    {"id": "arena_photo", "column": "Arena Photorealistic Elo"},
+    {"id": "arena_art", "column": "Arena Art Elo"},
+    {"id": "arena_portraits", "column": "Arena Portraits Elo"},
+    {"id": "arena_text", "column": "Arena Text Rendering Elo"},
 ]
 
 
@@ -2358,7 +2220,7 @@ datasets = [
     },
     {
         "id": "artificial_analysis",
-        "name": "Artificial Analysis",
+        "name": "Artificial Analysis Dataset",
         "data": aa_df,
         "columns": aa_display_columns,
         "metric_ids": aa_metric_ids,
@@ -2367,7 +2229,7 @@ datasets = [
     },
     {
         "id": "arena_ai",
-        "name": "Arena AI",
+        "name": "Arena AI Dataset",
         "data": arena_df,
         "columns": arena_display_columns,
         "metric_ids": arena_metric_ids,

model_display.py

@@ -12,28 +12,14 @@ import re
 MODEL_DISPLAY_NAMES = {
     # FLUX
     "flux_2_pro": "FLUX.2 [pro]",
-    "FLUX.2 [pro]": "FLUX.2 [pro]",
     "flux_2_max": "FLUX.2 [max]",
-    "FLUX.2 [max]": "FLUX.2 [max]",
     "flux_2_flex": "FLUX.2 [flex]",
-    "FLUX.2 [flex]": "FLUX.2 [flex]",
     "flux_2_dev": "FLUX.2 [dev]",
-    "FLUX.2 [dev]": "FLUX.2 [dev]",
-    "FLUX.2 [dev] Turbo": "FLUX.2 [dev] Turbo",
-    "FLUX.2 [dev] Flash": "FLUX.2 [dev] Flash",
     "flux_1_1_pro": "FLUX1.1 [pro]",
-    "FLUX1.1 [pro]": "FLUX1.1 [pro]",
     "flux_1_1_pro_ultra": "FLUX1.1 [pro] Ultra",
-    "FLUX1.1 [pro] Ultra": "FLUX1.1 [pro] Ultra",
     "flux_dev": "FLUX.1 [dev]",
-    "FLUX.1 [dev]": "FLUX.1 [dev]",
     "flux_schnell": "FLUX.1 [schnell]",
-    "FLUX.1 [schnell]": "FLUX.1 [schnell]",
     "flux_krea": "FLUX.1 Krea [dev]",
-    "FLUX.1 Krea [dev]": "FLUX.1 Krea [dev]",
-    "FLUX.1 [pro]": "FLUX.1 [pro]",
-    "FLUX.1 Kontext [pro]": "FLUX.1 Kontext [pro]",
-    "FLUX.1 Kontext [max]": "FLUX.1 Kontext [max]",
     # GPT Image
     "gpt_image_2": "GPT Image 2",
     "GPT Image 2 (high)": "GPT Image 2",
@@ -52,41 +38,28 @@ MODEL_DISPLAY_NAMES = {
     "Nano Banana (Gemini 2.5 Flash Image)": "Nano Banana",
     # Seedream
     "seedream_5_0": "Seedream 5.0",
-    "Seedream 5.0 Pro": "Seedream 5.0 Pro",
-    "Seedream 5.0 Lite": "Seedream 5.0 Lite",
     "seedream_4_5": "Seedream 4.5",
-    "Seedream 4.5": "Seedream 4.5",
     "seedream_4_0": "Seedream 4.0",
-    "Seedream 4.0": "Seedream 4.0",
     "seedream_3": "Seedream 3.0",
-    "Seedream 3.0": "Seedream 3.0",
     # Qwen
     "qwen_image": "Qwen Image",
-    "Qwen Image": "Qwen Image",
     "qwen_image_2_0_pro": "Qwen Image 2.0 Pro",
     "Qwen Image 2.0 Pro (2026-04-22)": "Qwen Image 2.0 Pro",
     "Qwen Image 2.0 (2026-03-03)": "Qwen Image 2.0",
     "qwen_image_2512": "Qwen Image 2512",
     "Qwen Image Max 2512": "Qwen Image 2512",
     "qwen_image_fast": "Qwen Image Fast",
-    "Qwen Image Plus 2601": "Qwen Image Plus 2601",
     # Ideogram
     "ideogram_4_0_quality": "Ideogram 4.0 Quality",
     "Ideogram 4.0 (Quality)": "Ideogram 4.0 Quality",
-    "Ideogram 4.0": "Ideogram 4.0",
-    "Ideogram 4.0 Fast": "Ideogram 4.0 Fast",
     "Ideogram 4.0 Fast (Quality)": "Ideogram 4.0 Fast Quality",
-    "Ideogram 4.0 Instant": "Ideogram 4.0 Instant",
-    "Ideogram 3.0": "Ideogram 3.0",
     # Imagen
     "imagen_4_0": "Imagen 4",
     "imagen_4": "Imagen 4",
     "Imagen 4 Standard": "Imagen 4",
     "imagen_4_0_ultra": "Imagen 4 Ultra",
     "imagen_4_ultra": "Imagen 4 Ultra",
-    "Imagen 4 Ultra": "Imagen 4 Ultra",
     "imagen_4_fast": "Imagen 4 Fast",
-    "Imagen 4 Fast": "Imagen 4 Fast",
     "Imagen 3 (v002)": "Imagen 3",
     # HiDream
     "hidream_i1_dev": "HiDream-I1 Dev",
@@ -99,11 +72,9 @@ MODEL_DISPLAY_NAMES = {
     "HiDream-O1-Image-Dev": "HiDream-O1 Dev",
     # Reve
     "reve_2_1": "Reve 2.1",
-    "Reve 2.1": "Reve 2.1",
     "Reve Image (Halfmoon)": "Reve Image",
     # P-Image
     "p_image": "P-Image",
-    "P-Image": "P-Image",
     "p_image_2_ideogram_very_low_1k": "P-Image-Ideogram Very Low 1K",
     "p_image_2_ideogram_very_low_2k": "P-Image-Ideogram Very Low 2K",
     "P-Image-Ideogram (Very Low)": "P-Image-Ideogram Very Low",
@@ -118,29 +89,21 @@ MODEL_DISPLAY_NAMES = {
     "P-Image-Ideogram (High)": "P-Image-Ideogram High",
     # Others overlapping P-Bench
     "z_image": "Z-Image",
-    "Z-Image Turbo": "Z-Image Turbo",
-    "Z-Image Base": "Z-Image Base",
     "glm_image": "GLM-Image",
-    "GLM-Image": "GLM-Image",
     "hunyuanimage_3_0": "HunyuanImage 3.0",
     "hunyuan_image_3": "HunyuanImage 3.0",
     "HunyuanImage 3.0 (Fal)": "HunyuanImage 3.0",
     "HunyuanImage 3.0 Instruct (Fal)": "HunyuanImage 3.0 Instruct",
-    "HunyuanImage 2.1": "HunyuanImage 2.1",
     "wan_2_2_image": "Wan 2.2 Image",
-    "Wan 2.6 Image": "Wan 2.6 Image",
     "Wan2.6 Text to Image": "Wan 2.6 Text to Image",
     "kling_v2_1": "Kling v2.1",
-    "Kling Image 3.0 Omni": "Kling Image 3.0 Omni",
     "juggernaut_base_flux": "Juggernaut Base FLUX",
     "juggernaut_pro_flux": "Juggernaut Pro FLUX",
     "juggernaut_lightning_flux": "Juggernaut Lightning FLUX",
     "bria_4_fibo": "Bria FIBO",
-    "Bria 3.2": "Bria 3.2",
     "sdxl": "SDXL 1.0",
     "Stable Diffusion XL 1.0": "SDXL 1.0",
     "sdxl_lightning": "SDXL Lightning",
-    "SDXL Lightning": "SDXL Lightning",
     # Arena AI (kebab / arena.ai ids)
     "gpt-image-2 (medium)": "GPT Image 2",
     "gpt-image-1.5-high-fidelity": "GPT Image 1.5",

ui.py

@@ -9,11 +9,11 @@ import plotly.graph_objects as go
 
 from model_display import display_model_name
 
-_MASCOT_PATH = Path(__file__).resolve().parent / "pruna-mascot.png"
-_MASCOT_DATA_URI = (
+_LOGO_PATH = Path(__file__).resolve().parent / "pruna-logo.png"
+_LOGO_DATA_URI = (
     "data:image/png;base64,"
-    + base64.b64encode(_MASCOT_PATH.read_bytes()).decode("ascii")
-    if _MASCOT_PATH.exists()
+    + base64.b64encode(_LOGO_PATH.read_bytes()).decode("ascii")
+    if _LOGO_PATH.exists()
     else "https://playground.pruna.ai/logo.svg"
 )
 
@@ -51,13 +51,17 @@ across P-Bench.
 
 1. Pick a **dataset** and a **metric**.
 2. **Leaderboards**: ranked by that metric. Price and generation time sit in
-   the same table.
+   the same table when the source publishes them.
 3. **Pareto plots**: mark models that are not beaten on both higher score
-   and lower price (or time).
-4. **Samples**: the same prompts, side by side.
+   and lower price (or time). Only datasets with price or generation time
+   can open this tab (not Arena AI).
+4. **Samples**: the same prompts, side by side. Only for datasets we
+   generated (Qwen Image Dataset and OneIG Alignment Dataset).
 
 ## How a score is made
 
+On **Qwen Image Dataset** and **OneIG Alignment Dataset**:
+
 1. Each endpoint is given the same prompt suite.
 2. It generates one image per prompt when the run succeeds. Not every model
    has every prompt or every metric.
@@ -65,18 +69,33 @@ across P-Bench.
    available, by human preference (Datapoint Elo, Rapidata Elo).
 4. Price per image and generation time are joined from the evaluation table.
 
+**Artificial Analysis** and **Arena AI** are external leaderboards. We import
+their published Elos (and Artificial Analysis price). We do not run their
+prompt suites, so samples are not shown.
+
 ## Current datasets
 
 ### 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.
+Rapidata Elo, and P-Judger. Samples are available.
 
 ### OneIG Alignment Dataset
-Prompt-image **alignment** on anime / stylization, human / portrait, and
-general object prompts (100 prompts each). This is the alignment slice of
+Prompt-image **alignment** on anime / stylization (100), human / portrait
+(100), and general object prompts (99). This is the alignment slice of
 OneIG, not the full suite. Alignment Overall is the mean of the category
-scores that exist for that row.
+scores that exist for that row. Also includes Datapoint category Elo,
+Rapidata Elo, and P-Judger. Samples are available.
+
+### Artificial Analysis Dataset
+External text-to-image Elo and price per image from Artificial Analysis.
+Their prompt set is private, so samples are not shown. Pareto plots use
+price vs score only.
+
+### Arena AI Dataset
+External text-to-image Elo (overall and category) from Arena AI. Their
+prompt set is private, so samples are not shown. Price and generation time
+are not in this export, so Pareto plots are unavailable.
 """
 
 ABOUT_DETAILS_CONTENT = """
@@ -93,11 +112,17 @@ ABOUT_DETAILS_CONTENT = """
 - **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). Rapidata is not a dataset.
+- **Artificial Analysis Elo**: Elo published by Artificial Analysis on their
+  own dataset.
+- **Arena Elo**: Elo published by Arena AI on their own dataset, plus
+  category Elos (branding, 3D, cartoon/anime, photorealistic, art, portraits,
+  text rendering).
 - **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.
+  warm vs cold or concurrent load. Not available for Arena AI.
 - **Price**: USD per image in the evaluation table. We do not state list
-  price vs amount paid, or whether failed generations are included.
+  price vs amount paid, or whether failed generations are included. Not
+  available for Arena AI.
 
 Scores from different datasets or metrics are **not interchangeable**. A high
 OneIG alignment score is not the same quantity as a Datapoint Elo. Compare
@@ -108,25 +133,29 @@ models *within* a Dataset | Metric view.
 - **Evaluation window:** July–August 2026.
 - **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 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.
-  Default resolution is 1024×1024. Exceptions: FLUX 1.1 Pro Ultra at 2K,
-  FLUX 2 Flex at 1008×1008, and any endpoint labeled 2K. The seed is derived
-  from the prompt, so every model gets the same seed for the same prompt.
-  Steps, CFG, prompt rewrite, and safety filters follow each endpoint's
-  default.
-- **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 Dataset prompts. 4 votes per pair; about
-  26,000 votes on OneIG and 35,000 on Qwen Image Dataset.
+- **Prompt counts:** OneIG Alignment uses 100 anime, 100 human, and 99 object
+  prompts (299 total). Qwen Image Dataset uses 100 prompts sampled from the
+  1,000-prompt pool for roughly even coverage of its fine-grained (L3)
+  categories. Artificial Analysis and Arena AI use their own private prompt
+  sets.
+- **Generation (Qwen and OneIG):** one image per prompt per endpoint when
+  the run exists. Default resolution is 1024×1024. Exceptions: FLUX 1.1 Pro
+  Ultra at 2K, FLUX 2 Flex at 1008×1008, and any endpoint labeled 2K. The
+  seed is derived from the prompt, so every model gets the same seed for the
+  same prompt. Steps, CFG, prompt rewrite, and safety filters follow each
+  endpoint's default. This does not describe Artificial Analysis or Arena AI.
+- **Datapoint (Qwen and OneIG):** every model pair is compared on every
+  prompt, with 10 votes per battle.
+- **Rapidata (Qwen and OneIG):** prompts longer than 400 characters are
+  dropped, leaving 212 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.
+- Artificial Analysis and Arena AI samples, prompts, and (for Arena) price
+  or latency are not available to P-Bench.
 - Rapidata Elo is not on the full prompt suite, so it is not directly
   comparable to Datapoint Elo even on the same dataset.
 - Elo ratings can shift when the comparison pool changes: treat them as
@@ -147,6 +176,7 @@ FOOTER_CONTENT = """
   <div class="community-footer-links">
     <a rel="nofollow" href="https://x.com/PrunaAI" target="_blank">X</a>
     <a rel="nofollow" href="https://www.linkedin.com/company/pruna-ai" target="_blank">LinkedIn</a>
+    <a rel="nofollow" href="https://www.instagram.com/pruna.ai/" target="_blank">Instagram</a>
     <a rel="nofollow" href="https://discord.gg/JFQmtFKCjd" target="_blank">Discord</a>
     <a rel="nofollow" href="https://github.com/PrunaAI/pruna" target="_blank">GitHub</a>
     <a rel="nofollow" href="https://www.pruna.ai/" target="_blank">pruna.ai</a>
@@ -160,7 +190,7 @@ CITATION_CONTENT = """
     title={P-Bench: A Leaderboard for Text-to-Image Models},
     author={PrunaAI},
     year={2026},
-    howpublished={\\url{https://huggingface.co/spaces/PrunaAI/InferBench}}
+    howpublished={\\url{https://huggingface.co/spaces/PrunaAI/P-Bench}}
 }
 ```
 """
@@ -172,7 +202,7 @@ def render_header():
         <header class="app-header">
           <div class="app-header-bar">
             <div class="app-header-brand">
-              <img class="app-header-logo" src="{_MASCOT_DATA_URI}" alt="" />
+              <img class="app-header-logo" src="{_LOGO_DATA_URI}" alt="" />
               <h1>P-Bench</h1>
             </div>
             <button type="button" class="theme-toggle" data-mode="dark" aria-label="Switch to light mode" title="Switch to light mode">
@@ -200,11 +230,12 @@ def _item(items, item_id):
     return items[0] if items else None
 
 
-def _dataset_choices(datasets, *, require_samples=False):
+def _dataset_choices(datasets, *, require_samples=False, require_pareto=False):
     return [
         (dataset["name"], dataset["id"])
         for dataset in datasets
-        if not require_samples or dataset.get("samples")
+        if (not require_samples or dataset.get("samples"))
+        and (not require_pareto or _dataset_has_pareto(datasets, dataset["id"]))
     ]
 
 
@@ -219,6 +250,20 @@ def _dataset_has_pareto(datasets, dataset_id):
     return _PARETO_PRICE_COLUMN in columns or _PARETO_TIME_COLUMN in columns
 
 
+def _dataset_dropdown_update(datasets, tab, dataset_id):
+    """Limit the dataset list to what the current tab can show."""
+    return gr.update(
+        choices=_dataset_choices(
+            datasets,
+            require_samples=tab == TAB_SAMPLES
+            and _dataset_has_samples(datasets, dataset_id),
+            require_pareto=tab == TAB_PARETO
+            and _dataset_has_pareto(datasets, dataset_id),
+        ),
+        value=dataset_id,
+    )
+
+
 ALL_METRICS_ID = "__all__"
 
 
@@ -306,29 +351,12 @@ def _metric_columns(datasets, metrics, dataset_id):
     ]
 
 
-def _view_title(datasets, metrics, dataset_id, metric_id):
-    dataset = _item(datasets, dataset_id)
-    dataset_name = dataset["name"] if dataset else "Dataset"
-    selected = [
-        item
-        for item in _normalize_metric_ids(metric_id)
-        if item != ALL_METRICS_ID
-    ]
-    all_ids = [choice[1] for choice in _metric_choices(datasets, metrics, dataset_id)]
-    if not selected or set(selected) == set(all_ids):
-        return dataset_name
-    names = []
-    for metric_key in selected:
-        metric = _item(metrics, metric_key)
-        if metric:
-            names.append(_display_label(metric["column"]))
-    if not names:
-        return dataset_name
-    if len(names) == 1:
-        return f"{dataset_name} | {names[0]}"
-    return f"{dataset_name} | {', '.join(names)}"
-
-
+_LEADERBOARD_IDENTITY_COLUMNS = [
+    "Model",
+    "Platform",
+    "Endpoint Owner",
+    "Optimized",
+]
 _LEADERBOARD_META_COLUMNS = [
     "Median Generation Time (s)",
     "Min Generation Time (s)",
@@ -338,23 +366,14 @@ _LEADERBOARD_META_COLUMNS = [
 ]
 
 
-def _columns_for_metric(dataset, metric_column):
+def _columns_for_metric(dataset, score_columns):
     """When metrics are selected, show identity + those scores + time/price."""
-    metric_columns = (
-        [metric_column]
-        if isinstance(metric_column, str)
-        else [column for column in (metric_column or []) if column]
-    )
     available = list(getattr(dataset.get("data"), "columns", [])) or list(
         dataset.get("columns") or []
     )
-    identity = [
-        column
-        for column in ["Model", "Platform", "Endpoint Owner", "Optimized"]
-        if column in available
-    ]
+    identity = [column for column in _LEADERBOARD_IDENTITY_COLUMNS if column in available]
     meta = [column for column in _LEADERBOARD_META_COLUMNS if column in available]
-    scores = [column for column in metric_columns if column in available]
+    scores = [column for column in (score_columns or []) if column in available]
     if scores:
         return [*identity, *scores, *meta]
     return [column for column in (dataset.get("columns") or available) if column != "URL"]
@@ -364,21 +383,14 @@ def resolve_view(datasets, metrics, dataset_id, metric_id):
     dataset = _item(datasets, dataset_id)
     if not dataset:
         return None
-    metric_ids = _coerce_metric(datasets, metrics, dataset_id, metric_id)
-    selected_metrics = []
-    for metric_key in metric_ids:
+    data_columns = getattr(dataset.get("data"), "columns", [])
+    score_columns = []
+    for metric_key in _coerce_metric(datasets, metrics, dataset_id, metric_id):
         metric = _item(metrics, metric_key)
-        if metric:
-            selected_metrics.append(metric)
-    score_columns = [
-        metric["column"]
-        for metric in selected_metrics
-        if metric["column"] in getattr(dataset.get("data"), "columns", [])
-    ]
+        if metric and metric["column"] in data_columns:
+            score_columns.append(metric["column"])
     if score_columns:
         columns = _columns_for_metric(dataset, score_columns)
-        score_column = score_columns[0]
-        metric = selected_metrics[0]
     else:
         columns = [
             column
@@ -386,16 +398,10 @@ def resolve_view(datasets, metrics, dataset_id, metric_id):
             if column != "URL"
         ]
         score_columns = _metric_columns(datasets, metrics, dataset_id)
-        score_column = score_columns[0] if score_columns else None
-        metric = None
     return {
-        "dataset": dataset,
-        "metric": metric,
-        "metric_id": metric_ids,
-        "title": _view_title(datasets, metrics, dataset["id"], metric_ids),
         "data": dataset["data"],
         "columns": columns,
-        "score_column": score_column,
+        "score_column": score_columns[0] if score_columns else None,
         "score_columns": score_columns,
         "samples": dataset.get("samples"),
         "note": dataset.get("note"),
@@ -474,10 +480,8 @@ def _assign_leaderboard_ranks(data, overall_column):
     return ranked
 
 
-def _leaderboard_html(data, columns, score_columns, overall_column):
-    leaderboard = _leaderboard_dataframe(
-        data, columns, score_columns, overall_column
-    )
+def _leaderboard_html(data, columns):
+    leaderboard = _leaderboard_dataframe(data, columns)
     if leaderboard.empty:
         return (
             '<div class="ranking-table-scroll">'
@@ -546,65 +550,22 @@ def _filter_leaderboard(data, platform, owner, optimized, models=None):
     return filtered
 
 
-def _leaderboard_dataframe(data, columns, score_columns, overall_column):  # noqa: ARG001
-    skip_columns = {"URL"}
-    preferred_prefix = [
-        column
-        for column in ["Model", "Platform", "Endpoint Owner", "Optimized"]
-        if column in data.columns
-    ]
-    preferred_suffix = [
-        column
-        for column in [
-            "Median Generation Time (s)",
-            "Min Generation Time (s)",
-            "Price / Image (USD)",
-            "Evaluation Date (UTC)",
-            "Date",
-        ]
-        if column in data.columns
-    ]
-    middle = [
-        column
-        for column in columns
-        if column in data.columns
-        and column not in skip_columns
-        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()
-    for column in [*preferred_prefix, *middle, *preferred_suffix]:
-        if column not in seen:
-            seen.add(column)
-            ordered_columns.append(column)
+def _leaderboard_dataframe(data, columns):
+    ordered = []
     if "Rank" in data.columns:
-        ordered_columns = ["Rank", *[c for c in ordered_columns if c != "Rank"]]
-
-    leaderboard = data[ordered_columns].copy()
-
-    if overall_column and overall_column in leaderboard.columns:
-        leaderboard = leaderboard.sort_values(
-            overall_column, ascending=False, na_position="last"
-        )
-    leaderboard = leaderboard.reset_index(drop=True)
-    if "Rank" not in leaderboard.columns:
-        leaderboard.insert(0, "Rank", leaderboard.index + 1)
-    return leaderboard.rename(columns=_display_label)
+        ordered.append("Rank")
+    for column in columns:
+        if (
+            column in data.columns
+            and column not in {"URL", "Rank"}
+            and column not in ordered
+        ):
+            ordered.append(column)
+    return data[ordered].rename(columns=_display_label)
 
 
 def _display_label(column):
     labels = {
-        "_overall_score": "Overall score",
         "OneIG Overall Score": "Overall",
         "OneIG (Anime Alignment)": "Anime",
         "OneIG (Human Alignment)": "Human",
@@ -944,20 +905,15 @@ def _samples_html(samples, selected_models, num_prompts, seed=0):
         return _pareto_unavailable_html(
             "Samples aren't available for this dataset."
         )
-    models = list(selected_models or [])
-    available = samples.get("models") or []
-    models = [model for model in models if model in samples.get("images", {})]
+    images = samples.get("images", {})
+    models = [model for model in (selected_models or []) if model in images]
     if not models:
-        models = available[: min(2, len(available))]
+        models = (samples.get("models") or [])[:2]
     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]
+    selected_models = list(selected_models or [])[:MAX_COMPARE_MODELS]
 
     if not selected_models:
         return (
@@ -1023,39 +979,24 @@ def _build_compare_samples_html(samples, selected_models, num_prompts, seed=0):
     return "\n".join(blocks)
 
 
-def _plain_note(note):
-    text = (note or "").strip()
-    if text.startswith(">"):
-        text = text.lstrip(">").strip()
-    return text
-
-
 def _leaderboard_intro_markdown(note):
-    extra = _plain_note(note)
     parts = [
         "Models are ranked by the selected metric, with price and generation "
         "time in the same table."
     ]
+    extra = (note or "").strip()
     if extra:
         parts.append(extra)
     return "<p class='view-help'>" + " ".join(parts) + "</p>"
 
 
-def _filter_row(
-    datasets,
-    metrics,
-    default_dataset_id,
-    default_metric_id=None,
-    *,
-    require_samples=False,
-    include_metric=True,
-):
+def _filter_row(datasets, metrics, default_dataset_id, default_metric_id=None):
     metric_id = _coerce_metric(
         datasets, metrics, default_dataset_id, default_metric_id
     )
     with gr.Row(elem_classes="view-filters"):
         dataset_dd = gr.Dropdown(
-            choices=_dataset_choices(datasets, require_samples=require_samples),
+            choices=_dataset_choices(datasets),
             value=default_dataset_id,
             label="Dataset",
             type="value",
@@ -1063,22 +1004,18 @@ def _filter_row(
             scale=2,
             min_width=160,
         )
-        metric_dd = None
-        if include_metric:
-            metric_dd = gr.Dropdown(
-                choices=_metric_dropdown_choices(
-                    datasets, metrics, default_dataset_id
-                ),
-                value=_metric_dropdown_value(metric_id),
-                label="Metric",
-                type="value",
-                multiselect=True,
-                allow_custom_value=False,
-                filterable=True,
-                scale=2,
-                min_width=180,
-                elem_classes="filter-chips",
-            )
+        metric_dd = gr.Dropdown(
+            choices=_metric_dropdown_choices(datasets, metrics, default_dataset_id),
+            value=_metric_dropdown_value(metric_id),
+            label="Metric",
+            type="value",
+            multiselect=True,
+            allow_custom_value=False,
+            filterable=True,
+            scale=2,
+            min_width=180,
+            elem_classes="filter-chips",
+        )
         models_dd = gr.Dropdown(
             choices=_model_choices(datasets, default_dataset_id),
             value=[],
@@ -1101,14 +1038,16 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
     initial = resolve_view(datasets, metrics, default_dataset_id, default_metric_id)
     initial_data = initial["data"]
     initial_columns = initial["columns"]
-    initial_score_columns = initial["score_columns"]
     initial_samples = initial.get("samples")
     with gr.Column(elem_classes="workspace-shell"):
         with gr.Column(elem_classes="workspace-filters") as filters_host:
             gr.Markdown(
                 "<p class='filter-help'>"
                 "These filters apply to Leaderboards, Pareto plots, and Samples. "
-                "Search in Models, or leave it empty to include every model."
+                "On Samples, only datasets we have generations for are listed. "
+                "On Pareto plots, only datasets with price or generation time "
+                "are listed. Search in Models, or leave it empty to include "
+                "every model."
                 "</p>",
                 elem_classes="filter-help-host",
             )
@@ -1163,12 +1102,9 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
                 ranking = gr.HTML(
                     _leaderboard_html(
                         _assign_leaderboard_ranks(
-                            initial_data,
-                            initial_score_columns[0] if initial_score_columns else None,
+                            initial_data, initial.get("score_column")
                         ),
                         initial_columns,
-                        initial_score_columns,
-                        initial_score_columns[0] if initial_score_columns else None,
                     ),
                     padding=False,
                     elem_classes="ranking-table-host",
@@ -1451,21 +1387,16 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
         view = resolve_view(datasets, metrics, dataset_id, metric_id)
         data = view["data"]
         if include_leaderboard:
-            sort_column = view["score_column"] or (
-                view["score_columns"][0] if view["score_columns"] else None
-            )
             note = _leaderboard_intro_markdown(view.get("note"))
             ranking_html = _leaderboard_html(
                 _filter_leaderboard(
-                    _assign_leaderboard_ranks(data, sort_column),
+                    _assign_leaderboard_ranks(data, view["score_column"]),
                     platform_value or [],
                     owner_value or [],
                     optimized_value or [],
                     models=models,
                 ),
                 view["columns"],
-                view["score_columns"],
-                sort_column,
             )
         else:
             note = gr.skip()
@@ -1495,7 +1426,8 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
             samples_visible,
         )
 
-    def on_dataset(
+    def _apply_filter_change(
+        source,
         dataset_id,
         metric_id,
         models,
@@ -1508,75 +1440,159 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
     ):
         view_state = dict(view_state or {})
         tab = view_state.get("current_tab") or TAB_LEADERBOARDS
-        dataset_changed = dataset_id != view_state.get("dataset_id")
-        synced = _synced_filters(
-            dataset_id,
-            metric_id,
-            models,
-            clear_metric=dataset_changed,
+        selected_raw = _normalize_metric_ids(metric_id)
+        incoming_models = list(models or [])
+        dataset_changed = source == "dataset" and dataset_id != view_state.get(
+            "dataset_id"
+        )
+
+        if source == "dataset":
+            synced = _synced_filters(
+                dataset_id, metric_id, models, clear_metric=dataset_changed
+            )
+            dataset_id, metric_id, models = synced[:3]
+            metric_update, models_update = synced[3], synced[4]
+        else:
+            metric_id = _coerce_metric(datasets, metrics, dataset_id, metric_id)
+            if source == "models":
+                allowed = set(
+                    _model_choice_values(_model_choices(datasets, dataset_id))
+                )
+                models = [model for model in incoming_models if model in allowed]
+                models_update = (
+                    gr.update(value=models)
+                    if models != incoming_models
+                    else gr.skip()
+                )
+            else:
+                models = incoming_models
+                models_update = gr.skip()
+            metric_update = (
+                gr.update(
+                    choices=_metric_dropdown_choices(datasets, metrics, dataset_id),
+                    value=_metric_dropdown_value(metric_id),
+                )
+                if source == "metric" and ALL_METRICS_ID in selected_raw
+                else gr.skip()
+            )
+
+        unchanged = _applied_key(view_state) == _selection_key(
+            dataset_id, metric_id, models
         )
-        dataset_id, metric_id, models = synced[:3]
         if (
             not dataset_changed
-            and _applied_key(view_state)
-            == _selection_key(dataset_id, metric_id, models)
+            and not (source == "metric" and ALL_METRICS_ID in selected_raw)
+            and unchanged
         ):
-            return _skip_all(len(dataset_outputs))
+            return None
+
+        selected_tab = tab
+        extras = (
+            list(platform_value or []),
+            list(owner_value or []),
+            list(optimized_value or []),
+        )
+        extra_updates = None
         can_pareto = _dataset_has_pareto(datasets, dataset_id)
         can_samples = _dataset_has_samples(datasets, dataset_id)
-        selected_tab = tab
-        if tab == TAB_SAMPLES and not can_samples:
-            selected_tab = TAB_LEADERBOARDS
-        elif tab == TAB_PARETO and not can_pareto:
-            selected_tab = TAB_LEADERBOARDS
+        if source == "dataset":
+            if tab == TAB_SAMPLES and not can_samples:
+                selected_tab = TAB_LEADERBOARDS
+            elif tab == TAB_PARETO and not can_pareto:
+                selected_tab = TAB_LEADERBOARDS
+            view = resolve_view(datasets, metrics, dataset_id, metric_id)
+            extra_updates = _leaderboard_extras(
+                view["data"] if view else None,
+                platform_value,
+                owner_value,
+                optimized_value,
+            )
+            extras = extra_updates[3:6]
+
         flags = _content_flags(selected_tab)
-        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,
-            extras[3],
-            extras[4],
-            extras[5],
-            num_prompts,
-            seed,
-            **flags,
-        )
         extras_payload = (
             {
-                "platform": extras[3],
-                "owner": extras[4],
-                "optimized": extras[5],
+                "platform": extras[0],
+                "owner": extras[1],
+                "optimized": extras[2],
             }
             if selected_tab == TAB_LEADERBOARDS
             else {}
         )
-        new_state = _commit_state(
-            view_state,
+        return {
+            "dataset_id": dataset_id,
+            "metric_update": metric_update,
+            "models_update": models_update,
+            "selected_tab": selected_tab,
+            "tab": tab,
+            "extra_updates": extra_updates,
+            "can_pareto": can_pareto,
+            "can_samples": can_samples,
+            "views": _views(
+                dataset_id,
+                metric_id,
+                models,
+                extras[0],
+                extras[1],
+                extras[2],
+                num_prompts,
+                seed,
+                **flags,
+            ),
+            "state": _commit_state(
+                view_state,
+                dataset_id,
+                metric_id,
+                models,
+                selected_tab,
+                flags,
+                extras=extras_payload,
+            ),
+        }
+
+    def on_dataset(
+        dataset_id,
+        metric_id,
+        models,
+        platform_value,
+        owner_value,
+        optimized_value,
+        num_prompts,
+        seed,
+        view_state,
+    ):
+        result = _apply_filter_change(
+            "dataset",
             dataset_id,
             metric_id,
             models,
-            selected_tab,
-            flags,
-            extras=extras_payload,
+            platform_value,
+            owner_value,
+            optimized_value,
+            num_prompts,
+            seed,
+            view_state,
         )
+        if result is None:
+            return _skip_all(len(dataset_outputs))
+        extras = result["extra_updates"]
         return (
-            synced[3],
-            synced[4],
+            _dataset_dropdown_update(
+                datasets, result["selected_tab"], result["dataset_id"]
+            ),
+            result["metric_update"],
+            result["models_update"],
             extras[6],
             extras[0],
             extras[1],
             extras[2],
-            *views,
-            gr.update(interactive=can_pareto),
-            gr.update(interactive=can_samples),
-            gr.update(selected=selected_tab)
-            if selected_tab != tab
+            *result["views"],
+            gr.update(interactive=result["can_pareto"]),
+            gr.update(interactive=result["can_samples"]),
+            gr.update(selected=result["selected_tab"])
+            if result["selected_tab"] != result["tab"]
             else gr.skip(),
-            new_state,
+            result["state"],
         )
 
     def on_metric(
@@ -1590,19 +1606,8 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
         seed,
         view_state,
     ):
-        view_state = dict(view_state or {})
-        tab = view_state.get("current_tab") or TAB_LEADERBOARDS
-        selected_raw = _normalize_metric_ids(metric_id)
-        metric_id = _coerce_metric(datasets, metrics, dataset_id, metric_id)
-        models = list(models or [])
-        if (
-            ALL_METRICS_ID not in selected_raw
-            and _applied_key(view_state)
-            == _selection_key(dataset_id, metric_id, models)
-        ):
-            return _skip_all(len(metric_outputs))
-        flags = _content_flags(tab)
-        views = _views(
+        result = _apply_filter_change(
+            "metric",
             dataset_id,
             metric_id,
             models,
@@ -1611,39 +1616,11 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
             optimized_value,
             num_prompts,
             seed,
-            **flags,
-        )
-        extras_payload = (
-            {
-                "platform": platform_value or [],
-                "owner": owner_value or [],
-                "optimized": optimized_value or [],
-            }
-            if tab == TAB_LEADERBOARDS
-            else {}
-        )
-        new_state = _commit_state(
             view_state,
-            dataset_id,
-            metric_id,
-            models,
-            tab,
-            flags,
-            extras=extras_payload,
-        )
-        metric_update = (
-            gr.update(
-                choices=_metric_dropdown_choices(datasets, metrics, dataset_id),
-                value=_metric_dropdown_value(metric_id),
-            )
-            if ALL_METRICS_ID in selected_raw
-            else gr.skip()
-        )
-        return (
-            metric_update,
-            *views,
-            new_state,
         )
+        if result is None:
+            return _skip_all(len(metric_outputs))
+        return (result["metric_update"], *result["views"], result["state"])
 
     def on_models(
         dataset_id,
@@ -1656,18 +1633,8 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
         seed,
         view_state,
     ):
-        view_state = dict(view_state or {})
-        tab = view_state.get("current_tab") or TAB_LEADERBOARDS
-        metric_id = _coerce_metric(datasets, metrics, dataset_id, metric_id)
-        incoming = list(models or [])
-        model_values = set(
-            _model_choice_values(_model_choices(datasets, dataset_id))
-        )
-        models = [model for model in incoming if model in model_values]
-        if _applied_key(view_state) == _selection_key(dataset_id, metric_id, models):
-            return _skip_all(len(models_outputs))
-        flags = _content_flags(tab)
-        views = _views(
+        result = _apply_filter_change(
+            "models",
             dataset_id,
             metric_id,
             models,
@@ -1676,30 +1643,11 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
             optimized_value,
             num_prompts,
             seed,
-            **flags,
-        )
-        extras_payload = (
-            {
-                "platform": platform_value or [],
-                "owner": owner_value or [],
-                "optimized": optimized_value or [],
-            }
-            if tab == TAB_LEADERBOARDS
-            else {}
-        )
-        new_state = _commit_state(
             view_state,
-            dataset_id,
-            metric_id,
-            models,
-            tab,
-            flags,
-            extras=extras_payload,
-        )
-        models_update = (
-            gr.update(value=models) if models != incoming else gr.skip()
         )
-        return (models_update, *views, new_state)
+        if result is None:
+            return _skip_all(len(models_outputs))
+        return (result["models_update"], *result["views"], result["state"])
 
     def on_tab_select(
         tab,
@@ -1715,6 +1663,11 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
     ):
         view_state = dict(view_state or {})
         prev_tab = view_state.get("current_tab") or TAB_LEADERBOARDS
+        requested_tab = tab
+        if tab == TAB_SAMPLES and not _dataset_has_samples(datasets, dataset_id):
+            tab = TAB_LEADERBOARDS
+        elif tab == TAB_PARETO and not _dataset_has_pareto(datasets, dataset_id):
+            tab = TAB_LEADERBOARDS
         if prev_tab == TAB_LEADERBOARDS:
             _save_leaderboard_filters(
                 view_state,
@@ -1722,9 +1675,10 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
                 owner_value,
                 optimized_value,
             )
-        view_state["current_tab"] = tab
+        dataset_update = _dataset_dropdown_update(datasets, tab, dataset_id)
         metric_id = _coerce_metric(datasets, metrics, dataset_id, metric_id)
         models = list(models or [])
+        view_state["current_tab"] = tab
         view_state["dataset_id"] = dataset_id
         view_state["metric_id"] = metric_id
         view_state["models"] = models
@@ -1756,11 +1710,23 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
         else:
             lb_filters = _skip_all(4)
         stale = dict(view_state.get("stale") or {})
-        chrome = (filters_vis, metric_vis, *lb_filters)
+        chrome = (
+            filters_vis,
+            dataset_update,
+            metric_vis,
+            gr.skip(),
+            *lb_filters,
+        )
+        tab_select = (
+            gr.update(selected=tab)
+            if tab != requested_tab
+            else gr.skip()
+        )
         if tab == TAB_ABOUT or not stale.get(tab, True):
             return (
                 *chrome,
                 *_skip_all(len(view_outputs)),
+                tab_select,
                 view_state,
             )
         flags = _content_flags(tab)
@@ -1777,7 +1743,7 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
         )
         stale[tab] = False
         view_state["stale"] = stale
-        return (*chrome, *views, view_state)
+        return (*chrome, *views, tab_select, view_state)
 
     def on_leaderboard_filters(
         dataset_id,
@@ -1796,21 +1762,16 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
             optimized_value,
         )
         view = resolve_view(datasets, metrics, dataset_id, metric_id)
-        sort_column = view["score_column"] or (
-            view["score_columns"][0] if view["score_columns"] else None
-        )
         return (
             _leaderboard_html(
                 _filter_leaderboard(
-                    _assign_leaderboard_ranks(view["data"], sort_column),
+                    _assign_leaderboard_ranks(view["data"], view["score_column"]),
                     platform_value or [],
                     owner_value or [],
                     optimized_value or [],
                     models=models,
                 ),
                 view["columns"],
-                view["score_columns"],
-                sort_column,
             ),
             view_state,
         )
@@ -1913,6 +1874,7 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
     filter_inputs = [dataset_dd, metric_dd, models_dd, *view_inputs]
 
     dataset_outputs = [
+        dataset_dd,
         metric_dd,
         models_dd,
         lb_controls,
@@ -1958,12 +1920,15 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
 
     tab_outputs = [
         filters_host,
+        dataset_dd,
         metric_dd,
+        models_dd,
         lb_controls,
         platform,
         owner,
         optimized,
         *view_outputs,
+        main_tabs,
         view_state,
     ]
     for tab, tab_item in (