feat: add AA and Arenaai results, fix some ui features

app.py

@@ -2023,6 +2023,29 @@ footer, .footer { display: none !important; }
     color: var(--pruna-text-primary) !important;
     font-size: 1rem;
 }
+.pareto-panel-host {
+    display: flex;
+    flex-direction: column;
+    gap: 1.5rem;
+}
+.pareto-metric-block {
+    padding-bottom: 0.5rem;
+    border-bottom: 1px solid var(--pruna-hairline);
+}
+.pareto-metric-block:last-child {
+    border-bottom: none;
+}
+.pareto-metric-title {
+    margin: 0 0 0.75rem;
+    color: var(--pruna-text-primary);
+    font-size: 1.05rem;
+    font-weight: 600;
+}
+.pareto-subhead {
+    margin: 0 0 0.35rem;
+    color: var(--pruna-text-muted);
+    font-size: 0.9rem;
+}
 
 .options,
 ul.options,
@@ -2271,6 +2294,72 @@ def load_oneig_dataframe(path):
     return df
 
 
+def load_artificial_analysis_dataframe(path):
+    """Load the Artificial Analysis text-to-image leaderboard."""
+    df = pd.read_csv(path, na_values=["N/A", "n/a", ""])
+    df = df.rename(
+        columns={
+            "model": "Model",
+            "elo": "Artificial Analysis Elo",
+            "price_per_image_usd": "Price / Image (USD)",
+        }
+    )
+    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)
+
+
+ARENA_CATEGORY_COLUMNS = {
+    "product_branding_commercial_design_elo": "Arena Branding / Commercial Elo",
+    "3d_imaging_and_modeling_elo": "Arena 3D Imaging Elo",
+    "cartoon_anime_and_fantasy_elo": "Arena Cartoon / Anime Elo",
+    "photorealistic_and_cinematic_imagery_elo": "Arena Photorealistic Elo",
+    "art_elo": "Arena Art Elo",
+    "portraits_elo": "Arena Portraits Elo",
+    "text_rendering_elo": "Arena Text Rendering Elo",
+}
+
+
+def load_arena_ai_dataframe(path):
+    """Load the Arena AI text-to-image leaderboard (overall + category Elos)."""
+    df = pd.read_csv(path, na_values=["N/A", "n/a", ""])
+    rename_map = {"model": "Model", "elo": "Arena Elo"}
+    rename_map.update(
+        {
+            source: label
+            for source, label in ARENA_CATEGORY_COLUMNS.items()
+            if source in df.columns
+        }
+    )
+    df = df.rename(columns=rename_map)
+    df["Model"] = df["Model"].astype(str).str.strip()
+    score_columns = [
+        column
+        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)
+    ordered = ["Model", *score_columns]
+    return df[[column for column in ordered if column in df.columns]].reset_index(
+        drop=True
+    )
+
+
 def load_qwen_combined_dataframe(path):
     """Load the combined Qwen Image Bench metrics table."""
     df = pd.read_csv(path, na_values=["N/A", "n/a", ""])
@@ -2288,7 +2377,6 @@ 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")
@@ -2369,8 +2457,18 @@ qwen_path = _resolve_data_path(
     data_dir / "qwen_image_bench_model_price_and_median_generation_time.csv",
     space_root.parent / "qwen_image_bench_model_price_and_median_generation_time.csv",
 )
+aa_path = _resolve_data_path(
+    data_dir / "artificial_analysis_text_to_image_leaderboard.csv",
+    space_root.parent / "artificial_analysis_text_to_image_leaderboard.csv",
+)
+arena_path = _resolve_data_path(
+    data_dir / "arena_ai_text_to_image_leaderboard.csv",
+    space_root.parent / "arena_ai_text_to_image_leaderboard.csv",
+)
 
 qwen_df = load_qwen_combined_dataframe(qwen_path)
