commaai/openpilot

This system is an autonomous driving platform that manages vehicle lateral and longitudinal control, driver monitoring, and sensor fusion across multiple hardware variants. It processes real-time data from cameras, GPS, and IMUs to execute driving decisions, while handling device-specific hardware abstraction, power management, and connectivity. The platform includes a comprehensive suite of testing, simulation, and debugging tools for validating control logic and visualizing driving data.

This change introduces the initial software support for the Chestnut (ASM2464) hardware platform. It adds a SPI flasher (flash.py) to update the device firmware via USB control transfers, a monitoring thread (monitoring.py) that reads power, temperature, and PCIe link state from the device, and a status manager (status.py) that tracks hardware health and triggers specific offroad alerts for issues like overheating, USB detection failures, PCIe link loss, or model errors.

openpilot/system/hardware/chestnut · high confidence

The simulation bridge now includes a new MetaDrive backend, allowing users to run openpilot simulations in a procedurally generated driving environment. This change introduces a new \MetaDriveBridge\ and associated components (\metadrive\_process\, \metadrive\_world\, \metadrive\_common\) that handle vehicle physics, camera rendering (road and wide-angle), and control loops via multiprocessing. The bridge supports dual-camera setups, configurable test durations, and specific termination conditions such as going out of lane or vehicle stalling, providing a new option for automated driving system validation alongside existing simulation backends.

openpilot/tools/sim/bridge · high confidence

Users can now run openpilot on a PC using a standard webcam instead of hardware car cameras. This change introduces a new webcam module that captures video via OpenCV, converts frames to the required NV12 format, and streams them through the VisionIpcServer. The system supports configurable camera IDs for the road, wide, and driver cameras via environment variables (e.g., USE\_WEBCAM=1, ROAD\_CAM=1), allowing developers to test the UI and calibration workflows with simulated video feeds.

openpilot/system/camerad/webcam · high confidence

The device module now includes a new video streaming implementation that captures camera feeds and transmits them via WebRTC. This change introduces support for embedding precise frame-timing metadata (SEI messages) into the video stream, enabling better synchronization on the receiving end. It also adds logic to handle keyframe requests and manage video enable/disable states for the driver, wide road, and narrow road cameras.

openpilot/system/webrtc/device · high confidence

Adds a new eSIM management module under openpilot/common/esim, providing both a Python library (base.py, lpa.py) and a command-line interface (esim.py) for users to list, download, switch, delete, and nickname eSIM profiles. The implementation follows the GSMA SGP.22 specification, includes a GSMA CI certificate bundle for secure profile downloads, and ensures notifications are processed after profile operations as required by the spec.

openpilot/common/esim · high confidence

The on-road display now features a dynamic animated face that reacts to driving context. The face displays different expressions based on vehicle state: it appears asleep when off-road, switches to an inquisitive look after 30 seconds of no steering or speed input, and returns to normal when driving resumes. The animation also responds to steering inputs by shifting eye direction and includes a sleepy reaction when the screen is tapped while off-road.

openpilot/selfdrive/ui/body · high confidence

A new interactive desktop application, Jotpluggler, has been added to the tools directory. It provides a UI for loading and analyzing openpilot route data, featuring a data browser, customizable plot panes with curve support, and dedicated views for camera feeds, maps, and thumbnails. The tool includes a layout system for saving and restoring workspace configurations, supports custom Python-based series calculations, and handles DBC file parsing for CAN message decoding.

openpilot/tools/jotpluggler · high confidence

The system now includes a dedicated sensord daemon and driver stack for the LSM6DS3 IMU chip, replacing previous sensor handling. This change introduces new Python modules for I2C communication, accelerometer, gyroscope, and temperature sensor classes, along with a main daemon process that reads sensor data via interrupts and polling. The implementation supports self-test capabilities and publishes standardized sensor events. Comprehensive unit tests have been added to verify sensor presence, timing accuracy (104Hz), value sanity, and interrupt behavior.

openpilot/system/sensord · high confidence

A new simulation tool is available in \openpilot/tools/sim\ that allows running openpilot inside the MetaDrive simulator. This includes a bridge (\run\_bridge.py\) to connect the simulator to openpilot, a launcher script (\launch\_openpilot.sh\) to start openpilot in simulation mode with a Honda Civic 2022 fingerprint, and libraries to simulate sensors (cameras, GPS, IMU) and car CAN messages. Users can control the simulation via keyboard (WASD, cruise buttons) or a connected joystick.

openpilot/tools/sim · high confidence

This change introduces the Mici UI layout system, a new graphical interface for the comma four device. The \openpilot/selfdrive/ui/mici/layouts\ directory now contains the core layout components, including \MiciHomeLayout\ for the home screen (featuring network status, experimental mode toggle, and alert pills), \MiciMainLayout\ for managing navigation between home, on-road, and off-road views, \MiciOffroadAlerts\ for displaying off-road notifications, and \OnboardingWindow\ for initial setup flows like driver monitoring calibration. This replaces the previous Raygui-based implementation with a custom widget-based approach using the \pyray\ library.

openpilot/selfdrive/ui/mici/layouts · high confidence

This change introduces a new set of UI widgets for the Mici interface, including \button.py\ with \BigCircleButton\, \BigCircleToggle\, and \BigButton\ classes that support icons, labels, and long-press descriptions; \dialog.py\ providing \SettingDescriptionDialog\, \BigConfirmationDialog\, and \BigInputDialog\ for user interactions; \info.py\ with \InfoLayoutMici\ for structured two-part information display; and \qr.py\ with a \QR\ widget for rendering QR codes. These components form the foundational visual elements for the new Mici settings and interaction screens.

openpilot/selfdrive/ui/mici/widgets · high confidence

The Mici UI now includes a dedicated device settings layout that allows users to pair their device with a comma.ai account via QR code, view their Prime subscription status, and manage their subscription. This layout also provides access to regulatory information, a cabin camera preview, and options to reboot or power off the device, with safety checks preventing certain actions while the vehicle is engaged.

openpilot/selfdrive/ui/mici/layouts/settings/device · high confidence

