Datasets:

WarmwindOS
/

pointerbench

A 500-example GUI grounding benchmark for professional desktop software. Given a screenshot of a professional application and a short functional instruction (e.g. "Begin a performance recording.", "Select the Bass track.", "Open the Browser panel."), a model must output the pixel coordinate to click. Scored exactly like ScreenSpot and ScreenSpot-Pro: a click is correct if it lands inside the target's bounding box.

Why professional apps?

Everyday GUI suites are dominated by browsers and consumer apps. Real agent work happens in dense expert tools: IDEs, DAWs, CAD, GIS, EDA, data and analytics consoles, scientific software. Their interfaces are packed with small icons and tightly labeled controls, which is exactly where grounding breaks down. Pointerbench-Pro targets that regime across 100 professional applications, with the generated target mix preserved instead of forcing a fixed icon/text quota.

What's inside

500 examples, one instruction per image.
1024x768 PNG screenshots, fully synthetic (model-dreamed UIs, no scraping, no PII).
100 applications spanning development, creative, scientific, CAD/engineering, productivity, enterprise, office, communication, analytics, finance, and OS/system surfaces.
3 target types from the generated source pools:

element_type count example instruction

icon 190 Find a packet.

other 156 Select the red-coat clip.

text 154 Switch to Home.
Multiple platforms (Windows, macOS, Linux, plus a few embedded/mobile).
Functional intent prompts (not literal element names), matching the ScreenSpot-Pro task style.

element_type	count	example instruction
`icon`	190	Find a packet.
`other`	156	Select the red-coat clip.
`text`	154	Switch to Home.

Schema

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

{
  "file_name": "0000.png",
  "id": "pbp_0000",
  "instruction": "Begin a performance recording.",
  "bbox": [596, 376, 681, 395],
  "point": [638, 385],
  "answer_type": "point",
  "eval": {"type": "point_in_bbox", "bbox": [596, 376, 681, 395]},
  "data_type": "icon",
  "element_type": "icon",
  "app": "Google Chrome DevTools",
  "app_slug": "chrome_devtools",
  "app_category": "development",
  "platform": "Windows 11 / Chrome",
  "source_id": "images_chrome_devtools_02_el8",
  "source_file": "clicks_icons_pro_3k.ndjson",
  "image_size": [1024, 768]
}

bbox: ground-truth target, [x1, y1, x2, y2] in absolute pixels (top-left, bottom-right) on the 1024x768 image. A prediction is correct iff it lands inside this box.
point: the box center.
answer_type / eval: binary evaluation rule. Pro rows are point answers scored with point-in-bbox.
element_type (= data_type): icon, text, or other.
app / app_slug / app_category / platform: the source application and its metadata, for per-app result breakdowns.

A machine-readable coverage summary (counts per app, category, platform) is in apps.json.

Quickstart

Load the data

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

from datasets import load_dataset
ds = load_dataset("YOUR_ORG/pointerbench-pro", split="test")
ex = ds[0]
ex["image"]        # PIL.Image, 1024x768
ex["instruction"]  # "Begin a performance recording."
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 1024x768 image).
Write predictions as JSONL, one object per example:
```
{"id": "pbp_0000", "point": [612, 388]}
```

Score (pure standard library, no dependencies):

python eval.py --predictions preds.jsonl --json report.json

Pointerbench-Pro: 500 examples
============================================
Accuracy: 41.20%   (206/500)

By target type:
 icon                     33.20%   (n=190)
 other                    37.18%   (n=156)
 text                     49.35%   (n=154)
  ...

The scorer reports overall accuracy plus per-target-type, per-app-category, and per-platform breakdowns; the per-app table is in the --json 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)	low	sanity floor
your model here	n/a	open a PR

Construction

Screenshots are dreamed by an image model from per-app scenario prompts (one scene per professional application), so the UIs are realistic but contain no real user data.
Boxes are pixel-exact: a copy of each screenshot is edited to paint the target region, and the box is recovered by diffing the edit against the clean image. QA gates reject ambiguous or oversized regions.
Targets come from the labeled professional-icon pool and the general professional GUI intent pool. They are labeled as icon, text, or other for analysis, but they are not filtered to a fixed element-type ratio.

The selected source_ids are listed in heldout_source_ids.txt so they can be excluded from any training set built from the same generator. See REPRODUCE.md.

Limitations

Fully synthetic: realistic but not screenshots of the real applications.
Fixed 1024x768 resolution; instructions in English.
The text / other label for the general intent pool is derived by a description heuristic rather than human annotation.

Citation

@misc{pointerbench_pro_2026,
  title  = {Pointerbench-Pro: A GUI Grounding Benchmark for Professional Software},
  author = {Pointerbench-Pro contributors},
  year   = {2026},
  url    = {https://github.com/YOUR_ORG/pointerbench-pro}
}

License

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