Replace the 2025 benchmark with the revised NTv3 benchmark, keeping the 2025 leaderboard as a page

.gitignore

@@ -0,0 +1,3 @@
+__pycache__/
+*.py[cod]
+.DS_Store

README.md

@@ -1,5 +1,5 @@
 ---
-title: Ntv3 Benchmark
+title: NTv3 Benchmark
 emoji: 🚀
 colorFrom: red
 colorTo: red
@@ -10,4 +10,74 @@ tags:
 pinned: false
 short_description: NTv3 Benchmark
 license: apache-2.0
----
+---
+
+# NTv3 Benchmark
+
+A standardized comparison of sequence-to-function models on **155 functional-track
+prediction tasks across 11 species**. Every model is given the same 32-kb input, the same
+task-specific 1-bp prediction head and the same per-nucleotide Poisson-multinomial loss, so
+what is compared is the representation rather than the training recipe.
+
+## What is measured
+
+**Metric.** Pearson correlation on the held-out test set, per track, averaged over three
+seeds where available.
+
+**Species (11).** Animals: human, cattle, rat. Plants: *A. thaliana*, rice, maize, tomato.
+Fungi: *S. cerevisiae*, *S. pombe*. Protists: *P. falciparum*, *D. discoideum*.
+
+**Assays (7).** Chromatin accessibility (ATAC-seq), histone modifications and transcription
+factor binding (ChIP-seq), transcription initiation (PRO-cap), RNA binding (eCLIP), gene
+expression (RNA-seq) and translation (Ribo-seq).
+
+The benchmark tests two kinds of generalization. For human, *A. thaliana*, rice and maize,
+which NTv3-tracks saw during post-training, the assays and tracks were chosen to be absent
+from that post-training set. The remaining seven genomes were absent from post-training
+entirely, so those species measure transfer to an unseen genome.
+
+## Models
+
+Ten models: two convolutional baselines trained from scratch, five pretrained genomic
+foundation models, two pretrained sequence-to-function models, and NTv3.
+
+| Model | Training |
+| --- | --- |
+| BPNet, Residual CNN | from scratch |
+| HyenaDNA, Caduceus, NTv2, Evo2, PlantCAD2 | pretrained |
+| Borzoi, AlphaGenome | pretrained sequence-to-function |
+| **NTv3** | post-trained |
+
+**AlphaGenome** is fine-tuned from its fold-1 checkpoint on human, because the all-folds
+checkpoint saw those test regions, and from its all-folds checkpoint on every other species.
+
+## Reading the leaderboard
+
+**Scores are never averaged across species.** Not every model was run on every species, so a
+single cross-species number would compare models over different task sets. Pick a species in
+the sidebar for its own leaderboard, where every model shown was evaluated on all of that
+species' tracks.
+
+## Contents
+
+- `data/ntv3_benchmark_results.csv`, one row per model, species, track and seed, carrying
+  the score and the training-cost columns the app reports. This is the data behind every
+  view; nothing is computed elsewhere.
+- `src/streamlit_app.py`, the app.
+
+## Links
+
+- 📚 **Benchmark dataset:** [`InstaDeepAI/NTv3_benchmark_dataset_revised`](https://huggingface.co/datasets/InstaDeepAI/NTv3_benchmark_dataset_revised),
+  the genomes, splits and tracks to reproduce or extend the benchmark.
+- 🧬 **NTv3 tutorials and models:** [`InstaDeepAI/ntv3`](https://huggingface.co/spaces/InstaDeepAI/ntv3).
+- 🗄️ **Initial release (2025):** the leaderboard of the initial NTv3 release is the last page of this Space.
+
+## Citation
+
+`TBC`, to be added on publication of the NTv3 paper.
+
+## License
+
+The app code and the results table here are Apache-2.0. **The NTv3 model weights are not.**
+They are released under the InstaDeep Open Model Licence, which permits non-commercial use
+only and also places conditions on model outputs. See each model repository for its terms.

requirements.txt

@@ -1,18 +1,4 @@
-APScheduler
-black
-datasets
-gradio
-gradio[oauth]
-gradio_leaderboard==0.0.9
-gradio_client
-huggingface-hub>=0.18.0
-matplotlib
 numpy
 pandas
-python-dateutil
-tqdm
-transformers
-tokenizers>=0.15.0
-sentencepiece
 plotly
-streamlit
+streamlit

src/initial_release.py

@@ -0,0 +1,1078 @@
+from typing import List
+import os
+
+import pandas as pd
+import streamlit as st
+import plotly.express as px
+from plotly.subplots import make_subplots
+import plotly.graph_objects as go
+import numpy as np
+
+# The leaderboard of the initial NTv3 release (December 2025), as it was published.
+# streamlit_app.py runs main() as one page of the revised benchmark, which owns the page config.
+
+# ---------------------------------------------------------------------
+# Configuration
+# ---------------------------------------------------------------------
+COLORS = {
+    # Primary colors 1 (our models)
+    'blue_0': '#004697',     # Darkest allowable blue
+    'blue_1': '#3973fc',     # Main blue
+    'blue_2': '#7ea4fc',     # Medium blue
+    'blue_3': '#c3d5fc',     # Light blue (lightest allowable blue)
+    # Secondary colors 1
+    'red_1': '#ff554d',      # Medium red
+    'red_2': '#ffe0de',      # Light red
+    # Primary colors 2
+    'green_1': '#00b050',    # Darkest green
+    'green_2': '#92d050',    # Medium green
+    'green_3': '#c6e0b4',    # Light green (lightest allowable green)
+    # Secondary colors 2
+    'gold_1': '#fdb932',
+    # Tertiary colors
+    'orange_1': '#ff975e',
+    'purple_1': '#9a6ce4',
+    'purple_2': '#bb9aef',     # Medium purple
+    'purple_3': '#ceb5f5',     # Light purple (lightest allowable purple)
+    # Grays (other models)
+    'gray_1': '#808080',     # Darkest gray (use as a last resort)
+    'gray_2': '#b3b3b3',     # Medium gray (start with this as the darkest when possible)
+    'gray_3': '#e6e6e6',     # Lightest gray
+    'gray_4': '#ffffff',     # It's actually just white (use as a last resort)
+    # If all other options are exhausted
+    'cyan_1': '#0096b4',     # Darkest teal
+    'cyan_2': '#28bed2',     # Medium cyan
+    'cyan_3': '#8cdceb',     # Lightest cyan
+    'magenta_1': '#b428a0',  # Darkest magenta
+    'magenta_2': '#dc50be',  # Medium pink
+    'magenta_3': '#f5a0dc',  # Lightest pink
+    'yellow_1': '#c8aa00',   # Darkest yellow
+    'yellow_2': '#ffd200',   # Medium yellow
+    'yellow_3': '#fff08c',   # Lightest yellow
+}
+
+
+ASSAY_TYPE_MAPPING = {
+    'ATAC-seq': 'chromatin accessibility',
+    'DNase-seq': 'chromatin accessibility',
+    'Histone ChIP-seq': 'histone modifications',
+    'TF ChIP-seq': 'chromatin accessibility',
+    'PRO-cap': 'transcription initiation',
+    'eCLIP': 'RNA binding sites',
+    'RNA-seq': 'gene expression',
+    'ribo-seq': 'mRNA translation',
+    'Annotation': 'genome annotation',
+    "Exon": "exon",
+    "Intron": "intron",
+    "Splice acceptor": "splice acceptor",
+    "Start codon": "start codon",
+
+}
+
+ASSAY_COLORS = {
+    'chromatin accessibility': '#004697',
+    'histone modifications': '#cc0000',
+    'transcription initiation': '#ff9900',
+    'RNA binding sites': '#9933cc',
+    'gene expression': '#009900',
+    'mRNA translation': '#ff6699',
+    'genome annotation': '#ffcc00',
+    "intron": '#004697',
+    "exon": '#cc0000',
+    "splice acceptor": '#ff9900',
+    "start codon": '#9933cc',
+}
+ASSAY_COLORS["other"] = "#808080"
+
+MODEL_COLORS = {
+    "NTv3 650M (pos)": COLORS['blue_0'],
+    'NTv3 650M (pre)': COLORS['blue_1'],    # #3973fc (Darkest blue)
+    'NTv3 100M (pre)': COLORS['blue_2'],    # #7ea4fc (Medium blue)
+    'NTv3 8M (pre)': COLORS['blue_3'],      # #c3d5fc (Light blue)
+    'Evo2 1B': COLORS['green_3'],      # #b3b3b3 (Medium gray)
+    "NTv2 500M": COLORS['gray_1'],
+    "BPNet arch. 6M": COLORS['cyan_1'],
+    "Residual CNN 44M":  COLORS['magenta_1'],
+    "PlantCAD2 88M": COLORS["purple_1"],
+    "Caduceus 7M": COLORS["purple_2"],
+    "HyenaDNA 7M": COLORS["yellow_2"]
+}
+
+MODEL_TRAINING_STATUS = {
+    "NTv3 650M (pos)": "POS",
+    "NTv3 650M (pre)": "PRE",
+    "NTv3 100M (pre)": "PRE",
+    "NTv3 8M (pre)": "PRE",
+    "Residual CNN 44M": "SCRATCH",
+    "Caduceus 7M": "PRE",
+    "Evo2 1B": "PRE",
+    "NTv2 500M": "PRE",
+    "BPNet arch. 6M": "SCRATCH",
+    "PlantCAD2 88M": "PRE",
+    "HyenaDNA 7M": "PRE"
+}
+
+MODEL_GPU_MULTIPLIER = {
+    "Evo2 1B": 8,   # trained on 8 GPUs
+}
+
+
+MODEL_NAMES = list(MODEL_COLORS.keys())
+
+PLANT_SPECIES = ["tomato", "rice", "maize", "arabidopsis"]
+ANIMAL_SPECIES = ["human", "chicken", "cattle"]
+
+SPECIES_GROUPS = {
+    "Plants": PLANT_SPECIES,
+    "Animals": ANIMAL_SPECIES,   # (your code calls these HUMAN_SPECIES, but they’re the “animal” set)
+}
+
+
+_LAST_UPDATED = "Dec 10, 2025"
+_INTRO = """
+The **NTv3 Benchmark** is a curated benchmark of 106 long-range genomic datasets 
+designed to evaluate models under realistic 32 kb input, single-base-pair output settings. 
+The dataset spans two complementary task families: genome annotation (exon, intron, splice acceptor, start codon) 
+and functional-regulatory prediction, which includes diverse experimental tracks such as chromatin accessibility,
+ histone modifications, transcription initiation (PRO-cap), RNA binding (eCLIP), gene expression (RNA-seq), 
+ and translation (Ribo-seq).
+
+Data are drawn from a phylogenetically diverse set of species, including organisms seen during post-training 
+(human, chicken, arabidopsis, rice, maize) and entirely unseen species (cattle, tomato), with careful curation 
+to avoid data leakage. This design allows the dataset to probe long-range sequence-to-function mapping, 
+cross-species generalization, and transfer across heterogeneous regulatory modalities, 
+including assays not present in prior multispecies training corpora. By standardizing sequence length, 
+resolution, and evaluation metrics across all tracks, the NTv3 Benchmark provides a controlled dataset 
+for comparing representation quality across genomic foundation models.
+
+The metrics used are:
+- **Pearson correlations (multi-assay)**: per-dataset scores across species and models for functional tracks.
+- **MCC (bed tracks)**: per-track MCC values across species and models for gene annotation tracks.
+"""
+
+HERE = os.path.dirname(os.path.abspath(__file__))  # /app/src
+PROJECT_ROOT = os.path.dirname(HERE)               # /app
+DATA_DIR = os.path.join(PROJECT_ROOT, "data")
+
+SINGLE_TABLE_PATH = os.path.join(DATA_DIR, "initial_release", "ntv3_benchmark_results.csv")  
+
+# ---------------------------------------------------------------------
+# Data loading & preprocessing
+# ---------------------------------------------------------------------
+
+
+@st.cache_data
+def load_raw_data():
+    df = pd.read_csv(SINGLE_TABLE_PATH)
+    df.columns = [c.strip() for c in df.columns]
+    return df
+
+
+def _normalize_training_time_to_gpu_hours(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Your new column is `running_time`. In your sample it looks like seconds
+    (e.g. 317034 ~= 88 hours). We'll convert to hours if values look like seconds.
+    """
+    if "running_time" not in df.columns:
+        return df
+
+    rt = pd.to_numeric(df["running_time"], errors="coerce")
+    # Heuristic: if median is huge, it's probably seconds -> convert to hours
+    # (88 hours = 316800 seconds is a typical-looking value in your sample)
+    if rt.dropna().median() > 10_000:
+        df["GPU hours"] = rt / 3600.0
+    else:
+        df["GPU hours"] = rt.astype(float)
+
+    return df
+
+
+def _best_step_time_to_hours(s: pd.Series) -> pd.Series:
+    """
+    Converts strings like '3 days 04:26:26.467000' to hours (float).
+    Works with pandas Timedelta parsing.
+    """
+    td = pd.to_timedelta(s, errors="coerce")
+    return td.dt.total_seconds() / 3600.0
+
+
+
+@st.cache_data
+def load_expanded_data():
+    df = load_raw_data().copy()
+
+    df = df.rename(columns={"Metric": "Score", "model_name": "Model"})
+    df["Score"] = pd.to_numeric(df["Score"], errors="coerce")
+
+    if "best_step" in df.columns:
+        df["best_step"] = pd.to_numeric(df["best_step"], errors="coerce")
+
+    if "best_step_time" in df.columns:
+        df["best_step_time_hours"] = _best_step_time_to_hours(df["best_step_time"])
+    else:
+        df["best_step_time_hours"] = np.nan
+
+    is_annot = df.get("assay_type", "").astype(str).eq("Annotation")
+    pearson_raw = df[~is_annot].copy()
+    mcc_raw = df[is_annot].copy()
+
+    # -------------------------
+    # Functional Tracks (Pearson)
+    # -------------------------
+    pearson_group_cols = ["species", "datasets", "Model"]
+    if "assay_type" in pearson_raw.columns:
+        pearson_group_cols.append("assay_type")
+
+    pearson_df = (
+        pearson_raw
+        .groupby(pearson_group_cols, as_index=False, dropna=False)
+        .agg({
+            "Score": "mean",
+            "best_step": "mean",
+            "best_step_time_hours": "mean",
+        })
+    )
+
+    # ✅ merge track_name_clean WHILE assay_type is still raw
+    if "track_name_clean" in pearson_raw.columns:
+        map_keys = ["species", "datasets"]
+        if "assay_type" in pearson_raw.columns:
+            map_keys.append("assay_type")
+
+        track_map = (
+            pearson_raw[map_keys + ["track_name_clean"]]
+            .dropna(subset=["track_name_clean"])
+            .drop_duplicates()
+        )
+        pearson_df = pearson_df.merge(track_map, on=map_keys, how="left")
+
+    # ✅ now it’s safe to map assay_type to categories
+    if "assay_type" in pearson_df.columns:
+        pearson_df["assay_type"] = (
+            pearson_df["assay_type"].astype(str).map(ASSAY_TYPE_MAPPING).fillna("Other")
+        )
+
+    # -------------------------
+    # Genome Annotation (MCC)
+    # -------------------------
+    mcc_df = (
+        mcc_raw
+        .groupby(["species", "datasets", "Model"], as_index=False, dropna=False)
+        .agg({
+            "Score": "mean",
+            "best_step": "mean",
+            "best_step_time_hours": "mean",
+        })
+    )
+
+    return pearson_df, mcc_df
+
+
+_PEARSON_DF, _MCC_DF = load_expanded_data()
+
+# Global sets (we'll further filter per-benchmark below)
+_ALL_SPECIES = sorted(
+    set(_PEARSON_DF["species"].unique()).union(_MCC_DF["species"].unique())
+)
+
+_ALL_ASSAYS = (
+    sorted(_PEARSON_DF["assay_type"].dropna().unique())
+    if "assay_type" in _PEARSON_DF.columns
+    else []
+)
+
+_ALL_MODELS = MODEL_NAMES[:]
+
+_BENCHMARKS = {
+    "Functional Tracks": {
+        "df": _PEARSON_DF,
+        "metric_label": "Pearson correlation",
+        "has_assay_type": True,
+    },
+    "Genome Annotation": {
+        "df": _MCC_DF,
+        "metric_label": "MCC",
+        "has_assay_type": False,
+    },
+}
+
+
+# ---------------------------------------------------------------------
+# Computation helpers
+# ---------------------------------------------------------------------
+
+
+def filter_base_df(
+    benchmark_name: str,
+    selected_species: List[str],
+    selected_assays: List[str],
+    selected_models: List[str],
+    selected_datasets: List[str],
+) -> pd.DataFrame:
+    cfg = _BENCHMARKS[benchmark_name]
+    df = cfg["df"].copy()
+
+    # Species filter
+    if selected_species:
+        df = df[df["species"].isin(selected_species)]
+
+    # Assay type filter (Pearson only)
+    if cfg.get("has_assay_type", False) and selected_assays and "assay_type" in df.columns:
+        df = df[df["assay_type"].isin(selected_assays)]
+
+    # Dataset / bed track filter (for MCC, but safe to apply generally)
+    if selected_datasets and "datasets" in df.columns:
+        df = df[df["datasets"].isin(selected_datasets)]
+
+    # Model filter
+    if selected_models:
+        df = df[df["Model"].isin(selected_models)]
+
+    return df
+
+
+def build_leaderboard(
+    benchmark_name: str,
+    selected_species: List[str],
+    selected_assays: List[str],
+    selected_models: List[str],
+    selected_datasets: List[str],
+) -> pd.DataFrame:
+    df = filter_base_df(
+        benchmark_name,
+        selected_species,
+        selected_assays,
+        selected_models,
+        selected_datasets,
+    )
+
+    if df.empty:
+        return pd.DataFrame(columns=["Model", "Model Type", "Num entries", "Mean score"])
+
+    agg = (
+        df.groupby("Model")["Score"]
+        .mean()
+        .reset_index()
+        .rename(columns={"Score": "Mean score"})
+    )
+    agg["Mean score"] = agg["Mean score"].round(3)
+
+    agg["Num entries"] = (
+        df.groupby("Model")["Score"].count().reindex(agg["Model"]).values
+    )
+
+    # 👇 Add training regime column
+    agg["Training"] = agg["Model"].map(MODEL_TRAINING_STATUS).fillna("UNKNOWN")
+
+    # Sort by performance
+    agg = agg.sort_values("Mean score", ascending=False).reset_index(drop=True)
+
+    # Column order
+    agg = agg[["Model", "Training", "Num entries", "Mean score"]]
+
+    # Ensure the index starts with 1
+    agg.index += 1
+
+    return agg
+
+
+
+def build_bar_df(
+    benchmark_name: str,
+    selected_species: List[str],
+    selected_assays: List[str],
+    selected_models: List[str],
+    selected_datasets: List[str],
+) -> pd.DataFrame:
+    """For now, just one bar per model (same as leaderboard)."""
+    return build_leaderboard(
+        benchmark_name, selected_species, selected_assays, selected_models, selected_datasets
+    )
+
+
+def build_category_model_df(
+    benchmark_name: str,
+    selected_species: List[str],
+    selected_assays: List[str],
+    selected_models: List[str],
+    selected_datasets: List[str],
+) -> pd.DataFrame:
+    """
+    Mean score per (category, Model) after applying the same filters.
+    Category = assay_type (Functional Tracks) or datasets (Genome Annotation).
+    """
+    cfg = _BENCHMARKS[benchmark_name]
+    df = filter_base_df(
+        benchmark_name,
+        selected_species,
+        selected_assays,
+        selected_models,
+        selected_datasets,
+    )
+    if df.empty:
+        return pd.DataFrame(columns=["Category", "Model", "Mean score"])
+
+    # Pick the right breakdown column
+    if cfg.get("has_assay_type", False) and "assay_type" in df.columns:
+        category_col = "assay_type"
+        category_label = "Assay type"
+    else:
+        category_col = "datasets"
+        category_label = "Dataset"
+
+    if category_col not in df.columns:
+        return pd.DataFrame(columns=["Category", "Model", "Mean score"])
+
+    out = (
+        df.groupby([category_col, "Model"], as_index=False)["Score"]
+        .mean()
+        .rename(columns={category_col: "Category", "Score": "Mean score"})
+    )
+    out["Mean score"] = out["Mean score"].round(3)
+    out.attrs["category_label"] = category_label  # for nicer axis title
+    return out
+
+
+def plot_breakdown_facets_sorted_models(
+    breakdown_df: pd.DataFrame,
+    metric_label: str,
+    height: int = 420,
+):
+    categories = list(breakdown_df["Category"].dropna().unique())
+    categories = sorted(categories)
+
+    n = len(categories)
+    if n == 0:
+        return None
+
+    rows = 1
+    cols = n  # 👈 everything in one row
+
+    # Global y-range (consistent scale)
+    y_min = breakdown_df["Mean score"].min()
+    y_max = breakdown_df["Mean score"].max()
+    pad = 0.05 * (y_max - y_min if y_max > y_min else 1.0)
+    y_range = [y_min - pad, y_max + pad]
+
+    fig = make_subplots(
+        rows=rows,
+        cols=cols,
+        subplot_titles=categories,
+        shared_yaxes=True,
+        horizontal_spacing=0.04,  # tighter spacing
+    )
+
+    for i, cat in enumerate(categories):
+        r = (i // cols) + 1
+        c = (i % cols) + 1
+
+        sub = (
+            breakdown_df[breakdown_df["Category"] == cat]
+            .sort_values("Mean score", ascending=True)
+        )
+
+        fig.add_trace(
+            go.Bar(
+                x=sub["Model"],
+                y=sub["Mean score"],
+                marker_color=[MODEL_COLORS.get(m, "#808080") for m in sub["Model"]],
+                showlegend=False,
+            ),
+            row=r,
+            col=c,
+        )
+
+        fig.update_xaxes(showticklabels=False, title_text="", row=r, col=c)
+        fig.update_yaxes(range=y_range, title_text="", row=r, col=c)  # 👈 apply range
+
+    fig.update_layout(
+        height=height,
+        plot_bgcolor="rgba(0,0,0,0)",
+        paper_bgcolor="rgba(0,0,0,0)",
+        margin=dict(t=60, l=10, r=10, b=10),
+    )
+
+    # Single y-axis label on the leftmost panel
+    fig.update_yaxes(title_text=metric_label, row=1, col=1)
+
+    return fig
+
+def build_pairwise_scatter_df(
+    benchmark_name: str,
+    selected_species: List[str],
+    selected_assays: List[str],
+    selected_models: List[str],
+    selected_datasets: List[str],
+    model_a: str,
+    model_b: str,
+) -> pd.DataFrame:
+    cfg = _BENCHMARKS[benchmark_name]
+
+    models_for_filter = (
+        list(set(selected_models + [model_a, model_b]))
+        if selected_models else [model_a, model_b]
+    )
+
+    df = filter_base_df(
+        benchmark_name,
+        selected_species,
+        selected_assays,
+        models_for_filter,
+        selected_datasets,
+    )
+    if df.empty:
+        return pd.DataFrame()
+
+    # ---- define "track identity" for head-to-head ----
+    # Always use datasets for the identity (x/y points)
+    track_cols = ["datasets"]
+    if cfg.get("has_assay_type", False) and "assay_type" in df.columns:
+        track_cols = ["assay_type", "datasets"]
+
+    keep_species = "species" in df.columns and (selected_species is None or len(selected_species) != 1)
+    id_cols = (["species"] if keep_species else []) + track_cols
+
+    wide = (
+        df[df["Model"].isin([model_a, model_b])]
+        .pivot_table(index=id_cols, columns="Model", values="Score", aggfunc="mean")
+        .reset_index()
+    )
+
+    if model_a not in wide.columns or model_b not in wide.columns:
+        return pd.DataFrame()
+
+    wide = wide.dropna(subset=[model_a, model_b])
+
+    # Nice display label: use datasets (not track_name_clean)
+    if "assay_type" in wide.columns:
+        wide["Track"] = wide["assay_type"].astype(str) + " / " + wide["datasets"].astype(str)
+    else:
+        wide["Track"] = wide["datasets"].astype(str)
+
+    wide = wide.rename(columns={model_a: "Model A", model_b: "Model B"})
+
+    # ---- Pearson-only: merge track_name_clean for hover ----
+    if benchmark_name == "Functional Tracks" and "track_name_clean" in df.columns:
+        merge_keys = id_cols.copy()  # species? + assay_type? + datasets
+        track_map = (
+            df[merge_keys + ["track_name_clean"]]
+            .dropna(subset=["track_name_clean"])
+            .drop_duplicates()
+        )
+        wide = wide.merge(track_map, on=merge_keys, how="left")
+
+    return wide
+
+
+
+def build_violin_df(
+    benchmark_name: str,
+    selected_species: List[str],
+    selected_assays: List[str],
+    selected_models: List[str],
+    selected_datasets: List[str],
+) -> pd.DataFrame:
+    # Use the same base filtering, but keep all per-track rows
+    df = filter_base_df(
+        benchmark_name,
+        selected_species,
+        selected_assays,
+        selected_models,
+        selected_datasets,
+    )
+    # Keep only needed columns
+    keep = ["Model", "Score"]
+    for col in ["species", "assay_type", "datasets"]:
+        if col in df.columns:
+            keep.append(col)
+    return df[keep].copy()
+
+
+def build_convergence_df(
+    benchmark_name: str,
+    selected_species: List[str],
+    selected_assays: List[str],
+    selected_models: List[str],
+    selected_datasets: List[str],
+    x_mode: str = "best_step",  # "best_step" | "best_step_time"
+) -> pd.DataFrame:
+
+    df = filter_base_df(
+        benchmark_name,
+        selected_species,
+        selected_assays,
+        selected_models,
+        selected_datasets,
+    )
+
+    if df.empty:
+        return pd.DataFrame(columns=["Model", "X", "Performance"])
+
+    # Mean performance per model
+    out = (
+        df.groupby("Model", as_index=False)
+        .agg({"Score": "mean"})
+        .rename(columns={"Score": "Performance"})
+    )
+
+    # -------------------------
+    # X axis selection
+    # -------------------------
+    if x_mode == "Steps (billions)":
+        if "best_step" not in df.columns:
+            return pd.DataFrame(columns=["Model", "X", "Performance"])
+
+        x = (
+            df.groupby("Model", as_index=False)["best_step"]
+            .mean()
+            .rename(columns={"best_step": "X"})
+        )
+
+    else:  # best_step_time (GPU hours)
+        if "best_step_time_hours" not in df.columns:
+            return pd.DataFrame(columns=["Model", "X", "Performance"])
+
+        x = (
+            df.groupby("Model", as_index=False)["best_step_time_hours"]
+            .mean()
+            .rename(columns={"best_step_time_hours": "X"})
+        )
+
+        # 👇 Apply GPU multiplier (Evo2 uses 8 GPUs)
+        gpu_multiplier = {
+            "Evo2 1B": 8,
+        }
+
+        x["X"] = x.apply(
+            lambda r: r["X"] * gpu_multiplier.get(r["Model"], 1),
+            axis=1,
+        )
+
+    # Merge + clean
+    out = out.merge(x, on="Model", how="left")
+    out = out.dropna(subset=["X", "Performance"])
+
+    out["Performance"] = out["Performance"].round(3)
+
+    return out
+
+
+# ---------------------------------------------------------------------
+# UI helpers
+# ---------------------------------------------------------------------
+
+
+def sidebar_toggle(label: str, value: bool = False, key: str | None = None) -> bool:
+    """
+    Wrapper to use st.sidebar.toggle when available, otherwise fall back to checkbox.
+    This makes the app compatible with older Streamlit versions on Hugging Face.
+    """
+    toggle_fn = getattr(st.sidebar, "toggle", None)
+    if toggle_fn is not None:
+        return toggle_fn(label, value=value, key=key)
+    # Fallback for older Streamlit versions
+    return st.sidebar.checkbox(label, value=value, key=key)
+
+# ---------------------------------------------------------------------
+# Streamlit UI
+# ---------------------------------------------------------------------
+def main():
+    st.title("🗄️ NTv3 Benchmark: initial release (2025)")
+    st.info(
+        "The leaderboard of the initial NTv3 release, as published in December 2025. "
+        "The other pages show the revised release."
+    )
+    st.markdown(_INTRO)
+    st.markdown(f"_Last updated: **{_LAST_UPDATED}**_")
+
+    # --- Sidebar filters ---
+    st.sidebar.header("Filters")
+
+    # Benchmark
+    benchmark_name = st.sidebar.selectbox(
+        "Benchmark",
+        options=list(_BENCHMARKS.keys()),
+        index=0,
+    )
+
+    cfg = _BENCHMARKS[benchmark_name]
+    df_bench = cfg["df"]
+
+    # Species toggles, but only for species present in this benchmark
+    st.sidebar.subheader("Species")
+
+    # Toggle: Plants vs Animals
+    species_group = st.sidebar.radio(
+        "Group",
+        options=["Animals", "Plants"],
+        index=0,
+        horizontal=True,
+        key=f"species_group_{benchmark_name}",
+    )
+
+    available_species_all = sorted(df_bench["species"].unique())
+    allowed_species = set(SPECIES_GROUPS[species_group]).intersection(available_species_all)
+    available_species = sorted(allowed_species)
+
+    selected_species: List[str] = []
+    for sp in available_species:
+        if sidebar_toggle(sp, value=True, key=f"species_{benchmark_name}_{species_group}_{sp}"):
+            selected_species.append(sp)
+
+    # (Optional) If no species exist for that group in this benchmark
+    if not available_species:
+        st.sidebar.info(f"No {species_group.lower()} species available for this benchmark.")
+
+    # Assay toggles (Pearson only), based on filtered species
+    if cfg.get("has_assay_type", False):
+        st.sidebar.subheader("Assay types")
+        if selected_species:
+            df_for_assays = df_bench[df_bench["species"].isin(selected_species)]
+        else:
+            df_for_assays = df_bench
+        available_assays = (
+            sorted(df_for_assays["assay_type"].dropna().unique())
+            if "assay_type" in df_for_assays.columns
+            else []
+        )
+        selected_assays: List[str] = []
+        for assay in available_assays:
+            if sidebar_toggle(assay, value=True, key=f"assay_{benchmark_name}_{assay}"):
+                selected_assays.append(assay)
+    else:
+        selected_assays = []
+
+    # Bed track / dataset toggles (MCC only), based on species selection
+    selected_datasets: List[str] = []
+    if benchmark_name == "Genome Annotation":
+        st.sidebar.subheader("Genome annotations")
+        if selected_species:
+            df_for_tracks = df_bench[df_bench["species"].isin(selected_species)]
+        else:
+            df_for_tracks = df_bench
+        available_datasets = sorted(df_for_tracks["datasets"].unique())
+        for ds in available_datasets:
+            if sidebar_toggle(ds, value=True, key=f"dataset_{benchmark_name}_{ds}"):
+                selected_datasets.append(ds)
+    else:
+        selected_datasets = []
+
+    # Model toggles (we keep all models in MODEL_NAMES; filters + data will prune)
+    st.sidebar.subheader("Models")
+    selected_models: List[str] = []
+    for model in _ALL_MODELS:
+        if sidebar_toggle(model, value=True, key=f"model_{model}"):
+            selected_models.append(model)
+
+        # -------------------------
+    # ✅ Validation: require ≥1 selection per relevant category
+    # -------------------------
+    missing = []
+
+    # Always required
+    if not selected_species:
+        missing.append("Species")
+    if not selected_models:
+        missing.append("Models")
+
+    # Required depending on benchmark
+    if cfg.get("has_assay_type", False) and not selected_assays:
+        missing.append("Assay types")
+
+    if benchmark_name == "Genome Annotation" and not selected_datasets:
+        missing.append("Genome annotations")
+
+    if missing:
+        # Show a single message and prevent *any* further display
+        st.error(
+            "Please select at least one item in each category. Currently missing: "
+            + ", ".join(missing)
+            + "."
+        )
+        st.stop()
+
+    # --- Main content ---
+    leaderboard_df = build_leaderboard(
+        benchmark_name, selected_species, selected_assays, selected_models, selected_datasets
+    )
+    bar_df = build_bar_df(
+        benchmark_name, selected_species, selected_assays, selected_models, selected_datasets
+    )
+
+    col1, col2 = st.columns([1, 1])
+
+    with col1:
+        st.subheader("🏅 Leaderboard")
+        st.write("\n")  # spacer to match plotly padding
+        st.write("\n")
+        st.write("\n")
+        if leaderboard_df.empty:
+            st.info("No data for the selected filters.")
+        else:
+            st.dataframe(leaderboard_df, use_container_width=True)
+
+    with col2:
+        st.subheader("📈 Mean score per model")
+        if bar_df.empty:
+            st.info("No data for the selected filters.")
+        else:
+            # Order models by performance (least -> most)
+            bar_df = bar_df.sort_values("Mean score", ascending=True)
+            model_order = bar_df["Model"].tolist()
+
+            fig = px.bar(
+                bar_df,
+                x="Model",
+                y="Mean score",
+                color="Model",
+                color_discrete_map=MODEL_COLORS,
+                category_orders={"Model": model_order},
+            )
+            fig.update_layout(
+                barmode="group",
+                height=500,
+                xaxis_title="",
+                yaxis_title=cfg["metric_label"],
+                plot_bgcolor="rgba(0,0,0,0)",
+                paper_bgcolor="rgba(0,0,0,0)",
+                bargap=0.08,
+            )
+            fig.update_xaxes(showticklabels=False)
+            st.plotly_chart(fig, use_container_width=True)
+
+    # --- Breakdown plot: assay_type (Functional Tracks) OR datasets (Genome Annotation) ---
+    breakdown_df = build_category_model_df(
+        benchmark_name, selected_species, selected_assays, selected_models, selected_datasets
+    )
+
+    type_of_data = "assay type" if benchmark_name == "Functional Tracks" else "gene annotation"
+
+    st.subheader(f"🧪 Mean score by {type_of_data}")
+    if breakdown_df.empty:
+        st.info("No data for the selected filters.")
+    else:
+        fig_breakdown = plot_breakdown_facets_sorted_models(
+            breakdown_df,
+            metric_label=cfg["metric_label"],
+            height=300,
+        )
+        st.plotly_chart(fig_breakdown, use_container_width=True)
+
+    # ------------------------------------------------------------------
+    # Model comparison: Head-to-head (left) + Convergence (right)
+    # ------------------------------------------------------------------
+    left, right = st.columns([1, 1], gap="large")
+
+    with left:
+        st.markdown("#### ⚖️ Head-to-head (per track)")
+
+        model_picker_options = selected_models if selected_models else _ALL_MODELS
+        default_a = model_picker_options[0] if model_picker_options else _ALL_MODELS[0]
+        default_b = model_picker_options[1] if len(model_picker_options) > 1 else (
+            _ALL_MODELS[1] if len(_ALL_MODELS) > 1 else default_a
+        )
+
+        cA, cB = st.columns([1, 1])
+        with cA:
+            model_a = st.selectbox(
+                "Model A (y-axis)",
+                options=model_picker_options,
+                index=model_picker_options.index(default_a) if default_a in model_picker_options else 0,
+                key=f"pair_model_a_{benchmark_name}",
+            )
+        with cB:
+            b_options = [m for m in model_picker_options if m != model_a] or model_picker_options
+            model_b = st.selectbox(
+                "Model B (x-axis)",
+                options=b_options,
+                index=0,
+                key=f"pair_model_b_{benchmark_name}",
+            )
+
+        scatter_df = build_pairwise_scatter_df(
+            benchmark_name,
+            selected_species,
+            selected_assays,
+            selected_models,
+            selected_datasets,
+            model_a,
+            model_b,
+        )
+
+        if scatter_df.empty:
+            st.info("No overlapping tracks for the selected filters (or one model is missing values).")
+        else:
+            min_v = float(min(scatter_df["Model A"].min(), scatter_df["Model B"].min()))
+            max_v = float(max(scatter_df["Model A"].max(), scatter_df["Model B"].max()))
+            pad = 0.05 * (max_v - min_v if max_v > min_v else 1.0)
+            axis_range = [min_v - pad, max_v + pad]
+            tick_step = (axis_range[1] - axis_range[0]) / 5
+            
+            hover_cols = ["datasets"]
+            if benchmark_name == "Functional Tracks" and "track_name_clean" in scatter_df.columns:
+                hover_cols.append("track_name_clean")
+            else:
+                hover_cols.append("datasets")
+
+            color_col = "assay_type" if "assay_type" in scatter_df.columns else "datasets"
+
+            fig_scatter = px.scatter(
+                scatter_df,
+                x="Model B",
+                y="Model A",
+                color=color_col,
+                color_discrete_map=ASSAY_COLORS,
+                hover_name="Track",
+                hover_data=hover_cols,
+            )
+
+            fig_scatter.add_shape(
+                type="line",
+                x0=axis_range[0], y0=axis_range[0],
+                x1=axis_range[1], y1=axis_range[1],
+                xref="x", yref="y",
+                line=dict(color="red", dash="dot", width=2),
+            )
+
+            fig_scatter.update_layout(
+                height=550,
+                margin=dict(l=60, r=20, t=20, b=60),
+                xaxis=dict(
+                    title=f"{model_b} — {cfg['metric_label']}",
+                    range=axis_range,
+                    dtick=tick_step,
+                    constrain="domain",
+                ),
+                yaxis=dict(
+                    title=f"{model_a} — {cfg['metric_label']}",
+                    range=axis_range,
+                    dtick=tick_step,
+                    scaleanchor="x",
+                    scaleratio=1,
+                    constrain="domain",
+                ),
+                plot_bgcolor="rgba(0,0,0,0)",
+                paper_bgcolor="rgba(0,0,0,0)",
+            )
+
+            fig_scatter.update_layout(
+                legend=dict(
+                    title="Assay type" if benchmark_name == "Functional Tracks" else "Genome Annotation",
+                    x=0.98,
+                    y=0.1,
+                    xanchor="right",
+                    yanchor="bottom",
+                    bgcolor="rgba(255,255,255,0.2)",  # semi-transparent white
+                    bordercolor="rgba(0,0,0,0.2)",
+                    borderwidth=1,
+                )
+            )
+
+            st.plotly_chart(fig_scatter, use_container_width=True)
+
+    with right:
+        st.markdown("#### ⏱️ Time to convergence")
+
+        x_mode = st.selectbox(
+            "X-axis",
+            options=["GPU (hours)", "Steps (billions)"],
+            index=0,
+            key=f"conv_x_mode_{benchmark_name}",
+        )
+
+
+        conv_df = build_convergence_df(
+            benchmark_name,
+            selected_species,
+            selected_assays,
+            selected_models,
+            selected_datasets,
+            x_mode=x_mode,
+        )
+
+        if conv_df.empty:
+            st.info("No convergence data found for the selected filters / x-axis mode.")
+        else:
+            fig_conv = px.scatter(
+                conv_df,
+                x="X",
+                y="Performance",
+                text="Model",
+                color="Model",
+                color_discrete_map=MODEL_COLORS,
+                hover_data=["Model", "X", "Performance"],
+            )
+            fig_conv.update_layout(
+                height=550,
+                xaxis_title=("GPU (hours)" if x_mode == "GPU (hours)" else x_mode),
+                yaxis_title=cfg["metric_label"],
+                plot_bgcolor="rgba(0,0,0,0)",
+                paper_bgcolor="rgba(0,0,0,0)",
+                showlegend=False,  # ✅ no legend
+            )
+            fig_conv.update_traces(
+                marker=dict(size=14),          # 👈 bigger dots
+                textposition="top center",
+            )
+
+            # Log scale only makes sense for hours (and sometimes best_step)
+            if x_mode in ["GPU (hours)"]:
+                fig_conv.update_xaxes(
+                type="log",
+                dtick=1,
+                minor=dict(ticks="", showgrid=False),
+            )
+            st.plotly_chart(fig_conv, use_container_width=True)
+
+    # ------------------------------------------------------------------
+    # Violin (full width, below)
+    # ------------------------------------------------------------------
+    st.subheader("🎻 Performance comparison across tracks")
+
+    violin_df = build_violin_df(
+        benchmark_name,
+        selected_species,
+        selected_assays,
+        selected_models,
+        selected_datasets,
+    )
+
+    if violin_df.empty:
+        st.info("No data for the selected filters.")
+    else:
+        model_order = (
+            violin_df
+            .groupby("Model")["Score"]
+            .median()
+            .sort_values(ascending=True)
+            .index
+            .tolist()
+        )
+
+        fig_violin = px.violin(
+            violin_df,
+            x="Model",
+            y="Score",
+            color="Model",
+            color_discrete_map=MODEL_COLORS,
+            box=True,
+            points=False,
+            category_orders={"Model": model_order},
+        )
+
+        fig_violin.update_layout(
+            height=650,
+            xaxis_title="",
+            yaxis_title=cfg["metric_label"],
+            plot_bgcolor="rgba(0,0,0,0)",
+            paper_bgcolor="rgba(0,0,0,0)",
+            showlegend=False,
+        )
+
+        fig_violin.update_traces(
+            box_visible=True,
+            meanline_visible=False,
+        )
+
+        st.plotly_chart(fig_violin, use_container_width=True)
+

src/streamlit_app.py

@@ -1,12 +1,11 @@
-from typing import List
 import os
 
+import numpy as np
 import pandas as pd
-import streamlit as st
 import plotly.express as px
-from plotly.subplots import make_subplots
 import plotly.graph_objects as go
-import numpy as np
+import streamlit as st
+from plotly.subplots import make_subplots
 
 # ---------------------------------------------------------------------
 # Page config (must be the first Streamlit command)
@@ -16,150 +15,163 @@ st.set_page_config(
     layout="wide",
 )
 
+import initial_release  # noqa: E402  (reads its CSV on import, so after the page config)
+
 # ---------------------------------------------------------------------
 # Configuration
 # ---------------------------------------------------------------------
 COLORS = {
-    # Primary colors 1 (our models)
-    'blue_0': '#004697',     # Darkest allowable blue
-    'blue_1': '#3973fc',     # Main blue
-    'blue_2': '#7ea4fc',     # Medium blue
-    'blue_3': '#c3d5fc',     # Light blue (lightest allowable blue)
-    # Secondary colors 1
-    'red_1': '#ff554d',      # Medium red
-    'red_2': '#ffe0de',      # Light red
-    # Primary colors 2
-    'green_1': '#00b050',    # Darkest green
-    'green_2': '#92d050',    # Medium green
-    'green_3': '#c6e0b4',    # Light green (lightest allowable green)
-    # Secondary colors 2
+    'blue_0': '#004697',
+    'blue_1': '#3973fc',
+    'blue_2': '#7ea4fc',
+    'blue_3': '#c3d5fc',
+    'red_1': '#ff554d',
+    'green_1': '#00b050',
+    'green_3': '#c6e0b4',
     'gold_1': '#fdb932',
-    # Tertiary colors
     'orange_1': '#ff975e',
     'purple_1': '#9a6ce4',
-    'purple_2': '#bb9aef',     # Medium purple
-    'purple_3': '#ceb5f5',     # Light purple (lightest allowable purple)
-    # Grays (other models)
-    'gray_1': '#808080',     # Darkest gray (use as a last resort)
-    'gray_2': '#b3b3b3',     # Medium gray (start with this as the darkest when possible)
-    'gray_3': '#e6e6e6',     # Lightest gray
-    'gray_4': '#ffffff',     # It's actually just white (use as a last resort)
-    # If all other options are exhausted
-    'cyan_1': '#0096b4',     # Darkest teal
-    'cyan_2': '#28bed2',     # Medium cyan
-    'cyan_3': '#8cdceb',     # Lightest cyan
-    'magenta_1': '#b428a0',  # Darkest magenta
-    'magenta_2': '#dc50be',  # Medium pink
-    'magenta_3': '#f5a0dc',  # Lightest pink
-    'yellow_1': '#c8aa00',   # Darkest yellow
-    'yellow_2': '#ffd200',   # Medium yellow
-    'yellow_3': '#fff08c',   # Lightest yellow
+    'purple_2': '#bb9aef',
+    'gray_1': '#808080',
+    'gray_2': '#b3b3b3',
+    'cyan_1': '#0096b4',
+    'magenta_1': '#b428a0',
 }
 
-
 ASSAY_TYPE_MAPPING = {
     'ATAC-seq': 'chromatin accessibility',
     'DNase-seq': 'chromatin accessibility',
     'Histone ChIP-seq': 'histone modifications',
-    'TF ChIP-seq': 'chromatin accessibility',
+    'TF ChIP-seq': 'TF binding',
     'PRO-cap': 'transcription initiation',
     'eCLIP': 'RNA binding sites',
     'RNA-seq': 'gene expression',
     'ribo-seq': 'mRNA translation',
-    'Annotation': 'genome annotation',
-    "Exon": "exon",
-    "Intron": "intron",
-    "Splice acceptor": "splice acceptor",
-    "Start codon": "start codon",
-
 }
 
 ASSAY_COLORS = {
     'chromatin accessibility': '#004697',
     'histone modifications': '#cc0000',
+    'TF binding': '#00b050',
     'transcription initiation': '#ff9900',
     'RNA binding sites': '#9933cc',
     'gene expression': '#009900',
     'mRNA translation': '#ff6699',
-    'genome annotation': '#ffcc00',
-    "intron": '#004697',
-    "exon": '#cc0000',
-    "splice acceptor": '#ff9900',
-    "start codon": '#9933cc',
+    'other': '#808080',
 }
-ASSAY_COLORS["other"] = "#808080"
 
-MODEL_COLORS = {
-    "NTv3 650M (pos)": COLORS['blue_0'],
-    'NTv3 650M (pre)': COLORS['blue_1'],    # #3973fc (Darkest blue)
-    'NTv3 100M (pre)': COLORS['blue_2'],    # #7ea4fc (Medium blue)
-    'NTv3 8M (pre)': COLORS['blue_3'],      # #c3d5fc (Light blue)
-    'Evo2 1B': COLORS['green_3'],      # #b3b3b3 (Medium gray)
-    "NTv2 500M": COLORS['gray_1'],
-    "BPNet arch. 6M": COLORS['cyan_1'],
-    "Residual CNN 44M":  COLORS['magenta_1'],
-    "PlantCAD2 88M": COLORS["purple_1"],
-    "Caduceus 7M": COLORS["purple_2"],
-    "HyenaDNA 7M": COLORS["yellow_2"]
+CLADE_COLORS = {
+    "Animals": COLORS['blue_1'],
+    "Plants": COLORS['green_1'],
+    "Fungi": COLORS['gold_1'],
+    "Protists": COLORS['purple_1'],
 }
 
-MODEL_TRAINING_STATUS = {
-    "NTv3 650M (pos)": "POS",
-    "NTv3 650M (pre)": "PRE",
-    "NTv3 100M (pre)": "PRE",
-    "NTv3 8M (pre)": "PRE",
-    "Residual CNN 44M": "SCRATCH",
-    "Caduceus 7M": "PRE",
-    "Evo2 1B": "PRE",
-    "NTv2 500M": "PRE",
-    "BPNet arch. 6M": "SCRATCH",
-    "PlantCAD2 88M": "PRE",
-    "HyenaDNA 7M": "PRE"
+# CSV model name -> the label the paper figure uses. Other models in the CSV (v1 NTv3
+# checkpoints, small BPNet / Residual CNN) are kept in the data but not shown.
+MODEL_LABELS = {
+    "BPNet arch. 6M": "BPNet",
+    "Residual CNN 44M": "Residual CNN",
+    "HyenaDNA 7M": "HyenaDNA",
+    "Caduceus 7M": "Caduceus",
+    "NTv2 500M": "NTv2",
+    "Evo2 1B": "Evo2",
+    "PlantCAD2 88M": "PlantCAD2",
+    "Borzoi": "Borzoi",
+    "AlphaGenome": "AlphaGenome",
+    "NTv3 700M (tracks)": "NTv3",
 }
+NTV3 = "NTv3"
 
-MODEL_GPU_MULTIPLIER = {
-    "Evo2 1B": 8,   # trained on 8 GPUs
+# In the paper figure's architecture blocks, with its colours.
+MODEL_COLORS = {
+    "BPNet": COLORS['cyan_1'],
+    "Residual CNN": COLORS['magenta_1'],
+    "HyenaDNA": COLORS['gold_1'],
+    "Caduceus": COLORS['purple_2'],
+    "NTv2": COLORS['gray_1'],
+    "Evo2": COLORS['green_3'],
+    "PlantCAD2": COLORS['purple_1'],
+    "Borzoi": COLORS['gray_2'],
+    "AlphaGenome": COLORS['orange_1'],
+    NTV3: COLORS['blue_0'],
 }
 
+MODEL_TRAINING_STATUS = {
+    "BPNet": "SCRATCH",
+    "Residual CNN": "SCRATCH",
+    "HyenaDNA": "PRE",
+    "Caduceus": "PRE",
+    "NTv2": "PRE",
+    "Evo2": "PRE",
+    "PlantCAD2": "PRE",
+    "Borzoi": "PRE",
+    "AlphaGenome": "PRE",
+    NTV3: "POS",
+}
 
 MODEL_NAMES = list(MODEL_COLORS.keys())
 
-PLANT_SPECIES = ["tomato", "rice", "maize", "arabidopsis"]
-ANIMAL_SPECIES = ["human", "chicken", "cattle"]
-
+# CSV species key -> label, grouped by clade, in the paper's order.
 SPECIES_GROUPS = {
-    "Plants": PLANT_SPECIES,
-    "Animals": ANIMAL_SPECIES,   # (your code calls these HUMAN_SPECIES, but they’re the “animal” set)
+    "Animals": {"human": "Human", "cattle": "Cattle", "rat": "Rat"},
+    "Plants": {
+        "arabidopsis": "A. thaliana",
+        "rice": "Rice",
+        "maize": "Maize",
+        "tomato": "Tomato",
+    },
+    "Fungi": {"yeast": "S. cerevisiae", "fission yeast": "S. pombe"},
+    "Protists": {"plasmodium": "P. falciparum", "dictyostelium": "D. discoideum"},
 }
+SPECIES_LABEL = {k: v for group in SPECIES_GROUPS.values() for k, v in group.items()}
+SPECIES_ORDER = list(SPECIES_LABEL)
+SPECIES_CLADE = {s: name for name, group in SPECIES_GROUPS.items() for s in group}
+SPECIES_ICON = {
+    "human": "🧍",
+    "cattle": "🐄",
+    "rat": "🐀",
+    "arabidopsis": "🌱",
+    "rice": "🌾",
+    "maize": "🌽",
+    "tomato": "🍅",
+    "yeast": "🍞",
+    "fission yeast": "🍺",
+    "plasmodium": "🦟",
+    "dictyostelium": "🦠",
+}
+SPECIES_COMMON_NAME = {
+    "arabidopsis": "thale cress",
+    "yeast": "baker's yeast",
+    "fission yeast": "fission yeast",
+    "plasmodium": "malaria parasite",
+    "dictyostelium": "social amoeba",
+}
+METRIC_LABEL = "Pearson correlation"
 
-
-_LAST_UPDATED = "Dec 10, 2025"
+_LAST_UPDATED = "Sep 24, 2026"
 _INTRO = """
-The **NTv3 Benchmark** is a curated benchmark of 106 long-range genomic datasets 
-designed to evaluate models under realistic 32 kb input, single-base-pair output settings. 
-The dataset spans two complementary task families: genome annotation (exon, intron, splice acceptor, start codon) 
-and functional-regulatory prediction, which includes diverse experimental tracks such as chromatin accessibility,
- histone modifications, transcription initiation (PRO-cap), RNA binding (eCLIP), gene expression (RNA-seq), 
- and translation (Ribo-seq).
-
-Data are drawn from a phylogenetically diverse set of species, including organisms seen during post-training 
-(human, chicken, arabidopsis, rice, maize) and entirely unseen species (cattle, tomato), with careful curation 
-to avoid data leakage. This design allows the dataset to probe long-range sequence-to-function mapping, 
-cross-species generalization, and transfer across heterogeneous regulatory modalities, 
-including assays not present in prior multispecies training corpora. By standardizing sequence length, 
-resolution, and evaluation metrics across all tracks, the NTv3 Benchmark provides a controlled dataset 
-for comparing representation quality across genomic foundation models.
-
-The metrics used are:
-- **Pearson correlations (multi-assay)**: per-dataset scores across species and models for functional tracks.
-- **MCC (bed tracks)**: per-track MCC values across species and models for gene annotation tracks.
+The **NTv3 Benchmark** is 155 long-range functional genomics tracks for evaluating models
+under realistic 32 kb input, single-base-pair output settings. The tracks span chromatin accessibility (ATAC-seq),
+histone modifications and transcription factor binding (ChIP-seq), transcription initiation (PRO-cap),
+RNA binding (eCLIP), gene expression (RNA-seq) and translation (Ribo-seq).
+
+The benchmark covers 11 phylogenetically diverse species:
+**animals** (human, cattle, rat), **plants** (*A. thaliana*, rice, maize, tomato),
+**fungi** (*S. cerevisiae*, *S. pombe*) and **protists** (*P. falciparum*, *D. discoideum*).
+
+The metric is the **Pearson correlation** on the test set, per track, averaged over three
+seeds where available. Not every model was run on every species, so scores are never
+averaged across species: pick a species in the sidebar for its own leaderboard, where every
+model shown was evaluated on all of that species' tracks. AlphaGenome is fine-tuned from its
+fold-1 checkpoint on human, whose test regions the all-folds checkpoint saw, and from its
+all-folds checkpoint on every other species.
 """
 
 HERE = os.path.dirname(os.path.abspath(__file__))  # /app/src
 PROJECT_ROOT = os.path.dirname(HERE)               # /app
 DATA_DIR = os.path.join(PROJECT_ROOT, "data")
-
-SINGLE_TABLE_PATH = os.path.join(DATA_DIR, "ntv3_benchmark_results.csv")  
+SINGLE_TABLE_PATH = os.path.join(DATA_DIR, "ntv3_benchmark_results.csv")
 
 # ---------------------------------------------------------------------
 # Data loading & preprocessing
@@ -167,139 +179,54 @@ SINGLE_TABLE_PATH = os.path.join(DATA_DIR, "ntv3_benchmark_results.csv")
 
 
 @st.cache_data
-def load_raw_data():
+def load_raw_data() -> pd.DataFrame:
     df = pd.read_csv(SINGLE_TABLE_PATH)
     df.columns = [c.strip() for c in df.columns]
     return df
 
 
-def _normalize_training_time_to_gpu_hours(df: pd.DataFrame) -> pd.DataFrame:
-    """
-    Your new column is `running_time`. In your sample it looks like seconds
-    (e.g. 317034 ~= 88 hours). We'll convert to hours if values look like seconds.
-    """
-    if "running_time" not in df.columns:
-        return df
-
-    rt = pd.to_numeric(df["running_time"], errors="coerce")
-    # Heuristic: if median is huge, it's probably seconds -> convert to hours
-    # (88 hours = 316800 seconds is a typical-looking value in your sample)
-    if rt.dropna().median() > 10_000:
-        df["GPU hours"] = rt / 3600.0
-    else:
-        df["GPU hours"] = rt.astype(float)
-
-    return df
-
-
-def _best_step_time_to_hours(s: pd.Series) -> pd.Series:
-    """
-    Converts strings like '3 days 04:26:26.467000' to hours (float).
-    Works with pandas Timedelta parsing.
-    """
-    td = pd.to_timedelta(s, errors="coerce")
-    return td.dt.total_seconds() / 3600.0
-
-
-
 @st.cache_data
-def load_expanded_data():
-    df = load_raw_data().copy()
-
-    df = df.rename(columns={"Metric": "Score", "model_name": "Model"})
+def load_track_data() -> pd.DataFrame:
+    """One row per (species, track, model): the score averaged over seeds."""
+    df = load_raw_data().rename(columns={"Metric": "Score", "model_name": "Model"})
+    df["Model"] = df["Model"].map(MODEL_LABELS)
+    df = df[df["Model"].notna() & df["species"].isin(SPECIES_ORDER)]
     df["Score"] = pd.to_numeric(df["Score"], errors="coerce")
-
-    if "best_step" in df.columns:
-        df["best_step"] = pd.to_numeric(df["best_step"], errors="coerce")
-
-    if "best_step_time" in df.columns:
-        df["best_step_time_hours"] = _best_step_time_to_hours(df["best_step_time"])
-    else:
-        df["best_step_time_hours"] = np.nan
-
-    is_annot = df.get("assay_type", "").astype(str).eq("Annotation")
-    pearson_raw = df[~is_annot].copy()
-    mcc_raw = df[is_annot].copy()
-
-    # -------------------------
-    # Functional Tracks (Pearson)
-    # -------------------------
-    pearson_group_cols = ["species", "datasets", "Model"]
-    if "assay_type" in pearson_raw.columns:
-        pearson_group_cols.append("assay_type")
-
-    pearson_df = (
-        pearson_raw
-        .groupby(pearson_group_cols, as_index=False, dropna=False)
-        .agg({
-            "Score": "mean",
-            "best_step": "mean",
-            "best_step_time_hours": "mean",
-        })
+    keys = ["species", "datasets", "Model", "assay_type", "track_name_clean"]
+    out = df.groupby(keys, as_index=False, dropna=False).agg(
+        Score=("Score", "mean"), Seeds=("Score", "size")
     )
+    out["assay_type"] = out["assay_type"].map(ASSAY_TYPE_MAPPING).fillna("other")
+    return out
 
-    # ✅ merge track_name_clean WHILE assay_type is still raw
-    if "track_name_clean" in pearson_raw.columns:
-        map_keys = ["species", "datasets"]
-        if "assay_type" in pearson_raw.columns:
-            map_keys.append("assay_type")
-
-        track_map = (
-            pearson_raw[map_keys + ["track_name_clean"]]
-            .dropna(subset=["track_name_clean"])
-            .drop_duplicates()
-        )
-        pearson_df = pearson_df.merge(track_map, on=map_keys, how="left")
-
-    # ✅ now it’s safe to map assay_type to categories
-    if "assay_type" in pearson_df.columns:
-        pearson_df["assay_type"] = (
-            pearson_df["assay_type"].astype(str).map(ASSAY_TYPE_MAPPING).fillna("Other")
-        )
 
-    # -------------------------
-    # Genome Annotation (MCC)
-    # -------------------------
-    mcc_df = (
-        mcc_raw
-        .groupby(["species", "datasets", "Model"], as_index=False, dropna=False)
-        .agg({
-            "Score": "mean",
-            "best_step": "mean",
-            "best_step_time_hours": "mean",
-        })
+@st.cache_data
+def load_run_data() -> pd.DataFrame:
+    """One row per training run: its best checkpoint's step and GPU hours."""
+    df = load_raw_data().rename(columns={"model_name": "Model"})
+    df["Model"] = df["Model"].map(MODEL_LABELS)
+    df = df[df["Model"].notna() & df["species"].isin(SPECIES_ORDER)]
+    run_cols = ["species", "Model", "best_step", "best_step_time", "running_time"]
+    runs = df.drop_duplicates(run_cols).copy()
+    # Training steps only: excludes job setup and validation, whose cadence differs
+    # between runs of the benchmark.
+    # Parsed one by one: pandas 3 misparses a column mixing fraction lengths.
+    hours = runs["best_step_train_time"].map(
+        lambda v: pd.Timedelta(v).total_seconds() / 3600 if pd.notna(v) else np.nan
     )
-
-    return pearson_df, mcc_df
+    runs["GPU hours"] = hours * pd.to_numeric(runs["num_gpus"], errors="coerce")
+    runs["Tokens (billions)"] = pd.to_numeric(runs["best_step"], errors="coerce") / 1e9
+    return runs
 
 
-_PEARSON_DF, _MCC_DF = load_expanded_data()
+_TRACKS = load_track_data()
+_RUNS = load_run_data()
 
-# Global sets (we'll further filter per-benchmark below)
-_ALL_SPECIES = sorted(
-    set(_PEARSON_DF["species"].unique()).union(_MCC_DF["species"].unique())
-)
 
-_ALL_ASSAYS = (
-    sorted(_PEARSON_DF["assay_type"].dropna().unique())
-    if "assay_type" in _PEARSON_DF.columns
-    else []
-)
-
-_ALL_MODELS = MODEL_NAMES[:]
-
-_BENCHMARKS = {
-    "Functional Tracks": {
-        "df": _PEARSON_DF,
-        "metric_label": "Pearson correlation",
-        "has_assay_type": True,
-    },
-    "Genome Annotation": {
-        "df": _MCC_DF,
-        "metric_label": "MCC",
-        "has_assay_type": False,
-    },
-}
+def models_in(df: pd.DataFrame) -> list[str]:
+    """Models present in `df`, in the paper's block order."""
+    present = set(df["Model"])
+    return [m for m in MODEL_NAMES if m in present]
 
 
 # ---------------------------------------------------------------------
@@ -307,775 +234,517 @@ _BENCHMARKS = {
 # ---------------------------------------------------------------------
 
 
-def filter_base_df(
-    benchmark_name: str,
-    selected_species: List[str],
-    selected_assays: List[str],
-    selected_models: List[str],
-    selected_datasets: List[str],
-) -> pd.DataFrame:
-    cfg = _BENCHMARKS[benchmark_name]
-    df = cfg["df"].copy()
-
-    # Species filter
-    if selected_species:
-        df = df[df["species"].isin(selected_species)]
-
-    # Assay type filter (Pearson only)
-    if cfg.get("has_assay_type", False) and selected_assays and "assay_type" in df.columns:
-        df = df[df["assay_type"].isin(selected_assays)]
-
-    # Dataset / bed track filter (for MCC, but safe to apply generally)
-    if selected_datasets and "datasets" in df.columns:
-        df = df[df["datasets"].isin(selected_datasets)]
-
-    # Model filter
-    if selected_models:
-        df = df[df["Model"].isin(selected_models)]
-
-    return df
-
-
-def build_leaderboard(
-    benchmark_name: str,
-    selected_species: List[str],
-    selected_assays: List[str],
-    selected_models: List[str],
-    selected_datasets: List[str],
-) -> pd.DataFrame:
-    df = filter_base_df(
-        benchmark_name,
-        selected_species,
-        selected_assays,
-        selected_models,
-        selected_datasets,
+def build_species_scores(df: pd.DataFrame) -> pd.DataFrame:
+    """Mean over tracks per (species, model): the paper figure's points."""
+    return df.groupby(["species", "Model"], as_index=False).agg(
+        Score=("Score", "mean"),
+        Tracks=("datasets", "nunique"),
+        Seeds=("Seeds", "max"),
     )
 
-    if df.empty:
-        return pd.DataFrame(columns=["Model", "Model Type", "Num entries", "Mean score"])
 
-    agg = (
-        df.groupby("Model")["Score"]
-        .mean()
-        .reset_index()
-        .rename(columns={"Score": "Mean score"})
-    )
+def build_leaderboard(df: pd.DataFrame) -> pd.DataFrame:
+    if df.empty:
+        return pd.DataFrame(columns=["Model", "Training", "Num entries", "Mean score"])
+    agg = df.groupby("Model").agg(
+        **{
+            "Num entries": ("Score", "count"),
+            "Seeds": ("Seeds", "max"),
+            "Mean score": ("Score", "mean"),
+        }
+    ).reset_index()
     agg["Mean score"] = agg["Mean score"].round(3)
-
-    agg["Num entries"] = (
-        df.groupby("Model")["Score"].count().reindex(agg["Model"]).values
-    )
-
-    # 👇 Add training regime column
     agg["Training"] = agg["Model"].map(MODEL_TRAINING_STATUS).fillna("UNKNOWN")
-
-    # Sort by performance
     agg = agg.sort_values("Mean score", ascending=False).reset_index(drop=True)
-
-    # Column order
-    agg = agg[["Model", "Training", "Num entries", "Mean score"]]
-
-    # Ensure the index starts with 1
+    agg = agg[["Model", "Training", "Num entries", "Seeds", "Mean score"]]
     agg.index += 1
-
     return agg
 
 
-
-def build_bar_df(
-    benchmark_name: str,
-    selected_species: List[str],
-    selected_assays: List[str],
-    selected_models: List[str],
-    selected_datasets: List[str],
-) -> pd.DataFrame:
-    """For now, just one bar per model (same as leaderboard)."""
-    return build_leaderboard(
-        benchmark_name, selected_species, selected_assays, selected_models, selected_datasets
+def build_category_model_df(df: pd.DataFrame) -> pd.DataFrame:
+    """Mean score per (assay category, model)."""
+    if df.empty:
+        return pd.DataFrame(columns=["Category", "Model", "Mean score"])
+    out = (
+        df.groupby(["assay_type", "Model"], as_index=False)["Score"].mean()
+        .rename(columns={"assay_type": "Category", "Score": "Mean score"})
     )
+    out["Mean score"] = out["Mean score"].round(3)
+    return out
 
 
-def build_category_model_df(
-    benchmark_name: str,
-    selected_species: List[str],
-    selected_assays: List[str],
-    selected_models: List[str],
-    selected_datasets: List[str],
-) -> pd.DataFrame:
-    """
-    Mean score per (category, Model) after applying the same filters.
-    Category = assay_type (Functional Tracks) or datasets (Genome Annotation).
-    """
-    cfg = _BENCHMARKS[benchmark_name]
-    df = filter_base_df(
-        benchmark_name,
-        selected_species,
-        selected_assays,
-        selected_models,
-        selected_datasets,
+def build_pairwise_scatter_df(df: pd.DataFrame, model_a: str, model_b: str) -> pd.DataFrame:
+    """Scores of two models on the tracks both were evaluated on."""
+    sub = df[df["Model"].isin([model_a, model_b])]
+    wide = sub.pivot_table(
+        index=["species", "assay_type", "datasets", "track_name_clean"],
+        columns="Model",
+        values="Score",
+    ).reset_index()
+    if model_a not in wide.columns or model_b not in wide.columns:
+        return pd.DataFrame()
+    wide = wide.dropna(subset=[model_a, model_b])
+    wide["Species"] = wide["species"].map(SPECIES_LABEL)
+    wide["Track"] = wide["Species"] + " / " + wide["track_name_clean"].astype(str)
+    return wide.rename(columns={model_a: "Model A", model_b: "Model B"})
+
+
+def aggregate_pairs_by_species(pairs: pd.DataFrame) -> pd.DataFrame:
+    """One point per species: both models' means over the tracks they share there."""
+    clade = {s: name for name, group in SPECIES_GROUPS.items() for s in group}
+    out = pairs.groupby(["species", "Species"], as_index=False).agg(
+        **{
+            "Model A": ("Model A", "mean"),
+            "Model B": ("Model B", "mean"),
+            "Shared tracks": ("datasets", "size"),
+        }
     )
-    if df.empty:
-        return pd.DataFrame(columns=["Category", "Model", "Mean score"])
+    out["Clade"] = out["species"].map(clade)
+    out["Track"] = out["Species"]
+    return out
 
-    # Pick the right breakdown column
-    if cfg.get("has_assay_type", False) and "assay_type" in df.columns:
-        category_col = "assay_type"
-        category_label = "Assay type"
-    else:
-        category_col = "datasets"
-        category_label = "Dataset"
 
-    if category_col not in df.columns:
-        return pd.DataFrame(columns=["Category", "Model", "Mean score"])
+# ---------------------------------------------------------------------
+# Plots
+# ---------------------------------------------------------------------
 
-    out = (
-        df.groupby([category_col, "Model"], as_index=False)["Score"]
-        .mean()
-        .rename(columns={category_col: "Category", "Score": "Mean score"})
-    )
-    out["Mean score"] = out["Mean score"].round(3)
-    out.attrs["category_label"] = category_label  # for nicer axis title
-    return out
 
+def plot_species_overview(scores: pd.DataFrame, models: list[str]) -> go.Figure:
+    """The paper figure: one column per species, one point per model evaluated on it."""
+    cols = [s for s in SPECIES_ORDER if s in set(scores["species"])]
+    labels = [SPECIES_LABEL[s] for s in cols]
+    fig = go.Figure()
+    # Thin guide line per species, from the weakest to the strongest model.
+    span = scores.groupby("species")["Score"].agg(["min", "max"]).reindex(cols)
+    for label, (lo, hi) in zip(labels, span.itertuples(index=False)):
+        fig.add_shape(
+            type="line", x0=label, x1=label, y0=lo, y1=hi, layer="below",
+            line=dict(color="rgba(128,128,128,0.35)", width=2),
+        )
+    # AlphaGenome is drawn last so it stays visible where it sits on NTv3's marker;
+    # `legendrank` keeps the legend in the paper's block order.
+    draw_order = [m for m in models if m != "AlphaGenome"] + (
+        ["AlphaGenome"] if "AlphaGenome" in models else []
+    )
+    for model in draw_order:
+        sub = scores[scores["Model"] == model].set_index("species").reindex(cols)
+        is_ntv3 = model == NTV3
+        fig.add_trace(
+            go.Scatter(
+                x=labels,
+                y=sub["Score"],
+                mode="markers",
+                name=model,
+                legendrank=models.index(model),
+                marker=dict(
+                    color=MODEL_COLORS[model],
+                    size=16 if is_ntv3 else 11,
+                    symbol="diamond" if is_ntv3 else "circle",
+                    line=dict(color="rgba(0,0,0,0.5)", width=1),
+                ),
+                customdata=np.stack([sub["Tracks"], sub["Seeds"]], axis=-1),
+                hovertemplate=(
+                    f"<b>{model}</b><br>%{{x}}<br>{METRIC_LABEL}: %{{y:.3f}}"
+                    "<br>%{customdata[0]} tracks, %{customdata[1]} seed(s)<extra></extra>"
+                ),
+            )
+        )
+    # Clade separators and clade names above the plot.
+    x = 0
+    for name, group in SPECIES_GROUPS.items():
+        n = sum(1 for s in group if s in cols)
+        if n == 0:
+            continue
+        fig.add_annotation(
+            x=x + (n - 1) / 2, y=1.0, xref="x", yref="paper", yanchor="bottom",
+            text=f"<b>{name}</b>", showarrow=False,
+        )
+        x += n
+        if x < len(cols):
+            fig.add_vline(x=x - 0.5, line=dict(color="rgba(128,128,128,0.4)", dash="dot"))
+    fig.update_xaxes(categoryorder="array", categoryarray=labels, title_text="")
+    fig.update_yaxes(
+        title_text=f"{METRIC_LABEL} on test set",
+        showgrid=True,
+        gridcolor="rgba(128,128,128,0.15)",
+        automargin=True,
+        tickformat=".1f",
+    )
+    fig.update_layout(
+        height=600,
+        plot_bgcolor="rgba(0,0,0,0)",
+        paper_bgcolor="rgba(0,0,0,0)",
+        legend=dict(orientation="h", yanchor="top", y=-0.1, x=0.5, xanchor="center"),
+        margin=dict(t=40, l=80, r=10, b=40),
+    )
+    return fig
 
-def plot_breakdown_facets_sorted_models(
-    breakdown_df: pd.DataFrame,
-    metric_label: str,
-    height: int = 420,
-):
-    categories = list(breakdown_df["Category"].dropna().unique())
-    categories = sorted(categories)
 
-    n = len(categories)
-    if n == 0:
-        return None
+def plot_mean_bars(leaderboard: pd.DataFrame) -> go.Figure:
+    bar_df = leaderboard.sort_values("Mean score", ascending=True)
+    fig = px.bar(
+        bar_df,
+        x="Model",
+        y="Mean score",
+        color="Model",
+        color_discrete_map=MODEL_COLORS,
+        category_orders={"Model": bar_df["Model"].tolist()},
+    )
+    fig.update_layout(
+        height=500,
+        xaxis_title="",
+        yaxis_title=METRIC_LABEL,
+        plot_bgcolor="rgba(0,0,0,0)",
+        paper_bgcolor="rgba(0,0,0,0)",
+        bargap=0.08,
+    )
+    fig.update_xaxes(showticklabels=False)
+    return fig
 
-    rows = 1
-    cols = n  # 👈 everything in one row
 
-    # Global y-range (consistent scale)
+def plot_breakdown_facets_sorted_models(breakdown_df: pd.DataFrame, height: int = 300):
+    categories = sorted(breakdown_df["Category"].dropna().unique())
+    if not categories:
+        return None
     y_min = breakdown_df["Mean score"].min()
     y_max = breakdown_df["Mean score"].max()
     pad = 0.05 * (y_max - y_min if y_max > y_min else 1.0)
-    y_range = [y_min - pad, y_max + pad]
+    y_range = [min(0, y_min - pad), y_max + pad]
 
     fig = make_subplots(
-        rows=rows,
-        cols=cols,
+        rows=1,
+        cols=len(categories),
         subplot_titles=categories,
         shared_yaxes=True,
-        horizontal_spacing=0.04,  # tighter spacing
+        horizontal_spacing=0.04,
     )
-
     for i, cat in enumerate(categories):
-        r = (i // cols) + 1
-        c = (i % cols) + 1
-
-        sub = (
-            breakdown_df[breakdown_df["Category"] == cat]
-            .sort_values("Mean score", ascending=True)
-        )
-
+        sub = breakdown_df[breakdown_df["Category"] == cat].sort_values("Mean score")
         fig.add_trace(
             go.Bar(
                 x=sub["Model"],
                 y=sub["Mean score"],
                 marker_color=[MODEL_COLORS.get(m, "#808080") for m in sub["Model"]],
                 showlegend=False,
+                hovertemplate="%{x}: %{y:.3f}<extra></extra>",
             ),
-            row=r,
-            col=c,
+            row=1,
+            col=i + 1,
         )
-
-        fig.update_xaxes(showticklabels=False, title_text="", row=r, col=c)
-        fig.update_yaxes(range=y_range, title_text="", row=r, col=c)  # 👈 apply range
-
+        fig.update_xaxes(showticklabels=False, title_text="", row=1, col=i + 1)
+        fig.update_yaxes(range=y_range, title_text="", row=1, col=i + 1)
     fig.update_layout(
         height=height,
         plot_bgcolor="rgba(0,0,0,0)",
         paper_bgcolor="rgba(0,0,0,0)",
         margin=dict(t=60, l=10, r=10, b=10),
     )
-
-    # Single y-axis label on the leftmost panel
-    fig.update_yaxes(title_text=metric_label, row=1, col=1)
-
+    fig.update_yaxes(title_text=METRIC_LABEL, row=1, col=1)
     return fig
 
-def build_pairwise_scatter_df(
-    benchmark_name: str,
-    selected_species: List[str],
-    selected_assays: List[str],
-    selected_models: List[str],
-    selected_datasets: List[str],
-    model_a: str,
-    model_b: str,
-) -> pd.DataFrame:
-    cfg = _BENCHMARKS[benchmark_name]
-
-    models_for_filter = (
-        list(set(selected_models + [model_a, model_b]))
-        if selected_models else [model_a, model_b]
-    )
-
-    df = filter_base_df(
-        benchmark_name,
-        selected_species,
-        selected_assays,
-        models_for_filter,
-        selected_datasets,
-    )
-    if df.empty:
-        return pd.DataFrame()
-
-    # ---- define "track identity" for head-to-head ----
-    # Always use datasets for the identity (x/y points)
-    track_cols = ["datasets"]
-    if cfg.get("has_assay_type", False) and "assay_type" in df.columns:
-        track_cols = ["assay_type", "datasets"]
 
-    keep_species = "species" in df.columns and (selected_species is None or len(selected_species) != 1)
-    id_cols = (["species"] if keep_species else []) + track_cols
-
-    wide = (
-        df[df["Model"].isin([model_a, model_b])]
-        .pivot_table(index=id_cols, columns="Model", values="Score", aggfunc="mean")
-        .reset_index()
-    )
-
-    if model_a not in wide.columns or model_b not in wide.columns:
-        return pd.DataFrame()
+def show_head_to_head(
+    df: pd.DataFrame, key: str, per_species: bool = False, title: str | None = None
+) -> None:
+    """Two models on their shared tracks only, with the number of tracks compared.
 
-    wide = wide.dropna(subset=[model_a, model_b])
+    Per track by default, one point per track coloured by assay; `per_species` shows
+    one point per species instead, each the mean over that species' shared tracks.
+    """
+    st.markdown(title or "#### ⚖️ Head-to-head (per track)")
+    options = models_in(df)
+    if len(options) < 2:
+        st.info("Fewer than two models were evaluated here.")
+        return
+    default_a = options.index(NTV3) if NTV3 in options else 0
+    c_a, c_b = st.columns([1, 1])
+    with c_a:
+        model_a = st.selectbox(
+            "Model A (y-axis)", options=options, index=default_a, key=f"a_{key}"
+        )
+    with c_b:
+        b_options = [m for m in options if m != model_a]
+        default_b = b_options.index("AlphaGenome") if "AlphaGenome" in b_options else 0
+        model_b = st.selectbox(
+            "Model B (x-axis)", options=b_options, index=default_b, key=f"b_{key}"
+        )
 
-    # Nice display label: use datasets (not track_name_clean)
-    if "assay_type" in wide.columns:
-        wide["Track"] = wide["assay_type"].astype(str) + " / " + wide["datasets"].astype(str)
+    scatter_df = build_pairwise_scatter_df(df, model_a, model_b)
+    if scatter_df.empty:
+        st.info(f"{model_a} and {model_b} share no evaluated track.")
+        return
+
+    n_tracks = len(scatter_df)
+    n_species = scatter_df["species"].nunique()
+    if per_species:
+        scatter_df = aggregate_pairs_by_species(scatter_df)
+        wins = int((scatter_df["Model A"] > scatter_df["Model B"]).sum())
+        st.caption(
+            f"Compared on **n = {n_species} shared species** ({n_tracks} shared "
+            f"tracks). {model_a} is higher on {wins} of them."
+        )
+        color_col, hover = "Clade", {"Shared tracks": True}
     else:
-        wide["Track"] = wide["datasets"].astype(str)
-
-    wide = wide.rename(columns={model_a: "Model A", model_b: "Model B"})
-
-    # ---- Pearson-only: merge track_name_clean for hover ----
-    if benchmark_name == "Functional Tracks" and "track_name_clean" in df.columns:
-        merge_keys = id_cols.copy()  # species? + assay_type? + datasets
-        track_map = (
-            df[merge_keys + ["track_name_clean"]]
-            .dropna(subset=["track_name_clean"])
-            .drop_duplicates()
+        wins = int((scatter_df["Model A"] > scatter_df["Model B"]).sum())
+        st.caption(
+            f"Compared on **n = {n_tracks} shared tracks** over {n_species} "
+            f"species. {model_a} is higher on {wins} of them."
         )
-        wide = wide.merge(track_map, on=merge_keys, how="left")
-
-    return wide
-
-
-
-def build_violin_df(
-    benchmark_name: str,
-    selected_species: List[str],
-    selected_assays: List[str],
-    selected_models: List[str],
-    selected_datasets: List[str],
-) -> pd.DataFrame:
-    # Use the same base filtering, but keep all per-track rows
-    df = filter_base_df(
-        benchmark_name,
-        selected_species,
-        selected_assays,
-        selected_models,
-        selected_datasets,
+        color_col, hover = "assay_type", {"Species": True, "datasets": True}
+
+    min_v = float(min(scatter_df["Model A"].min(), scatter_df["Model B"].min()))
+    max_v = float(max(scatter_df["Model A"].max(), scatter_df["Model B"].max()))
+    pad = 0.05 * (max_v - min_v if max_v > min_v else 1.0)
+    axis_range = [min_v - pad, max_v + pad]
+
+    color_map = ASSAY_COLORS if color_col == "assay_type" else CLADE_COLORS
+    fig = px.scatter(
+        scatter_df,
+        x="Model B",
+        y="Model A",
+        color=color_col,
+        color_discrete_map=color_map,
+        category_orders={"Clade": list(SPECIES_GROUPS)},
+        hover_name="Track",
+        hover_data={**hover, "Model A": ":.3f", "Model B": ":.3f"},
+        text="Species" if per_species else None,
     )
-    # Keep only needed columns
-    keep = ["Model", "Score"]
-    for col in ["species", "assay_type", "datasets"]:
-        if col in df.columns:
-            keep.append(col)
-    return df[keep].copy()
-
-
-def build_convergence_df(
-    benchmark_name: str,
-    selected_species: List[str],
-    selected_assays: List[str],
-    selected_models: List[str],
-    selected_datasets: List[str],
-    x_mode: str = "best_step",  # "best_step" | "best_step_time"
-) -> pd.DataFrame:
-
-    df = filter_base_df(
-        benchmark_name,
-        selected_species,
-        selected_assays,
-        selected_models,
-        selected_datasets,
+    if per_species:
+        fig.update_traces(marker=dict(size=13), textposition="top center")
+    fig.add_shape(
+        type="line",
+        x0=axis_range[0], y0=axis_range[0], x1=axis_range[1], y1=axis_range[1],
+        xref="x", yref="y",
+        line=dict(color="red", dash="dot", width=2),
     )
-
-    if df.empty:
-        return pd.DataFrame(columns=["Model", "X", "Performance"])
-
-    # Mean performance per model
-    out = (
-        df.groupby("Model", as_index=False)
-        .agg({"Score": "mean"})
-        .rename(columns={"Score": "Performance"})
+    fig.update_layout(
+        height=620,
+        margin=dict(l=60, r=20, t=20, b=110),
+        xaxis=dict(
+            title=f"{model_b} — {METRIC_LABEL}",
+            range=axis_range, dtick=0.1, tickformat=".1f", constrain="domain",
+        ),
+        yaxis=dict(
+            title=f"{model_a} — {METRIC_LABEL}",
+            range=axis_range, dtick=0.1, tickformat=".1f",
+            scaleanchor="x", scaleratio=1, constrain="domain",
+        ),
+        plot_bgcolor="rgba(0,0,0,0)",
+        paper_bgcolor="rgba(0,0,0,0)",
+        legend=dict(
+            title="",
+            orientation="h",
+            x=0.5, xanchor="center", y=-0.15, yanchor="top",
+        ),
     )
+    st.plotly_chart(fig, width="stretch")
 
-    # -------------------------
-    # X axis selection
-    # -------------------------
-    if x_mode == "Steps (billions)":
-        if "best_step" not in df.columns:
-            return pd.DataFrame(columns=["Model", "X", "Performance"])
-
-        x = (
-            df.groupby("Model", as_index=False)["best_step"]
-            .mean()
-            .rename(columns={"best_step": "X"})
-        )
 
-    else:  # best_step_time (GPU hours)
-        if "best_step_time_hours" not in df.columns:
-            return pd.DataFrame(columns=["Model", "X", "Performance"])
-
-        x = (
-            df.groupby("Model", as_index=False)["best_step_time_hours"]
-            .mean()
-            .rename(columns={"best_step_time_hours": "X"})
-        )
+def build_convergence_df(tracks: pd.DataFrame, runs: pd.DataFrame, x_col: str) -> pd.DataFrame:
+    """Per model: mean score and the mean cost of reaching its best checkpoint."""
+    perf = tracks.groupby("Model", as_index=False)["Score"].mean()
+    cost = runs.groupby("Model", as_index=False).agg(X=(x_col, "mean"), Runs=(x_col, "count"))
+    out = perf.merge(cost, on="Model").dropna(subset=["X"])
+    out["Score"] = out["Score"].round(3)
+    return out
 
-        # 👇 Apply GPU multiplier (Evo2 uses 8 GPUs)
-        gpu_multiplier = {
-            "Evo2 1B": 8,
-        }
 
-        x["X"] = x.apply(
-            lambda r: r["X"] * gpu_multiplier.get(r["Model"], 1),
-            axis=1,
+def show_convergence(tracks: pd.DataFrame, runs: pd.DataFrame, key: str) -> None:
+    st.markdown("#### ⏱️ Time to convergence")
+    x_mode = st.selectbox(
+        "X-axis",
+        options=["GPU hours", "Tokens (billions)"],
+        index=0,
+        key=f"conv_{key}",
+    )
+    conv_df = build_convergence_df(tracks, runs, x_mode)
+    if conv_df.empty:
+        st.info("No convergence data for this species.")
+        return
+    if x_mode == "GPU hours":
+        caption = (
+            "GPU hours spent in training steps until the best validation checkpoint "
+            "(the one scored on the test set), × GPUs used, averaged over seeds. Job "
+            "setup and validation are excluded. All runs on H100s."
         )
-
-    # Merge + clean
-    out = out.merge(x, on="Model", how="left")
-    out = out.dropna(subset=["X", "Performance"])
-
-    out["Performance"] = out["Performance"].round(3)
-
-    return out
+    else:
+        caption = (
+            "Training tokens seen at the best validation checkpoint, averaged over "
+            "seeds. Validation ran every 1.05B tokens on most runs, so this is "
+            "resolved to about 1B tokens."
+        )
+    st.caption(caption)
+    fig = px.scatter(
+        conv_df,
+        x="X",
+        y="Score",
+        text="Model",
+        color="Model",
+        color_discrete_map=MODEL_COLORS,
+        hover_data={"Model": True, "X": ":.2f", "Score": ":.3f", "Runs": True},
+    )
+    fig.update_traces(marker=dict(size=14), textposition="middle right")
+    fig.update_layout(
+        height=620,
+        xaxis_title=x_mode + (" (log scale)" if x_mode == "GPU hours" else ""),
+        yaxis_title=METRIC_LABEL,
+        plot_bgcolor="rgba(0,0,0,0)",
+        paper_bgcolor="rgba(0,0,0,0)",
+        showlegend=False,
+    )
+    if x_mode == "GPU hours":
+        lo, hi = np.log10(conv_df["X"].min()), np.log10(conv_df["X"].max())
+        fig.update_xaxes(
+            type="log", dtick=1, range=[lo - 0.15, hi + 0.45],
+            minor=dict(ticks="", showgrid=False),
+        )
+    else:
+        lo, hi = conv_df["X"].min(), conv_df["X"].max()
+        fig.update_xaxes(range=[lo - 0.05 * (hi - lo), hi + 0.3 * (hi - lo)])
+    st.plotly_chart(fig, width="stretch")
+
+
+def plot_violin(df: pd.DataFrame) -> go.Figure:
+    order = df.groupby("Model")["Score"].median().sort_values().index.tolist()
+    fig = px.violin(
+        df,
+        x="Model",
+        y="Score",
+        color="Model",
+        color_discrete_map=MODEL_COLORS,
+        box=True,
+        points=False,
+        category_orders={"Model": order},
+        hover_data=["track_name_clean"],
+    )
+    fig.update_layout(
+        height=650,
+        xaxis_title="",
+        yaxis_title=METRIC_LABEL,
+        plot_bgcolor="rgba(0,0,0,0)",
+        paper_bgcolor="rgba(0,0,0,0)",
+        showlegend=False,
+    )
+    fig.update_traces(box_visible=True, meanline_visible=False)
+    return fig
 
 
 # ---------------------------------------------------------------------
-# UI helpers
+# Pages
 # ---------------------------------------------------------------------
 
 
-def sidebar_toggle(label: str, value: bool = False, key: str | None = None) -> bool:
-    """
-    Wrapper to use st.sidebar.toggle when available, otherwise fall back to checkbox.
-    This makes the app compatible with older Streamlit versions on Hugging Face.
-    """
-    toggle_fn = getattr(st.sidebar, "toggle", None)
-    if toggle_fn is not None:
-        return toggle_fn(label, value=value, key=key)
-    # Fallback for older Streamlit versions
-    return st.sidebar.checkbox(label, value=value, key=key)
+SIDEBAR_CSS = """
+<style>
+[data-testid="stSidebarNav"] a, [data-testid="stSidebarNavLink"] {
+    padding-top: 0.35rem; padding-bottom: 0.35rem; border-radius: 0.5rem;
+}
+[data-testid="stSidebarNav"] a span, [data-testid="stSidebarNavLink"] span {
+    font-size: 1.08rem;
+}
+[data-testid="stNavSectionHeader"], [data-testid="stSidebarNav"] header {
+    font-size: 0.85rem; font-weight: 700; letter-spacing: 0.06em;
+    text-transform: uppercase; opacity: 0.7; margin-top: 0.8rem;
+}
+</style>
+"""
 
-# ---------------------------------------------------------------------
-# Streamlit UI
-# ---------------------------------------------------------------------
-def main():
+
+def overview_page() -> None:
+    df = _TRACKS
     st.title("🧬 NTv3 Benchmark")
     st.markdown(_INTRO)
     st.markdown(f"_Last updated: **{_LAST_UPDATED}**_")
+    st.divider()
 
-    # --- Sidebar filters ---
-    st.sidebar.header("Filters")
-
-    # Benchmark
-    benchmark_name = st.sidebar.selectbox(
-        "Benchmark",
-        options=list(_BENCHMARKS.keys()),
-        index=0,
-    )
-
-    cfg = _BENCHMARKS[benchmark_name]
-    df_bench = cfg["df"]
-
-    # Species toggles, but only for species present in this benchmark
-    st.sidebar.subheader("Species")
-
-    # Toggle: Plants vs Animals
-    species_group = st.sidebar.radio(
-        "Group",
-        options=["Animals", "Plants"],
-        index=0,
-        horizontal=True,
-        key=f"species_group_{benchmark_name}",
+    st.subheader("📊 Every model on every species")
+    st.caption(
+        "One point per model and species: the mean over that species' tracks. "
+        "A model with no point on a species was not evaluated on it. Hover for values."
     )
+    scores = build_species_scores(df)
+    st.plotly_chart(plot_species_overview(scores, models_in(df)), width="stretch")
 
-    available_species_all = sorted(df_bench["species"].unique())
-    allowed_species = set(SPECIES_GROUPS[species_group]).intersection(available_species_all)
-    available_species = sorted(allowed_species)
-
-    selected_species: List[str] = []
-    for sp in available_species:
-        if sidebar_toggle(sp, value=True, key=f"species_{benchmark_name}_{species_group}_{sp}"):
-            selected_species.append(sp)
-
-    # (Optional) If no species exist for that group in this benchmark
-    if not available_species:
-        st.sidebar.info(f"No {species_group.lower()} species available for this benchmark.")
-
-    # Assay toggles (Pearson only), based on filtered species
-    if cfg.get("has_assay_type", False):
-        st.sidebar.subheader("Assay types")
-        if selected_species:
-            df_for_assays = df_bench[df_bench["species"].isin(selected_species)]
-        else:
-            df_for_assays = df_bench
-        available_assays = (
-            sorted(df_for_assays["assay_type"].dropna().unique())
-            if "assay_type" in df_for_assays.columns
-            else []
-        )
-        selected_assays: List[str] = []
-        for assay in available_assays:
-            if sidebar_toggle(assay, value=True, key=f"assay_{benchmark_name}_{assay}"):
-                selected_assays.append(assay)
-    else:
-        selected_assays = []
-
-    # Bed track / dataset toggles (MCC only), based on species selection
-    selected_datasets: List[str] = []
-    if benchmark_name == "Genome Annotation":
-        st.sidebar.subheader("Genome annotations")
-        if selected_species:
-            df_for_tracks = df_bench[df_bench["species"].isin(selected_species)]
-        else:
-            df_for_tracks = df_bench
-        available_datasets = sorted(df_for_tracks["datasets"].unique())
-        for ds in available_datasets:
-            if sidebar_toggle(ds, value=True, key=f"dataset_{benchmark_name}_{ds}"):
-                selected_datasets.append(ds)
-    else:
-        selected_datasets = []
-
-    # Model toggles (we keep all models in MODEL_NAMES; filters + data will prune)
-    st.sidebar.subheader("Models")
-    selected_models: List[str] = []
-    for model in _ALL_MODELS:
-        if sidebar_toggle(model, value=True, key=f"model_{model}"):
-            selected_models.append(model)
-
-        # -------------------------
-    # ✅ Validation: require ≥1 selection per relevant category
-    # -------------------------
-    missing = []
-
-    # Always required
-    if not selected_species:
-        missing.append("Species")
-    if not selected_models:
-        missing.append("Models")
-
-    # Required depending on benchmark
-    if cfg.get("has_assay_type", False) and not selected_assays:
-        missing.append("Assay types")
-
-    if benchmark_name == "Genome Annotation" and not selected_datasets:
-        missing.append("Genome annotations")
-
-    if missing:
-        # Show a single message and prevent *any* further display
-        st.error(
-            "Please select at least one item in each category. Currently missing: "
-            + ", ".join(missing)
-            + "."
+    left, right = st.columns([1, 1], gap="large")
+    with left:
+        show_head_to_head(df, key="overview_track")
+    with right:
+        show_head_to_head(
+            df,
+            key="overview_species",
+            per_species=True,
+            title="#### ⚖️ Head-to-head (per species)",
         )
-        st.stop()
 
-    # --- Main content ---
-    leaderboard_df = build_leaderboard(
-        benchmark_name, selected_species, selected_assays, selected_models, selected_datasets
-    )
-    bar_df = build_bar_df(
-        benchmark_name, selected_species, selected_assays, selected_models, selected_datasets
+
+def species_page(species: str) -> None:
+    sub = _TRACKS[_TRACKS["species"] == species]
+    runs = _RUNS[(_RUNS["species"] == species) & _RUNS["Model"].isin(set(sub["Model"]))]
+    n_tracks = sub["datasets"].nunique()
+    common = SPECIES_COMMON_NAME.get(species)
+    st.title(f"{SPECIES_ICON[species]} {SPECIES_LABEL[species]}")
+    st.caption(
+        f"{SPECIES_CLADE[species]}{f' · {common}' if common else ''} · {n_tracks} tracks · "
+        f"{sub['Model'].nunique()} models, each evaluated on all {n_tracks} tracks."
     )
 
+    leaderboard = build_leaderboard(sub)
     col1, col2 = st.columns([1, 1])
-
     with col1:
         st.subheader("🏅 Leaderboard")
-        st.write("\n")  # spacer to match plotly padding
         st.write("\n")
         st.write("\n")
-        if leaderboard_df.empty:
-            st.info("No data for the selected filters.")
-        else:
-            st.dataframe(leaderboard_df, use_container_width=True)
-
+        st.write("\n")
+        st.dataframe(leaderboard, width="stretch")
     with col2:
         st.subheader("📈 Mean score per model")
-        if bar_df.empty:
-            st.info("No data for the selected filters.")
-        else:
-            # Order models by performance (least -> most)
-            bar_df = bar_df.sort_values("Mean score", ascending=True)
-            model_order = bar_df["Model"].tolist()
-
-            fig = px.bar(
-                bar_df,
-                x="Model",
-                y="Mean score",
-                color="Model",
-                color_discrete_map=MODEL_COLORS,
-                category_orders={"Model": model_order},
-            )
-            fig.update_layout(
-                barmode="group",
-                height=500,
-                xaxis_title="",
-                yaxis_title=cfg["metric_label"],
-                plot_bgcolor="rgba(0,0,0,0)",
-                paper_bgcolor="rgba(0,0,0,0)",
-                bargap=0.08,
-            )
-            fig.update_xaxes(showticklabels=False)
-            st.plotly_chart(fig, use_container_width=True)
-
-    # --- Breakdown plot: assay_type (Functional Tracks) OR datasets (Genome Annotation) ---
-    breakdown_df = build_category_model_df(
-        benchmark_name, selected_species, selected_assays, selected_models, selected_datasets
-    )
+        st.plotly_chart(plot_mean_bars(leaderboard), width="stretch")
 
-    type_of_data = "assay type" if benchmark_name == "Functional Tracks" else "gene annotation"
+    breakdown_df = build_category_model_df(sub)
+    if breakdown_df["Category"].nunique() > 1:
+        st.subheader("🧪 Mean score by assay type")
+        st.plotly_chart(plot_breakdown_facets_sorted_models(breakdown_df), width="stretch")
 
-    st.subheader(f"🧪 Mean score by {type_of_data}")
-    if breakdown_df.empty:
-        st.info("No data for the selected filters.")
-    else:
-        fig_breakdown = plot_breakdown_facets_sorted_models(
-            breakdown_df,
-            metric_label=cfg["metric_label"],
-            height=300,
-        )
-        st.plotly_chart(fig_breakdown, use_container_width=True)
-
-    # ------------------------------------------------------------------
-    # Model comparison: Head-to-head (left) + Convergence (right)
-    # ------------------------------------------------------------------
     left, right = st.columns([1, 1], gap="large")
-
     with left:
-        st.markdown("#### ⚖️ Head-to-head (per track)")
-
-        model_picker_options = selected_models if selected_models else _ALL_MODELS
-        default_a = model_picker_options[0] if model_picker_options else _ALL_MODELS[0]
-        default_b = model_picker_options[1] if len(model_picker_options) > 1 else (
-            _ALL_MODELS[1] if len(_ALL_MODELS) > 1 else default_a
-        )
-
-        cA, cB = st.columns([1, 1])
-        with cA:
-            model_a = st.selectbox(
-                "Model A (y-axis)",
-                options=model_picker_options,
-                index=model_picker_options.index(default_a) if default_a in model_picker_options else 0,
-                key=f"pair_model_a_{benchmark_name}",
-            )
-        with cB:
-            b_options = [m for m in model_picker_options if m != model_a] or model_picker_options
-            model_b = st.selectbox(
-                "Model B (x-axis)",
-                options=b_options,
-                index=0,
-                key=f"pair_model_b_{benchmark_name}",
-            )
-
-        scatter_df = build_pairwise_scatter_df(
-            benchmark_name,
-            selected_species,
-            selected_assays,
-            selected_models,
-            selected_datasets,
-            model_a,
-            model_b,
-        )
-
-        if scatter_df.empty:
-            st.info("No overlapping tracks for the selected filters (or one model is missing values).")
-        else:
-            min_v = float(min(scatter_df["Model A"].min(), scatter_df["Model B"].min()))
-            max_v = float(max(scatter_df["Model A"].max(), scatter_df["Model B"].max()))
-            pad = 0.05 * (max_v - min_v if max_v > min_v else 1.0)
-            axis_range = [min_v - pad, max_v + pad]
-            tick_step = (axis_range[1] - axis_range[0]) / 5
-            
-            hover_cols = ["datasets"]
-            if benchmark_name == "Functional Tracks" and "track_name_clean" in scatter_df.columns:
-                hover_cols.append("track_name_clean")
-            else:
-                hover_cols.append("datasets")
-
-            color_col = "assay_type" if "assay_type" in scatter_df.columns else "datasets"
-
-            fig_scatter = px.scatter(
-                scatter_df,
-                x="Model B",
-                y="Model A",
-                color=color_col,
-                color_discrete_map=ASSAY_COLORS,
-                hover_name="Track",
-                hover_data=hover_cols,
-            )
-
-            fig_scatter.add_shape(
-                type="line",
-                x0=axis_range[0], y0=axis_range[0],
-                x1=axis_range[1], y1=axis_range[1],
-                xref="x", yref="y",
-                line=dict(color="red", dash="dot", width=2),
-            )
-
-            fig_scatter.update_layout(
-                height=550,
-                margin=dict(l=60, r=20, t=20, b=60),
-                xaxis=dict(
-                    title=f"{model_b} — {cfg['metric_label']}",
-                    range=axis_range,
-                    dtick=tick_step,
-                    constrain="domain",
-                ),
-                yaxis=dict(
-                    title=f"{model_a} — {cfg['metric_label']}",
-                    range=axis_range,
-                    dtick=tick_step,
-                    scaleanchor="x",
-                    scaleratio=1,
-                    constrain="domain",
-                ),
-                plot_bgcolor="rgba(0,0,0,0)",
-                paper_bgcolor="rgba(0,0,0,0)",
-            )
-
-            fig_scatter.update_layout(
-                legend=dict(
-                    title="Assay type" if benchmark_name == "Functional Tracks" else "Genome Annotation",
-                    x=0.98,
-                    y=0.1,
-                    xanchor="right",
-                    yanchor="bottom",
-                    bgcolor="rgba(255,255,255,0.2)",  # semi-transparent white
-                    bordercolor="rgba(0,0,0,0.2)",
-                    borderwidth=1,
-                )
-            )
-
-            st.plotly_chart(fig_scatter, use_container_width=True)
-
+        show_head_to_head(sub, key=species)
     with right:
-        st.markdown("#### ⏱️ Time to convergence")
+        show_convergence(sub, runs, key=species)
 
-        x_mode = st.selectbox(
-            "X-axis",
-            options=["GPU (hours)", "Steps (billions)"],
-            index=0,
-            key=f"conv_x_mode_{benchmark_name}",
-        )
+    st.subheader("🎻 Performance across tracks")
+    st.plotly_chart(plot_violin(sub), width="stretch")
 
 
-        conv_df = build_convergence_df(
-            benchmark_name,
-            selected_species,
-            selected_assays,
-            selected_models,
-            selected_datasets,
-            x_mode=x_mode,
-        )
+def make_species_page(species: str) -> st.Page:
+    def render() -> None:
+        species_page(species)
 
-        if conv_df.empty:
-            st.info("No convergence data found for the selected filters / x-axis mode.")
-        else:
-            fig_conv = px.scatter(
-                conv_df,
-                x="X",
-                y="Performance",
-                text="Model",
-                color="Model",
-                color_discrete_map=MODEL_COLORS,
-                hover_data=["Model", "X", "Performance"],
-            )
-            fig_conv.update_layout(
-                height=550,
-                xaxis_title=("GPU (hours)" if x_mode == "GPU (hours)" else x_mode),
-                yaxis_title=cfg["metric_label"],
-                plot_bgcolor="rgba(0,0,0,0)",
-                paper_bgcolor="rgba(0,0,0,0)",
-                showlegend=False,  # ✅ no legend
-            )
-            fig_conv.update_traces(
-                marker=dict(size=14),          # 👈 bigger dots
-                textposition="top center",
-            )
-
-            # Log scale only makes sense for hours (and sometimes best_step)
-            if x_mode in ["GPU (hours)"]:
-                fig_conv.update_xaxes(
-                type="log",
-                dtick=1,
-                minor=dict(ticks="", showgrid=False),
-            )
-            st.plotly_chart(fig_conv, use_container_width=True)
-
-    # ------------------------------------------------------------------
-    # Violin (full width, below)
-    # ------------------------------------------------------------------
-    st.subheader("🎻 Performance comparison across tracks")
-
-    violin_df = build_violin_df(
-        benchmark_name,
-        selected_species,
-        selected_assays,
-        selected_models,
-        selected_datasets,
+    render.__name__ = f"page_{species.replace(' ', '_')}"
+    return st.Page(
+        render,
+        title=SPECIES_LABEL[species],
+        icon=SPECIES_ICON[species],
+        url_path=species.replace(" ", "-"),
     )
 
-    if violin_df.empty:
-        st.info("No data for the selected filters.")
-    else:
-        model_order = (
-            violin_df
-            .groupby("Model")["Score"]
-            .median()
-            .sort_values(ascending=True)
-            .index
-            .tolist()
-        )
-
-        fig_violin = px.violin(
-            violin_df,
-            x="Model",
-            y="Score",
-            color="Model",
-            color_discrete_map=MODEL_COLORS,
-            box=True,
-            points=False,
-            category_orders={"Model": model_order},
-        )
 
-        fig_violin.update_layout(
-            height=650,
-            xaxis_title="",
-            yaxis_title=cfg["metric_label"],
-            plot_bgcolor="rgba(0,0,0,0)",
-            paper_bgcolor="rgba(0,0,0,0)",
-            showlegend=False,
-        )
-
-        fig_violin.update_traces(
-            box_visible=True,
-            meanline_visible=False,
-        )
-
-        st.plotly_chart(fig_violin, use_container_width=True)
+# ---------------------------------------------------------------------
+# Streamlit UI
+# ---------------------------------------------------------------------
+def main():
+    st.markdown(SIDEBAR_CSS, unsafe_allow_html=True)
+    available = set(_TRACKS["species"])
+    sections = {
+        "": [st.Page(overview_page, title="Overview", icon="🌍", default=True)],
+    }
+    for clade, group in SPECIES_GROUPS.items():
+        pages = [make_species_page(s) for s in group if s in available]
+        if pages:
+            sections[clade] = pages
+    sections["Initial release (2025)"] = [
+        st.Page(initial_release.main, title="2025 leaderboard", icon="🗄️", url_path="initial-release")
+    ]
+    st.navigation(sections, position="sidebar").run()
 
 
 if __name__ == "__main__":