The videos in this dataset show gameplay of a Valve game and are (c) Valve Corporation. They are shared for non-commercial research under Valve's Video Policy. This dataset does not license any of Valve's rights to you. The annotations, tables and code by the dataset authors are licensed under CC BY-NC 4.0.

vor.tech CS World-Model Dataset

Every tick of 9,515 bot-played CS matches (actions, states and damage for all 10 players) plus 255k first-person videos aligned frame by frame to those ticks. It is built for training and evaluating world models, imitation-learning agents and multi-agent behaviour models.

Released by vor.tech.

_{Round 7 of match 2162 in our viewer. The 10 POVs, player states and hit events are this
dataset; the depth/normal buffers and the radar are rendered from it by our own tools and
are not included.}

At a glance


Matches	9,515 (218,768 rounds), all on `aim_map_usp_s`, 5v5 bots
Events	195 M rows at 16 Hz, ≈ 3,390 h of game time, all 10 players per row, 14 GB Parquet
Videos	255,712 per-player POV MP4s from 1,367 matches (30,017 rounds), ≈ 3,280 POV-hours, 1.07 TB in one tar per match
Video format	256×256, 16 fps, H.264 + AAC stereo game audio, HUD visible
Actions	movement, fire/reload/use, walk, duck, jump, mouse Δyaw/Δpitch, weapon switch
States	position, view angles, alive, team, health, armor, helmet, weapon, ammo
Damage	attacker × receiver matrix per tick: health, armor, hitgroup
Alignment	frame i ↔ event row `state_idx_start + i`, exact, 1-tick render lag already removed
Splits	none; split by match to avoid leakage (see Splits)
License	CC BY-NC 4.0 for our annotations and code; footage © Valve

Terms of use

Non-commercial only. The footage is Valve's game content, shared under Valve's Video Policy, which allows non-commercial videos. Do not sell, license or charge for access to the videos or anything that redistributes them.
No asset extraction. Do not pull game assets (sounds, textures, models) out of the videos and distribute them separately.

This dataset is not affiliated with or endorsed by Valve.

Quick start

The repo is gated. Accept the terms on this page, then hf auth login.

Tables only (14 GB). Actions, states and damage for every match:

from datasets import load_dataset
events = load_dataset("v0rt3ch/cs-5v5-bots-aim_usp-3k", "events", split="all")

Tables and a few matches' videos. Each match's videos are one tar of ≈0.8 GB, so fetch only the matches you need:

from huggingface_hub import snapshot_download
root = snapshot_download(
    "v0rt3ch/cs-5v5-bots-aim_usp-3k", repo_type="dataset",
    allow_patterns=["*.parquet", "*.json", "*.py", "requirements.txt",
                    "videos/000024.tar", "videos/000025.tar"],
)

One clip, no loader. The tars are uncompressed, and videos.parquet stores each clip's byte range in its tar, so there is nothing to extract:

import io, decord, pandas as pd
v = pd.read_parquet(f"{root}/videos.parquet").query("match_id == 24").iloc[0]
with open(f"{root}/{v.video_tar}", "rb") as f:
    f.seek(v.video_offset)
    mp4 = f.read(v.video_nbytes)
frames = decord.VideoReader(io.BytesIO(mp4))   # or write `mp4` to a file

PyTorch. The bundled loader returns windows of actions, states and frames:

from vortech_loader import VortechDataset   # pip install -r requirements.txt

ds = VortechDataset(root, action_h=8, state_h=1, frame_h=8,
                    include_video=True, samples_w_frame_only=True,
                    match_ids=[24, 25])
s = ds[0]
s["actions"].shape   # (8, 10, n_actions)
s["frames"].shape    # (9, 256, 256, 3)
s["frame_actions"]   # (9, 10, n_actions): the action of each frame's row

VortechDataset handles the gotchas below (round boundaries, pre-round head, frame ↔ row mapping) for you.

Things to know before training

Aligned by row. Frame, state and action of row i belong together. Action i is the input issued between rows i and i+1, so state[i] + action[i] → state[i+1].
Skip the start of every round. In the events, round r begins with 160 rows (10 s, ≈18% of all rows) of round r−1's aftermath: frozen dead players and idle survivors. Video clips cover the last ≈61 of those rows (≈8% of all frames). There is a hidden ≈5 s jump before the real spawn, and round_id does not change across it. Nothing happens in that head (no shots, damage or deaths in 149 sampled clips), and there the video is not reliably paired with the states (≈11 frames off). Start at matches.round_start_rows / videos.round_start_row. From there on, alignment is exact, which we verified against the ammo and health digits rendered in the HUD.
Never window across (match_id, round_id). Rounds are independent episodes.
Alignment is exact as published. Frames lag the game state by one tick. That lag was measured two ways (ray-cast vs. YOLO mask IoU, and image motion vs. yaw change: −0.97 ± 0.67 rows over 59 clips) and is already removed from state_idx_start.
198 matches were brightened. They were recorded with a darker render setting (mean brightness ≈70 vs ≈120). They ship already corrected to the look of the rest by one fixed per-channel tone curve (≈ 39 dB PSNR to the ideal mapping, re-encoded at CRF 16), and are flagged brightness_corrected. Their shadows carry slightly more compression noise.
is_alive is inverted: Source lifeState, so 0 = alive, 1 = dying, 2 = dead.

Dataset structure

dataset_config.json     schema: column names, dtypes, tickrate, n_clients
weapons.json            weapon code <-> name
matches.parquet         one row per match
videos.parquet          one row per (match, round, player) clip
events/events-*.parquet 98 shards, one row per 16 Hz tick, matches contiguous
videos/{match_id:06d}.tar   1,367 tars, one per match with video
vortech_loader.py       PyTorch loader    visualize_round.py   round previewer

