SIMLOG-25k is licensed under Creative Commons Attribution-NonCommercial 4.0 International (CC-BY-NC-4.0): you may use, share and adapt it for non-commercial purposes, with attribution to SimForge and a note of any changes. Commercial use needs a commercial licence from SimForge (contact@simforge.ai). SimForge uses this information to understand who uses the dataset and to contact you if you opt in; see https://simforge.ai/privacy.

SIMLOG-25k

24,483 real-world driving scenarios on 7 SimForge Worlds (HD maps and digital twins of real places), ready to run closed loop. Each scenario is built from a recorded real-world drive: the motion of every road user, re-created as positions on one of the Worlds, then simulated again and kept only if it passes the release gates. There is no video and no sensor data in this dataset; you simulate or render a scenario yourself, with SimForge or, through the OpenSCENARIO export, another simulator.

Version 0.2.2 · format simforge.public-dataset/v1 · licence Creative Commons Attribution-NonCommercial 4.0 International (commercial licence available).

Quick start

pip install "datasets>=3" huggingface_hub
hf auth login                      # accept the terms on this page first
hf download SIMFORGE-AI/simlog-25k --repo-type dataset --local-dir simlog-25k   # everything, ~150 GB

Or load the index and fetch only the scenarios you need (examples/load_simlog.py):

import gzip, json
from datasets import load_dataset
from huggingface_hub import hf_hub_download

REPO = "SIMFORGE-AI/simlog-25k"
test = load_dataset(REPO, split="test").filter(lambda r: r["sim_verdict"] == "clean")
row = test[0]
fetch = lambda path: hf_hub_download(REPO, path, repo_type="dataset")
trace = json.load(gzip.open(fetch(row["trace"])))      # every actor's pose every 20 ms
ego = trace["ticks"]["actors"][trace["header"]["metricSubject"]]
print(row["title"], row["map"], len(trace["ticks"]["t"]), "ticks; ego x:", ego["x"][0], "->", ego["x"][-1])

To simulate, render or evaluate a scenario, see Getting started with the SimForge CLI.

Getting started with the SimForge CLI

The scenarios run on the SimForge runtime through the simforge command-line tool. You simulate a scenario on its World, render it (a top-down video, or photoreal camera, lidar and radar data) and evaluate the result. Full documentation: simforge.ai/docs.

