Datasets:

WarmwindOS
/

pointerbench

A 500-example GUI grounding benchmark for spreadsheets. Given a spreadsheet screenshot and a short instruction (e.g. "Click cell E33", "Click the orange cell", "Click the Revenue column header", "Drag to resize column C"), a model must output the pixel coordinate to click. Scored exactly like ScreenSpot: a click is correct if it lands inside the target's bounding box.

Why spreadsheets?

General GUI-grounding suites (ScreenSpot, ScreenSpot-v2, ScreenSpot-Pro) are broad but thin on spreadsheets, yet spreadsheets are where grounding is hardest: hundreds of near-identical small cells, dense grids, colored fills, header rows, scroll positions that rarely start at A1, and click targets that are not ordinary objects at all. Resizing a column means clicking the thin line between columns; selecting a cell corner means landing on one grid intersection; following "three cells below A5" means reasoning over grid coordinates, not OCR tokens. Pointerbench-Sheets isolates this spreadsheet-specific grounding skill across four real spreadsheet UI skins plus a chrome-free grid.

What's inside

500 examples, one instruction per image.
1024×768 PNG screenshots, fully synthetic (no scraping, no PII).
5 UI styles: Excel, Excel (white), Google Sheets, LibreOffice Calc, and a bare chrome-free grid.

16 task categories:

category	data_type	instruction example
`cell_ref`	cell	Click cell C12.
`cell_ref_content`	cell	Click cell C12 containing "Madrid".
`cell_content`	cell	Click the cell containing "Madrid".
`col_header`	header	Click the column D header.
`row_header`	header	Click the row 18 header.
`cell_color`	color	Click the orange cell.
`col_resize_handle`	edge	Click the divider after column D.
`row_resize_handle`	edge	Click the lower border of row 18.
`cell_right_edge`	edge	Click the right edge of cell C12.
`cell_bottom_edge`	edge	Click the bottom edge of cell C12.
`cell_top_left_corner`	corner	Click the top-left corner of cell C12.
`cell_top_right_corner`	corner	Click the top-right corner of cell C12.
`cell_bottom_left_corner`	corner	Click the bottom-left corner of cell C12.
`cell_bottom_right_corner`	corner	Click the bottom-right corner of cell C12.
`cell_relative_row`	relative	Click the cell 3 rows below D18.
`cell_relative_offset`	relative	From B7, move 3 columns right and 1 row down.

Randomized realism: per-sheet font family/size, per-column text color / bold / alignment, colored fills (single cell / row / column / stripe), banded rows, a selected-cell distractor, and random row + column scroll offsets (the window does not always start at A1).
~10% of instructions are in German (language field), the rest English.

Schema

Each line of data/test/metadata.jsonl (HuggingFace imagefolder layout):

{
  "file_name": "0000.png",
  "id": "pbs_0000",
  "instruction": "Click cell E33.",
  "bbox": [596, 376, 681, 395],
  "point": [638, 385],
  "data_type": "cell",
  "category": "cell_ref",
  "ui_style": "excel",
  "language": "en",
  "image_size": [1024, 768]
}

bbox: ground-truth target, [x1, y1, x2, y2] in absolute pixels (top-left, bottom-right) on the 1024×768 image. A prediction is correct iff it lands inside this box.
point: the box center (a convenient single-point reference).
data_type: coarse ScreenSpot-style class (cell / header / color / edge / corner / relative).
category: the fine-grained task kind.
ui_style: the rendered app skin.

Quickstart

Load the data

Via 🤗 datasets (after the set is pushed to the Hub):

from datasets import load_dataset
ds = load_dataset("YOUR_ORG/pointerbench-sheets", split="test")
ex = ds[0]
ex["image"]        # PIL.Image, 1024x768
ex["instruction"]  # "Click cell E33."
ex["bbox"]         # [x1, y1, x2, y2]

Or locally with the imagefolder loader:

from datasets import load_dataset
ds = load_dataset("imagefolder", data_dir="data", split="test")

Or with no dependencies at all, read data/test/metadata.jsonl and open the sibling PNGs yourself.

Evaluate

Print the recommended system prompt with python eval.py --show-system-prompt, or edit it for your inference stack while keeping the 1024x768 coordinate frame fixed.
Run your model on every example's instruction + image and collect a predicted click point (absolute pixels on the 1024×768 image).
Write predictions as JSONL, one object per example:
```
{"id": "pbs_0000", "point": [612, 388]}
```

Score (pure standard library, no dependencies):

python eval.py --predictions preds.jsonl

Pointerbench-Sheets: 500 examples
============================================
Accuracy: 73.40%   (367/500)

By category:
  cell_color          61.11%   (n=72)
  cell_ref            81.46%   (n=178)
  ...

The scorer reports overall accuracy plus per-category, per-UI-style, and per-data-type breakdowns. --json report.json writes the full report.

Turning model output into a point

Models emit clicks in many shapes; map them to [x, y] pixels before scoring. For example, a <click>x,y</click> tag or a normalized 0-1 / 0-999 point:

import re
def to_point(text, w=1024, h=768):
    m = re.search(r"(-?\d+(?:\.\d+)?)\s*[,\s]\s*(-?\d+(?:\.\d+)?)", text)
    x, y = float(m.group(1)), float(m.group(2))
    if max(x, y) <= 1.0:   x, y = x * w, y * h          # normalized 0-1
    elif max(x, y) <= 999: x, y = x / 999 * w, y / 999 * h  # 0-999 grid
    return [round(x), round(y)]

Baselines

Model	Accuracy	Notes
Center-click (512, 384)	0.6%	sanity floor
your model here	n/a	open a PR

Construction & reproducibility

Examples are rendered programmatically (pure PIL, no browser, no real files), so every ground-truth box is pixel-exact. The set is held out: it is built with a generation seed disjoint from any training data, so no benchmark sheet is reused for training. The generator and the exact build command live in the source repo; see REPRODUCE.md.

Limitations

Fully synthetic: realistic but not screenshots of real workbooks.
Fixed 1024×768 resolution; instructions in English/German only.
Targets are cells, headers, colored regions, grid/resize edges, cell corners, and relative cell offsets, not in-sheet charts, shapes, or app chrome (menus/toolbars are decorative and never targets).

Citation

@misc{pointerbench_sheets_2026,
  title  = {Pointerbench-Sheets: A GUI Grounding Benchmark for Spreadsheets},
  author = {Pointerbench-Sheets contributors},
  year   = {2026},
  url    = {https://github.com/YOUR_ORG/pointerbench-sheets}
}

License

Data (images + annotations): CC BY 4.0.
Code (eval.py): MIT.