The Mici UI now includes a dedicated network settings layout that allows users to manage both Wi-Fi and eSIM connections. Users can view and connect to Wi-Fi networks, configure tethering (including setting a password), and mark connections as metered. For cellular connectivity, the interface displays eSIM profile status and strength, and allows users to install new profiles by scanning an LPA QR code via the cabin camera, as well as rename or delete existing profiles. Advanced cellular options like roaming, APN configuration, and cellular metered settings are also accessible.

openpilot/selfdrive/ui/mici/layouts/settings/network · high confidence

The Mici UI now includes a dedicated Settings layout featuring a Developer section (enabling ADB, SSH, joystick/debug modes, and alpha longitudinal control) and a Firehose Mode page to maximize training data uploads. The Toggles layout adds a Driving Personality selector (aggressive, standard, relaxed) and an Experimental Mode toggle with a confirmation flow, while the Software layout improves update status display and handling.

openpilot/selfdrive/ui/mici/layouts/settings · high confidence

A new \juggle.py\ script and a suite of XML layouts have been added to \openpilot/tools/plotjuggler\ to simplify visualizing openpilot log data. The script automates the installation of PlotJuggler and its plugins, handles log migration, and provides command-line options to parse routes, stream live data, and load specific DBC files. The included layouts offer pre-configured views for debugging CAN bus states, camera timings, GPS/LLK alignment, longitudinal control, thermal performance, and torque controller tuning.

openpilot/tools/plotjuggler · high confidence

The \openpilot/system/qcomgpsd\ directory now contains a new GPS daemon implementation (\qcomgpsd.py\) that communicates with Quectel modems via AT commands and modem diagnostics. This daemon enables OEMDRE (Extended Differential GNSS) mode for improved positioning accuracy, configures specific GNSS log types (GPS, GLONASS, OEMDRE) via the modem's diagnostic interface, and publishes parsed GNSS measurement data to the openpilot messaging system. Additionally, a new \nmeaport.py\ utility is provided to configure the modem's NMEA output port and process raw GNSS clock and measurement data from \/dev/ttyUSB1\ for debugging purposes.

openpilot/system/qcomgpsd · high confidence

A new U-Blox GNSS daemon (pigeond) has been added to handle GPS and GLONASS navigation data. It includes a declarative binary struct parser for UBX protocol messages, along with specific parsers for GPS navigation subframes (IS-GPS-200E) and GLONASS navigation strings (GLONASS ICD). The daemon manages the U-Blox device via serial communication, handles AssistNow data for faster time-to-first-fix, and publishes parsed location and satellite data to the openpilot messaging system.

openpilot/system/ubloxd · high confidence

The \openpilot/system/ui/lib\ directory has been populated with a new set of core UI components. This includes a \CellularManager\ for managing eSIM profiles (download, switch, delete) and a \WifiManager\ for network connectivity and tethering. The UI rendering layer now features a new \GuiScrollPanel2\ with momentum-based scrolling and snapping, alongside a \ShaderPolygon\ for gradient rendering and a \Multilang\ system for localized text with font fallbacks for Asian languages.

openpilot/system/ui/lib · high confidence

The UI now includes dedicated widgets for the initial device setup flow, including a pairing dialog that displays a QR code for connecting to comma connect, a setup screen for unpaired devices, and a firehose mode prompt for registered users. Offroad alerts are now rendered using a new scrollable alert system with snooze and reboot actions, and a new experimental mode toggle button allows users to switch between Chill and Experimental driving modes directly from the interface.

openpilot/selfdrive/ui/widgets · high confidence

The system now includes new audio assets for driver monitoring and vehicle engagement states. Specifically, new sound files have been added for critical alerts (including a maximum volume variant), warnings, pre-alerts, disengagement, refusal, and engagement. A Python script is also included to generate the engagement and disengagement beep sounds programmatically using harmonic synthesis.

openpilot/selfdrive/assets/sounds · high confidence

This change introduces a new camera driver implementation in the camerad subsystem, specifically targeting Qualcomm Spectra ISP hardware. The diff adds core infrastructure files including \camera\_common.h\ and \camera\_common.cc\ for shared buffer management and V4L2 device access, \camera\_qcom2.cc\ for the main camera state and exposure control logic, and \cdm.h\/\cdm.cc\ for Command Dispatch Module (CDM) register access helpers. It also includes \bps\_blobs.h\, an auto-generated header containing binary configuration blobs for the BPS (Block Processing Subsystem). This code replaces or supplements the previous camera handling logic with a more robust, hardware-specific implementation for stream initialization, frame buffering, and exposure adjustment.

openpilot/system/camerad/cameras · high confidence

A new \tools/camerastream\ directory has been added, containing \compressed\_vipc.py\ and \ffmpeg\_decoder.py\. This tool allows developers to connect to a remote openpilot device, decode the HEVC video streams (narrow road, wide road, and cabin) via ZMQ, and republish them locally over VisionIPC for debugging and visualization using \watch3.py\.

openpilot/tools/camerastream · high confidence

A suite of new diagnostic and tuning scripts has been added to the tools/scripts/car directory. These tools allow users to inspect and modify vehicle ECUs via UDS and CAN, including reading and clearing diagnostic trouble codes (clear\_dtc.py, read\_dtc\_status.py), querying ECU addresses and firmware versions (ecu\_addrs.py, fw\_versions.py, vin.py), and disabling specific ECUs (disable\_ecu.py). Additional scripts support car-specific tuning and debugging, such as enabling radar points on Hyundai vehicles (hyundai\_enable\_radar\_points.py), calculating maximum lateral acceleration from drive logs (max\_lat\_accel.py), measuring torque response time (measure\_torque\_time\_to\_max.py), determining Toyota EPS scaling factors (toyota\_eps\_factor.py), and enabling Heading Control Assist on Volkswagen MQB vehicles (vw\_mqb\_config.py). General CAN bus utilities for monitoring live traffic (can\_printer.py), detecting bit changes (can\_print\_changes.py), and viewing data in table format (can\_table.py) are also included.

tools/scripts/car · high confidence