+aa_df = load_artificial_analysis_dataframe(aa_path)
+arena_df = load_arena_ai_dataframe(arena_path)
 qwen_display_columns = [
     col
     for col in [
@@ -2389,12 +2487,19 @@ aa_display_columns = [
     col
     for col in [
         "Model",
-        "Benchmark.ai Elo",
-        "Median Generation Time (s)",
-        "Min Generation Time (s)",
+        "Artificial Analysis Elo",
         "Price / Image (USD)",
     ]
-    if col in qwen_df.columns
+    if col in aa_df.columns
+]
+arena_display_columns = [
+    col
+    for col in [
+        "Model",
+        "Arena Elo",
+        *ARENA_CATEGORY_COLUMNS.values(),
+    ]
+    if col in arena_df.columns
 ]
 
 oneig_samples = load_sample_comparison_data(oneig_combined_dir)
@@ -2439,7 +2544,47 @@ metrics = [
     {
         "id": "aa_elo",
         "name": "Artificial Analysis ELO Metric",
-        "column": "Benchmark.ai Elo",
+        "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",
     },
 ]
 
@@ -2467,7 +2612,20 @@ oneig_metric_ids = _metric_ids_for(
         "datapoint_elo_object",
     ],
 )
-aa_metric_ids = _metric_ids_for(qwen_df, ["aa_elo"])
+aa_metric_ids = _metric_ids_for(aa_df, ["aa_elo"])
+arena_metric_ids = _metric_ids_for(
+    arena_df,
+    [
+        "arena_elo",
+        "arena_branding",
+        "arena_3d",
+        "arena_cartoon",
+        "arena_photo",
+        "arena_art",
+        "arena_portraits",
+        "arena_text",
+    ],
+)
 
 datasets = [
     {
@@ -2496,14 +2654,21 @@ datasets = [
     },
     {
         "id": "artificial_analysis",
-        "name": "Artificial Analysis Dataset",
-        "data": qwen_df,
+        "name": "Artificial Analysis",
+        "data": aa_df,
         "columns": aa_display_columns,
         "metric_ids": aa_metric_ids,
-        "note": (
-            "> Ranked by Artificial Analysis Elo from the evaluation table."
-        ),
-        "samples": qwen_samples,
+        "note": "",
+        "samples": None,
+    },
+    {
+        "id": "arena_ai",
+        "name": "Arena AI",
+        "data": arena_df,
+        "columns": arena_display_columns,
+        "metric_ids": arena_metric_ids,
+        "note": "",
+        "samples": None,
     },
 ]
 datasets = [dataset for dataset in datasets if dataset["metric_ids"]]
@@ -2512,11 +2677,7 @@ 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)
-)
+DEFAULT_METRIC_ID = None
 
 
 custom_head = """

data/arena_ai_text_to_image_leaderboard.csv

@@ -0,0 +1,77 @@
+model,elo,product_branding_commercial_design_elo,3d_imaging_and_modeling_elo,cartoon_anime_and_fantasy_elo,photorealistic_and_cinematic_imagery_elo,art_elo,portraits_elo,text_rendering_elo
+gpt-image-2 (medium),1381,1391,1361,1397,1380,1370,1429,1425
+mai-image-2.6-preview,1336,1344,1362,1355,1325,1345,1365,1374
+grok-imagine-image-2.0 (low),1316,1309,1268,1321,1327,1306,1371,1353
+reve-2.1,1302,1314,1274,1310,1302,1289,1317,1341
+muse-image,1282,1269,1255,1289,1293,1275,1313,1304
+reve-2.0,1270,1279,1220,1275,1280,1259,1283,1297
+gemini-3.1-flash-image (nano-banana-2) [web-search],1264,1271,1260,1268,1270,1251,1266,1295
+seedream-5.0-pro,1258,1234,1246,1273,1280,1269,1291,1255
+qwen-image-3.0-pro,1257,1258,1240,1271,1257,1257,1273,1289
+mai-image-2.5,1256,1261,1248,1270,1252,1278,1259,1284
+gemini-3.1-flash-lite-image (nano-banana-2-lite),1251,1250,1225,1258,1260,1257,1248,1275
+gemini-3-pro-image-2k (nano-banana-pro),1246,1246,1231,1242,1260,1225,1258,1270
+gpt-image-1.5-high-fidelity,1239,1241,1216,1243,1249,1224,1261,1254
+gemini-3-pro-image-preview (nano-banana-pro),1232,1237,1209,1238,1243,1216,1236,1254
+ideogram-4.0-quality,1204,1224,1180,1195,1203,1199,1201,1238
+qwen-image-2.0-pro-2026-06-22,1191,1187,1198,1191,1205,1177,1216,1201
+uni-1.1-max,1188,1197,1172,1194,1188,1195,1158,1217
+mai-image-2,1183,1175,1179,1180,1203,1177,1207,1175
+uni-1.1,1181,1181,1167,1189,1180,1188,1176,1202
+Cosmos3-Super-Text2Image (Agentic),1175,1162,1170,1191,1189,1195,1212,1151
+grok-imagine-image,1171,1175,1176,1177,1179,1179,1187,1185
+recraft-v4.1-utility-pro,1169,1167,1147,1177,1180,1178,1169,1162
+flux-2-max,1162,1165,1161,1169,1161,1170,1157,1167
+grok-imagine-image-pro,1161,1168,1165,1163,1169,1165,1172,1182
+flux-2-flex,1157,1173,1172,1162,1147,1156,1145,1172
+flux-2-pro,1155,1157,1150,1161,1152,1163,1146,1157
+Cosmos3-Super-Text2Image,1155,1129,1166,1177,1155,1173,1176,1122
+reve-v1.5,1154,1182,1143,1141,1147,1144,1149,1185
+hunyuan-image-3.0,1151,1153,1168,1163,1152,1153,1146,1150
+gemini-2.5-flash-image-preview (nano-banana),1150,1152,1142,1145,1157,1145,1168,1154
+imagen-ultra-4.0-generate-001,1148,1151,1141,1141,1156,1128,1168,1148
+seedream-4.5,1147,1140,1147,1149,1166,1154,1166,1141
+flux-2-dev,1145,1155,1149,1144,1143,1150,1133,1159
+seedream-4-2k,1140,1134,1150,1149,1151,1164,1142,1143
+seedream-5.0-lite,1137,1129,1138,1140,1154,1137,1150,1134
+wan2.6-t2i,1136,1148,1146,1146,1128,1156,1123,1149
+recraft-v4.1-pro,1130,1138,1111,1122,1143,1154,1144,1156
+imagen-4.0-generate-001,1129,1129,1123,1120,1136,1110,1145,1123
+qwen-image-2512,1125,1128,1135,1125,1135,1133,1143,1122
+krea-2-medium,1122,1119,1132,1140,1127,1152,1148,1124
+wan2.5-t2i-preview,1117,1138,1135,1120,1102,1120,1094,1142
+hidream-o1-image,1117,1128,1121,1121,1111,1122,1106,1135
+seedream-4-fal,1116,1128,1138,1109,1121,1119,1116,1124
+gpt-image-1,1115,1115,1114,1115,1115,1115,1115,1115
+recraft-v4,1114,1126,1076,1111,1119,1123,1119,1139
+seedream-4-high-res-fal,1113,1113,1121,1109,1129,1112,1133,1110
+krea-2-turbo,1111,1109,1133,1122,1123,1139,1138,1097
+gpt-image-1-mini,1109,1109,1108,1108,1114,1113,1112,1104
+krea-2-large,1107,1104,1113,1112,1121,1116,1117,1111
+wan2.7-image-pro,1103,1114,1080,1080,1123,1079,1127,1118
+wan2.7-image,1100,1110,1082,1075,1117,1075,1125,1114
+mai-image-1,1093,1086,1096,1100,1103,1104,1095,1070
+seedream-3,1082,1070,1094,1081,1102,1092,1102,1052
+z-image-turbo,1082,1060,1066,1067,1115,1074,1140,1058
+flux-1-kontext-max,1074,1082,1079,1079,1083,1081,1085,1071
+flux-2-klein-9b,1070,1070,1078,1064,1090,1079,1092,1057
+qwen-image-prompt-extend,1061,1087,1082,1062,1047,1055,1051,1082
+flux-1-kontext-pro,1059,1068,1062,1058,1066,1067,1065,1053
+imagen-3.0-generate-002,1058,1057,1046,1048,1075,1059,1077,1045
+qwen-image,1057,1068,1064,1052,1062,1055,1076,1047
+ideogram-v3-quality,1049,1082,1029,1027,1051,1039,1052,1070
+photon,1035,1052,1033,1026,1035,1046,1023,1041
+p-image,1034,1031,1031,1014,1074,1041,1100,1021
+flux-2-klein-4b,1030,1026,1030,1023,1047,1028,1054,1015
+runway-gen4,1025,1027,1013,1008,1041,1019,1022,1019
+recraft-v3,1021,1027,1011,978,1054,991,1040,1005
+flux-1.1-pro,1016,1012,1051,1016,1044,1044,1043,995
+lucid-origin,1013,1020,1015,1007,1035,1031,1043,1005
+ideogram-v2,1013,1054,990,995,1019,1017,1019,1046
+glm-image,1010,1036,1018,1003,1000,1013,1000,1033
+gemini-2.0-flash-preview-image-generation,975,1019,976,954,963,965,961,1007
+flux-1-dev-fp8,969,991,978,957,990,978,999,963
+dall-e-3,968,987,987,988,940,1010,924,969
+flux-1-kontext-dev,940,966,943,924,935,927,944,953
+stable-diffusion-v35-large,938,937,964,946,928,998,941,921
+bagel,898,887,866,885,923,911,926,875

data/artificial_analysis_text_to_image_leaderboard.csv

@@ -0,0 +1,146 @@
+model,elo,price_per_image_usd
+GPT Image 2 (high),1370,0.211
+Reve 2.1,1324,0.2
+Nano Banana 2 (Gemini 3.1 Flash Image Preview),1322,0.067
+GPT Image 1.5 (high),1312,0.133
+MAI-Image-2.5,1306,0.0481
+Nano Banana Pro (Gemini 3 Pro Image),1298,0.134
+Nano Banana 2 Lite (Gemini 3.1 Flash Lite Image),1292,0.0336
+Seedream 5.0 Pro,1281,0.09
+grok-imagine-image-quality,1236,0.05
+Qwen Image 2.0 Pro (2026-04-22),1235,0.075
+FLUX.2 [max],1231,0.07
+MAI-Image-2.5-Flash,1230,0.02
+HiDream-O1-Image-1.5,1227,0.08
+Seedream 4.0,1224,0.03
+Luma UNI 1 Max,1223,0.1
+FLUX.2 [flex],1222,0.06
+Krea 2 Medium Turbo,1222,0.015
+Krea 2 Large,1220,0.06
+grok-imagine-image,1218,0.02
+Recraft V4.1 Utility,1217,0.035
+Ideogram 4.0,1217,0.06
+Recraft V4.1 Utility Pro,1217,0.21
+Ideogram 4.0 (Quality),1214,0.1
+Wan2.6 Text to Image,1213,0.03
+Krea 2 Medium,1212,0.03
+MAI-Image-2,1210,0.035
+FLUX.2 [pro],1208,0.03
+Wan 2.6 Image,1206,0.03
+Seedream 4.5,1205,0.04
+GPT Image 1 (high),1205,0.167
+Luma UNI 1,1205,0.0404
+FLUX.2 [dev] Turbo,1199,0.008
+FLUX.2 [dev],1199,0.012
+Seedream 5.0 Lite,1199,0.035
+Ideogram 4.0 Fast (Quality),1199,0.0175
+P-Image-Ideogram (High),1198,0.015
+Recraft V4 Pro,1195,0.25
+Recraft V4.1,1191,0.035
+Nano Banana (Gemini 2.5 Flash Image),1189,0.039
+Recraft V4.1 Pro,1189,0.21
+Imagen 4 Ultra,1189,0.06
+Ideogram 4.0 Instant,1187,0.0075
+Wan 2.7 Pro,1184,0.064
+Recraft V4,1182,0.04
+MAI-Image-2-Efficient,1182,0.022
+P-Image-Ideogram (Medium),1181,0.01
+FLUX.2 [dev] Flash,1179,0.005
+HiDream-O1-Image,1176,
+Ideogram 4.0 Fast,1176,0.0105
+ImagineArt 2.0,1173,0.03
+Qwen Image Max 2512,1173,0.02
+Wan 2.7,1170,0.026
+ImagineArt 1.5 Preview,1165,0.03
+P-Image-Ideogram (Low),1165,0.0075
+Seedream 3.0,1160,0.03
+Vivago 2.1,1152,0.035
+HunyuanImage 3.0 Instruct (Fal),1151,0.09
+Wan 2.5 Preview,1150,0.021
+FLUX.2 [klein] 9B,1146,0.015
+FLUX.1 Kontext [max],1142,0.08
+Kolors 2.1,1142,0.014
+image-1,1141,0.04
+HunyuanImage 3.0 (Fal),1140,0.1
+Qwen Image 2.0 (2026-03-03),1135,0.035
+Z-Image Turbo,1130,0.005
+Vivago 2.0,1125,
+Imagen 3 (v002),1124,0.04
+Lucid Origin Ultra,1122,0.0867
+Eigen Image,1122,0.025
+Imagen 4 Standard,1120,0.04
+Reve Image (Halfmoon),1116,
+Kling Image 3.0 Omni,1115,0.028
+Vidu Q2,1112,0.03
+P-Image-Ideogram (Very Low),1111,0.003
+Qwen Image Plus 2601,1110,0.03
+GPT Image 1 Mini (medium),1110,0.011
+Lucid Origin Fast,1110,0.0179
+FLUX.1 Kontext [pro],1109,0.04
+Dreamina 3.1,1108,0.03
+FLUX1.1 [pro] Ultra,1104,0.06
+Ideogram 3.0,1101,0.06
+FLUX.2 [klein] Base 9B,1099,0.011
+Imagen 4 Fast,1098,0.02
+P-Image,1093,0.005
+FLUX1.1 [pro],1092,0.04
+Midjourney v7 Alpha,1092,
+Ideogram v2,1084,0.08
+FLUX.1 [pro],1083,0.05
+Qwen Image,1082,0.02
+SRPO,1080,0.026
+HunyuanImage 2.1,1078,0.1
+Midjourney v6,1076,
+Ideogram v2 Turbo,1075,0.05
+FIBO,1075,0.04
+Recraft V3,1075,0.04
+Luma Photon,1074,0.019
+HiDream-O1-Image-Dev,1071,0.005
+Image-01,1070,0.01
+HiDream-I1-Dev,1070,0.024
+GLM-Image,1068,0.05
+Z-Image Base,1064,0.01
+MAI Image 1,1064,
+HiDream-I1-Fast,1063,0.012
+FLUX.2 [klein] 4B,1057,0.014
+Midjourney v6.1,1057,
+Infinity 8B,1056,0.0017
+LongCat Image,1053,0.13
+Stable Diffusion 3 Large,1042,
+FLUX.1 [dev],1041,0.025
+Phoenix 1.0 Ultra,1041,0.0762
+FLUX.1 Krea [dev],1036,0.025
+Stable Diffusion 3.5 Large Turbo,1034,0.04
+Stable Diffusion 3.5 Large,1034,0.065
+Phoenix 0.9 Ultra,1028,0.0762
+Ideogram v2a Turbo,1028,0.025
+Ideogram v2a,1027,0.04
+Playground v3 (beta),1015,0.0105
+Krea 1,1013,
+Phoenix 1.0 Fast,1007,0.0194
+Luma Photon Flash,1004,0.005
+FLUX.1 [schnell],1000,0.003
+Step Image Edit 2,1000,0.003
+Runway Gen-4 Image,992,0.08
+Recraft 20B,984,0.022
+Lumina Image v2,978,0.075
+Playground v2.5,972,0.08
+FLUX.2 [klein] Base 4B,972,0.009
+DALLE 3,968,0.04
+DALLE 3 HD,967,0.08
+Stable Diffusion 3.5 Medium,963,0.02
+Sana Sprint 1.6B,939,0.0015
+Amazon Titan G1 v2 (Standard),923,0.01
+Stable Diffusion 3 Medium,922,0.035
+Stable Diffusion 3 Large Turbo,917,
+Amazon Titan G1 (Standard),914,0.01
+Stable Diffusion 1.6,914,0.009
+OmniGen V2,911,0.15
+SDXL Lightning,909,0.0019
+Bagel,908,0.1
+Bria 3.2,906,0.04
+Stable Diffusion XL 1.0,884,0.009
+Stable Diffusion 2.1,754,0.0039
+DALLE 2,745,0.02
+Janus Pro,720,0.0
+Stable Diffusion 1.5,665,0.044

model_display.py

@@ -0,0 +1,251 @@
+"""UI-only model display names.
+
+Raw CSV / sample IDs stay unchanged; this maps aliases to a shared label
+shown in leaderboards, Pareto plots, dropdowns, and sample headers.
+"""
+
+from __future__ import annotations
+
+import re
+
+# Explicit aliases (any leaderboard / sample id) -> shared display label.
+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",
+    "gpt_image_1_5": "GPT Image 1.5",
+    "GPT Image 1.5 (high)": "GPT Image 1.5",
+    "gpt_image_1": "GPT Image 1",
+    "GPT Image 1 (high)": "GPT Image 1",
+    "GPT Image 1 Mini (medium)": "GPT Image 1 Mini",
+    # Nano Banana / Gemini
+    "nano_banana_2_0": "Nano Banana 2",
+    "nano_banana_2": "Nano Banana 2",
+    "Nano Banana 2 (Gemini 3.1 Flash Image Preview)": "Nano Banana 2",
+    "Nano Banana 2 Lite (Gemini 3.1 Flash Lite Image)": "Nano Banana 2 Lite",
+    "nano_banana_pro": "Nano Banana Pro",
+    "Nano Banana Pro (Gemini 3 Pro Image)": "Nano Banana Pro",
+    "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",
+    "HiDream-I1-Dev": "HiDream-I1 Dev",
+    "hidream_i1_fast": "HiDream-I1 Fast",
+    "HiDream-I1-Fast": "HiDream-I1 Fast",
+    "hidream_i1_full": "HiDream-I1 Full",
+    "HiDream-O1-Image": "HiDream-O1",
+    "HiDream-O1-Image-1.5": "HiDream-O1 1.5",
+    "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",
+    "p_image_2_ideogram_low_1k": "P-Image-Ideogram Low 1K",
+    "p_image_2_ideogram_low_2k": "P-Image-Ideogram Low 2K",
+    "P-Image-Ideogram (Low)": "P-Image-Ideogram Low",
+    "p_image_2_ideogram_medium_1k": "P-Image-Ideogram Medium 1K",
+    "p_image_2_ideogram_medium_2k": "P-Image-Ideogram Medium 2K",
+    "P-Image-Ideogram (Medium)": "P-Image-Ideogram Medium",
+    "p_image_2_ideogram_high_1k": "P-Image-Ideogram High 1K",
+    "p_image_2_ideogram_high_2k": "P-Image-Ideogram High 2K",
+    "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",
+    "gpt-image-1": "GPT Image 1",
+    "gpt-image-1-mini": "GPT Image 1 Mini",
+    "mai-image-2.6-preview": "MAI-Image-2.6 Preview",
+    "mai-image-2.5": "MAI-Image-2.5",
+    "mai-image-2": "MAI-Image-2",
+    "mai-image-1": "MAI Image 1",
+    "grok-imagine-image-2.0 (low)": "Grok Imagine Image 2.0",
+    "grok-imagine-image": "Grok Imagine Image",
+    "grok-imagine-image-pro": "Grok Imagine Image Pro",
+    "reve-2.1": "Reve 2.1",
+    "reve-2.0": "Reve 2.0",
+    "reve-v1.5": "Reve 1.5",
+    "muse-image": "Muse Image",
+    "gemini-3.1-flash-image (nano-banana-2) [web-search]": "Nano Banana 2",
+    "gemini-3.1-flash-lite-image (nano-banana-2-lite)": "Nano Banana 2 Lite",
+    "gemini-3-pro-image-2k (nano-banana-pro)": "Nano Banana Pro 2K",
+    "gemini-3-pro-image-preview (nano-banana-pro)": "Nano Banana Pro",
+    "gemini-2.5-flash-image-preview (nano-banana)": "Nano Banana",
+    "gemini-2.0-flash-preview-image-generation": "Gemini 2.0 Flash Image",
+    "seedream-5.0-pro": "Seedream 5.0 Pro",
+    "seedream-5.0-lite": "Seedream 5.0 Lite",
+    "seedream-4.5": "Seedream 4.5",
+    "seedream-4-2k": "Seedream 4.0 2K",
+    "seedream-4-fal": "Seedream 4.0",
+    "seedream-4-high-res-fal": "Seedream 4.0 High Res",
+    "seedream-3": "Seedream 3.0",
+    "qwen-image-3.0-pro": "Qwen Image 3.0 Pro",
+    "qwen-image-2.0-pro-2026-06-22": "Qwen Image 2.0 Pro",
+    "qwen-image-2512": "Qwen Image 2512",
+    "qwen-image-prompt-extend": "Qwen Image Prompt Extend",
+    "qwen-image": "Qwen Image",
+    "uni-1.1-max": "Luma UNI 1 Max",
+    "uni-1.1": "Luma UNI 1",
+    "Cosmos3-Super-Text2Image (Agentic)": "Cosmos3 Super Text2Image (Agentic)",
+    "Cosmos3-Super-Text2Image": "Cosmos3 Super Text2Image",
+    "recraft-v4.1-utility-pro": "Recraft V4.1 Utility Pro",
+    "recraft-v4.1-pro": "Recraft V4.1 Pro",
+    "recraft-v4": "Recraft V4",
+    "recraft-v3": "Recraft V3",
+    "flux-2-max": "FLUX.2 [max]",
+    "flux-2-flex": "FLUX.2 [flex]",
+    "flux-2-pro": "FLUX.2 [pro]",
+    "flux-2-dev": "FLUX.2 [dev]",
+    "flux-2-klein-9b": "FLUX.2 [klein] 9B",
+    "flux-2-klein-4b": "FLUX.2 [klein] 4B",
+    "flux-1-kontext-max": "FLUX.1 Kontext [max]",
+    "flux-1-kontext-pro": "FLUX.1 Kontext [pro]",
+    "flux-1-kontext-dev": "FLUX.1 Kontext [dev]",
+    "flux-1.1-pro": "FLUX1.1 [pro]",
+    "flux-1-dev-fp8": "FLUX.1 [dev]",
+    "hunyuan-image-3.0": "HunyuanImage 3.0",
+    "imagen-ultra-4.0-generate-001": "Imagen 4 Ultra",
+    "imagen-4.0-generate-001": "Imagen 4",
+    "imagen-3.0-generate-002": "Imagen 3",
+    "wan2.6-t2i": "Wan 2.6 Text to Image",
+    "wan2.5-t2i-preview": "Wan 2.5 Preview",
+    "wan2.7-image-pro": "Wan 2.7 Pro",
+    "wan2.7-image": "Wan 2.7",
+    "ideogram-4.0-quality": "Ideogram 4.0 Quality",
+    "ideogram-v3-quality": "Ideogram 3.0",
+    "ideogram-v2": "Ideogram v2",
+    "krea-2-medium": "Krea 2 Medium",
+    "krea-2-turbo": "Krea 2 Medium Turbo",
+    "krea-2-large": "Krea 2 Large",
+    "hidream-o1-image": "HiDream-O1",
+    "z-image-turbo": "Z-Image Turbo",
+    "photon": "Luma Photon",
+    "p-image": "P-Image",
+    "runway-gen4": "Runway Gen-4 Image",
+    "lucid-origin": "Lucid Origin",
+    "glm-image": "GLM-Image",
+    "dall-e-3": "DALLE 3",
+    "stable-diffusion-v35-large": "Stable Diffusion 3.5 Large",
+    "bagel": "Bagel",
+}
+
+
+def _prettify_snake_case(model_id: str) -> str:
+    parts = [part for part in str(model_id).split("_") if part]
+    pretty = []
+    for part in parts:
+        if part.isdigit():
+            pretty.append(part)
+        elif re.fullmatch(r"\d+k", part, flags=re.IGNORECASE):
+            pretty.append(part.upper())
+        elif part.lower() in {"flux", "gpt", "sdxl", "glm"}:
+            pretty.append(part.upper())
+        else:
+            pretty.append(part.capitalize())
+    return " ".join(pretty)
+
+
+def display_model_name(model_id) -> str:
+    """Return the shared UI label for a raw model id / source name."""
+    if model_id is None:
+        return ""
+    raw = str(model_id).strip()
+    if not raw:
+        return ""
+    if raw in MODEL_DISPLAY_NAMES:
+        return MODEL_DISPLAY_NAMES[raw]
+    # Already a human label (spaces / punctuation) — keep as-is.
+    if re.search(r"[\s.\[\]()]", raw):
+        return raw
+    return _prettify_snake_case(raw)

ui.py

@@ -7,6 +7,8 @@ import gradio as gr
 import pandas as pd
 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 = (
     "data:image/png;base64,"
@@ -19,6 +21,7 @@ _MASCOT_DATA_URI = (
 MAX_COMPARE_MODELS = 4
 DEFAULT_COMPARE_PROMPTS = 3
 MAX_COMPARE_PROMPTS = 8
+MAX_PARETO_METRICS = 8
 
 ABOUT_OVERVIEW_CONTENT = """
 # About P-Bench
