# 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.**

![teaser](assets/teaser.png)

## 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.