Datasets:

WarmwindOS
/

pointerbench

A 500-example GUI grounding benchmark for text. Given a screenshot of a text-rich interface and a short instruction (e.g. "Click the word 'invoice'", "Place the cursor between the 'r' and 'e' in 'erfolgreich'", "Return the bounding box of this paragraph"), a model must output either a pixel coordinate or a bounding box. Point answers are correct if they land inside the target box. Bbox answers use an asymmetric overlap rule: the ground truth must be almost fully covered while the prediction stays reasonably tight around it (see Evaluation).

Why text?

General GUI-grounding suites (ScreenSpot, ScreenSpot-v2, ScreenSpot-Pro) target icons, buttons, and widgets, but they barely test pointing inside running text: a specific word among hundreds of near-identical ones, a single character, a punctuation mark, or a caret position between two letters. That precision is exactly what cursor-based editing, proofreading, and text-selection agents need. Pointerbench-Text isolates it across many real text surfaces and five languages.

What's inside

500 examples, one instruction per image.
1024x768 PNG screenshots, fully synthetic (no scraping, no PII).
Many text surfaces: articles, books, email inbox and threads, chat, Slack, code editors, terminals, markdown notes, docs sites, forums, social feeds, search results, data tables, log viewers, invoices, and dozens more (119 distinct surfaces).

7 data types (interaction granularity):

data_type	example instruction
`word`	Click the word "invoice".
`char`	Click the second "e" in "settlement".
`punctuation`	Click the period after "done".
`caret`	Place the cursor between the "r" and "e" in "core".
`chrome`	Click "Settings" in the toolbar.
`bbox`	Return the bbox of the paragraph beginning with "In".
`invoice`	Draw a box around the subtotal.

Fine-grained categories under those types (word center, char center, punctuation, caret before/after/between, between words, line start/end, sentence boundary, paragraph start/end, blank line, chrome label, word bbox, char bbox, line bbox, paragraph bbox).
Invoice fields (70 examples): bounding boxes for real invoice anatomy: invoice number, dates, sender/recipient blocks, line items and the full line-item table, subtotal, tax / VAT ID, total, IBAN/BIC, and bank details. These are dedicated invoice surfaces so the target is unambiguous.
5 languages, Latin alphabet only: 50% English; the other 50% split evenly across German, French, Spanish, Italian, Dutch.
Difficulty tag (easy / medium / hard) from font size, target kind, and theme contrast.
Randomized realism: 20 font families, mixed sizes, per-span color / bold / italic / underline / highlight / link / code / strike / faded styling, light and dark themes, plus film grain, JPEG artifacts, and fake caret / cursor distractors.

Schema

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

{
  "file_name": "0000.png",
  "id": "pbt_0000",
  "instruction": "Click the word \"invoice\".",
  "bbox": [596, 376, 681, 395],
  "point": [638, 385],
  "answer_type": "point",
  "eval": {"type": "point_in_bbox", "bbox": [596, 376, 681, 395]},
  "data_type": "word",
  "category": "word_center",
  "surface": "email_thread",
  "language": "en",
  "difficulty": "medium",
  "image_size": [1024, 768]
}

bbox: ground-truth target, [x1, y1, x2, y2] in absolute pixels (top-left, bottom-right) on the 1024x768 image. For point rows, a prediction is correct iff it lands inside this box. For bbox rows, the prediction is scored against this box with the asymmetric coverage/precision rule (see Evaluation).
point: a reference click point inside the box.
answer_type: point or bbox.
eval: binary evaluation rule for this row.
data_type: coarse interaction granularity (see table above).
category: the fine-grained target kind.
surface: the rendered surface (app/document skin).
language: instruction language (en, de, fr, es, it, nl).
difficulty: easy / medium / hard.

Quickstart

Load the data

Via HuggingFace datasets:

from datasets import load_dataset
ds = load_dataset("WarmwindOS/pointerbench", data_dir="pointerbench-text", split="test")
ex = ds[0]
ex["image"]        # PIL.Image, 1024x768
ex["instruction"]  # "Click the word \"invoice\"."
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 or bbox (absolute pixels on the 1024x768 image).

Write predictions as JSONL, one object per example:

{"id": "pbt_0000", "point": [612, 388]}
{"id": "pbt_0001", "bbox": [193, 643, 807, 688]}

Score (pure standard library, no dependencies):

python eval.py --predictions preds.jsonl

Pointerbench-Text: 500 examples
============================================
Accuracy: 64.20%   (321/500)

By data type:
  caret               48.81%   (n=168)
  char                55.56%   (n=18)
  ...

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

Bbox scoring rule. Point rows use point-in-bbox. Bbox rows (text bounding boxes and invoice fields) use an asymmetric overlap rule instead of plain IoU: a hit requires coverage >= 0.90 (share of the ground-truth area inside the prediction) and precision >= 0.70 (share of the prediction inside the ground truth). Cutting off part of the target is penalised far more than wrapping it with some margin, which matches what text-grounding actually needs. The thresholds are configurable per row via eval.min_coverage / eval.min_precision.

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 and reproducibility

Examples are rendered programmatically (pure PIL, no browser, no real files), so every ground-truth box is pixel-exact: the layout engine records per-glyph geometry and an independent verifier confirms each instruction resolves to exactly one target before the example is kept. The set is held out: it is built with a generation seed disjoint from any training data, so no benchmark page 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 applications.
Fixed 1024x768 resolution; Latin-script languages only.
Non-English instructions reference targets by quoted word or chrome label; the fine-grained caret/char/punctuation categories are English and German.
Targets are words, characters, punctuation, caret positions, and chrome labels, and text bboxes, not icons, images, or widgets.

Citation

@misc{pointerbench_text_2026,
  title  = {Pointerbench-Text: A GUI Grounding Benchmark for Text},
  author = {Maximilian Schilling and Warmwind AG},
  year   = {2026},
  url    = {https://github.com/warmwindOS/pointerbench}
}

License

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