@@ -43,8 +46,7 @@ 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) or by
-   Artificial Analysis Elo.
+   available, by human preference (Datapoint Elo, Rapidata Elo).
 4. Price per image and generation time are joined from the evaluation table.
 
 ## Current datasets
@@ -59,10 +61,6 @@ 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. Alignment Overall is the mean of the category
 scores that exist for that row.
-
-### Artificial Analysis Dataset
-Artificial Analysis Elo from the evaluation table. Rapidata is a **metric**,
-not a dataset.
 """
 
 ABOUT_DETAILS_CONTENT = """
@@ -79,8 +77,6 @@ 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**: 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.
@@ -186,8 +182,23 @@ def _item(items, item_id):
     return items[0] if items else None
 
 
-def _dataset_choices(datasets):
-    return [(dataset["name"], dataset["id"]) for dataset in datasets]
+def _dataset_choices(datasets, *, require_samples=False):
+    return [
+        (dataset["name"], dataset["id"])
+        for dataset in datasets
+        if not require_samples or dataset.get("samples")
+    ]
+
+
+def _coerce_sample_dataset(datasets, dataset_id):
+    """Prefer datasets that have compare-sample artifacts."""
+    dataset = _item(datasets, dataset_id)
+    if dataset and dataset.get("samples"):
+        return dataset["id"]
+    for candidate in datasets:
+        if candidate.get("samples"):
+            return candidate["id"]
+    return dataset_id
 
 
 def _metric_choices(datasets, metrics, dataset_id):
