mini-carla-192x320

Action-conditioned driving clips rendered offline from CARLA 0.9.16, built as the training set for miniworld, a minimal flow-matching world-model framework.

192,000 frames at 192×320 (h×w), 20 Hz, across 16 environments — 8 CARLA towns seen from two camera regimes.

Frames	192,000 (12,000 per env × 16 envs)
Episodes	320 (20 per env, 600 frames = 30 s each)
Resolution	192 × 320 (h × w), RGB uint8
Frame rate	20 Hz (fixed_delta_seconds = 0.05)
Action	continuous (throttle, steer, brake) float32
Towns	Town01–Town07, Town10HD
Simulator	CARLA 0.9.16, Low quality preset, seed 42
Size on disk	35.4 GB (uncompressed)

Two camera regimes

Each town appears twice, under a vehicle_ and a freecam_ prefix:

• vehicle_town* — camera mounted on a car driven by CARLA's Traffic Manager. Actions are read back from vehicle.get_control() at capture time, so they are what the simulator actually applied, not what was requested. brake is genuinely used here.
• freecam_town* — a camera flying the lane graph with no vehicle attached, so the tensor layout still matches: throttle is normalised speed (speed / 12 m·s⁻¹), steer is yaw rate scaled so ±1 = ±60 °/s, and brake is always 0. These episodes are nearly always in motion (moving_fraction = 0.998) and produce motions a traffic-obeying car never does — lateral drift, looking sideways while moving, and viewpoints above and below driver height.

Mixing the two matters: vehicle episodes are stationary 6–30 % of the time (moving_fraction 0.695–0.943), which on its own teaches a world model that "nothing moves" is a good prediction.

The freecam rig is a documented simplification of the free-camera trajectories in arXiv:2603.15583, which fly freely with collision detection against buildings and terrain. Following the lane graph is collision-free by construction and needs no raycasting, at the cost of exploring less of each map.

Files

For each of the 16 environments <env>:

File	Contents
<env>_frames.npy	(12000, 192, 320, 3) uint8 — uncompressed, meant to be memory-mapped
<env>.npz	the small per-frame and per-episode arrays, below
meta.json	capture settings, camera intrinsics, and per-env statistics

Inside <env>.npz

Key	Shape	dtype	Meaning
actions	(12000, 3)	float32	(throttle, steer, brake); throttle/brake ∈ [0,1], steer ∈ [−1,1]
ep_ids	(12000,)	int64	episode index 0–19; clips must never straddle a change here
pose	(12000, 6)	float32	x, y, z, pitch, yaw, roll (CARLA world frame, metres/degrees)
velocity	(12000, 2)	float32	vx, vy in m/s
moving	(20,)	float32	per-episode fraction of frames with non-zero speed
ep_weather	(20,)	<U16	per-episode CARLA weather preset name

actions[i] is the control that produced frames[i] — there is no off-by-one shift to undo.

pose and velocity are carried alongside but are not needed for plain action-conditioned training. They are here so camera-following accuracy (the RotErr / TransErr metrics of arXiv:2603.15583) stays computable, and so pose conditioning remains possible without re-running the capture.

Camera intrinsics

Pinhole derived from a 90° horizontal FOV, square pixels:

fx = 160.0   fy = 160.0
cx = 160.0   cy =  96.0

Weather

ClearNoon dominates (217 of 320 episodes). The remainder are spread across CloudyNoon, CloudySunset, ClearSunset, WetNoon, WetSunset, WetCloudyNoon, SoftRainSunset, MidRainyNoon, MidRainSunset, and HardRainNoon — roughly 7–13 episodes each. Per-episode assignments are in ep_weather; per-env totals are in meta.json.

This is a deliberately mild distribution shift, not a balanced weather benchmark. A model trained here will see rain, but not enough to be judged on it.

Usage

Download the whole set (35.4 GB):

hf download kamwoh/mini-carla-192x320 --repo-type dataset --local-dir ./mini_192x320_low

Or take a single town to try things out (~2.2 GB):

hf download kamwoh/mini-carla-192x320 --repo-type dataset \
  --include 'vehicle_town01*' 'meta.json' --local-dir ./mini_192x320_low

Note that meta.json lists all 16 environments, so a partial download needs an explicit envs=[...] when loading.

With miniworld

from datasets.carla import CarlaVideoDataset

ds = CarlaVideoDataset(
    data_dir="./mini_192x320_low",
    frames_per_clip=24,
    envs=["vehicle_town01"],   # omit to use all 16 from meta.json
)
clip = ds[0]
clip["image"]   # (24, 3, 192, 320) float32 in [-1, 1]
clip["action"]  # (24, 3)           float32

Set model.action_dim=3 — actions are continuous and passed through unchanged. Discretising them would throw away steering magnitude.

Plain NumPy, no framework

import json, numpy as np

meta = json.load(open("mini_192x320_low/meta.json"))
env = "vehicle_town01"

frames = np.load(f"mini_192x320_low/{env}_frames.npy", mmap_mode="r")  # do NOT drop mmap_mode
with np.load(f"mini_192x320_low/{env}.npz") as d:
    actions, ep_ids = d["actions"], d["ep_ids"]

# frames of episode 3
sel = np.flatnonzero(ep_ids == 3)
clip = np.asarray(frames[sel[0] : sel[-1] + 1])   # (600, 192, 320, 3) uint8

Always pass mmap_mode="r". The arrays are stored uncompressed precisely so they can be paged in a clip at a time; loading one whole file eagerly costs 2.2 GB of RAM, and all 16 costs 35 GB.

Why uncompressed .npy

These are the exact bytes the miniworld models were trained on. Lossless codecs only reach ~2–4× here, and the lossy mp4 that would reach ~30× would publish pixels that differ from the ones used in training. Random-access memory-mapping — the access pattern a clip sampler actually needs — also costs nothing in this format and is awkward in every compressed one.

Generation

Produced by scripts/gen_dataset.py in a separate CARLA-side repo, which needs the carla wheel and so never shares an interpreter with the reader. datasets/carla.py in miniworld imports nothing from CARLA; there is a test asserting exactly that.

Limitations

• No held-out split. All 16 environments are training data. Splitting by town or by episode is left to the consumer.
• Traffic Manager only. Vehicle trajectories come from CARLA's built-in autopilot, so the action distribution is that of a cautious rule-following driver — few emergency stops, no collisions, no lane-departure recovery.
• Weather is imbalanced, as described above.
• No depth, segmentation, or bounding boxes in this repo. Depth maps exist in the capture pipeline but are not published here.
• Low quality preset. Rendering used CARLA's Low setting for throughput, so shadows and reflections are simplified relative to Epic.

License

CARLA's code is MIT; its assets — the town maps and vehicle models these frames render — are released under CC-BY. This dataset is derived from those assets and is published under CC-BY 4.0 to match. Please cite CARLA if you use it:

@inproceedings{Dosovitskiy17,
  title  = {{CARLA}: An Open Urban Driving Simulator},
  author = {Alexey Dosovitskiy and German Ros and Felipe Codevilla and Antonio Lopez and Vladlen Koltun},
  booktitle = {Proceedings of the 1st Annual Conference on Robot Learning},
  pages  = {1--16},
  year   = {2017}
}