EditJudge-Bench

Can vision-language models tell whether an image edit was done correctly? EditJudge-Bench tests VLM judges on before/after image pairs rendered in Blender. Every edit is a known change to a 3D scene, so the ground truth is exact. A judge is shown an image pair with the correct instruction and with wrong ones, and is scored on telling them apart.

NeurIPS 2026, Evaluations and Datasets Track · Paper · Code · Project page

_{Auditing VLM image-edit judges. We procedurally alter 3D scenes and render controlled before/after image pairs spanning nine edit types, then use these pairs to audit VLM image-edit judges, exposing systematic reliability gaps in current VLM-as-a-judge protocols.}

Quick start

from datasets import load_dataset
from huggingface_hub import snapshot_download

bench = load_dataset("JensParslov/EditJudge-Bench", split="test")   # curated: 1,382 pairs
root = snapshot_download("JensParslov/EditJudge-Bench", repo_type="dataset", revision="v1.0")

row = bench[0]
print(row["instruction_pos"])                  # "Move the cell shelf right."
print(row["instruction_neg_list"])             # wrong instructions for the same pair
before, after = f"{root}/{row['before']}", f"{root}/{row['after']}"

To run the judges from the paper or evaluate your own, use the code repository. Its python -m editjudge.download fetches this dataset at the pinned version and checks every file.

What is in a row

One row is one before/after image pair. These are the columns you need:

Column	Meaning
sample_id	Stable ID, <edit_type>-<number>. The number is the row's position in benchmark.parquet.
edit_type	One of the 10 edit types below.
in_curated	True if the pair passed the manual audit (see below).
before, after	Image paths relative to the dataset root: images/<sample_id>/before.png and after.png.
instruction_pos	The correct instruction: it describes the edit that was made.
instruction_neg_list	2–5 wrong instructions for the same image pair.
instruction_neg_types	The type of each wrong instruction (same order).

Judge examples. Each pair gives one positive example (before, after, instruction_pos) and one negative example per wrong instruction. A judge scores all of them; the paper reports AUROC × 100 per edit type.

Variant	Pairs	Judge examples	Positives	Negatives
curated (default, used for the paper's headline results)	1,382	6,755	1,382	5,373
full	1,500	7,318	1,500	5,818

Wrong-instruction types (instruction_neg_types):

Type	Example for "Move the books up"	Tests	Count (full)
counterfactual	"Move the books down"	direction	2,100
wrong_object	"Move the table up"	which object	718
cross_type	"Make the books bigger"	which kind of edit	1,500
no_edit	"Leave the scene as it is."	whether anything changed	1,500

Edit types

edit_type	Example instruction	Full	Curated
removal	Remove the toilet from the scene.	150	150
object_material	Change the material of the large plant container to …	150	144
material_slot	Change the oven's back panel material to …	150	124
lighting	Change the lighting to green.	150	137
camera	Zoom the camera in.	150	149
movement	Move the cell shelf right.	150	126
scale	Make the mirror smaller.	150	142
shape	Make the dining table longer.	150	146
articulation	Close the oven door.	150	131
rotation	Rotate the simple desk 90 degrees.	150	133
Total		1,500	1,382

The paper reports nine columns: object_material and material_slot are averaged into one "material" column.

Ground-truth parameters

All other columns hold the scene parameters saved when the edit was generated. Each edit type fills only its own columns; the rest are empty.

Columns	What they hold
metadata.*	One magnitude per edit type, e.g. metadata.movement_distance, metadata.scale_factor, metadata.rotation_angle_deg, metadata.lighting_energy_ratio, metadata.camera_angle_delta, metadata.attribute_relative_change (shape, articulation). metadata holds the same values as one struct.
meta.*	The edit as applied, e.g. meta.direction, meta.distance_moved, meta.axis, meta.angle_deg, meta.factor, meta.preset, meta.material.
params.*	The edited object's or light's parameters, e.g. params.location, params.rotation_euler, params.scale, params.param_key / params.original_value / params.new_value (shape, articulation).
camera_params.*	Camera location, rotation, lens and focus distance.
dataset, object_key, view_key, object_type	Which render batch, object and view the pair comes from.

Audit

Every one of the 1,500 pairs was checked by hand in two passes:

1. First pass. Each pair was checked against its correct instruction. Pairs where the change could not clearly be seen, or where the render showed a change that was not asked for, were flagged: 219 pairs.
2. Second pass. A second reviewer re-checked every flagged pair and either confirmed it as ambiguous (118) or found the edit visible after all (101).

The 118 confirmed pairs (7.9%) are left out of curated. Every decision is listed in metadata/audit.csv. The main causes:

• Direction near a bin boundary. Movement direction is rounded to one of eight compass directions in the image plane; near a boundary, the direction cannot be told visually.
• Wall-mounted objects. They are turned to face the new wall after a move, so the pair also contains a rotation that was not asked for.
• Hard to see. The changed object or part is occluded or very small, or the change cannot be told apart from a wrong instruction.

Files

benchmark.parquet                  full benchmark, 1,500 rows, with in_curated
curated.parquet                    the 1,382 rows with in_curated == True
images/<sample_id>/before.png      original lossless renders, 1920x1080
images/<sample_id>/after.png
metadata/audit.csv                 the 219 flagged pairs and both reviewers' decisions
metadata/checksums.csv             sha256 and size of every file
metadata/validation_report.json    checks run when this version was built
croissant.json                     machine-readable metadata, incl. Responsible AI fields

The images are byte-identical to the renders the paper's results were computed on. Versions are git tags; the code pins v1.0.

Intended use

EditJudge-Bench is for diagnosing VLM-based edit judges: can a model verify that an edit was carried out, reject wrong instructions, and where does it fail as a function of the known scene parameters? It measures instruction verification (was the requested change made?), not full edit fidelity (was everything else kept?).

It is not meant as training data for image generation, as a measure of human ability, or for safety-critical evaluation. The images are synthetic indoor scenes and do not represent all real-world editing.

Responsible AI notes

The images are rendered synthetic indoor scenes. Nothing was collected from people, social media, surveillance footage or private sources. The benchmark can reflect the scene generator's biases in object categories, room layouts, materials and camera placement. Known limitations: the gap between synthetic and real images, a finite set of edit types, and that it audits judges rather than editing models.

License

The dataset is released under CC-BY-NC-4.0. The code repository is MIT-licensed.

Citation

@inproceedings{parslov2026editjudge,
  title     = {EditJudge-Bench: Auditing VLM Image-Edit Judges with Synthetic Ground Truth},
  author    = {Parslov, Jens and Schouten, Marco and Papadopoulos, Dim P.},
  booktitle = {Advances in Neural Information Processing Systems (NeurIPS),
               Track on Evaluations and Datasets},
  year      = {2026}
}