Cianmcnally/cursor-streams

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

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.

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

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

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 — MIT. 8,598 sessions here. arXiv:2603.24440
• anaisleila/computer-use-data-psai (Paradigm Shift AI) — MIT. 2,751 sessions here.
• 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

@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}
}