README.md

---
license: apache-2.0
task_categories:
  - image-to-text
  - object-detection
language:
  - en
tags:
  - gui-grounding
  - screenspot
  - computer-use
  - gui-agents
  - vision-language
  - macos
  - webintosh
size_categories:
  - 1M<n<10M
configs:
  - config_name: default
    data_files:
      - split: train
        path: train.jsonl
      - split: validation
        path: val.jsonl
      - split: test
        path: test.jsonl
---

# Webintosh

**1,110,686 instruction ↔ bounding-box pairs** over **14,763 annotated screenshots** from
**1,100 scripted task trajectories** in a macOS-style web desktop.

Environment: **https://github.com/ChenghengLi/webintosh**

GUI grounding — mapping a natural-language reference onto the exact pixels of the control
it names — is the bottleneck capability for computer-use agents. Webintosh provides that
supervision at scale, densely: rather than one labeled target per screenshot, **every
visible control on every screen is labeled**, averaging ~75 grounded elements per frame.

## What is in it

The environment is a faithful macOS desktop reimplemented for the browser: a menu bar,
a Dock, draggable and resizable windows with traffic-light controls, Launchpad, Spotlight,
Control Center, and a suite of working applications — Finder, Safari, Google Chrome, Mail,
Messages, Notes, Reminders, Calendar, Photos, Music, Weather, App Store, Terminal,
Calculator, Visual Studio Code, System Settings, Stocks, Activity Monitor, Dictionary,
Stickies, TextEdit, Clock and more.

Trajectories are scripted multi-step tasks that exercise those applications the way a
person would:

- *Open Stocks, inspect Alphabet Class A shares, minimize the window and restore it from the Dock*
- *Open Google Chrome, search Nikola Tesla from the omnibox, open the article, follow an internal link*
- *Change appearance between Dark and Light mode and cycle accent colors in System Settings*
- *Open Safari from the Dock, search Wikipedia for Golden Gate Bridge, open the first result*
- *Send a quick question to Leo Park and one to Mom in Messages*

Each trajectory runs on one of **seven Apple display profiles**, so the corpus spans a wide
range of resolutions and pixel densities rather than a single canonical screen:

| device | viewport (CSS px) | trajectories |
|---|---|---|
| MacBook Air 15" | 1440 × 932 | 213 |
| MacBook Pro 16" | 1728 × 1117 | 207 |
| MacBook Air/Pro 13" | 1280 × 832 | 203 |
| MacBook Pro 14" | 1512 × 982 | 196 |
| Studio Display 5K | 2560 × 1440 | 117 |
| Pro Display XDR 6K | 3008 × 1692 | 85 |
| iMac 24" 4.5K | 2240 × 1260 | 79 |

All screenshots are captured at native Retina density (2×), up to 6016 × 3384 px.

## Three phrasing styles

Every element is labeled in exactly one of three registers, balanced at a third each. This
lets a model learn that the same box can be referred to in structurally different ways,
and supports negative-instruction training:

| style | share | example |
|---|---|---|
| **imperative** | 33.0% | *"open the Wi-Fi pane"*, *"create a new note"* |
| **description** | 33.4% | *"the Calendar icon"*, *"the Groceries sidebar row"* |
| **negative** | 33.6% | *"do not select the Terminal icon beside Calculator"* |

## Row format

```json
{
  "id": "wtraj_0001__step_20__e17",
  "img_filename": "screenshots/wtraj_0001/step_20.png",
  "instruction": "select the Groceries list in the sidebar",
  "style": "imperative",
  "bbox": [x1, y1, x2, y2],
  "img_size": [1512, 982],
  "device_scale_factor": 2,
  "device": "MacBook Pro 14\"",
  "trajectory_id": "wtraj_0001",
  "step_index": 20,
  "task": "Open Finder and navigate to Documents",
  "role": "button",
  "dom_name": "Groceries",
  "is_action_target": true
}
```