1. Install the CLI and sign in (Linux x86_64 and macOS; on Windows, irm https://simforge.ai/install.ps1 | iex):

curl -fsSL https://simforge.ai/install.sh | sh
simforge login               # approve in your browser; on a machine without one: simforge login --device
simforge doctor --offline    # checks the GPU, ffmpeg and disk, with the fix for anything missing

2. Install the runtime and the scenario's World. Accepting the runtime licence (PolyForm Noncommercial 1.0.0) and the map terms entitles your account to both. A scenario's World is its map in the index (sourceMap.mapId in its document.json).

simforge runtime install --accept-license            # simulation and 2D renders; add --for 3d for local photoreal renders
simforge maps pull el-camino-road --accept-license   # a few MB; --for 3d adds the digital twin (5 to 22 GB)

3. Download a scenario and simulate it. Here, El Camino · fec09ed4 from the test split; the folder holds the scenario, its recording, its trace and its OpenSCENARIO export:

ID=fec09ed46a2d5d5a655227a972981b29fb5649f28d5d7a85321ce5ca3814a44e
hf download SIMFORGE-AI/simlog-25k --repo-type dataset --local-dir simlog-25k --include "scenarios/el-camino-road/fe/$ID/*"
S=simlog-25k/scenarios/el-camino-road/fe/$ID
simforge simulate $S/document.json --out sim

The simulation writes sim/trace.json.gz, in the same format as the released trace.json.gz. Every command prints one JSON document with its result.

4. Render it.

simforge render $S/document.json --mode 2d --out topdown            # top-down video, on the CPU
simforge rig init --preset roof-8cam-6lidar-4radar --out rig.json   # 8 cameras, 6 lidar, 4 radar on the ego
# a rig with radar also needs a video block (its fps is the radar sample rate):
python -c "import json; r=json.load(open('rig.json')); r['video']={'width':1280,'height':720,'fps':24,'container':'mp4','codec':'h264','quality':'standard'}; json.dump(r,open('rig.json','w'),indent=1)"
simforge render $S/document.json --mode 3d --rig rig.json --out helios

A 3D render (Helios Engine) writes a video per sensor (video/<sensor>.mp4), depth, semantic and instance passes per camera frame, lidar point clouds (.ply) and radar returns (.csv). Without --rig it renders one front camera. With this rig, a 20 s scenario takes about 4 minutes on an RTX 5080 and writes about 26 GB; --passes rgb drops the depth, semantic and instance passes. Locally it needs the runtime and the map installed --for 3d, and an NVIDIA GPU with at least 8 GiB or an Apple M3 or newer (San Ramon at full textures needs about 11 GiB; --textures bc7-512 brings it under 5 GiB). Without a GPU, render on SimForge cloud: add --cloud --max-cost <cents> --wait --download. A cloud job is priced before it starts, and --dry-run only quotes it. See Preview and render and Sensors.

5. Evaluate. Measure a trace locally, free: the released trace.json.gz or the one your simulation wrote.

simforge evaluate sim/trace.json.gz > eval.json

metrics in the result holds collisions, the minimum distance and time to collision between the ego and each road user, and the hardest braking a conflict required. The command's verdict comes from SimForge's filter for generated test scenarios. That filter rejects an uneventful drive, such as this one, as trivially-safe (exit code 2). For SIMLOG scenarios, use the metrics, not the exit code.

To evaluate a driving model in closed loop, copy scenarios into a dataset in your SimForge workspace and run a hosted evaluation; the model drives the ego through each scenario and is scored. It is priced per scenario, and the CLI shows the total and asks before it starts. --dry-run on the copy only counts the scenarios (29 here).

simforge datasets copy simlog-25k --filter 'map:richmond-field-station split:test' --new 'SIMLOG-25k Richmond test'
simforge evaluate --cloud --dataset 'SIMLOG-25k Richmond test'                         # lists the models you can run
simforge evaluate --cloud --model <model> --dataset 'SIMLOG-25k Richmond test' --wait

To evaluate your own model on your own GPU, use SimForge Gym (pip install simforge-gym). It reports driving score, route completion, collisions, infractions and comfort.

How it was built

From real drives. Each scenario starts from a recorded real-world drive. The ego's and every other road user's motion is re-registered onto the road geometry of a SimForge World and kept as positions only; no images, sensor data or identifiers from the original recording are in the dataset.
Simulated again. Every scenario was simulated afresh on the released SimForge runtime (0.31.0, build 1163) at 50 Hz.
Gated. A scenario is in the dataset only if it passes four release gates (below). 10,235 candidates were left out: 6,791 used an actor model that is not in the public asset pack, 1,955 were out of the release's scope, 773 overlapped held-out test material, 485 failed the traffic-law gate, 140 were empty after curation, 89 failed the simulation gate and 2 were duplicates.
Checked for determinism. A re-simulated sample of 468 scenarios produced byte-identical traces.

The scenarios were selected and checked automatically; there was no per-scenario human review.

Worlds

World	Scenarios
Belmont Research Center (`belmont-research-center`)	915
Di Rosa, San Francisco (`di-rosa-sf`)	3,951
Easterbrook Discovery School (`easterbrook-discovery-school`)	760
El Camino Road, Palo Alto (`el-camino-road`)	2,989
Richmond Field Station (`richmond-field-station`)	206
San Ramon, phase 1 (`san-ramon-phase-1`)	11,511
Yale Street, Palo Alto (`yale-street`)	4,151

The Worlds (ASAM OpenDRIVE road networks and their digital twins) are available after a free sign-in, with simforge maps pull <map>; see SimForge Worlds.

What's in it

Measured over all 24,483 scenarios:


Length	median 19.9 s (14.8 to 27.8 s); 133.5 hours in total
Moving road users per scenario	median 8; 10% have 2 or fewer, 10% have 40 or more (up to 399)
Scenarios with a pedestrian	4,536
… with a motorcycle	577
… with a cyclist	298
Collisions	0 (no scenario is a collision scenario)

Each scenario also names a time of day and weather for rendering (noon 18,417, lit night 4,392, dusk 924, afternoon 546, night 198, dawn 6; clear 15,126, cloudy 4,366, wet road 2,660, snow 1,396, light rain 715, light fog 220). These are rendering presets assigned to the scenario, not the conditions of the original drive.

There are no scenario category labels in this version.

Files

Each scenario is a folder scenarios/<map>/<id[:2]>/<id>/ (<id[:2]>: the first two characters of its id, which keeps every folder far below 10,000 entries):

File	Format
`document.json`	the scenario: SimForge scenario document v4 (`schema/`)
`recordings/<sha256>.rec.json.gz`	the motion tracks the scenario plays back: `simforge.recording/v1`, positions on the map's OpenDRIVE frame at 50 Hz
`trace.json.gz`	the simulation result: `simforge.trace/v5`, every actor's pose per 20 ms tick, as the SimForge runtime 0.31.0 (build 1163) simulated it
`scenario.xosc`	the same scenario as ASAM OpenSCENARIO 1.4, for other simulators

At the root: scenarios.jsonl (one line per scenario: id, title, map, split, the checks' readings, files and their sha256), index/<split>.parquet (the same index, one table per split; the default config above), manifest.json (counts, the runtime, the gates), SHA256SUMS (sha256sum -c SHA256SUMS), schema/ (scenario-template.v4.schema.json, recording.v1.schema.json), LICENSE and NOTICE.

12,691 scenarios use a CARLA model in place of a vehicle or prop model that is not in the public asset pack; each substitution is listed in its scenarios.jsonl line (actorSubstitutions).

Splits

Split	Scenarios	With a `clean` verdict
train	19,297	17,268
validation	2,320	1,842
test	2,866	2,466

The splits are fixed: a scenario keeps its split in every version of the dataset. All scenarios made from the same recorded drive are in the same split. The splits are not stratified by World or by verdict.

How scenarios were checked

Every scenario was simulated afresh on the released SimForge runtime, and is in the dataset only if:

it simulates, and its ego and key actors (the ego and every road user that is not a replayed background track) move only in physically possible ways;
it has no collision, unless the scenario is labelled as a collision scenario;
none of its ego and key vehicles runs a red light or rolls through a stop line, and no crossing is flagged as a possible violation the measurement could not settle;
it exports to OpenSCENARIO 1.4.

Each row also carries readings the gates do not exclude on:

sim_verdict grades the motion of every actor, background tracks included: clean 21,576, warnings 421 (simulation diagnostics), implausible 2,486 (at least one tick of physically implausible motion, always of a background actor, since key actors are gated). For evaluation, we recommend the clean subset.
crossings counts the signal- and stop-controlled crossings the traffic-law measurement could and could not observe; 13,282 scenarios contain crossings it could not observe (34,039 in total). None was flagged as a possible violation, but they are not verified as compliant either.

Each scenario's verdict comes from a closed-loop simulation on the released runtime; a re-simulated sample of 468 scenarios was byte-identical.

Test sets and duplicates are removed. Scenarios that use an actor model outside the public CARLA asset pack are either mapped to the CARLA model with the same blueprint or left out.

Intended uses

Closed-loop evaluation of driving policies: the policy drives the ego, and the rest of the scene plays back.
Reinforcement learning and fine-tuning in closed loop, for example with SimForge Gym.
Sensor simulation: render camera and lidar for any scenario with Helios Engine, SimForge's renderer, on the Worlds' digital twins.
Scenario and simulation research, including in other simulators through the OpenSCENARIO export.

Out of scope: evidence for safety certification or homologation; estimating real-world crash or violation rates (the release is gated to remove collisions and violations); commercial use without a commercial licence; any attempt to identify the original drives or the people in them.

Limitations

Traffic is not reactive. Every road user except the ego replays its recorded track; it does not respond to what the ego does. Closed loop here means the ego is controlled by your policy.
The places are real; the motion was recorded elsewhere. Each drive's motion was re-registered onto a World's road geometry, so the behaviour is real driving but not a recording made on that road.
Near-duplicates. Some scenarios replay the same recording placed at a different site of the same World. When you need independent samples, keep one scenario per recording (its sha256 is in the recordings/ file name). Scenarios that share a recording are always in the same split.
Imbalanced. San Ramon holds 47% of the scenarios and Richmond Field Station 0.8%; the implausible share is 9.0% of train, 15.9% of validation and 13.0% of test.
Positions only. No camera, lidar or radar data from the original drives; anything you render is simulated.
Asset substitutions. About half the scenarios use a CARLA model in place of the original vehicle or prop model (listed per scenario).
No labels for scenario type, and no collisions: this is not a crash or near-miss dataset.

Helios Engine: SimForge's renderer for closed-loop driving simulation.
SimForge Worlds: the seven Worlds these scenarios run on.
SimForge Gym: train driving models on SimForge, in closed loop.

Licence

The scenarios are licensed under Creative Commons Attribution-NonCommercial 4.0 International (LICENSE holds the full legal code): free for research, evaluation and other non-commercial use, with attribution. A commercial licence is available from SimForge: contact@simforge.ai. Access is granted after you accept these terms on this page.

How to cite and attribute

When you share this dataset or anything made from it, credit SimForge, name the dataset and its version, link this page and the licence, and state whether you modified it (NOTICE has the same text):

"SIMLOG-25k" (version 0.2.2) by SimForge, https://huggingface.co/datasets/SIMFORGE-AI/simlog-25k, licensed under CC-BY-NC-4.0 (https://creativecommons.org/licenses/by-nc/4.0/). Modified: [what you changed, or "no"].

@misc{simlog_25k,
  title  = {SIMLOG-25k},
  author = {{SimForge}},
  year   = {2026},
  note   = {Version 0.2.2},
  url    = {https://huggingface.co/datasets/SIMFORGE-AI/simlog-25k}
}

Downloads last month: 91

Total file size:

150 GB

You need to agree to share your Hugging Face information to access this dataset