@@ -205,11 +216,21 @@ def _metric_choices(datasets, metrics, dataset_id):
 
 
 def _coerce_metric(datasets, metrics, dataset_id, metric_id):
+    """Keep a selected metric only if it is valid for this dataset."""
+    if isinstance(metric_id, (list, tuple)):
+        metric_id = metric_id[0] if metric_id else None
+    if metric_id is None or metric_id == "":
+        return None
     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
+    return None
+
+
+def _metric_dropdown_value(metric_id):
+    """Gradio multiselect value for an optional single metric."""
+    return [metric_id] if metric_id else []
 
 
 def _model_choices(datasets, dataset_id):
@@ -217,42 +238,92 @@ def _model_choices(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())
+    models = data["Model"].dropna().astype(str).unique().tolist()
+    # (label, value) so the UI shows the shared name but filters on the raw id.
+    return sorted(
+        ((display_model_name(model), model) for model in models),
+        key=lambda item: item[0].casefold(),
+    )
+
+
+def _model_choice_values(choices):
+    return [choice[1] if isinstance(choice, tuple) else choice for choice in choices]
+
+
+def _metric_columns(datasets, metrics, dataset_id):
+    dataset = _item(datasets, dataset_id)
+    if not dataset:
+        return []
+    data = dataset.get("data")
+    columns = getattr(data, "columns", [])
+    allowed = set(dataset.get("metric_ids") or [])
+    return [
+        metric["column"]
+        for metric in metrics
+        if metric["id"] in allowed and metric["column"] in columns
+    ]
 
 
 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}"