Added several Jupyter notebooks to the car porting examples directory to assist with vehicle integration and debugging. These include \find\_segments\_with\_message.ipynb\ for searching the commaCarSegments database for specific CAN messages, \ford\_vin\_fingerprint.ipynb\ to evaluate VIN-based fingerprinting for Ford vehicles, \hkg\_canfd\_gear\_message.ipynb\ for analyzing gear messages in Hyundai/Kia CAN-FD EVs, \subaru\_fuzzy\_fingerprint.ipynb\ for testing Subaru fuzzy fingerprinting logic, and two Subaru-specific analysis notebooks (\subaru\_long\_accel.ipynb\ and \subaru\_steer\_temp\_fault.ipynb\) for plotting brake/acceleration relationships and steering temperature fault conditions.

_tools/car\porting/examples · high confidence

The tools/car\_porting directory now includes a README with documentation and several new scripts to assist with developing and validating new car ports. auto\_fingerprint.py automatically inserts firmware fingerprints into fingerprints.py based on a route, while test\_car\_model.py runs common interface checks (such as missing signals or panda safety mismatches) against a given route. A new measure\_steering\_accuracy.py script provides real-time or logged analysis of steering control error, and example Jupyter notebooks demonstrate how to analyze CAN signals, plot actuator responses, and check VIN fingerprinting feasibility.

_tools/car\porting · high confidence

A new \run.py\ script has been added to \openpilot/tools/clip\ that allows users to generate video clips from specific route segments. The tool supports selecting start and end times, choosing between front and q-camera feeds, adjusting playback speed and output file size, and overlaying metadata or titles. It handles downloading and parsing route data in parallel, migrating log messages, and rendering frames using FFmpeg or direct frame readers to produce an MP4 output.

openpilot/tools/clip · high confidence

This change introduces a new \openpilot/common\ library containing core utilities and infrastructure. It adds a C++ implementation for persistent key-value parameters (\params.cc\, \params.h\) with a Python binding (\params.py\) and a build script (\SConscript\). It also includes a new JWT-based API client (\api.py\), hardware abstraction layers for PC (\hardware/pc/\), system monitoring via \/proc\ (\linux.py\), GPIO and I2C access (\gpio.py\, \i2c.py\), and various testing utilities including a fuzzy data generator (\fuzzy.py\), mock message generators (\mock/\), and parameterized test helpers (\parameterized.py\).

openpilot/common · high confidence

A new \openpilot/common/transformations\ module has been introduced to centralize helper functions for transforming between various reference frames (Geodetic, ECEF, NED, Device, Calibrated, Car, View, Camera) and handling orientation conversions (Euler, Quaternion, Rotation Matrix). This library provides the mathematical foundation for calibrating camera images into a standardized 'calibrated frame' and converting global positions into local vehicle-relative coordinates, which is essential for the driving model's perception and control logic. The module includes specific camera configurations for supported hardware (tici, tizi, etc.) and comprehensive unit tests for the coordinate and orientation math.

openpilot/common/transformations · high confidence

The scripts directory now includes several new tools to aid development and continuous integration workflows. Developers can use \apply-pr.sh\ and \checkout-pr.sh\ to easily apply and switch to pull requests from GitHub. A new \ci\_results.py\ script fetches and formats status from both GitHub Actions and Jenkins into a Markdown report, while \jenkins\_loop\_test.sh\ automates repeated Jenkins build runs for stability testing. Additional utilities include \waste.c\ and \waste.py\ for benchmarking CPU and memory bandwidth, \test\_pip\_install.sh\ to verify package installation, \disable-powersave.py\ to manage hardware power settings, and \retry.sh\ for command retry logic.

scripts · high confidence

A collection of new utility scripts has been added to tools/scripts to aid in development, debugging, and device management. These include adb\_ssh.sh for forwarding openpilot service ports and SSH access, devsync.py for file synchronization with devices, and ssh.py for connecting to comma prime devices via a jump server. Diagnostic tools such as count\_events.py, cycle\_alerts.py, live\_cpu\_and\_temp.py, mem\_usage.py, qlog\_size.py, and watch\_timings.py provide insights into system performance, log analysis, and service timing. Additional scripts like fingerprint\_from\_route.py, get\_fingerprint.py, and test\_fw\_query\_on\_routes.py assist with vehicle fingerprinting, while setup\_ssh\_keys.py and set\_car\_params.py handle device configuration.

tools/scripts · high confidence

This change introduces a new hardware platform directory (openpilot/common/hardware/comma) that consolidates device-specific drivers and configuration for the comma three, 3X, and four. It includes an AGNOS OS updater with manifest files for partition verification and flashing, a modem manager for cellular connectivity, an amplifier driver for audio output, and a power monitor. The update also adds a C++ hardware header for device identification and a set of integration tests to verify the AGNOS updater and amplifier functionality.

openpilot/common/hardware/comma · high confidence

This change introduces support for the new 'Chestnut' hardware platform (previously referred to as 'usbgpu' or 'tici' in some contexts) by adding a new fan controller, power monitoring system, and hardware state management. The fan controller adjusts setpoints based on device type to reduce noise and prevent CPU throttling. The power monitoring system tracks car battery capacity and voltage, implementing logic to automatically shut down the device when offroad for extended periods or when battery levels are critically low. Additionally, the hardware daemon now monitors USB connections for Chestnut devices, flashing firmware if a mismatch is detected, and displays offroad alerts to guide users to the correct software branch.

openpilot/system/hardware · high confidence

Added a new debugging tool in openpilot/tools/joystick that allows developers to control the vehicle's longitudinal and lateral actuators using a physical joystick or keyboard while the car is offroad. The tool includes joystickd.py, which subscribes to joystick input and publishes carControl messages, and joystick\_control.py, which handles input from gamepads (such as the PlayStation 5 DualSense) or keyboard keys (WASD for gas/brake/steering) and sends testJoystick packets over the network.

openpilot/tools/joystick · high confidence

This update introduces a new Lateral Maneuvers Testing Tool located in \tools/lateral\_maneuvers\, which allows users to evaluate vehicle lateral control tuning by executing a suite of maneuvers (step left/right, sine wave) at 20 and 30 mph and generating detailed HTML reports with plots of acceleration, steering, and jerk. Additionally, the system now includes support for new camera sensors (OS04C10 and OX03C10) with their respective initialization registers and gain tables, and adds FCC compliance documentation for the comma three and comma four devices.

(repo-wide) · high confidence

