README.md

---
license: other
license_name: origin-lab-data-license
license_link: LICENSE.md
pretty_name: Origin Lab Frame-Synced Multiplayer
task_categories:
- reinforcement-learning
- robotics
- depth-estimation
- image-to-video
annotations_creators:
- machine-generated
source_datasets:
- original
tags:
- video
- multi-view
- multi-agent
- multiplayer
- world-models
- video-prediction
- imitation-learning
- embodied-ai
- physical-ai
- game-agents
- theory-of-mind
- collaborative-perception
- slam
- rgbd
- metric-depth
- camera-pose
- action-labels
- game-engine
- frame-synchronization
- licensed-data
- origin-lab
size_categories:
- n<1K
extra_gated_heading: "Request access to Origin Lab Frame-Synced Multiplayer"
extra_gated_prompt: >-
  Two access tracks, defined in LICENSE.md. Track A, Internal Evaluation: 90
  days to train and evaluate models internally to assess the data. No
  obligation to publish anything. Track B, Non-Commercial Research: research
  use with attribution; publish freely. Under both tracks there is no
  commercial use, no deployment, and no redistribution in any form. Commercial
  licensing requires a direct agreement with Origin Lab: originlab.ai/hf.
extra_gated_fields:
  Name: text
  Organization: text
  Work email: text
  Access track:
    type: select
    options:
      - Track A, Internal Evaluation (90 days)
      - Track B, Non-Commercial Research
  Intended use: text
  I agree to the terms of my selected track in the LICENSE file: checkbox
configs:
- config_name: matches
  data_files: metadata/matches.parquet
  default: true
- config_name: timesync
  data_files: matches/*/timesync.parquet
- config_name: visibility
  data_files: matches/*/annotations/visibility.parquet
---

<p align="center">
  <img src="https://huggingface.co/datasets/originlab/brand-assets/resolve/main/logo.png" alt="Origin Lab" width="320">
</p>

# Origin Lab Frame-Synced Multiplayer: Eight Players, One Frame Clock

**Six to eight players, each on their own PC on residential internet, each
recording their own live view of one match, and frame *k* on every machine is
the same server instant, verified four independent ways, with the
verification script in this repo.** Every player ships the full engine stack
at 1080p / 60 FPS on one shared frame grid. Because the alignment is measured
rather than assumed, the release also ships per-frame cross-player
annotations: who has whom in view, at what angle and distance, and who is
being watched without knowing it.

*Version 0.2.0. Single title, four arena maps, 3v3 and 4v4.*

![Six synchronized player views with a live telemetry minimap rendered at the same instants](assets/previews/hero.gif)

*One match, one frame clock: six players' synchronized views, with their
camera telemetry (position and 90° view frustum) rendered on the minimap below
at the same server instants. When two frustums cross on the minimap, you
watch it happen in the video tiles.*

| | |
|---|---|
| Matches | 16 (ten 6-player, six 8-player) |
| Player-sessions | 108 |
| Player-hours | 108.0 |
| Size | ~3.8 TB |
| Shared grid frames | 3,454,524 |
| Engine events | 377,079 |
| View-crossing intervals | 73,676 |
| Titles | 1 (anonymized; disclosed under agreement) |
| Capture | 1080p / 60 FPS CFR, in-engine SDK, one shared frame clock across machines |
| Delivery | everything in this repository (~3.8 TB): all video, depth, telemetry, alignment, annotations, tools. Selective download by path prefix |

