Make Navigation VLA Simple.
A simple, unified, reproducible, and extensible framework for navigation VLA research.

Project Page · Data Pipeline · Documentation · Results · Data, Environments & Models

SimpleNav is a simple, unified, reproducible, and extensible framework for navigation VLA research, jointly developed and open-sourced by THUNLP at Tsinghua University, AI9Stars, OpenBMB, and HITDIP. It provides a unified research pipeline that connects heterogeneous navigation data, long-horizon VLA models, training, and benchmark evaluation through well-defined interfaces. SimpleNav supports both aerial and ground navigation, preserves dataset-specific coordinate systems and simulator semantics through dedicated adapters, and standardizes model, action, artifact, and evaluation interfaces to enable efficient reuse, comparison, and extension across datasets, tasks, and platforms.

Table of Contents

• Why SimpleNav
• Framework
• Data Protocol
• Model
• Results
  • Demos
• Quick Start
  • 1. Clone and install the shared uv environment
  • 2. Prepare data
  • 3. Train
  • 4. Evaluate
• Documentation
• Roadmap
• Risks and Limitations
• Citation
• License
• Acknowledgements

Why SimpleNav

Framework

Data Protocol

The primary LeRobot dataloader keeps storage, model input, and prediction target separate:

Benchmark adapters may declare a different action Protocol when required by the benchmark. The config and adapter Protocol are authoritative. See Data Structure and State/Action Protocol.

Model

SimpleNav combines a vision-language backbone, selected long history, temporal-view context, and a continuous action head. The model consumes the protocol above and keeps dataset-specific coordinate semantics in the adapter.

Results

We adopt Qwen3.5-VL 4B as the unified vision-language backbone, and complete model training and closed-loop evaluation on 6 benchmarks respectively. Except for the necessary adaptation of data and task interfaces, we do not perform task-specific performance optimization for any individual benchmark. The results are summarized as follows. Full comparison tables and protocol notes are in Release 01 Benchmarks.

Demos

Animated rollout previews are shown below. Click an animation to play the full rollout video hosted on the project website. More videos are available in the project-page video gallery.

Quick Start

Public resources:

• Data, environments, and models

Place native dependency wheels in the repository-relative third_party/wheels/ directory. Place data, environment, and model packages in the local/ layout below.

1. Clone and install the shared uv environment

One root pyproject.toml installs the SimpleNav project into the root .venv. Base includes models, training, DINO, dataset conversion, trajectory augmentation, and common evaluation tools. The data-pipeline directories are source modules in this project, with six console commands; they are not separate distributions or uv workspace members.

Simulator dependencies are optional and selected by simulator, not by benchmark:

TravelUAV's DINO dependencies are in base. Benchmark data, scenes, and model weights are downloaded separately. VLN-CE conversion of already rendered data needs only base; online VLN-CE evaluation/rendering requires Habitat.

Python is fixed to 3.10.12; uv.lock pins dependencies, and ordinary packages use the Tsinghua index. Base includes CUDA training libraries: use Linux x86_64, a CUDA 12.4 toolkit and compatible NVIDIA driver, GCC/G++, and FFmpeg/FFprobe with H.264 support. Set CUDA_HOME to your toolkit; DeepSpeed requires an executable bin/nvcc. AirSim rendering additionally needs Vulkan and scene executables. Habitat source builds additionally need CMake, Ninja, and EGL/OpenGL development libraries.

sudo apt-get install build-essential python3.10-dev libjpeg-dev ffmpeg
git clone -b SimpleNav https://github.com/OpenBMB/SimpleNav.git SimpleNav
cd SimpleNav
curl -LsSf https://astral.sh/uv/install.sh | sh
export CUDA_HOME=/usr/local/cuda-12.4
export UV_PROJECT_ENVIRONMENT="$PWD/.venv"

Base wheels and installation