+    metric = _item(metrics, metric_id) if metric_id else None
+    if not metric:
+        return dataset_name
+    return f"{dataset_name} | {metric['name']}"
+
+
+_LEADERBOARD_META_COLUMNS = [
+    "Median Generation Time (s)",
+    "Min Generation Time (s)",
+    "Price / Image (USD)",
+    "Evaluation Date (UTC)",
+    "Date",
+]
 
 
 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
+    """When a metric is selected, show identity + that score + time/price."""
+    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
+    ]
+    meta = [column for column in _LEADERBOARD_META_COLUMNS if column in available]
+    if metric_column and metric_column in available:
+        return [*identity, metric_column, *meta]
+    return [column for column in (dataset.get("columns") or available) if column != "URL"]
 
 
 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:
+    if not dataset:
         return None
+    metric_id = _coerce_metric(datasets, metrics, dataset_id, metric_id)
+    metric = _item(metrics, metric_id) if metric_id else None
+    score_column = metric["column"] if metric else None
+    if score_column:
+        columns = _columns_for_metric(dataset, score_column)
+        score_columns = [score_column]
+    else:
+        columns = [
+            column
+            for column in (dataset.get("columns") or [])
+            if column != "URL"
+        ]
+        score_columns = _metric_columns(datasets, metrics, dataset_id)
     return {
         "dataset": dataset,
         "metric": metric,
-        "title": _view_title(datasets, metrics, dataset["id"], metric["id"]),
+        "metric_id": metric_id,
+        "title": _view_title(datasets, metrics, dataset["id"], metric_id),
         "data": dataset["data"],
-        "columns": _columns_for_metric(dataset, metric["column"]),
-        "score_column": metric["column"],
+        "columns": columns,
+        "score_column": score_column,
+        "score_columns": score_columns,
         "samples": dataset.get("samples"),
         "note": dataset.get("note"),
     }
