Three open-source driving stacks, three completely different bets on how a vehicle should be automated — and picking the wrong one costs you six months. Autoware assumes you are building a robotaxi and want ROS 2 in the middle of everything. openpilot assumes you want to ship a driver assistance system to thousands of real cars this quarter. Apollo assumes you want a modular L4 platform with a middleware you control end to end.
64,152 GitHub stars sit behind openpilot, 12,256 behind Autoware, and 26,909 behind Apollo. Stars do not tell you which one compiles on your machine, integrates with your sensors, or still ships releases. This comparison does.
TL;DR — Quick Verdict
Choose Autoware if you are building a research platform, a shuttle, a yard truck, or anything that needs a full ROS 2 autonomy stack with simulation, mapping and scenario testing. It is the most complete system.
Choose openpilot if your target is a retrofit driver assistance product on consumer vehicles. It is the only one of the three with a real hardware fleet, a CAN interface, and an enforceably safe actuation path.
Choose Apollo if you need a battery-included L4 architecture with its own middleware (Cyber RT), a mature planning module, and you are comfortable running a Docker-centric C++ monorepo.
One-line summary: Autoware = most complete, openpilot = most deployable, Apollo = most self-contained.
Comparison Table
| Dimension | Autoware | openpilot | Apollo |
|---|---|---|---|
| Stars (Nov 2026) | 12,256 | 64,152 | 26,909 |
| Last push | 2026-11-12 | 2026-11-16 | 2026-04-16 |
| License | Apache-2.0 | MIT | Apache-2.0 |
| Primary language | C++ with ROS 2 packages | Python | C++ |
| Middleware | ROS 2 (DDS) | cereal + msgq | Cyber RT |
| Architecture | Meta-repo assembling Universe/Core/Launch | Monolithic stack, per-car port | Module-per-capability |
| Simulation | AWSIM, scenario simulator, CARLA bridges | MetaDrive-based sim launcher | Dreamview + simulator |
| Hardware path | Bring your own sensors and vehicle interface | comma 3X device, 300+ supported cars | Reference hardware, BYO sensors |
| Build system | colcon + rosdep + vcstool | ./tools/op.sh | ./apollo.sh in Docker |
| GPU requirement | Effectively yes for perception | Yes (model inference) | Yes on x86 |
| Learning curve | Steep — ROS 2 literacy needed | Moderate for the stack, steep for car porting | Steep — proprietary middleware |
| Best fit | Shuttles, research, yard/logistics | Retrofit driver assistance | L4 platform engineering |
Decision Matrix
| If this is you | Pick | Reason |
|---|---|---|
| University lab with ROS 2 experience | Autoware | Every component is a ROS 2 node you can swap |
| Startup building a retrofit ADAS product | openpilot | Only stack with a road-proven actuation and panda CAN path |
| Company with its own vehicle platform, wants L4 planning | Apollo | Cyber RT gives deterministic module scheduling out of the box |
| You need scenario-based safety validation | Autoware | Scenario simulator and lanelet2 tooling are built in |
| You want to contribute to a fast-moving project | openpilot | Daily commits, MIT license, active review |
| You need an air-gapped reference architecture | Apollo | Self-contained Docker workflow, few external service calls |
| You have no GPU budget | None of these | All three assume hardware acceleration for perception |
Autoware — The Complete System, With the Complete Setup Cost
Autoware is not a single build. The autowarefoundation/autoware repository is a meta-repo: it pins compatible revisions of Autoware Core, Autoware Universe and Autoware Launch, and you materialise it with vcstool. That design is why it stays coherent across dozens of packages, and also why your first build takes an afternoon.
| |
Then bring up the planning simulator with a sample map:
| |
What you get: localization (NDT and GNSS fusion), perception with camera and lidar pipelines, lanelet2-based routing, behavior and motion planning, and a vehicle interface abstraction that you implement once and reuse across vehicle types.
What it costs you: ROS 2 fluency is mandatory. The package graph is large, launch files nest three or four levels deep, and debugging means reading ROS 2 logs across a dozen nodes. Budget a week for a first working simulation, a month for a first sensor-equipped vehicle.
Where it shines: the map-first architecture. Because everything keys off lanelet2 vector maps, you can validate an entire route in simulation before touching hardware — that is exactly what safety reviewers want to see.
openpilot — The One That Actually Ships
openpilot is an MIT-licensed driver assistance stack that runs on comma’s own hardware and is ported to 300+ car models through community and in-house work. Where Autoware starts from “assume nothing about the vehicle”, openpilot starts from “here is the car, here is its CAN bus, here is the actuation path”.
Setting up the development environment is genuinely two commands:
| |
The runtime layout explains the design philosophy: a cereal message schema defines every signal on the bus, msgq carries those messages between processes with a shared-memory transport, panda firmware sits on the CAN side enforcing rate and torque limits, controls produces actuation, and the perception pipeline feeds it lane and lead-vehicle state.
What you get: a stack with a real safety story. The panda board is a separate microcontroller that clamps commands — if the main compute dies, actuation stops. That is not a design you can bolt on later, and it is why openpilot is the only one of these three that hobbyists and small teams actually put on the road.
What it costs you: you are inside someone else’s architecture. Porting a new car means reverse-engineering its CAN signals and writing a car interface — weeks of work per model, and no shortcut. The stack also assumes comma’s hardware for deployment; running on your own compute is a development path, not a supported product path.
Where it shines: iteration speed. Because the fleet reports back real disengagement data, fixes land fast. The project pushed commits on the same day this article was written.
Apollo — L4 Architecture in a Box
Apollo is Baidu’s open platform: a C++ monorepo with its own middleware, Cyber RT, which schedules module processes with a deterministic, conflict-free graph instead of a best-effort message bus. If your organisation dislikes ROS 2’s discovery model, Cyber RT is a legitimate alternative.
The workflow is Docker-first, and everything assumes you are inside the container:
| |
What you get: a modular platform with perception, prediction, planning, control and a browser-based Dreamview for replay and monitoring. The planning module is unusually mature for an open project — public-road rule-based planning with scenario switching.
What it costs you: the last push to the repository was April 2026, which is a slow cadence compared with the other two. Cyber RT is Apollo-specific knowledge that transfers poorly to other robotics work, and the Docker images are large enough that CI runners need real disk. Documentation quality varies sharply between modules.
Where it shines: when you need a complete, self-contained reference design and you would rather adopt an architecture than assemble one.
Pitfalls That Cost Real Weeks
GPU assumptions are baked in. All three stacks expect CUDA for perception. Autoware’s perception packages will build without it and then fail at runtime; openpilot’s setup script checks for a supported compute path; Apollo’s build flags assume x86 plus NVIDIA. Plan your hardware before your software.
Map formats are not interchangeable. Autoware is lanelet2-first. Apollo uses its own protobuf map format plus OpenDRIVE import. Converting between them is a project, not a script. Choose the map format you can actually source for your site.
Simulation is where the schedule dies. Autoware’s simulator needs a calibrated sensor kit definition; openpilot’s sim is great for regression testing, not for validating a new vehicle; Apollo’s Dreamview replay assumes recorded Apollo-format bags. Validate your data pipeline before promising a demo date.
Calibration is a deliverable, not a step. Camera intrinsics, lidar-to-camera extrinsics, IMU alignment and vehicle geometry all need repeatable procedures. None of the three hands you a finished calibration workflow for your specific sensor set.
Safety and legality are yours. openpilot ships a torque-limiting safety model; Autoware and Apollo leave actuation safety to your vehicle interface. None of them makes your deployment legal, and regulatory approval is per-jurisdiction.
Version pinning matters more than star counts. Autoware’s meta-repo pins by design — do not float branches. openpilot moves fast enough that a two-week-old fork may not build. Apollo expects a specific container tag. Pin everything.
For related builds, our ROS 2 navigation and MoveIt guide covers the middleware layer these stacks sit on, the robotics simulation comparison helps you choose a simulator, and if your project is airborne rather than on-road the ArduPilot vs PX4 vs Betaflight comparison is the equivalent decision for drones.
FAQ
Is openpilot fully open source?
Yes — the repository is MIT licensed and includes the vehicle interface, controls, perception pipeline and the panda firmware. The caveat is hardware: comma’s device is the supported deployment target, and its safety model depends on that board’s CAN enforcement. You can read and modify everything, but a custom compute platform means you own the safety argument.
Can Autoware run without ROS 2?
No in practice. Autoware is a collection of ROS 2 packages communicating over DDS, with launch files orchestrating nodes. You can replace individual components with your own nodes, but removing ROS 2 removes the integration layer the whole system depends on.
Which stack is best for a university research project?
Autoware. The component boundaries are clean ROS 2 interfaces, the simulator lets you test planning changes without hardware, and results are comparable with published work that uses the same stack. openpilot is harder to instrument for research because it is optimised for a shipping product, not for introspection.
Does Apollo still receive updates?
The repository shows activity through April 2026, which is slower than Autoware and openpilot. It is stable rather than abandoned — the architecture and planning modules are mature — but do not expect rapid upstream fixes. If you need a vendor-backed support path, evaluate commercial forks instead of the open repo alone.
What hardware do I need to start experimenting?
A recent x86 machine with an NVIDIA GPU and 32 GB of RAM is enough to build and run any of the three in simulation. For real vehicles, Autoware and Apollo expect lidar plus camera plus GNSS/INS, while openpilot is built around a forward camera and the vehicle’s existing CAN bus. Start in simulation — all three let you do that without buying sensors.
💰 想测试你的市场判断力?我用 Polymarket 做预测市场交易——这是全球最大的预测市场平台,从大选结果到技术监管时间线,什么都可以押注。和赌博不同,这是真正的信息市场:你懂的信息越多,胜率越高。我靠预测技术相关事件的走向已经赚了不少。用我的邀请链接注册:Polymarket.com