The new locationd service has been added to handle vehicle state estimation, including calibration, lateral lag estimation, and torque parameter learning. This service integrates with the existing openpilot architecture to provide more accurate and reliable vehicle state information.

openpilot/selfdrive/locationd · high confidence

Added a new tool suite in \openpilot/tools/longitudinal\_maneuvers\ for testing and evaluating longitudinal control tuning. The \maneuversd\ daemon executes a suite of standardized maneuvers (such as start from stop, creep, and step responses) when \LongitudinalManeuverMode\ is enabled, while \generate\_report.py\ creates detailed HTML reports from route logs, visualizing acceleration, velocity, and actuator data. Additionally, \mpc\_longitudinal\_tuning\_report.py\ provides simulation-based reports for MPC tuning validation.

_openpilot/tools/longitudinal\maneuvers · high confidence

The UI system now includes dedicated setup, update, and factory-reset screens for the smaller Mici display (in addition to the existing Tici screens). Users can now complete initial device setup, install OS updates, and perform factory resets directly on the device when using Mici hardware. The new flows include Wi-Fi network selection, a software choice between openpilot and custom software (with a third-party warning), download progress tracking, and a recovery mode for corrupted data partitions. These screens replace the previous raygui-based implementation for Mici devices.

openpilot/system/ui · high confidence

This change introduces the openpilot/tools/lib package, providing a unified Python library for accessing driving data. It includes the LogReader and FrameReader classes for parsing route logs and video segments, a CommaApi client for interacting with the comma API, and a browser-based auth.py tool for handling user sign-ins via Google, Apple, or GitHub. The library also adds file downloading and decompression utilities, Azure container integration for data storage, and helpers for parsing route names and segment ranges.

openpilot/tools/lib · high confidence

The tools/release directory now includes a comprehensive set of scripts and documentation to streamline the release process. A new README provides a step-by-step checklist for staging and publishing releases. New build scripts (build\_release.sh, build\_stripped.sh) automate the creation of release branches, handle file copying via release\_files.py, manage Git LFS for large driving models, and execute on-device tests. Supporting utilities include pack.py for creating portable executables, check\_file\_sizes.sh to enforce size limits, and identity.sh to standardize Git authorship.

tools/release · high confidence

The openpilot/system directory now includes several new background services: journald.py and logmessaged.py handle system journal and application log forwarding; micd.py monitors microphone input and publishes sound pressure data; timed.py synchronizes the system clock using GPS time in UTC; and tombstoned.py detects, processes, and uploads crash logs (tombstones) for registered devices. These changes introduce new runtime behaviors for system monitoring, audio sensing, timekeeping, and diagnostics.

openpilot/system · high confidence

The replay tool now features a new terminal-based console UI (consoleui.cc) that displays playback status, timeline, and download progress. It also adds support for hardware-accelerated video decoding via V4L on Linux and VideoToolbox on macOS, falling back to FFmpeg CPU decoding if hardware is unavailable. Additionally, the tool now includes a CAN replay script (can\_replay.py) for sending logged CAN messages to Panda devices via a PandaJungle.

openpilot/tools/replay · high confidence

The \selfdrive/sensord\ directory's Makefile and \sensors.cc\ source file have been deleted, removing the legacy C++ implementation that handled sensor polling (accelerometer, gyroscope, magnetometer) and GPS NMEA data via ZMQ. This change eliminates the old sensor loop and hardware interface code from the build, indicating a migration to a different sensor handling mechanism elsewhere in the system.

selfdrive/sensord · high confidence

The legacy C-based user interface implementation and its associated touch input handling have been removed from the selfdrive/ui directory. This change deletes the build configuration (Makefile) and source files (ui.c, touch.c, touch.h) that previously managed the display rendering via OpenGL/EGL and raw Linux input events, indicating a migration away from this specific codebase component.

selfdrive/ui · high confidence

The \selfdrive/common\ directory has removed several legacy C/C++ header and source files, including \framebuffer\, \mat\, \modeldata\, \mutex\, \swaglog\, \util\, and \visionipc\. This cleanup eliminates older implementations for matrix math, model data structures, logging, and inter-process communication that are no longer used in the current codebase.

selfdrive/common · high confidence

The \common/kalman/ekf.py\ file, which contained the generic Extended Kalman Filter (EKF) framework along with associated sensor classes like \GPS\ and \SimpleSensor\, has been removed from the codebase. This change eliminates the legacy EKF module and its specific sensor processing logic, indicating a shift away from this particular filtering implementation in the common utilities.

common/kalman · high confidence

The firmware source files for the legacy STM32F205-based board have been removed from the repository. This includes the build configuration (Makefile), linker script, startup assembly, and all C header and source files defining the hardware abstraction layer (ADC, CAN, DAC, USB, timers) and the main application logic. The deletion eliminates the ability to build or flash this specific hardware variant using the existing codebase.

board · high confidence

The installation process no longer supports the legacy Termux-based setup. The \install.sh\ script, which previously used ADB to deploy the \continue.sh\ runner and the \id\_rsa\_openpilot\_ro\ SSH key, has been removed along with those files. Users can no longer install or update openpilot via this specific Termux workflow.

installation · high confidence

The legacy C++ implementation (boardd.cc) and Python implementation (boardd.py) of the board daemon, along with its associated Makefile, have been removed from the repository. This change eliminates the old code paths that handled USB communication with the Panda hardware using libusb and ZeroMQ, indicating that the boardd functionality has been fully migrated to a different implementation or architecture elsewhere in the system.

selfdrive/boardd · high confidence

The legacy \cereal\ package has been removed, including the \log.capnp\ schema definition and all generated C and C++ bindings (such as \cereal/gen/c/log.capnp.c\ and \cereal/gen/cpp/log.capnp.c++\). This change eliminates the old data serialization structures and their associated language bindings from the codebase.

cereal · high confidence

The legacy \common/api\ module, which previously provided a basic \api\_get\ function for making HTTP requests to the comma.ai backend, has been removed from the codebase.

common/api · high confidence

The \selfdrive/controls\ directory has been removed, deleting the original monolithic \controlsd.py\ process and its associated legacy libraries (\adaptivecruise.py\, \alert\_database.py\, \can\_parser.py\, \carcontroller.py\, \carstate.py\, and \drive\_helpers.py\). This change eliminates the initial Honda-centric control implementation, including its specific CAN parsing, alert definitions, and adaptive cruise logic, as the system has moved to a more modular architecture.