@@ -272,6 +343,8 @@ def _format_leaderboard_cell(column, value):
         except (TypeError, ValueError):
             return escape(str(value))
     if label in {"model", "platform", "endpoint owner", "optimized"}:
+        if label == "model":
+            return escape(display_model_name(value))
         return escape(str(value))
     try:
         number = float(value)
@@ -384,6 +457,11 @@ def _filter_leaderboard(data, search_term, platform, owner, optimized, models=No
             matches |= filtered[column].astype(str).str.contains(
                 search_term, case=False, na=False
             )
+        if "Model" in filtered.columns:
+            display_names = filtered["Model"].map(display_model_name).astype(str)
+            matches |= display_names.str.contains(
+                search_term, case=False, na=False
+            )
         filtered = filtered[matches]
 
     for column, values in [
@@ -467,7 +545,14 @@ def _display_label(column):
         "P-Judge Overall": "P-Judger (Pruna)",
         "Datapoint Elo": "Datapoint Elo",
         "Rapidata Elo": "Rapidata Elo",
-        "Benchmark.ai Elo": "Artificial Analysis Elo",
+        "Arena Elo": "Overall Elo",
+        "Arena Branding / Commercial Elo": "Branding / Commercial",
+        "Arena 3D Imaging Elo": "3D Imaging",
+        "Arena Cartoon / Anime Elo": "Cartoon / Anime",
+        "Arena Photorealistic Elo": "Photorealistic",
+        "Arena Art Elo": "Art",
+        "Arena Portraits Elo": "Portraits",
+        "Arena Text Rendering Elo": "Text Rendering",
         "Raw Win Rate": "Raw win rate",
         "Median Generation Time (s)": "Median generation time",
         "Min Generation Time (s)": "Min generation time",
@@ -544,8 +629,12 @@ def _build_pareto_figure(
     scores = scatter[score_column].astype(float).tolist()
     on_frontier = _pareto_frontier_mask(x_values, scores)
 
-    dominated = scatter.loc[[not flag for flag in on_frontier]]
-    frontier = scatter.loc[on_frontier].sort_values(x_column)
+    dominated = scatter.loc[[not flag for flag in on_frontier]].copy()
+    frontier = scatter.loc[on_frontier].sort_values(x_column).copy()
+    if not dominated.empty:
+        dominated["Model"] = dominated["Model"].map(display_model_name)
+    if not frontier.empty:
+        frontier["Model"] = frontier["Model"].map(display_model_name)
     hover = (
         "<b>%{text}</b><br>"
         f"{escape(x_title)}: {x_hover_prefix}%{{x:.4f}}{x_hover_suffix}"
@@ -661,13 +750,37 @@ def _pareto_pair(data, score_column):
     )
 
 
+def _pareto_slot_updates(data, score_columns):
+    """Updates for a fixed bank of Gradio Plot slots (visible/hidden)."""
+    score_columns = [column for column in (score_columns or []) if column]
+    updates = []
+    for index in range(MAX_PARETO_METRICS):
+        if index < len(score_columns):
+            score_column = score_columns[index]
+            price_fig, time_fig = _pareto_pair(data, score_column)
+            updates.extend(
+                [
+                    gr.update(visible=True),
+                    f"#### {_display_label(score_column)}",
+                    price_fig,
+                    time_fig,
+                ]
+            )
+        else:
+            updates.extend(
+                [
+                    gr.update(visible=False),
+                    "",
+                    None,
+                    None,
+                ]
+            )
+    return updates
+
+
 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>"
-        )
+        return ""
     models = list(selected_models or [])
     available = samples.get("models") or []
     models = [model for model in models if model in samples.get("images", {})]
@@ -722,9 +835,9 @@ def _build_compare_samples_html(samples, selected_models, num_prompts, seed=0):
             cells.append(
                 f"""
                 <div class="compare-cell">
-                    <div class="compare-model-label">{escape(model)}</div>
+                    <div class="compare-model-label">{escape(display_model_name(model))}</div>
                     <a href="{image_url}" target="_blank" rel="noopener noreferrer">
-                        <img src="{image_url}" alt="{escape(model)} sample" loading="lazy" />
+                        <img src="{image_url}" alt="{escape(display_model_name(model))} sample" loading="lazy" />
                     </a>
                 </div>
                 """
@@ -755,38 +868,55 @@ def _note_markdown(note):
     return note or ""
 
 
-def _filter_row(datasets, metrics, default_dataset_id, default_metric_id):
+def _filter_row(
+    datasets,
+    metrics,
+    default_dataset_id,
+    default_metric_id=None,
+    *,
+    require_samples=False,
+    include_metric=True,
+):
     metric_choices = _metric_choices(datasets, metrics, default_dataset_id)
     model_choices = _model_choices(datasets, default_dataset_id)
+    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),
+            choices=_dataset_choices(datasets, require_samples=require_samples),
             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,
-        )
+        metric_dd = None
+        if include_metric:
+            metric_dd = gr.Dropdown(
+                choices=metric_choices,
+                value=_metric_dropdown_value(metric_id),
+                label="Metric",
+                type="value",
+                multiselect=True,
+                max_choices=1,
+                allow_custom_value=True,
+                scale=2,
+                min_width=180,
+            )
         models_dd = gr.Dropdown(
             choices=model_choices,
             value=[],
             multiselect=True,
             label="Models",
             type="value",
+            allow_custom_value=True,
             scale=3,
             min_width=200,
         )
     title = gr.Markdown(
         _title_markdown(
-            _view_title(datasets, metrics, default_dataset_id, default_metric_id)
+            _view_title(datasets, metrics, default_dataset_id, metric_id)
         ),
         elem_classes="view-title",
     )
@@ -800,14 +930,17 @@ 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 = initial["score_column"]
+    initial_score_columns = initial["score_columns"]
     initial_samples = initial.get("samples")
-    price_fig, time_fig = _pareto_pair(initial_data, initial_score)
+    initial_pareto_updates = _pareto_slot_updates(
+        _filter_leaderboard(initial_data, "", [], [], [], models=[]),
+        initial_score_columns,
+    )
 
     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
+                datasets, metrics, default_dataset_id, None
             )
             lb_note = gr.Markdown(_note_markdown(initial.get("note")))
             platform_choices = _filter_choices(initial_data, "Platform")
