README.md

---
license: cc-by-4.0
language:
- en
task_categories:
- video-classification
- other
tags:
- computer-use
- gui-agents
- click-detection
- cursor-tracking
- inverse-dynamics
- action-prediction
- desktop
- human-demonstrations
- video
size_categories:
- 10M<n<100M
configs:
- config_name: sessions
  data_files: sessions.parquet
- config_name: clicks
  data_files: clicks.parquet
- config_name: cursor_track
  data_files: tracks/cursor_*.parquet
- config_name: window_track
  data_files: tracks/window_*.parquet
---


<!-- CURSOR_STREAMS_RELEASE_SUMMARY_START -->

# Cursor Streams

**The largest open human computer-use video dataset combining precise mouse-event annotations with frame-by-frame cursor localization.**

Cursor Streams is a **156-hour human computer-use dataset** containing **11,746 desktop interaction trajectories**, **16,848,718 frame-level cursor annotations**, and **61,804 precisely timestamped mouse interaction events** across **105 foreground applications**.

It combines continuous screen video with accurate click timing and dense frame-by-frame cursor bounding boxes, providing large-scale training data for **inverse dynamics models, GUI action recognition, cursor tracking, computer-use agents, and precise temporal event spotting**.

| Statistic | Size |
|---|---:|
| Human trajectories | 11,746 |
| Video | 156 hours |
| Annotated frames | 16,848,718 |
| Mouse interaction events | 61,804 |
| Foreground applications | 105 |

### Human-only data

All trajectories included in this release are human computer-use recordings. For **A11y-CUA specifically, only the human-recorded trajectories are included; agent-generated trajectories are excluded.**

The release unifies the source datasets into a common representation containing continuous video, session metadata, mouse-event timing, cursor trajectories, cursor bounding boxes, and foreground-window information.

<!-- CURSOR_STREAMS_RELEASE_SUMMARY_END -->

# Cursor Streams

**156 hours of real human desktop use — 16.8 M frames at 30 fps — where every single frame
carries a cursor bounding box, and every click carries a frame-accurate timestamp.**

Screen recordings of people using computers are abundant. Recordings where you know
*exactly which frame the mouse button went down on*, and *exactly where the cursor was on
every frame in between*, are not. That second thing is what this dataset is: three public
human computer-use corpora re-synchronised, cursor-tracked, and re-emitted in one format,
with the alignment work — the part that is normally left as an exercise — already done and
measured.

To the best of my knowledge this is the largest corpus of human desktop interaction that
has **both** frame-accurate click labels **and** dense per-frame cursor localisation.
Bigger raw video corpora exist; corpora with cursor boxes on every frame do not.

|  | |
|---|---|
| Sessions | **11,746** |
| Frames | **16,848,718** (30 fps, constant frame rate) |
| Duration | **156.0 hours** |
| Mouse-down events | **60,302** |
| Click pairs / drags | **49,819** / **8,023** |
| Cursor boxes | **one per frame — 16.8 M** |
| Applications | **113** (7-Zip → Blender → VS Code → Chrome → QGIS) |
| Platforms | Windows, Linux desktops |
| Median session | 22 s |

## Why it exists

It was built to train a **click inverse-dynamics model**: given only the pixels, decide on
which frame a physical mouse button went down. That is the missing half of learning from
screen recordings — a video shows you what happened, but not what the human *did*, and a
click is invisible unless you can read the 2-3 frame press animation under the cursor.
Solve it and every unlabelled screen recording becomes action-labelled training data.

It is also directly usable for: cursor detection/tracking (16.8 M boxes), GUI grounding
with real trajectories, action-timing models, drag/click discrimination, and video-to-action
pretraining.

## Contents

```
sessions.parquet             11,746 rows — one per session, with splits and task text
clicks.parquet               60,302 rows — every mouse-down, with sub-frame position
tracks/cursor_<source>.parquet   16.8 M rows — per-frame cursor tip + bounding box
tracks/window_<source>.parquet   16.8 M rows — per-frame focused window rect + app/title
data/<source>/<session_id>/
    recording.mp4            cursor-centred square crop, 30 fps, cursor composited
    window.mp4               focused window, letterboxed into a 640x400 canvas
    meta.json                geometry, clocks, task metadata, per-session QA fields
    osclicks.jsonl           raw input events as recorded (down/up, epoch ms, x, y)
```

Sources are kept separate on disk (`a11y-cua`, `psai`, `videocua`) but share one schema.

### `clicks.parquet`

| column | meaning |
|---|---|
| `session_id`, `source`, `split` | join keys |
| `kind` | `click`, `drag`, or `down_only` (no matching release) |
| `down_frame`, `up_frame` | **fractional** frame index of the press / release |
| `down_epoch_ms`, `up_epoch_ms` | original event clock |
| `x`, `y` | press position, screen pixels |
| `duration_s`, `displacement_px` | press length, cursor travel between down and up |
| `click_count`, `app`, `ax_role`, `dud` | double-click index, foreground app, a11y role, no-effect flag |