Watch full playable previews of every modality, side by side and in sync, at
**[app.originlab.ai/data](https://app.originlab.ai/data)**.

## Dataset summary

This dataset is a multiplayer companion to
[game-recordings-v3](https://huggingface.co/datasets/originlab/game-recordings-v3):
each player folder is the same eighteen-file session layout, recorded with the
same in-engine SDK, and everything v3 ships per session, this release ships
six to eight times over per match. What is new is the relationship between the
sessions. Multi-view gameplay datasets to date are replay-rendered: one demo
file re-rendered per viewpoint, synchronous by construction because there is
only one clock, and the real client-side frames, input timing, and depth are
lost. Here six to eight independently-clocked consumer PCs on residential
internet each capture their own live view of a shared match, and the
synchronization is achieved and then measured. A scheduled start pins every
machine's frame grid to one server instant, per-machine clock rates are
calibrated before capture and re-checked every minute during it, and the worst
validated player pair in the release slides 0.44 frames over a full hour. Most
matches hold under a quarter frame.

Because the alignment is measured rather than assumed, the release can ship
what no single-view dataset has: per-frame cross-player annotations. For every
ordered player pair at every grid instant, the data records whether one player
holds the other in view, with angular offset, screen position, and distance,
plus interval events built on top (mutual sight, first sight, blindside). All
of it is computed deterministically from the engine's own camera pose; no
annotators were involved.

## Supported tasks

| Task | Why this dataset |
|---|---|
| Multi-agent world models & video prediction | Up to eight adversarial viewpoints of one live scene with per-frame depth and pose: reproject one player's view into another's and measure the agreement. Public multi-agent gameplay corpora that we are aware of top out at two cooperative agents; pointers to others are welcome in Discussions. |
| Imitation learning & game agents | Every opponent's observation and action is recorded, not just the ego player's: opponent-conditioned policies, team coordination, and offline evaluation against real human adversaries. |
| Theory of mind & joint attention | Frustum-geometric labels for "A has B in view; B does not have A in view", computed from engine camera pose. Occlusion is not resolved in the shipped labels; the depth maps are what refining them into true line-of-sight requires. |
| Collaborative BEV perception | Six to eight synchronized egocentric RGB-D streams with per-frame pose observing one shared scene: the on-foot analogue of cooperative-perception benchmarks, with BEV occupancy derivable directly from depth and pose. No LiDAR or 3D boxes ship. |
| Collaborative SLAM & 3D reconstruction | Posed RGB-D video from multiple agents covering one arena (6,000 to 15,000 m² per match) from different viewpoints: cross-agent loop closure, sub-map fusion, and multi-view-consistent geometry, with engine depth and pose as ground truth. |
| Player-behavior modeling | Verified-human aim with synchronized camera pose, target visibility, and hit events: a legitimate-behavior baseline with geometric ground truth that server-side logs cannot supply. |
| Depth, pose & ego-motion | Every per-session task v3 supports, per lane: dense engine depth for every RGB frame, per-frame 6-DOF camera extrinsics, frame-level actions. |

## Matches

Titles are anonymized for licensing; real titles are disclosed under the
full-dataset agreement.

| Match | Map | Players | Hours | Size (GB) | Sync (worst pair) | Engine events | Crossings | Coverage (m²) |
|---|---|---|---|---|---|---|---|---|
| game7-6p-0078 | arena-a | 6 | 1.0 | 210 | 0.28 frames | 46,132 | 3,443 | 6,320 |
| game7-6p-0081 | arena-b | 6 | 1.0 | 211 | 0.22 frames | 31,517 | 3,488 | 6,112 |
| game7-6p-0087 | arena-a | 6 | 1.0 | 210 | 0.20 frames | 39,471 | 3,914 | 6,356 |
| game7-6p-0090 | arena-a | 6 | 1.0 | 210 | 0.30 frames | 40,080 | 3,150 | 6,224 |
| game7-6p-0092 | arena-b | 6 | 1.0 | 210 | 0.23 frames | 23,244 | 3,774 | 6,000 |
| game7-8p-0093 | arena-b | 8 | 1.0 | 280 | 0.34 frames | 16,008 | 6,416 | 6,104 |
| game7-6p-0094 | arena-b | 6 | 1.0 | 211 | 0.19 frames | 43,074 | 4,059 | 6,064 |
| game7-8p-0095 | arena-b | 8 | 1.0 | 279 | 0.18 frames | 23,845 | 7,317 | 6,112 |
| game7-6p-0096 | arena-c | 6 | 1.0 | 210 | 0.23 frames | 21,946 | 3,081 | 7,356 |
| game7-8p-0097 | arena-c | 8 | 1.0 | 279 | 0.21 frames | 11,713 | 4,264 | 7,812 |
| game7-6p-0098 | arena-c | 6 | 1.0 | 210 | 0.20 frames | 10,043 | 2,723 | 8,232 |
| game7-8p-0099 | arena-c | 8 | 1.0 | 279 | 0.44 frames | 12,928 | 4,984 | 8,072 |
| game7-6p-0100 | arena-d | 6 | 1.0 | 209 | 0.17 frames | 17,620 | 4,095 | 15,616 |
| game7-8p-0101 | arena-d | 8 | 1.0 | 281 | 0.23 frames | 11,579 | 7,603 | 14,580 |
| game7-6p-0102 | arena-d | 6 | 1.0 | 210 | 0.19 frames | 12,510 | 4,480 | 13,596 |
| game7-8p-0103 | arena-d | 8 | 1.0 | 281 | 0.27 frames | 15,369 | 6,885 | 15,268 |

Matches span four arena maps in two team formats (3v3 and 4v4); every match
certifies within half a frame across all player pairs.

## Dataset structure

One folder per match: `match.json` (manifest and QA), `timesync.parquet` (the
cross-player frame lookup), one `players/pNN/` folder per player each holding
the standard eighteen-file session layout, plus match-level `sync/` (fold
tables, live residuals, anchor solve, aim-sweep evidence) and `annotations/`.
A six-player hour measures about 210 GB; an eight-player hour about 280 GB.
No splits are imposed. For comparable results we suggest holding out
`game7-8p-0103` and `game7-6p-0096` (one per team format, distinct arenas) as
test matches; `metadata/matches.parquet` carries the `map` column for
map-disjoint splits of your own.

| Modality | Files | Notes |
|---|---|---|
| Pre-HUD RGB | `video/prehud.mp4` | 1080p / 60 FPS CFR, clean render |
| Post-HUD RGB | `video/posthud.mp4` | the frame exactly as the player saw it |
| Surface normals | `video/normals.mp4` | camera-space, same clock |
| Metric depth | `depth/depth.hevc` + `depth_meta.jsonl` + `decode_contract.json` | frame k is RGB frame k |
| Mosaic preview | `video/mosaic.mp4` + `mosaic_layout.json` | four streams, one decode |
| Camera telemetry | `telemetry/camera.jsonl` | pose and orientation at render rate |
| Keyboard & mouse | `telemetry/input.jsonl` | raw events, frame-indexed |
| Engine action events | `telemetry/events.jsonl` | kills, damage, jumps, weapon events |
| Game state | `telemetry/state.jsonl` | sampled in-engine state |
| Game clock | `telemetry/gameclock.jsonl` | where the title exposes one |
| Training tables | `tables/frames.parquet`, `tables/events.parquet` | pre-joined on the frame index |

### Time model

Four named time domains, each mapping's accuracy published:
`qpc_raw → qpc_corrected → server_time_us → frame_grid_index`
(see `metadata/time_domains.md`). **`timesync.parquet` is the only sanctioned
cross-player frame lookup**: capture gates during game loading screens carry
per-machine durations, so linear frame arithmetic across players is invalid on
gated matches. The shipped table gives the exact mapping, with an `in_pause`
flag per player per instant.

### Cross-player annotations

Computed from the engine's camera pose, with no annotators or models in the
loop, and regenerable with your own thresholds (`tools/crossings.py`;
definitions in each file header). Three tiers: dense per-frame visibility
(`in_frustum`, angular offset, screen position, distance, confidence),
interval events (`sees`, `mutual_sight`, `crossing`, `first_sight`,
`sight_break`, and `blindside`, where one player holds another in view
unreciprocated), and per-frame interaction graphs. Visibility is
frustum-geometric: occlusion is not resolved (no world geometry ships), and
the depth maps are exactly what refining `in_frustum` into true line-of-sight
requires.

## Verify the sync yourself

Every synchronization claim on this card is re-derivable from shipped
artifacts:

```
python tools/verify_sync.py --match game7-6p-0081
```

Four independent evidence chains ship per match:

1. **Clock fits**: pairwise grid slide from ten-second clock samples. Across
   all 318 player pairs in the release (15 per 6-player match, 28 per
   8-player), the worst pair lands at 0.44 frames (7.3 ms) over 60 minutes,
   and most matches hold under a quarter frame.
2. **Live residuals**: each recorder refits its clock every minute during
   capture, so the claim is falsifiable mid-match, not just after the fact.
3. **Event bookkeeping**: every kill and damage event exists on two machines
   off one server tick. Solving all pairwise offsets as an over-determined
   system yields per-machine anchors with ±6–9 ms error bars.
4. **Aim geometry**: at each matched hit, the attacker's camera ray (from its
   own telemetry) must point at the victim's position (from the victim's
   telemetry). Median aim error collapses to 1.4° only at true alignment,
   across roughly 4,800 matched events per match, and the consistent
   −70 to −100 ms optimum is the game's lag-compensation window, measured from
   the data itself.