@@ -847,7 +980,10 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
                 )
             ranking = gr.HTML(
                 _leaderboard_html(
-                    initial_data, initial_columns, [initial_score], initial_score
+                    initial_data,
+                    initial_columns,
+                    initial_score_columns,
+                    initial_score_columns[0] if initial_score_columns else None,
                 ),
                 padding=False,
                 elem_classes="ranking-table-host",
@@ -855,65 +991,102 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
 
         with gr.TabItem("Pareto Plots"):
             pp_dataset, pp_metric, pp_models, pp_title = _filter_row(
-                datasets, metrics, default_dataset_id, default_metric_id
+                datasets, metrics, default_dataset_id, None
             )
             gr.Markdown(
                 "<span class='pareto-help'>"
                 "Green = on the frontier (lower cost or time at the same or better score). "
-                "Lavender = below the frontier."
+                "Lavender = below the frontier. Pick a metric to focus on one pair of plots; "
+                "leave it empty to see every metric."
                 "</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")
-                    time_plot = gr.Plot(
-                        value=time_fig,
-                        show_label=False,
-                        elem_classes="pareto-plot",
+            pareto_slots = []
+            for slot_index in range(MAX_PARETO_METRICS):
+                offset = slot_index * 4
+                visible = slot_index < len(initial_score_columns)
+                with gr.Column(
+                    visible=visible,
+                    elem_classes="pareto-metric-block",
+                ) as slot_group:
+                    slot_title = gr.Markdown(
+                        (
+                            f"#### {_display_label(initial_score_columns[slot_index])}"
+                            if visible
+                            else ""
+                        ),
+                        elem_classes="pareto-metric-title",
                     )
+                    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")
+                            slot_price = gr.Plot(
+                                value=(
+                                    initial_pareto_updates[offset + 2]
+                                    if visible
+                                    else None
+                                ),
+                                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")
+                            slot_time = gr.Plot(
+                                value=(
+                                    initial_pareto_updates[offset + 3]
+                                    if visible
+                                    else None
+                                ),
+                                show_label=False,
+                                elem_classes="pareto-plot",
+                            )
+                pareto_slots.append(
+                    (slot_group, slot_title, slot_price, slot_time)
+                )
 
         with gr.TabItem("Samples"):
-            sm_dataset, sm_metric, sm_models, sm_title = _filter_row(
-                datasets, metrics, default_dataset_id, default_metric_id
+            sample_default_dataset_id = _coerce_sample_dataset(
+                datasets, default_dataset_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>
-                """
+            sm_dataset, _, sm_models, sm_title = _filter_row(
+                datasets,
+                metrics,
+                sample_default_dataset_id,
+                None,
+                require_samples=True,
+                include_metric=False,
             )
-            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",
+            with gr.Column(visible=bool(initial_samples)) as samples_panel:
+                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
@@ -925,33 +1098,49 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
         with gr.TabItem("About"):
             render_about()
 
-    def _synced_filters(dataset_id, metric_id, models):
-        metric_id = _coerce_metric(datasets, metrics, dataset_id, metric_id)
+    def _synced_filters(dataset_id, metric_id, models, *, clear_metric=False):
+        if clear_metric:
+            metric_id = None
+        else:
+            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]
+        model_values = set(_model_choice_values(model_choices))
+        models = [model for model in (models or []) if model in model_values]
         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)
+        metric_update = gr.update(
+            choices=metric_choices, value=_metric_dropdown_value(metric_id)
+        )
         models_update = gr.update(choices=model_choices, value=models)
+
+        sample_dataset_id = _coerce_sample_dataset(datasets, dataset_id)
+        sample_model_choices = _model_choices(datasets, sample_dataset_id)
+        sample_model_values = set(_model_choice_values(sample_model_choices))
+        sample_models = [
+            model for model in (models or []) if model in sample_model_values
+        ]
+        sample_title = _title_markdown(
+            _view_title(datasets, metrics, sample_dataset_id, None)
+        )
         return (
             dataset_id,
             metric_id,
             models,
+            sample_dataset_id,
             dataset_update,
             dataset_update,
-            dataset_update,
+            gr.update(value=sample_dataset_id),
             metric_update,
             metric_update,
-            metric_update,
-            models_update,
             models_update,
             models_update,
+            gr.update(choices=sample_model_choices, value=sample_models),
             title,
             title,
-            title,
+            sample_title,
         )
 
     def _leaderboard_extras(data, platform_value, owner_value, optimized_value):
@@ -1009,28 +1198,38 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
             optimized_value or [],
             models=models,
         )
+        sort_column = view["score_column"] or (
+            view["score_columns"][0] if view["score_columns"] else None
+        )
         ranking_html = _leaderboard_html(
             filtered,
             view["columns"],
-            [view["score_column"]],
-            view["score_column"],
+            view["score_columns"],
+            sort_column,
         )
-        pareto_data = _filter_leaderboard(
-            data, "", [], [], [], models=models
-        )
-        next_price, next_time = _pareto_pair(pareto_data, view["score_column"])
+        pareto_data = _filter_leaderboard(data, "", [], [], [], models=models)
+        pareto_updates = _pareto_slot_updates(pareto_data, view["score_columns"])
+        sample_dataset_id = _coerce_sample_dataset(datasets, dataset_id)
+        sample_view = resolve_view(datasets, metrics, sample_dataset_id, None)
+        samples = sample_view.get("samples") if sample_view else None
+        sample_models = [
+            model
+            for model in (models or [])
+            if model
+            in _model_choice_values(_model_choices(datasets, sample_dataset_id))
+        ]
         samples_html = _samples_html(
-            view.get("samples"),
-            models,
+            samples,
+            sample_models,
             int(num_prompts or DEFAULT_COMPARE_PROMPTS),
             int(seed or 0),
         )
         return (
             _note_markdown(view.get("note")),
             ranking_html,
-            next_price,
-            next_time,
+            *pareto_updates,
             samples_html,
+            gr.update(visible=bool(samples)),
         )
 
     def on_dataset(
@@ -1044,7 +1243,9 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
         num_prompts,
         seed,
     ):
-        synced = _synced_filters(dataset_id, metric_id, models)
+        synced = _synced_filters(
+            dataset_id, metric_id, models, clear_metric=True
+        )
         dataset_id, metric_id, models = synced[:3]
         view = resolve_view(datasets, metrics, dataset_id, metric_id)
         extras = _leaderboard_extras(
@@ -1061,7 +1262,7 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
             num_prompts,
             seed,
         )
-        return (*synced[3:], extras[0], extras[1], extras[2], *views)
+        return (*synced[4:], extras[0], extras[1], extras[2], *views)
 
     def on_metric(
         dataset_id,
@@ -1075,10 +1276,21 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
         seed,
     ):
         metric_id = _coerce_metric(datasets, metrics, dataset_id, metric_id)
+        metric_choices = _metric_choices(datasets, metrics, dataset_id)
         title = _title_markdown(
             _view_title(datasets, metrics, dataset_id, metric_id)
         )
-        metric_update = gr.update(value=metric_id)
+        metric_update = gr.update(
+            choices=metric_choices, value=_metric_dropdown_value(metric_id)
+        )
+        sample_title = _title_markdown(
+            _view_title(
+                datasets,
+                metrics,
+                _coerce_sample_dataset(datasets, dataset_id),
+                None,
+            )
+        )
         views = _views(
             dataset_id,
             metric_id,
@@ -1090,7 +1302,14 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
             num_prompts,
             seed,
         )
-        return (metric_update, metric_update, metric_update, title, title, title, *views)
+        return (
+            metric_update,
+            metric_update,
+            title,
+            title,
+            sample_title,
+            *views,
+        )
 
     def on_models(
         dataset_id,
@@ -1104,8 +1323,19 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
         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)
+        model_values = set(_model_choice_values(model_choices))
+        models = [model for model in (models or []) if model in model_values]
+        models_update = gr.update(choices=model_choices, value=models)
+
+        sample_dataset_id = _coerce_sample_dataset(datasets, dataset_id)
+        sample_model_choices = _model_choices(datasets, sample_dataset_id)
+        sample_model_values = set(_model_choice_values(sample_model_choices))
+        sample_models = [
+            model for model in (models or []) if model in sample_model_values
+        ]
+        sample_models_update = gr.update(
+            choices=sample_model_choices, value=sample_models
+        )
         views = _views(
             dataset_id,
             metric_id,
@@ -1117,7 +1347,12 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
             num_prompts,
             seed,
         )
-        return (models_update, models_update, models_update, *views)
+        return (
+            models_update,
+            models_update,
+            sample_models_update,
+            *views,
+        )
 
     def on_leaderboard_filters(
         dataset_id,
@@ -1137,11 +1372,14 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
             optimized_value or [],
             models=models,
         )
+        sort_column = view["score_column"] or (
+            view["score_columns"][0] if view["score_columns"] else None
+        )
         return _leaderboard_html(
             filtered,
             view["columns"],
-            [view["score_column"]],
-            view["score_column"],
+            view["score_columns"],
+            sort_column,
         )
 
     def on_samples_controls(dataset_id, models, num_prompts, seed):
@@ -1163,23 +1401,19 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
             next_seed,
         )
 
-    dataset_inputs = [
-        lb_metric,
-        lb_models,
-        search,
-        platform,
-        owner,
-        optimized,
-        prompt_count,
-        seed_state,
+    no_metric = gr.State(None)
+    pareto_outputs = [
+        component
+        for slot_group, slot_title, slot_price, slot_time in pareto_slots
+        for component in (slot_group, slot_title, slot_price, slot_time)
     ]
+
     dataset_outputs = [
         lb_dataset,
         pp_dataset,
         sm_dataset,
         lb_metric,
         pp_metric,
-        sm_metric,
         lb_models,
         pp_models,
         sm_models,
@@ -1191,37 +1425,53 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
         optimized,
         lb_note,
         ranking,
-        price_plot,
-        time_plot,
+        *pareto_outputs,
         gallery,
+        samples_panel,
     ]
-    for dataset_dd in (lb_dataset, pp_dataset, sm_dataset):
+    for dataset_dd, metric_dd, models_dd in (
+        (lb_dataset, lb_metric, lb_models),
+        (pp_dataset, pp_metric, pp_models),
+        (sm_dataset, no_metric, sm_models),
+    ):
         dataset_dd.change(
             on_dataset,
-            inputs=[dataset_dd, *dataset_inputs],
+            inputs=[
+                dataset_dd,
+                metric_dd,
+                models_dd,
+                search,
+                platform,
+                owner,
+                optimized,
+                prompt_count,
+                seed_state,
+            ],
             outputs=dataset_outputs,
         )
 
     metric_outputs = [
         lb_metric,
         pp_metric,
-        sm_metric,
         lb_title,
         pp_title,
         sm_title,
         lb_note,
         ranking,
-        price_plot,
-        time_plot,
+        *pareto_outputs,
         gallery,
+        samples_panel,
     ]
-    for metric_dd in (lb_metric, pp_metric, sm_metric):
+    for dataset_dd, metric_dd, models_dd in (
+        (lb_dataset, lb_metric, lb_models),
+        (pp_dataset, pp_metric, pp_models),
+    ):
         metric_dd.change(
             on_metric,
             inputs=[
-                lb_dataset,
+                dataset_dd,
                 metric_dd,
-                lb_models,
+                models_dd,
                 search,
                 platform,
                 owner,
@@ -1238,16 +1488,20 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
         sm_models,
         lb_note,
         ranking,
-        price_plot,
-        time_plot,
+        *pareto_outputs,
         gallery,
+        samples_panel,
     ]
-    for models_dd in (lb_models, pp_models, sm_models):
+    for dataset_dd, metric_dd, models_dd in (
+        (lb_dataset, lb_metric, lb_models),
+        (pp_dataset, pp_metric, pp_models),
+        (sm_dataset, no_metric, sm_models),
+    ):
         models_dd.change(
             on_models,
             inputs=[
-                lb_dataset,
-                lb_metric,
+                dataset_dd,
+                metric_dd,
                 models_dd,
                 search,
                 platform,
@@ -1285,7 +1539,6 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
         outputs=[seed_state, gallery],
     )
 
-
 def render_about():
     with gr.Row(elem_classes="about-layout", equal_height=False):
         with gr.Column(scale=1, min_width=340, elem_classes="about-col"):