`down_frame` is fractional on purpose: the press happened *between* two frames and the
label says where. Round it for a hard target, or keep the sub-frame residual as a
regression target.

### `tracks/cursor_*.parquet`

| column | meaning |
|---|---|
| `session_id`, `frame`, `epoch_ms` | join keys / wall clock |
| `cursor_x`, `cursor_y` | cursor **tip**, screen pixels |
| `crop_x`, `crop_y` | origin of `recording.mp4`'s crop for this frame |
| `box_x1 … box_y2` | cursor bounding box, screen pixels |
| `box_source` | `detected`, `tracked_session`, or `tracked_prior` (see below) |

### Coordinates

Every released session has `dpr = 1`, so screen pixels and video pixels are the same unit.

```python
# a point in the cursor crop (recording.mp4 is cursor_crop_size x cursor_crop_size)
u, v = x - crop_x, y - crop_y

# the same point in window.mp4 (window.jsonl maps into a 1280x800 canvas; the
# video is that canvas at half scale)
u = ((x - win.x) * win.scale + win.tx) * 0.5
v = ((y - win.y) * win.scale + win.ty) * 0.5
```

## How the cursor boxes were made

The cursor **tip** track is dense and comes from the strongest source each corpus has:
125 Hz mouse telemetry (psai), or an RF-DETR cursor detector fused with the event stream
(a11y-cua, videocua). The **box** around that tip is the detector's box wherever a
detection was accepted on that frame, and elsewhere the tip plus a glyph extent measured
from that session's own detections. Sessions with too few detections fall back to a global
prior.

That prior is `(-1.0, 0.0, +17.0, +26.5)` px from the tip, and it is not a guess: it was
measured twice, independently, and the two agree —

* 34,204 RF-DETR detections over 250 psai sessions → `(-0.74, 0.30, 17.29, 27.24)`
* 24,060 dense ground-truth boxes from the a11y-cua conversion → `(-1.5, -1.5, 16.2, 25.5)`

`box_source` tells you exactly which case a row is, so you can train on `detected` rows
only if you want detector-grade boxes, or use all 16.8 M for tip-anchored supervision.

## How accurate are the labels

Each corpus was re-anchored against its own video and the residual recorded per session in
`meta.json`, so accuracy is a measured quantity here, not a claim:

| source | sessions | hours | cursor source | time anchor | anchor residual (p50 / p90) |
|---|---|---|---|---|---|
| videocua | 8,598 | 50.5 | RF-DETR fused | none needed — timestamps verified frame-accurate | — |
| psai | 2,751 | 95.6 | 125 Hz telemetry | RF-DETR fit against video (1,575) / OBS prior (1,176) | 2.05 px / 5.4 px |
| a11y-cua | 397 | 9.9 | RF-DETR fused | motion cross-correlation + RF-DETR fit | 3.3 px / 7.0 px |

The residual is the median distance, in screen pixels, between where the event stream says
the cursor was and where the detector found it in the frame — an agreement check between
two fully independent sources, so a low residual certifies the time anchor *and* the
coordinate mapping at once.

**Caveat worth reading:** the 1,176 psai sessions with `anchor_method = prior_static` had
a cursor too still to pin the clock visually, so they keep the coarse recording-software
anchor. Filter them out of any timing evaluation:

```python
sessions[sessions.anchor_method == "rfdetr_fit"]
```

## Splits

Split by session, in `sessions.parquet`:

| split | sessions |
|---|---|
| `train` | 10,922 |
| `val_videocua` / `val_psai` / `val_a11ycua` | 40 / 20 / 10 |
| `test_videocua` / `test_psai` / `test_a11ycua` | 680 / 20 / 54 |

Validation and test are held out per source so you can measure cross-corpus transfer
instead of averaging it away. Sessions from the same source episode never straddle a split.

## Click detection: baseline numbers

A supervised click IDM was trained on an earlier, much smaller mix (320 sessions,
6,108 mouse-downs — roughly **5 % of what is released here**) to establish that clicks are
recoverable from pixels at all. Architecture: dual-stream CNN + non-causal dilated TCN,
3.8 M parameters, cursor crop (64 px) + window view (192x120), 64-frame clips at 6 fps.
Click *position* is an input (the cursor track), never a prediction — the model only has to
answer *when*.

Held-out test, threshold 0.5, click-pair matching at ±7 source frames (±233 ms, the
human-validated practical tolerance):