## Dataset creation

Consenting, compensated players record live matches with our in-engine SDK.
Capture starts on a scheduled server instant established per session by a
min-RTT clock handshake; each machine's clock rate is calibrated against its
recording history before capture and monitored throughout, and the frame grid
ticks on the corrected clock. Depth and camera state are read from the engine
at capture time, so depth is a measurement, not an estimate. Before a match
ships, the four-chain audit above runs across every player pair, and a match
certifies only when all pairs hold within half a frame. Of 18 matches
captured for this release, 16 certified and ship; 2 were withheld for missing
the half-frame gate.

## How to use it

```python
from datasets import load_dataset

matches = load_dataset("originlab/frame-synced-multiplayer", "matches")
timesync = load_dataset("originlab/frame-synced-multiplayer", "timesync")
visibility = load_dataset("originlab/frame-synced-multiplayer", "visibility")
```

Videos and depth are plain files under `matches/*/players/*/` in the standard
v3 layout, so the v3 loader and depth decode pattern apply per lane, and
per-modality selective download works by path prefix (telemetry only, one
player only). To align anything across players, join through
`timesync.parquet` on `frame_grid_index`.

## What is in this repository

The complete release:

- `matches/*/players/pNN/`: every player-session in the standard eighteen-file
  v3 layout — video renditions, depth, telemetry, training tables (~3.8 TB
  total, LFS).