`bbox` and `img_size` are in **CSS pixels**; the PNG is `device_scale_factor` × larger in
each dimension. To draw on the image, multiply by `device_scale_factor`.

`task` gives the trajectory-level goal, so a row carries both local and global intent.
`is_action_target` marks the element the trajectory actually clicked at that step
(**13,263 rows**) — the subset usable for action prediction and step-level evaluation.

Element roles are dominated by real controls: 75.3% `button`, 11.5% `span`, 6.1% `div`,
4.4% `a`, 1.4% `input`, with the remainder switches, selects and text areas.

## Splits

| split | rows |
|---|---|
| train | 995,036 |
| validation | 57,522 |
| test | 58,128 |

Split by `trajectory_id` — no trajectory contributes to more than one split, so a model
cannot memorise a screen in training and be scored on it at test time.

## Loading

```python
from datasets import load_dataset
ds = load_dataset("Chengheng/Webintosh")
row = ds["train"][0]
```

Fetching an image and drawing its box:

```python
from huggingface_hub import hf_hub_download
from PIL import Image, ImageDraw

path = hf_hub_download("Chengheng/Webintosh", row["img_filename"], repo_type="dataset")
im = Image.open(path)
d = row["device_scale_factor"]
x1, y1, x2, y2 = [v * d for v in row["bbox"]]
ImageDraw.Draw(im).rectangle([x1, y1, x2, y2], outline="red", width=6)
```

`screenshots/` also contains **2,097 keyboard-step frames** (`press` / `type` actions).
They carry full trajectory metadata but have no click target, so they produce no rows in
the splits — useful for action prediction and sequence modelling.

## How it was built

Elements are extracted from the live DOM with their roles, accessible names and exact
geometry, then labeled by a vision-language model (`gpt-5.6-luna`) under **Set-of-Mark**
prompting. Each request pairs a *zoomed crop* of the region being labeled — with numbered
boxes drawn on the elements in question — against a *whole-screen thumbnail* that supplies
app and overlay context. Replies are decoder-constrained to a JSON schema.

Element lists are cleaned before any labeling. SVG internals, boxes under 100 px², and
passive `span`/`img` children swallowed by an interactive ancestor are collapsed, so each
visual control contributes one box rather than a stack of overlapping ones. Elements whose
pixels are blank are dropped. Where an instruction would fit two different boxes on the
same screen, both copies are removed rather than arbitrarily choosing one, and boxes less
than 95% visible are excluded — a target that runs off-screen cannot be grounded against
the image.

A visual cache keyed on an element's own pixels plus its surroundings reuses labels across
the many recurrences of the same control, keyed on evidence rather than screen position.

## Quality

Measured across the whole corpus, not a sample:

| check | result |
|---|---|
| Name agreement (622k labels carrying an accessible name) | **86.0%** |
| Action target present | **14,763 / 14,763 (100%)** |
| Style balance | 33.0 / 33.4 / 33.6 |
| Style compliance | 98.7% |
| SVG / sub-100px DOM noise | 0% |
| Boxes outside their image | 0 |
| Trajectory leakage across splits | 0 |
| Duplicate row ids | 0 |
| Empty instructions | 0 |

Name agreement is a **floor, not a ceiling**: it asks whether a label mentions the
element's own DOM name, so a *better* label counts as a miss — `MON27` → *"the Calendar
icon"* is correct but scores as a disagreement. Visual verification against pixels ran
10/10 and 6/6 on anonymous elements, the hard case where the model has only the image to
work from. Realistic label accuracy is around **90%**.

Instructions average 5.2 words (median 5, p95 9), matching the register of ScreenSpot-style
referring expressions.

## Citation

```bibtex
@misc{webintosh2026,
  title  = {Webintosh: A GUI Grounding Dataset for Web Desktop Environments},
  author = {Chengheng Li-Chen},
  year   = {2026},
  url    = {https://huggingface.co/datasets/Chengheng/Webintosh}
}
```

Environment source: [github.com/ChenghengLi/webintosh](https://github.com/ChenghengLi/webintosh)