VisionPilot: Autoware's Open Source L2 ADAS Stack Without HD Maps

What VisionPilot actually solves for OEM and Tier-1 teams

Most open driving stacks assume you can supply a 3D high definition map and a sensor suite. VisionPilot assumes neither. The README states it runs on a single front-facing monocular camera with 52 to 55 degree horizontal field of view and 1MP to 2MP resolution, and that it operates in a 'mapless' mode to follow the road in real time. That constraint defines the audience: automotive OEMs and Tier-1 suppliers who want a productionizable L2 feature set (ACC, FCW, AEB, LKAS, LDW, ISA and single-lane hands-free highway autopilot) without paying the map maintenance bill or adding a second camera. The README also notes the system can optionally be adopted for transportation and logistics in buses and trucks, but the primary framing is series production passenger cars. If your program already has a validated HD map pipeline and a radar-camera fusion stack, VisionPilot solves a problem you do not have.

The hybrid end-to-end architecture and what each model contributes

VisionPilot does not run one network. The README describes a 'Hybrid End-to-End AI Architecture' in which data is processed in parallel by perception AI models for safety and end-to-end AI models for performance. Three Autoware Foundation models do the work: AutoSpeed handles closest in-path object detection, AutoSteer produces ego path future waypoints, and AutoDrive performs end-to-end distance and in-path object presence detection plus road curvature estimation. The split matters because the two paths can disagree. A perception model that detects an object and an end-to-end model that predicts a trajectory are answering different questions, and the architecture keeps both answers available rather than collapsing them into one output. The README does not document how conflicts between the two paths are arbitrated, which is the first question a functional safety reviewer will ask. The model weights ship with the codebase, so there is no separate download step for them, but the ONNX Runtime binary is a manual download from Microsoft's GitHub releases page.

Building VisionPilot from source and running the OpenLane sample

The README gives three build paths: source, pre-built Debian package, and a third option not fully shown in the excerpt. The source path is the one with complete instructions. First clone the repository and download ONNX Runtime from its GitHub releases page, then configure with CMake pointing at the extracted runtime.

git clone https://github.com/autowarefoundation/autoware_vision_pilot.git
cd VisionPilot
mkdir build && cd build
cmake -DONNXRUNTIME_ROOT=<ONNX_RUNTIME_ROOT_PATH> ../
make

The build produces a VisionPilot executable inside the build directory. Two optional flags change what gets compiled: -DENABLE_ROS2_INTERFACE=ON adds ROS2 support, and -DENABLE_OCCUPANCY=ON adds a heuristic 3D bird's-eye panel beside the HUD, which the README says is off by default. Before running, the config files need editing. In vision_pilot.conf set source.mode = video, and in vision_pilot_test.conf point source.input_video and source.input_vehicle_speed at the sample files from the Google Drive directory. The README warns that when building from source you must update the config files before the build, not after.

./VisionPilot

Run from inside the build directory. The expected output is the visualization over the sample video, with the optional Occupancy window if you enabled it. The README points to VisionPilot/modules/visualization/README.md for the orbit, pan and zoom controls.

Where the documentation stops short

Several things a production team needs are absent from the README. There is no rollback procedure, no calibration workflow beyond the presence of a Calibration directory in the repository tree, and no description of how the three models were validated or on what data. The Functional_Safety directory exists, but the README does not explain what is in it or how it maps to ISO 26262 artifacts, so anyone citing it as safety evidence is doing so without the project's own guidance. The pre-built Debian package path is described as recommended when CUDA dependencies are not yet installed, and the build section shows a CPU-only configuration with -DGPU=OFF, but the README does not state the performance difference between the two. For a system whose central claim is real-time operation on a single camera, the absence of any latency or throughput figure in the README is a real gap. The introductory presentation is hosted on Canva and the video on Google Drive, which means the primary explanatory material lives outside the repository and can change without a commit.

VisionPilot compared with Autoware's full stack

The Autoware Foundation maintains both this project and the broader Autoware stack, and the difference is scope. Full Autoware targets higher levels of autonomy with lidar, HD maps and a planning stack that reasons over a map graph. VisionPilot strips that down to a monocular camera and a mapless mode, and the README frames the result as entry-level L2: in-lane features and single-lane hands-free highway driving. The trade-off is explicit. You give up map-based localization and the redundancy of multiple sensor modalities, and in exchange you get a stack that can be integrated into a vehicle with one camera and no map licensing costs. For a highway commute feature, that may be the right trade. For urban driving or anything above L2, the mapless monocular approach is not the tool.

Licence, packaging and what upgrading costs

VisionPilot is Apache-2.0, which the README describes as permissive and usable for both commercial and research purposes. That is unusually permissive for an ADAS stack and removes the licence negotiation that usually precedes an OEM evaluation. It does not remove patent risk or the need for your own safety case, and Apache-2.0 provides no warranty. On upgrades: three releases shipped in roughly five weeks, v1.0 on 2026-07-06, v1.1 on 2026-07-27 and v1.2 on 2026-08-10. The last push to the repository was on 2026-09-09, which is recent. A cadence that fast is good for momentum and bad for stability. There is no documented deprecation policy and no LTS branch mentioned, so pinning to a tag and reading the release notes before each move is the only safe upgrade path the README supports. The Debian packaging via cpack -G DEB gives you a versioned artifact to pin, which is at least a starting point for change control.

Editorial conclusion

VisionPilot is for OEM and Tier-1 teams that need an Apache-2.0 starting point for entry L2 features and are willing to work with an early codebase: v1.0 shipped on 2026-07-06 and v1.2 on 2026-08-10, so expect API churn. It is not for hobbyists expecting a plug-and-play autopilot, because the README's own path is clone, build with CMake and run VisionPilot against recorded video. Before committing, check three things: whether the AutoSpeed, AutoSteer and AutoDrive weights are sufficient for your target ODD, whether the ONNX Runtime version you download matches what the build expects, and whether the Functional_Safety directory in the repository contains the evidence your process requires. Start by running the OpenLane sample data through the build and reading the outputs against the config keys in vision_pilot.conf.

Frequently asked questions

Official sources

1. autowarefoundation/vision_pilot on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases