1. openpilot

github.com/commaai/openpilot

openpilot is an open-source driver assistance system from comma.ai. It adds features such as adaptive cruise control and lane centering to a large list of supported production cars by reading camera and CAN data, running neural networks on-device, and sending steering and speed commands back through a CAN interface.

Why it matters

It is one of the few complete, production-quality ADAS codebases you can read end to end: a driver monitoring model, a driving model, a planner, a lateral and longitudinal controller, and per-car interface code. It also shows how real teams think about safety limits, such as torque rate limits and driver override.

Skills you build

• Vehicle interfaces and CAN message handling per car brand
• Longitudinal and lateral control (PID, MPC concepts)
• Inter-process messaging with a publish/subscribe model
• On-device ML inference constraints

First step

Browse the selfdrive directory and read how a car interface translates high-level commands into CAN messages. Then replay a recorded drive to see the pipeline without any hardware.

2. opendbc

github.com/commaai/opendbc

opendbc is a collection of DBC files and Python tooling that describe CAN messages for many vehicles, along with parsers and packers that turn raw bytes into named signals. Recent versions also host car-specific interface and safety logic that sits close to the bus.

Why it matters

A DBC file is the common language of CAN work. Reading a large, real-world collection teaches you how signals are laid out: start bit, length, byte order, factor, offset and units. That is exactly what you need when you debug a bus trace or write a gateway.

BO_ 304 GAS_PEDAL: 8 PCM
 SG_ GAS_POS : 7|8@0+ (0.4,0) [0|100] "%" EON

The snippet above shows a message with ID 304 and one signal: 8 bits starting at bit 7, big-endian, scaled by 0.4 to give a percentage. (Illustrative example, not a real vehicle definition.)

First step

Pick one DBC, find a speed or pedal signal, and decode a few bytes by hand. Then confirm your result using the Python parser.

3. Apollo Auto

github.com/ApolloAuto/apollo

Apollo is Baidu’s open autonomous driving platform. It is a modular stack with perception, prediction, planning, control, localization, mapping and a custom runtime (Cyber RT) designed for deterministic scheduling of autonomy components.

Why it matters

Apollo shows what an industrial-scale L4 architecture looks like: HD map handling, multi-sensor fusion, scenario-based planning, and a task-scheduling framework built for latency. It is large, so treat it as a reference to study module by module.

First step

Read the module list, then follow one data path, for example from a camera frame to a detected object to a prediction. Do not try to build everything on day one.

4. Autoware

github.com/autowarefoundation/autoware

Autoware is an open-source autonomous driving stack built on ROS 2 and maintained by the Autoware Foundation. It covers localization with lidar, perception, planning, control and vehicle interface layers, with a strong focus on real-world deployments such as shuttles and robotaxis.

Why it matters

If your company already uses ROS 2, Autoware is the natural bridge into autonomous driving. Its architecture documentation is a good example of how to decompose a self-driving system into well-defined interfaces.

First step

Run the planning simulator on a sample map, then change one parameter such as a speed limit and watch the effect on the trajectory.

5. CARLA Simulator

github.com/carla-simulator/carla

CARLA is an open-source driving simulator built on Unreal Engine. It provides cities, weather, traffic, pedestrians and a sensor suite (RGB, depth, semantic segmentation, lidar, radar), controlled through a Python API.

Why it matters

Real testing is expensive and risky. CARLA lets you test perception and control ideas safely, generate labelled training data, and replay edge-case scenarios again and again. It also connects to ROS and to scenario runners for systematic testing.

import carla
client = carla.Client("localhost", 2000)
world = client.get_world()
bp = world.get_blueprint_library().filter("vehicle.*")[0]
vehicle = world.spawn_actor(bp, world.get_map().get_spawn_points()[0])
vehicle.set_autopilot(True)

First step

Spawn a vehicle, attach a camera, and save frames to disk. Then change the weather and compare.

6. vsomeip

github.com/COVESA/vsomeip

vsomeip is an open-source implementation of SOME/IP (Scalable service-Oriented MiddlewarE over IP), the protocol used by AUTOSAR for service-oriented communication on automotive Ethernet. It supports service discovery, request/response, events and fields.

Why it matters

As vehicles move to zonal and centralised architectures, signal-based CAN is giving way to services. vsomeip lets you run a real service provider and consumer on a laptop and watch the packets in Wireshark.

First step

Build the examples, run one service and one client, and capture the traffic. Identify the SOME/IP header fields: service ID, method ID, length, client ID, session ID, protocol version, interface version, message type and return code.

7. autoas / as

github.com/autoas/as

This project is an open-source automotive software platform that implements many AUTOSAR-style modules, such as communication, diagnostics, memory and OS-related layers, and runs on a PC for experimentation. Check the repository README for the current scope and which modules are covered.

Why it matters

Commercial AUTOSAR stacks are expensive and closed. Reading an open implementation lets you see how PduR routes PDUs, how ComM manages networks, and how Dcm handles UDS requests.