| test set | F1 | precision | timing error (median) |
|---|---|---|---|
| psai (in this release) | **0.557** | 0.589 | ~1 frame (33 ms) |
| own captures, dense clicking (not released) | **0.746 – 0.820** | 0.83 | ~1 frame (33 ms) |
| psai, previous model generation | 0.503 | 0.452 | |

At the tighter ±2-frame ruler the same predictions score ~0.33–0.45 — most remaining error
is timing, not detection, and it is dominated by near-click double-fires rather than
hallucinations on quiet screens (a zero-click probe session produced 0 false positives).

Three things moved these numbers more than any architecture change, and they are worth
knowing before you train on this data:

1. **Sample at ~6 fps, not 30.** Identical models scored ~5x higher F1 at stride 5 than at
   stride 1: a 30 fps clip is mostly redundant frames and too little context. The sweep
   peaked on a 5–6 fps plateau (64-frame clips ≈ 11 s of context).
2. **Match the training target to the evaluation ruler.** A one-frame hard target evaluated
   at ±7 frames trains the frames you will later score as *correct* as hard background;
   the model resolves the contradiction with a smeared, multi-peak response. Gaussian soft
   targets (σ 0.7 model frames) plus a don't-care ring cut near-click false positives
   40–50 % and background false positives 38–63 % in one change.
3. **Cursor-anchor your crop.** An earlier bug took the model's field of view from the
   frame centre rather than the cursor's position in it; whenever the crop clamped at a
   screen edge the cursor left the input entirely — on ~30 % of click frames in some
   sessions. Every number before that fix was invalid.

A run on the full release corpus is pending; these baselines are a floor, not a ceiling.

## Quickstart

```python
import pandas as pd, pyarrow.parquet as pq, cv2

sessions = pq.read_table("sessions.parquet").to_pandas()
clicks   = pq.read_table("clicks.parquet").to_pandas()

sid = sessions.query("source == 'videocua'").iloc[0].session_id
trk = pq.read_table("tracks/cursor_videocua.parquet",
                    filters=[("session_id", "=", sid)]).to_pandas()

# the frame a click landed on, with the cursor box drawn in crop coordinates
c = clicks[clicks.session_id == sid].iloc[0]
f = int(round(c.down_frame))
row = trk[trk.frame == f].iloc[0]

cap = cv2.VideoCapture(f"data/videocua/{sid}/recording.mp4")
cap.set(cv2.CAP_PROP_POS_FRAMES, f)
ok, img = cap.read()
x1, y1 = row.box_x1 - row.crop_x, row.box_y1 - row.crop_y
x2, y2 = row.box_x2 - row.crop_x, row.box_y2 - row.crop_y
cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), 1)
```

## Limitations

* **No macOS.** Windows and Linux desktops only.
* **Cursor boxes are mostly tip-anchored**, not per-frame detections — the tip is dense and
  measured, the glyph extent is a per-session or global constant. Use `box_source` to
  select. Rendered cursor size does vary (I-beam, resize, busy states) and that variation
  is not captured outside `detected` rows.
* **Frames where the cursor is invisible** (hidden during typing, video playback, some
  full-screen apps) still carry a box at the last known tip position.
* **`down_only` events** are mouse-downs whose release was not logged; they are labelled,
  not dropped.
* **Task instructions come from the source corpora** and describe intent, not outcome — a
  session's clicks are not guaranteed to accomplish its stated task.
* The 1,176 `prior_static` psai sessions have coarse time anchors (above).
* Audio, DOM snapshots, accessibility trees and screenshots from the source corpora are
  **not** included — fetch those from the originals if you need them.

## Sources and attribution

This is a derivative work. All credit for the underlying recordings goes to:

* **[ServiceNow/VideoCUA](https://huggingface.co/datasets/ServiceNow/VideoCUA)** — MIT.
  8,598 sessions here. `arXiv:2603.24440`
* **[anaisleila/computer-use-data-psai](https://huggingface.co/datasets/anaisleila/computer-use-data-psai)**
  (Paradigm Shift AI) — MIT. 2,751 sessions here.
* **[berkeley-hci/A11y-CUA](https://huggingface.co/datasets/berkeley-hci/A11y-CUA)** —
  CC-BY-4.0. 397 sessions here (the SU human-participant group). `arXiv:2602.09310`

Released under **CC-BY-4.0**, the strictest of the three, so the attribution requirement
carries through. If you use this, cite the source corpora above as well.

Own-machine captures used in development are deliberately **not** part of this release.

## Citation

```bibtex
@misc{mcnally2026cursorstreams,
  title  = {Cursor Streams: human computer-use video with frame-accurate clicks
            and dense cursor boxes},
  author = {McNally, Cian},
  year   = {2026},
  url    = {https://huggingface.co/datasets/Cianmcnally/cursor-streams}
}
```