| # Pointerbench-Sheets |
|
|
| **A 500-example GUI grounding benchmark for spreadsheets.** Given a spreadsheet |
| screenshot and a short instruction (e.g. *"Click cell E33"*, *"Click the orange |
| cell"*, *"Click the Revenue column header"*, *"Drag to resize column C"*), a model must output the pixel |
| coordinate to click. Scored exactly like [ScreenSpot](https://github.com/njucckevin/SeeClick): |
| **a click is correct if it lands inside the target's bounding box.** |
|
|
|  |
|
|
| ## Why spreadsheets? |
|
|
| General GUI-grounding suites (ScreenSpot, ScreenSpot-v2, ScreenSpot-Pro) are |
| broad but **thin on spreadsheets**, yet spreadsheets are where grounding is |
| hardest: hundreds of near-identical small cells, dense grids, colored fills, |
| header rows, scroll positions that rarely start at `A1`, and click targets that |
| are not ordinary objects at all. Resizing a column means clicking the thin line |
| between columns; selecting a cell corner means landing on one grid intersection; |
| following "three cells below A5" means reasoning over grid coordinates, not OCR |
| tokens. Pointerbench-Sheets isolates this spreadsheet-specific |
| grounding skill across four real spreadsheet UI skins plus a chrome-free grid. |
|
|
| ## What's inside |
|
|
| - **500** examples, one instruction per image. |
| - **1024×768** PNG screenshots, fully synthetic (no scraping, no PII). |
| - **5 UI styles**: Excel, Excel (white), Google Sheets, LibreOffice Calc, and a |
| bare chrome-free grid. |
| - **16 task categories**: |
|
|
| | category | data_type | instruction example | |
| | ------------------ | --------- | ------------------------------------------ | |
| | `cell_ref` | cell | *Click cell C12.* | |
| | `cell_ref_content` | cell | *Click cell C12 containing "Madrid".* | |
| | `cell_content` | cell | *Click the cell containing "Madrid".* | |
| | `col_header` | header | *Click the column D header.* | |
| | `row_header` | header | *Click the row 18 header.* | |
| | `cell_color` | color | *Click the orange cell.* | |
| | `col_resize_handle`| edge | *Click the divider after column D.* | |
| | `row_resize_handle`| edge | *Click the lower border of row 18.* | |
| | `cell_right_edge` | edge | *Click the right edge of cell C12.* | |
| | `cell_bottom_edge` | edge | *Click the bottom edge of cell C12.* | |
| | `cell_top_left_corner` | corner | *Click the top-left corner of cell C12.* | |
| | `cell_top_right_corner` | corner | *Click the top-right corner of cell C12.* | |
| | `cell_bottom_left_corner` | corner | *Click the bottom-left corner of cell C12.* | |
| | `cell_bottom_right_corner` | corner | *Click the bottom-right corner of cell C12.* | |
| | `cell_relative_row` | relative | *Click the cell 3 rows below D18.* | |
| | `cell_relative_offset` | relative | *From B7, move 3 columns right and 1 row down.* | |
|
|
| - Randomized realism: per-sheet font family/size, per-column text color / bold / |
| alignment, colored fills (single cell / row / column / stripe), banded rows, a |
| selected-cell distractor, and **random row + column scroll offsets** (the |
| window does not always start at `A1`). |
| - ~10% of instructions are in German (`language` field), the rest English. |
|
|
| ## Schema |
|
|
| Each line of `data/test/metadata.jsonl` (HuggingFace `imagefolder` layout): |
|
|
| ```json |
| { |
| "file_name": "0000.png", |
| "id": "pbs_0000", |
| "instruction": "Click cell E33.", |
| "bbox": [596, 376, 681, 395], |
| "point": [638, 385], |
| "data_type": "cell", |
| "category": "cell_ref", |
| "ui_style": "excel", |
| "language": "en", |
| "image_size": [1024, 768] |
| } |
| ``` |
|
|
| - **`bbox`**: ground-truth target, **`[x1, y1, x2, y2]` in absolute pixels** |
| (top-left, bottom-right) on the 1024×768 image. A prediction is correct iff it |
| lands inside this box. |
| - **`point`**: the box center (a convenient single-point reference). |
| - **`data_type`**: coarse ScreenSpot-style class (`cell` / `header` / `color` / `edge` / `corner` / `relative`). |
| - **`category`**: the fine-grained task kind. |
| - **`ui_style`**: the rendered app skin. |
|
|
| ## Quickstart |
|
|
| ### Load the data |
|
|
| Via 🤗 `datasets` (after the set is pushed to the Hub): |
|
|
| ```python |
| from datasets import load_dataset |
| ds = load_dataset("YOUR_ORG/pointerbench-sheets", split="test") |
| ex = ds[0] |
| ex["image"] # PIL.Image, 1024x768 |
| ex["instruction"] # "Click cell E33." |
| 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 1024×768 image). |
| 3. Write predictions as JSONL, one object per example: |
|
|
| ```json |
| {"id": "pbs_0000", "point": [612, 388]} |
| ``` |
|
|
| 4. Score (pure standard library, no dependencies): |
|
|
| ```bash |
| python eval.py --predictions preds.jsonl |
| ``` |
|
|
| ``` |
| Pointerbench-Sheets: 500 examples |
| ============================================ |
| Accuracy: 73.40% (367/500) |
| |
| By category: |
| cell_color 61.11% (n=72) |
| cell_ref 81.46% (n=178) |
| ... |
| ``` |
|
|
| The scorer reports overall accuracy plus per-category, per-UI-style, and |
| per-data-type breakdowns. `--json report.json` writes the full 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) | 0.6% | sanity floor | |
| | _your model here_ | n/a | open a PR | |
|
|
| ## Construction & reproducibility |
|
|
| Examples are rendered programmatically (pure PIL, no browser, no real files), |
| so every ground-truth box is pixel-exact. The set is **held out**: it is built |
| with a generation seed disjoint from any training data, so no benchmark sheet is |
| reused for training. The generator and the exact build command live in the |
| [source repo](https://github.com/YOUR_ORG/YOUR_GENERATOR_REPO); see |
| [`REPRODUCE.md`](REPRODUCE.md). |
|
|
| ## Limitations |
|
|
| - Fully synthetic: realistic but not screenshots of real workbooks. |
| - Fixed 1024×768 resolution; instructions in English/German only. |
| - Targets are cells, headers, colored regions, grid/resize edges, cell corners, |
| and relative cell offsets, not in-sheet charts, shapes, or app chrome |
| (menus/toolbars are decorative and never targets). |
|
|
| ## Citation |
|
|
| ```bibtex |
| @misc{pointerbench_sheets_2026, |
| title = {Pointerbench-Sheets: A GUI Grounding Benchmark for Spreadsheets}, |
| author = {Pointerbench-Sheets contributors}, |
| year = {2026}, |
| url = {https://github.com/YOUR_ORG/pointerbench-sheets} |
| } |
| ``` |
|
|
| ## License |
|
|
| - **Data** (images + annotations): [CC BY 4.0](LICENSE). |
| - **Code** (`eval.py`): MIT. |
|
|