`events`: one row per tick (16 Hz)

column	type	notes
`match_id`	uint32	match, key into `matches`
`round_id`	uint16	round within the match
`state_idx`	uint64	global row index, the key used by `videos`
`tick_beg`, `tick_med`, `tick_end`	uint64	64 Hz demo ticks covered by this row
`actions`	float16 list	reshape `(n_clients, n_actions)`
`states`	float16 list	reshape `(n_clients, n_states)`
`dmgs`	uint32 list	reshape `(n_clients + 1, n_clients)` = `[attacker, receiver]`; last attacker row = world

NaN in actions / states means unobserved. In this build that happens only in active_weapon_ammo (≈40% of cells). A damage cell packs health = v & 0xFFFF, armor = (v >> 16) & 0xFF, hitgroup = (v >> 24) & 0xFF; 0 means no damage.

`matches`

match_id (PK), match_name, source_path, map_name, tickrate, n_clients, n_rounds, n_event_rows, round_ids, round_start_rows (parallel to round_ids), steamids, brightness_corrected.

steamids defines the canonical client_id order: client_id = 3 ↔ steamids[3].

Steam ids here are bot slot ids (2–11), not real accounts.

`videos`

column	notes
`match_id`, `round_id`, `client_id`, `steamid`	`client_id` indexes `matches.steamids`
`video_tar`	the match's tar, e.g. `videos/000024.tar`
`video_member`	the clip's name in it, e.g. `000024_001_07_9.mp4`
`video_offset`, `video_nbytes`	byte range of the mp4 inside the tar
`state_idx_start`, `state_idx_stop`, `state_idx_step`	frame i ↔ row `start + i·step`; `step` = 1; `stop` exclusive, clamped to the round
`round_start_row`	first row of the real round (see gotcha 2)
`n_frames`	every frame has a row and every row in range has a frame
`beg_tick`, `end_tick`	64 Hz demo ticks covered
`brightness_corrected`	see gotcha 5
`delay_`, `source_`, `*_tickrate`	provenance

Not every row has video: 1,367 of the 9,515 matches were recorded, and a few POVs are missing in some rounds.

Each tar is also a valid WebDataset shard. Clips are sorted by round and player, and each {match}_{round}_{client}_{steamid}.mp4 is preceded by a .json holding its videos.parquet row, so the tars can be streamed without the tables.

Actions

name	meaning
`wasd`	enum 0–8: none, W, S, D, A, W+D, W+A, S+D, S+A (conflicting combos zeroed)
`interact`	enum 0–7: none, fire, alt-fire, reload, inspect, use, fire+alt, inspect+use
`walk`, `duck`, `jump`	0/1
`mouse_dx`	Δyaw in degrees over the row's 64 Hz sub-ticks, + = right, clipped to ±50°/sub-tick
`mouse_dy`	Δpitch in degrees, + = down, clipped to ±15°/sub-tick
`weapon_select`	weapon code switched to (0 = no switch), see `weapons.json`

States

name	meaning
`pitch`, `yaw`	degrees; pitch negative = up, yaw in [0, 360)
`x`, `y`, `z`	world position, Source units
`is_alive`	0 = alive, 1 = dying, 2 = dead
`team_num`	2 = T, 3 = CT
`health`, `armor_value`	0–100
`has_helmet`	0/1
`active_weapon_name`, `active_weapon_ammo`	weapon code, rounds in clip

weapons.json is {category: [[code, name], ...]}. If a code appears twice, the first name is canonical.

Splits

There are no predefined splits. Hold out whole matches so that rounds of one match never leak across the split:

import numpy as np, pandas as pd
ids = pd.read_parquet(f"{root}/matches.parquet").match_id.to_numpy()
np.random.default_rng(0).shuffle(ids)
train_ids, val_ids = ids[: int(.9 * len(ids))], ids[int(.9 * len(ids)):]

How it was made

CS bots played 5v5 matches on the community aim map aim_map_usp_s (by im0rtus, a remake of the classic CS 1.6 map). The demos were parsed with demoparser4bots, our own fork of the Python-demoparser, into 64 Hz game state, which was binned to 16 Hz rows. Each player's POV was re-rendered from the demo at 16 fps, and every video was aligned to the event table and checked as described above. No human players are included.

Limitations

One map, pistols only. Ts use the Glock-18 (weapon code 4), CTs the HK P2000 (weapon code 32).
Near-constant columns. The bots never walk, so walk is always 0. interact takes only none, fire and reload, and world damage is always 0, since the map has nothing to fall from.
Bot behaviour. Bots move and aim differently from humans. Do not treat this data as a model of human play.
Rendering. The HUD is in every frame, the resolution is low (256²), and 198 matches are brightness-corrected.
Coverage. Video exists for ≈14% of matches. Everything else is event-only.

License and terms

Annotations, tables, configs and code by the dataset authors: CC BY-NC 4.0. The full legal code is in LICENSE.
aim_map_usp_s belongs to its author.

This dataset is not affiliated with or endorsed by Valve.

About vor.tech

We are building world models for multiplayer games. If you train on this dataset, build on it, or want to work with us, reach out via vor.tech.

Citation

@misc{vortech_cs_world_model,
  title  = {vor.tech CS World-Model Dataset},
  author = {vor.tech},
  year   = {2026},
  url    = {https://huggingface.co/datasets/v0rt3ch/cs-5v5-bots-aim_usp-3k}
}

Downloads last month: 128

Total file size:

1.08 TB

Non-commercial research access