| # Pointerbench-Text |
|
|
| **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](#evaluate)). |
|
|
|  |
|
|
| ## 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): |
| |
| ```json |
| { |
| "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](#evaluate)). |
| - **`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`: |
| |
| ```python |
| 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: |
| |
| ```python |
| 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 |
| |
| 1. 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. |
| 2. Run your model on every example's `instruction` + image and collect a |
| predicted click point or bbox (absolute pixels on the 1024x768 image). |
| 3. Write predictions as JSONL, one object per example: |
| |
| ```json |
| {"id": "pbt_0000", "point": [612, 388]} |
| {"id": "pbt_0001", "bbox": [193, 643, 807, 688]} |
| ``` |
| |
| 4. Score (pure standard library, no dependencies): |
| |
| ```bash |
| 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: |
|
|
| ```python |
| 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](https://github.com/warmwindOS/pointerbench); see |
| [`REPRODUCE.md`](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 |
|
|
| ```bibtex |
| @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](LICENSE). |
| - **Code** (`eval.py`): MIT. |
|
|
