video-to-video model

app.py

@@ -2301,6 +2301,62 @@ def load_qwen_combined_dataframe(path):
     return df.reset_index(drop=True)
 
 
+def load_video_editing_dataframe(path):
+    """Load the video-to-video editing leaderboard."""
+    df = pd.read_csv(path, na_values=["N/A", "n/a", ""])
+    df = df.rename(
+        columns={
+            "display_name": "Model",
+            "elo": "Video Edit Elo",
+            "n_generations": "Generations",
+            "min_generation_s": "Min Generation Time (s)",
+            "median_generation_s": "Median Generation Time (s)",
+            "p20_generation_s": "P20 Generation Time (s)",
+            "generation_s_per_output_video_s": "Time / Output Video Second (s)",
+            "predict_time_s_per_output_video_s": "Predict Time / Output Video Second (s)",
+            "model_execution_time_s_per_output_video_s": (
+                "Execution Time / Output Video Second (s)"
+            ),
+            "price": "Price / Video (USD)",
+        }
+    )
+    df = df.drop(columns=["wandb_run_ids"], errors="ignore")
+    df["Model"] = df["Model"].astype(str).str.strip()
+    df = _as_numeric(
+        df,
+        [
+            "Video Edit Elo",
+            "Generations",
+            "Min Generation Time (s)",
+            "Median Generation Time (s)",
+            "P20 Generation Time (s)",
+            "Time / Output Video Second (s)",
+            "Predict Time / Output Video Second (s)",
+            "Execution Time / Output Video Second (s)",
+            "Price / Video (USD)",
+        ],
+    )
+    end_to_end = df.get("Time / Output Video Second (s)")
+    execution = df.get("Execution Time / Output Video Second (s)")
+    if end_to_end is not None:
+        if "model_id" in df.columns:
+            is_ours = df["model_id"].astype(str).str.lower().str.startswith(
+                "p_video_edit"
+            )
+        else:
+            is_ours = df["Model"].astype(str).str.casefold().str.startswith(
+                "p-video-edit"
+            )
+        if execution is None:
+            pareto_time = end_to_end
+        else:
+            ours_time = execution.where(execution.notna(), end_to_end)
+            pareto_time = end_to_end.where(~is_ours, ours_time)
+        df["Pareto Time / Output Video Second (s)"] = pareto_time
+    df = df.drop(columns=["model_id"], errors="ignore")
+    return df.reset_index(drop=True)
+
+
 df = load_oneig_dataframe(oneig_path)
 
 oneig_metric_columns = [
@@ -2360,10 +2416,15 @@ arena_path = _resolve_data_path(
     data_dir / "arena_ai_text_to_image_leaderboard.csv",
     space_root.parent / "arena_ai_text_to_image_leaderboard.csv",
 )
+video_path = _resolve_data_path(
+    data_dir / "video-editing-leaderboard.csv",
+    space_root.parent / "video-editing-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)
+video_df = load_video_editing_dataframe(video_path)
 qwen_display_columns = [
     col
     for col in [
@@ -2395,6 +2456,19 @@ arena_display_columns = [
     ]
     if col in arena_df.columns
 ]
+video_display_columns = [
+    col
+    for col in [
+        "Model",
+        "Video Edit Elo",
+        "Generations",
+        "Median Generation Time (s)",
+        "Min Generation Time (s)",
+        "Time / Output Video Second (s)",
+        "Price / Video (USD)",
+    ]
+    if col in video_df.columns
+]
 
 oneig_samples = load_sample_comparison_data(oneig_combined_dir)
 qwen_samples = load_sample_comparison_data(qwen_combined_dir)
@@ -2416,6 +2490,7 @@ metrics = [
     {"id": "arena_art", "column": "Arena Art Elo"},
     {"id": "arena_portraits", "column": "Arena Portraits Elo"},
     {"id": "arena_text", "column": "Arena Text Rendering Elo"},
+    {"id": "video_edit_elo", "column": "Video Edit Elo"},
 ]
 
 
@@ -2456,11 +2531,27 @@ arena_metric_ids = _metric_ids_for(
         "arena_text",
     ],
 )
+video_metric_ids = _metric_ids_for(video_df, ["video_edit_elo"])
 
 datasets = [
+    {
+        "id": "video_editing",
+        "name": "Video Editing Dataset",
+        "modality": "video_to_video",
+        "data": video_df,
+        "columns": video_display_columns,
+        "metric_ids": video_metric_ids,
+        "note": (
+            "Elo from pairwise video-edit preference. Price is USD per output "
+            "video. Seconds for 1s of video is how long it takes to produce "
+            "one second of output video (end-to-end wall time)."
+        ),
+        "samples": None,
+    },
     {
         "id": "qwen",
         "name": "Qwen Image Dataset",
+        "modality": "text_to_image",
         "data": qwen_df,
         "columns": qwen_display_columns,
         "metric_ids": qwen_metric_ids,
@@ -2470,6 +2561,7 @@ datasets = [
     {
         "id": "oneig",
         "name": "OneIG Alignment Dataset",
+        "modality": "text_to_image",
         "data": oneig_df,
         "columns": oneig_display_columns,
         "metric_ids": oneig_metric_ids,
@@ -2482,6 +2574,7 @@ datasets = [
     {
         "id": "artificial_analysis",
         "name": "Artificial Analysis Dataset",
+        "modality": "text_to_image",
         "data": aa_df,
         "columns": aa_display_columns,
         "metric_ids": aa_metric_ids,
@@ -2491,6 +2584,7 @@ datasets = [
     {
         "id": "arena_ai",
         "name": "Arena AI Dataset",
+        "modality": "text_to_image",
         "data": arena_df,
         "columns": arena_display_columns,
         "metric_ids": arena_metric_ids,
@@ -2501,8 +2595,11 @@ datasets = [
 datasets = [dataset for dataset in datasets if dataset["metric_ids"]]
 
 DEFAULT_DATASET_ID = next(
-    (dataset["id"] for dataset in datasets if dataset["id"] == "qwen"),
-    datasets[0]["id"] if datasets else None,
+    (dataset["id"] for dataset in datasets if dataset["id"] == "video_editing"),
+    next(
+        (dataset["id"] for dataset in datasets if dataset["id"] == "qwen"),
+        datasets[0]["id"] if datasets else None,
+    ),
 )
 DEFAULT_METRIC_ID = None
 

data/video-editing-leaderboard.csv

@@ -0,0 +1,12 @@
+model_id,display_name,elo,wandb_run_ids,n_generations,min_generation_s,median_generation_s,p20_generation_s,generation_s_per_output_video_s,predict_time_s_per_output_video_s,model_execution_time_s_per_output_video_s,price
+gemini_omni_flash_edit__fal,Gemini Omni Flash Edit,1054,3iuctwj9,56,32.574746752001374,58.2327566820004,50.44402900500063,13.78,,,0.13
+grok_imagine_video__replicate,Grok Imagine Video,974,q0ogvekx,59,31.640928319000523,43.75649321700257,32.88782280539963,11.04,,,0.05
+happyhorse_1_0__wavespeed,HappyHorse 1.0,1048,k4zj5wqk,71,106.5824136010051,201.2431439649954,141.46595527700265,46.73,,,0.14
+ltx_2_3_quality_reference_video_to_video__fal,LTX 2.3 Video Edit,911,p19ks8ad,73,60.768441981999786,73.62109239100027,70.20137865180223,15.83,,,0.054
+lucy_edit_pro__fal,Lucy Edit Pro,879,na6bz9xx,72,118.3459930579993,136.44442766549764,124.13885582720104,27.18,,,0.15
+minimax_h3_reference_to_video__fal,MiniMax H3 Reference-to-Video,1060,639xmakz,63,180.8385945170012,308.29198316100155,248.2394383729996,58.31,,,0.06
+p_video_edit_preview__replicate_final,P-Video-Edit,1000,m8irpsa6,73,31.41135125700021,86.86665409700072,57.21095684959946,23.18,17.99,12.06,0.045
+p_video_edit_preview__replicate_final__draft,P-Video-Edit Draft,994,6f88e6mx,73,23.04809326099712,42.9797806409988,33.19193872759861,11.48,11.28,4.46,0.025
+seedance_2_5_video_edit_turbo__wavespeed,Seedance 2.5 Video Edit Turbo,1063,2nr274vp,68,142.49452170499717,293.7401115540015,223.11569286320045,59.93,,,0.24
+wan_2_7_video_edit__wavespeed,Wan 2.7 Video Edit,1055,9lq803be,66,134.3744560209998,313.957433804002,219.2491260079987,68.04,,,0.2
+

model_display.py

@@ -88,6 +88,13 @@ MODEL_DISPLAY_NAMES = {
     "p_image_2_ideogram_high_2k": "P-Image-Ideogram High 2K",
     "P-Image-Ideogram (High)": "P-Image-Ideogram High",
     "p_image_2_ideogram_very_high_1k": "P-Image-Ideogram Very High 1K",
+    # P-Video-Edit
+    "P-Video-Edit": "P-Video-Edit",
+    "P-Video-Edit Draft": "P-Video-Edit Draft",
+    "P-Video Edit Final": "P-Video-Edit",
+    "P-Video Edit Final (draft)": "P-Video-Edit Draft",
+    "p_video_edit_preview__replicate_final": "P-Video-Edit",
+    "p_video_edit_preview__replicate_final__draft": "P-Video-Edit Draft",
     # Others overlapping P-Bench
     "z_image": "Z-Image",
     "glm_image": "GLM-Image",
@@ -210,6 +217,6 @@ def display_model_name(model_id) -> str:
     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):
+    if re.search(r"[\s.\[\]()-]", raw):
         return raw
     return _prettify_snake_case(raw)

ui.py

@@ -25,19 +25,41 @@ MAX_COMPARE_PROMPTS = 8
 MAX_PARETO_METRICS = 8
 _PARETO_SLOT_COUNT = 1 + MAX_PARETO_METRICS * 8
 _PARETO_PRICE_COLUMN = "Price / Image (USD)"
+_PARETO_VIDEO_PRICE_COLUMN = "Price / Video (USD)"
+_PARETO_PRICE_COLUMNS = (_PARETO_PRICE_COLUMN, _PARETO_VIDEO_PRICE_COLUMN)
 _PARETO_TIME_COLUMN = "Min Generation Time (s)"
+_PARETO_VIDEO_TIME_COLUMN = "Pareto Time / Output Video Second (s)"
+_PARETO_TIME_COLUMNS = (_PARETO_VIDEO_TIME_COLUMN, _PARETO_TIME_COLUMN)
+_PARETO_PRICE_TITLES = {
+    _PARETO_PRICE_COLUMN: "Price per image (USD)",
+    _PARETO_VIDEO_PRICE_COLUMN: "Price per video (USD)",
+}
+_PARETO_TIME_TITLES = {
+    _PARETO_TIME_COLUMN: "Min generation time (s)",
+    _PARETO_VIDEO_TIME_COLUMN: "Seconds needed for 1s of output video",
+}
 _PARETO_SCALE_CHOICES = [
     ("Log", "Logarithmic"),
     ("Linear", "Linear"),
 ]
 _PARETO_SCALE_VALUES = {value for _, value in _PARETO_SCALE_CHOICES}
 _PARETO_SCALE_DEFAULT = "Logarithmic"
+_PARETO_PRUNA_COLOR = "#c084fc"
+_PARETO_OTHER_COLOR = "#9aa3b5"
+_PARETO_FRONTIER_OUTLINE = "#3fa87e"
 
 TAB_LEADERBOARDS = "leaderboards"
 TAB_PARETO = "pareto"
 TAB_SAMPLES = "samples"
 TAB_ABOUT = "about"
 
+MODALITY_VIDEO_TO_VIDEO = "video_to_video"
+MODALITY_TEXT_TO_IMAGE = "text_to_image"
+MODALITY_CHOICES = [
+    ("Video to Video", MODALITY_VIDEO_TO_VIDEO),
+    ("Text to Image", MODALITY_TEXT_TO_IMAGE),
+]
+
 _MODEL_CHOICES_CACHE = {}
 _VIEW_EVENTS = {
     "show_progress": "hidden",
@@ -49,14 +71,15 @@ _VIEW_EVENTS = {
 ABOUT_OVERVIEW_CONTENT = """
 # About P-Bench
 
-P-Bench compares **text-to-image models**, including optimized or accelerated
-endpoints, on **quality, speed, and price**. Each view is a **dataset** scored
-with a **metric**, written as `Dataset | Metric`. There is no single score
-across P-Bench.
+P-Bench compares **text-to-image** and **video-to-video** models, including
+optimized or accelerated endpoints, on **quality, speed, and price**. Each
+view is a **dataset** scored with a **metric**, written as `Dataset | Metric`.
+There is no single score across P-Bench.
 
 ## How to read it
 
-1. Pick a **dataset** and a **metric**.
+1. Pick a **type** (Video to Video or Text to Image), then a **dataset**
+   and a **metric**.
 2. **Leaderboards**: ranked by that metric. Price and generation time sit in
    the same table when the source publishes them.
 3. **Pareto plots**: mark models that are not beaten on both higher score
@@ -82,6 +105,10 @@ prompt suites, so samples are not shown.
 
 ## Current datasets
 
+### Video Editing Dataset
+Video-to-video edit Elo from pairwise preference, with price per output
+video and generation time. Samples are not shown yet.
+
 ### 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,
@@ -222,7 +249,7 @@ def render_header():
               </svg>
             </button>
           </div>
-          <p class="app-header-tagline">Compare text-to-image models on quality, speed, and price</p>
+          <p class="app-header-tagline">Compare models on quality, speed, and price</p>
         </header>
         """,
         padding=False,
@@ -237,10 +264,42 @@ def _item(items, item_id):
     return items[0] if items else None
 
 
-def _dataset_choices(datasets, *, require_samples=False, require_pareto=False):
+def _dataset_modality(dataset):
+    return (dataset or {}).get("modality") or MODALITY_TEXT_TO_IMAGE
+
+
+def _datasets_for_modality(datasets, modality):
+    if not modality:
+        return list(datasets)
+    scoped = [
+        dataset
+        for dataset in datasets
+        if _dataset_modality(dataset) == modality
+    ]
+    return scoped or list(datasets)
+
+
+def _modality_choices(datasets):
+    present = {_dataset_modality(dataset) for dataset in datasets}
+    return [
+        (label, value) for label, value in MODALITY_CHOICES if value in present
+    ]
+
+
+def _default_dataset_id(datasets, modality, preferred=None):
+    scoped = _datasets_for_modality(datasets, modality)
+    if preferred and any(dataset["id"] == preferred for dataset in scoped):
+        return preferred
+    return scoped[0]["id"] if scoped else None
+
+
+def _dataset_choices(
+    datasets, *, modality=None, require_samples=False, require_pareto=False
+):
+    scoped = _datasets_for_modality(datasets, modality)
     return [
         (dataset["name"], dataset["id"])
-        for dataset in datasets
+        for dataset in scoped
         if (not require_samples or dataset.get("samples"))
         and (not require_pareto or _dataset_has_pareto(datasets, dataset["id"]))
     ]
@@ -259,17 +318,39 @@ def _sample_model_ids(datasets, dataset_id):
     return set(samples.get("models") or [])
 
 
+def _pareto_price_column(data):
+    columns = getattr(data, "columns", []) if data is not None else []
+    for column in _PARETO_PRICE_COLUMNS:
+        if column in columns:
+            return column
+    return None
+
+
+def _pareto_time_column(data):
+    columns = getattr(data, "columns", []) if data is not None else []
+    for column in _PARETO_TIME_COLUMNS:
+        if column in columns:
+            return column
+    return None
+
+
 def _dataset_has_pareto(datasets, dataset_id):
     dataset = _item(datasets, dataset_id)
-    columns = getattr(dataset.get("data") if dataset else None, "columns", [])
-    return _PARETO_PRICE_COLUMN in columns or _PARETO_TIME_COLUMN in columns
+    data = dataset.get("data") if dataset else None
+    return (
+        _pareto_price_column(data) is not None
+        or _pareto_time_column(data) is not None
+    )
 
 
-def _dataset_dropdown_update(datasets, tab, dataset_id):
+def _dataset_dropdown_update(datasets, tab, dataset_id, modality=None):
     """Limit the dataset list to what the current tab can show."""
+    if modality is None:
+        modality = _dataset_modality(_item(datasets, dataset_id))
     return gr.update(
         choices=_dataset_choices(
             datasets,
+            modality=modality,
             require_samples=tab == TAB_SAMPLES
             and _dataset_has_samples(datasets, dataset_id),
             require_pareto=tab == TAB_PARETO
@@ -377,7 +458,10 @@ _LEADERBOARD_IDENTITY_COLUMNS = [
 _LEADERBOARD_META_COLUMNS = [
     "Median Generation Time (s)",
     "Min Generation Time (s)",
+    "Time / Output Video Second (s)",
     "Price / Image (USD)",
+    "Price / Video (USD)",
+    "Generations",
     "Evaluation Date (UTC)",
     "Date",
 ]
@@ -429,7 +513,7 @@ def _format_leaderboard_cell(column, value):
     if pd.isna(value) or value is None or value == "":
         return "-"
     label = str(column).lower()
-    if label == "rank":
+    if label in {"rank", "generations"}:
         return str(int(value))
     if "price" in label:
         return _format_price(value)
@@ -604,7 +688,11 @@ def _display_label(column):
         "Arena Text Rendering Elo": "Text Rendering",
         "Median Generation Time (s)": "Median generation time",
         "Min Generation Time (s)": "Min generation time",
+        "Time / Output Video Second (s)": "Seconds for 1s of video",
         "Price / Image (USD)": "Price per image",
+        "Price / Video (USD)": "Price per video",
+        "Video Edit Elo": "Elo",
+        "Generations": "Generations",
         "Evaluation Date (UTC)": "Date",
         "Date": "Date",
     }
@@ -679,6 +767,23 @@ def _applied_key(view_state):
     )
 
 
+def _is_pruna_model(model_id) -> bool:
+    raw = str(model_id or "").casefold()
+    label = display_model_name(model_id).casefold()
+    return any(
+        value.startswith(prefix)
+        for value in (raw, label)
+        for prefix in ("p-image", "p_image", "p-video", "p_video")
+    )
+
+
+def _pareto_fill_colors(models):
+    return [
+        _PARETO_PRUNA_COLOR if _is_pruna_model(model) else _PARETO_OTHER_COLOR
+        for model in models
+    ]
+
+
 def _build_pareto_figure(
     data,
     score_column,
@@ -703,6 +808,8 @@ def _build_pareto_figure(
 
     dominated = scatter.loc[[not flag for flag in on_frontier]].copy()
     frontier = scatter.loc[on_frontier].sort_values(x_column).copy()
+    dominated_colors = _pareto_fill_colors(dominated["Model"]) if not dominated.empty else []
+    frontier_colors = _pareto_fill_colors(frontier["Model"]) if not frontier.empty else []
     if not dominated.empty:
         dominated["Model"] = dominated["Model"].map(display_model_name)
     if not frontier.empty:
@@ -723,10 +830,11 @@ def _build_pareto_figure(
                 name="Below frontier",
                 text=dominated["Model"],
                 hovertemplate=hover,
+                showlegend=False,
                 marker={
                     "size": 9,
-                    "color": "#d8b4fe",
-                    "opacity": 0.8,
+                    "color": dominated_colors,
+                    "opacity": 0.85,
                     "line": {"width": 0},
                 },
             )
@@ -740,14 +848,51 @@ def _build_pareto_figure(
                 name="On frontier",
                 text=frontier["Model"],
                 hovertemplate=hover,
-                line={"color": "#69a45c", "width": 2.5},
+                showlegend=False,
+                line={"color": _PARETO_FRONTIER_OUTLINE, "width": 2.5},
                 marker={
                     "size": 12,
-                    "color": "#69a45c",
-                    "line": {"width": 1.5, "color": "#86c077"},
+                    "color": frontier_colors,
+                    "line": {"width": 2.5, "color": _PARETO_FRONTIER_OUTLINE},
                 },
             )
         )
+    for name, marker in (
+        (
+            "Pruna",
+            {
+                "size": 10,
+                "color": _PARETO_PRUNA_COLOR,
+                "line": {"width": 0},
+            },
+        ),
+        (
+            "Other models",
+            {
+                "size": 10,
+                "color": _PARETO_OTHER_COLOR,
+                "line": {"width": 0},
+            },
+        ),
+        (
+            "On frontier",
+            {
+                "size": 12,
+                "color": "rgba(0,0,0,0)",
+                "line": {"width": 2.5, "color": _PARETO_FRONTIER_OUTLINE},
+            },
+        ),
+    ):
+        fig.add_trace(
+            go.Scatter(
+                x=[None],
+                y=[None],
+                mode="markers",
+                name=name,
+                marker=marker,
+                hoverinfo="skip",
+            )
+        )
 
     score_label = _display_label(score_column)
     fig.update_layout(
@@ -887,23 +1032,43 @@ def _pareto_pair(
     if data is None or not score_column or score_column not in data.columns:
         return None, score_missing, None, score_missing
 
+    price_column = _pareto_price_column(data) or _PARETO_PRICE_COLUMN
+    price_title = _PARETO_PRICE_TITLES.get(price_column, "Price (USD)")
+    price_missing = (
+        "Price per video isn't available for this dataset."
+        if price_column == _PARETO_VIDEO_PRICE_COLUMN
+        else "Price per image isn't available for this dataset."
+    )
     price_fig, price_message = _pareto_axis(
         data,
         score_column,
-        _PARETO_PRICE_COLUMN,
-        "Price per image (USD)",
-        "Price per image isn't available for this dataset.",
+        price_column,
+        price_title,
+        price_missing,
         "No models have both a score and a price for this metric.",
         x_hover_prefix="$",
         x_axis_type=_pareto_axis_type(price_scale),
     )
+    time_column = _pareto_time_column(data) or _PARETO_TIME_COLUMN
+    time_title = _PARETO_TIME_TITLES.get(time_column, "Generation time (s)")
+    time_missing = (
+        "Seconds needed for 1s of output video isn't available for this dataset."
+        if time_column == _PARETO_VIDEO_TIME_COLUMN
+        else "Min generation time isn't available for this dataset."
+    )
+    time_empty = (
+        "No models have both a score and seconds needed for 1s of output "
+        "video for this metric."
+        if time_column == _PARETO_VIDEO_TIME_COLUMN
+        else "No models have both a score and a min generation time for this metric."
+    )
     time_fig, time_message = _pareto_axis(
         data,
         score_column,
-        _PARETO_TIME_COLUMN,
-        "Min generation time (s)",
-        "Min generation time isn't available for this dataset.",
-        "No models have both a score and a min generation time for this metric.",
+        time_column,
+        time_title,
+        time_missing,
+        time_empty,
         x_hover_suffix="s",
         x_axis_type=_pareto_axis_type(latency_scale),
     )
@@ -911,29 +1076,29 @@ def _pareto_pair(
 
 
 def _pareto_dataset_message(data):
-    has_price = data is not None and _PARETO_PRICE_COLUMN in data.columns
-    has_time = data is not None and _PARETO_TIME_COLUMN in data.columns
+    has_price = _pareto_price_column(data) is not None
+    has_time = _pareto_time_column(data) is not None
     if has_price or has_time:
         return None
     return (
-        "Price per image and min generation time aren't available for "
+        "Price and generation time aren't available for "
         "this dataset, so these plots can't be drawn."
     )
 
 
 def _pareto_slot_note(price_fig, price_message, time_fig, time_message, data):
-    has_price = data is not None and _PARETO_PRICE_COLUMN in data.columns
-    has_time = data is not None and _PARETO_TIME_COLUMN in data.columns
+    has_price = _pareto_price_column(data) is not None
+    has_time = _pareto_time_column(data) is not None
     notes = []
     if has_price and not has_time:
         notes.append(
-            "Min generation time isn't available for this dataset, so only "
+            "Generation time isn't available for this dataset, so only "
             "price vs score is shown."
         )
     elif has_time and not has_price:
         notes.append(
-            "Price per image isn't available for this dataset, so only min "
-            "generation time vs score is shown."
+            "Price isn't available for this dataset, so only "
+            "time vs score is shown."
         )
     if price_fig is None and has_price:
         notes.append(price_message)
@@ -954,8 +1119,8 @@ def _pareto_slot_updates(
     score_columns = [column for column in (score_columns or []) if column]
     price_scales = _normalize_pareto_scales(price_scales)
     time_scales = _normalize_pareto_scales(time_scales)
-    has_price = data is not None and _PARETO_PRICE_COLUMN in data.columns
-    has_time = data is not None and _PARETO_TIME_COLUMN in data.columns
+    has_price = _pareto_price_column(data) is not None
+    has_time = _pareto_time_column(data) is not None
     dataset_note = _pareto_dataset_message(data)
     updates = [_pareto_note_update(dataset_note)]
     hide_all_slots = not has_price and not has_time
@@ -1123,9 +1288,19 @@ def _filter_row(datasets, metrics, default_dataset_id, default_metric_id=None):
     metric_id = _coerce_metric(
         datasets, metrics, default_dataset_id, default_metric_id
     )
+    default_modality = _dataset_modality(_item(datasets, default_dataset_id))
     with gr.Row(elem_classes="view-filters"):
+        modality_dd = gr.Dropdown(
+            choices=_modality_choices(datasets),
+            value=default_modality,
+            label="Type",
+            type="value",
+            filterable=False,
+            scale=1,
+            min_width=150,
+        )
         dataset_dd = gr.Dropdown(
-            choices=_dataset_choices(datasets),
+            choices=_dataset_choices(datasets, modality=default_modality),
             value=default_dataset_id,
             label="Dataset",
             type="value",
@@ -1157,7 +1332,7 @@ def _filter_row(datasets, metrics, default_dataset_id, default_metric_id=None):
             min_width=180,
             elem_classes="filter-chips",
         )
-    return dataset_dd, metric_dd, models_dd
+    return modality_dd, dataset_dd, metric_dd, models_dd
 
 
 def render_image_workspace(datasets, metrics, default_dataset_id, default_metric_id):
@@ -1172,15 +1347,16 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
         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. "
-                "On Samples, only datasets and models 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."
+                "Start with Type to switch between Video to Video and Text "
+                "to Image. The rest of the filters follow you across "
+                "Leaderboards, Pareto plots, and Samples. Samples only "
+                "lists datasets and models we have generations for; Pareto "
+                "plots only lists datasets with price or generation time. "
+                "Search in Models, or leave it empty to include every model."
                 "</p>",
                 elem_classes="filter-help-host",
             )
-            dataset_dd, metric_dd, models_dd = _filter_row(
+            modality_dd, dataset_dd, metric_dd, models_dd = _filter_row(
                 datasets, metrics, default_dataset_id, None
             )
         with gr.Tabs(elem_classes="main-tabs") as main_tabs:
@@ -1306,7 +1482,7 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
                                 elem_classes="pareto-col",
                             ) as slot_time_col:
                                 slot_time_scale = _pareto_plot_heading(
-                                    "Min generation time vs score"
+                                    "Time vs score"
                                 )
                                 slot_time = gr.Plot(
                                     value=None,
@@ -1460,8 +1636,14 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
     ):
         prev = dict(view_state or {})
         extras = extras or {}
+        modality = _dataset_modality(_item(datasets, dataset_id))
+        last_by_modality = dict(prev.get("dataset_by_modality") or {})
+        if dataset_id:
+            last_by_modality[modality] = dataset_id
         return {
             "dataset_id": dataset_id,
+            "modality": modality,
+            "dataset_by_modality": last_by_modality,
             "metric_id": metric_id,
             "models": list(models or []),
             "current_tab": tab,
@@ -1599,13 +1781,14 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
         tab = view_state.get("current_tab") or TAB_LEADERBOARDS
         selected_raw = _normalize_metric_ids(metric_id)
         incoming_models = list(models or [])
-        dataset_changed = source == "dataset" and dataset_id != view_state.get(
+        filter_changed = source in {"dataset", "modality"}
+        dataset_changed = filter_changed and dataset_id != view_state.get(
             "dataset_id"
         )
         can_pareto = _dataset_has_pareto(datasets, dataset_id)
         can_samples = _dataset_has_samples(datasets, dataset_id)
         selected_tab = tab
-        if source == "dataset":
+        if filter_changed:
             if tab == TAB_SAMPLES and not can_samples:
                 selected_tab = TAB_LEADERBOARDS
             elif tab == TAB_PARETO and not can_pareto:
@@ -1614,7 +1797,7 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
                 dataset_id,
                 metric_id,
                 models,
-                clear_metric=dataset_changed,
+                clear_metric=source == "modality" or dataset_changed,
                 require_samples=selected_tab == TAB_SAMPLES,
             )
             dataset_id, metric_id, models = synced[:3]
@@ -1659,7 +1842,7 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
             list(optimized_value or []),
         )
         extra_updates = None
-        if source == "dataset":
+        if filter_changed:
             view = resolve_view(datasets, metrics, dataset_id, metric_id)
             extra_updates = _leaderboard_extras(
                 view["data"] if view else None,
@@ -1712,6 +1895,67 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
             ),
         }
 
+    def on_modality(
+        modality,
+        dataset_id,
+        metric_id,
+        models,
+        platform_value,
+        owner_value,
+        optimized_value,
+        num_prompts,
+        seed,
+        view_state,
+    ):
+        view_state = dict(view_state or {})
+        last_by_modality = dict(view_state.get("dataset_by_modality") or {})
+        current_modality = view_state.get("modality") or _dataset_modality(
+            _item(datasets, dataset_id)
+        )
+        if dataset_id:
+            last_by_modality[current_modality] = dataset_id
+        dataset_id = _default_dataset_id(
+            datasets, modality, last_by_modality.get(modality)
+        )
+        view_state["modality"] = modality
+        view_state["dataset_by_modality"] = last_by_modality
+        result = _apply_filter_change(
+            "modality",
+            dataset_id,
+            metric_id,
+            models,
+            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 (
+            _dataset_dropdown_update(
+                datasets,
+                result["selected_tab"],
+                result["dataset_id"],
+                modality=modality,
+            ),
+            result["metric_update"],
+            result["models_update"],
+            extras[6],
+            extras[0],
+            extras[1],
+            extras[2],
+            *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(),
+            result["state"],
+        )
+
     def on_dataset(
         dataset_id,
         metric_id,
@@ -2061,9 +2305,12 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
         handler.__name__ = f"on_tab_{tab}"
         return handler
 
+    default_modality = _dataset_modality(_item(datasets, default_dataset_id))
     view_state = gr.State(
         {
             "dataset_id": default_dataset_id,
+            "modality": default_modality,
+            "dataset_by_modality": {default_modality: default_dataset_id},
             "metric_id": None,
             "models": [],
             "current_tab": TAB_LEADERBOARDS,
@@ -2145,6 +2392,12 @@ def render_image_workspace(datasets, metrics, default_dataset_id, default_metric
         main_tabs,
         view_state,
     ]
+    modality_dd.change(
+        on_modality,
+        inputs=[modality_dd, *filter_inputs],
+        outputs=dataset_outputs,
+        **_VIEW_EVENTS,
+    )
     dataset_dd.change(
         on_dataset,
         inputs=filter_inputs,