PaintBench

A precise, deterministic visual editing benchmark. PaintBench evaluates whether generative models can execute MS-Paint-style image editing operations with pixel-level correctness. Every problem is a (input_image, instruction, answer_image) triplet, generated programmatically so the answer is pixel-exact and the answer distribution is known by construction.

This dataset bundles three sibling benchmarks that share one generation and evaluation pipeline:

Subset (config)	Rows	Scope
PaintBench (default)	1,050	20 canonical tasks (35 task-modes) grouped into 4 categories — geometric_transformation, structural_manipulation, color_change, symbolic_reasoning.
TinyGrafixBench	600	Chart-edit mini-benchmark: 5 chart types (bar_chart, heatmap, line_chart, network, scatter_plot) × 4 edit subtasks per chart — a real-world analog of the primitive operations. The chart type is the category and the edit subtask is the task (mirrors the PaintBench grouping).
ablations	1,080	Per-axis variation studies on 4 focal PaintBench tasks (removal_attribute, recolor_color_code, copying, preservation) × 9 variants. Every row has category="ablation"; the focal task is the task and the variant (baseline, horizontal, vertical, small, nonstandard, striped, n16, n36, n64) is the mode.

Each subset has a single test split — the benchmarks are intended for evaluation, not training.

Quick start

from datasets import load_dataset

ds  = load_dataset("PaintBench/PaintBench", split="test")
tgb = load_dataset("PaintBench/PaintBench", "TinyGrafixBench", split="test")
abl = load_dataset("PaintBench/PaintBench", "ablations",       split="test")

ex = ds[0]
ex["category"]      # top-level group, e.g. "color_change"
ex["task"]          # canonical task, e.g. "flood_fill"
ex["mode"]          # subtask, e.g. "background"  ("" when the task has no modes)
ex["instruction"]   # natural-language edit instruction
ex["input_image"]   # PIL.Image — the source canvas
ex["answer_image"]  # PIL.Image — pixel-exact ground truth
ex["metadata"]      # JSON string — full per-problem spec (seed, scene_shapes, params, ...)

Group by category / task / mode:

from collections import Counter
Counter(ds["category"]).most_common()       # 4 PaintBench categories
Counter(tgb["category"]).most_common()      # 5 chart types
Counter(abl["mode"]).most_common()          # 9 ablation variants

Schema

All three configs share a uniform schema:

Column	Type	Description
category	string	Top-level grouping. PaintBench: one of geometric_transformation / structural_manipulation / color_change / symbolic_reasoning. TinyGrafixBench: chart type (bar_chart, heatmap, line_chart, network, scatter_plot). ablations: "ablation".
task	string	Operation within the category. PaintBench: canonical task (flood_fill, recolor, translation, ...). TinyGrafixBench: chart-edit subtask (add_bar, sort_bars, mask_cells, ...). ablations: focal task identifier (removal_attribute, recolor_color_code, copying, preservation).
mode	string	Subtask / variant within the task. PaintBench: subtask (background, foreground, external, ...) or "" when the task has no modes. TinyGrafixBench: always "". ablations: variant (baseline, horizontal, vertical, small, nonstandard, striped, n16, n36, n64). The on-disk problems.jsonl keeps the empty slots as JSON null; the dataset normalizes to "" so the column stays a non-nullable string.
problem_id	int32	Zero-indexed id within the (category, task, mode) cell.
instruction	string	Natural-language edit instruction.
input_image	image	Source canvas (PNG, embedded).
answer_image	image	Pixel-exact ground-truth output (PNG, embedded).
metadata	string	JSON-encoded per-problem spec — includes the random seed, scene composition, the on-disk folder name (task_mode), and any per-subset extras (base_task_canonical / base_task_mode for ablations; params / scene_shapes / colors for PaintBench). Useful for filtering, grouping, and exact regeneration.

To pull structured fields out of metadata:

import json
ex = ds[0]
meta = json.loads(ex["metadata"])
meta["seed"]                  # for deterministic regeneration
meta["task_mode"]             # on-disk folder name (= "<task>_<mode>" or "<task>")
meta.get("base_task_canonical")  # populated only for the `ablations` config
meta.get("scene_shapes")      # PaintBench scene composition

Evaluation

PaintBench uses pointwise CIE76 ΔE between the model's output and answer_image. Per-pixel ΔE values are thresholded at {0, 2, 5, 10} and aggregated to per-problem and per-task pass rates. The reference implementation lives in the project repo.

Source

The benchmarks are generated programmatically — there is no human curation step. Every problem is reproducible from its metadata.seed. See the project repo for the generation pipeline and a full per-task description.

License

Released under the Creative Commons Attribution 4.0 International (CC BY 4.0) license. You are free to share and adapt the dataset, including for commercial use, with attribution.

Citation

Citation will be added upon paper publication. For now, please reference this dataset as:

@misc{paintbench2026,
  title  = {PaintBench: A Precise, Deterministic Visual Editing Benchmark},
  author = {PaintBench team},
  year   = {2026},
  url    = {https://huggingface.co/datasets/PaintBench/PaintBench}
}