diff --git a/docs/credits.mdx b/docs/credits.mdx
index c634e90..92003fc 100644
--- a/docs/credits.mdx
+++ b/docs/credits.mdx
@@ -15,15 +15,12 @@ dependencies from the AgML project configuration.
 | opencv-python | >=4.10.0.84 |
 | opencv-python-headless | >=4.10.0.84 |
 | requests | >=2.0.0 |
-| scikit-learn | >=1.3.2 |
 | tqdm | >=4.67.0 |
 | pyyaml | >=6.0.2 |
 | albumentations | >=1.4.18 |
 | dict2xml | >=1.7.6 |
-| ipywidgets | >=8.1.5 |
 | rich | >=14.0.0 |
 | datasets | * |
-| transformers | * |
 
 ## Development dependencies
 
@@ -31,6 +28,7 @@ dependencies from the AgML project configuration.
 | --- | --- |
 | boto3 | >=1.35.66 |
 | scikit-image | >=0.21.0 |
+| scikit-learn | >=1.3.2 |
 | shapely | >=2.0.6 |
 | botocore | >=1.35.66 |
 | pandas | >=2.0.3 |
diff --git a/docs/development.mdx b/docs/development.mdx
index 1e345d7..7f09cdf 100644
--- a/docs/development.mdx
+++ b/docs/development.mdx
@@ -10,211 +10,216 @@ Thank you for choosing to contribute to AgML!
 ## Contributing Data
 
 If you've found (or already have) a new dataset and you want to contribute the dataset to AgML,
-then the instructions below will help you format and the data to the AgML standard.
+then the instructions below will help you format the data to the AgML standard and publish it
+through the Hugging Face Hub, which is how all new datasets are distributed.
 
 ### Dataset Formats
 
 Currently, we have image classification, object detection, and semantic segmentation datasets available