selfdrive/controls · high confidence

The legacy loggerd Python implementation has been removed from the codebase. This change deletes the core logging and uploading modules (\logger.py\, \uploader.py\), the main entry point (\loggerd.py\), and the configuration file (\config.py\) that previously handled log rotation, file locking, and cloud uploads via the \selfdrive.loggerd\ package.

selfdrive/loggerd · high confidence

The selfdrive directory has been cleaned up by removing several legacy modules: calibrationd (including calibration.py and calibrationd.py), config.py, logmessaged.py, manager.py, messaging.py, registration.py, swaglog.py, and thermal.py. This removes the old calibration logic, process management, messaging infrastructure, device registration, logging, and thermal monitoring code that was previously located in this area.

common, selfdrive · high confidence

The standalone Makefile, README, and the original visiond binary have been removed from the repository. This cleanup eliminates the previous local build and documentation structure for the vision pipeline component, indicating a shift in how this service is managed or integrated within the broader openpilot system.

selfdrive/visiond · high confidence

The logcatd service, which previously collected Android system logs (main, radio, system, crash, and kernel) and published them via ZeroMQ on port 8020, has been removed from the system. This eliminates the background process that captured and forwarded these specific Android log streams to other components.

selfdrive/logcatd · high confidence

The nanovg rendering library and its associated stb image and truetype font handling headers have been removed from the phonelibs directory. This deletion eliminates the local dependency on these specific graphics and font-rendering components, likely as part of a broader effort to streamline the library set or migrate to alternative rendering solutions.

phonelibs · high confidence

The openpilot controls logic has been reorganized from a monolithic structure into distinct, modular services: controlsd handles vehicle actuation and state management, plannerd manages longitudinal planning and lane departure warnings, and radard processes radar data and lead tracking. This change improves code maintainability and allows these components to run as independent processes within the controls directory.

openpilot/selfdrive/controls · high confidence

The longitudinal model predictive control (MPC) logic has been extracted into a new, self-contained library at openpilot/selfdrive/controls/lib/longitudinal\_mpc\_lib. This change introduces a dedicated SCons build system (SConscript) that automates the generation of C code from the CasADi model definition (long\_mpc.py) and compiles it into a shared library for performance. The library encapsulates the MPC solver configuration, including state dynamics, cost functions, and constraints, and is now isolated from the broader controls module to improve build structure and maintainability.

_openpilot/selfdrive/controls/lib/longitudinal\_mpc\lib · high confidence

The openpilot/selfdrive/assets directory now includes a Qt resource file (assets.qrc) that registers UI assets such as SVG icons, images, and the languages.json translation file. To support this, new build scripts (prep-svg.sh, compress-images.sh) and a .gitignore file have been added to automate SVG processing, image compression, and version control hygiene for generated font and image files.

openpilot/selfdrive/assets · high confidence

The athena service has been significantly refactored to use a minimal JSON-RPC implementation for handling remote commands, replacing the previous API. This change introduces a new upload queue caching mechanism that persists pending uploads to Params for resilience, and updates the device registration flow to support serial number and IMEI-based authentication for newer hardware. The athenad daemon is now managed via a dedicated process launcher, and the service no longer requires car parameters to function, improving reliability during connection setup.

openpilot/system/athena · high confidence

The Cabana tool has been refactored to replace its Qt-based interface with an ImGui frontend, significantly changing how the application is built and run. This migration introduces a new build system via SConscript that compiles the C++ core (DBC parsing, CAN data handling, undo/redo command stacks) alongside ImGui-specific UI widgets, dialogs, and charts. Users will now interact with a redesigned UI featuring native dockable panels, standardized floating menus, and improved dark theme contrast, while the underlying data processing for CAN messages and DBC files remains consistent but is now decoupled from Qt frameworks.

openpilot/tools/cabana · high confidence

The camerad service has been moved into the nested openpilot/system/camerad directory, restructuring the build and source layout. This change also introduces a new snapshot.py utility that allows users to capture and extract images from the narrow road, wide road, and cabin camera streams by connecting to the VisionIPC client and converting the NV12 video buffers to RGB.

openpilot/system/camerad · high confidence

The openpilot messaging system (cereal) has been moved into the openpilot/cereal directory and reorganized with a new build structure. The Cap'n Proto schema files (log.capnp, custom.capnp, deprecated.capnp) are now explicitly managed via a new SConscript build file, and the services.py script now generates the C++ services.h header. This change also introduces a new VisionStreamType enum (visionipc.py/visionstream.h) to define camera stream types (Narrow Road, Cabin, Wide Road, Map) that were previously located in msgq, centralizing vision stream definitions within the cereal package.

openpilot/cereal · high confidence

The \scripts/lint\ directory has been completely rewritten to replace the previous pre-commit hook system with a new, modular linting framework. This change introduces several new checks: a shellcheck-like static analyzer for shell scripts (\check\_shell.py\), validation for Python indentation (\check\_indentation.py\), enforcement of executable permissions on shebang scripts (\check\_shebang\_scripts\_are\_executable.py\), and checks for file size limits (\check\_added\_large\_files.py\) and dependency footprint (\check\_dependencies.py\). It also adds checks for invalid shebang formats and disallowed \NOMERGE\ comments. The main \lint.sh\ script now orchestrates these new tools alongside existing ones like \ruff\ and \ty\, providing a unified \op lint\ interface for developers.

scripts/lint · high confidence

The hardware module has been reorganized to support both comma hardware devices and PC environments through a new abstraction layer. A unified entry point now instantiates either HardwareComma or HardwarePc based on the presence of the AGNOS OS file. The codebase introduces a HardwareBase abstract class (with a C++ equivalent) defining standard interfaces for device identification, thermal monitoring, network status, and power management. Path resolution logic has been consolidated into a Paths class, directing comma devices to /data/ paths and PCs to user-home directories. Additionally, USB device detection has been expanded to include 'chestnut' hardware variants, with specific USB vendor/product IDs and firmware versions defined, and the USB state reporting now includes link error counts and USB3 lane orientation details.

openpilot/common/hardware · high confidence

The locationd service now uses dedicated, modular Kalman filter models for vehicle dynamics (car\_kf) and device pose estimation (pose\_kf). These new models define specific state variables, observation types, and noise parameters for sensors like gyroscopes, accelerometers, and steering angle, replacing the previous monolithic implementation. This change improves the structure and maintainability of the sensor fusion logic used for vehicle localization.

openpilot/selfdrive/locationd/models · high confidence

The onroad display for the Mici hardware platform has been replaced with a new rendering stack. This change introduces dedicated renderers for the augmented road view, HUD elements (speed, torque bar, turn intent), driver monitoring state, and alert overlays, all built on the pyray graphics library. It also adds a new camera view component that handles zero-copy EGL rendering for live video streams and implements a swipe-to-bookmark gesture on the road view.

openpilot/selfdrive/ui/mici/onroad · high confidence

The system now uses a new set of Python-based UI widgets in \openpilot/system/ui/widgets\ to replace the previous raygui implementation. This change introduces a comprehensive widget framework including a base \Widget\ class with touch/mouse event handling, interactive components like \Button\, \InputBox\, and \Keyboard\, and layout managers such as \HBoxLayout\. It also adds support for rich text rendering via \HtmlRenderer\ and structured list views with \ListView\, providing a more flexible and Python-native foundation for the user interface.

openpilot/system/ui/widgets · high confidence

The openpilot livestreaming capability has been restructured: the webrtcd daemon now uses the Python standard library HTTP server instead of aiohttp, binds to localhost, and enforces a 5-minute session timeout. The helpers module provides a new client interface to post stream requests and wait for the service, while the schema module generates type definitions from Cap'n Proto schemas for the API.

openpilot/system/webrtc · high confidence

The loggerd and encoderd components have been reorganized into a new directory structure, introducing a dedicated bootlog utility that captures pstore entries and journalctl output on startup. A new clip\_encoder module enables fast hardware-accelerated transcoding of HEVC segments to H.264 for livestreaming, while the video writer now supports audio muxing for cabin camera recordings. The deleter logic has been updated to respect extended preservation attributes, and the build system now conditionally links V4L-based encoders on comma hardware versus FFmpeg on other platforms.

openpilot/system/loggerd · high confidence

The openpilot/system/manager package has been completely rewritten to introduce a new process management architecture. The new manager.py initializes the system by clearing specific parameter flags on state transitions (onroad/offroad/ignition), registers the device dongle ID, and sets up environment variables for logging. It now relies on a new process.py module that defines PythonProcess, NativeProcess, and DaemonProcess classes to handle starting, stopping, and monitoring background daemons with improved signal handling and process joining logic. A new build.py script provides a user-facing build interface with progress tracking and error display. The process\_config.py file has been updated to define the current set of managed services, including the removal of the 'restarter' and 'preimport' stages mentioned in commit messages, and the addition of new process definitions like 'webrtcd' and 'joystick'.

openpilot/system/manager · high confidence

The openpilot messaging system has been rewritten to replace the ZeroMQ transport with the internal msgq IPC mechanism. This change introduces new Python and C++ messaging abstractions (SubMaster, PubMaster, and socket helpers) that communicate via msgq, while providing a bridge (bridge.cc, bridge\_zmq.cc) to maintain compatibility with external ZMQ endpoints. The update also includes comprehensive test coverage for the new messaging primitives and service definitions.

openpilot/cereal/messaging · high confidence

The modeld service has been rewritten to use Tinygrad for model execution, replacing the previous backend. This change introduces support for an external USB GPU (codenamed 'Chestnut'), allowing the driving and driver-monitoring models to run on external hardware with specific build flags and device detection logic. The build system (SConscript) now compiles ONNX models and camera warps into Tinygrad pickle artifacts, handling different architectures (comma\_arm64, Darwin, PC) and checking for LLVM availability. The runtime code includes helpers to detect and wait for the Chestnut USB device, load out-of-band compiled models, and manage GPU state metrics. Driver monitoring and driving model inference pipelines are updated to use these new Tinygrad-based model states and output parsers.

openpilot/selfdrive/modeld · high confidence

The openpilot package now includes a new test runner (test\native.py) that executes specific native C++ tests for swaglog, pandad canprotocol, and cabana DBC core, skipping them if the binaries are not built. Additionally, the package initialization file has been moved from cereal/gen/c/c++.capnp.h to openpilot/\\init\\_.py to better reflect the package structure.

openpilot · high confidence

The Panda daemon (pandad) has been rewritten in C++ to improve performance and reliability. This new implementation handles SPI communication with the Panda hardware directly, manages CAN message sending and receiving, and enforces real-time priority and core affinity on non-PC hardware. It introduces a new health packet structure and guarantees SPI slave turnaround times to ensure stable communication. The Python wrapper (pandad.py) now serves primarily to flash firmware updates and launch the C++ daemon, while the C++ core manages safety model configuration, multiplexing modes, and detailed Panda state reporting.

openpilot/selfdrive/pandad · high confidence

The Settings interface has been restructured into a sidebar-based layout with distinct panels for Device, Network, Toggles, Software, Firehose, and Developer modes. The new Developer panel exposes advanced controls including ADB, SSH key management, joystick/debug modes, and an alpha toggle for openpilot longitudinal control (which requires a restart). The Software panel now includes a branch switcher for selecting target update branches (e.g., devel, nightly) and improved update status feedback. The Firehose panel provides a dedicated interface to maximize training data uploads for model improvement.

openpilot/selfdrive/ui/layouts/settings · high confidence

The selfdrived module now uses a dedicated AlertManager and JSON-based configuration to handle offroad alerts, introducing specific notifications for the 'Chestnut' (USB GPU) hardware including detection, model errors, overheating, and branch-switching prompts. The system also adds onroad alerts for big model loading and failure states, refines the excessive actuation check to exclude non-Car devices, and updates the driver monitoring lockout ramp-up logic.

openpilot/selfdrive/selfdrived · high confidence

The driver monitoring system now uses a new \DriverMonitoring\ policy that primarily relies on vision-based attention detection but falls back to wheel-touch detection when the driver is not visible. The system enforces a graduated alert sequence (orange to red) based on timeouts for distraction and inattention, eventually triggering a lockout if the driver remains unresponsive. It also supports right-hand drive detection and an always-on monitoring mode.

openpilot/selfdrive/monitoring · high confidence

The openpilot UI now uses a new layout system in the \openpilot/selfdrive/ui/layouts\ directory, introducing a persistent sidebar for device status (temperature, network, panda connection) and navigation, alongside a redesigned home screen that displays update and alert notifications. The onboarding experience has been restructured into a multi-step visual guide with terms acceptance and a training tutorial, replacing the previous implementation.

openpilot/selfdrive/ui/layouts · high confidence

The on-road display now uses a new set of Python modules in the \openpilot/selfdrive/ui/onroad\ directory to render the driving interface. This includes an \AlertRenderer\ for displaying system status messages, an \AugmentedRoadView\ that composites camera feeds with model predictions and HUD overlays, a \DriverStateRenderer\ for visualizing driver monitoring data, and an \ExpButton\ for toggling experimental mode. These components replace the previous rendering logic to provide a more modular and visually consistent on-road experience.

openpilot/selfdrive/ui/onroad · high confidence

The system now uses an OverlayFS-based staging area to manage software updates, allowing changes to be prepared in a safe, isolated environment before being finalized and swapped into the main openpilot directory. This approach improves update reliability by ensuring the active system remains consistent and recoverable during the installation process, with specific handling for git state and release notes parsing within the staging area.

openpilot/system/updated · high confidence

The tools directory now provides a unified 'op' CLI (op.sh) to manage development tasks, replacing the previous separate setup.sh and ad-hoc scripts. This new workflow simplifies installation by handling git submodules, Python environment creation via uv, and system dependency checks in a single command. The tools README has been updated to reflect the new setup instructions, and a new CTF guide is included to help users learn the openpilot ecosystem.

tools · high confidence

The car control subsystem has been reorganized into the new \openpilot/selfdrive/car\ directory, introducing dedicated modules for core logic: \card.py\ now handles the main car daemon loop (CAN communication, fingerprinting, and state publishing), \car\_events.py\ centralizes the logic for generating driver alerts and engagement events (such as low-speed warnings, door open, and steering faults) with brand-specific overrides for Chrysler, Honda, Toyota, GM, and Volkswagen, and \cruise.py\ manages the adaptive cruise speed helper and button handling. Additionally, \docs.py\ and \CARS\_template.md\ were added to automate the generation of the supported cars documentation table, and the test suite was updated to cover these new components.

openpilot/selfdrive/car · high confidence

The lateral and longitudinal control logic has been reorganized into the \openpilot/selfdrive/controls/lib\ directory, introducing dedicated helper modules for lane-change state management (\desire\_helper.py\), curvature and acceleration calculations (\drive\_helpers.py\), and distinct lateral control strategies (\latcontrol\_angle.py\, \latcontrol\_curvature.py\, \latcontrol\_pid.py\, \latcontrol\_torque.py\). Longitudinal control is now handled by a simplified state machine in \longcontrol.py\ and a planner in \longitudinal\_planner.py\ that integrates MPC and end-to-end acceleration sources, while lane-departure warnings are managed in \ldw.py\. This change centralizes core control algorithms, standardizes saturation checks, and separates concerns between planning, control execution, and helper utilities.

openpilot/selfdrive/controls/lib · high confidence

The openpilot user interface has been migrated from Qt to Raylib. This change removes the Qt framework and its dependencies, replacing the previous UI implementation with a new Raylib-based renderer. Users will see a refreshed interface built on the new graphics library, which also enables features like 60fps rendering and simplified shader management.

(repo-wide) · high confidence

The loggerd encoder implementation has been rewritten to remove the libyuv and libjpeg dependencies, replacing them with FFmpeg for software encoding and a new V4L2-based hardware encoder for Qualcomm platforms. This change introduces a unified VideoEncoder base class with specific implementations: FfmpegEncoder for general software encoding, JpegEncoder for thumbnail generation, and V4LEncoder for hardware-accelerated H.264/H.265 encoding and decoding via the Linux V4L2 API. Users will benefit from reduced external library dependencies and improved performance on supported hardware through direct kernel driver integration.

openpilot/system/loggerd/encoder · high confidence

The openpilot UI module has been reorganized into a new directory structure, introducing dedicated modules for managing user subscription status, audio alerts, and hardware connectivity. A new PrimeState module now tracks pairing providers and subscription types, while a new soundd service handles dynamic audio alerting with volume ramping and ambient noise adaptation. The UI state now explicitly monitors external hardware connections, including USB and eGPU (chestnut) status, and the build system has been updated to compile specific installers for different release branches.

openpilot/selfdrive/ui · high confidence

The DBC files in the dbcs directory (including acura\_ilx\_2016\_can, acura\_ilx\_2016\_nidec, and honda\_civic\_touring\_2016\_can) have been modified to align with the Vector DBC format. This change ensures that the CAN database definitions used for parsing vehicle signals are consistent with the standard Vector format, which may affect how signal definitions and message structures are interpreted by the system.

dbcs · high confidence

The application interface strings in the translations directory have been refreshed to include new messages for steering torque and lag calibration progress, as well as updated network configuration options like APN and tethering. This ensures that users see accurate, localized text for device setup, calibration status, and connectivity settings across supported languages.

openpilot/selfdrive/ui/translations · high confidence

The driving and driver monitoring neural network models have been updated to new versions. The driving model (driving\_supercombo.onnx) and driver monitoring model (dmonitoring\_model.onnx) are replaced with new artifacts, and associated precompiled weights for the driving model (big\_driving\_tinygrad.pkl) and camera warps (big\_driving\warp\\*.pkl) are updated to match the new model architecture and input requirements.

openpilot/selfdrive/modeld/models · high confidence

Add longitudinal maneuver simulation tests; Added UI testing and profiling utilities; Added camerad integration tests and debugging utilities; Added comprehensive test coverage for common modules; Added integration and protocol tests for pandad; Added tests for UI widget memory leaks; Added tests for the Pigeon GPS daemon; Added unit tests for WebRTC stream session and message proxies; Added unit tests for athenad, ping, and registration modules; Added unit tests for hardware fan controller and power monitoring; Added unit tests for locationd components; Added unit tests for loggerd subsystem; Added unit tests for logmessared and WiFi state management; Added unit tests for longitudinal and lateral control logic; Added unit tests for openpilot tools/lib modules; Added unit tests for selfdrived alerting and state machine logic; Added unit tests for the MetaDrive simulator bridge; Added unit tests for the system manager; New UI video diff testing infrastructure; New process replay test suite for regression testing; New test infrastructure and onroad validation suite.

