README.md

---
license: other
pretty_name: NeuralCraft World Model Data
tags:
- world-model
- minecraft
- vision-language-action
- action-conditioned
viewer: false
---

# 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](https://huggingface.co/datasets/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% |

```python
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.

```python
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](https://huggingface.co/datasets/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.