Download the FlashAttention and causal-conv1d wheels to the exact repository-relative paths below. Both are required by base and target Python cp310, Linux x86_64, Torch 2.6, CUDA 12, and C++ ABI FALSE. Habitat-Sim and Magnum are only needed when selecting habitat.

Wheels are ignored by Git; the source manifest and patches stay tracked. Download the two base wheels from the official releases:

mkdir -p third_party/wheels
curl -fL 'https://github.com/Dao-AILab/flash-attention/releases/download/v2.7.4.post1/flash_attn-2.7.4.post1%2Bcu12torch2.6cxx11abiFALSE-cp310-cp310-linux_x86_64.whl' \
  -o third_party/wheels/flash_attn-2.7.4.post1+cu12torch2.6cxx11abiFALSE-cp310-cp310-linux_x86_64.whl
curl -fL 'https://github.com/Dao-AILab/causal-conv1d/releases/download/v1.5.0.post8/causal_conv1d-1.5.0.post8%2Bcu12torch2.6cxx11abiFALSE-cp310-cp310-linux_x86_64.whl' \
  -o third_party/wheels/causal_conv1d-1.5.0.post8+cu12torch2.6cxx11abiFALSE-cp310-cp310-linux_x86_64.whl

Install base, then select the simulator(s) you need:

uv sync --frozen                                # base
uv sync --frozen --extra airsim                 # base + AirSim
# Or, after preparing the Habitat wheels below:
uv sync --frozen --extra habitat                # base + Habitat
# Or:
uv sync --frozen --extra unrealcv               # base + UnrealCV
# Multiple simulators in the same environment:
uv sync --frozen --extra airsim --extra habitat

Each sync selects the complete set of extras to keep: repeat all desired extras on subsequent syncs. uv sync --frozen with no extras returns to base. Use --frozen for installations from the committed lock so unselected simulators do not require their local wheels or source checkouts. Run commands with uv run --no-sync after installation. --extra dev adds development tools.

Core versions remain Torch 2.6.0/cu124, torchvision 0.21.0, Transformers 5.12.1, DeepSpeed 0.16.9, NumPy 1.26.4, PyArrow 14.0.1, and Pillow 12.2.0. Export CUDA_HOME in the shell used for training; launchers and evaluation workers select the root .venv directly.

Habitat only: source build

Skip this section for base, AirSim, or UnrealCV installations. Habitat-Sim is a Git submodule pinned to revision 3d6d67d6deae4ab2472cc84df7a3cef1503f606d (0.3.1), also recorded in third_party/sources.json. Its NumPy patch remains tracked at third_party/patches/habitat-sim-numpy126.patch; applying it leaves an expected local modification inside the submodule.

Install base first, then install the build prerequisites and build Habitat-Sim and Magnum/Corrade with the root interpreter. The patch check supports an already patched checkout:

sudo apt-get install cmake ninja-build libglm-dev libegl1-mesa-dev libgl1-mesa-dev

git submodule update --init --recursive --jobs 4
git -C third_party/habitat-sim apply --reverse --check ../patches/habitat-sim-numpy126.patch 2>/dev/null || \
  git -C third_party/habitat-sim apply ../patches/habitat-sim-numpy126.patch

cd third_party/habitat-sim
../../.venv/bin/python setup.py build_ext --parallel 8 bdist_wheel \
  --headless --bullet --skip-install-magnum --no-update-submodules --no-lto
cp dist/habitat_sim-0.3.1-cp310-cp310-linux_x86_64.whl ../wheels/
cd ../..

repo_root=$PWD
(
  cd third_party/habitat-sim/build/temp.linux-x86_64-cpython-310/deps/magnum-bindings/src/python
  "$repo_root/.venv/bin/python" setup.py bdist_wheel -d "$repo_root/third_party/wheels"
)

The build enables headless EGL and Bullet; RGB rendering does not require --with-cuda. Habitat-Lab 0.3.1 is installed from fixed Git revision 142616776544f918c19e7f0392b65cc8cc69fa13. Track tasks use the same installed Habitat-Lab.

If locally rebuilt wheels differ from the committed hashes, refresh their lock entries before installation (lock maintenance requires all four local wheels):

uv lock --refresh-package habitat-sim --refresh-package magnum
uv lock --check
uv sync --frozen --extra habitat
uv pip check --python .venv/bin/python
uv run --no-sync python -c "import habitat_sim; print(habitat_sim.__version__)"

If the Habitat wheels already match the lock, run uv sync --frozen --extra habitat directly. Include any other simulator extras you want to retain.

2. Prepare data

The converter is already installed in the shared environment:

uv run --no-sync vln-convert --help

The other component entry points are:

data_pipeline/trajectory_augmentation  -> vln-augment
data_pipeline/image_collection         -> vln-collect

Follow Data Preparation, then place local resources under:

local/
├── models/                         # base VLMs and auxiliary models
├── data/                           # converted datasets and benchmark inputs
├── checkpoints/                    # SimpleNav checkpoints + dataset_statistics.json
├── simulators/                     # AirSim/Habitat runtimes and scene assets
├── eval_results/
└── results/

Validate a converted split:

uv run --no-sync python -m tool.navvla.cli.validate_dataset \
  local/data/<dataset>/<split> --visual-token-mode online_images --smoke-load 8

3. Train

The public reference recipe is OpenFly Qwen3.5-VL training:

bash examples/NavVLA/train_files/qwen35/run_train.sh \
  examples/NavVLA/train_files/qwen35/navvla_qwen35_cpm_openfly_portable.yaml \
  --dry-run

bash examples/NavVLA/train_files/qwen35/run_train.sh \
  examples/NavVLA/train_files/qwen35/navvla_qwen35_cpm_openfly_portable.yaml

Copy the portable config before changing data mixtures, GPU counts, or attention implementations. See Training.

4. Evaluate

Each public config resolves paths relative to its own directory.

Inspect a two-episode plan before starting a simulator:

bash benchmark/openfly/run_eval.sh --dry-run \
  --override benchmark.max_samples=2 \
  --override parallel.gpu_ids='[0]' \
  --override output.run_name=openfly_dry_run

See Evaluation for resource layout, execution, resume, and artifacts.

For the OpenFly, AerialVLN, and TravelUAV data-to-training-to-evaluation workflow, use Aerial Training and Evaluation.

For the released R2R-CE and RxR-CE Qwen3.5 workflow, use VLN-CE Training and Evaluation.

Documentation

Roadmap

• Maintain released checkpoints, model cards, converted-data manifests, dataset cards, and simulator packages.
• Add portable multi-domain training recipes and extend the released single-dataset workflows.
• Expand model backbones, history and memory modules, action heads, and platform adapters.
• Publish reproducible result bundles with resolved configs and episode-level artifacts.
• Connect evaluation failures to data generation and the next training iteration.

Risks and Limitations

SimpleNav is a research framework whose performance may vary across environments and platforms. Validate models in simulation and controlled settings before deployment, with human oversight and independent safety measures; operators remain responsible for safe use.

Citation

If SimpleNav is useful in your work, please cite the repository.

@software{simplenav,
  title = {SimpleNav: Make Navigation VLA Simple},
  author = {{SimpleNav Contributors}},
  year = {2026},
  url = {https://github.com/OpenBMB/SimpleNav},
}

License

Repository source code is released under the MIT License. Datasets, pretrained models, simulators, scene assets, and third-party components retain their own licenses.

Acknowledgements

We thank pioneering navigation VLA studies, including NavFoM, Qwen-RobotNav, ABot-N0, starVLA and InternVLA-N1, whose valuable explorations have helped shape and advance this field.

SimpleNav builds upon starVLA, Qwen-VL, LeRobot, PyTorch, Transformers, DeepSpeed, AirSim, Habitat, as well as the datasets and benchmarks described above. We gratefully acknowledge these open-source contributions and encourage users to cite the original projects and datasets employed in their experiments.