---
license: mit
task_categories:
  - reinforcement-learning
  - video-classification
tags:
  - world-models
  - pixel-art
  - synthetic
  - action-conditioned
size_categories:
  - 1M<n<10M
---

# Small Worlds: a generated pixel-platformer corpus

**2,025,385 frames** of a single controllable agent in a deterministic 2D
platformer, with per-frame actions, rewards, episode boundaries and task labels.
Nothing here was scraped: every frame was rendered by a simulator written for the
purpose, which makes the coverage structure a *controlled variable*.

Built for research on world models and on hallucination in generative dynamics
models. Accompanying report: *Small Worlds: Subject-Scale Failure in
Reconstruction-Trained World-Model Tokenizers*.

## Why this corpus exists

Two properties are hard to obtain from recorded gameplay and are exact here:

1. **A known finite palette.** The renderer emits exactly **21 colours**, so
   reconstruction can be scored as exact per-pixel agreement and *restricted to
   any semantic subset* — the agent's own colours, for instance. This is what
   makes the paper's central measurement possible.
2. **Coverage as a dial.** Each episode targets one coin drawn from a skewed
   distribution and ends when it is collected, so a goal is a *task* and the
   uppermost platform is visited in ~3% of episodes by construction.

The agent occupies a measured **1.30%** of frame pixels.

## Splits

| split | episodes | frames | size | purpose |
|---|---|---|---|---|
| `train` | 35,000 | 2,025,385 | 0.75 GB | training |
| `val` | 2,400 | 136,620 | 0.05 GB | evaluation |
| `test` | 2,400 | 139,157 | 0.05 GB | held out entirely |
| `probe_ledge` | 2,400 | 364,684 | 0.13 GB | 100% low-coverage region |

Seed blocks are widely separated and verified disjoint.

## Format

One `.npz` per shard, with a `.json` of per-shard statistics beside it.

| field | shape | dtype | notes |
|---|---|---|---|
| `frames` | (N, 128, 128, 3) | uint8 | native resolution, no resampling |
| `actions` | (N,) | uint8 | 0–5; 255 marks a terminal step |
| `action_vecs` | (N, 16) | float32 | zero-padded continuous encoding |
| `action_mask` | (16,) | float32 | 3 valid dimensions |
| `rewards` | (N,) | float32 | coin +1, crate +2, door +5 |
| `ep_id` | (N,) | int32 | episode boundaries |
| `goal` | (N,) | uint8 | task label; enables per-task resampling |
| `terminal` | (N,) | bool | |

Frames are stored once per episode; `frames[i+1]` is the successor within an
episode and `ep_id` marks boundaries. Flat pixel art deflates well — **368
bytes/frame** against 49,152 raw.

```python
import numpy as np
from huggingface_hub import hf_hub_download

p = hf_hub_download("maxmill/small-worlds-pixel-platformer", "train/shard_0000.npz", repo_type="dataset")
d = np.load(p)
frames, actions, rewards = d["frames"], d["action_vecs"], d["rewards"]
```

## Coverage structure

Episode share and frame share are deliberately mismatched, reproducing the
heavy-tailed structure of larger corpora:

| task | episode share | frame share | ratio |
|---|---|---|---|
| ground | 31.9% | 5.3% | 0.17 |
| P1 | 31.1% | 37.5% | 1.21 |
| P2 | 31.0% | 41.6% | 1.34 |
| **P3 (rare)** | **6.0%** | 15.5% | 2.57 |

## Behaviour policies

| policy | share |
|---|---|
| scripted (routes over a physics-derived hop graph) | 40% |
| scripted + 20% random | 25% |
| scripted + 50% random | 15% |
| uniform random | 15% |
| explorer (biased to the rare platform) | 5% |

## Measured properties

- **Redundancy**: 25.4% of frames unique (mean 3.94 repeats) → ~515k distinct frames
- **Intrinsic dimensionality**: a frame is a deterministic function of ~26 bits of state
- **Palette**: exactly 21 colours; 9 belong to the agent
- **Versioning**: every shard carries `action_space_version` and `art_version`

## Licence

MIT.