codelion/neuralcraft-world-data

NeuralCraft World Model Data

Action-conditioned Minecraft gameplay for training an interactive world model. 5,548,016 frames in 126,085 contiguous runs across 303 shards, with ground-truth actions — the player's actual keyboard and mouse input, not labels inferred from the pixels.

Derived from TESS-Computer/minecraft-vla-stage1 (OpenAI VPT contractor data), curated to gameplay only.

Frames are 256x144 RGB JPEG at 5 Hz (VPT's native rate). One frame is 200 ms — that matters for almost every design decision below.

Integrity

Verified on every run and every frame (integrity.jsonl, one row per run):

runs                    126,085
frames                5,548,016
unreadable runs               0
corrupt/truncated JPEG        0   (FFD9 end-of-image marker checked on all 5.5M files)
frame/action mismatch         0
frame_file mismatch           0
NaN / out-of-range            0
non-binary key bits           0

Run length is the main constraint

Curation cuts the source videos wherever a non-gameplay frame appears, which produces many short fragments. Plan your sequence length around this before anything else.

min 16   median 29   mean 44   p90 85   max 1055

seq_len	runs that fit	frames	training windows (stride 1)
16	126,085 (100%)	5,548,016 (100%)	3,656,741
24	81,896 (65%)	4,706,082 (85%)	2,822,474
32	57,571 (46%)	4,045,840 (73%)	2,261,139
48	32,877 (26%)	3,097,088 (56%)	1,551,869
64	20,972 (17%)	2,445,391 (44%)	1,124,155
128	5,646 (4.5%)	1,123,040 (20%)	405,998

At 5 Hz, seq_len=16 is 3.2 seconds. This dataset cannot test long-horizon stability, because it contains almost no long-horizon examples — 4.5% of runs reach 128 frames. If drift over minutes is what you care about, this is the wrong dataset.

Actions (13-dim)

idx	field	type	notes
0–8	W, S, A, D, jump, sneak, sprint, attack, use	binary	recorded key presses
9–10	cam_dx, cam_dy	float [−1,1]	recorded mouse delta, signed-sqrt scaled
11	speed	float [−1,1]	measured forward expansion
12	turn_rate	float [−1,1]	measured horizontal flow

To recover physical camera magnitude, undo the scaling: dx = sign(cam_dx) * cam_dx**2.

Normalisation for 11–12: speed /= 1.266, turn_rate /= 1.559 (p95 of |value|), then clipped.

Use 0–10, and think hard before using 11–12

Indices 0–10 are the player's intent. Indices 11–12 are measurements of what the world did — computed from the very frames a world model is asked to predict. Conditioning on them leaks the answer: the model appears to have excellent control while having learned to read the motion channel instead of the action. We hit this directly. A model of ours showed convincing "throttle authority" that vanished the moment the measured channels were dropped.

They are shipped because they are useful for filtering, analysis and inverse-dynamics work. For training an action-conditioned model, use actions[:, :11].

Camera sign and timing

cam_dx is negatively correlated with horizontal optical flow (pooled r = −0.25): positive cam_dx means looking right, which sweeps the world leftward across the screen. Get this backwards and your model learns mirrored controls.

Timing is genuinely ambiguous and we could not resolve it. Pooling 240 runs, correlation between cam_dx and the flow of transition j → j+1:

lag  -1     +0     +1     +2
r  -0.123 -0.2493 -0.2489 -0.085

Lag 0 (action[i] causes i → i+1) and lag +1 (action[i] describes i−1 → i) are tied to four decimal places. At 5 Hz a one-frame shift is 200 ms and camera motion is smooth, so the correlation cannot separate them. Try both pairings. Our own trainer used the lag +1 convention; we have no evidence that was right.

On the strength of that correlation: r ≈ 0.25 looks weak next to the r ≈ 0.82 in our companion driving dataset, but the comparison is invalid. Those labels were derived from optical flow, so correlating them with optical flow is partly circular. These labels are independent recorded input, and 0.25 is what an honest, non-circular measurement of a genuinely noisy relationship looks like — the player's mouse and the observed flow disagree whenever walking, head-turn and terrain interact. Ground truth is the reason to prefer this dataset, not a reason to distrust it.

Choosing what to train on

With 5.5M frames, signal is the constraint, not quantity. Measured over 171,158 frames sampled from 10 shards:

channel	ON-rate		channel	mean	std	p5	p95	exactly 0
W	65.5%		cam_dx	−0.004	0.313	−0.55	+0.54	31.0%
S	2.6%		cam_dy	+0.000	0.185	−0.31	+0.31	35.6%
A	10.5%		speed	+0.120	0.425	−0.58	+0.93	0.0%
D	9.1%		turn_rate	−0.002	0.415	−0.76	+0.76	0.0%
jump	25.5%
sneak	4.5%
sprint	29.2%
attack	24.6%
use	4.9%

W dominates and roughly a third of frames have a perfectly still camera, so a uniform sample is mostly "walking forward, looking nowhere". The camera channels are symmetric about zero, as they should be.

quality_*.jsonl rank every run with ≥48 frames (32,877 runs, 3,097,088 frames) on six rank-normalised measures plus length: control (does the player act at all), agreement (does the recorded action visibly move the world), smooth (lag-1 autocorrelation of frame difference — jittery timing makes dynamics unlearnable), motion, detail (Laplacian variance, excludes featureless sky and cave walls), clean (1 − duplicate rate).

tier	runs	frames	share of scored
quality_top20.jsonl	6,575	755,291	24%
quality_top35.jsonl	11,506	1,264,773	41%
quality_top50.jsonl	16,438	1,743,152	56%
quality_all.jsonl	32,877	3,097,088	100%

import json
from huggingface_hub import hf_hub_download

REPO = "codelion/neuralcraft-world-data"
best = [json.loads(l) for l in
        open(hf_hub_download(REPO, "quality_top35.jsonl", repo_type="dataset")) if l.strip()]
wanted = {r["run"] for r in best}
shards = sorted({r["tar"] for r in best})
print(len(best), "runs across", len(shards), "shards")     # 11,506 runs across all 303

Nothing is pruned from the tars; the ranking ships instead, so you can pick your own cutoff.

The selection is spread across every shard, so there is no way to skip downloads — a top-35% pull still streams all 303 tars. What it saves is what you keep: extract only the selected runs from each tar and delete the tar before the next, and 71 GB on the wire becomes ~16 GB on disk with peak usage of one shard. Do not try to select shards; select runs.

Note: these files were regenerated 2026-08-07. The earlier version computed its agreement measure on frames sampled with a stride, which is meaningless for optical flow — flow is only defined between adjacent frames. Because the ranking weights run length, the longest runs were exactly the ones the stride corrupted. The corrected top-35% differs from the old one on 20% of its selections. If you pulled a selection before that date, re-pull it.

Manifest file schema

quality_all.jsonl / quality_top{20,35,50}.jsonl — one JSON object per scored run, sorted by score descending. integrity.jsonl — one object per run, all runs, unsorted.

field	in	meaning
run	both	run directory name, e.g. s00123_r0007
tar	both	which shard holds it, e.g. data/shard_00123.tar
frames / actions	both	file count and action-line count
count_delta	integrity	frames - actions; 0 everywhere in this release
corrupt_jpeg	integrity	files failing the FFD9 end-of-image check; 0 everywhere
framefile_mismatch	integrity	records whose frame_file names the wrong frame; 0 everywhere
width_ok, nan, out_of_range, nonbinary_keys	integrity	action-vector sanity
scored	both	false if the run is under 48 frames
score	quality	the combined rank-normalised ranking value, 0–1
control	quality	how much the player acts: camera magnitude + key-change rate
agreement	quality	|corr| between the steering signal and horizontal optical flow
best_lag, lag_r	quality	lag maximising that correlation, and the signed r there
smooth	quality	lag-1 autocorrelation of frame difference; low means jittery timing
motion	quality	mean optical-flow magnitude; excludes AFK stretches
detail	quality	mean Laplacian variance; excludes featureless sky and cave walls
clean	quality	1 − near-duplicate-frame rate

score weights these as (2·control + 2·agreement + 1.5·length + smooth + motion + detail + clean) / 9.5, each rank-normalised across runs first so no raw scale dominates. Every component ships, so you can re-weight for your own priorities instead of accepting ours.

Layout

The .tar files are not a WebDataset. Each holds many run directories:

<run>/frames/frame_000000.jpg
<run>/frames/frame_000001.jpg
...
<run>/actions.jsonl          # one JSON line per frame, same order as the frames

A world model trains on contiguous windows, not independent samples, and WebDataset's flat key.jpg/key.json pairing cannot express "these frames are consecutive and ordered" — the viewer would shuffle them, which is meaningless for video. Tars also keep the repo to a few hundred objects instead of 5.5M, and keep neighbouring frames adjacent on disk. HF's auto-detection cannot parse this layout, so the dataset viewer is off.

import json, tarfile, glob, os
import numpy as np
from PIL import Image
from huggingface_hub import hf_hub_download

REPO = "codelion/neuralcraft-world-data"
meta = [json.loads(l) for l in
        open(hf_hub_download(REPO, "metadata.jsonl", repo_type="dataset")) if l.strip()]

tar = hf_hub_download(REPO, f"data/{meta[0]['shard']}.tar", repo_type="dataset")
with tarfile.open(tar) as tf:
    tf.extractall("work")                       # unpacks to MANY run directories

def load_run(run_dir):
    frames = sorted(glob.glob(os.path.join(run_dir, "frames", "*.jpg")))
    recs = [json.loads(l) for l in open(os.path.join(run_dir, "actions.jsonl")) if l.strip()]
    n = min(len(frames), len(recs))             # always slice to the shorter of the two
    acts = np.array([r["actions"] for r in recs[:n]], np.float32)
    return frames[:n], acts[:, :11]             # drop the measured channels — see above

def windows(frames, actions, seq_len=16, stride=8):
    for s in range(0, len(frames) - seq_len + 1, stride):
        imgs = np.stack([np.asarray(Image.open(f).convert("RGB"), np.float32) / 255.
                         for f in frames[s:s + seq_len]])
        yield imgs, actions[s:s + seq_len]      # [seq,144,256,3], [seq,11]

Horizontal-flip augmentation must mirror the controls too: swap A↔D (indices 2↔3) and negate cam_dx (index 9).

What we found training on this

Reported because negative results are worth more than silence.

We trained a 131M-parameter latent diffusion world model on the top-35% selection — ConvVAE codec (8 channels, /8 downsample) plus a DiT with rectified flow and per-frame diffusion forcing, at 256x144. Controls work. Walking expands the world forward (+0.205) and camera input turns it the correct way (+0.086), with the right signs on every channel.

The world does not persist. Rollouts hold together for roughly 10–20 frames (2–4 seconds) and then dissolve. No sampling setting rescued it: at 2 Euler steps it melts, and at 16 or 32 it produces high-frequency noise that scores sharper than real footage while showing nothing recognisable. Few-step distillation did not help either. We do not have an explanation and we are not claiming the data is at fault — the same failure appeared in a completely different domain on different data.

Two measurements worth passing on:

Minecraft is unusually hard to compress. The same autoencoder retained 58% of a frame's Laplacian edge energy on driving footage and 30% on this data. Leaves, grass and block edges are almost entirely high-frequency, and an 8-channel /8 latent cannot hold them. Every frame a latent world model emits is decoded through that ceiling. Budget more latent capacity here than a smooth-textured domain would need.

Do not use PSNR to decide when a codec is done. Ours flattened at 28.7 dB by 12k steps while edge retention was still climbing steeply (14.4% at 3k → 25.1% at 12k). We stopped on the PSNR signal and shipped a blurrier codec than we needed to.

Curation

1. Near-black frames dropped (brightness < 32) — unlit caves and night carry little signal.
2. GUI/menu removal with a CLIP content classifier (P(gameplay) < 0.20): inventory, crafting, chest, trading and pause screens, plus non-game content in the source recordings. A colour-based detector was tried first and failed — Minecraft's stone textures share the GUI greys, so the filter has to be semantic.
3. Re-segmented into contiguous runs of ≥16 frames, because filtering creates gaps and a world model needs unbroken windows. This is why runs are short.
4. Ego-motion measured per frame with optical flow and appended as indices 11–12.

15.1M source frames → 5,548,016 curated (~63% removed).

Provenance and licence

Upstream is OpenAI's VPT contractor data via TESS-Computer/minecraft-vla-stage1. Check the upstream terms and Minecraft's EULA for your intended use. Rights in the game remain with Mojang/Microsoft.