- `metadata/matches.parquet`: the match index (map, players, duration, sync
  status, event and crossing counts). This is what the dataset viewer renders.
- `matches/*/timesync.parquet` and `matches/*/annotations/`: the full
  alignment tables and cross-player annotations.
- `matches/*/sync/`: the complete verification evidence per match.
- `assets/previews/`: the preview GIFs above. `assets/plots/`: residual and
  pairwise-alignment figures.
- `tools/`: `verify_sync.py`, the crossings generator, and the fold-table
  reader.

Use `huggingface_hub.snapshot_download` with `allow_patterns` for selective
pulls (one match, one player, telemetry only). Teams on AWS can request
direct in-cloud delivery instead.

## Considerations for using the data

- Cross-player visibility is frustum-geometric; occlusion is not resolved.
  The shipped depth maps support refining it into true line-of-sight.
- Camera telemetry is emitted at each machine's render rate (roughly
  90–320 Hz here) with occasional dropouts; gridded pose carries a
  `gap_masked` flag and is never interpolated.
- Absolute wall-clock alignment is bounded at ±120 ms by the network
  handshake; all sub-frame claims are relative cross-player alignment, which
  is what the shared frame grid provides.
- Capture pauses during game loading screens, with per-machine durations. Use
  `timesync.parquet` for any cross-player lookup; frame arithmetic alone is
  not valid on gated matches.
- Game titles are anonymized as "Game N" in the public metadata; real titles
  are disclosed under the full-dataset agreement.
- **Players and personal data.** No microphone or player voice is captured;
  audio is game audio from the title process only. No legal names, contact
  details, faces, or biometric data ship in any stream or metadata file.
  Post-HUD video may show player-chosen in-game display names in scoreboards,
  kill feeds, and similar UI; these are pseudonymous handles. Every player
  recorded consented in writing and was compensated, under agreements that
  cover distribution and licensing of these recordings. Pre-HUD RGB carries
  no HUD and therefore no display names, so a name-free lane ships for every
  player in every match. Licensees may not attempt to identify any player
  (LICENSE.md, clause 8).

## License

Origin Lab Data License ([`LICENSE.md`](LICENSE.md)). Two tracks; select one
when requesting access.

- **Track A, Internal Evaluation.** 90 days to train and evaluate models
  internally in order to assess the data. Origin Lab does not require you to
  publish or open-source anything you train. Delete at the end, or convert to
  a commercial agreement.
- **Track B, Non-Commercial Research.** Research use with attribution.
  Papers, open weights, and benchmarks are welcome.

Under both tracks: no commercial use, no deployment, and no redistribution of
the data in any form.
Any commercial use of the data, or of a model trained on it, requires a
direct license from Origin Lab:
[originlab.ai/hf](https://originlab.ai/hf).

All gameplay is recorded under license from the rights holders by consenting,
compensated players.

## Citation

```bibtex
@misc{originlab2026framesync,
  title  = {Origin Lab Frame-Synced Multiplayer: Multi-Player Gameplay on One
            Verified Frame Clock with Cross-Player Annotations},
  author = {{Origin Lab}},
  year   = {2026},
  url    = {https://huggingface.co/datasets/originlab/frame-synced-multiplayer}
}
```