Overview
AlpaSim is an open-source autonomous vehicle simulation platform from NVIDIA Labs, built for research and development. It tests end-to-end driving policies in a closed loop: the simulator renders realistic camera frames, the policy under test answers with a planned trajectory, and the simulator applies vehicle dynamics, ground constraints and traffic before rendering the next frame. Its scenes are USDZ artifacts built from real-world driving logs, with a public sample set published on Hugging Face.
The project describes itself as modular, lightweight and data-driven, and its design document names three principles — sensor fidelity, horizontal scalability and hackability for research — while listing real-time operation and very precise physics as non-goals. To get there it is split into Python microservices that talk over gRPC: a renderer, physics, a controller/vehicle model, traffic simulation, the driver (the policy being evaluated) and a runtime at the centre that drives the simulation loop, logs every message and load-balances across replicas of the other services. An eval module runs outside the loop and turns the logs into driving metrics and videos.
The default renderer is NVIDIA NuRec, running on the Neural Rendering Engine (NRE), and the same renderer endpoint can instead be backed by the OmniDreams video model through FlashDreams. Supported driving policies include NVIDIA's Alpamayo-R1 and Alpamayo 1.5, Valeo's VaVAM (the tutorial default) and a provisional Latent TransFuser v6 integration. Runs are configured with Hydra and launched by the `alpasim_wizard` CLI, locally with Docker Compose or on SLURM clusters. The code is Apache-2.0 licensed.
What it does
- Pluggable renderer service: NuRec neural rendering by default, or the OmniDreams video model through FlashDreams for stateful, video-model rendering behind the same endpoint
- High-fidelity camera feeds with configurable field of view, resolution and frame rate, plus sensor noise and environmental conditions
- Microservice architecture over gRPC, so any component — driver, controller, physics, renderer — can be swapped for a custom implementation or container image
- Built-in driver integrations for Alpamayo-R1, Alpamayo 1.5, VaVAM and a provisional TransFuser (LTFv6), with a reasoning-overlay video layout for chain-of-causation output
- Evaluation output per run: per-rollout metrics in Parquet, an aggregated score table and plot, and videos sorted by violation type such as collision and offroad
- Horizontal scaling: replicate individual services for load balancing, run multi-node deployments on SLURM, and inspect performance through Prometheus telemetry
Getting started
The tutorial path runs on a single machine with Docker Compose. Prerequisites from the onboarding guide: uv 0.9.17 or newer, a Rust toolchain, Docker with Compose and Buildx (usable without sudo), CUDA 12.8+ with an NVIDIA driver 570 or newer, the NVIDIA Container Toolkit, and a Hugging Face token with access granted to the gated nvidia/PhysicalAI-Autonomous-Vehicles-NuRec dataset.
Clone and set up the environment
The setup script compiles the gRPC protos, downloads an example driver model, checks for a valid Hugging Face token and installs the `alpasim_wizard` CLI.
git clone https://github.com/NVlabs/alpasim.git
cd alpasim
source setup_local_env.shFetch the default driver's assets
The tutorial's default policy is VaVAM; its weights and the scenes are downloaded from Hugging Face.
export HF_TOKEN="<your_hf_token>"
bash data/download_vavam_assets.sh --model vavam-bRun a simulation
The wizard writes the config files, downloads the scene if needed and runs the closed-loop simulation. Results land in `tutorial/`: rollout logs under `rollouts/`, and a score table, metrics plot and violation videos under `aggregate/`.
uv run alpasim_wizard deploy=local topology=1gpu driver=vavam wizard.log_dir=$PWD/tutorialSwap the policy or the scenes
Change `driver=` to test another policy (Alpamayo 1 and 1.5 are 10B-parameter models needing about 40 GB of VRAM), pick scenes by id, or run a whole public scene suite.
uv run alpasim_wizard deploy=local topology=1gpu driver=alpamayo1_5 wizard.log_dir=$PWD/tutorial_alpamayo
uv run alpasim_wizard deploy=local topology=1gpu driver=vavam scenes.test_suite_id=public_2601 wizard.log_dir=$PWD/tutorial_suiteCommands and code are distilled from the project's own documentation — always check the official repo for the latest.
When to use it
- Validate a new end-to-end driving policy closed-loop on scenes reconstructed from real drives, rather than only open-loop on recorded logs
- Regression-test and benchmark driving models across a fixed scene suite, comparing aggregated scores and collision or offroad violations
- Debug a policy's behavior by replaying `.asl` logs into a driver instance or attaching a breakpoint debugger to one microservice while the rest run in Docker
- Plug a custom driver, controller or renderer into the simulation loop by exposing a compatible gRPC service
How AlpaSim compares
AlpaSim alongside other open-source simulators & synthetic environments tools AI/TLDR tracks, ranked by GitHub stars.
| Tool | Stars | What it does |
|---|---|---|
| AirSim | ★ 18.6k | Microsoft's Unreal Engine simulator for drones and cars, with a Computer Vision mode, weather effects and C++/Python/C#/Java APIs for generating training data and testing control policies. |
| CARLA | ★ 14.5k | An open-source driving simulator built for autonomous-driving research, shipping urban maps, vehicles and pedestrians with configurable sensor suites and weather behind a Python API. |
| AlpaSim | ★ 1.3k | NVIDIA's open-source closed-loop simulator for testing end-to-end driving policies |