The project has replaced its previous dependency management system with a standard pyproject.toml configuration, utilizing uv for package resolution and hatchling for building. This change introduces Python 3.12 as the minimum supported version and organizes dependencies into core, testing, and tools groups. It also explicitly declares submodules (msgq, opendbc, panda, etc.) as editable local sources and configures linting and formatting rules via ruff and ty within the same file.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 35 → 49 (+14.1)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 88 → 79 (-9.0)
• Architecture 81 → 99 (+17.3)
• Maturity 57 → 59 (+2.9)
• Readiness 22 → 40 (+17.6)
• Security 25 → 65 (+40.0)
• Accessibility 47 (new)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• Duplicated block (10 lines × 2) (openpilot/selfdrive/locationd/locationd.py)
• Duplicated block (11 lines × 2) (openpilot/tools/jotpluggler/generate_event_extractors.py)
• Duplicated block (12 lines × 2) (openpilot/system/ui/lib/wifi_manager.py)
• Duplicated block (13 lines × 2) (openpilot/system/ui/lib/tests/test_handle_state_change.py)
• Duplicated block (5 lines × 2) (openpilot/selfdrive/locationd/lagd.py)
• Duplicated block (8 lines × 2) (openpilot/system/loggerd/tests/test_uploader.py)
• Duplicated block (8 lines × 2) (openpilot/tools/sim/lib/simulated_car.py)
• Duplicated block (9 lines × 2) (openpilot/system/athena/tests/test_athenad.py)
• Duplicated block (9 lines × 4) (openpilot/tools/jotpluggler/generate_event_extractors.py)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 44 more

• AlertRenderer._draw_text (cognitive 16) (openpilot/selfdrive/ui/mici/onroad/alert_renderer.py)
• AlertRenderer.get_alert (cognitive 16) (openpilot/selfdrive/ui/mici/onroad/alert_renderer.py)
• AlertRenderer.get_alert (cognitive 17) (openpilot/selfdrive/ui/onroad/alert_renderer.py)
• AtClient.send_apdu (cognitive 22) (openpilot/common/esim/lpa.py)
• Boundary-crossing change coupling: athenad.py ↔ qlog_size.py (openpilot/system/athena/athenad.py)
• Car.init (cognitive 28) (openpilot/selfdrive/car/card.py)
• CarEvents.create_common_events (cognitive 52) (openpilot/selfdrive/car/car_events.py)
• CarEvents.create_common_events (cyclomatic 46) (openpilot/selfdrive/car/car_events.py)
• CarEvents.update (cognitive 59) (openpilot/selfdrive/car/car_events.py)
• CarEvents.update (cyclomatic 37) (openpilot/selfdrive/car/car_events.py)
• Change coupling clique: latcontrol_angle.py, latcontrol_pid.py, latcontrol_torque.py (openpilot/selfdrive/controls/lib/latcontrol_angle.py)
• Change coupling: manager.py ↔ tombstoned.py (openpilot/system/manager/manager.py)
• Change coupling: metadrive_bridge.py ↔ metadrive_process.py (openpilot/tools/sim/bridge/metadrive/metadrive_bridge.py)
• CheckUpdateButton._update_state (cognitive 28) (openpilot/selfdrive/ui/mici/layouts/settings/software.py)
• CheckUpdateButton._update_state (cyclomatic 22) (openpilot/selfdrive/ui/mici/layouts/settings/software.py)
• ChestnutStatus.update (cognitive 46) (openpilot/system/hardware/chestnut/status.py)
• ChestnutStatus.update (cyclomatic 40) (openpilot/system/hardware/chestnut/status.py)
• Controls.state_control (cognitive 24) (openpilot/selfdrive/controls/controlsd.py)
• Controls.state_control (cyclomatic 18) (openpilot/selfdrive/controls/controlsd.py)
• DesireHelper.update (cognitive 25) (openpilot/selfdrive/controls/lib/desire_helper.py)
• …and 530 more

• 300 commits — 257 feature/other, 43 fixes

• openpilot/selfdrive — 105 commits
• openpilot/tools — 81 commits
• (root) — 41 commits
• openpilot/system — 26 commits
• openpilot/common — 24 commits
• openpilot/cereal — 5 commits
• tools/op.sh — 5 commits
• tools/release — 5 commits
• .github/workflows — 2 commits
• tools/setup_dependencies.sh — 2 commits
• scripts/lint — 1 commit
• tools/scripts — 1 commit
• tools/setup.sh — 1 commit
• tools/test_runner.py — 1 commit

• fix: Fix button label widths (#38680)
• fix: Revert "Move Git LFS hosting to Hugging Face" (#38837)
• fix: Revert "bump msgq (#38836)" (#38920)
• fix: Revert "camerad: improve IFE robustness to lags (#38548)"
• fix: Revert "chestnut: don't compile if big model is LFS pointer" (#38670)
• fix: Revert "lfs: exclude big driving model in master clones (#38626)"
• fix: Revert "monitor chestnut USB in hardwared (#38741)" (#38744)
• fix: Revert "op: support all the linuxes!" (#38774)
• fix: Revert "process replay: new Y route" (#38999)
• fix: Revert big RL model (#38627)
• fix: Revert tinygrad update (#38879)
• fix: cabana: fix chart ranges and control layout (#38797)
• fix: cabana: fix clipped control outlines and filter sizing (#38795)
• fix: cabana: fix detached panel menus (#38890)
• fix: cabana: fix download bar layout (#38900)
• fix: cabana: fix sparkline edges and stroke rendering (#38784)
• fix: cabana: fix stale message size warnings (#38961)
• fix: cabana: fix stream and replay lifetimes (#38796)
• fix: cabana: fix video startup and desktop interactions (#38798)
• fix: cabana: make the Signals pane a native dock panel, fix pad (#38889)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

commaai/openpilot was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.