| # Pointerbench-Pro |
|
|
| **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](https://github.com/njucckevin/SeeClick) 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. |
| |
| ## Schema |
| |
| Each line of `data/test/metadata.jsonl` (HuggingFace `imagefolder` layout): |
| |
| ```json |
| { |
| "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`](apps.json). |
|
|
| ## Quickstart |
|
|
| ### Load the data |
|
|
| Via HuggingFace `datasets` (after the set is pushed to the Hub): |
|
|
| ```python |
| 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: |
|
|
| ```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 (absolute pixels on the 1024x768 image). |
| 3. Write predictions as JSONL, one object per example: |
|
|
| ```json |
| {"id": "pbp_0000", "point": [612, 388]} |
| ``` |
|
|
| 4. Score (pure standard library, no dependencies): |
|
|
| ```bash |
| 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: |
|
|
| ```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 |
|
|
| - **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_id`s are listed in `heldout_source_ids.txt` so they can be |
| excluded from any training set built from the same generator. See |
| [`REPRODUCE.md`](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 |
|
|
| ```bibtex |
| @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](LICENSE). |
| - **Code** (`eval.py`): MIT. |
|
|