First step

Trace one CAN frame as it moves from the driver up through CanIf and PduR to a signal in Com.

8. CANdevStudio

github.com/GENIVI/CANdevStudio

CANdevStudio is a graphical tool for simulating a CAN network. You drag and drop nodes (CAN device, signal sender, signal viewer, raw viewer), connect them and generate traffic without needing a real car. It can use SocketCAN and other backends on supported platforms.

Why it matters

It is a low-friction way to prototype a bus, test a DBC, or teach CAN to new team members. Pair it with a virtual CAN interface on Linux and you can practise with zero hardware.

sudo modprobe vcan
sudo ip link add dev vcan0 type vcan
sudo ip link set up vcan0
cansend vcan0 123#11223344
candump vcan0

First step

Create a vcan0 interface, load a DBC in CANdevStudio and send a periodic signal. Watch it in candump.

9. panda

github.com/commaai/panda

panda is the firmware and Python library for comma.ai’s USB vehicle interface, which exposes CAN, and other buses depending on the model, to a host computer through OBD-II or a harness. It runs on an STM32 microcontroller and enforces safety rules before messages reach the vehicle.

Why it matters

It is a rare open example of embedded firmware that is both a bus adapter and a safety gate. You see interrupts, USB handling, CAN driver code and a safety model that blocks unsafe commands, all in readable C.

10. Awesome Automotive

github.com/ajay-bhojani/Awesome-Automotive

A curated list of automotive tools, standards, courses, articles and projects. Think of it as a map of the field rather than a codebase.

Why it matters

The automotive domain is wide: diagnostics, functional safety, cybersecurity, testing, simulation, standards. A good list shortens your search time and often leads to repositories you would not otherwise find.

First step

Pick one category you know little about, such as diagnostics or cybersecurity, and open three links from it.

11. Eclipse KUKSA

github.com/eclipse-kuksa

KUKSA is an organisation of projects under the Eclipse Software Defined Vehicle ecosystem. Its core idea is a vehicle abstraction layer: a data broker exposes signals defined by the COVESA Vehicle Signal Specification (VSS), and apps read or write them through a common API instead of talking to raw buses.

Why it matters

This is the pattern behind software-defined vehicles. An app asks for Vehicle.Speed and does not care whether it comes from CAN, SOME/IP or a simulator. That portability is the whole point.

First step

Run the data broker in a container, set a speed value with the CLI and read it back from a small client.

12. Eclipse iceoryx

github.com/eclipse-iceoryx/iceoryx

iceoryx is a shared-memory inter-process communication framework. A publisher writes data once into shared memory and subscribers receive a reference, so large payloads such as camera frames and point clouds are never copied.

Why it matters

Autonomy stacks move gigabytes per second between processes. Copying that data costs CPU time and adds jitter. iceoryx shows how to design for bounded latency, and it is used as a transport option in ROS 2 and in the AUTOSAR Adaptive world.

First step

Run the publisher and subscriber examples, then send a large payload and compare against a socket-based test.

13. CANopenNode

github.com/CANopenNode/CANopenNode

CANopenNode is a free and open-source CANopen protocol stack written in C, designed for microcontrollers, with an object dictionary, PDOs, SDOs, heartbeat, NMT and emergency messages.

Why it matters

CANopen is common in off-highway vehicles, buses, agricultural machines, medical devices and industrial automation. The stack teaches how a higher-layer protocol is built on raw CAN and how an object dictionary describes a device.

First step

Run the Linux example on vcan0 and use an SDO read to fetch the device name from the object dictionary.

14. BUSMASTER

github.com/rbei-etas/busmaster

BUSMASTER is an open-source application for simulating, analysing and testing data bus systems such as CAN and LIN. It offers message logging, database import, signal watch, replay and node simulation.

Why it matters

It shows what a classic bus tool contains. Understanding trace logging, signal watch lists and node simulation will make you faster with any commercial tool you use at work.

First step

Load a database file, connect to a supported adapter or simulation, and build a simple node that answers a request.

15. Zephyr RTOS

github.com/zephyrproject-rtos/zephyr

Zephyr is a scalable, open-source real-time operating system for resource-constrained devices. It supports many architectures and boards, a CAN controller API, ISO-TP, networking, device tree configuration and a strong community around security and safety certification work.

Why it matters

Automotive ECUs depend on real-time scheduling, deterministic interrupts and clean hardware abstraction. Zephyr is a modern, readable example of all three, and its CAN subsystem is a good way to move from theory to a running node.

const struct device *can = DEVICE_DT_GET(DT_CHOSEN(zephyr_canbus));
struct can_frame f = { .id = 0x123, .dlc = 2, .data = {0x11, 0x22} };
can_send(can, &f, K_MSEC(100), NULL, NULL);

First step

Build the CAN counter sample for a supported board or for the native simulator, then add a second thread that sends a periodic message.