-in AgML. These sources are synthesized to standard annotation formats, namely the following:
+in AgML. Every dataset is published as a [Hugging Face `datasets`](https://huggingface.co/docs/datasets) repository
+under the `Project-AgML` organization, backed by Parquet, with a `dataset_info` config describing its columns and
+splits. The column layout depends on the task:
 
-- **Image Classification**: Image-To-Label-Number
-- **Object Detection**: [COCO JSON](https://cocodataset.org/#format-data)
-- **Semantic Segmentation**: Dense Pixel-Wise
+- **Image Classification**: an `image` column plus a `label` column of type `ClassLabel`.
+- **Object Detection**: an `image` column plus an `objects` column holding COCO-style bounding boxes and category IDs.
+- **Semantic Segmentation**: an `image` column plus a `mask` column (single-channel `L`-mode image).
+
+`HuggingFaceDataLoader` (in `agml/data/hf_loader.py`) relies on these names to verify that columns were cast correctly correctly upon loading, so new datasets must follow this schema
+for the loader to work.
 
 #### Image Classification
 
-Image classification datasets are organized in the following directory tree:
+Build a `datasets.Dataset` (or `DatasetDict`, if you have predefined splits) with two columns:
 
-```
-<dataset name>
-    ├── <label 1>
-    │   ├── image1.png
-    │   ├── image2.png
-    │   └── image3.png
-    └── <label 2>
-        ├── image1.png
-        ├── image2.png
-        └── image3.png
+- `image`: the image, as a Hugging Face `Image` feature.
+- `label`: a `ClassLabel` feature naming each class (e.g. `"Healthy Leaf"`, `"Bacterial Blight"`).
+
+```python
+from datasets import Dataset, Features, Image, ClassLabel
+
+features = Features({
+    "image": Image(),
+    "label": ClassLabel(names=["label_1", "label_2"]),
+})
+ds = Dataset.from_dict({"image": image_paths, "label": labels}, features=features)
 ```
 
-The `AgMLDataLoader` generates a mapping between each of the label names "label 1", "label 2", etc.,
-and a numerical value.
+`HuggingFaceDataLoader` reads the `ClassLabel` names as the mapping between each label and its numerical value —
+you don't need to build that mapping yourself.
 
 #### Object Detection
 
-Object detection datasets are constructed using COCO JSON formatting. For a general overview, see
-[https://cocodataset.org/#format-data](https://cocodataset.org/#format-data).
-Another good resource is [https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/cd-transform-coco.html](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/cd-transform-coco.html).
-Once you have the images and the bounding box annotations, this involves generating a dictionary with four keys:
-
-1. `images`: A list of dictionaries with the following items:
-    - The image file name (without the parent directory!) in `file_name`
-    - The ID (a unique number, usually from 1 to num_images) in `id`,
-    - The height/width of the image in `height` and `width`, respectively.
-2. `annotations`: A list of dictionaries with each dictionary representing a _unique_ bounding box (do not stack multiple bounding boxes into a single dictionary, even if they are for the same image!), and containing:
-    - The area of the bounding box in `area`.
-    - The bounding box itself in `bbox`. **Note**: The bounding box should have four coordinates. The first two are the x, y of the top-left corner of the bounding box, the other two are its height and width.
-    - The class label (numerical) of the image in `category_id`.
-    - The **ID** (NOT the filename) of the image it corresponds to in `image_id`.
-    - The ID of the bounding box in `id`. For instance, if a unique image has six corresponding bounding boxes, then each of them would be given an `id` from 1-6.
-    - `iscrowd` should be set to 0 by default, unless the dataset explicitly comes with `iscrowd` as 1.
-    - `ignore` should be 0 by default.
-    - `segmentation` only applies for instance segmentation datasets. If converting an instance segmentation dataset to object detection, you can leave the polygonal segmentation as is. Otherwise, put this as an empty list.
-3. `category`: A list of dictionaries with each category, where each of these dictionaries contains:
-    - The human-readable name of the class (e.g., "strawberry") in `name`.
-    - The supercategory of the class, if there are nested classes, in `supercategory`. Otherwise, just leave this as the string `"none"`.
-    - The numerical ID of the class in `id`.
-4. `info`: A single dictionary with metadata and information about the dataset:
-    - `description`: A basic description of the dataset.
-    - `url`: The URL from which the dataset was acquired.
-    - `version`: The dataset version. Set to `1.0` if unknown.
-    - `year`: The year in which the dataset was released.
-    - `contributor`: The author(s) of the dataset.
-    - `date_created`: The date when the dataset was published. Give an approximate year if unknown.
-
-The dictionary containing this information should be written to a file called `annotations.json`, and the file structure will be:
-
-```
-<dataset name>
-    ├── annotations.json
-    └── images
-        ├── image1.png
-        ├── image2.png
-        └── image3.png
+Store bounding boxes as an `objects` column: a dictionary (per row) with parallel arrays for the boxes and their
+category IDs, alongside an `image` column. For example:
+
+```python
+{
+    "image": <PIL.Image>,
+    "objects": {
+        "bbox": [[x_center, y_center, width, height], ...],
+        "category": [0, 0, 1, ...],
+    },
+}
 ```
 
-#### Semantic Segmentation
+The categories should map back to human-readable names — either via a `ClassLabel` feature on `objects.category`,
+or documented in the dataset card's `README.md`. If you're starting from a COCO-formatted `annotations.json`, use
+`datasets`' built-in COCO conversion utilities (or `imagefolder` with a `metadata.jsonl`) to build the `objects`
+column rather than uploading the raw COCO file directly.
 
-Semantic segmentation datasets are constructed using pixel-wise annotation masks. Each image in the dataset has a corresponding
-annotation mask. These masks have the following properties:
+#### Semantic Segmentation
 
-1. Two-dimensional, so no channel shape. Their complete shape will be `(image_height, image_width)`.
-2. Each of the pixels will be a numerical class label or `0` for background.
+Use an `image` column alongside a `mask` column, where the mask is a single-channel (`mode: L`) image of the same
+size as its corresponding image:
 
-The directory tree should look like follows:
+```python
+from datasets import Dataset, Features, Image
 
-```
-<dataset name>
-    ├── annotations
-    │   ├── mask1.png
-    │   ├── mask2.png
-    │   └── mask3.png
-    └── images
-        ├── image1.png
-        ├── image2.png
-        └── image3.png
+features = Features({
+    "image": Image(),
+    "mask": Image(),  # mode "L": each pixel is a numerical class label, or 0 for background
+})
+ds = Dataset.from_dict({"image": image_paths, "mask": mask_paths}, features=features)
 ```
 
-
 ## Contributing a Dataset
 
 If you've found a new dataset that *isn't already being used* in AgML and you want to add it, there's a few things you
-need to do.
-
-Any preprocessing code being used for the dataset can be kept in `agml/_internal/preprocess.py`, by adding an `elif` statement
-to the `preprocess()` method with the dataset name. If there is no preprocessing code, then just put a `pass` statement in the block.
+need to do. New datasets are hosted as their own repositories on the [Hugging Face Hub](https://huggingface.co/Project-AgML)
+under the `Project-AgML` organization, and loaded through `HuggingFaceDataLoader` rather than being bundled into AgML's
+own zip storage.
 
 ### Some Things to Check
 
 - Make sure each image is in the range of 0-255 in integers as opposed to 0-1 as floats. This will prevent any loss of data that
   could adversely affect training.
-- For a semantic segmentation dataset, put the masks in a `png` format as opposed to `jpg` or other.
+- For a semantic segmentation dataset, ensure the masks are in a `png` format as opposed to `jpg` or other.
 
-### Compiling the Dataset
-
-After processing and standardizing the dataset, make sure that the dataset is organized in one of the formats above, and then go to the parent directory
-of the directory of the dataset (for example, if the dataset is in `/root/my_new_dataset`, go to `/root`). Then run the following command:
-
-```shell
-zip -r my_new_dataset.zip my_new_dataset -x ".*"
-```
+### Structuring the Hugging Face Repository
 
-**If running on MacOS**, use the following command:
+Once the dataset is built into a `datasets.Dataset`/`DatasetDict` with the columns described above, push it to a new
+dataset repository on the Hub (for example,
+`Project-AgML/apple_flower_segmentation`) with `ds.push_to_hub("<org-name>/<dataset name>")`. This uploads the data
+as Parquet shards and writes the `dataset_info` config (features, splits, sizes) into the repository's `README.md`
+front matter automatically — you don't need to hand-write that config. Add to the generated `README.md`:
 
-```shell
-zip -r my_new_dataset.zip my_new_dataset -x ".*"  -x "__MACOSX"
-```
+- A description of the dataset, its original source, and its license. Hugging Face renders this on the dataset's page.
+- A `LICENSE` file, if the source dataset ships with one.
 
-### Updating the Source Files
+If the dataset has an augmented counterpart (e.g. extra synthetic samples), upload it as a separate config within the
+same repository rather than a separate repository, since `HuggingFaceDataLoader` selects configs by name:
 
-Next, you need to update the `public_datasources.json` and `source_citations.json` files. These two can be found
-in the `agml/_assets` folder. You will need to update the `public_datasources.json` file in the following way:
+```python
+ds.push_to_hub("Project-AgML/my_new_dataset", config_name="augmented")
 
-```json
-    "my_new_dataset": {
-        "classes": {
-            "1": "class_1",
-            "2": "class_2",
-            "3": "class_3"
-        },
-        "ml_task": "See the table for the different dataset types.",
-        "ag_task": "The agricultural task that is associated with the dataset.",
-        "location": {
-            "continent": "The continent the dataset was collected on.",
-            "country": "The country the dataset was collected in."
-        },
-        "sensor_modality": "Usually rgb, but can include other image modalities.",
-        "real_synthetic": "Are the images real or synthetically generated?",
-        "platform": "handheld or ground",
-        "input_data_format": "See the table for the different dataset types.",
-        "annotation_format": "See the table for the different dataset types.",
-        "n_images": "The total number of images in the dataset.",
-        "docs_url": "Where can the user find the most clear information about the dataset?"
-    }
+# ... which is later loaded with:
+loader = HuggingFaceDataLoader("Project-AgML/my_new_dataset", "augmented")
 ```
 
-**Note**: If the dataset is captured in multiple countries or you don't know where it is from,
-then put "worldwide" for both "continent" and "country".
-
-**Note**: If there is no explicit documentation for the dataset, then reach out to the AgML team
-regarding what you should put. It is important that we have references to as many datasets as possible,
-to allow users to acquire raw data as they desire.
-
-
-#### `ml_task` and `ag_task`
-
-The ML task can be quickly defined from the following table:
-
-| Dataset Format | `ml_task` | `annotation_format` |
-| :------------: | :-------: | :-----------------: |
-| Image Classification | `image_classification` | `directory_names` |
-| Object Detection | `object_detection` | `coco_json` |
-| Semantic Segmentation | `semantic_segmentation` | `image` |
+### Registering the Dataset
 
-
-The `ag_task` field is more broadly defined - it should be the main task that the dataset is associated with.
-For instance, any of the `*_leaf_disease_classification` datasets, alongside `bean_disease_uganda`, are all 
-associated with the `disease_classification` task. The `apple_segmentation_minnesota` dataset has the label
-`fruit_segmentation`. See `agml/_assets/public_datasources.json` for various examples of valid `ag_tasks`.
-Generally, you should keep this field broad enough that it encompasses the dataset (e.g., instead of a specific
-fruit, just put 'fruit' in general), but not as broad as the `ml_task`: it should have an agricultural component.
-
-The `source_citations.json` file should be updated this way:
+Once the dataset is live on the Hub, it needs to be registered in this website's catalog so it shows up in the
+dataset search and leaderboard pages. This repository (`project-agml.github.io`) stores that catalog as a JSON array
+at [`static/data/hf_datasets.json`](https://github.com/Project-AgML/project-agml.github.io/blob/main/static/data/hf_datasets.json).
+Add a new object to that array for your dataset:
 
 ```json
-    "my_new_dataset": {
-        "license": "The license being used by the dataset.",
-        "citation": "The paper/library to cite for the dataset."
-    }
+{
+    "name": "my_new_dataset",
+    "source": "huggingface",
+    "hf_link": "https://huggingface.co/datasets/Project-AgML/my_new_dataset",
+    "machine_learning_task": "object_detection",
+    "agricultural_task": "fruit_detection",
+    "location": ["United States"],
+    "environment": "field",
+    "crop_types": ["apple"],
+    "sensor_modality": "rgb",
+    "real_or_synthetic": "real",
+    "platform": "ground",
+    "input_data_format": "image_folder",
+    "annotation_format": "boundingBox",
+    "num_images": 1200,
+    "documentation": "my_new_dataset",
+    "examples_image_url": "/img/agml/sample_images/my_new_dataset_sample.webp",
+    "license": "cc-by-4.0",
+    "citation": null,
+    "parent_dataset": null,
+    "zip_size_bytes": 214000000,
+    "stats_mean": null,
+    "stats_std": null
+}
 ```
 
-If the dataset has no license or has no citation, leave the corresponding lines blank.
-
-### Uploading the Dataset
-
-Once you've readied the dataset, create a new pull request on the AgML repository.
-We will then review the changes and review next steps for adding the dataset into AgML's public data storage.
-
-
+The table below describes every field the catalog reads (see the `Dataset` type in
+[`src/lib/datasets.ts`](https://github.com/Project-AgML/project-agml.github.io/blob/main/src/lib/datasets.ts)).
+`name` is the only field that is strictly required for an entry to load at all, but the search, filter, and detail
+views depend on the rest — leave a field `null` rather than omitting it if the value is genuinely unknown.
+
+| Field | Required | Description |
+| :--- | :--- | :--- |
+| `name` | **Yes** | The dataset's identifier. Must match the Hugging Face repo name after `Project-AgML/`. |
+| `source` | **Yes** | Set to `"huggingface"` for datasets hosted on the Hub. |
+| `hf_link` | **Yes** | Full URL to the dataset's page on the Hugging Face Hub. |
+| `machine_learning_task` | **Yes** | One of `image_classification`, `object_detection`, `semantic_segmentation` (see table below). |
+| `agricultural_task` | Recommended | The agricultural task the dataset supports (e.g. `disease_classification`, `fruit_detection`). Keep it broad but agriculture-specific — see the guidance below. |
+| `location` | Recommended | Array of countries the data was collected in, e.g. `["Italy"]`. Use `["worldwide"]` if collected across many countries or unknown. |
+| `environment` | Recommended | `field`, `greenhouse`, `lab`, or similar. |
+| `crop_types` | Recommended | Array of crop names covered by the dataset, lowercase (e.g. `["grapes"]`). |
+| `sensor_modality` | Recommended | Usually `rgb`, but can include others such as `lidar`, `multispectral`. |
+| `real_or_synthetic` | Recommended | `real` or `synthetic`. |
+| `platform` | Recommended | How the images were captured, e.g. `handheld`, `ground`, `drone`. |
+| `input_data_format` | **Yes** | See the table below. |
+| `annotation_format` | **Yes** | See the table below. |
+| `num_images` | **Yes** | Total number of images in the dataset. Drives the "Labeled images" stat on the homepage. |
+| `documentation` | Recommended | A short doc slug/description, or a URL if the clearest documentation lives elsewhere. |
+| `examples_image_url` | Recommended | Path to a sample-image thumbnail under `static/img/agml/sample_images/`, used in dataset cards and the homepage marquee. |
+| `license` | **Yes** | The dataset's license identifier (e.g. `cc-by-4.0`). Leave `null` only if truly unlicensed. |
+| `citation` | Recommended | The paper or library to cite. `null` if none exists. |
+| `parent_dataset` | Only for variants | Set to the parent's `name` if this entry is an augmented/derived variant of another catalog entry. |
+| `zip_size_bytes` | Optional | Approximate size of the dataset, used for download-size display. |
+| `stats_mean` / `stats_std` | Optional | Per-channel normalization statistics, if precomputed. |
+| `augmented_num_images` / `augmented_zip_size_bytes` | Only for variants | Image count / size of the augmented counterpart, if applicable. |
+
+#### `machine_learning_task`, `input_data_format`, and `annotation_format`
+
+These three fields are coupled and should be taken from the same row:
+
+| Dataset Format | `machine_learning_task` | `input_data_format` | `annotation_format` | HF column |
+| :------------: | :----------------------: | :------------------: | :-----------------: | :-------: |
+| Image Classification | `image_classification` | `image_folder` | `classLabel` | `label` |
+| Object Detection | `object_detection` | `image_folder` | `boundingBox` | `objects` |
+| Semantic Segmentation | `semantic_segmentation` | `image_folder` | `segmentationMask` | `mask` |
+
+`input_data_format` is `image_folder` for all Hugging Face-hosted datasets — it refers to how the loader accesses the
+images (via the Hub, regardless of the underlying Parquet storage), not a literal local folder.
+
+#### `agricultural_task`
+
+This field is more broadly defined than `machine_learning_task` — it should describe the main agricultural task the
+dataset supports. For instance, any of the `*_leaf_disease_classification` datasets are associated with the
+`disease_classification` task, while a fruit-segmentation dataset would use `fruit_segmentation`. Browse
+`static/data/hf_datasets.json` for existing examples of valid `agricultural_task` values before inventing a new one.
+Keep it broad enough to describe the dataset in general (e.g. `fruit` rather than a specific cultivar), but not as
+broad as `machine_learning_task` — it should always carry an agricultural component.
+
+**Note**: If there is no explicit documentation for the dataset, then reach out to the AgML team regarding what you
+should put. It is important that we have references to as many datasets as possible, to allow users to acquire raw
+data as they desire.
+
+### Opening the Pull Request
+
+Once the dataset is uploaded to the Hub and its entry is added to `static/data/hf_datasets.json`, open a pull request
+against the `project-agml.github.io` repository with the JSON change (and the sample-image asset, if you added one).
+We'll review the entry and confirm the Hugging Face repository is publicly accessible before merging.
 
 ## Quality Checks
 
 When contributing a dataset, you should abide by the following guidelines to ensure compatibility with AgML and ensure that there are no problems for users who are working with the datasets:
 
-- Check that the dataset can be properly downloaded and loaded. It is best to instantiate an `AgMLDataLoader` and call `loader.show_sample()` in order to validate that the images and annotations are in the right format.
-- Make sure you have run `python3 scripts/generate_normalization_info.py --dataset <name>` and `python3 scripts/generate_shape_info.py --dataset <name>` to generate the dataset normalization and shape information.
-- Make sure that there is an entry in `agml/_internal/preprocess.py` for the dataset. Specifically, you should have a method in the class that makes up the file with the name of the method being the dataset, and the preprocessing code being that of the dataset.
-  
+- Check that the dataset can be properly downloaded and loaded. It is best to instantiate a `HuggingFaceDataLoader` for the dataset and inspect a few samples to validate that the images and annotations are in the right format.
+- Confirm the entry you added to `static/data/hf_datasets.json` is valid JSON and that `num_images`, `machine_learning_task`, `input_data_format`, and `annotation_format` all match the uploaded data.
+- Confirm the dataset appears correctly in the dataset search page (`/datasets`) after building the site locally, including its sample image and metadata modal.
+
 
 ## Development Guidelines
 
diff --git a/docs/index.mdx b/docs/index.mdx
index a167212..6065f8b 100644
--- a/docs/index.mdx
+++ b/docs/index.mdx
@@ -18,11 +18,7 @@ We're looking to hire a postdoc with both Python library development and ML expe
 
 ## Overview
 AgML is a comprehensive library for agricultural machine learning. Currently, AgML provides
-access to a wealth of public agricultural datasets for common agricultural deep learning tasks. In the future, AgML will provide ag-specific ML functionality related to data, training, and evaluation. Here's a conceptual diagram of the overall framework.
-
-<p align="center">
-    <img src="/img/agml/agml-framework.png" alt="AgML framework" width="350" height="291" />
-</p>
+access to a wealth of public agricultural datasets for common agricultural deep learning tasks. 
 
 AgML supports both the [TensorFlow](https://www.tensorflow.org/) and [PyTorch](https://pytorch.org/) machine learning frameworks.
 
@@ -41,118 +37,58 @@ necessary prerequisites and update WSL. The latest version of WSL includes built
 
 ## Quick Start
 
-AgML is designed for easy usage of agricultural data in a variety of formats. You can start off by using the `AgMLDataLoader` to
-download and load a dataset into a container:
+AgML datasets are hosted on the [Hugging Face Hub](https://huggingface.co/Project-AgML) under the `Project-AgML`
+organization. You can start off by using the `HuggingFaceDataLoader` to download and load a dataset directly into a
+native Hugging Face `DatasetDict`:
 
 ```python
-import agml
-
-loader = agml.data.AgMLDataLoader('apple_flower_segmentation')
-```
-
-You can then use the in-built processing methods to get the loader ready for your training and evaluation pipelines. This includes, but
-is not limited to, batching data, shuffling data, splitting data into training, validation, and test sets, and applying transforms.
-
-```python
-import albumentations as A
-
-# Batch the dataset into collections of 8 pieces of data:
-loader.batch(8)
-
-# Shuffle the data:
-loader.shuffle()
+from agml.data import HuggingFaceDataLoader
 
-# Apply transforms to the input images and output annotation masks:
-loader.mask_to_channel_basis()
-loader.transform(
-        transform = A.RandomContrast(),
-        dual_transform = A.Compose([A.RandomRotate90()])
-)
+# Load a dataset from the Hub
+loader = HuggingFaceDataLoader("Project-AgML/apple_flower_segmentation")
 
-# Split the data into train/val/test sets.
-loader.split(train = 0.8, val = 0.1, test = 0.1)
+# Load a specific config/subset (e.g. an augmented variant)
+loader = HuggingFaceDataLoader("Project-AgML/apple_flower_segmentation", config="augmented")
 ```
 
-The split datasets can be accessed using `loader.train_data`, `loader.val_data`, and `loader.test_data`. Any further processing applied to the
-main loader will be applied to the split datasets, until the split attributes are accessed, at which point you need to apply processing independently
-to each of the loaders. You can also turn toggle processing on and off using the `loader.eval()`, `loader.reset_preprocessing()`, and `loader.disable_preprocessing()`
-methods.
-
-You can visualize data using the `agml.viz` module, which supports multiple different types of visualization for different data types:
-
-```python
-# Disable processing and batching for the test data:
-test_ds = loader.test_data
-test_ds.batch(None)
-test_ds.reset_prepreprocessing()
-
-# Visualize the image and mask side-by-side:
-agml.viz.visualize_image_and_mask(test_ds[0])
-
-# Visualize the mask overlaid onto the image:
-agml.viz.visualize_overlaid_masks(test_ds[0])
-```
+`HuggingFaceDataLoader` automatically casts image-like columns (`image`, `mask`, and image-typed `label` columns) to
+the Hugging Face `Image` type for decoded pixel access.
 
-AgML supports both the TensorFlow and PyTorch libraries as backends, and provides functionality to export your loaders to native TensorFlow and PyTorch
-formats when you want to use them in a training pipeline. This includes both exporting the `AgMLDataLoader` to a `tf.data.Dataset` or `torch.utils.data.DataLoader`,
-but also internally converting data within the `AgMLDataLoader` itself, enabling access to its core functionality.
+You can split the dataset into train/val/test sets, with optional stratification across one or more columns:
 
 ```python
-# Export the loader as a `tf.data.Dataset`:
-train_ds = loader.train_data.export_tensorflow()
+dataset = loader.split(val_size=0.1, test_size=0.1, stratify_cols="label")
+# Returns a DatasetDict with 'train', 'val', and 'test' splits
 
-# Convert to PyTorch tensors without exporting.
-train_ds = loader.train_data
-train_ds.as_torch_dataset()
+# Access the underlying DatasetDict at any time
+dataset = loader.dataset
 ```
 
-You're now ready to use AgML for training your own models! Luckily, AgML comes with a training module that enables quick-start training of standard deep learning models on agricultural datasets. Training a grape detection model is as simple as the following code:
-
-:::warning Deprecation Notice
-`agml.models` is deprecated and will be removed in a future release. The example below still works but will emit a `DeprecationWarning` at import time.
-:::
+**For any preprocessing, inference, or training beyond loading and splitting, use the
+[`datasets`](https://huggingface.co/docs/datasets) and [`transformers`](https://huggingface.co/docs/transformers)
+libraries directly.** Since `loader.dataset` is a native Hugging Face `DatasetDict`, it works out of the box with
+`datasets`' `map`, `filter`, and `with_transform` methods for preprocessing, and with `transformers`' `Trainer`,
+`Pipeline`, and model classes for training and inference — there's no separate AgML-specific processing API to learn.
 
 ```python
-import agml
-import agml.models
+from transformers import AutoImageProcessor, AutoModelForImageClassification, Trainer
 
-import albumentations as A
-
-loader = agml.data.AgMLDataLoader('grape_detection_californiaday')
-loader.split(train = 0.8, val = 0.1, test = 0.1)
-processor = agml.models.preprocessing.EfficientDetPreprocessor(
-        image_size = 512, augmentation = [A.HorizontalFlip(p=0.5)]
+processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")
+model = AutoModelForImageClassification.from_pretrained(
+    "google/vit-base-patch16-224",
+    num_labels=dataset["train"].features["label"].num_classes,
 )
-loader.transform(processor)
-
-model = agml.models.DetectionModel(num_classes=loader.num_classes)
-
-model.run_training(loader)
-```
-
-## HuggingFace Integration
-
-AgML now includes a `HuggingFaceDataLoader` for loading datasets directly from the [Hugging Face Hub](https://huggingface.co/datasets) into native HuggingFace `DatasetDict` objects, compatible with `transformers` and `diffusers` pipelines.
-
-```python
-from agml.data import HuggingFaceDataLoader
 
-# Load a dataset from the Hub
-loader = HuggingFaceDataLoader("org/dataset-name")
+def preprocess(batch):
+    batch["pixel_values"] = processor(batch["image"], return_tensors="pt")["pixel_values"]
+    return batch
 
-# Load a specific config/subset
-loader = HuggingFaceDataLoader("org/dataset-name", config="augmented")
-
-# Split into train/val/test with optional stratification
-dataset = loader.split(val_size=0.1, test_size=0.1, stratify_cols="label")
-# Returns a DatasetDict with 'train', 'val', and 'test' splits
+dataset = dataset.with_transform(preprocess)
 
-# Access the underlying DatasetDict at any time
-dataset = loader.dataset
+trainer = Trainer(model=model, train_dataset=dataset["train"], eval_dataset=dataset["val"])
+trainer.train()
 ```
 
-The `HuggingFaceDataLoader` automatically casts image-like columns to the HuggingFace `Image` type for decoded pixel access. Stratified splitting is supported across one or more columns using a composite key.
-
 ## Public Datasets
 
 AgML contains a wide variety of public datasets from various locations across the world:
@@ -184,17 +120,15 @@ the dataset locally from which point it will be automatically loaded from the di
 From this point, the data within the loader can be split into train/val/test sets, batched, have augmentations and transforms
 applied, and be converted into a training-ready dataset (including batching, tensor conversion, and image formatting).
 
-To see the various ways in which you can use AgML datasets in your training pipelines, check out
-the [example notebook](https://github.com/Project-AgML/AgML/blob/main/examples/AgML-Data.ipynb).
-
 ## Annotation Formats
 
 A core aim of AgML is to provide datasets in a standardized format, enabling the synthesizing of multiple datasets
-into a single training pipeline. To this end, we provide annotations in the following formats:
+into a single training pipeline. Datasets on the Hugging Face Hub encode annotations as columns on the underlying
+`Dataset`/`DatasetDict`:
 
-- **Image Classification**: Image-To-Label-Number
-- **Object Detection**: [COCO JSON](https://cocodataset.org/#format-data)
-- **Semantic Segmentation**: Dense Pixel-Wise
+- **Image Classification**: a `label` column of type `ClassLabel`.
+- **Object Detection**: an `objects` column, holding COCO-style bounding boxes (un-normlized [x_min, y_min, width, height]) and corresponding category IDs as a ClassLabel per image.
+- **Semantic Segmentation**: a `mask` column, a single-channel (`L`-mode) image the same size as the corresponding image.
 
 ## Contributions
 
diff --git a/docusaurus.config.ts b/docusaurus.config.ts
index a6bafd9..d6e3b48 100644
--- a/docusaurus.config.ts
+++ b/docusaurus.config.ts
@@ -61,10 +61,6 @@ const config: Config = {
     },
     navbar: {
       title: 'AgML',
-      logo: {
-        alt: 'AgML Logo',
-        src: 'img/agml/agml-logo-wide.png',
-      },
       items: [
         {
           type: 'docSidebar',
@@ -72,55 +68,16 @@ const config: Config = {
           position: 'left',
           label: 'Docs',
         },
-        {to: '/datasets', label: 'Dataset Search', position: 'left'},
+        {to: '/datasets', label: 'Datasets', position: 'left'},
+        {to: '/leaderboard', label: 'Leaderboard', position: 'left'},
         {
           href: 'https://github.com/Project-AgML/AgML',
-          label: 'GitHub',
+          label: 'View on GitHub',
           position: 'right',
+          className: 'navbar__github-button',
         },
       ],
     },
-    footer: {
-      style: 'dark',
-      links: [
-        {
-          title: 'Docs',
-          items: [
-            {
-              label: 'Overview',
-              to: '/docs',
-            },
-          ],
-        },
-        {
-          title: 'Explore',
-          items: [
-            {
-              label: 'Dataset Search',
-              to: '/datasets',
-            },
-            {
-              label: 'AgML Library',
-              href: 'https://github.com/Project-AgML/AgML',
-            },
-          ],
-        },
-        {
-          title: 'Project',
-          items: [
-            {
-              label: 'Code of Conduct',
-              to: '/docs/code-of-conduct',
-            },
-            {
-              label: 'License',
-              to: '/docs/license',
-            },
-          ],
-        },
-      ],
-      copyright: `Copyright © ${new Date().getFullYear()} AgML. Built with Docusaurus.`,
-    },
     prism: {
       theme: prismThemes.github,
       darkTheme: prismThemes.dracula,
diff --git a/scripts/generate-datasets.mjs b/scripts/generate-datasets.mjs
index 083022f..9e41ef2 100644
--- a/scripts/generate-datasets.mjs
+++ b/scripts/generate-datasets.mjs
@@ -7,6 +7,10 @@ const projectRoot = path.resolve(__dirname, '..');
 const staticDataDir = path.join(projectRoot, 'static', 'data');
 const datasetsPath = path.join(staticDataDir, 'datasets.json');
 const hfDatasetsPath = path.join(staticDataDir, 'hf_datasets.json');
+const performanceDir = path.join(staticDataDir, 'performance');
+const performanceIndexPath = path.join(performanceDir, 'index.json');
+const performanceGlobalPath = path.join(performanceDir, 'global.json');
+const PERFORMANCE_MANIFEST_FILES = new Set(['index.json', 'global.json']);
 
 function readJson(filePath) {
   if (!fs.existsSync(filePath)) return null;
@@ -31,6 +35,234 @@ function writeJson(filePath, value) {
   fs.writeFileSync(filePath, JSON.stringify(value, null, 2), 'utf8');
 }
 
+function buildDatasetMetadataLookup(...manifests) {
+  const lookup = new Map();
+  for (const manifest of manifests) {
+    for (const entry of manifest ?? []) {
+      const name = typeof entry?.name === 'string' ? entry.name : null;
+      if (!name || lookup.has(name)) continue;
+      const cropTypes = Array.isArray(entry.crop_types)
+        ? entry.crop_types.filter((c) => typeof c === 'string' && c.trim()).map((c) => c.toLowerCase())
+        : null;
+      const mlTask = typeof entry.machine_learning_task === 'string' && entry.machine_learning_task.trim()
+        ? entry.machine_learning_task
+        : null;
+      lookup.set(name, { crop_types: cropTypes?.length ? cropTypes : null, machine_learning_task: mlTask });
+    }
+  }
+  return lookup;
+}
+
+// Raw benchmark run records (see static/data/performance/<dataset>.json) are converted into
+// leaderboard rows here. This logic is mirrored in src/lib/performance.ts for client-side
+// rendering of the same files — keep the two in sync if the run schema changes.
+const TASK_METRIC_KEYS = {
+  classification: ['f1', 'accuracy', 'top1_accuracy'],
+  detection: ['map', 'map_50', 'map50', 'mAP', 'mAP@0.5'],
+  segmentation: ['miou', 'iou', 'mean_iou'],
+};
+
+function isFiniteNumber(value) {
+  return typeof value === 'number' && Number.isFinite(value);
+}
+
+function resolveMetricKey(task, metrics) {
+  const candidates = TASK_METRIC_KEYS[task] ?? [];
+  for (const key of candidates) {
+    if (isFiniteNumber(metrics[key])) return key;
+  }
+  return Object.keys(metrics).find((key) => isFiniteNumber(metrics[key])) ?? null;
+}
+
+// Every run can report several metric families at once (F1, mAP, precision, recall),
+// independent of the single metric resolveMetricKey picks for the legacy per-dataset rank.
+// These four category scores back the leaderboard's four sortable global columns — precision
+// and recall are ranked/percentiled independently, not averaged into one blended score.
+function isMapMetricKey(key) {
+  return /^m?ap([_@-]|$)/i.test(key);
+}
+
+function computeCategoryScores(metrics) {
+  const f1 = isFiniteNumber(metrics.f1) ? metrics.f1 : null;
+  let map = null;
+  for (const [key, value] of Object.entries(metrics)) {
+    if (isMapMetricKey(key) && isFiniteNumber(value)) {
+      map = map == null ? value : Math.max(map, value);
+    }
+  }
+  const precision = isFiniteNumber(metrics.precision) ? metrics.precision : null;
+  const recall = isFiniteNumber(metrics.recall) ? metrics.recall : null;
+  return { f1, map, precision, recall };
+}
+
+function buildRunNote(entry) {
+  const parts = [];
+  if (isFiniteNumber(entry.num_samples)) parts.push(`${entry.num_samples} samples`);
+  if (typeof entry.device === 'string' && entry.device.trim()) parts.push(entry.device.trim());
+  return parts.length ? parts.join(' · ') : null;
+}
+
+function buildFinetuneNote(finetune) {
+  if (!finetune || typeof finetune !== 'object') return null;
+  const parts = [];
+  if (isFiniteNumber(finetune.epochs)) parts.push(`${finetune.epochs} epochs`);
+  if (isFiniteNumber(finetune.train_samples)) parts.push(`${finetune.train_samples} train samples`);
+  return parts.length ? parts.join(' · ') : null;
+}
+
+// Rendered as train/test/val percentages in that fixed order, e.g. "10/80/10" — mirrors
+// buildSplitBreakdown in src/lib/performance.ts, kept in sync for the same reason as above.
+function buildSplitBreakdown(entry, finetune) {
+  const testSamples = isFiniteNumber(entry.num_samples) ? entry.num_samples : null;
+  const trainSamples = finetune != null && typeof finetune === 'object' && isFiniteNumber(finetune.train_samples) ? finetune.train_samples : null;
+  const valSamples = finetune != null && typeof finetune === 'object' && isFiniteNumber(finetune.val_samples) ? finetune.val_samples : null;
+  const total = (trainSamples ?? 0) + (testSamples ?? 0) + (valSamples ?? 0);
+  if (!total) return null;
+  const toShare = (value) => (value != null ? ((value / total) * 100).toFixed(0) : '-');
+  return `${toShare(trainSamples)}/${toShare(testSamples)}/${toShare(valSamples)}`;
+}
+
+// The result set encodes optimized as the string "yes" / "no" (not a boolean) — a finetune
+// object's own optimized field, if present, may already be boolean, so both forms are accepted.
+function isOptimized(value) {
+  if (typeof value === 'string') return value.trim().toLowerCase() === 'yes';
+  return Boolean(value);
+}
+
+function makeLeaderboardRow(entry, metricKey, variant) {
+  const finetune = entry.finetune;
+  return {
+    model: entry.model.trim(),
+    score: entry.metrics[metricKey],
+    categoryScores: computeCategoryScores(entry.metrics),
+    variant,
+    date: typeof entry.timestamp === 'string' ? entry.timestamp.slice(0, 10) : null,
+    submitted_by: null,
+    link: null,
+    notes: variant === 'fine-tuned' ? buildFinetuneNote(finetune) : buildRunNote(entry),
+    optimized: isOptimized(entry.optimized) || (finetune != null && typeof finetune === 'object' && isOptimized(finetune.optimized)),
+    platform: typeof entry.device === 'string' && entry.device.trim() ? entry.device.trim() : null,
+    splitBreakdown: buildSplitBreakdown(entry, finetune),
+    // dataset_config is the result set's own config field (raw / augmented) — no fallback to
+    // `split`, which is a different concept (the run's data split, e.g. "train"). Absent config
+    // means the run used the dataset's raw (unaugmented) form.
+    datasetConfig: typeof entry.dataset_config === 'string' && entry.dataset_config.trim() ? entry.dataset_config.trim() : 'raw',
+  };
+}
+
+// A model can appear multiple times per dataset (repeated runs, or a fine-tuned run alongside
+// a zero-shot one). The leaderboard shows the best zero-shot result and the best fine-tuned
+// result per model, side by side, rather than collapsing to a single row.
+function buildLeaderboardFromRawResults(rawResults) {
+  const scored = [];
+  for (const entry of rawResults) {
+    if (!entry || typeof entry !== 'object') continue;
+    if (typeof entry.model !== 'string' || !entry.model.trim()) continue;
+    if (!entry.metrics || typeof entry.metrics !== 'object') continue;
+    const metricKey = resolveMetricKey(entry.task, entry.metrics);
+    if (!metricKey || !isFiniteNumber(entry.metrics[metricKey])) continue;
+    scored.push({
+      entry,
+      metricKey,
+      score: entry.metrics[metricKey],
+      isFinetune: entry.finetune != null && typeof entry.finetune === 'object',
+    });
+  }
+
+  const byModel = new Map();
+  for (const item of scored) {
+    const model = item.entry.model.trim();
+    const group = byModel.get(model) ?? { zeroShot: null, fineTuned: null };
+    const slot = item.isFinetune ? 'fineTuned' : 'zeroShot';
+    if (!group[slot] || item.score > group[slot].score) group[slot] = item;
+    byModel.set(model, group);
+  }
+
+  const rows = [];
+  for (const group of byModel.values()) {
+    if (group.zeroShot) rows.push(makeLeaderboardRow(group.zeroShot.entry, group.zeroShot.metricKey, 'zero-shot'));
+    if (group.fineTuned) rows.push(makeLeaderboardRow(group.fineTuned.entry, group.fineTuned.metricKey, 'fine-tuned'));
+  }
+
+  rows.sort((a, b) => (b.score ?? -Infinity) - (a.score ?? -Infinity));
+  rows.forEach((row, index) => {
+    row.rank = index + 1;
+  });
+
+  return { metric: scored.length ? scored[0].metricKey : null, leaderboard: rows };
+}
+
+function sortLeaderboardEntries(entries) {
+  return [...entries].sort((a, b) => {
+    const rankA = typeof a.rank === 'number' ? a.rank : null;
+    const rankB = typeof b.rank === 'number' ? b.rank : null;
+    if (rankA != null && rankB != null) return rankA - rankB;
+    const scoreA = typeof a.score === 'number' ? a.score : null;
+    const scoreB = typeof b.score === 'number' ? b.score : null;
+    if (scoreA != null && scoreB != null) return scoreB - scoreA;
+    return 0;
+  });
+}
+
+const CATEGORY_KEYS = ['f1', 'map', 'precision', 'recall'];
+
+// Ranks entries by a single category's score, independently of the other categories and of
+// the legacy single-metric rank — an entry that doesn't report this category gets a null
+// percentile for it rather than being penalized or excluded from the others.
+function computeCategoryPercentiles(entries, categoryKey) {
+  const withScore = entries
+    .map((entry, index) => ({ index, score: entry.categoryScores?.[categoryKey] }))
+    .filter((item) => isFiniteNumber(item.score))
+    .sort((a, b) => b.score - a.score);
+  const total = withScore.length;
+  const percentileByIndex = new Map();
+  withScore.forEach((item, rankIndex) => {
+    const rank = rankIndex + 1;
+    percentileByIndex.set(item.index, total > 1 ? ((total - rank) / (total - 1)) * 100 : 100);
+  });
+  return percentileByIndex;
+}
+
+function buildGlobalPerformanceRecords(performanceDatasets, metadataLookup) {
+  const records = [];
+  for (const datasetName of performanceDatasets) {
+    const raw = readJson(path.join(performanceDir, `${datasetName}.json`));
+    const leaderboard = Array.isArray(raw)
+      ? buildLeaderboardFromRawResults(raw).leaderboard
+      : Array.isArray(raw?.leaderboard)
+        ? raw.leaderboard
+        : [];
+    const entries = sortLeaderboardEntries(leaderboard.filter((entry) => typeof entry?.model === 'string' && entry.model.trim()));
+    const total = entries.length;
+    if (total === 0) continue;
+
+    const percentilesByCategory = Object.fromEntries(
+      CATEGORY_KEYS.map((key) => [key, computeCategoryPercentiles(entries, key)])
+    );
+
+    const meta = metadataLookup.get(datasetName) ?? { crop_types: null, machine_learning_task: null };
+    entries.forEach((entry, index) => {
+      const percentiles = Object.fromEntries(
+        CATEGORY_KEYS.map((key) => [key, percentilesByCategory[key].get(index) ?? null])
+      );
+      records.push({
+        model: entry.model.trim(),
+        dataset: datasetName,
+        percentiles,
+        scores: entry.categoryScores,
+        crop_types: meta.crop_types,
+        machine_learning_task: meta.machine_learning_task,
+        variant: entry.variant === 'zero-shot' || entry.variant === 'fine-tuned' ? entry.variant : null,
+        optimized: Boolean(entry.optimized),
+        platform: typeof entry.platform === 'string' && entry.platform.trim() ? entry.platform.trim() : null,
+        splitBreakdown: entry.splitBreakdown ?? null,
+        datasetConfig: entry.datasetConfig ?? null,
+      });
+    });
+  }
+  return records;
+}
+
 async function generateDatasets() {
   const datasets = normalizeManifest(readJson(datasetsPath));
   const hfDatasetsRaw = readJson(hfDatasetsPath);
@@ -45,6 +277,21 @@ async function generateDatasets() {
     writeJson(hfDatasetsPath, hfDatasets);
     console.log('Wrote', hfDatasetsPath);
   }
+
+  const performanceDatasets = fs.existsSync(performanceDir)
+    ? fs
+        .readdirSync(performanceDir)
+        .filter((file) => file.endsWith('.json') && !PERFORMANCE_MANIFEST_FILES.has(file))
+        .map((file) => file.slice(0, -'.json'.length))
+        .sort()
+    : [];
+  writeJson(performanceIndexPath, performanceDatasets);
+  console.log('Wrote', performanceIndexPath, '—', performanceDatasets.length, 'performance datasets');
+
+  const metadataLookup = buildDatasetMetadataLookup(datasets, hfDatasets);
+  const globalPerformance = buildGlobalPerformanceRecords(performanceDatasets, metadataLookup);
+  writeJson(performanceGlobalPath, globalPerformance);
+  console.log('Wrote', performanceGlobalPath, '—', globalPerformance.length, 'performance records');
 }
 
 generateDatasets().catch((err) => {
diff --git a/sidebars.ts b/sidebars.ts
index a4caefd..aadad3e 100644
--- a/sidebars.ts
+++ b/sidebars.ts
@@ -14,11 +14,20 @@ import type {SidebarsConfig} from '@docusaurus/plugin-content-docs';
  */
 const sidebars: SidebarsConfig = {
   agmlSidebar: [
-    'index',
-    'development',
-    'credits',
-    'code-of-conduct',
-    'license',
+    {
+      type: 'category',
+      label: 'Guide',
+      collapsible: false,
+      className: 'sidebarCategoryLabel',
+      items: ['index', 'development'],
+    },
+    {
+      type: 'category',
+      label: 'Project',
+      collapsible: false,
+      className: 'sidebarCategoryLabel',
+      items: ['credits', 'code-of-conduct', 'license'],
+    },
   ],
 };
 
diff --git a/src/components/DatasetMetadataModal.module.css b/src/components/DatasetMetadataModal.module.css
index dc1ff3e..e4686c1 100644
--- a/src/components/DatasetMetadataModal.module.css
+++ b/src/components/DatasetMetadataModal.module.css
@@ -5,20 +5,20 @@
 	display: grid;
 	place-items: center;
 	padding: 1.25rem;
-	background: rgba(10, 16, 12, 0.58);
+	background: var(--agml-modal-overlay);
 	backdrop-filter: blur(10px);
 }
 
 .modal {
-	width: min(780px, 100%);
+	width: min(1140px, 95vw);
 	max-height: min(88vh, 920px);
 	overflow: auto;
-	border-radius: 28px;
-	border: 1px solid var(--agml-border);
-	background: var(--agml-surface);
-	box-shadow: 0 35px 80px rgba(10, 16, 12, 0.35);
+	border-radius: 12px;
+	border: 1px solid var(--agml-border-strong);
+	background: var(--agml-surface-strong);
+	box-shadow: var(--agml-shadow-strong);
 	color: var(--agml-text);
-	padding: 1.4rem 1.4rem 1.2rem;
+	padding: 2rem;
 }
 
 .header {
@@ -26,93 +26,126 @@
 	align-items: flex-start;
 	justify-content: space-between;
 	gap: 1rem;
-	padding-bottom: 1rem;
-	border-bottom: 1px solid var(--agml-border);
-}
-
-.kicker {
-	margin: 0 0 0.35rem;
-	font-size: 0.72rem;
-	letter-spacing: 0.16em;
-	text-transform: uppercase;
-	color: var(--agml-muted);
+	margin-bottom: 1.1rem;
 }
 
 .title {
-	margin: 0;
-	font-size: clamp(1.4rem, 2vw, 2rem);
-	line-height: 1.15;
+	font-family: var(--ifm-code-font-family);
+	font-weight: 700;
+	font-size: 1.25rem;
+	margin: 0 0 0.5rem;
+	line-height: 1.2;
 	overflow-wrap: anywhere;
 }
 
+.headerBadges {
+	display: flex;
+	flex-wrap: wrap;
+	gap: 0.4rem;
+}
+
+.taskBadge {
+	font-family: var(--ifm-code-font-family);
+	font-size: 0.65rem;
+	padding: 0.15rem 0.5rem;
+	border-radius: 4px;
+	display: inline-block;
+	white-space: nowrap;
+}
+
+.badgeClassification {
+	background: var(--agml-badge-classification-bg);
+	color: var(--agml-badge-classification-fg);
+}
+
+.badgeDetection {
+	background: var(--agml-badge-detection-bg);
+	color: var(--agml-badge-detection-fg);
+}
+
+.badgeSegmentation {
+	background: var(--agml-badge-segmentation-bg);
+	color: var(--agml-badge-segmentation-fg);
+}
+
+.badgeOther {
+	background: var(--agml-badge-other-bg);
+	color: var(--agml-badge-other-fg);
+}
+
+.tag {
+	font-family: var(--ifm-code-font-family);
+	font-size: 0.68rem;
+	padding: 0.2rem 0.55rem;
+	border-radius: 4px;
+	display: inline-block;
+	white-space: nowrap;
+	background: var(--agml-tag-bg);
+	color: var(--agml-tag-fg);
+}
+
 .closeButton {
 	flex: 0 0 auto;
+	width: 30px;
+	height: 30px;
+	display: flex;
+	align-items: center;
+	justify-content: center;
 	border: 1px solid var(--agml-border-strong);
-	border-radius: 999px;
-	background: var(--agml-surface-strong);
+	border-radius: 6px;
+	background: var(--agml-surface-soft);
 	color: var(--agml-text);
-	padding: 0.55rem 0.9rem;
+	padding: 0;
+	font-size: 15px;
+	line-height: 1;
 	cursor: pointer;
 }
 
 .closeButton:hover,
 .closeButton:focus-visible {
-	border-color: var(--ifm-color-primary);
+	background: var(--agml-border);
 	outline: none;
 }
 
 .detailGrid {
 	display: grid;
-	grid-template-columns: repeat(auto-fit, minmax(190px, 1fr));
-	gap: 0.9rem;
-	margin: 1rem 0 0;
+	gap: 0.85rem;
+	margin: 1.25rem 0 1.75rem;
 }
 
 .detailItem {
-	padding: 0.85rem 0.9rem;
-	border-radius: 18px;
-	border: 1px solid var(--agml-border);
-	background: var(--agml-surface-strong);
+	min-width: 0;
 }
 
 .detailLabel {
-	margin: 0 0 0.35rem;
-	font-size: 0.68rem;
-	font-weight: 600;
+	margin: 0 0 0.3rem;
+	font-family: var(--ifm-code-font-family);
+	font-size: 0.62rem;
+	letter-spacing: 0.05em;
 	text-transform: uppercase;
-	letter-spacing: 0.14em;
 	color: var(--agml-muted);
 }
 
 .detailValue {
 	margin: 0;
-	font-size: 0.95rem;
+	font-size: 0.82rem;
 	line-height: 1.4;
 	color: var(--agml-text);
-	font-weight: 600;
 	overflow-wrap: anywhere;
 }
 
-.secondaryGrid {
-	display: grid;
-	grid-template-columns: 1.2fr 0.8fr;
-	gap: 1rem;
-	margin-top: 1rem;
-}
-
-.secondarySection {
-	padding: 1rem;
-	border-radius: 20px;
-	border: 1px solid var(--agml-border);
-	background: var(--agml-surface-strong);
+.section {
+	margin-bottom: 1.75rem;
 }
 
 .sectionTitle {
-	margin: 0 0 0.65rem;
-	font-size: 0.82rem;
+	font-family: var(--ifm-code-font-family);
+	font-size: 0.68rem;
+	font-weight: 600;
 	text-transform: uppercase;
-	letter-spacing: 0.14em;
+	letter-spacing: 0.05em;
 	color: var(--agml-muted);
+	margin: 0 0 0.65rem;
 }
 
 .bodyText {
@@ -126,32 +159,33 @@
 	margin-top: 0.5rem;
 }
 
-.codeBlock {
-	margin: 0.85rem 0 0;
-	padding: 0.9rem 1rem;
-	border-radius: 16px;
-	border: 1px solid var(--agml-border);
-	background: var(--agml-surface);
-	color: var(--agml-text);
-	overflow: auto;
-	font-family: var(--ifm-code-font-family);
-	font-size: 0.85rem;
-	line-height: 1.5;
-	white-space: pre-wrap;
-	word-break: break-word;
-}
-
 .inlineLabel {
 	color: var(--agml-muted);
 	font-weight: 600;
 }
 
-.footer {
-	display: grid;
-	gap: 1rem;
-	margin-top: 1rem;
-	padding-top: 1rem;
-	border-top: 1px solid var(--agml-border);
+.badgeWrap {
+	display: flex;
+	flex-wrap: wrap;
+	gap: 0.5rem;
+}
+
+.expandButton {
+	font-family: var(--ifm-code-font-family);
+	font-size: 0.68rem;
+	padding: 0.2rem 0.55rem;
+	border-radius: 4px;
+	background: transparent;
+	border: 1px dashed var(--agml-border-strong);
+	color: var(--agml-muted);
+	cursor: pointer;
+}
+
+.expandButton:hover,
+.expandButton:focus-visible {
+	border-color: var(--ifm-color-primary);
+	color: var(--agml-text);
+	outline: none;
 }
 
 .figure {
@@ -161,71 +195,351 @@
 .exampleImage {
 	display: block;
 	width: 100%;
-	height: auto;
-	border-radius: 18px;
+	max-height: 65vh;
+	object-fit: contain;
+	border-radius: 8px;
+	background: var(--agml-surface-soft);
+}
+
+.snippetRow {
+	display: flex;
+	align-items: flex-start;
+	justify-content: space-between;
+	gap: 0.75rem;
+	background: var(--agml-page-bg);
 	border: 1px solid var(--agml-border);
-	background: var(--agml-surface-strong);
+	border-radius: 6px;
+	padding: 0.6rem 0.85rem;
+	margin-top: 0.6rem;
+}
+
+.snippetCode {
+	font-family: var(--ifm-code-font-family);
+	font-size: 0.78rem;
+	line-height: 1.6;
+	color: var(--agml-text);
+	overflow-x: auto;
+	white-space: pre;
+}
+
+.snippetCopyButton {
+	flex-shrink: 0;
+	align-self: center;
+	font-family: var(--ifm-code-font-family);
+	font-size: 0.68rem;
+	padding: 0.3rem 0.65rem;
+	border-radius: 5px;
+	border: 1px solid var(--agml-border-strong);
+	background: transparent;
+	color: var(--agml-muted);
+	cursor: pointer;
+}
+
+.snippetCopyButton:hover,
+.snippetCopyButton:focus-visible {
+	border-color: var(--ifm-color-primary);
+	color: var(--agml-text);
+	outline: none;
 }
 
 .linkRow {
 	display: flex;
 	flex-wrap: wrap;
 	gap: 0.6rem;
+	margin-bottom: 1.75rem;
 }
 
-.externalLink {
+.externalLink,
+.hfLink {
 	display: inline-flex;
 	width: fit-content;
-	border-radius: 999px;
-	padding: 0.6rem 1rem;
-	border: 1px solid var(--ifm-color-primary);
-	background: var(--ifm-color-primary);
-	color: #fff;
+	border-radius: 6px;
+	padding: 0.5rem 1rem;
+	border: 1px solid var(--agml-border-strong);
+	background: var(--agml-tag-bg);
+	color: var(--agml-tag-fg);
 	text-decoration: none;
-	font-weight: 600;
+	font-size: 0.82rem;
+	cursor: pointer;
 }
 
 .externalLink:hover,
-.externalLink:focus-visible {
-	background: var(--ifm-color-primary-dark);
-	border-color: var(--ifm-color-primary-dark);
+.externalLink:focus-visible,
+.hfLink:hover,
+.hfLink:focus-visible {
+	border-color: var(--ifm-color-primary);
+	color: var(--ifm-color-primary);
 	outline: none;
 }
 
-.hfLink {
-	display: inline-flex;
-	width: fit-content;
+.leaderboardWrap {
+	overflow-x: auto;
+}
+
+.filterBar {
+	display: flex;
+	flex-wrap: wrap;
+	align-items: flex-end;
+	gap: 1rem;
+	margin-bottom: 0.9rem;
+	padding: 0.75rem;
+	border-radius: 8px;
+	border: 1px solid var(--agml-border);
+	background: var(--agml-surface-soft);
+}
+
+.filterGroup {
+	display: flex;
+	flex-direction: column;
+	gap: 0.4rem;
+}
+
+.filterGroupLabel {
+	margin: 0;
+	font-family: var(--ifm-code-font-family);
+	font-size: 0.62rem;
+	text-transform: uppercase;
+	letter-spacing: 0.04em;
+	color: var(--agml-muted);
+}
+
+.filterGroupOptions {
+	display: flex;
+	flex-wrap: wrap;
+	gap: 0.65rem;
+}
+
+.filterCheckboxRow {
+	display: flex;
+	align-items: center;
+	gap: 0.35rem;
+	font-size: 0.75rem;
+	cursor: pointer;
+	color: var(--agml-text);
+	white-space: nowrap;
+}
+
+.checkbox {
+	appearance: none;
+	-webkit-appearance: none;
+	width: 15px;
+	height: 15px;
+	flex-shrink: 0;
+	border-radius: 4px;
+	border: 1.5px solid var(--agml-border-strong);
+	background: var(--agml-page-bg);
+	position: relative;
+	cursor: pointer;
+	transition: background 0.12s, border-color 0.12s;
+}
+
+.checkbox:hover {
+	border-color: var(--agml-muted);
+}
+
+.checkbox:checked {
+	background: var(--ifm-color-primary);
+	border-color: var(--ifm-color-primary);
+}
+
+.checkbox::after {
+	content: '';
+	position: absolute;
+	left: 3.5px;
+	top: 0.5px;
+	width: 4px;
+	height: 7px;
+	border-style: solid;
+	border-width: 0 2px 2px 0;
+	border-color: var(--agml-page-bg);
+	transform: rotate(45deg);
+	opacity: 0;
+}
+
+.checkbox:checked::after {
+	opacity: 1;
+}
+
+.filterRange {
+	display: flex;
+	flex-direction: column;
+	gap: 0.4rem;
+}
+
+.filterRangeLabel {
+	font-family: var(--ifm-code-font-family);
+	font-size: 0.62rem;
+	text-transform: uppercase;
+	letter-spacing: 0.04em;
+	color: var(--agml-muted);
+}
+
+.filterRangeInput {
+	width: 96px;
+	border-radius: 5px;
+	border: 1px solid var(--agml-border-strong);
+	padding: 0.4rem 0.55rem;
+	background: var(--agml-surface-strong);
+	color: var(--agml-text);
+	font-family: var(--ifm-code-font-family);
+	font-size: 0.75rem;
+}
+
+.clearFiltersButton {
+	border: 1px solid var(--agml-border-strong);
+	background: transparent;
 	border-radius: 999px;
-	padding: 0.6rem 1rem;
-	border: 1px solid #f5a000;
-	background: #f5a000;
-	color: #fff;
-	text-decoration: none;
-	font-weight: 600;
+	padding: 0.45rem 0.9rem;
+	font-size: 0.78rem;
+	color: var(--agml-text);
+	cursor: pointer;
+	white-space: nowrap;
 }
 
-.hfLink:hover,
-.hfLink:focus-visible {
-	background: #d98c00;
-	border-color: #d98c00;
-	outline: none;
+.tableWrap {
+	border: 1px solid var(--agml-border);
+	border-radius: 8px;
+	overflow-x: auto;
+}
+
+.leaderboardTable {
+	width: 100%;
+	min-width: 960px;
+	font-size: 0.78rem;
+}
+
+.tableRow {
+	display: grid;
+	grid-template-columns: 42px minmax(150px, 1fr) 120px 70px 125px 130px 120px 65px;
+	gap: 0.5rem;
+	align-items: start;
+}
+
+.tableRow[role='row']:first-child {
+	font-family: var(--ifm-code-font-family);
+	font-size: 0.62rem;
+	text-transform: uppercase;
+	letter-spacing: 0.05em;
+	color: var(--agml-muted);
+	background: var(--agml-tag-bg);
+	padding: 0.5rem 0.75rem;
+	align-items: center;
+}
+
+.tableRow:not(:first-child) {
+	padding: 0.55rem 0.75rem;
+	border-top: 1px solid var(--agml-border);
+}
+
+.tableRow > [role='columnheader'] {
+	white-space: nowrap;
+	overflow: hidden;
+	text-overflow: ellipsis;
+}
+
+.simpleCell {
+	white-space: nowrap;
+	overflow: hidden;
+	text-overflow: ellipsis;
+	display: block;
+}
+
+.rankCell {
+	font-family: var(--ifm-code-font-family);
+	color: var(--agml-muted);
+}
+
+.modelButton {
+	background: none;
+	border: none;
+	padding: 0;
+	max-width: 100%;
+	font-family: var(--ifm-code-font-family);
+	font-weight: 500;
+	color: var(--agml-text);
+	text-decoration: underline dashed var(--agml-muted);
+	text-decoration-thickness: 1px;
+	text-underline-offset: 3px;
+	cursor: pointer;
+	text-align: left;
+	white-space: nowrap;
+	overflow: hidden;
+	text-overflow: ellipsis;
+	display: block;
+}
+
+.scoresCell {
+	display: flex;
+	flex-direction: column;
+	gap: 0.15rem;
+	font-family: var(--ifm-code-font-family);
+	font-size: 0.72rem;
+	color: var(--ifm-color-primary);
+}
+
+.scoresCell span {
+	white-space: nowrap;
+}
+
+.stackCell {
+	display: flex;
+	flex-direction: column;
+	gap: 0.15rem;
+	font-family: var(--ifm-code-font-family);
+	font-size: 0.72rem;
+	color: var(--agml-muted);
+}
+
+.stackCell span {
+	white-space: nowrap;
+}
+
+.notesRow {
+	padding: 0.5rem 0.75rem 0.75rem 2.6rem;
+	background: var(--agml-surface-soft);
+	border-top: 1px dashed var(--agml-border);
+	font-size: 0.75rem;
+	line-height: 1.5;
+}
+
+.notesLabel {
+	margin: 0 0 0.2rem;
+	font-family: var(--ifm-code-font-family);
+	font-size: 0.62rem;
+	text-transform: uppercase;
+	letter-spacing: 0.05em;
+	color: var(--agml-muted);
+}
+
+.notesText {
+	margin: 0;
+	color: var(--agml-text);
+	line-height: 1.5;
+	overflow-wrap: anywhere;
+}
+
+.leaderboardTable a {
+	color: var(--ifm-color-primary);
+	font-weight: 600;
+	text-decoration: none;
 }
 
-:global(html[data-theme='dark']) .backdrop {
-	background: rgba(4, 7, 5, 0.72);
+.leaderboardTable a:hover,
+.leaderboardTable a:focus-visible {
+	text-decoration: underline;
 }
 
 @media (max-width: 720px) {
 	.modal {
-		padding: 1.1rem;
-		border-radius: 22px;
+		padding: 1.25rem;
+		border-radius: 10px;
 	}
 
 	.header {
 		flex-direction: column;
 	}
 
-	.secondaryGrid {
-		grid-template-columns: 1fr;
+	.detailGrid {
+		grid-template-columns: repeat(2, 1fr) !important;
 	}
 }
diff --git a/src/components/DatasetMetadataModal.tsx b/src/components/DatasetMetadataModal.tsx
index d5e38ee..e7bebe8 100644
--- a/src/components/DatasetMetadataModal.tsx
+++ b/src/components/DatasetMetadataModal.tsx
@@ -1,6 +1,8 @@
-import { useEffect } from 'react';
+import { Fragment, useEffect, useMemo, useState } from 'react';
 import type { Dataset } from '../lib/datasets';
 import { formatDisplayLocation } from '../lib/datasets';
+import { METRIC_CATEGORY_LABELS, useDatasetPerformance } from '../lib/performance';
+import type { MetricCategory, PerformanceEntry } from '../lib/performance';
 import styles from './DatasetMetadataModal.module.css';
 
 function formatImageCount(count: number | null) {
@@ -42,26 +44,99 @@ function formatBytesDecimal(bytes: number | null | undefined) {
 	return `${trimmed} ${units[unitIndex]}`;
 }
 
+const EMPTY_ENTRIES: PerformanceEntry[] = [];
+
 function hasExampleImage(url: string | null): url is string {
 	return Boolean(url);
 }
 
+function formatResultType(entry: { variant: 'zero-shot' | 'fine-tuned' | null; optimized: boolean }) {
+	const base = entry.variant === 'fine-tuned' ? 'Fine-tuned' : entry.variant === 'zero-shot' ? 'Zero-shot' : '—';
+	if (base === '—') return base;
+	return entry.optimized ? `${base} (optimized)` : base;
+}
+
+function taskBadgeClass(task: string | null): string {
+	if (!task) return styles.badgeOther;
+	if (task.includes('classif')) return styles.badgeClassification;
+	if (task.includes('detect')) return styles.badgeDetection;
+	if (task.includes('segment')) return styles.badgeSegmentation;
+	return styles.badgeOther;
+}
+
+function formatTunedKey(key: string) {
+	return key === 'fine-tuned' ? 'Fine-tuned' : 'Zero-shot';
+}
+
+function formatOptimizedKey(key: string) {
+	return key === 'optimized' ? 'Optimized' : 'Not optimized';
+}
+
+function parseFilterNumber(value: string): number | null {
+	if (!value.trim()) return null;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : null;
+}
+
+function formatTimePerImage(value: number | null) {
+	if (value == null || !Number.isFinite(value)) return '—';
+	return `${value.toFixed(3)} s/img`;
+}
+
+function formatMetricScore(entry: { metrics: { key: string; label: string; value: number }[]; score: number | null }) {
+	if (entry.metrics.length > 0) {
+		return entry.metrics.map((metric) => `${metric.label}: ${metric.value.toFixed(3)}`).join(' · ');
+	}
+	return entry.score != null ? entry.score.toLocaleString() : '—';
+}
+
 function formatLoaderInstructions(dataset: Dataset) {
 	if (dataset.source === 'huggingface') {
 		return {
 			title: 'Load from Hugging Face',
-			body: `Use agml.data.hf_loader.HuggingFaceDataLoader("Project-AgML/${dataset.name}") to load this dataset from Hugging Face.`,
-			code: `from agml.data.hf_loader import HuggingFaceDataLoader\n\nloader = HuggingFaceDataLoader("Project-AgML/${dataset.name}")`,
+			code: `from agml.data.hf_loader import HuggingFaceDataLoader\nloader = HuggingFaceDataLoader("Project-AgML/${dataset.name}")`,
 		};
 	}
 
 	return {
 		title: 'Load with AgML',
-		body: `Use agml.data.AgMLDataLoader("${dataset.name}") to load this dataset locally through AgML.`,
-		code: `import agml\n\nloader = agml.data.AgMLDataLoader("${dataset.name}")`,
+		code: `import agml\nloader = agml.data.AgMLDataLoader("${dataset.name}")`,
 	};
 }
 
+function InlineFilterGroup({
+	label,
+	options,
+	selected,
+	onToggle,
+	formatOption = (value: string) => value,
+}: {
+	label: string;
+	options: string[];
+	selected: string[];
+	onToggle: (value: string) => void;
+	formatOption?: (value: string) => string;
+}) {
+	return (
+		<div className={styles.filterGroup}>
+			<p className={styles.filterGroupLabel}>{label}</p>
+			<div className={styles.filterGroupOptions}>
+				{options.map((option) => (
+					<label key={option} className={styles.filterCheckboxRow}>
+						<input
+							type="checkbox"
+							className={styles.checkbox}
+							checked={selected.includes(option)}
+							onChange={() => onToggle(option)}
+						/>
+						<span>{formatOption(option)}</span>
+					</label>
+				))}
+			</div>
+		</div>
+	);
+}
+
 export function DatasetMetadataModal({
 	dataset,
 	open,
@@ -88,17 +163,95 @@ export function DatasetMetadataModal({
 		};
 	}, [open, onClose]);
 
+	const datasetPerformance = useDatasetPerformance(open ? (dataset?.name ?? null) : null);
+
+	const [metricTypeFilter, setMetricTypeFilter] = useState<string[]>([]);
+	const [tunedFilter, setTunedFilter] = useState<string[]>([]);
+	const [optimizedFilter, setOptimizedFilter] = useState<string[]>([]);
+	const [platformFilter, setPlatformFilter] = useState<string[]>([]);
+	const [trainingTimeMax, setTrainingTimeMax] = useState('');
+	const [trainingSizeMin, setTrainingSizeMin] = useState('');
+
+	const allEntries = datasetPerformance.data?.entries ?? EMPTY_ENTRIES;
+
+	const { metricTypeOptions, tunedOptions, optimizedOptions, platformOptions } = useMemo(() => {
+		const metricTypes = new Set<MetricCategory>();
+		const tuned = new Set<string>();
+		const optimized = new Set<string>();
+		const platforms = new Set<string>();
+		for (const entry of allEntries) {
+			entry.metricCategories.forEach((category) => metricTypes.add(category));
+			if (entry.variant) tuned.add(entry.variant);
+			optimized.add(entry.optimized ? 'optimized' : 'not-optimized');
+			if (entry.platform) platforms.add(entry.platform);
+		}
+		return {
+			metricTypeOptions: Array.from(metricTypes),
+			tunedOptions: Array.from(tuned).sort(),
+			optimizedOptions: Array.from(optimized).sort(),
+			platformOptions: Array.from(platforms).sort(),
+		};
+	}, [allEntries]);
+
+	const toggleFilter = (setter: (updater: (current: string[]) => string[]) => void, value: string) => {
+		setter((current) => (current.includes(value) ? current.filter((v) => v !== value) : [...current, value]));
+	};
+
+	const filteredEntries = useMemo(() => {
+		const timeMax = parseFilterNumber(trainingTimeMax);
+		const sizeMin = parseFilterNumber(trainingSizeMin);
+
+		return allEntries.filter((entry: PerformanceEntry) => {
+			if (metricTypeFilter.length && !entry.metricCategories.some((category) => metricTypeFilter.includes(category))) {
+				return false;
+			}
+			if (tunedFilter.length && !(entry.variant && tunedFilter.includes(entry.variant))) return false;
+			if (optimizedFilter.length && !optimizedFilter.includes(entry.optimized ? 'optimized' : 'not-optimized')) return false;
+			if (platformFilter.length && !(entry.platform && platformFilter.includes(entry.platform))) return false;
+			if (timeMax != null && (entry.trainTimePerImage == null || entry.trainTimePerImage > timeMax)) return false;
+			if (sizeMin != null && (entry.trainPercentage == null || entry.trainPercentage < sizeMin)) return false;
+			return true;
+		});
+	}, [allEntries, metricTypeFilter, tunedFilter, optimizedFilter, platformFilter, trainingTimeMax, trainingSizeMin]);
+
+	const hasActiveLeaderboardFilters =
+		metricTypeFilter.length > 0 ||
+		tunedFilter.length > 0 ||
+		optimizedFilter.length > 0 ||
+		platformFilter.length > 0 ||
+		trainingTimeMax !== '' ||
+		trainingSizeMin !== '';
+
+	const clearLeaderboardFilters = () => {
+		setMetricTypeFilter([]);
+		setTunedFilter([]);
+		setOptimizedFilter([]);
+		setPlatformFilter([]);
+		setTrainingTimeMax('');
+		setTrainingSizeMin('');
+	};
+
+	const [cropsExpanded, setCropsExpanded] = useState(false);
+	const [classesExpanded, setClassesExpanded] = useState(false);
+	const [copied, setCopied] = useState(false);
+
+	const [expandedRowKeys, setExpandedRowKeys] = useState<Set<string>>(new Set());
+	const toggleExpandedRow = (key: string) => {
+		setExpandedRowKeys((current) => {
+			const next = new Set(current);
+			if (next.has(key)) next.delete(key);
+			else next.add(key);
+			return next;
+		});
+	};
+	useEffect(() => setExpandedRowKeys(new Set()), [filteredEntries]);
+
 	if (!open || dataset == null) return null;
 
-	const detailRows = [
-		['Machine learning task', formatValue(dataset.machine_learning_task)],
-		['Agricultural task', formatValue(dataset.agricultural_task)],
+	const metadataRows = [
 		['Location', formatDisplayLocation(dataset.location)],
 		['Sensor modality', formatValue(dataset.sensor_modality)],
-		['Real or synthetic', formatValue(dataset.real_or_synthetic)],
 		['Platform', formatValue(dataset.platform)],
-		['Input format', formatValue(dataset.input_data_format)],
-		['Annotation format', formatValue(dataset.annotation_format)],
 		['Number of images', formatImageCount(dataset.num_images)],
 		['Size', formatBytesDecimal(dataset.zip_size_bytes)],
 		...(dataset.augmented_num_images != null
@@ -109,6 +262,8 @@ export function DatasetMetadataModal({
 			: []),
 	] as [string, string][];
 	const loader = formatLoaderInstructions(dataset);
+	const cropList = dataset.crop_types ?? [];
+	const classList = dataset.classes ? dataset.classes.split(', ').filter(Boolean) : [];
 
 	return (
 		<div className={styles.backdrop} role="presentation" onClick={onClose}>
@@ -121,18 +276,26 @@ export function DatasetMetadataModal({
 			>
 				<div className={styles.header}>
 					<div>
-						<p className={styles.kicker}>Dataset metadata</p>
 						<h2 id="dataset-metadata-title" className={styles.title}>
 							{dataset.name}
 						</h2>
+						<div className={styles.headerBadges}>
+							{dataset.machine_learning_task && (
+								<span className={`${styles.taskBadge} ${taskBadgeClass(dataset.machine_learning_task)}`}>
+									{formatValue(dataset.machine_learning_task)}
+								</span>
+							)}
+							{dataset.agricultural_task && <span className={styles.tag}>{formatValue(dataset.agricultural_task)}</span>}
+							{dataset.real_or_synthetic && <span className={styles.tag}>{formatValue(dataset.real_or_synthetic)}</span>}
+						</div>
 					</div>
 					<button type="button" className={styles.closeButton} onClick={onClose} aria-label="Close dataset details">
-						Close
+						×
 					</button>
 				</div>
 
-				<dl className={styles.detailGrid}>
-					{detailRows.map(([label, value]) => (
+				<dl className={styles.detailGrid} style={{ gridTemplateColumns: `repeat(${metadataRows.length}, 1fr)` }}>
+					{metadataRows.map(([label, value]) => (
 						<div key={label} className={styles.detailItem}>
 							<dt className={styles.detailLabel}>{label}</dt>
 							<dd className={styles.detailValue}>{value}</dd>
@@ -140,30 +303,52 @@ export function DatasetMetadataModal({
 					))}
 				</dl>
 
-				{(dataset.classes || dataset.stats_mean || dataset.stats_std) && (
-					<div className={styles.secondaryGrid}>
-						{dataset.classes && (
-							<section className={styles.secondarySection}>
-								<h3 className={styles.sectionTitle}>Classes</h3>
-								<p className={styles.bodyText}>{dataset.classes}</p>
+				{cropList.length > 0 && (
+					<section className={styles.section}>
+						<h3 className={styles.sectionTitle}>Crops</h3>
+						<div className={styles.badgeWrap}>
+							{(cropsExpanded ? cropList : cropList.slice(0, 10)).map((crop) => (
+								<span key={crop} className={styles.tag}>{crop}</span>
+							))}
+							{!cropsExpanded && cropList.length > 10 && (
+								<button type="button" className={styles.expandButton} onClick={() => setCropsExpanded(true)}>
+									+{cropList.length - 10} more
+								</button>
+							)}
+						</div>
+					</section>
+				)}
 
-							</section>
-						)}
-						{(dataset.stats_mean || dataset.stats_std) && (
-							<section className={styles.secondarySection}>
-								<h3 className={styles.sectionTitle}>Stats</h3>
-								<p className={styles.bodyText}>
-									<span className={styles.inlineLabel}>Mean:</span> {formatArray(dataset.stats_mean)}
-								</p>
-								<p className={styles.bodyText}>
-									<span className={styles.inlineLabel}>Std:</span> {formatArray(dataset.stats_std)}
-								</p>
-							</section>
-						)}
-					</div>
+				{classList.length > 0 && (
+					<section className={styles.section}>
+						<h3 className={styles.sectionTitle}>Classes</h3>
+						<div className={styles.badgeWrap}>
+							{(classesExpanded ? classList : classList.slice(0, 10)).map((cls) => (
+								<span key={cls} className={styles.tag}>{cls}</span>
+							))}
+							{!classesExpanded && classList.length > 10 && (
+								<button type="button" className={styles.expandButton} onClick={() => setClassesExpanded(true)}>
+									+{classList.length - 10} more
+								</button>
+							)}
+						</div>
+					</section>
+				)}
+
+				{(dataset.stats_mean || dataset.stats_std) && (
+					<section className={styles.section}>
+						<h3 className={styles.sectionTitle}>Stats</h3>
+						<p className={styles.bodyText}>
+							<span className={styles.inlineLabel}>Mean:</span> {formatArray(dataset.stats_mean)}
+						</p>
+						<p className={styles.bodyText}>
+							<span className={styles.inlineLabel}>Std:</span> {formatArray(dataset.stats_std)}
+						</p>
+					</section>
 				)}
 
-				<div className={styles.footer}>
+				<section className={styles.section}>
+					<h3 className={styles.sectionTitle}>Sample image</h3>
 					{hasExampleImage(dataset.examples_image_url) ? (
 						<figure className={styles.figure}>
 							<img className={styles.exampleImage} src={dataset.examples_image_url} alt={`Example for ${dataset.name}`} />
@@ -171,28 +356,182 @@ export function DatasetMetadataModal({
 					) : (
 						<p className={styles.bodyText}>No example image is available for this dataset.</p>
 					)}
+				</section>
 
-					<section className={styles.secondarySection}>
-						<h3 className={styles.sectionTitle}>{loader.title}</h3>
-						<p className={styles.bodyText}>{loader.body}</p>
-						<pre className={styles.codeBlock}>{loader.code}</pre>
-					</section>
+				<section className={styles.section}>
+					<h3 className={styles.sectionTitle}>{loader.title}</h3>
+					<div className={styles.snippetRow}>
+						<span className={styles.snippetCode}>{loader.code}</span>
+						<button
+							type="button"
+							className={styles.snippetCopyButton}
+							onClick={() => {
+								navigator.clipboard.writeText(loader.code);
+								setCopied(true);
+								setTimeout(() => setCopied(false), 1500);
+							}}
+						>
+							{copied ? 'Copied!' : 'Copy'}
+						</button>
+					</div>
+				</section>
 
-					{(dataset.documentation || dataset.hf_link) && (
-						<div className={styles.linkRow}>
-							{dataset.documentation && (
-								<a className={styles.externalLink} href={dataset.documentation} target="_blank" rel="noreferrer">
-									Open source documentation
-								</a>
-							)}
-							{dataset.hf_link && (
-								<a className={styles.hfLink} href={dataset.hf_link} target="_blank" rel="noreferrer">
-									View on Hugging Face
-								</a>
+				{(dataset.documentation || dataset.hf_link) && (
+					<div className={styles.linkRow}>
+						{dataset.documentation && (
+							<a className={styles.externalLink} href={dataset.documentation} target="_blank" rel="noreferrer">
+								Open source documentation
+							</a>
+						)}
+						{dataset.hf_link && (
+							<a className={styles.hfLink} href={dataset.hf_link} target="_blank" rel="noreferrer">
+								View on Hugging Face
+							</a>
+						)}
+					</div>
+				)}
+
+				<section className={styles.section}>
+					<h3 className={styles.sectionTitle}>
+						Leaderboard{datasetPerformance.data?.metric ? ` — ${datasetPerformance.data.metric}` : ''}
+					</h3>
+					{datasetPerformance.loading ? (
+						<p className={styles.bodyText}>Loading leaderboard…</p>
+					) : datasetPerformance.data && datasetPerformance.data.entries.length > 0 ? (
+						<div className={styles.leaderboardWrap}>
+							<div className={styles.filterBar}>
+								<InlineFilterGroup
+									label="Metric type"
+									options={metricTypeOptions}
+									selected={metricTypeFilter}
+									onToggle={(value) => toggleFilter(setMetricTypeFilter, value)}
+									formatOption={(value) => METRIC_CATEGORY_LABELS[value as MetricCategory]}
+								/>
+								<InlineFilterGroup
+									label="Tuned"
+									options={tunedOptions}
+									selected={tunedFilter}
+									onToggle={(value) => toggleFilter(setTunedFilter, value)}
+									formatOption={formatTunedKey}
+								/>
+								<InlineFilterGroup
+									label="Optimized"
+									options={optimizedOptions}
+									selected={optimizedFilter}
+									onToggle={(value) => toggleFilter(setOptimizedFilter, value)}
+									formatOption={formatOptimizedKey}
+								/>
+								<InlineFilterGroup
+									label="Platform"
+									options={platformOptions}
+									selected={platformFilter}
+									onToggle={(value) => toggleFilter(setPlatformFilter, value)}
+								/>
+								<div className={styles.filterRange}>
+									<label className={styles.filterRangeLabel}>Max train time (s/img)</label>
+									<input
+										type="number"
+										placeholder="Max"
+										value={trainingTimeMax}
+										onChange={(event) => setTrainingTimeMax(event.target.value)}
+										className={styles.filterRangeInput}
+									/>
+								</div>
+								<div className={styles.filterRange}>
+									<label className={styles.filterRangeLabel}>Min train split (%)</label>
+									<input
+										type="number"
+										placeholder="Min"
+										value={trainingSizeMin}
+										onChange={(event) => setTrainingSizeMin(event.target.value)}
+										className={styles.filterRangeInput}
+									/>
+								</div>
+								{hasActiveLeaderboardFilters && (
+									<button type="button" className={styles.clearFiltersButton} onClick={clearLeaderboardFilters}>
+										Clear filters
+									</button>
+								)}
+							</div>
+
+							{filteredEntries.length === 0 ? (
+								<p className={styles.bodyText}>No results match the selected filters.</p>
+							) : (
+								<div className={styles.tableWrap}>
+									<div className={styles.leaderboardTable} role="table">
+										<div className={styles.tableRow} role="row">
+											<span role="columnheader">Rank</span>
+											<span role="columnheader">Model</span>
+											<span role="columnheader">Result</span>
+											<span role="columnheader">Split%</span>
+											<span role="columnheader">Config</span>
+											<span role="columnheader">Scores</span>
+											<span role="columnheader">Norm s/img</span>
+											<span role="columnheader">Plat.</span>
+										</div>
+										{filteredEntries.map((entry, index) => {
+											const rowKey = `${entry.model}-${entry.variant ?? 'default'}-${index}`;
+											const isExpanded = expandedRowKeys.has(rowKey);
+											return (
+												<Fragment key={rowKey}>
+													<div role="row" aria-expanded={isExpanded} className={styles.tableRow}>
+														<span role="cell" className={styles.rankCell}>#{entry.rank ?? index + 1}</span>
+														<span role="cell">
+															<button type="button" className={styles.modelButton} onClick={() => toggleExpandedRow(rowKey)}>
+																{entry.link ? (
+																	<a
+																		href={entry.link}
+																		target="_blank"
+																		rel="noreferrer"
+																		onClick={(event) => event.stopPropagation()}
+																	>
+																		{entry.model}
+																	</a>
+																) : (
+																	entry.model
+																)}{' '}
+																{isExpanded ? '▾' : '▸'}
+															</button>
+														</span>
+														<span role="cell" className={styles.simpleCell}>{formatResultType(entry)}</span>
+														<span role="cell" className={styles.simpleCell}>{entry.splitBreakdown ?? '—'}</span>
+														<span role="cell" className={styles.simpleCell}>{entry.datasetConfig ?? '—'}</span>
+														<span role="cell">
+															{entry.metrics.length > 0 ? (
+																<div className={styles.scoresCell}>
+																	{entry.metrics.map((metric) => (
+																		<span key={metric.key}>{metric.label}: {metric.value.toFixed(3)}</span>
+																	))}
+																</div>
+															) : (
+																<span className={styles.simpleCell}>{formatMetricScore(entry)}</span>
+															)}
+														</span>
+														<span role="cell">
+															<div className={styles.stackCell}>
+																<span>train {formatTimePerImage(entry.trainTimePerImage)}</span>
+																<span>inf {formatTimePerImage(entry.infTimePerImage)}</span>
+															</div>
+														</span>
+														<span role="cell" className={styles.simpleCell}>{entry.platform ?? '—'}</span>
+													</div>
+													{isExpanded && (
+														<div className={styles.notesRow}>
+															<p className={styles.notesLabel}>Notes</p>
+															<p className={styles.notesText}>{entry.notes ?? 'No additional notes for this result.'}</p>
+														</div>
+													)}
+												</Fragment>
+											);
+										})}
+									</div>
+								</div>
 							)}
 						</div>
+					) : (
+						<p className={styles.bodyText}>No leaderboard results have been submitted for this dataset yet.</p>
 					)}
-				</div>
+				</section>
 			</div>
 		</div>
 	);
diff --git a/src/components/DatasetTable.module.css b/src/components/DatasetTable.module.css
index 9629660..7dca769 100644
--- a/src/components/DatasetTable.module.css
+++ b/src/components/DatasetTable.module.css
@@ -51,8 +51,8 @@
 
 .searchInput:focus {
   outline: none;
-  border-color: #2f8a5b;
-  box-shadow: 0 0 0 3px rgba(47, 138, 91, 0.15);
+  border-color: var(--ifm-color-primary);
+  box-shadow: 0 0 0 3px var(--agml-accent-soft);
 }
 
 .tableWrap {
@@ -79,7 +79,7 @@
   appearance: none;
   border: none;
   background: transparent;
-  color: #2f8a5b;
+  color: var(--ifm-color-primary);
   padding: 0;
   font: inherit;
   cursor: pointer;
@@ -92,7 +92,7 @@
 }
 
 .datasetButton:focus-visible {
-  outline: 2px solid #2f8a5b;
+  outline: 2px solid var(--ifm-color-primary);
   outline-offset: 3px;
   border-radius: 4px;
 }
diff --git a/src/components/LeaderboardDetailModal.module.css b/src/components/LeaderboardDetailModal.module.css
new file mode 100644
index 0000000..268e618
--- /dev/null
+++ b/src/components/LeaderboardDetailModal.module.css
@@ -0,0 +1,245 @@
+.backdrop {
+  position: fixed;
+  inset: 0;
+  z-index: 999;
+  display: grid;
+  place-items: center;
+  padding: 1.25rem;
+  background: var(--agml-modal-overlay);
+  backdrop-filter: blur(10px);
+}
+
+.modal {
+  width: min(1040px, 95vw);
+  max-height: min(88vh, 900px);
+  overflow-y: auto;
+  border-radius: 12px;
+  border: 1px solid var(--agml-border-strong);
+  background: var(--agml-surface-strong);
+  box-shadow: var(--agml-shadow-strong);
+  color: var(--agml-text);
+  padding: 2rem;
+}
+
+.header {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+  gap: 1rem;
+  margin-bottom: 1.1rem;
+}
+
+.badgeRow {
+  display: flex;
+  gap: 0.4rem;
+  flex-wrap: wrap;
+  align-items: center;
+  margin-bottom: 0.5rem;
+}
+
+.taskBadge {
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.65rem;
+  padding: 0.15rem 0.5rem;
+  border-radius: 4px;
+  display: inline-block;
+  white-space: nowrap;
+}
+
+.badgeClassification {
+  background: var(--agml-badge-classification-bg);
+  color: var(--agml-badge-classification-fg);
+}
+
+.badgeDetection {
+  background: var(--agml-badge-detection-bg);
+  color: var(--agml-badge-detection-fg);
+}
+
+.badgeSegmentation {
+  background: var(--agml-badge-segmentation-bg);
+  color: var(--agml-badge-segmentation-fg);
+}
+
+.badgeOther {
+  background: var(--agml-badge-other-bg);
+  color: var(--agml-badge-other-fg);
+}
+
+.resultTypeBadge {
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.65rem;
+  padding: 0.15rem 0.5rem;
+  border-radius: 4px;
+  background: var(--agml-tag-bg);
+  color: var(--agml-tag-fg);
+  display: inline-block;
+}
+
+.title {
+  font-family: var(--ifm-code-font-family);
+  font-weight: 700;
+  font-size: 1.2rem;
+  margin: 0 0 0.4rem;
+}
+
+.summaryLine {
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.78rem;
+  color: var(--agml-muted);
+  margin: 0;
+}
+
+.closeButton {
+  flex: 0 0 auto;
+  border: 1px solid var(--agml-border-strong);
+  background: var(--agml-surface-soft);
+  color: var(--agml-text);
+  width: 30px;
+  height: 30px;
+  border-radius: 6px;
+  cursor: pointer;
+  font-size: 15px;
+  line-height: 1;
+}
+
+.closeButton:hover {
+  background: var(--agml-border);
+}
+
+.sectionTitle {
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.72rem;
+  font-weight: 600;
+  letter-spacing: 0.05em;
+  text-transform: uppercase;
+  color: var(--agml-muted);
+  margin: 0 0 0.65rem;
+}
+
+.tableWrap {
+  border: 1px solid var(--agml-border);
+  border-radius: 8px;
+  overflow: hidden;
+}
+
+.table {
+  width: 100%;
+  font-size: 0.72rem;
+}
+
+.tableRow {
+  display: grid;
+  grid-template-columns: minmax(200px, 1.4fr) 70px 100px minmax(280px, 1.6fr);
+  gap: 0.75rem;
+  align-items: start;
+}
+
+.tableRow[role='row']:first-child {
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.6rem;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  color: var(--agml-muted);
+  background: var(--agml-tag-bg);
+  padding: 0.5rem 0.75rem;
+  align-items: center;
+}
+
+.tableRow:not(:first-child) {
+  padding: 0.55rem 0.75rem;
+  border-top: 1px solid var(--agml-border);
+}
+
+.tableRow > [role='columnheader'] {
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.simpleCell {
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.clickableRow {
+  cursor: pointer;
+}
+
+.clickableRow:hover {
+  background: var(--agml-accent-soft);
+}
+
+.datasetCell {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 0.4rem;
+}
+
+.datasetName {
+  display: flex;
+  align-items: center;
+  gap: 0.4rem;
+  max-width: 100%;
+  background: none;
+  border: none;
+  padding: 0;
+  cursor: pointer;
+  font-family: var(--ifm-code-font-family);
+  color: var(--agml-text);
+  text-decoration: underline dashed var(--agml-muted);
+  text-decoration-thickness: 1px;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.expandChevron {
+  color: var(--agml-muted);
+  font-size: 0.7rem;
+}
+
+.viewDatasetLink {
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.625rem;
+  padding: 0.1rem 0.45rem;
+  border-radius: 4px;
+  background: var(--agml-tag-bg);
+  color: var(--agml-tag-fg);
+  text-decoration: none;
+  white-space: nowrap;
+}
+
+.viewDatasetLink:hover {
+  background: var(--ifm-color-primary);
+  color: var(--agml-page-bg);
+  text-decoration: none;
+}
+
+.scoresCell {
+  display: flex;
+  flex-direction: column;
+  gap: 0.2rem;
+  font-family: var(--ifm-code-font-family);
+  color: var(--ifm-color-primary);
+  font-size: 0.66rem;
+}
+
+.scoresCell span {
+  white-space: nowrap;
+}
+
+.scoresCell span span {
+  color: var(--agml-muted);
+}
+
+.notesRow {
+  padding: 0.5rem 0.75rem 0.75rem;
+  background: var(--agml-surface-soft);
+  border-top: 1px dashed var(--agml-border);
+  font-size: 0.72rem;
+  line-height: 1.5;
+  color: var(--agml-muted);
+}
diff --git a/src/components/LeaderboardDetailModal.tsx b/src/components/LeaderboardDetailModal.tsx
new file mode 100644
index 0000000..2a5c0f4
--- /dev/null
+++ b/src/components/LeaderboardDetailModal.tsx
@@ -0,0 +1,194 @@
+import { Fragment, useEffect, useState } from 'react';
+import Link from '@docusaurus/Link';
+import type { GlobalLeaderboardEntry } from '../lib/performance';
+import styles from './LeaderboardDetailModal.module.css';
+
+function toLabel(value: string) {
+  return value.replace(/_/g, ' ');
+}
+
+function formatPercentile(value: number | null) {
+  return value == null ? null : `${value.toFixed(0)}th pctl`;
+}
+
+function formatScore(value: number) {
+  return value.toFixed(3);
+}
+
+function formatResultType(entry: { variant: 'zero-shot' | 'fine-tuned' | null; optimized: boolean }) {
+  const base = entry.variant === 'fine-tuned' ? 'Fine-tuned' : entry.variant === 'zero-shot' ? 'Zero-shot' : '—';
+  if (base === '—') return base;
+  return entry.optimized ? `${base} (optimized)` : base;
+}
+
+function taskBadgeClass(task: string | null): string {
+  if (!task) return styles.badgeOther;
+  if (task.includes('classif')) return styles.badgeClassification;
+  if (task.includes('detect')) return styles.badgeDetection;
+  if (task.includes('segment')) return styles.badgeSegmentation;
+  return styles.badgeOther;
+}
+
+export function LeaderboardDetailModal({
+  entry,
+  open,
+  onClose,
+}: {
+  entry: GlobalLeaderboardEntry | null;
+  open: boolean;
+  onClose: () => void;
+}) {
+  useEffect(() => {
+    if (!open) return;
+
+    const previousOverflow = document.body.style.overflow;
+    document.body.style.overflow = 'hidden';
+
+    const onKeyDown = (event: KeyboardEvent) => {
+      if (event.key === 'Escape') onClose();
+    };
+
+    window.addEventListener('keydown', onKeyDown);
+    return () => {
+      document.body.style.overflow = previousOverflow;
+      window.removeEventListener('keydown', onKeyDown);
+    };
+  }, [open, onClose]);
+
+  const [expandedKeys, setExpandedKeys] = useState<Set<string>>(new Set());
+  useEffect(() => setExpandedKeys(new Set()), [entry]);
+  const toggleExpanded = (key: string) => {
+    setExpandedKeys((current) => {
+      const next = new Set(current);
+      if (next.has(key)) next.delete(key);
+      else next.add(key);
+      return next;
+    });
+  };
+
+  if (!open || entry == null) return null;
+
+  return (
+    <div className={styles.backdrop} role="presentation" onClick={onClose}>
+      <div
+        className={styles.modal}
+        role="dialog"
+        aria-modal="true"
+        aria-labelledby="leaderboard-detail-title"
+        onClick={(event) => event.stopPropagation()}
+      >
+        <div className={styles.header}>
+          <div>
+            <h2 id="leaderboard-detail-title" className={styles.title}>
+              {entry.model}
+            </h2>
+            <div className={styles.badgeRow}>
+              <span className={`${styles.taskBadge} ${taskBadgeClass(entry.machineLearningTask)}`}>
+                {entry.machineLearningTask ? toLabel(entry.machineLearningTask) : 'Unknown task'}
+              </span>
+              <span className={styles.resultTypeBadge}>{entry.resultType}</span>
+            </div>
+            <p className={styles.summaryLine}>
+              {entry.appearances} result{entry.appearances === 1 ? '' : 's'} across {entry.datasets.length} dataset
+              {entry.datasets.length === 1 ? '' : 's'}
+            </p>
+          </div>
+          <button type="button" className={styles.closeButton} onClick={onClose} aria-label="Close model details">
+            ×
+          </button>
+        </div>
+
+        <p className={styles.sectionTitle}>Datasets included ({entry.datasetDetails.length})</p>
+        <div className={styles.tableWrap}>
+          <div className={styles.table} role="table">
+            <div className={styles.tableRow} role="row">
+              <span role="columnheader">Dataset</span>
+              <span role="columnheader">Split %</span>
+              <span role="columnheader">Config</span>
+              <span role="columnheader">Scores (percentile)</span>
+            </div>
+            {entry.datasetDetails.map((detail, index) => {
+              const rowKey = `${detail.dataset}-${index}`;
+              const isExpanded = expandedKeys.has(rowKey);
+              const scoreLines = (
+                [
+                  ['F1', 'f1'],
+                  ['mAP', 'map'],
+                  ['Precision', 'precision'],
+                  ['Recall', 'recall'],
+                ] as [string, 'f1' | 'map' | 'precision' | 'recall'][]
+              )
+                .map(([label, category]) => {
+                  const score = detail.scores[category];
+                  const pctl = detail.percentiles[category];
+                  if (score == null || pctl == null) return null;
+                  return [label, formatScore(score), formatPercentile(pctl)] as [string, string, string];
+                })
+                .filter((line): line is [string, string, string] => line != null);
+
+              return (
+                <Fragment key={rowKey}>
+                  <div
+                    role="row"
+                    tabIndex={0}
+                    className={`${styles.tableRow} ${styles.clickableRow}`}
+                    onClick={() => toggleExpanded(rowKey)}
+                    onKeyDown={(event) => {
+                      if (event.key === 'Enter' || event.key === ' ') {
+                        event.preventDefault();
+                        toggleExpanded(rowKey);
+                      }
+                    }}
+                    aria-expanded={isExpanded}
+                  >
+                    <span role="cell">
+                      <div className={styles.datasetCell}>
+                        <button type="button" className={styles.datasetName}>
+                          {toLabel(detail.dataset)}
+                          <span className={styles.expandChevron} aria-hidden>
+                            {isExpanded ? '▲' : '▾'}
+                          </span>
+                        </button>
+                        <Link
+                          className={styles.viewDatasetLink}
+                          to={`/datasets?dataset=${encodeURIComponent(detail.dataset)}`}
+                          onClick={(event) => event.stopPropagation()}
+                        >
+                          view dataset
+                        </Link>
+                      </div>
+                    </span>
+                    <span role="cell" className={styles.simpleCell}>
+                      {detail.splitBreakdown ?? '—'}
+                    </span>
+                    <span role="cell" className={styles.simpleCell}>
+                      {detail.datasetConfig ?? '—'}
+                    </span>
+                    <span role="cell">
+                      {scoreLines.length === 0 ? (
+                        '—'
+                      ) : (
+                        <div className={styles.scoresCell}>
+                          {scoreLines.map(([label, score, pctl]) => (
+                            <span key={label}>
+                              {label} {score} <span>({pctl})</span>
+                            </span>
+                          ))}
+                        </div>
+                      )}
+                    </span>
+                  </div>
+                  {isExpanded && (
+                    <div className={styles.notesRow}>
+                      {formatResultType(detail)} · {detail.platform ?? 'unknown platform'}
+                    </div>
+                  )}
+                </Fragment>
+              );
+            })}
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/MultiSelectDropdown.module.css b/src/components/MultiSelectDropdown.module.css
new file mode 100644
index 0000000..d98205d
--- /dev/null
+++ b/src/components/MultiSelectDropdown.module.css
@@ -0,0 +1,106 @@
+.dropdown {
+	position: relative;
+	display: flex;
+	flex-direction: column;
+	gap: 0.4rem;
+	min-width: 200px;
+	z-index: 31;
+}
+
+.dropdownOpen {
+	z-index: 50;
+}
+
+.dropdownLabel {
+	font-family: var(--ifm-code-font-family);
+	font-size: 0.68rem;
+	font-weight: 600;
+	text-transform: uppercase;
+	letter-spacing: 0.06em;
+	color: var(--agml-muted);
+	margin: 0 0 0.7rem;
+	display: block;
+}
+
+.dropdownTrigger {
+	display: flex;
+	justify-content: space-between;
+	align-items: center;
+	border-radius: 6px;
+	border: 1px solid var(--agml-border-strong);
+	padding: 0.6rem 0.9rem;
+	background: var(--agml-surface-strong);
+	font-family: var(--ifm-code-font-family);
+	font-size: 0.82rem;
+	color: var(--agml-text);
+	width: 100%;
+}
+
+.dropdownChevron {
+	margin-left: 0.5rem;
+}
+
+.dropdownMenu {
+	position: absolute;
+	top: calc(100% + 0.4rem);
+	left: 0;
+	right: 0;
+	border-radius: 6px;
+	border: 1px solid var(--agml-border-strong);
+	background: var(--agml-surface-strong);
+	padding: 0.35rem;
+	max-height: 240px;
+	overflow: auto;
+	box-shadow: var(--agml-shadow-strong);
+	z-index: 40;
+}
+
+.dropdownEmpty {
+	padding: 0.55rem 0.9rem;
+	font-size: 0.85rem;
+	color: var(--agml-muted);
+}
+
+.dropdownOption {
+	display: flex;
+	align-items: center;
+	gap: 0.5rem;
+	padding: 0.4rem 0.5rem;
+	width: 100%;
+	text-align: left;
+	border: none;
+	border-radius: 4px;
+	background: transparent;
+	cursor: pointer;
+	font-size: 0.82rem;
+	color: var(--agml-text);
+}
+
+.dropdownOption:hover {
+	background: var(--agml-tag-bg);
+}
+
+.dropdownOptionSelected {
+	color: var(--agml-text);
+}
+
+.dropdownCheckbox {
+	width: 16px;
+	height: 16px;
+	flex-shrink: 0;
+	border-radius: 4px;
+	border: 1.5px solid var(--agml-border-strong);
+	background: var(--agml-page-bg);
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	font-size: 0.65rem;
+	color: transparent;
+	transition: background 0.12s, border-color 0.12s;
+}
+
+.dropdownOptionSelected .dropdownCheckbox {
+	background: var(--ifm-color-primary);
+	border-color: var(--ifm-color-primary);
+	color: var(--agml-page-bg);
+}
diff --git a/src/components/MultiSelectDropdown.tsx b/src/components/MultiSelectDropdown.tsx
new file mode 100644
index 0000000..0974eea
--- /dev/null
+++ b/src/components/MultiSelectDropdown.tsx
@@ -0,0 +1,65 @@
+import { useState } from 'react';
+import styles from './MultiSelectDropdown.module.css';
+
+export function MultiSelectDropdown({
+	label,
+	options,
+	selected,
+	onToggle,
+	formatOption,
+}: {
+	label: string;
+	options: string[];
+	selected: string[];
+	onToggle: (value: string) => void;
+	formatOption?: (value: string) => string;
+}) {
+	const [open, setOpen] = useState(false);
+	const format = formatOption ?? ((value: string) => value);
+
+	return (
+		<div className={`${styles.dropdown} ${open ? styles.dropdownOpen : ''}`} data-dropdown={label}>
+			<label className={styles.dropdownLabel}>{label}</label>
+			<button
+				type="button"
+				onClick={() => setOpen((value) => !value)}
+				onBlur={() => setTimeout(() => setOpen(false), 150)}
+				aria-expanded={open}
+				className={styles.dropdownTrigger}
+			>
+				<span>
+					{selected.length === 0
+						? 'All'
+						: selected.length === 1
+							? format(selected[0])
+							: `${selected.length} selected`}
+				</span>
+				<span className={styles.dropdownChevron} aria-hidden>
+					▾
+				</span>
+			</button>
+			{open && (
+				<div className={styles.dropdownMenu} role="listbox" aria-multiselectable="true">
+					{options.length === 0 && <div className={styles.dropdownEmpty}>No options</div>}
+					{options.map((option) => {
+						const isSelected = selected.includes(option);
+						return (
+							<button
+								key={option}
+								type="button"
+								className={`${styles.dropdownOption} ${isSelected ? styles.dropdownOptionSelected : ''}`}
+								onMouseDown={(event) => event.preventDefault()}
+								onClick={() => onToggle(option)}
+							>
+								<span className={styles.dropdownCheckbox} aria-hidden>
+									{isSelected ? '✓' : ''}
+								</span>
+								{format(option)}
+							</button>
+						);
+					})}
+				</div>
+			)}
+		</div>
+	);
+}
diff --git a/src/css/custom.css b/src/css/custom.css
index c4ea3da..62cf4a0 100644
--- a/src/css/custom.css
+++ b/src/css/custom.css
@@ -1,4 +1,4 @@
-@import url('https://fonts.googleapis.com/css2?family=Fraunces:opsz,wght@9..144,500;9..144,700&family=Space+Grotesk:wght@400;500;600;700&family=Source+Code+Pro:wght@400;600&display=swap');
+@import url('https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@400;500;600;700&family=Inter:wght@400;500;600;700&display=swap');
 
 /**
  * Any CSS included here will be global. The classic template
@@ -8,32 +8,43 @@
 
 /* You can override the default Infima variables here. */
 :root {
-  --ifm-color-primary: #2d8b5b;
-  --ifm-color-primary-dark: #267b50;
-  --ifm-color-primary-darker: #236f48;
-  --ifm-color-primary-darkest: #1b5a3a;
-  --ifm-color-primary-light: #3aa96d;
-  --ifm-color-primary-lighter: #45b879;
-  --ifm-color-primary-lightest: #66cf95;
-  --ifm-font-family-base: 'Space Grotesk', 'Noto Sans', sans-serif;
-  --ifm-heading-font-family: 'Fraunces', 'Ibarra Real Nova', serif;
-  --ifm-code-font-family: 'Source Code Pro', 'Fira Code', monospace;
+  --ifm-color-primary: oklch(0.5 0.14 150);
+  --ifm-color-primary-dark: oklch(0.45 0.14 150);
+  --ifm-color-primary-darker: oklch(0.42 0.14 150);
+  --ifm-color-primary-darkest: oklch(0.35 0.13 150);
+  --ifm-color-primary-light: oklch(0.55 0.14 150);
+  --ifm-color-primary-lighter: oklch(0.6 0.14 150);
+  --ifm-color-primary-lightest: oklch(0.7 0.13 150);
+  --ifm-font-family-base: 'Inter', 'Noto Sans', sans-serif;
+  --ifm-heading-font-family: 'Inter', 'Noto Sans', sans-serif;
+  --ifm-code-font-family: 'IBM Plex Mono', 'Fira Code', monospace;
   --ifm-code-font-size: 95%;
-  --docusaurus-highlighted-code-line-bg: rgba(16, 28, 22, 0.08);
-  --agml-page-bg: linear-gradient(130deg, #f6f3ec 0%, #eaf4ee 45%, #f4efe6 100%);
-  --agml-surface: rgba(255, 255, 255, 0.88);
-  --agml-surface-strong: rgba(255, 255, 255, 0.95);
-  --agml-surface-soft: rgba(234, 244, 238, 0.8);
-  --agml-border: rgba(25, 45, 33, 0.12);
-  --agml-border-strong: rgba(25, 45, 33, 0.18);
-  --agml-shadow: 0 20px 40px rgba(25, 45, 33, 0.08);
-  --agml-shadow-strong: 0 28px 60px rgba(25, 45, 33, 0.12);
-  --agml-text: #1c2b21;
-  --agml-muted: #4a5f52;
-  --agml-accent-soft: rgba(45, 139, 91, 0.15);
-  --agml-accent-border: rgba(45, 139, 91, 0.35);
+  --docusaurus-highlighted-code-line-bg: oklch(0.16 0.01 145 / 0.08);
+  --agml-page-bg: oklch(0.985 0.006 145);
+  --agml-surface: oklch(0.97 0.01 145);
+  --agml-surface-strong: oklch(1 0.002 145);
+  --agml-surface-soft: oklch(0.965 0.008 145);
+  --agml-border: oklch(0.85 0.012 145);
+  --agml-border-strong: oklch(0.78 0.014 145);
+  --agml-shadow: 0 16px 32px oklch(0 0 0 / 0.06);
+  --agml-shadow-strong: 0 24px 48px oklch(0 0 0 / 0.09);
+  --agml-text: oklch(0.2 0.012 145);
+  --agml-muted: oklch(0.45 0.012 145);
+  --agml-accent-soft: oklch(0.92 0.06 150);
+  --agml-accent-border: color-mix(in oklch, var(--ifm-color-primary) 35%, var(--agml-border));
   --agml-warning-soft: rgba(189, 139, 76, 0.12);
   --agml-warning-text: #7a4e2a;
+  --agml-modal-overlay: oklch(0 0 0 / 0.3);
+  --agml-badge-classification-bg: oklch(0.89 0.10 145);
+  --agml-badge-classification-fg: oklch(0.34 0.13 145);
+  --agml-badge-detection-bg: oklch(0.89 0.08 175);
+  --agml-badge-detection-fg: oklch(0.36 0.12 175);
+  --agml-badge-segmentation-bg: oklch(0.89 0.07 110);
+  --agml-badge-segmentation-fg: oklch(0.36 0.11 110);
+  --agml-badge-other-bg: oklch(0.91 0.01 145);
+  --agml-badge-other-fg: oklch(0.4 0.01 145);
+  --agml-tag-bg: oklch(0.91 0.02 145);
+  --agml-tag-fg: oklch(0.36 0.03 145);
   --ifm-background-color: transparent;
   --ifm-navbar-background-color: var(--agml-surface);
   --ifm-footer-background-color: var(--agml-surface);
@@ -44,28 +55,39 @@
 
 /* For readability concerns, you should choose a lighter palette in dark mode. */
 html[data-theme='dark'] {
-  --ifm-color-primary: #5ccf9a;
-  --ifm-color-primary-dark: #44b983;
-  --ifm-color-primary-darker: #3aa975;
-  --ifm-color-primary-darkest: #2f8a5f;
-  --ifm-color-primary-light: #6fdaaa;
-  --ifm-color-primary-lighter: #7fe1b6;
-  --ifm-color-primary-lightest: #9fe9c9;
-  --docusaurus-highlighted-code-line-bg: rgba(0, 0, 0, 0.35);
-  --agml-page-bg: linear-gradient(130deg, #0d1410 0%, #101b15 45%, #151f18 100%);
-  --agml-surface: rgba(18, 26, 21, 0.88);
-  --agml-surface-strong: rgba(21, 30, 24, 0.96);
-  --agml-surface-soft: rgba(32, 43, 36, 0.9);
-  --agml-border: rgba(255, 255, 255, 0.09);
-  --agml-border-strong: rgba(255, 255, 255, 0.14);
-  --agml-shadow: 0 20px 40px rgba(0, 0, 0, 0.28);
-  --agml-shadow-strong: 0 28px 60px rgba(0, 0, 0, 0.34);
-  --agml-text: #e8f0ea;
-  --agml-muted: #a6b7ad;
-  --agml-accent-soft: rgba(92, 207, 154, 0.16);
-  --agml-accent-border: rgba(92, 207, 154, 0.3);
+  --ifm-color-primary: oklch(0.72 0.15 150);
+  --ifm-color-primary-dark: oklch(0.65 0.15 150);
+  --ifm-color-primary-darker: oklch(0.6 0.15 150);
+  --ifm-color-primary-darkest: oklch(0.5 0.14 150);
+  --ifm-color-primary-light: oklch(0.78 0.14 150);
+  --ifm-color-primary-lighter: oklch(0.83 0.13 150);
+  --ifm-color-primary-lightest: oklch(0.88 0.11 150);
+  --docusaurus-highlighted-code-line-bg: oklch(0 0 0 / 0.35);
+  --agml-page-bg: oklch(0.16 0.01 145);
+  --agml-surface: oklch(0.18 0.012 145);
+  --agml-surface-strong: oklch(0.19 0.012 145);
+  --agml-surface-soft: oklch(0.17 0.01 145);
+  --agml-border: oklch(0.28 0.014 145);
+  --agml-border-strong: oklch(0.3 0.014 145);
+  --agml-shadow: 0 16px 32px oklch(0 0 0 / 0.28);
+  --agml-shadow-strong: 0 24px 48px oklch(0 0 0 / 0.34);
+  --agml-text: oklch(0.92 0.006 145);
+  --agml-muted: oklch(0.65 0.01 145);
+  --agml-accent-soft: oklch(0.22 0.05 150);
+  --agml-accent-border: color-mix(in oklch, var(--ifm-color-primary) 30%, var(--agml-border));
   --agml-warning-soft: rgba(189, 139, 76, 0.18);
   --agml-warning-text: #d9b084;
+  --agml-modal-overlay: oklch(0 0 0 / 0.62);
+  --agml-badge-classification-bg: oklch(0.30 0.10 145);
+  --agml-badge-classification-fg: oklch(0.88 0.15 145);
+  --agml-badge-detection-bg: oklch(0.30 0.09 175);
+  --agml-badge-detection-fg: oklch(0.86 0.13 175);
+  --agml-badge-segmentation-bg: oklch(0.30 0.07 110);
+  --agml-badge-segmentation-fg: oklch(0.86 0.12 110);
+  --agml-badge-other-bg: oklch(0.30 0.02 145);
+  --agml-badge-other-fg: oklch(0.8 0.02 145);
+  --agml-tag-bg: oklch(0.24 0.014 145);
+  --agml-tag-fg: oklch(0.75 0.012 145);
   --ifm-background-color: transparent;
   --ifm-navbar-background-color: var(--agml-surface);
   --ifm-footer-background-color: var(--agml-surface);
@@ -79,6 +101,7 @@ body,
 #__docusaurus {
   background: var(--agml-page-bg);
   color: var(--agml-text);
+  overflow-x: hidden;
 }
 
 body {
@@ -122,15 +145,96 @@ body {
 
 .navbar {
   border-bottom: 1px solid var(--agml-border);
+  --ifm-navbar-height: 64px;
+  --ifm-navbar-padding-horizontal: 24px;
+  --ifm-navbar-item-padding-horizontal: 0;
+  --ifm-navbar-item-padding-vertical: 0;
 }
 
-.footer {
-  border-top: 1px solid var(--agml-border);
+.navbar__brand {
+  margin-right: 20px;
+}
+
+.navbar__brand::before {
+  content: '';
+  display: inline-block;
+  width: 10px;
+  height: 10px;
+  margin-right: 10px;
+  border-radius: 2px;
+  background: var(--ifm-color-primary);
+  flex-shrink: 0;
+}
+
+.navbar__title {
+  font-family: var(--ifm-code-font-family);
+  font-weight: 600;
+  font-size: 15px;
+  letter-spacing: -0.2px;
+}
+
+.navbar__item {
+  padding: 4px;
+}
+
+.navbar__link {
+  font-family: var(--ifm-code-font-family);
+  font-size: 12.5px;
+  font-weight: 400;
+  padding: 8px 12px;
+  border-radius: 6px;
+  color: var(--agml-muted);
+}
+
+.navbar__link:hover,
+.navbar__link--active {
+  background: var(--agml-tag-bg);
+  color: var(--agml-text);
+}
+
+.navbar__github-button .navbar__link {
+  color: var(--ifm-navbar-background-color);
+  background: var(--ifm-color-primary);
+  font-weight: 600;
+}
+
+.navbar__github-button .navbar__link:hover {
+  background: var(--ifm-color-primary-dark);
+  color: var(--ifm-navbar-background-color);
 }
 
 .theme-doc-markdown {
-  border-radius: 24px;
-  padding: 2rem;
+  border-radius: 0;
+  padding: 0;
+  background: transparent;
+  border: none;
+  box-shadow: none;
+  max-width: 760px;
+}
+
+.theme-doc-markdown.markdown h1 {
+  font-size: 1.875rem;
+  font-weight: 600;
+  letter-spacing: -0.01em;
+  margin-bottom: 0.5rem;
+}
+
+.theme-doc-markdown.markdown h2 {
+  font-size: 1.1875rem;
+  font-weight: 600;
+  scroll-margin-top: 1.25rem;
+}
+
+.theme-doc-markdown.markdown h3 {
+  font-size: 1rem;
+  font-weight: 600;
+  scroll-margin-top: 1.25rem;
+}
+
+.theme-doc-markdown.markdown p,
+.theme-doc-markdown.markdown li {
+  font-size: 0.906rem;
+  line-height: 1.65;
 }
 
 .main-wrapper {
@@ -140,22 +244,60 @@ body {
 
 .theme-doc-sidebar-container {
   border-right: 1px solid var(--agml-border);
+  background: var(--agml-surface-soft);
+  box-shadow: none;
+}
+
+.theme-doc-sidebar-menu {
+  --ifm-menu-color: var(--agml-muted);
+  --ifm-menu-color-active: var(--agml-text);
+  --ifm-menu-color-background-hover: var(--agml-tag-bg);
+  --ifm-menu-color-background-active: var(--agml-tag-bg);
+  --ifm-menu-link-padding-vertical: 0.5rem;
+  --ifm-menu-link-padding-horizontal: 0.5rem;
+  padding: 1.5rem 1rem;
+}
+
+.menu__link {
+  font-size: 0.82rem;
+  font-weight: 400;
+}
+
+.sidebarCategoryLabel > .menu__list-item-collapsible {
+  background: transparent !important;
+}
+
+.sidebarCategoryLabel > .menu__list-item-collapsible > .menu__link {
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.68rem;
+  font-weight: 600;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--agml-muted);
+  padding: 0.4rem 0.5rem;
+  pointer-events: none;
+}
+
+.sidebarCategoryLabel + .sidebarCategoryLabel {
+  margin-top: 1.25rem;
 }
 
 .theme-doc-sidebar-item-link,
 .table-of-contents__link,
-.menu__link,
-.navbar__link,
 .footer__link-item {
   color: var(--agml-text);
 }
 
-.theme-doc-sidebar-item-link--active,
-.menu__link--active,
-.navbar__link--active {
+.theme-doc-sidebar-item-link--active {
   color: var(--ifm-color-primary);
 }
 
+.theme-code-block {
+  border: 1px solid var(--agml-border);
+  border-radius: 8px;
+  box-shadow: none;
+}
+
 .theme-code-block pre,
 .prism-code {
   background: var(--agml-surface-strong) !important;
diff --git a/src/lib/datasets.ts b/src/lib/datasets.ts
index 83c174d..7ef07e5 100644
--- a/src/lib/datasets.ts
+++ b/src/lib/datasets.ts
@@ -215,7 +215,11 @@ export function useDatasets(): { data: Dataset[]; loading: boolean; error: Error
   const [data, setData] = useState<Dataset[]>([]);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<Error | null>(null);
-  const manifestUrls = DATASET_MANIFESTS.map((manifest) => useBaseUrl(manifest));
+  const resolvedManifestUrls = DATASET_MANIFESTS.map((manifest) => useBaseUrl(manifest));
+  // Memoized off the individual (stable) resolved URLs rather than reusing the array
+  // from .map() above, which is a new reference every render and would otherwise
+  // retrigger the effect below on every single render — an infinite fetch loop.
+  const manifestUrls = useMemo(() => resolvedManifestUrls, resolvedManifestUrls);
 
   useEffect(() => {
     let active = true;
@@ -340,3 +344,27 @@ export function formatDisplayLocation(value: string | string[] | null | undefine
   if (value == null) return '—';
   return Array.isArray(value) ? value.join(', ') : value;
 }
+
+export interface DatasetStats {
+  datasetCount: number;
+  imageCount: number;
+  taskTypeCount: number;
+}
+
+// Shared by the homepage stats row and the dataset search page's hero stats, so both
+// report the same real numbers instead of two slightly different ad-hoc counts.
+export function computeDatasetStats(datasets: Dataset[]): DatasetStats {
+  const topLevel = datasets.filter((dataset) => !dataset.parent_dataset);
+  const imageCount = topLevel
+    .filter((dataset) => !dataset.name.startsWith('iNatAg-mini'))
+    .reduce((sum, dataset) => sum + (dataset.num_images ?? 0), 0);
+  const taskTypeCount = new Set(
+    datasets.map((dataset) => dataset.machine_learning_task).filter((task): task is string => Boolean(task))
+  ).size;
+
+  return {
+    datasetCount: topLevel.length,
+    imageCount,
+    taskTypeCount,
+  };
+}
diff --git a/src/lib/performance.ts b/src/lib/performance.ts
new file mode 100644
index 0000000..856042b
--- /dev/null
+++ b/src/lib/performance.ts
@@ -0,0 +1,658 @@
+import { useEffect, useState } from 'react';
+import useBaseUrl from '@docusaurus/useBaseUrl';
+
+export interface PerformanceEntry {
+  rank: number | null;
+  model: string;
+  score: number | null;
+  submitted_by: string | null;
+  date: string | null;
+  link: string | null;
+  notes: string | null;
+  variant: 'zero-shot' | 'fine-tuned' | null;
+  optimized: boolean;
+  splitBreakdown: string | null;
+  trainPercentage: number | null;
+  datasetConfig: string | null;
+  trainTimePerImage: number | null;
+  infTimePerImage: number | null;
+  platform: string | null;
+  metrics: MetricValue[];
+  metricCategories: MetricCategory[];
+  categoryScores: CategoryScores;
+}
+
+export type MetricCategory = 'f1' | 'map' | 'precision_recall' | 'other';
+
+export interface MetricValue {
+  key: string;
+  label: string;
+  value: number;
+}
+
+export function classifyMetricLabel(label: string): MetricCategory {
+  if (label === 'F1') return 'f1';
+  if (label.startsWith('mAP')) return 'map';
+  if (label === 'Precision' || label === 'Recall') return 'precision_recall';
+  return 'other';
+}
+
+export const METRIC_CATEGORY_LABELS: Record<MetricCategory, string> = {
+  f1: 'F1',
+  map: 'mAP',
+  precision_recall: 'Precision / Recall',
+  other: 'Other',
+};
+
+export interface DatasetPerformance {
+  metric: string | null;
+  entries: PerformanceEntry[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function toNumber(value: unknown): number | null {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value === 'string' && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+
+function toText(value: unknown): string | null {
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+}
+
+function normalizeEntry(raw: unknown): PerformanceEntry | null {
+  if (!isRecord(raw)) return null;
+  const model = toText(raw.model ?? raw.model_name ?? raw.name);
+  if (!model) return null;
+
+  return {
+    rank: toNumber(raw.rank),
+    model,
+    score: toNumber(raw.score ?? raw.value ?? raw.metric_value),
+    submitted_by: toText(raw.submitted_by ?? raw.submittedBy ?? raw.author),
+    date: toText(raw.date ?? raw.submitted_at),
+    link: toText(raw.link ?? raw.url ?? raw.source_link),
+    notes: toText(raw.notes),
+    variant: null,
+    optimized: Boolean(raw.optimized),
+    splitBreakdown: toText(raw.split_breakdown),
+    trainPercentage: toNumber(raw.train_percentage),
+    datasetConfig: toText(raw.dataset_config ?? raw.config) ?? 'raw',
+    trainTimePerImage: toNumber(raw.train_time_per_image),
+    infTimePerImage: toNumber(raw.inference_time_per_image),
+    platform: toText(raw.platform ?? raw.device),
+    metrics: [],
+    metricCategories: [],
+    categoryScores: { f1: null, map: null, precision: null, recall: null },
+  };
+}
+
+// Raw benchmark run records (see static/data/performance/<dataset>.json) are converted into
+// leaderboard rows here. This logic is mirrored in scripts/generate-datasets.mjs, which derives
+// global.json from the same files at build time — keep the two in sync if the run schema changes.
+const TASK_METRIC_KEYS: Record<string, string[]> = {
+  classification: ['f1', 'accuracy', 'top1_accuracy'],
+  detection: ['map', 'map_50', 'map50', 'mAP', 'mAP@0.5'],
+  segmentation: ['miou', 'iou', 'mean_iou'],
+};
+
+function isFiniteNumber(value: unknown): value is number {
+  return typeof value === 'number' && Number.isFinite(value);
+}
+
+function resolveMetricKey(task: unknown, metrics: Record<string, unknown>): string | null {
+  const candidates = typeof task === 'string' ? (TASK_METRIC_KEYS[task] ?? []) : [];
+  for (const key of candidates) {
+    if (isFiniteNumber(metrics[key])) return key;
+  }
+  return Object.keys(metrics).find((key) => isFiniteNumber(metrics[key])) ?? null;
+}
+
+// Every dataset can report F1, mAP, and precision/recall side by side, regardless of the
+// dataset's primary task — resolveMetricKey above still picks one metric to rank/sort by, but
+// this collects every recognized metric present on a run for display purposes. Detection runs in
+// particular may report mAP at several IoU thresholds (map_50, map_75, map_50_95, ...); each is
+// surfaced as its own labeled value rather than collapsed into one number.
+const NAMED_METRIC_LABELS: Record<string, string> = {
+  f1: 'F1',
+  accuracy: 'Accuracy',
+  top1_accuracy: 'Top-1 Accuracy',
+  precision: 'Precision',
+  prec: 'Precision',
+  recall: 'Recall',
+  rec: 'Recall',
+  miou: 'mIoU',
+  iou: 'IoU',
+  mean_iou: 'mIoU',
+};
+
+function isMapMetricKey(key: string): boolean {
+  return /^m?ap([_@-]|$)/i.test(key);
+}
+
+export interface CategoryScores {
+  f1: number | null;
+  map: number | null;
+  precision: number | null;
+  recall: number | null;
+}
+
+// Every run can report several metric families at once (F1, mAP, precision, recall),
+// independent of the single metric resolveMetricKey picks for the legacy per-dataset rank.
+// These four category scores back the leaderboard's four sortable global columns — precision
+// and recall are ranked/percentiled independently, not averaged into one blended score.
+// Mirrored in scripts/generate-datasets.mjs — keep in sync.
+function computeCategoryScores(metrics: Record<string, unknown>): CategoryScores {
+  const f1 = isFiniteNumber(metrics.f1) ? metrics.f1 : null;
+  let map: number | null = null;
+  for (const [key, value] of Object.entries(metrics)) {
+    if (isMapMetricKey(key) && isFiniteNumber(value)) {
+      map = map == null ? value : Math.max(map, value);
+    }
+  }
+  const precision = isFiniteNumber(metrics.precision) ? metrics.precision : null;
+  const recall = isFiniteNumber(metrics.recall) ? metrics.recall : null;
+  return { f1, map, precision, recall };
+}
+
+function formatMapMetricLabel(key: string): string {
+  const normalized = key.toLowerCase();
+  if (normalized === 'map' || normalized === 'map50' || normalized === 'map_50' || normalized === 'mAP@0.5'.toLowerCase()) {
+    return 'mAP@0.50';
+  }
+  const match = normalized.match(/(\d{2,3})(?:[_-](\d{2,3}))?\s*$/);
+  if (!match) return 'mAP';
+  const lo = (Number(match[1]) / 100).toFixed(2);
+  if (match[2]) {
+    const hi = (Number(match[2]) / 100).toFixed(2);
+    return `mAP@[${lo}:${hi}]`;
+  }
+  return `mAP@${lo}`;
+}
+
+function labelForMetricKey(key: string): string | null {
+  const normalized = key.toLowerCase();
+  if (isMapMetricKey(normalized)) return formatMapMetricLabel(normalized);
+  return NAMED_METRIC_LABELS[normalized] ?? null;
+}
+
+function collectMetrics(metrics: Record<string, unknown>): MetricValue[] {
+  const results: MetricValue[] = [];
+  for (const [key, value] of Object.entries(metrics)) {
+    if (!isFiniteNumber(value)) continue;
+    const label = labelForMetricKey(key);
+    if (!label) continue;
+    results.push({ key, label, value });
+  }
+  return results;
+}
+
+function buildRunNote(entry: Record<string, unknown>): string | null {
+  const parts: string[] = ['Zero-shot'];
+  if (isFiniteNumber(entry.num_samples)) parts.push(`evaluated on ${entry.num_samples} images`);
+  return parts.join(' · ');
+}
+
+function buildFinetuneNote(finetune: unknown): string | null {
+  if (!isRecord(finetune)) return null;
+  const parts: string[] = ['Fine-tuned'];
+  if (isFiniteNumber(finetune.train_samples)) parts.push(`trained on ${finetune.train_samples} images from this dataset`);
+  if (isFiniteNumber(finetune.val_samples)) parts.push(`validated on ${finetune.val_samples} images`);
+  if (isFiniteNumber(finetune.epochs)) parts.push(`${finetune.epochs} epochs`);
+  if (isFiniteNumber(finetune.lr)) parts.push(`lr=${finetune.lr}`);
+  if (isFiniteNumber(finetune.weight_decay)) parts.push(`weight decay=${finetune.weight_decay}`);
+  if (isFiniteNumber(finetune.split_seed)) parts.push(`seed=${finetune.split_seed}`);
+  if (isFiniteNumber(finetune.train_ratio)) parts.push(`train ratio=${finetune.train_ratio}`);
+  return parts.join(' · ');
+}
+
+function computeTrainPercentage(entry: Record<string, unknown>, finetune: unknown): number | null {
+  const testSamples = isFiniteNumber(entry.num_samples) ? entry.num_samples : null;
+  const trainSamples = isRecord(finetune) && isFiniteNumber(finetune.train_samples) ? finetune.train_samples : null;
+  const valSamples = isRecord(finetune) && isFiniteNumber(finetune.val_samples) ? finetune.val_samples : null;
+  const total = (trainSamples ?? 0) + (testSamples ?? 0) + (valSamples ?? 0);
+  if (!total || trainSamples == null) return null;
+  return (trainSamples / total) * 100;
+}
+
+// Rendered as train/test/val percentages in that fixed order, e.g. "10/80/10" or "-/100/-" when
+// a split is absent — compact enough to fit the leaderboard's narrow split column.
+function buildSplitBreakdown(entry: Record<string, unknown>, finetune: unknown): string | null {
+  const testSamples = isFiniteNumber(entry.num_samples) ? entry.num_samples : null;
+  const trainSamples = isRecord(finetune) && isFiniteNumber(finetune.train_samples) ? finetune.train_samples : null;
+  const valSamples = isRecord(finetune) && isFiniteNumber(finetune.val_samples) ? finetune.val_samples : null;
+  const total = (trainSamples ?? 0) + (testSamples ?? 0) + (valSamples ?? 0);
+  if (!total) return null;
+
+  const toShare = (value: number | null) => (value != null ? ((value / total) * 100).toFixed(0) : '-');
+  return `${toShare(trainSamples)}/${toShare(testSamples)}/${toShare(valSamples)}`;
+}
+
+// The result set encodes optimized as the string "yes" / "no" (not a boolean) — a finetune
+// object's own optimized field, if present, may already be boolean, so both forms are accepted.
+function isOptimized(value: unknown): boolean {
+  if (typeof value === 'string') return value.trim().toLowerCase() === 'yes';
+  return Boolean(value);
+}
+
+function makeLeaderboardRow(
+  entry: Record<string, unknown>,
+  metricKey: string,
+  variant: 'zero-shot' | 'fine-tuned'
+): Omit<PerformanceEntry, 'rank'> & { score: number } {
+  const metrics = entry.metrics as Record<string, unknown>;
+  const finetune = entry.finetune;
+  const trainSamples = isRecord(finetune) && isFiniteNumber(finetune.train_samples) ? finetune.train_samples : null;
+  const trainingTimeSeconds = isRecord(finetune) && isFiniteNumber(finetune.training_time_seconds) ? finetune.training_time_seconds : null;
+  const metricValues = collectMetrics(metrics);
+
+  return {
+    model: (entry.model as string).trim(),
+    score: metrics[metricKey] as number,
+    variant,
+    date: toText(entry.timestamp)?.slice(0, 10) ?? null,
+    submitted_by: null,
+    link: null,
+    notes: variant === 'fine-tuned' ? buildFinetuneNote(finetune) : buildRunNote(entry),
+    optimized: isOptimized(entry.optimized) || (isRecord(finetune) && isOptimized(finetune.optimized)),
+    splitBreakdown: buildSplitBreakdown(entry, finetune),
+    trainPercentage: computeTrainPercentage(entry, finetune),
+    // dataset_config is the result set's own config field (raw / augmented) — no fallback to
+    // `split`, which is a different concept (the run's data split, e.g. "train"). Absent config
+    // means the run used the dataset's raw (unaugmented) form.
+    datasetConfig: toText(entry.dataset_config) ?? 'raw',
+    trainTimePerImage: trainingTimeSeconds != null && trainSamples ? trainingTimeSeconds / trainSamples : null,
+    infTimePerImage: isFiniteNumber(entry.inference_time_seconds) && isFiniteNumber(entry.num_samples) && entry.num_samples > 0
+      ? entry.inference_time_seconds / entry.num_samples
+      : null,
+    platform: toText(entry.device),
+    metrics: metricValues,
+    metricCategories: Array.from(new Set(metricValues.map((metric) => classifyMetricLabel(metric.label)))),
+    categoryScores: computeCategoryScores(metrics),
+  };
+}
+
+// A model can appear multiple times per dataset (repeated runs, or a fine-tuned run alongside a
+// zero-shot one). The leaderboard shows the best zero-shot result and the best fine-tuned result
+// per model, side by side, rather than collapsing to a single row.
+function buildLeaderboardFromRawResults(rawResults: unknown[]): DatasetPerformance {
+  type ScoredEntry = { entry: Record<string, unknown>; metricKey: string; score: number; isFinetune: boolean };
+  const scored: ScoredEntry[] = [];
+
+  for (const raw of rawResults) {
+    if (!isRecord(raw)) continue;
+    const model = toText(raw.model);
+    if (!model) continue;
+    if (!isRecord(raw.metrics)) continue;
+    const metricKey = resolveMetricKey(raw.task, raw.metrics);
+    if (!metricKey || !isFiniteNumber(raw.metrics[metricKey])) continue;
+    scored.push({
+      entry: raw,
+      metricKey,
+      score: raw.metrics[metricKey] as number,
+      isFinetune: isRecord(raw.finetune),
+    });
+  }
+
+  const byModel = new Map<string, { zeroShot: ScoredEntry | null; fineTuned: ScoredEntry | null }>();
+  for (const item of scored) {
+    const model = (item.entry.model as string).trim();
+    const group = byModel.get(model) ?? { zeroShot: null, fineTuned: null };
+    const slot = item.isFinetune ? 'fineTuned' : 'zeroShot';
+    if (!group[slot] || item.score > group[slot]!.score) group[slot] = item;
+    byModel.set(model, group);
+  }
+
+  const rows: Omit<PerformanceEntry, 'rank'>[] = [];
+  for (const group of byModel.values()) {
+    if (group.zeroShot) rows.push(makeLeaderboardRow(group.zeroShot.entry, group.zeroShot.metricKey, 'zero-shot'));
+    if (group.fineTuned) rows.push(makeLeaderboardRow(group.fineTuned.entry, group.fineTuned.metricKey, 'fine-tuned'));
+  }
+
+  rows.sort((a, b) => (b.score ?? -Infinity) - (a.score ?? -Infinity));
+  const entries: PerformanceEntry[] = rows.map((row, index) => ({ ...row, rank: index + 1 }));
+
+  return { metric: scored.length ? scored[0].metricKey : null, entries };
+}
+
+function normalizePerformance(json: unknown): DatasetPerformance {
+  if (Array.isArray(json)) return buildLeaderboardFromRawResults(json);
+
+  if (isRecord(json) && Array.isArray(json.leaderboard)) {
+    const entries = json.leaderboard
+      .map(normalizeEntry)
+      .filter((entry): entry is PerformanceEntry => entry != null)
+      .sort((a, b) => {
+        if (a.rank != null && b.rank != null) return a.rank - b.rank;
+        if (a.score != null && b.score != null) return b.score - a.score;
+        return 0;
+      });
+    return { metric: toText(json.metric), entries };
+  }
+
+  return { metric: null, entries: [] };
+}
+
+export interface CategoryPercentiles {
+  f1: number | null;
+  map: number | null;
+  precision: number | null;
+  recall: number | null;
+}
+
+export interface GlobalPerformanceRecord {
+  model: string;
+  dataset: string;
+  percentiles: CategoryPercentiles;
+  scores: CategoryScores;
+  crop_types: string[] | null;
+  machine_learning_task: string | null;
+  variant: 'zero-shot' | 'fine-tuned' | null;
+  optimized: boolean;
+  platform: string | null;
+  splitBreakdown: string | null;
+  datasetConfig: string | null;
+}
+
+export interface GlobalLeaderboardDatasetDetail {
+  dataset: string;
+  percentiles: CategoryPercentiles;
+  scores: CategoryScores;
+  variant: 'zero-shot' | 'fine-tuned' | null;
+  optimized: boolean;
+  platform: string | null;
+  splitBreakdown: string | null;
+  datasetConfig: string | null;
+}
+
+export function globalResultTypeKey(record: { variant: 'zero-shot' | 'fine-tuned' | null; optimized: boolean }): string | null {
+  if (!record.variant) return null;
+  return record.optimized ? `${record.variant}-optimized` : record.variant;
+}
+
+export function formatGlobalResultTypeKey(key: string) {
+  const optimized = key.endsWith('-optimized');
+  const base = optimized ? key.slice(0, -'-optimized'.length) : key;
+  const label = base === 'fine-tuned' ? 'Fine-tuned' : 'Zero-shot';
+  return optimized ? `${label} (optimized)` : label;
+}
+
+export interface GlobalLeaderboardEntry {
+  model: string;
+  machineLearningTask: string | null;
+  avgF1Percentile: number | null;
+  avgMapPercentile: number | null;
+  avgPrecisionPercentile: number | null;
+  avgRecallPercentile: number | null;
+  appearances: number;
+  datasets: string[];
+  fineTunedDatasets: string[];
+  resultType: string;
+  optimized: boolean;
+  datasetDetails: GlobalLeaderboardDatasetDetail[];
+}
+
+function normalizeCategoryPercentiles(raw: unknown): CategoryPercentiles {
+  const record = isRecord(raw) ? raw : {};
+  return {
+    f1: toNumber(record.f1),
+    map: toNumber(record.map),
+    precision: toNumber(record.precision),
+    recall: toNumber(record.recall),
+  };
+}
+
+function normalizeCategoryScores(raw: unknown): CategoryScores {
+  const record = isRecord(raw) ? raw : {};
+  return {
+    f1: toNumber(record.f1),
+    map: toNumber(record.map),
+    precision: toNumber(record.precision),
+    recall: toNumber(record.recall),
+  };
+}
+
+function normalizeGlobalPerformanceRecord(raw: unknown): GlobalPerformanceRecord | null {
+  if (!isRecord(raw)) return null;
+  const model = toText(raw.model);
+  const dataset = toText(raw.dataset);
+  const percentiles = normalizeCategoryPercentiles(raw.percentiles);
+  if (!model || !dataset) return null;
+  if (percentiles.f1 == null && percentiles.map == null && percentiles.precision == null && percentiles.recall == null) return null;
+
+  const cropTypes = Array.isArray(raw.crop_types)
+    ? raw.crop_types.filter((entry): entry is string => typeof entry === 'string' && entry.trim().length > 0)
+    : null;
+
+  const variant = raw.variant === 'zero-shot' || raw.variant === 'fine-tuned' ? raw.variant : null;
+
+  return {
+    model,
+    dataset,
+    percentiles,
+    scores: normalizeCategoryScores(raw.scores),
+    crop_types: cropTypes?.length ? cropTypes : null,
+    machine_learning_task: toText(raw.machine_learning_task),
+    variant,
+    optimized: Boolean(raw.optimized),
+    platform: toText(raw.platform),
+    splitBreakdown: toText(raw.splitBreakdown),
+    datasetConfig: toText(raw.datasetConfig),
+  };
+}
+
+function formatResultTypeLabel(variants: Set<'zero-shot' | 'fine-tuned'>, optimized: boolean) {
+  let base: string;
+  if (variants.size === 0) base = '—';
+  else if (variants.size > 1) base = 'Mixed';
+  else base = variants.has('fine-tuned') ? 'Fine-tuned' : 'Zero-shot';
+
+  if (base === '—') return base;
+  return optimized ? `${base} (optimized)` : base;
+}
+
+export function computeGlobalLeaderboard(
+  records: GlobalPerformanceRecord[],
+  options: {
+    cropTypes?: string[];
+    mlTasks?: string[];
+    resultTypes?: string[];
+    tuned?: ('tuned' | 'not-tuned')[];
+    optimizedValues?: ('optimized' | 'not-optimized')[];
+    platforms?: string[];
+    minAppearances?: number;
+  } = {}
+): GlobalLeaderboardEntry[] {
+  const { cropTypes = [], mlTasks = [], resultTypes = [], tuned = [], optimizedValues = [], platforms = [], minAppearances = 3 } = options;
+  const stats = new Map<
+    string,
+    {
+      model: string;
+      machineLearningTask: string | null;
+      categoryTotals: Record<keyof CategoryPercentiles, number>;
+      categoryCounts: Record<keyof CategoryPercentiles, number>;
+      appearances: number;
+      datasets: Set<string>;
+      fineTunedDatasets: Set<string>;
+      variants: Set<'zero-shot' | 'fine-tuned'>;
+      optimized: boolean;
+      datasetDetails: GlobalLeaderboardDatasetDetail[];
+    }
+  >();
+
+  for (const record of records) {
+    if (cropTypes.length && !record.crop_types?.some((crop) => cropTypes.includes(crop))) continue;
+    if (mlTasks.length && !(record.machine_learning_task && mlTasks.includes(record.machine_learning_task))) continue;
+    if (resultTypes.length) {
+      const resultTypeKey = globalResultTypeKey(record);
+      if (!resultTypeKey || !resultTypes.includes(resultTypeKey)) continue;
+    }
+    if (tuned.length) {
+      const tunedKey = record.variant === 'fine-tuned' ? 'tuned' : 'not-tuned';
+      if (!tuned.includes(tunedKey)) continue;
+    }
+    if (optimizedValues.length) {
+      const optimizedKey = record.optimized ? 'optimized' : 'not-optimized';
+      if (!optimizedValues.includes(optimizedKey)) continue;
+    }
+    if (platforms.length && !(record.platform && platforms.includes(record.platform))) continue;
+
+    const key = `${record.model}|||${record.machine_learning_task ?? ''}`;
+    const entryStats =
+      stats.get(key) ??
+      {
+        model: record.model,
+        machineLearningTask: record.machine_learning_task,
+        categoryTotals: { f1: 0, map: 0, precision: 0, recall: 0 },
+        categoryCounts: { f1: 0, map: 0, precision: 0, recall: 0 },
+        appearances: 0,
+        datasets: new Set<string>(),
+        fineTunedDatasets: new Set<string>(),
+        variants: new Set<'zero-shot' | 'fine-tuned'>(),
+        optimized: false,
+        datasetDetails: [] as GlobalLeaderboardDatasetDetail[],
+      };
+    (Object.keys(record.percentiles) as (keyof CategoryPercentiles)[]).forEach((categoryKey) => {
+      const value = record.percentiles[categoryKey];
+      if (value == null) return;
+      entryStats.categoryTotals[categoryKey] += value;
+      entryStats.categoryCounts[categoryKey] += 1;
+    });
+    entryStats.appearances += 1;
+    entryStats.datasets.add(record.dataset);
+    if (record.variant === 'fine-tuned') entryStats.fineTunedDatasets.add(record.dataset);
+    if (record.variant) entryStats.variants.add(record.variant);
+    if (record.optimized) entryStats.optimized = true;
+    entryStats.datasetDetails.push({
+      dataset: record.dataset,
+      percentiles: record.percentiles,
+      scores: record.scores,
+      variant: record.variant,
+      optimized: record.optimized,
+      platform: record.platform,
+      splitBreakdown: record.splitBreakdown,
+      datasetConfig: record.datasetConfig,
+    });
+    stats.set(key, entryStats);
+  }
+
+  const average = (total: number, count: number) => (count > 0 ? total / count : null);
+
+  return Array.from(stats.values())
+    .filter((entryStats) => entryStats.appearances >= minAppearances)
+    .map((entryStats) => ({
+      model: entryStats.model,
+      machineLearningTask: entryStats.machineLearningTask,
+      avgF1Percentile: average(entryStats.categoryTotals.f1, entryStats.categoryCounts.f1),
+      avgMapPercentile: average(entryStats.categoryTotals.map, entryStats.categoryCounts.map),
+      avgPrecisionPercentile: average(entryStats.categoryTotals.precision, entryStats.categoryCounts.precision),
+      avgRecallPercentile: average(entryStats.categoryTotals.recall, entryStats.categoryCounts.recall),
+      appearances: entryStats.appearances,
+      datasets: Array.from(entryStats.datasets).sort(),
+      fineTunedDatasets: Array.from(entryStats.fineTunedDatasets).sort(),
+      resultType: formatResultTypeLabel(entryStats.variants, entryStats.optimized),
+      optimized: entryStats.optimized,
+      datasetDetails: entryStats.datasetDetails.sort((a, b) => a.dataset.localeCompare(b.dataset)),
+    }))
+    .sort((a, b) => (b.avgMapPercentile ?? b.avgF1Percentile ?? 0) - (a.avgMapPercentile ?? a.avgF1Percentile ?? 0));
+}
+
+export function useGlobalPerformance(): {
+  data: GlobalPerformanceRecord[];
+  loading: boolean;
+  error: Error | null;
+} {
+  const url = useBaseUrl('/data/performance/global.json');
+  const [data, setData] = useState<GlobalPerformanceRecord[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    let active = true;
+    setLoading(true);
+    setError(null);
+
+    fetch(url)
+      .then((response) => {
+        if (!response.ok) throw new Error('Failed to load global performance data');
+        return response.json();
+      })
+      .then((json: unknown) => {
+        if (!active) return;
+        const records = Array.isArray(json) ? json.map(normalizeGlobalPerformanceRecord).filter((entry): entry is GlobalPerformanceRecord => entry != null) : [];
+        setData(records);
+      })
+      .catch((err) => {
+        if (!active) return;
+        setError(err instanceof Error ? err : new Error('Failed to load global performance data'));
+      })
+      .finally(() => {
+        if (!active) return;
+        setLoading(false);
+      });
+
+    return () => {
+      active = false;
+    };
+  }, [url]);
+
+  return { data, loading, error };
+}
+
+export function useDatasetPerformance(datasetName: string | null): {
+  data: DatasetPerformance | null;
+  loading: boolean;
+  error: Error | null;
+} {
+  const url = useBaseUrl(`/data/performance/${datasetName ?? ''}.json`);
+  const [data, setData] = useState<DatasetPerformance | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    if (!datasetName) {
+      setData(null);
+      setLoading(false);
+      setError(null);
+      return;
+    }
+
+    let active = true;
+    setLoading(true);
+    setError(null);
+
+    fetch(url)
+      .then((response) => {
+        if (response.status === 404) return null;
+        if (!response.ok) throw new Error(`Failed to load performance data for ${datasetName}`);
+        return response.json();
+      })
+      .then((json) => {
+        if (!active) return;
+        setData(json == null ? { metric: null, entries: [] } : normalizePerformance(json));
+      })
+      .catch((err) => {
+        if (!active) return;
+        setError(err instanceof Error ? err : new Error('Failed to load performance data'));
+        setData(null);
+      })
+      .finally(() => {
+        if (!active) return;
+        setLoading(false);
+      });
+
+    return () => {
+      active = false;
+    };
+  }, [datasetName, url]);
+
+  return { data, loading, error };
+}
diff --git a/src/pages/datasets/index.module.css b/src/pages/datasets/index.module.css
index aa0be49..50c3ab2 100644
--- a/src/pages/datasets/index.module.css
+++ b/src/pages/datasets/index.module.css
@@ -1,390 +1,139 @@
 .page {
-  position: relative;
-  overflow: visible;
-  padding: 3.5rem 1.5rem 4rem;
   background: var(--agml-page-bg);
   color: var(--agml-text);
-}
-
-:global(html),
-:global(body) {
-  overflow-y: auto;
-  overflow-x: hidden;
-}
-
-:global(#__docusaurus) {
-  min-height: 100%;
-}
-
-.page::before,
-.page::after {
-  content: '';
-  position: absolute;
-  border-radius: 999px;
-  filter: blur(0);
-  opacity: 0.45;
-  pointer-events: none;
-}
-
-.page::before {
-  width: 420px;
-  height: 420px;
-  top: -120px;
-  right: -120px;
-  background: radial-gradient(circle at top, rgba(64, 131, 91, 0.55), transparent 70%);
-}
-
-.page::after {
-  width: 360px;
-  height: 360px;
-  bottom: -140px;
-  left: -120px;
-  background: radial-gradient(circle at bottom, var(--agml-warning-soft), transparent 70%);
-}
-
-.hero {
-  position: relative;
-  z-index: 1;
-  max-width: 1100px;
-  margin: 0 auto 2.5rem;
-  padding: 2.5rem 2.5rem 2rem;
-  border-radius: 28px;
-  border: 1px solid var(--agml-border);
-  background: var(--agml-surface);
-  box-shadow: var(--agml-shadow-strong);
-}
-
-.heroContent {
-  display: flex;
-  flex-direction: column;
-  gap: 1rem;
-}
-
-.heroTag {
-  text-transform: uppercase;
-  letter-spacing: 0.2em;
-  font-size: 0.75rem;
-  font-weight: 600;
-  color: var(--agml-muted);
-  margin: 0;
-}
-
-.heroTitle {
-  font-size: clamp(2.2rem, 2.8vw, 3.4rem);
-  margin: 0;
-  color: var(--agml-text);
-}
-
-.heroSubtitle {
-  margin: 0;
-  font-size: 1.05rem;
-  color: var(--agml-muted);
-  max-width: 720px;
-}
-
-.heroStats {
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
-  gap: 1rem;
-  margin-top: 1rem;
-}
-
-.heroStat {
+  min-height: calc(100vh - 60px);
   display: flex;
   flex-direction: column;
-  gap: 0.35rem;
-  padding: 0.9rem 1.1rem;
-  border-radius: 18px;
-  background: var(--agml-surface-soft);
-  border: 1px solid rgba(25, 45, 33, 0.08);
-  font-weight: 600;
-  color: var(--agml-text);
 }
 
-.heroStat span:last-child {
-  font-size: 0.78rem;
-  text-transform: uppercase;
-  letter-spacing: 0.12em;
-  color: var(--agml-muted);
-  font-weight: 500;
-}
-
-.controls {
-  position: relative;
-  z-index: 30;
-  max-width: 1100px;
-  margin: 0 auto 1.5rem;
+.toolbar {
   display: flex;
-  flex-wrap: wrap;
-  gap: 1.2rem;
-  align-items: flex-end;
-  justify-content: space-between;
-  padding: 1.5rem 2rem;
-  border-radius: 22px;
+  align-items: center;
+  gap: 1rem;
+  padding: 0.9rem 1.5rem;
+  border-bottom: 1px solid var(--agml-border);
   background: var(--agml-surface);
-  border: 1px solid var(--agml-border);
-  box-shadow: var(--agml-shadow);
-}
-
-.searchBlock {
-  flex: 1 1 260px;
-  min-width: 240px;
-}
-
-.searchLabel {
-  display: block;
-  font-size: 0.75rem;
-  text-transform: uppercase;
-  letter-spacing: 0.14em;
-  color: var(--agml-muted);
-  margin-bottom: 0.4rem;
 }
 
 .searchInput {
-  width: 100%;
-  border-radius: 999px;
+  flex: 1;
+  max-width: 480px;
+  border-radius: 6px;
   border: 1px solid var(--agml-border-strong);
   background: var(--agml-surface-strong);
-  padding: 0.7rem 1rem;
-  font-size: 0.95rem;
+  padding: 0.55rem 0.8rem;
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.85rem;
   color: var(--agml-text);
-  box-shadow: inset 0 0 0 1px rgba(25, 45, 33, 0.04);
 }
 
 .searchInput:focus {
   outline: none;
-  border-color: #2d8b5b;
-  box-shadow: 0 0 0 4px rgba(45, 139, 91, 0.15);
+  border-color: var(--ifm-color-primary);
+  box-shadow: 0 0 0 3px var(--agml-accent-soft);
 }
 
-.dropdownRow {
+.toolbarRight {
+  margin-left: auto;
   display: flex;
-  gap: 1rem;
-  flex-wrap: wrap;
-}
-
-.toggle {
-  display: inline-flex;
   align-items: center;
-  gap: 0.5rem;
-  font-size: 0.85rem;
-  color: #4a5f52;
-  background: rgba(255, 255, 255, 0.7);
-  border: 1px solid rgba(25, 45, 33, 0.12);
-  padding: 0.5rem 0.8rem;
-  border-radius: 999px;
-}
-
-.toggle input {
-  accent-color: #2d8b5b;
-}
-
-.dropdown {
-  position: relative;
-  display: flex;
-  flex-direction: column;
-  gap: 0.4rem;
-  min-width: 160px;
-  z-index: 31;
+  gap: 1rem;
 }
 
-.dropdownLabel {
-  font-size: 0.7rem;
-  text-transform: uppercase;
-  letter-spacing: 0.14em;
+.resultCount {
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.78rem;
   color: var(--agml-muted);
+  white-space: nowrap;
 }
 
-.dropdownTrigger {
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  border-radius: 14px;
+.clearButton {
   border: 1px solid var(--agml-border-strong);
-  padding: 0.6rem 0.9rem;
-  background: var(--agml-surface-strong);
-  font-size: 0.92rem;
+  background: transparent;
+  border-radius: 999px;
+  padding: 0.4rem 0.9rem;
+  font-size: 0.8rem;
   color: var(--agml-text);
+  cursor: pointer;
+  white-space: nowrap;
 }
 
-.dropdownChevron {
-  margin-left: 0.5rem;
-}
-
-.dropdownMenu {
-  position: absolute;
-  top: calc(100% + 0.4rem);
-  left: 0;
-  right: 0;
-  border-radius: 16px;
-  border: 1px solid var(--agml-border);
-  background: var(--agml-surface-strong);
-  padding: 0.4rem 0;
-  max-height: 240px;
-  overflow: auto;
-  box-shadow: var(--agml-shadow);
-  z-index: 40;
+.body {
+  flex: 1;
+  display: flex;
+  min-height: 0;
 }
 
-.dropdownOption {
-  display: flex;
-  align-items: center;
-  gap: 0.5rem;
-  padding: 0.55rem 0.9rem;
-  width: 100%;
-  text-align: left;
-  border: none;
-  background: transparent;
-  cursor: pointer;
-  font-size: 0.9rem;
+.sidebar {
+  width: 260px;
+  flex-shrink: 0;
+  border-right: 1px solid var(--agml-border);
+  background: var(--agml-surface-soft);
+  padding: 1.25rem 1.1rem;
+  overflow-y: auto;
 }
 
-.dropdownOptionSelected {
-  background: var(--agml-accent-soft);
-  color: var(--ifm-color-primary);
+.filterGroup {
+  margin-bottom: 1.6rem;
 }
 
-.dropdownCheckbox {
-  width: 1.2rem;
-  height: 1.2rem;
-  border-radius: 6px;
-  border: 1px solid var(--agml-border-strong);
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  font-size: 0.8rem;
-  color: var(--ifm-color-primary);
+.filterGroupLabel {
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.68rem;
+  font-weight: 600;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--agml-muted);
+  margin: 0 0 0.7rem;
 }
 
-.chipsSection {
-  position: relative;
-  z-index: 1;
-  max-width: 1100px;
-  margin: 0 auto 1.5rem;
+.filterGroupOptions {
   display: flex;
   flex-direction: column;
-  gap: 1rem;
+  gap: 0.55rem;
 }
 
-.chipGroup {
+.checkboxRow {
   display: flex;
-  flex-wrap: wrap;
-  gap: 0.6rem;
   align-items: center;
-}
-
-.chipLabel {
-  font-size: 0.72rem;
-  text-transform: uppercase;
-  letter-spacing: 0.14em;
-  color: var(--agml-muted);
-  margin-right: 0.4rem;
-}
-
-.chipBase {
-  border-radius: 999px;
-  padding: 0.45rem 0.85rem;
-  font-size: 0.78rem;
-  border: 1px solid transparent;
-  transition: all 0.2s ease;
-}
-
-.tag {
-  border-radius: 999px;
-  padding: 0.35rem 0.7rem;
-  font-size: 0.75rem;
-  border: 1px solid transparent;
-}
-
-.chip {
+  justify-content: space-between;
+  gap: 0.5rem;
+  font-size: 0.82rem;
   cursor: pointer;
-}
-
-.chipInactive {
-  background: var(--agml-surface-strong);
-  border-color: var(--agml-border);
-  color: var(--agml-text);
-}
-
-.chipActive {
-  background: var(--ifm-color-primary);
-  color: #fff;
-  border-color: var(--ifm-color-primary);
-}
-
-.chipAccent {
-  background: var(--agml-accent-soft);
-  color: var(--ifm-color-primary);
-  border-color: var(--agml-accent-border);
-}
-
-.chipMuted {
-  background: rgba(127, 143, 134, 0.12);
   color: var(--agml-text);
 }
 
-.chipOutline {
-  background: rgba(127, 143, 134, 0.08);
-  color: var(--agml-muted);
-}
-
-.chipCount {
-  background: var(--agml-warning-soft);
-  color: var(--agml-warning-text);
-}
-
-.activeFilters {
-  position: relative;
-  z-index: 1;
-  max-width: 1100px;
-  margin: 0 auto 1.5rem;
+.checkboxRowLeft {
   display: flex;
-  flex-wrap: wrap;
   align-items: center;
-  gap: 0.8rem;
-  justify-content: space-between;
-}
-
-.activeList {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 0.6rem;
+  gap: 0.5rem;
 }
 
-.activeChip {
-  border: none;
-  background: var(--agml-text);
-  color: #fff;
-  border-radius: 999px;
-  padding: 0.4rem 0.85rem;
-  font-size: 0.75rem;
+.checkbox {
+  width: 15px;
+  height: 15px;
+  accent-color: var(--ifm-color-primary);
   cursor: pointer;
 }
 
-.clearButton {
-  border: 1px solid var(--agml-border-strong);
-  background: transparent;
-  border-radius: 999px;
-  padding: 0.45rem 0.9rem;
-  font-size: 0.8rem;
-  color: var(--agml-text);
-  cursor: pointer;
+.checkboxCount {
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.7rem;
+  color: var(--agml-muted);
 }
 
 .results {
-  position: relative;
-  z-index: 1;
-  max-width: 1100px;
-  margin: 0 auto;
+  flex: 1;
+  overflow-y: auto;
+  padding: 1.5rem;
 }
 
 .cardGrid {
   display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
-  gap: 1.2rem;
+  grid-template-columns: repeat(auto-fill, minmax(260px, 1fr));
+  gap: 1rem;
 }
 
-
 .cardButton {
   appearance: none;
   border: none;
@@ -409,77 +158,100 @@
 
 .card {
   background: var(--agml-surface-strong);
-  border-radius: 20px;
-  padding: 1.2rem 1.3rem 1.4rem;
+  border-radius: 8px;
+  padding: 1rem;
   border: 1px solid var(--agml-border);
-  box-shadow: var(--agml-shadow);
-  transition: transform 0.2s ease, box-shadow 0.2s ease, border-color 0.2s ease;
+  display: flex;
+  flex-direction: column;
+  gap: 0.75rem;
+  transition: border-color 0.15s ease;
 }
 
 .cardButton:hover .card,
 .cardButton:focus-visible .card {
-  transform: translateY(-4px);
-  box-shadow: 0 28px 50px rgba(25, 45, 33, 0.16);
-  border-color: rgba(45, 139, 91, 0.4);
+  border-color: var(--agml-accent-border);
 }
 
 .cardButton:focus-visible .card {
   outline: 2px solid var(--ifm-color-primary);
-  outline-offset: 3px;
+  outline-offset: 2px;
 }
 
 .cardTitle {
   margin: 0;
-  font-size: 1.05rem;
+  font-family: var(--ifm-code-font-family);
+  font-weight: 600;
+  font-size: 0.9rem;
   color: var(--agml-text);
   line-height: 1.3;
 }
 
-.cardDetails {
-  display: grid;
-  gap: 0.55rem;
-  margin-top: 0.75rem;
-}
-
-.cardDetail {
+.cardTags {
   display: flex;
-  flex-direction: column;
-  gap: 0.15rem;
+  flex-wrap: wrap;
+  gap: 0.4rem;
 }
 
-.cardDetailLabel {
+.taskBadge {
+  font-family: var(--ifm-code-font-family);
   font-size: 0.68rem;
-  text-transform: uppercase;
-  letter-spacing: 0.16em;
-  color: var(--agml-muted);
+  padding: 0.15rem 0.5rem;
+  border-radius: 4px;
+  display: inline-block;
+  white-space: nowrap;
 }
 
-.cardDetailValue {
-  font-size: 0.92rem;
-  color: var(--agml-text);
-  font-weight: 600;
+.badgeClassification {
+  background: var(--agml-badge-classification-bg);
+  color: var(--agml-badge-classification-fg);
+}
+
+.badgeDetection {
+  background: var(--agml-badge-detection-bg);
+  color: var(--agml-badge-detection-fg);
+}
+
+.badgeSegmentation {
+  background: var(--agml-badge-segmentation-bg);
+  color: var(--agml-badge-segmentation-fg);
+}
+
+.badgeOther {
+  background: var(--agml-badge-other-bg);
+  color: var(--agml-badge-other-fg);
 }
 
-.codeBadge {
+.tag {
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.68rem;
+  padding: 0.15rem 0.5rem;
+  border-radius: 4px;
   display: inline-block;
-  padding: 0.25rem 0.6rem;
-  border-radius: 12px;
-  background: rgba(25, 45, 33, 0.08);
-  font-family: 'Source Code Pro', monospace;
-  font-size: 0.85rem;
+  white-space: nowrap;
+  background: var(--agml-tag-bg);
+  color: var(--agml-tag-fg);
 }
 
-.cardTags {
+.cardFooter {
   display: flex;
-  flex-wrap: wrap;
-  gap: 0.45rem;
-  margin-top: 0.7rem;
+  flex-direction: column;
+  gap: 0.3rem;
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.72rem;
+  color: var(--agml-muted);
+  padding-top: 0.6rem;
+  border-top: 1px solid var(--agml-border);
 }
 
-.cardMeta {
-  margin: 0.7rem 0 0;
-  color: #4a5f52;
-  font-size: 0.85rem;
+.cardFooterRow {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+  gap: 0.5rem;
+}
+
+.cardFooterAugmented {
+  color: var(--ifm-color-primary);
 }
 
 .status {
@@ -489,17 +261,16 @@
 .loadMore {
   display: flex;
   justify-content: center;
-  margin-top: 2rem;
+  margin-top: 1.75rem;
 }
 
 .loadMoreButton {
   border-radius: 999px;
-  padding: 0.7rem 1.4rem;
+  padding: 0.6rem 1.3rem;
   border: 1px solid var(--ifm-color-primary);
   background: var(--ifm-color-primary);
-  color: #fff;
+  color: var(--agml-page-bg);
   font-weight: 600;
-  box-shadow: var(--agml-shadow);
   cursor: pointer;
 }
 
@@ -508,49 +279,14 @@
   border-color: var(--ifm-color-primary-dark);
 }
 
-.loadMoreButton:focus-visible {
-  outline: none;
-  box-shadow: 0 0 0 4px rgba(45, 139, 91, 0.25), var(--agml-shadow);
-}
-
-html[data-theme='dark'] .page::before {
-  opacity: 0.25;
-}
-
-html[data-theme='dark'] .page::after {
-  opacity: 0.2;
-}
-
-html[data-theme='dark'] .dropdownOptionSelected {
-  color: var(--ifm-color-primary-lightest);
-}
-
-html[data-theme='dark'] .chipActive {
-  background: var(--agml-accent-soft);
-  color: var(--ifm-color-primary);
-  border-color: var(--agml-accent-border);
-}
-
-html[data-theme='dark'] .activeChip {
-  background: var(--agml-accent-soft);
-  color: var(--ifm-color-primary);
-  border: 1px solid var(--agml-accent-border);
-}
-
-html[data-theme='dark'] .toggle input {
-  accent-color: var(--ifm-color-primary-light);
-}
-
 @media (max-width: 996px) {
-  .hero {
-    padding: 2rem 1.6rem;
-  }
-
-  .controls {
-    padding: 1.2rem 1.5rem;
+  .body {
+    flex-direction: column;
   }
 
-  .heroStats {
-    grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
+  .sidebar {
+    width: 100%;
+    border-right: none;
+    border-bottom: 1px solid var(--agml-border);
   }
 }
diff --git a/src/pages/datasets/index.tsx b/src/pages/datasets/index.tsx
index b866d3a..a3e71da 100644
--- a/src/pages/datasets/index.tsx
+++ b/src/pages/datasets/index.tsx
@@ -2,12 +2,11 @@ import { useCallback, useDeferredValue, useEffect, useMemo, useRef, useState } f
 import Layout from '@theme/Layout';
 import { useHistory, useLocation } from '@docusaurus/router';
 import { DatasetMetadataModal } from '../../components/DatasetMetadataModal';
+import { MultiSelectDropdown } from '../../components/MultiSelectDropdown';
 import styles from './index.module.css';
-import { filterDatasets, formatDisplayLocation, useDatasets } from '../../lib/datasets';
+import { computeDatasetStats, filterDatasets, formatDisplayLocation, useDatasets } from '../../lib/datasets';
 
-const CHIP_CLASSES = `${styles.chip} ${styles.chipBase}`;
-
-type FilterKind = 'dropdown' | 'chips';
+type FilterKind = 'checkbox' | 'dropdown';
 
 type DatasetFilterConfig = {
   key: string;
@@ -15,46 +14,27 @@ type DatasetFilterConfig = {
   field: keyof import('../../lib/datasets').Dataset;
   kind: FilterKind;
   formatOption?: (value: string) => string;
-  chipLabel?: string;
   mode?: 'exact' | 'containsAny';
 };
 
 const DATASET_FILTERS: DatasetFilterConfig[] = [
   {
     key: 'ml_task',
-    label: 'Task',
-    chipLabel: 'Task',
+    label: 'Task Type',
     field: 'machine_learning_task',
-    kind: 'chips',
+    kind: 'checkbox',
     formatOption: (value) => value.replace(/_/g, ' '),
   },
   {
     key: 'ag_task',
-    label: 'Ag task',
+    label: 'Agricultural Task',
     field: 'agricultural_task',
     kind: 'dropdown',
     formatOption: (value) => value.replace(/_/g, ' '),
   },
-  {
-    key: 'environment',
-    label: 'Environment',
-    chipLabel: 'Environment',
-    field: 'environment',
-    kind: 'chips',
-    formatOption: (value) => value.charAt(0).toUpperCase() + value.slice(1),
-  },
-  {
-    key: 'augmented_counterpart',
-    label: 'Augmented counterpart',
-    chipLabel: 'Augmented',
-    field: 'augmented_counterpart',
-    kind: 'chips',
-    formatOption: (value) => (value === 'yes' ? 'Yes' : 'No'),
-  },
   {
     key: 'crop_types',
-    label: 'Crop type',
-    chipLabel: 'Crop type',
+    label: 'Crop',
     field: 'crop_types',
     kind: 'dropdown',
     mode: 'containsAny',
@@ -63,12 +43,18 @@ const DATASET_FILTERS: DatasetFilterConfig[] = [
   {
     key: 'location',
     label: 'Location',
-    chipLabel: 'Location',
     field: 'location',
     kind: 'dropdown',
     mode: 'containsAny',
     formatOption: (value) => value,
   },
+  {
+    key: 'environment',
+    label: 'Environment',
+    field: 'environment',
+    kind: 'checkbox',
+    formatOption: (value) => value.charAt(0).toUpperCase() + value.slice(1),
+  },
   {
     key: 'platform',
     label: 'Platform',
@@ -78,22 +64,22 @@ const DATASET_FILTERS: DatasetFilterConfig[] = [
   },
   {
     key: 'real',
-    label: 'Data',
-    chipLabel: 'Data',
+    label: 'Data Type',
     field: 'real_or_synthetic',
-    kind: 'chips',
+    kind: 'checkbox',
     formatOption: (value) => value,
   },
+  {
+    key: 'augmented_counterpart',
+    label: 'Augmented',
+    field: 'augmented_counterpart',
+    kind: 'checkbox',
+    formatOption: (value) => (value === 'yes' ? 'Yes' : 'No'),
+  },
 ];
 
 type FilterKey = (typeof DATASET_FILTERS)[number]['key'];
 
-type ActiveFilterChip = {
-  key: FilterKey;
-  value: string;
-  label: string;
-};
-
 function toLabel(value: string) {
   return value.replace(/_/g, ' ');
 }
@@ -115,6 +101,28 @@ function formatImageCount(count: number | null) {
   return count.toLocaleString();
 }
 
+function formatBytesDecimal(bytes: number | null | undefined) {
+  if (bytes == null || !Number.isFinite(bytes) || bytes < 0) return null;
+  const units = ['B', 'kB', 'MB', 'GB', 'TB'];
+  let value = bytes;
+  let unitIndex = 0;
+  while (value >= 1000 && unitIndex < units.length - 1) {
+    value /= 1000;
+    unitIndex += 1;
+  }
+  const formatted = value >= 100 ? Math.round(value).toString() : value.toFixed(1);
+  const trimmed = formatted.endsWith('.0') ? formatted.slice(0, -2) : formatted;
+  return `${trimmed} ${units[unitIndex]}`;
+}
+
+function taskBadgeClass(task: string | null): string {
+  if (!task) return styles.badgeOther;
+  if (task.includes('classif')) return styles.badgeClassification;
+  if (task.includes('detect')) return styles.badgeDetection;
+  if (task.includes('segment')) return styles.badgeSegmentation;
+  return styles.badgeOther;
+}
+
 function getFilterValues(
   datasets: import('../../lib/datasets').Dataset[],
   field: keyof import('../../lib/datasets').Dataset
@@ -128,106 +136,40 @@ function getFilterValues(
   return Array.from(new Set(values)).sort((a, b) => a.localeCompare(b));
 }
 
-function MultiSelectDropdown({
+function CheckboxFilterGroup({
   label,
   options,
   selected,
   onToggle,
   formatOption = (value: string) => value.replace(/_/g, ' '),
+  counts,
 }: {
   label: string;
   options: string[];
   selected: string[];
   onToggle: (value: string) => void;
   formatOption?: (value: string) => string;
+  counts: Record<string, number>;
 }) {
-  const [open, setOpen] = useState(false);
-  const [focusedIndex, setFocusedIndex] = useState(0);
-
-  useEffect(() => {
-    const handler = (event: MouseEvent) => {
-      const target = event.target as HTMLElement;
-      if (!target.closest(`[data-dropdown=\"${label}\"]`)) setOpen(false);
-    };
-    document.addEventListener('click', handler);
-    return () => document.removeEventListener('click', handler);
-  }, [label]);
-
-  const onKeyDown = (event: React.KeyboardEvent) => {
-    if (!open) {
-      if (event.key === 'Enter' || event.key === ' ' || event.key === 'ArrowDown') {
-        event.preventDefault();
-        setOpen(true);
-      }
-      return;
-    }
-
-    switch (event.key) {
-      case 'Escape':
-        event.preventDefault();
-        setOpen(false);
-        break;
-      case 'ArrowDown':
-        event.preventDefault();
-        setFocusedIndex((index) => (index + 1) % options.length);
-        break;
-      case 'ArrowUp':
-        event.preventDefault();
-        setFocusedIndex((index) => (index - 1 + options.length) % options.length);
-        break;
-      case 'Enter':
-      case ' ':
-        event.preventDefault();
-        if (options[focusedIndex] != null) onToggle(options[focusedIndex]);
-        break;
-      default:
-        break;
-    }
-  };
-
   return (
-    <div className={styles.dropdown} data-dropdown={label}>
-      <label className={styles.dropdownLabel}>{label}</label>
-      <button
-        type="button"
-        onClick={() => setOpen((value) => !value)}
-        onKeyDown={onKeyDown}
-        aria-expanded={open}
-        className={styles.dropdownTrigger}
-      >
-        <span>
-          {selected.length === 0
-            ? 'All'
-            : selected.length === 1
-              ? formatOption(selected[0])
-              : `${selected.length} selected`}
-        </span>
-        <span className={styles.dropdownChevron} aria-hidden>
-          ▾
-        </span>
-      </button>
-      {open && (
-        <div className={styles.dropdownMenu} role="listbox" aria-multiselectable="true">
-          {options.map((option, index) => {
-            const isSelected = selected.includes(option);
-            return (
-              <button
-                key={option}
-                type="button"
-                className={`${styles.dropdownOption} ${isSelected ? styles.dropdownOptionSelected : ''}`}
-                onClick={() => onToggle(option)}
-                onKeyDown={onKeyDown}
-                onFocus={() => setFocusedIndex(index)}
-              >
-                <span className={styles.dropdownCheckbox} aria-hidden>
-                  {isSelected ? '✓' : ''}
-                </span>
-                {formatOption(option)}
-              </button>
-            );
-          })}
-        </div>
-      )}
+    <div className={styles.filterGroup}>
+      <p className={styles.filterGroupLabel}>{label}</p>
+      <div className={styles.filterGroupOptions}>
+        {options.map((option) => (
+          <label key={option} className={styles.checkboxRow}>
+            <span className={styles.checkboxRowLeft}>
+              <input
+                type="checkbox"
+                className={styles.checkbox}
+                checked={selected.includes(option)}
+                onChange={() => onToggle(option)}
+              />
+              <span>{formatOption(option)}</span>
+            </span>
+            <span className={styles.checkboxCount}>{counts[option] ?? 0}</span>
+          </label>
+        ))}
+      </div>
     </div>
   );
 }
@@ -239,8 +181,20 @@ function DatasetCard({
   dataset: import('../../lib/datasets').Dataset;
   onOpen: (trigger: HTMLButtonElement) => void;
 }) {
-  const { name, machine_learning_task, agricultural_task, num_images, location } = dataset;
-  const mainTask = machine_learning_task || agricultural_task;
+  const {
+    name,
+    machine_learning_task,
+    agricultural_task,
+    num_images,
+    zip_size_bytes,
+    augmented_num_images,
+    augmented_zip_size_bytes,
+    location,
+  } = dataset;
+  const fileSize = formatBytesDecimal(zip_size_bytes);
+  const augmentedFileSize = formatBytesDecimal(augmented_zip_size_bytes);
+  const hasAugmented = augmented_num_images != null;
+
   return (
     <button
       type="button"
@@ -252,21 +206,26 @@ function DatasetCard({
         <h2 className={styles.cardTitle}>
           <span className={styles.cardTitleLink}>{toTitle(name)}</span>
         </h2>
-        <div className={styles.cardDetails}>
-          <div className={styles.cardDetail}>
-            <span className={styles.cardDetailLabel}>Main task</span>
-            <span className={styles.cardDetailValue}>
-              {mainTask ? toLabel(mainTask) : 'Unknown'}
+        <div className={styles.cardTags}>
+          {machine_learning_task && (
+            <span className={`${styles.taskBadge} ${taskBadgeClass(machine_learning_task)}`}>
+              {toLabel(machine_learning_task)}
             </span>
+          )}
+          {agricultural_task && <span className={styles.tag}>{toLabel(agricultural_task)}</span>}
+          {location && <span className={styles.tag}>{formatDisplayLocation(location)}</span>}
+        </div>
+        <div className={styles.cardFooter}>
+          <div className={styles.cardFooterRow}>
+            <span>{formatImageCount(num_images)} images</span>
+            {fileSize && <span>{fileSize}</span>}
           </div>
-          <div className={styles.cardDetail}>
-            <span className={styles.cardDetailLabel}>Images</span>
-            <span className={styles.cardDetailValue}>{formatImageCount(num_images)}</span>
-          </div>
-          <div className={styles.cardDetail}>
-            <span className={styles.cardDetailLabel}>Location</span>
-            <span className={styles.cardDetailValue}>{formatDisplayLocation(location)}</span>
-          </div>
+          {hasAugmented && (
+            <div className={`${styles.cardFooterRow} ${styles.cardFooterAugmented}`}>
+              <span>augmented: {formatImageCount(augmented_num_images)} images</span>
+              {augmentedFileSize && <span>{augmentedFileSize}</span>}
+            </div>
+          )}
         </div>
       </div>
     </button>
@@ -295,8 +254,6 @@ export default function DatasetBrowserPage() {
     return next;
   }, [searchParams]);
 
-  const activeFilterCount = DATASET_FILTERS.reduce((count, filter) => count + selections[filter.key].length, 0);
-
   const setSearchParams = useCallback(
     (updater: (params: URLSearchParams) => URLSearchParams, replace = true) => {
       const currentSearch = location.search.startsWith('?')
@@ -339,17 +296,7 @@ export default function DatasetBrowserPage() {
     });
   };
 
-  const removeFilterValue = (key: string, value: string) => {
-    setSearchParams((prev) => {
-      const current = prev.getAll(key);
-      const rest = current.filter((v) => v !== value);
-      const nextParams = new URLSearchParams(prev);
-      nextParams.delete(key);
-      rest.forEach((v) => nextParams.append(key, v));
-      return nextParams;
-    });
-  };
-
+  const activeFilterCount = DATASET_FILTERS.reduce((count, filter) => count + selections[filter.key].length, 0);
   const hasActiveFilters = Boolean(qDeferred || activeFilterCount);
 
   const clearFilters = () => {
@@ -358,11 +305,34 @@ export default function DatasetBrowserPage() {
   };
 
   const safeData = Array.isArray(data) ? data : [];
+  const stats = useMemo(() => computeDatasetStats(safeData), [safeData]);
   const filterOptions = useMemo(
     () =>
       Object.fromEntries(DATASET_FILTERS.map((filter) => [filter.key, getFilterValues(safeData, filter.field)])) as Record<FilterKey, string[]>,
     [safeData]
   );
+  const filterCounts = useMemo(
+    () =>
+      Object.fromEntries(
+        DATASET_FILTERS.map((filter) => [
+          filter.key,
+          Object.fromEntries(
+            filterOptions[filter.key].map((value) => [
+              value,
+              new Set(
+                safeData
+                  .filter((dataset) => {
+                    const fieldValue = dataset[filter.field] as string | string[] | null | undefined;
+                    return Array.isArray(fieldValue) ? fieldValue.includes(value) : fieldValue === value;
+                  })
+                  .map((dataset) => dataset.parent_dataset ?? dataset.name)
+              ).size,
+            ])
+          ),
+        ])
+      ) as Record<FilterKey, Record<string, number>>,
+    [safeData, filterOptions]
+  );
 
   const filtered = useMemo(
     () =>
@@ -377,28 +347,27 @@ export default function DatasetBrowserPage() {
     [safeData, qDeferred, selections]
   );
 
-  const taskTypes = filterOptions.ml_task.length;
-
   const INITIAL_SHOW = 60;
   const [showCount, setShowCount] = useState(INITIAL_SHOW);
   const [selectedDatasetName, setSelectedDatasetName] = useState<string | null>(null);
+
+  // Supports deep links like /datasets?dataset=<name> (e.g. from the leaderboard's
+  // "view dataset" link) by opening that dataset's modal once its data has loaded.
+  const datasetParam = searchParams.get('dataset');
+  useEffect(() => {
+    if (datasetParam) setSelectedDatasetName(datasetParam);
+  }, [datasetParam]);
+
   const displayed = useMemo(() => filtered.slice(0, showCount), [filtered, showCount]);
   const hasMore = filtered.length > showCount;
+  const distinctDatasetCount = useMemo(
+    () => new Set(filtered.map((dataset) => dataset.parent_dataset ?? dataset.name)).size,
+    [filtered]
+  );
   const selectedDataset = useMemo(
     () => safeData.find((dataset) => dataset.name === selectedDatasetName) ?? null,
     [safeData, selectedDatasetName]
   );
-  const topLevelDatasetCount = useMemo(
-    () => safeData.filter((dataset) => !dataset.parent_dataset).length,
-    [safeData]
-  );
-  const totalImageCount = useMemo(
-    () =>
-      safeData
-        .filter((dataset) => !dataset.parent_dataset && !dataset.name.startsWith('iNatAg-mini'))
-        .reduce((sum, dataset) => sum + (dataset.num_images ?? 0), 0),
-    [safeData]
-  );
 
   const openDataset = useCallback((datasetName: string, trigger: HTMLButtonElement) => {
     selectedTriggerRef.current = trigger;
@@ -418,20 +387,6 @@ export default function DatasetBrowserPage() {
     setShowCount(INITIAL_SHOW);
   }, [qDeferred, activeFilterCount]);
 
-  const activeFilterChips = useMemo(() => {
-    const list: ActiveFilterChip[] = [];
-    DATASET_FILTERS.forEach((filter) => {
-      selections[filter.key].forEach((value) => {
-        list.push({
-          key: filter.key,
-          value,
-          label: filter.formatOption ? filter.formatOption(value) : value,
-        });
-      });
-    });
-    return list;
-  }, [selections]);
-
   return (
     <Layout title="Dataset Search" description="Browse AgML datasets by task, platform, and modality.">
       <div className={styles.page}>
@@ -440,125 +395,85 @@ export default function DatasetBrowserPage() {
           open={selectedDataset != null}
           onClose={closeDataset}
         />
-        <section className={styles.hero}>
-          <div className={styles.heroContent}>
-            <p className={styles.heroTag}>AgML Dataset Hub</p>
-            <h1 className={styles.heroTitle}>Search agricultural datasets fast.</h1>
-            <p className={styles.heroSubtitle}>
-              Filter by task, crop type, environment, location, and platform. Browse the
-              AgML datasets and the new Hugging Face-backed entries in one place.
-            </p>
-            <div className={styles.heroStats}>
-              <div className={styles.heroStat}>
-                <span>{topLevelDatasetCount.toLocaleString()}</span>
-                <span>datasets</span>
-              </div>
-              <div className={styles.heroStat}>
-                <span>{totalImageCount.toLocaleString()}</span>
-                <span>images</span>
-              </div>
-              <div className={styles.heroStat}>
-                <span>{taskTypes}</span>
-                <span>task types</span>
-              </div>
-            </div>
-          </div>
-        </section>
-
-        <section className={styles.controls}>
-          <div className={styles.searchBlock}>
-            <label className={styles.searchLabel} htmlFor="dataset-search">
-              Search
-            </label>
-            <input
-              id="dataset-search"
-              type="search"
-              placeholder="Name, task, platform, location…"
-              value={qLocal}
-              onChange={(event) => setQLocal(event.target.value)}
-              className={styles.searchInput}
-            />
-          </div>
-          <div className={styles.dropdownRow}>
-            {DATASET_FILTERS.filter((filter) => filter.kind === 'dropdown').map((filter) => (
-              <MultiSelectDropdown
-                key={filter.key}
-                label={filter.label}
-                options={filterOptions[filter.key]}
-                selected={selections[filter.key]}
-                onToggle={(value) => toggleMultiFilter(filter.key, value)}
-                formatOption={filter.formatOption}
-              />
-            ))}
+
+        <div className={styles.toolbar}>
+          <input
+            id="dataset-search"
+            type="search"
+            placeholder="search datasets, tasks, crops..."
+            value={qLocal}
+            onChange={(event) => setQLocal(event.target.value)}
+            className={styles.searchInput}
+          />
+          <div className={styles.toolbarRight}>
+            <span className={styles.resultCount}>{distinctDatasetCount.toLocaleString()} datasets</span>
+            <span className={styles.resultCount}>
+              {stats.imageCount.toLocaleString()} images · {stats.taskTypeCount} task types
+            </span>
+            {hasActiveFilters && (
+              <button type="button" className={styles.clearButton} onClick={clearFilters}>
+                Clear filters
+              </button>
+            )}
           </div>
-        </section>
-
-        <section className={styles.chipsSection}>
-          {DATASET_FILTERS.filter((filter) => filter.kind === 'chips').map((filter) => (
-            <div key={filter.key} className={styles.chipGroup}>
-              <span className={styles.chipLabel}>{filter.chipLabel ?? filter.label}</span>
-              {filterOptions[filter.key].map((value) => (
-                <button
-                  key={value}
-                  type="button"
-                  onClick={() => toggleMultiFilter(filter.key, value)}
-                  className={`${CHIP_CLASSES} ${selections[filter.key].includes(value) ? styles.chipActive : styles.chipInactive}`}
-                >
-                  {filter.formatOption ? filter.formatOption(value) : value}
-                </button>
-              ))}
-            </div>
-          ))}
-        </section>
-
-        {hasActiveFilters && (
-          <section className={styles.activeFilters}>
-            <div className={styles.activeList}>
-              {activeFilterChips.map((chip) => (
-                <button
-                  key={`${chip.key}-${chip.value}`}
-                  type="button"
-                  className={styles.activeChip}
-                  onClick={() => removeFilterValue(chip.key, chip.value)}
-                >
-                  {chip.label} ×
-                </button>
-              ))}
-            </div>
-            <button type="button" className={styles.clearButton} onClick={clearFilters}>
-              Clear filters
-            </button>
-          </section>
-        )}
-
-        <section className={styles.results}>
-          {loading && <p className={styles.status}>Loading datasets…</p>}
-          {error && <p className={styles.status}>Error: {error.message}</p>}
-          {!loading && !error && (
-            <>
-              {filtered.length === 0 ? (
-                <p className={styles.status}>No datasets match the current filters.</p>
+        </div>
+
+        <div className={styles.body}>
+          <aside className={styles.sidebar}>
+            {DATASET_FILTERS.map((filter) =>
+              filter.kind === 'checkbox' ? (
+                <CheckboxFilterGroup
+                  key={filter.key}
+                  label={filter.label}
+                  options={filterOptions[filter.key]}
+                  selected={selections[filter.key]}
+                  onToggle={(value) => toggleMultiFilter(filter.key, value)}
+                  formatOption={filter.formatOption}
+                  counts={filterCounts[filter.key]}
+                />
               ) : (
-                <div className={styles.cardGrid}>
-                  {displayed.map((dataset) => (
-                    <DatasetCard key={dataset.name} dataset={dataset} onOpen={(trigger) => openDataset(dataset.name, trigger)} />
-                  ))}
-                </div>
-              )}
-              {hasMore && (
-                <div className={styles.loadMore}>
-                  <button
-                    type="button"
-                    className={styles.loadMoreButton}
-                    onClick={() => setShowCount((count) => count + INITIAL_SHOW)}
-                  >
-                    Load more results
-                  </button>
+                <div key={filter.key} className={styles.filterGroup}>
+                  <MultiSelectDropdown
+                    label={filter.label}
+                    options={filterOptions[filter.key]}
+                    selected={selections[filter.key]}
+                    onToggle={(value) => toggleMultiFilter(filter.key, value)}
+                    formatOption={filter.formatOption}
+                  />
                 </div>
-              )}
-            </>
-          )}
-        </section>
+              )
+            )}
+          </aside>
+
+          <section className={styles.results}>
+            {loading && <p className={styles.status}>Loading datasets…</p>}
+            {error && <p className={styles.status}>Error: {error.message}</p>}
+            {!loading && !error && (
+              <>
+                {filtered.length === 0 ? (
+                  <p className={styles.status}>No datasets match the current filters.</p>
+                ) : (
+                  <div className={styles.cardGrid}>
+                    {displayed.map((dataset) => (
+                      <DatasetCard key={dataset.name} dataset={dataset} onOpen={(trigger) => openDataset(dataset.name, trigger)} />
+                    ))}
+                  </div>
+                )}
+                {hasMore && (
+                  <div className={styles.loadMore}>
+                    <button
+                      type="button"
+                      className={styles.loadMoreButton}
+                      onClick={() => setShowCount((count) => count + INITIAL_SHOW)}
+                    >
+                      Load more results
+                    </button>
+                  </div>
+                )}
+              </>
+            )}
+          </section>
+        </div>
       </div>
     </Layout>
   );
diff --git a/src/pages/index.module.css b/src/pages/index.module.css
index d6d6393..71a8558 100644
--- a/src/pages/index.module.css
+++ b/src/pages/index.module.css
@@ -1,81 +1,64 @@
-/**
- * CSS files with the .module.css suffix will be treated as CSS modules
- * and scoped locally.
- */
-
-.hero {
-  position: relative;
-  overflow: hidden;
-  padding: 4.5rem 2rem 4rem;
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
-  gap: 2.5rem;
-  align-items: center;
+.page {
   background: var(--agml-page-bg);
   color: var(--agml-text);
 }
 
-.hero::before,
-.hero::after {
-  content: '';
-  position: absolute;
-  border-radius: 999px;
-  pointer-events: none;
-}
-
-.hero::before {
-  width: 420px;
-  height: 420px;
-  top: -120px;
-  left: -120px;
-  background: radial-gradient(circle at top, rgba(44, 133, 90, 0.45), transparent 70%);
-}
-
-.hero::after {
-  width: 340px;
-  height: 340px;
-  bottom: -140px;
-  right: -90px;
-  background: radial-gradient(circle at bottom, var(--agml-warning-soft), transparent 70%);
+.hero {
+  padding: 6rem 1.5rem 4rem;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  text-align: center;
+  border-bottom: 1px solid var(--agml-border);
 }
 
 .heroContent {
-  position: relative;
-  z-index: 1;
-  max-width: 520px;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  max-width: 760px;
 }
 
 .kicker {
   text-transform: uppercase;
-  letter-spacing: 0.2em;
+  letter-spacing: 0.08em;
   font-size: 0.75rem;
-  color: var(--agml-muted);
-  margin: 0 0 0.8rem;
+  font-family: var(--ifm-code-font-family);
   font-weight: 600;
+  color: var(--ifm-color-primary);
+  margin: 0 0 1.1rem;
 }
 
 .heroTitle {
-  font-size: clamp(2.4rem, 3vw, 3.6rem);
-  margin-bottom: 1rem;
+  font-size: clamp(2.2rem, 2.8vw, 2.75rem);
+  font-weight: 600;
+  letter-spacing: -0.01em;
+  line-height: 1.15;
+  margin: 0 0 1.25rem;
   color: var(--agml-text);
 }
 
 .heroSubtitle {
-  font-size: 1.05rem;
+  margin: 0 0 2.25rem;
+  font-size: 1rem;
+  line-height: 1.6;
   color: var(--agml-muted);
-  margin: 0 0 1.8rem;
+  max-width: 620px;
 }
 
 .heroActions {
   display: flex;
   flex-wrap: wrap;
-  gap: 1rem;
+  gap: 0.75rem;
+  justify-content: center;
 }
 
 .primaryButton,
 .secondaryButton {
-  border-radius: 999px;
-  padding: 0.75rem 1.6rem;
+  border-radius: 7px;
+  padding: 0.75rem 1.4rem;
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.85rem;
   font-weight: 600;
   text-decoration: none;
   display: inline-flex;
@@ -84,122 +67,229 @@
 }
 
 .primaryButton {
-  background: var(--agml-text);
-  color: #fff;
-  box-shadow: var(--agml-shadow);
+  background: var(--ifm-color-primary);
+  color: var(--agml-page-bg);
 }
 
 .secondaryButton {
   border: 1px solid var(--agml-border-strong);
   color: var(--agml-text);
-  background: var(--agml-surface);
+  background: transparent;
+}
+
+.secondaryButton:hover {
+  background: var(--agml-surface-soft);
+  color: var(--agml-text);
+  text-decoration: none;
 }
 
-.heroVisual {
+.sectionLabel {
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.7rem;
+  font-weight: 600;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  color: var(--agml-muted);
+  margin: 0 0 0.9rem;
+}
+
+.samplesSection {
+  padding: 3.5rem 1.5rem;
+  max-width: 1080px;
+  margin: 0 auto;
+}
+
+.samplesMarquee {
+  overflow: hidden;
+  -webkit-mask-image: linear-gradient(to right, transparent, #000 6%, #000 94%, transparent);
+  mask-image: linear-gradient(to right, transparent, #000 6%, #000 94%, transparent);
+  width: 100vw;
   position: relative;
-  z-index: 1;
+  left: 50%;
+  right: 50%;
+  margin-left: -50vw;
+  margin-right: -50vw;
+}
+
+.samplesTrack {
   display: flex;
-  justify-content: center;
+  gap: 1rem;
+  width: max-content;
+  animation: samplesScroll 60s linear infinite;
 }
 
-.heroVisual img {
-  max-width: 420px;
-  width: 100%;
-  border-radius: 24px;
-  border: 1px solid var(--agml-border);
-  box-shadow: var(--agml-shadow-strong);
-  background: var(--agml-surface-strong);
+.samplesTrack:hover {
+  animation-play-state: paused;
 }
 
-.main {
-  padding: 3.5rem 2rem 4rem;
-  max-width: 1100px;
-  margin: 0 auto;
+@keyframes samplesScroll {
+  from {
+    transform: translateX(-50%);
+  }
+  to {
+    transform: translateX(0);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .samplesTrack {
+    animation: none;
+  }
+}
+
+.sampleTile {
   display: flex;
   flex-direction: column;
-  gap: 2.5rem;
+  gap: 0.5rem;
+  flex: 0 0 220px;
+  width: 220px;
+}
+
+.sampleImage {
+  width: 100%;
+  aspect-ratio: 4 / 3;
+  object-fit: cover;
+  border-radius: 10px;
+  border: 1px solid var(--agml-border);
+  background: var(--agml-surface-soft);
 }
 
-.highlightGrid {
+.sampleCaption {
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.72rem;
+  color: var(--agml-muted);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.statsRow {
   display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(240px, 1fr));
-  gap: 1.5rem;
+  grid-template-columns: repeat(3, 1fr);
+  border-top: 1px solid var(--agml-border);
+  border-bottom: 1px solid var(--agml-border);
 }
 
-.highlightCard {
-  padding: 1.5rem;
-  border-radius: 20px;
-  background: var(--agml-surface-strong);
-  border: 1px solid var(--agml-border);
-  box-shadow: var(--agml-shadow);
+.statBlock {
+  padding: 2rem 1.5rem;
+  text-align: center;
+  border-right: 1px solid var(--agml-border);
 }
 
-.highlightCard h2 {
-  margin-top: 0;
-  color: var(--agml-text);
+.statBlock:last-child {
+  border-right: none;
+}
+
+.statValue {
+  display: block;
+  font-family: var(--ifm-code-font-family);
+  font-size: 2rem;
+  font-weight: 700;
+  color: var(--ifm-color-primary);
 }
 
-.highlightCard p {
-  margin-bottom: 0;
+.statLabel {
+  display: block;
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.72rem;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
   color: var(--agml-muted);
+  margin-top: 0.4rem;
 }
 
-.callout {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 1.5rem;
-  align-items: center;
-  justify-content: space-between;
-  padding: 1.8rem 2rem;
-  border-radius: 24px;
-  background: var(--agml-surface);
-  border: 1px solid var(--agml-border);
-  box-shadow: var(--agml-shadow);
-  color: var(--agml-text);
+.featuresSection {
+  padding: 4rem 1.5rem;
+  max-width: 1080px;
+  margin: 0 auto;
 }
 
-.mapSection {
+.featuresGrid {
   display: grid;
-  gap: 1.8rem;
-  align-items: center;
-  grid-template-columns: repeat(auto-fit, minmax(260px, 1fr));
+  grid-template-columns: repeat(3, 1fr);
+  gap: 1.25rem;
 }
 
-.mapImage {
-  width: 100%;
-  border-radius: 20px;
-  border: 1px solid var(--agml-border);
-  box-shadow: var(--agml-shadow);
+.featureCard {
   background: var(--agml-surface-strong);
+  border: 1px solid var(--agml-border);
+  border-radius: 10px;
+  padding: 1.4rem;
+  display: flex;
+  flex-direction: column;
+  gap: 0.6rem;
 }
 
-:global(html[data-theme='dark']) .hero::before {
-  opacity: 0.22;
+.featureTag {
+  margin: 0;
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.7rem;
+  color: var(--ifm-color-primary);
 }
 
-:global(html[data-theme='dark']) .hero::after {
-  opacity: 0.18;
+.featureTitle {
+  margin: 0;
+  font-size: 1rem;
+  font-weight: 600;
+  color: var(--agml-text);
 }
 
-:global(html[data-theme='dark']) .primaryButton {
-  background: var(--agml-accent-soft);
-  color: var(--ifm-color-primary);
-  box-shadow: none;
-  border: 1px solid var(--agml-accent-border);
+.featureBody {
+  margin: 0;
+  font-size: 0.85rem;
+  line-height: 1.55;
+  color: var(--agml-muted);
 }
 
-:global(html[data-theme='dark']) .secondaryButton {
-  background: transparent;
-  color: var(--ifm-color-primary);
-  border-color: var(--agml-accent-border);
+.calloutSection {
+  padding: 0 1.5rem 4.5rem;
+  max-width: 1080px;
+  margin: 0 auto;
+}
+
+.callout {
+  background: var(--agml-surface-soft);
+  border: 1px solid var(--agml-border);
+  border-radius: 10px;
+  padding: 1.75rem 2rem;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1.5rem;
+  flex-wrap: wrap;
+}
+
+.calloutTitle {
+  margin: 0 0 0.4rem;
+  font-size: 1rem;
+  font-weight: 600;
+  color: var(--agml-text);
+}
+
+.calloutCode {
+  margin: 0;
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.82rem;
+  color: var(--agml-muted);
+  white-space: pre;
+  overflow-x: auto;
 }
 
 @media (max-width: 996px) {
-  .hero {
-    padding: 3.5rem 1.5rem 3rem;
+  .featuresGrid {
+    grid-template-columns: 1fr;
+  }
+
+  .statsRow {
+    grid-template-columns: 1fr;
+  }
+
+  .statBlock {
+    border-right: none;
+    border-bottom: 1px solid var(--agml-border);
   }
 
-  .main {
-    padding: 3rem 1.5rem 3.5rem;
+  .statBlock:last-child {
+    border-bottom: none;
   }
 }
diff --git a/src/pages/index.tsx b/src/pages/index.tsx
index 1c73f59..360c060 100644
--- a/src/pages/index.tsx
+++ b/src/pages/index.tsx
@@ -1,4 +1,5 @@
 import type {ReactNode} from 'react';
+import { useMemo } from 'react';
 import Link from '@docusaurus/Link';
 import useBaseUrl from '@docusaurus/useBaseUrl';
 import useDocusaurusContext from '@docusaurus/useDocusaurusContext';
@@ -6,8 +7,63 @@ import Layout from '@theme/Layout';
 import Heading from '@theme/Heading';
 
 import styles from './index.module.css';
+import { computeDatasetStats, useDatasets } from '../lib/datasets';
 
-function HomepageHeader() {
+// The ~30 most recently added sample images (by commit date) — hardcoded rather than
+// picked live from useDatasets() so the homepage doesn't depend on the full dataset fetch.
+// SampleImagery scrolls this pool left-to-right as a continuous marquee.
+const SAMPLE_IMAGES = [
+  { name: 'ACHENY_variety_classification', path: '/img/agml/sample_images/ACHENY_variety_classification_sample.webp' },
+  { name: 'CocoaMFDB_detection', path: '/img/agml/sample_images/CocoaMFDB_detection_sample.webp' },
+  { name: 'Medjool_date_ripeness_classification', path: '/img/agml/sample_images/Medjool_date_ripeness_classification_sample.webp' },
+  { name: 'QuinceSet_detection', path: '/img/agml/sample_images/QuinceSet_detection_sample.webp' },
+  { name: 'citrus_fruit_leaf_disease_classification', path: '/img/agml/sample_images/citrus_fruit_leaf_disease_classification_sample.webp' },
+  { name: 'crop_weed_detection_latvia', path: '/img/agml/sample_images/crop_weed_detection_latvia_sample.webp' },
+  { name: 'fortunella_margarita_growth_detection', path: '/img/agml/sample_images/fortunella_margarita_growth_detection_sample.webp' },
+  { name: 'maize_weed_detection', path: '/img/agml/sample_images/maize_weed_detection_sample.webp' },
+  { name: 'merlot_mildew_segmentation', path: '/img/agml/sample_images/merlot_mildew_segmentation_sample.webp' },
+  { name: 'pomegranate_quality_classification', path: '/img/agml/sample_images/pomegranate_quality_classification_sample.webp' },
+  { name: 'ERWIAM_blight_detection', path: '/img/agml/sample_images/ERWIAM_blight_detection_sample.webp' },
+  { name: 'LSID_bean_segmentation', path: '/img/agml/sample_images/LSID_bean_segmentation_sample.webp' },
+  { name: 'TealeafAgeQuality_detection', path: '/img/agml/sample_images/TealeafAgeQuality_detection_sample.webp' },
+  { name: 'bean_disease_classification_tanzania', path: '/img/agml/sample_images/bean_disease_classification_tanzania_sample.webp' },
+  { name: 'fruitseg30_segmentation', path: '/img/agml/sample_images/fruitseg30_segmentation_sample.webp' },
+  { name: 'grapevine_esca_classification', path: '/img/agml/sample_images/grapevine_esca_classification_sample.webp' },
+  { name: 'maize_tomato_weed_classification', path: '/img/agml/sample_images/maize_tomato_weed_classification_sample.webp' },
+  { name: 'oil_palm_fruit_ripeness_classification', path: '/img/agml/sample_images/oil_palm_fruit_ripeness_classification_sample.webp' },
+  { name: 'onionfoliageset_detection', path: '/img/agml/sample_images/onionfoliageset_detection_sample.webp' },
+  { name: 'seasveg_classification_bd', path: '/img/agml/sample_images/seasveg_classification_bd_sample.webp' },
+  { name: 'sunflower_detection', path: '/img/agml/sample_images/sunflower_detection_sample.webp' },
+  { name: 'fresh_rotten_fruit_classification', path: '/img/agml/sample_images/fresh_rotten_fruit_classification_sample.webp' },
+  { name: 'grapevine_disease_classification', path: '/img/agml/sample_images/grapevine_disease_classification_sample.webp' },
+  { name: 'soybean_damage_classification', path: '/img/agml/sample_images/soybean_damage_classification_sample.webp' },
+  { name: 'tomato_factory_detection', path: '/img/agml/sample_images/tomato_factory_detection_sample.webp' },
+  { name: 'BDMediLeaves_variety_classification', path: '/img/agml/sample_images/BDMediLeaves_variety_classification_sample.webp' },
+  { name: 'MangoClassify-12_variety_classification', path: '/img/agml/sample_images/MangoClassify-12_variety_classification_sample.webp' },
+  { name: 'PaddyVarietyBD_variety_classification', path: '/img/agml/sample_images/PaddyVarietyBD_variety_classification_sample.webp' },
+  { name: 'date_cluster_detection', path: '/img/agml/sample_images/date_cluster_detection_sample.webp' },
+  { name: 'grape_variety_classification', path: '/img/agml/sample_images/grape_variety_classification_sample.webp' },
+];
+
+const FEATURES = [
+  {
+    tag: 'Search',
+    title: 'Dataset-first workflow',
+    body: 'Browse thousands of public datasets, filter by task, and jump directly into training with the AgML data loader.',
+  },
+  {
+    tag: 'Train',
+    title: 'TensorFlow + PyTorch ready',
+    body: 'Export loaders to native TensorFlow or PyTorch pipelines without rewriting your data preprocessing logic.',
+  },
+  {
+    tag: 'Coverage',
+    title: 'Global coverage',
+    body: 'From crop disease to detection and segmentation, AgML catalogs datasets spanning continents, crops, and sensor modalities.',
+  },
+];
+
+function HomepageHero() {
   const {siteConfig} = useDocusaurusContext();
   return (
     <header className={styles.hero}>
@@ -21,78 +77,103 @@ function HomepageHeader() {
           tasks and modalities. Start with a dataset, scale to a full pipeline.
         </p>
         <div className={styles.heroActions}>
-          <Link className={styles.primaryButton} to="/docs">
-            Read the docs
+          <Link className={styles.primaryButton} to="/datasets">
+            Search datasets
           </Link>
-          <Link className={styles.secondaryButton} to="/datasets">
-            Dataset search
+          <Link className={styles.secondaryButton} to="/leaderboard">
+            Browse leaderboard
           </Link>
         </div>
       </div>
-      <div className={styles.heroVisual}>
-        <img src={useBaseUrl('/img/agml/agml-framework.png')} alt="AgML framework diagram" />
-      </div>
     </header>
   );
 }
 
+function SampleImagery() {
+  // Rendered twice back-to-back so the track can loop seamlessly: once it has
+  // scrolled through the first copy, it's positioned exactly where the second
+  // copy begins, and the animation resets without a visible jump.
+  const track = useMemo(() => [...SAMPLE_IMAGES, ...SAMPLE_IMAGES], []);
+
+  return (
+    <section className={styles.samplesSection}>
+      <p className={styles.sectionLabel}>Sample imagery</p>
+      <div className={styles.samplesMarquee}>
+        <div className={styles.samplesTrack}>
+          {track.map((sample, index) => (
+            <div key={`${sample.name}-${index}`} className={styles.sampleTile}>
+              <img
+                src={useBaseUrl(sample.path)}
+                alt={`${sample.name} sample`}
+                className={styles.sampleImage}
+              />
+              <span className={styles.sampleCaption}>{sample.name}</span>
+            </div>
+          ))}
+        </div>
+      </div>
+    </section>
+  );
+}
+
+function StatsRow() {
+  const { data } = useDatasets();
+  const stats = useMemo(() => computeDatasetStats(data), [data]);
+
+  return (
+    <section className={styles.statsRow}>
+      <div className={styles.statBlock}>
+        <span className={styles.statValue}>{stats.datasetCount.toLocaleString()}</span>
+        <span className={styles.statLabel}>Datasets indexed</span>
+      </div>
+      <div className={styles.statBlock}>
+        <span className={styles.statValue}>{stats.imageCount.toLocaleString()}</span>
+        <span className={styles.statLabel}>Labeled images</span>
+      </div>
+      <div className={styles.statBlock}>
+        <span className={styles.statValue}>{stats.taskTypeCount.toLocaleString()}</span>
+        <span className={styles.statLabel}>CV task types</span>
+      </div>
+    </section>
+  );
+}
+
 export default function Home(): ReactNode {
   return (
     <Layout description="AgML is a comprehensive library for agricultural machine learning.">
-      <HomepageHeader />
-      <main className={styles.main}>
-        <section className={styles.highlightGrid}>
-          <article className={styles.highlightCard}>
-            <h2>Dataset-first workflow</h2>
-            <p>
-              Browse thousands of public datasets, filter by task, and jump directly into training
-              with the AgML data loader.
-            </p>
-          </article>
-          <article className={styles.highlightCard}>
-            <h2>TensorFlow + PyTorch ready</h2>
-            <p>
-              Export loaders to native TensorFlow or PyTorch pipelines without rewriting your data
-              preprocessing logic.
-            </p>
-          </article>
-          <article className={styles.highlightCard}>
-            <h2>Global coverage</h2>
-            <p>
-              From crop disease to detection and segmentation, AgML catalogs datasets spanning
-              continents, crops, and sensor modalities.
-            </p>
-          </article>
-        </section>
+      <div className={styles.page}>
+        <HomepageHero />
+        <SampleImagery />
+        <StatsRow />
 
-        <section className={styles.callout}>
-          <div>
-            <h2>Find the right dataset in minutes</h2>
-            <p>
-              Use the new dataset search page to filter by task, platform, and modality, then dive
-              into detailed dataset docs in one click.
-            </p>
+        <section className={styles.featuresSection}>
+          <p className={styles.sectionLabel}>What AgML offers</p>
+          <div className={styles.featuresGrid}>
+            {FEATURES.map((feature) => (
+              <article key={feature.title} className={styles.featureCard}>
+                <p className={styles.featureTag}>{feature.tag}</p>
+                <h2 className={styles.featureTitle}>{feature.title}</h2>
+                <p className={styles.featureBody}>{feature.body}</p>
+              </article>
+            ))}
           </div>
-          <Link className={styles.primaryButton} to="/datasets">
-            Explore datasets
-          </Link>
         </section>
 
-        <section className={styles.mapSection}>
-          <div>
-            <h2>See AgML on the map</h2>
-            <p>
-              AgML datasets span a global network of agricultural research efforts. Track coverage
-              and discover new sources from every region.
-            </p>
+        <section className={styles.calloutSection}>
+          <div className={styles.callout}>
+            <div>
+              <h2 className={styles.calloutTitle}>Load any dataset in one line</h2>
+              <pre className={styles.calloutCode}>
+                {'from agml.data.hf_loader import HuggingFaceDataLoader\n'}
+                {'loader = HuggingFaceDataLoader("Project-AgML/apple_flower_segmentation")'}
+              </pre>
+            </div>
+            <Link className={styles.secondaryButton} to="/docs">
+              Read the docs
+            </Link>
           </div>
-          <img
-            src={useBaseUrl('/img/agml/agml_dataset_world_map.png')}
-            alt="AgML dataset world map"
-            className={styles.mapImage}
-          />
         </section>
-      </main>
+      </div>
     </Layout>
   );
 }
diff --git a/src/pages/leaderboard/index.module.css b/src/pages/leaderboard/index.module.css
new file mode 100644
index 0000000..a87caf8
--- /dev/null
+++ b/src/pages/leaderboard/index.module.css
@@ -0,0 +1,336 @@
+.page {
+  background: var(--agml-page-bg);
+  color: var(--agml-text);
+  min-height: calc(100vh - 60px);
+  display: flex;
+  flex-direction: column;
+}
+
+.toolbar {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+  padding: 0.9rem 1.5rem;
+  border-bottom: 1px solid var(--agml-border);
+  background: var(--agml-surface);
+}
+
+.searchInput {
+  flex: 1;
+  max-width: 480px;
+  border-radius: 6px;
+  border: 1px solid var(--agml-border-strong);
+  background: var(--agml-surface-strong);
+  padding: 0.55rem 0.8rem;
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.85rem;
+  color: var(--agml-text);
+}
+
+.searchInput:focus {
+  outline: none;
+  border-color: var(--ifm-color-primary);
+  box-shadow: 0 0 0 3px var(--agml-accent-soft);
+}
+
+.toolbarRight {
+  margin-left: auto;
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+}
+
+.resultCount {
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.78rem;
+  color: var(--agml-muted);
+  white-space: nowrap;
+}
+
+.clearButton {
+  border: 1px solid var(--agml-border-strong);
+  background: transparent;
+  border-radius: 999px;
+  padding: 0.4rem 0.9rem;
+  font-size: 0.8rem;
+  color: var(--agml-text);
+  cursor: pointer;
+  white-space: nowrap;
+}
+
+.body {
+  flex: 1;
+  display: flex;
+  min-height: 0;
+}
+
+.sidebar {
+  width: 240px;
+  flex-shrink: 0;
+  border-right: 1px solid var(--agml-border);
+  background: var(--agml-surface-soft);
+  padding: 1.25rem 1.1rem;
+  overflow-y: auto;
+}
+
+.filterGroup {
+  margin-bottom: 1.6rem;
+}
+
+.filterGroupLabel {
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.68rem;
+  font-weight: 600;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--agml-muted);
+  margin: 0 0 0.7rem;
+}
+
+.filterGroupOptions {
+  display: flex;
+  flex-direction: column;
+  gap: 0.55rem;
+}
+
+.checkboxRow {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  font-size: 0.82rem;
+  cursor: pointer;
+  color: var(--agml-text);
+}
+
+.checkbox {
+  appearance: none;
+  -webkit-appearance: none;
+  width: 16px;
+  height: 16px;
+  flex-shrink: 0;
+  border-radius: 4px;
+  border: 1.5px solid var(--agml-border-strong);
+  background: var(--agml-page-bg);
+  position: relative;
+  cursor: pointer;
+  transition: background 0.12s, border-color 0.12s;
+}
+
+.checkbox:hover {
+  border-color: var(--agml-muted);
+}
+
+.checkbox:checked {
+  background: var(--ifm-color-primary);
+  border-color: var(--ifm-color-primary);
+}
+
+.checkbox::after {
+  content: '';
+  position: absolute;
+  left: 4px;
+  top: 1px;
+  width: 4px;
+  height: 8px;
+  border-style: solid;
+  border-width: 0 2px 2px 0;
+  border-color: var(--agml-page-bg);
+  transform: rotate(45deg);
+  opacity: 0;
+}
+
+.checkbox:checked::after {
+  opacity: 1;
+}
+
+.results {
+  flex: 1;
+  overflow: auto;
+  padding: 1.5rem;
+}
+
+.status {
+  color: var(--agml-muted);
+}
+
+.tableWrap {
+  border: 1px solid var(--agml-border);
+  border-radius: 8px;
+  overflow-x: auto;
+}
+
+.leaderboardTable {
+  width: 100%;
+  min-width: 980px;
+  font-size: 0.85rem;
+}
+
+.tableRow {
+  display: grid;
+  grid-template-columns:
+    minmax(100px, 1.1fr) minmax(200px, 2.4fr) minmax(120px, 1.1fr) minmax(120px, 1.1fr)
+    minmax(120px, 1.1fr) minmax(120px, 1.1fr) minmax(90px, 0.8fr) minmax(78px, 0.4fr);
+  gap: 0.6rem;
+  align-items: center;
+}
+
+.tableRow[role='row']:first-child {
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.66rem;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  color: var(--agml-muted);
+  background: var(--agml-tag-bg);
+  padding: 0.5rem 0.85rem;
+}
+
+.tableRow:not(:first-child) {
+  padding: 0.65rem 0.85rem;
+  border-top: 1px solid var(--agml-border);
+}
+
+.tableRow [role='cell'],
+.tableRow [role='columnheader'] {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.sortHeader {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.3rem;
+  width: 100%;
+  background: none;
+  border: none;
+  padding: 0;
+  cursor: pointer;
+  font-family: inherit;
+  font-size: inherit;
+  text-transform: inherit;
+  letter-spacing: inherit;
+  color: inherit;
+  text-align: left;
+}
+
+.sortHeaderActive {
+  color: var(--ifm-color-primary);
+}
+
+.clickableRow {
+  cursor: pointer;
+}
+
+.clickableRow:hover {
+  background: var(--agml-accent-soft);
+}
+
+.modelName {
+  font-family: var(--ifm-code-font-family);
+  font-weight: 500;
+  color: var(--agml-text);
+  text-decoration: underline dashed var(--agml-muted);
+  text-decoration-thickness: 1px;
+  text-underline-offset: 3px;
+}
+
+.taskBadge {
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.68rem;
+  padding: 0.15rem 0.5rem;
+  border-radius: 4px;
+  display: inline-block;
+  white-space: nowrap;
+}
+
+.badgeClassification {
+  background: var(--agml-badge-classification-bg);
+  color: var(--agml-badge-classification-fg);
+}
+
+.badgeDetection {
+  background: var(--agml-badge-detection-bg);
+  color: var(--agml-badge-detection-fg);
+}
+
+.badgeSegmentation {
+  background: var(--agml-badge-segmentation-bg);
+  color: var(--agml-badge-segmentation-fg);
+}
+
+.badgeOther {
+  background: var(--agml-badge-other-bg);
+  color: var(--agml-badge-other-fg);
+}
+
+.metricCell {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  min-width: 110px;
+}
+
+.metricBarTrack {
+  flex: 1;
+  height: 6px;
+  border-radius: 3px;
+  background: var(--agml-surface-soft);
+  overflow: hidden;
+}
+
+.metricBarFill {
+  height: 100%;
+  background: var(--ifm-color-primary);
+}
+
+.metricLabel {
+  font-family: var(--ifm-code-font-family);
+  font-size: 0.72rem;
+  color: var(--agml-muted);
+  flex-shrink: 0;
+}
+
+.metricEmpty {
+  color: var(--agml-muted);
+}
+
+.pagination {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 1rem;
+  margin-top: 1.5rem;
+}
+
+.paginationButton {
+  border: 1px solid var(--agml-border-strong);
+  background: var(--agml-surface-strong);
+  border-radius: 999px;
+  padding: 0.5rem 1.1rem;
+  font-size: 0.85rem;
+  color: var(--agml-text);
+  cursor: pointer;
+}
+
+.paginationButton:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.paginationStatus {
+  font-size: 0.82rem;
+  color: var(--agml-muted);
+}
+
+@media (max-width: 996px) {
+  .body {
+    flex-direction: column;
+  }
+
+  .sidebar {
+    width: 100%;
+    border-right: none;
+    border-bottom: 1px solid var(--agml-border);
+  }
+}
diff --git a/src/pages/leaderboard/index.tsx b/src/pages/leaderboard/index.tsx
new file mode 100644
index 0000000..5f3b539
--- /dev/null
+++ b/src/pages/leaderboard/index.tsx
@@ -0,0 +1,348 @@
+import { useDeferredValue, useEffect, useMemo, useState } from 'react';
+import Layout from '@theme/Layout';
+import {
+  computeGlobalLeaderboard,
+  useGlobalPerformance,
+} from '../../lib/performance';
+import type { GlobalLeaderboardEntry } from '../../lib/performance';
+import { MultiSelectDropdown } from '../../components/MultiSelectDropdown';
+import { LeaderboardDetailModal } from '../../components/LeaderboardDetailModal';
+import styles from './index.module.css';
+
+const MIN_APPEARANCES = 3;
+const PAGE_SIZE = 25;
+
+type SortField = 'f1' | 'map' | 'precision' | 'recall';
+
+function toLabel(value: string) {
+  return value.replace(/_/g, ' ');
+}
+
+function shortTaskLabel(value: string) {
+  const lower = value.toLowerCase();
+  if (lower.includes('classif')) return 'Classification';
+  if (lower.includes('detect')) return 'Detection';
+  if (lower.includes('segment')) return 'Segmentation';
+  return toLabel(value);
+}
+
+function percentileValue(entry: GlobalLeaderboardEntry, field: SortField) {
+  switch (field) {
+    case 'f1':
+      return entry.avgF1Percentile;
+    case 'map':
+      return entry.avgMapPercentile;
+    case 'precision':
+      return entry.avgPrecisionPercentile;
+    case 'recall':
+      return entry.avgRecallPercentile;
+  }
+}
+
+function taskBadgeClass(task: string | null): string {
+  if (!task) return styles.badgeOther;
+  if (task.includes('classif')) return styles.badgeClassification;
+  if (task.includes('detect')) return styles.badgeDetection;
+  if (task.includes('segment')) return styles.badgeSegmentation;
+  return styles.badgeOther;
+}
+
+function CheckboxFilterGroup({
+  label,
+  options,
+  selected,
+  onToggle,
+  formatOption = (value: string) => value,
+}: {
+  label: string;
+  options: string[];
+  selected: string[];
+  onToggle: (value: string) => void;
+  formatOption?: (value: string) => string;
+}) {
+  return (
+    <div className={styles.filterGroup}>
+      <p className={styles.filterGroupLabel}>{label}</p>
+      <div className={styles.filterGroupOptions}>
+        {options.map((option) => (
+          <label key={option} className={styles.checkboxRow}>
+            <input
+              type="checkbox"
+              className={styles.checkbox}
+              checked={selected.includes(option)}
+              onChange={() => onToggle(option)}
+            />
+            <span>{formatOption(option)}</span>
+          </label>
+        ))}
+      </div>
+    </div>
+  );
+}
+
+function PercentileCell({ value }: { value: number | null }) {
+  if (value == null) {
+    return <span className={styles.metricEmpty}>—</span>;
+  }
+  return (
+    <div className={styles.metricCell}>
+      <div className={styles.metricBarTrack}>
+        <div className={styles.metricBarFill} style={{ width: `${value}%` }} />
+      </div>
+      <span className={styles.metricLabel}>{value.toFixed(0)}th</span>
+    </div>
+  );
+}
+
+export default function GlobalLeaderboardPage() {
+  const { data: records, loading, error } = useGlobalPerformance();
+
+  const [search, setSearch] = useState('');
+  const searchDeferred = useDeferredValue(search);
+  const [cropTypes, setCropTypes] = useState<string[]>([]);
+  const [mlTasks, setMlTasks] = useState<string[]>([]);
+  const [tuned, setTuned] = useState<('tuned' | 'not-tuned')[]>([]);
+  const [optimizedValues, setOptimizedValues] = useState<('optimized' | 'not-optimized')[]>([]);
+  const [platforms, setPlatforms] = useState<string[]>([]);
+  const [sortBy, setSortBy] = useState<SortField>('map');
+
+  const { cropTypeOptions, mlTaskOptions, platformOptions } = useMemo(() => {
+    const cropSet = new Set<string>();
+    const taskSet = new Set<string>();
+    const platformSet = new Set<string>();
+    for (const record of records) {
+      record.crop_types?.forEach((crop) => cropSet.add(crop));
+      if (record.machine_learning_task) taskSet.add(record.machine_learning_task);
+      if (record.platform) platformSet.add(record.platform);
+    }
+    return {
+      cropTypeOptions: Array.from(cropSet).sort((a, b) => a.localeCompare(b)),
+      mlTaskOptions: Array.from(taskSet).sort((a, b) => a.localeCompare(b)),
+      platformOptions: Array.from(platformSet).sort((a, b) => a.localeCompare(b)),
+    };
+  }, [records]);
+
+  const toggleValue = <T,>(setter: (updater: (current: T[]) => T[]) => void, value: T) => {
+    setter((current) => (current.includes(value) ? current.filter((v) => v !== value) : [...current, value]));
+  };
+
+  const hasActiveFilters =
+    cropTypes.length > 0 || mlTasks.length > 0 || tuned.length > 0 || optimizedValues.length > 0 || platforms.length > 0;
+  const clearFilters = () => {
+    setCropTypes([]);
+    setMlTasks([]);
+    setTuned([]);
+    setOptimizedValues([]);
+    setPlatforms([]);
+  };
+
+  const leaderboard = useMemo(
+    () =>
+      computeGlobalLeaderboard(records, {
+        cropTypes,
+        mlTasks,
+        tuned,
+        optimizedValues,
+        platforms,
+        minAppearances: MIN_APPEARANCES,
+      }),
+    [records, cropTypes, mlTasks, tuned, optimizedValues, platforms]
+  );
+
+  const searched = useMemo(() => {
+    const q = searchDeferred.trim().toLowerCase();
+    if (!q) return leaderboard;
+    return leaderboard.filter(
+      (entry) =>
+        entry.model.toLowerCase().includes(q) ||
+        (entry.machineLearningTask ?? '').toLowerCase().includes(q) ||
+        entry.datasets.some((dataset) => dataset.toLowerCase().includes(q))
+    );
+  }, [leaderboard, searchDeferred]);
+
+  const sorted = useMemo(
+    () =>
+      [...searched].sort((a, b) => (percentileValue(b, sortBy) ?? -1) - (percentileValue(a, sortBy) ?? -1)),
+    [searched, sortBy]
+  );
+
+  const [page, setPage] = useState(1);
+  useEffect(() => setPage(1), [cropTypes, mlTasks, tuned, optimizedValues, platforms, searchDeferred]);
+
+  const pageCount = Math.max(1, Math.ceil(sorted.length / PAGE_SIZE));
+  const currentPage = Math.min(page, pageCount);
+  const pagedLeaderboard = useMemo(
+    () => sorted.slice((currentPage - 1) * PAGE_SIZE, currentPage * PAGE_SIZE),
+    [sorted, currentPage]
+  );
+
+  const [selectedKey, setSelectedKey] = useState<string | null>(null);
+  const selectedEntry = useMemo(
+    () => sorted.find((entry) => `${entry.model}|||${entry.machineLearningTask ?? ''}` === selectedKey) ?? null,
+    [sorted, selectedKey]
+  );
+
+  const sortHeaderClass = (field: SortField) => `${styles.sortHeader} ${sortBy === field ? styles.sortHeaderActive : ''}`;
+
+  return (
+    <Layout title="Model Leaderboard" description="Global model leaderboard aggregated across AgML dataset benchmarks.">
+      <div className={styles.page}>
+        <LeaderboardDetailModal entry={selectedEntry} open={selectedEntry != null} onClose={() => setSelectedKey(null)} />
+
+        <div className={styles.toolbar}>
+          <input
+            type="search"
+            placeholder="search models, datasets, tasks..."
+            value={search}
+            onChange={(event) => setSearch(event.target.value)}
+            className={styles.searchInput}
+          />
+          <div className={styles.toolbarRight}>
+            <span className={styles.resultCount}>{sorted.length.toLocaleString()} models</span>
+            {hasActiveFilters && (
+              <button type="button" className={styles.clearButton} onClick={clearFilters}>
+                Clear filters
+              </button>
+            )}
+          </div>
+        </div>
+
+        <div className={styles.body}>
+          <aside className={styles.sidebar}>
+            <CheckboxFilterGroup label="CV Task" options={mlTaskOptions} selected={mlTasks} onToggle={(value) => toggleValue(setMlTasks, value)} formatOption={shortTaskLabel} />
+            <div className={styles.filterGroup}>
+              <MultiSelectDropdown label="Crop" options={cropTypeOptions} selected={cropTypes} onToggle={(value) => toggleValue(setCropTypes, value)} formatOption={toLabel} />
+            </div>
+            <CheckboxFilterGroup
+              label="Tuned"
+              options={['tuned', 'not-tuned']}
+              selected={tuned}
+              onToggle={(value) => toggleValue(setTuned, value as 'tuned' | 'not-tuned')}
+              formatOption={(value) => (value === 'tuned' ? 'Tuned' : 'Not tuned')}
+            />
+            <CheckboxFilterGroup
+              label="Optimized"
+              options={['optimized', 'not-optimized']}
+              selected={optimizedValues}
+              onToggle={(value) => toggleValue(setOptimizedValues, value as 'optimized' | 'not-optimized')}
+              formatOption={(value) => (value === 'optimized' ? 'Optimized' : 'Not optimized')}
+            />
+            <CheckboxFilterGroup label="Platform" options={platformOptions} selected={platforms} onToggle={(value) => toggleValue(setPlatforms, value)} formatOption={toLabel} />
+          </aside>
+
+          <section className={styles.results}>
+            {loading && <p className={styles.status}>Loading leaderboard…</p>}
+            {error && <p className={styles.status}>Error: {error.message}</p>}
+            {!loading && !error && sorted.length === 0 && (
+              <p className={styles.status}>
+                No models have at least {MIN_APPEARANCES} dataset appearances for the current filters.
+              </p>
+            )}
+            {!loading && !error && sorted.length > 0 && (
+              <>
+                <div className={styles.tableWrap}>
+                  <div className={styles.leaderboardTable} role="table">
+                    <div className={styles.tableRow} role="row">
+                      <span role="columnheader">CV Task</span>
+                      <span role="columnheader">Model</span>
+                      <span role="columnheader">
+                        <button type="button" className={sortHeaderClass('f1')} onClick={() => setSortBy('f1')}>
+                          <span>Avg F1 pctl</span>
+                          <span>{sortBy === 'f1' ? '▼' : '▾'}</span>
+                        </button>
+                      </span>
+                      <span role="columnheader">
+                        <button type="button" className={sortHeaderClass('map')} onClick={() => setSortBy('map')}>
+                          <span>Avg mAP pctl</span>
+                          <span>{sortBy === 'map' ? '▼' : '▾'}</span>
+                        </button>
+                      </span>
+                      <span role="columnheader">
+                        <button type="button" className={sortHeaderClass('precision')} onClick={() => setSortBy('precision')}>
+                          <span>Avg Precision pctl</span>
+                          <span>{sortBy === 'precision' ? '▼' : '▾'}</span>
+                        </button>
+                      </span>
+                      <span role="columnheader">
+                        <button type="button" className={sortHeaderClass('recall')} onClick={() => setSortBy('recall')}>
+                          <span>Avg Recall pctl</span>
+                          <span>{sortBy === 'recall' ? '▼' : '▾'}</span>
+                        </button>
+                      </span>
+                      <span role="columnheader">Result type</span>
+                      <span role="columnheader"># Results</span>
+                    </div>
+                    {pagedLeaderboard.map((entry) => {
+                      const key = `${entry.model}|||${entry.machineLearningTask ?? ''}`;
+                      return (
+                        <div
+                          key={key}
+                          role="row"
+                          tabIndex={0}
+                          className={`${styles.tableRow} ${styles.clickableRow}`}
+                          onClick={() => setSelectedKey(key)}
+                          onKeyDown={(event) => {
+                            if (event.key === 'Enter' || event.key === ' ') {
+                              event.preventDefault();
+                              setSelectedKey(key);
+                            }
+                          }}
+                        >
+                          <span role="cell">
+                            <span className={`${styles.taskBadge} ${taskBadgeClass(entry.machineLearningTask)}`}>
+                              {entry.machineLearningTask ? shortTaskLabel(entry.machineLearningTask) : 'Unknown'}
+                            </span>
+                          </span>
+                          <span role="cell">
+                            <span className={styles.modelName}>{entry.model}</span>
+                          </span>
+                          <span role="cell">
+                            <PercentileCell value={entry.avgF1Percentile} />
+                          </span>
+                          <span role="cell">
+                            <PercentileCell value={entry.avgMapPercentile} />
+                          </span>
+                          <span role="cell">
+                            <PercentileCell value={entry.avgPrecisionPercentile} />
+                          </span>
+                          <span role="cell">
+                            <PercentileCell value={entry.avgRecallPercentile} />
+                          </span>
+                          <span role="cell">{entry.resultType}</span>
+                          <span role="cell">{entry.appearances}</span>
+                        </div>
+                      );
+                    })}
+                  </div>
+                </div>
+                {pageCount > 1 && (
+                  <div className={styles.pagination}>
+                    <button
+                      type="button"
+                      className={styles.paginationButton}
+                      onClick={() => setPage((p) => Math.max(1, p - 1))}
+                      disabled={currentPage === 1}
+                    >
+                      Previous
+                    </button>
+                    <span className={styles.paginationStatus}>
+                      Page {currentPage} of {pageCount}
+                    </span>
+                    <button
+                      type="button"
+                      className={styles.paginationButton}
+                      onClick={() => setPage((p) => Math.min(pageCount, p + 1))}
+                      disabled={currentPage === pageCount}
+                    >
+                      Next
+                    </button>
+                  </div>
+                )}
+              </>
+            )}
+          </section>
+        </div>
+      </div>
+    </Layout>
+  );
+}
diff --git a/static/data/hf_datasets.json b/static/data/hf_datasets.json
index cf08897..0790dd4 100644
--- a/static/data/hf_datasets.json
+++ b/static/data/hf_datasets.json
@@ -2720,7 +2720,7 @@
       0.186
     ],
     "examples_image_url": "/img/agml/sample_images/banana_leaf_disease_classification_examples.webp",
-    "source": "agml",
+    "source": "huggingface",
     "license": "CC BY 4.0",
     "citation": "hailu, yordanos (2021), “Banana Leaf Disease Images”, Mendeley Data, V1, doi: 10.17632/rjykr62kdh.1",
     "crop_types": [
@@ -2753,7 +2753,7 @@
       0.169
     ],
     "examples_image_url": "/img/agml/sample_images/bean_disease_uganda_examples.webp",
-    "source": "agml",
+    "source": "huggingface",
     "license": "MIT",
     "citation": "",
     "crop_types": [
@@ -2780,7 +2780,7 @@
     "stats_mean": null,
     "stats_std": null,
     "examples_image_url": "/img/agml/sample_images/blackgram_plant_leaf_disease_classification_examples.webp",
-    "source": "agml",
+    "source": "huggingface",
     "license": "CC BY 4.0",
     "citation": "Talasila, Srinivas; Rawal, Kirti; Sethi, Gaurav; MSS, Sanjay; M, Surya Prakash Reddy (2022), “Blackgram Plant Leaf Disease Dataset”, Mendeley Data, V3, doi: 10.17632/zfcv9fmrgv.3",
     "crop_types": [
@@ -7428,4 +7428,4 @@
     "hf_link": "https://huggingface.co/datasets/Project-AgML/Medjool_date_ripeness_detection",
     "examples_image_url": "/img/agml/sample_images/Medjool_date_ripeness_classification_sample.webp"
   }
-]
+]
\ No newline at end of file
diff --git a/static/data/performance/MoringaLeafNet_disease_classification.json b/static/data/performance/MoringaLeafNet_disease_classification.json
new file mode 100644
index 0000000..67bd0d0
--- /dev/null
+++ b/static/data/performance/MoringaLeafNet_disease_classification.json
@@ -0,0 +1,77 @@
+[
+  {
+    "timestamp": "2026-07-18T23:17:33.173272+00:00",
+    "dataset": "Project-AgML/MoringaLeafNet_disease_classification",
+    "dataset_config": null,
+    "split": "train",
+    "model": "openai/clip-vit-base-patch32",
+    "task": "classification",
+    "result_type": "zero-shot",
+    "optimized": "no",
+    "train_pct": 0.0,
+    "test_pct": 100.0,
+    "val_pct": 0.0,
+    "num_samples": 2817,
+    "device": "cuda",
+    "inference_time_seconds": 261.95,
+    "inference_time_seconds_per_image": 0.09299,
+    "train_time_seconds": 0.0,
+    "train_time_seconds_per_image": 0.0,
+    "metrics": {
+      "f1": 0.297072,
+      "precision": 0.46061,
+      "recall": 0.423695
+    },
+    "notes": ""
+  },
+  {
+    "timestamp": "2026-07-18T23:22:23.033141+00:00",
+    "dataset": "Project-AgML/MoringaLeafNet_disease_classification",
+    "dataset_config": null,
+    "split": "train",
+    "model": "google/siglip-base-patch16-224",
+    "task": "classification",
+    "result_type": "zero-shot",
+    "optimized": "no",
+    "train_pct": 0.0,
+    "test_pct": 100.0,
+    "val_pct": 0.0,
+    "num_samples": 2817,
+    "device": "cuda",
+    "inference_time_seconds": 287.08,
+    "inference_time_seconds_per_image": 0.101911,
+    "train_time_seconds": 0.0,
+    "train_time_seconds_per_image": 0.0,
+    "metrics": {
+      "f1": 0.320317,
+      "precision": 0.505885,
+      "recall": 0.399747
+    },
+    "notes": ""
+  },
+  {
+    "timestamp": "2026-07-18T23:26:39.899754+00:00",
+    "dataset": "Project-AgML/MoringaLeafNet_disease_classification",
+    "dataset_config": null,
+    "split": "train",
+    "model": "kakaobrain/align-base",
+    "task": "classification",
+    "result_type": "zero-shot",
+    "optimized": "no",
+    "train_pct": 0.0,
+    "test_pct": 100.0,
+    "val_pct": 0.0,
+    "num_samples": 2817,
+    "device": "cuda",
+    "inference_time_seconds": 253.68,
+    "inference_time_seconds_per_image": 0.090052,
+    "train_time_seconds": 0.0,
+    "train_time_seconds_per_image": 0.0,
+    "metrics": {
+      "f1": 0.130136,
+      "precision": 0.407792,
+      "recall": 0.254646
+    },
+    "notes": ""
+  }
+]
\ No newline at end of file
diff --git a/static/data/performance/ash_gourd_disease_classification.json b/static/data/performance/ash_gourd_disease_classification.json
new file mode 100644
index 0000000..a21ff94
--- /dev/null
+++ b/static/data/performance/ash_gourd_disease_classification.json
@@ -0,0 +1,77 @@
+[
+  {
+    "timestamp": "2026-07-18T23:27:54.133075+00:00",
+    "dataset": "Project-AgML/ash_gourd_disease_classification",
+    "dataset_config": null,
+    "split": "train",
+    "model": "openai/clip-vit-base-patch32",
+    "task": "classification",
+    "result_type": "zero-shot",
+    "optimized": "no",
+    "train_pct": 0.0,
+    "test_pct": 100.0,
+    "val_pct": 0.0,
+    "num_samples": 2676,
+    "device": "cuda",
+    "inference_time_seconds": 70.37,
+    "inference_time_seconds_per_image": 0.026298,
+    "train_time_seconds": 0.0,
+    "train_time_seconds_per_image": 0.0,
+    "metrics": {
+      "f1": 0.152805,
+      "precision": 0.139378,
+      "recall": 0.199623
+    },
+    "notes": ""
+  },
+  {
+    "timestamp": "2026-07-18T23:29:08.172946+00:00",
+    "dataset": "Project-AgML/ash_gourd_disease_classification",
+    "dataset_config": null,
+    "split": "train",
+    "model": "google/siglip-base-patch16-224",
+    "task": "classification",
+    "result_type": "zero-shot",
+    "optimized": "no",
+    "train_pct": 0.0,
+    "test_pct": 100.0,
+    "val_pct": 0.0,
+    "num_samples": 2676,
+    "device": "cuda",
+    "inference_time_seconds": 71.08,
+    "inference_time_seconds_per_image": 0.026562,
+    "train_time_seconds": 0.0,
+    "train_time_seconds_per_image": 0.0,
+    "metrics": {
+      "f1": 0.215341,
+      "precision": 0.175789,
+      "recall": 0.283302
+    },
+    "notes": ""
+  },
+  {
+    "timestamp": "2026-07-18T23:30:31.504295+00:00",
+    "dataset": "Project-AgML/ash_gourd_disease_classification",
+    "dataset_config": null,
+    "split": "train",
+    "model": "kakaobrain/align-base",
+    "task": "classification",
+    "result_type": "zero-shot",
+    "optimized": "no",
+    "train_pct": 0.0,
+    "test_pct": 100.0,
+    "val_pct": 0.0,
+    "num_samples": 2676,
+    "device": "cuda",
+    "inference_time_seconds": 80.02,
+    "inference_time_seconds_per_image": 0.029902,
+    "train_time_seconds": 0.0,
+    "train_time_seconds_per_image": 0.0,
+    "metrics": {
+      "f1": 0.086037,
+      "precision": 0.207444,
+      "recall": 0.22084
+    },
+    "notes": ""
+  }
+]
\ No newline at end of file
diff --git a/static/data/performance/cotton_leaf_disease_classification.json b/static/data/performance/cotton_leaf_disease_classification.json
new file mode 100644
index 0000000..c94ff30
--- /dev/null
+++ b/static/data/performance/cotton_leaf_disease_classification.json
@@ -0,0 +1,77 @@
+[
+  {
+    "timestamp": "2026-07-18T23:11:28.749699+00:00",
+    "dataset": "Project-AgML/cotton_leaf_disease_classification",
+    "dataset_config": null,
+    "split": "train",
+    "model": "openai/clip-vit-base-patch32",
+    "task": "classification",
+    "result_type": "zero-shot",
+    "optimized": "no",
+    "train_pct": 0.0,
+    "test_pct": 100.0,
+    "val_pct": 0.0,
+    "num_samples": 1373,
+    "device": "cuda",
+    "inference_time_seconds": 6.36,
+    "inference_time_seconds_per_image": 0.004634,
+    "train_time_seconds": 0.0,
+    "train_time_seconds_per_image": 0.0,
+    "metrics": {
+      "f1": 0.110828,
+      "precision": 0.109944,
+      "recall": 0.241157
+    },
+    "notes": ""
+  },
+  {
+    "timestamp": "2026-07-18T23:11:38.074861+00:00",
+    "dataset": "Project-AgML/cotton_leaf_disease_classification",
+    "dataset_config": null,
+    "split": "train",
+    "model": "google/siglip-base-patch16-224",
+    "task": "classification",
+    "result_type": "zero-shot",
+    "optimized": "no",
+    "train_pct": 0.0,
+    "test_pct": 100.0,
+    "val_pct": 0.0,
+    "num_samples": 1373,
+    "device": "cuda",
+    "inference_time_seconds": 6.62,
+    "inference_time_seconds_per_image": 0.004822,
+    "train_time_seconds": 0.0,
+    "train_time_seconds_per_image": 0.0,
+    "metrics": {
+      "f1": 0.313517,
+      "precision": 0.679998,
+      "recall": 0.410273
+    },
+    "notes": ""
+  },
+  {
+    "timestamp": "2026-07-18T23:11:50.448026+00:00",
+    "dataset": "Project-AgML/cotton_leaf_disease_classification",
+    "dataset_config": null,
+    "split": "train",
+    "model": "kakaobrain/align-base",
+    "task": "classification",
+    "result_type": "zero-shot",
+    "optimized": "no",
+    "train_pct": 0.0,
+    "test_pct": 100.0,
+    "val_pct": 0.0,
+    "num_samples": 1373,
+    "device": "cuda",
+    "inference_time_seconds": 9.24,
+    "inference_time_seconds_per_image": 0.00673,
+    "train_time_seconds": 0.0,
+    "train_time_seconds_per_image": 0.0,
+    "metrics": {
+      "f1": 0.100794,
+      "precision": 0.108849,
+      "recall": 0.224622
+    },
+    "notes": ""
+  }
+]
\ No newline at end of file
diff --git a/static/data/performance/eggplant_leaf_disease_classification.json b/static/data/performance/eggplant_leaf_disease_classification.json
new file mode 100644
index 0000000..684b269
--- /dev/null
+++ b/static/data/performance/eggplant_leaf_disease_classification.json
@@ -0,0 +1,77 @@
+[
+  {
+    "timestamp": "2026-07-18T23:12:14.210533+00:00",
+    "dataset": "Project-AgML/eggplant_leaf_disease_classification",
+    "dataset_config": null,
+    "split": "train",
+    "model": "openai/clip-vit-base-patch32",
+    "task": "classification",
+    "result_type": "zero-shot",
+    "optimized": "no",
+    "train_pct": 0.0,
+    "test_pct": 100.0,
+    "val_pct": 0.0,
+    "num_samples": 3116,
+    "device": "cuda",
+    "inference_time_seconds": 20.02,
+    "inference_time_seconds_per_image": 0.006425,
+    "train_time_seconds": 0.0,
+    "train_time_seconds_per_image": 0.0,
+    "metrics": {
+      "f1": 0.252379,
+      "precision": 0.318532,
+      "recall": 0.301476
+    },
+    "notes": ""
+  },
+  {
+    "timestamp": "2026-07-18T23:12:38.747166+00:00",
+    "dataset": "Project-AgML/eggplant_leaf_disease_classification",
+    "dataset_config": null,
+    "split": "train",
+    "model": "google/siglip-base-patch16-224",
+    "task": "classification",
+    "result_type": "zero-shot",
+    "optimized": "no",
+    "train_pct": 0.0,
+    "test_pct": 100.0,
+    "val_pct": 0.0,
+    "num_samples": 3116,
+    "device": "cuda",
+    "inference_time_seconds": 21.59,
+    "inference_time_seconds_per_image": 0.006927,
+    "train_time_seconds": 0.0,
+    "train_time_seconds_per_image": 0.0,
+    "metrics": {
+      "f1": 0.299814,
+      "precision": 0.388911,
+      "recall": 0.362106
+    },
+    "notes": ""
+  },
+  {
+    "timestamp": "2026-07-18T23:13:07.258348+00:00",
+    "dataset": "Project-AgML/eggplant_leaf_disease_classification",
+    "dataset_config": null,
+    "split": "train",
+    "model": "kakaobrain/align-base",
+    "task": "classification",
+    "result_type": "zero-shot",
+    "optimized": "no",
+    "train_pct": 0.0,
+    "test_pct": 100.0,
+    "val_pct": 0.0,
+    "num_samples": 3116,
+    "device": "cuda",
+    "inference_time_seconds": 25.38,
+    "inference_time_seconds_per_image": 0.008146,
+    "train_time_seconds": 0.0,
+    "train_time_seconds_per_image": 0.0,
+    "metrics": {
+      "f1": 0.239863,
+      "precision": 0.290847,
+      "recall": 0.307375
+    },
+    "notes": ""
+  }
+]
\ No newline at end of file
diff --git a/static/data/performance/global.json b/static/data/performance/global.json
new file mode 100644
index 0000000..b627dee
--- /dev/null
+++ b/static/data/performance/global.json
@@ -0,0 +1,377 @@
+[
+  {
+    "model": "google/siglip-base-patch16-224",
+    "dataset": "MoringaLeafNet_disease_classification",
+    "percentiles": {
+      "f1": 100,
+      "map": null,
+      "precision": 100,
+      "recall": 50
+    },
+    "scores": {
+      "f1": 0.320317,
+      "map": null,
+      "precision": 0.505885,
+      "recall": 0.399747
+    },
+    "crop_types": [
+      "moringa"
+    ],
+    "machine_learning_task": "image_classification",
+    "variant": "zero-shot",
+    "optimized": false,
+    "platform": "cuda",
+    "splitBreakdown": "-/100/-",
+    "datasetConfig": "raw"
+  },
+  {
+    "model": "openai/clip-vit-base-patch32",
+    "dataset": "MoringaLeafNet_disease_classification",
+    "percentiles": {
+      "f1": 50,
+      "map": null,
+      "precision": 50,
+      "recall": 100
+    },
+    "scores": {
+      "f1": 0.297072,
+      "map": null,
+      "precision": 0.46061,
+      "recall": 0.423695
+    },
+    "crop_types": [
+      "moringa"
+    ],
+    "machine_learning_task": "image_classification",
+    "variant": "zero-shot",
+    "optimized": false,
+    "platform": "cuda",
+    "splitBreakdown": "-/100/-",
+    "datasetConfig": "raw"
+  },
+  {
+    "model": "kakaobrain/align-base",
+    "dataset": "MoringaLeafNet_disease_classification",
+    "percentiles": {
+      "f1": 0,
+      "map": null,
+      "precision": 0,
+      "recall": 0
+    },
+    "scores": {
+      "f1": 0.130136,
+      "map": null,
+      "precision": 0.407792,
+      "recall": 0.254646
+    },
+    "crop_types": [
+      "moringa"
+    ],
+    "machine_learning_task": "image_classification",
+    "variant": "zero-shot",
+    "optimized": false,
+    "platform": "cuda",
+    "splitBreakdown": "-/100/-",
+    "datasetConfig": "raw"
+  },
+  {
+    "model": "google/siglip-base-patch16-224",
+    "dataset": "ash_gourd_disease_classification",
+    "percentiles": {
+      "f1": 100,
+      "map": null,
+      "precision": 50,
+      "recall": 100
+    },
+    "scores": {
+      "f1": 0.215341,
+      "map": null,
+      "precision": 0.175789,
+      "recall": 0.283302
+    },
+    "crop_types": [
+      "ash gourd"
+    ],
+    "machine_learning_task": "image_classification",
+    "variant": "zero-shot",
+    "optimized": false,
+    "platform": "cuda",
+    "splitBreakdown": "-/100/-",
+    "datasetConfig": "raw"
+  },
+  {
+    "model": "openai/clip-vit-base-patch32",
+    "dataset": "ash_gourd_disease_classification",
+    "percentiles": {
+      "f1": 50,
+      "map": null,
+      "precision": 0,
+      "recall": 0
+    },
+    "scores": {
+      "f1": 0.152805,
+      "map": null,
+      "precision": 0.139378,
+      "recall": 0.199623
+    },
+    "crop_types": [
+      "ash gourd"
+    ],
+    "machine_learning_task": "image_classification",
+    "variant": "zero-shot",
+    "optimized": false,
+    "platform": "cuda",
+    "splitBreakdown": "-/100/-",
+    "datasetConfig": "raw"
+  },
+  {
+    "model": "kakaobrain/align-base",
+    "dataset": "ash_gourd_disease_classification",
+    "percentiles": {
+      "f1": 0,
+      "map": null,
+      "precision": 100,
+      "recall": 50
+    },
+    "scores": {
+      "f1": 0.086037,
+      "map": null,
+      "precision": 0.207444,
+      "recall": 0.22084
+    },
+    "crop_types": [
+      "ash gourd"
+    ],
+    "machine_learning_task": "image_classification",
+    "variant": "zero-shot",
+    "optimized": false,
+    "platform": "cuda",
+    "splitBreakdown": "-/100/-",
+    "datasetConfig": "raw"
+  },
+  {
+    "model": "google/siglip-base-patch16-224",
+    "dataset": "cotton_leaf_disease_classification",
+    "percentiles": {
+      "f1": 100,
+      "map": null,
+      "precision": 100,
+      "recall": 100
+    },
+    "scores": {
+      "f1": 0.313517,
+      "map": null,
+      "precision": 0.679998,
+      "recall": 0.410273
+    },
+    "crop_types": [
+      "cotton"
+    ],
+    "machine_learning_task": "image_classification",
+    "variant": "zero-shot",
+    "optimized": false,
+    "platform": "cuda",
+    "splitBreakdown": "-/100/-",
+    "datasetConfig": "raw"
+  },
+  {
+    "model": "openai/clip-vit-base-patch32",
+    "dataset": "cotton_leaf_disease_classification",
+    "percentiles": {
+      "f1": 50,
+      "map": null,
+      "precision": 50,
+      "recall": 50
+    },
+    "scores": {
+      "f1": 0.110828,
+      "map": null,
+      "precision": 0.109944,
+      "recall": 0.241157
+    },
+    "crop_types": [
+      "cotton"
+    ],
+    "machine_learning_task": "image_classification",
+    "variant": "zero-shot",
+    "optimized": false,
+    "platform": "cuda",
+    "splitBreakdown": "-/100/-",
+    "datasetConfig": "raw"
+  },
+  {
+    "model": "kakaobrain/align-base",
+    "dataset": "cotton_leaf_disease_classification",
+    "percentiles": {
+      "f1": 0,
+      "map": null,
+      "precision": 0,
+      "recall": 0
+    },
+    "scores": {
+      "f1": 0.100794,
+      "map": null,
+      "precision": 0.108849,
+      "recall": 0.224622
+    },
+    "crop_types": [
+      "cotton"
+    ],
+    "machine_learning_task": "image_classification",
+    "variant": "zero-shot",
+    "optimized": false,
+    "platform": "cuda",
+    "splitBreakdown": "-/100/-",
+    "datasetConfig": "raw"
+  },
+  {
+    "model": "google/siglip-base-patch16-224",
+    "dataset": "eggplant_leaf_disease_classification",
+    "percentiles": {
+      "f1": 100,
+      "map": null,
+      "precision": 100,
+      "recall": 100
+    },
+    "scores": {
+      "f1": 0.299814,
+      "map": null,
+      "precision": 0.388911,
+      "recall": 0.362106
+    },
+    "crop_types": [
+      "eggplant"
+    ],
+    "machine_learning_task": "image_classification",
+    "variant": "zero-shot",
+    "optimized": false,
+    "platform": "cuda",
+    "splitBreakdown": "-/100/-",
+    "datasetConfig": "raw"
+  },
+  {
+    "model": "openai/clip-vit-base-patch32",
+    "dataset": "eggplant_leaf_disease_classification",
+    "percentiles": {
+      "f1": 50,
+      "map": null,
+      "precision": 50,
+      "recall": 0
+    },
+    "scores": {
+      "f1": 0.252379,
+      "map": null,
+      "precision": 0.318532,
+      "recall": 0.301476
+    },
+    "crop_types": [
+      "eggplant"
+    ],
+    "machine_learning_task": "image_classification",
+    "variant": "zero-shot",
+    "optimized": false,
+    "platform": "cuda",
+    "splitBreakdown": "-/100/-",
+    "datasetConfig": "raw"
+  },
+  {
+    "model": "kakaobrain/align-base",
+    "dataset": "eggplant_leaf_disease_classification",
+    "percentiles": {
+      "f1": 0,
+      "map": null,
+      "precision": 0,
+      "recall": 50
+    },
+    "scores": {
+      "f1": 0.239863,
+      "map": null,
+      "precision": 0.290847,
+      "recall": 0.307375
+    },
+    "crop_types": [
+      "eggplant"
+    ],
+    "machine_learning_task": "image_classification",
+    "variant": "zero-shot",
+    "optimized": false,
+    "platform": "cuda",
+    "splitBreakdown": "-/100/-",
+    "datasetConfig": "raw"
+  },
+  {
+    "model": "kakaobrain/align-base",
+    "dataset": "groundnut_leaf_disease_classification",
+    "percentiles": {
+      "f1": 100,
+      "map": null,
+      "precision": 50,
+      "recall": 100
+    },
+    "scores": {
+      "f1": 0.157617,
+      "map": null,
+      "precision": 0.120098,
+      "recall": 0.229333
+    },
+    "crop_types": [
+      "groundnut"
+    ],
+    "machine_learning_task": "image_classification",
+    "variant": "zero-shot",
+    "optimized": false,
+    "platform": "cuda",
+    "splitBreakdown": "-/100/-",
+    "datasetConfig": "raw"
+  },
+  {
+    "model": "google/siglip-base-patch16-224",
+    "dataset": "groundnut_leaf_disease_classification",
+    "percentiles": {
+      "f1": 50,
+      "map": null,
+      "precision": 100,
+      "recall": 50
+    },
+    "scores": {
+      "f1": 0.145332,
+      "map": null,
+      "precision": 0.127236,
+      "recall": 0.219556
+    },
+    "crop_types": [
+      "groundnut"
+    ],
+    "machine_learning_task": "image_classification",
+    "variant": "zero-shot",
+    "optimized": false,
+    "platform": "cuda",
+    "splitBreakdown": "-/100/-",
+    "datasetConfig": "raw"
+  },
+  {
+    "model": "openai/clip-vit-base-patch32",
+    "dataset": "groundnut_leaf_disease_classification",
+    "percentiles": {
+      "f1": 0,
+      "map": null,
+      "precision": 0,
+      "recall": 0
+    },
+    "scores": {
+      "f1": 0.082803,
+      "map": null,
+      "precision": 0.05224,
+      "recall": 0.199556
+    },
+    "crop_types": [
+      "groundnut"
+    ],
+    "machine_learning_task": "image_classification",
+    "variant": "zero-shot",
+    "optimized": false,
+    "platform": "cuda",
+    "splitBreakdown": "-/100/-",
+    "datasetConfig": "raw"
+  }
+]
\ No newline at end of file
diff --git a/static/data/performance/groundnut_leaf_disease_classification.json b/static/data/performance/groundnut_leaf_disease_classification.json
new file mode 100644
index 0000000..e677269
--- /dev/null
+++ b/static/data/performance/groundnut_leaf_disease_classification.json
@@ -0,0 +1,77 @@
+[
+  {
+    "timestamp": "2026-07-18T23:00:41.273137+00:00",
+    "dataset": "Project-AgML/groundnut_leaf_disease_classification",
+    "dataset_config": null,
+    "split": "train",
+    "model": "openai/clip-vit-base-patch32",
+    "task": "classification",
+    "result_type": "zero-shot",
+    "optimized": "no",
+    "train_pct": 0.0,
+    "test_pct": 100.0,
+    "val_pct": 0.0,
+    "num_samples": 1720,
+    "device": "cuda",
+    "inference_time_seconds": 364.31,
+    "inference_time_seconds_per_image": 0.21181,
+    "train_time_seconds": 0.0,
+    "train_time_seconds_per_image": 0.0,
+    "metrics": {
+      "f1": 0.082803,
+      "precision": 0.05224,
+      "recall": 0.199556
+    },
+    "notes": ""
+  },
+  {
+    "timestamp": "2026-07-18T23:05:56.625342+00:00",
+    "dataset": "Project-AgML/groundnut_leaf_disease_classification",
+    "dataset_config": null,
+    "split": "train",
+    "model": "google/siglip-base-patch16-224",
+    "task": "classification",
+    "result_type": "zero-shot",
+    "optimized": "no",
+    "train_pct": 0.0,
+    "test_pct": 100.0,
+    "val_pct": 0.0,
+    "num_samples": 1720,
+    "device": "cuda",
+    "inference_time_seconds": 312.06,
+    "inference_time_seconds_per_image": 0.181432,
+    "train_time_seconds": 0.0,
+    "train_time_seconds_per_image": 0.0,
+    "metrics": {
+      "f1": 0.145332,
+      "precision": 0.127236,
+      "recall": 0.219556
+    },
+    "notes": ""
+  },
+  {
+    "timestamp": "2026-07-18T23:11:18.750341+00:00",
+    "dataset": "Project-AgML/groundnut_leaf_disease_classification",
+    "dataset_config": null,
+    "split": "train",
+    "model": "kakaobrain/align-base",
+    "task": "classification",
+    "result_type": "zero-shot",
+    "optimized": "no",
+    "train_pct": 0.0,
+    "test_pct": 100.0,
+    "val_pct": 0.0,
+    "num_samples": 1720,
+    "device": "cuda",
+    "inference_time_seconds": 318.51,
+    "inference_time_seconds_per_image": 0.185183,
+    "train_time_seconds": 0.0,
+    "train_time_seconds_per_image": 0.0,
+    "metrics": {
+      "f1": 0.157617,
+      "precision": 0.120098,
+      "recall": 0.229333
+    },
+    "notes": ""
+  }
+]
\ No newline at end of file
diff --git a/static/data/performance/index.json b/static/data/performance/index.json
new file mode 100644
index 0000000..16c7ae3
--- /dev/null
+++ b/static/data/performance/index.json
@@ -0,0 +1,7 @@
+[
+  "MoringaLeafNet_disease_classification",
+  "ash_gourd_disease_classification",
+  "cotton_leaf_disease_classification",
+  "eggplant_leaf_disease_classification",
+  "groundnut_leaf_disease_classification"
+]
\ No newline at end of file