Headquartered in Dubai, UAE, with several engineering offices in Egypt, BrightDrive develops Level 4 autonomous driving systems—covering both software and hardware—and has a proven track record in advancing autonomous vehicle platforms and mobility solutions.

As part of their membership, BrightDrive plans to:

Deploy Autoware’s Vision AI models (SceneSeg, EgoLanes, EgoPath) on its QuantumDrive Zonal Controller and middleware platform.

Contribute engineering expertise to the PoV Working Group for reference implementations and demonstrators.

Provide in-kind contributions, including access to the QuantumDrive platform and support in the development of Autoware E2E models.

Collaborate on joint marketing and GTM activities with the Autoware Foundation to engage automotive OEMs and showcase outcomes at global events.

Through this collaboration, the Autoware Foundation will advance its mission to deliver automotive-certifiable reference implementations for L2–L2++ autonomy, while BrightDrive will demonstrate the scalability and flexibility of its L4 QuantumDrive platform to support multiple levels of autonomy across diverse vehicle architectures.

We’re thrilled to welcome BrightDrive into the Autoware ecosystem to shape the future of open autonomous driving together.

Visit the BrightDrive website > www.brightdrive.ai

Visit the BrightSkies website > www.brightskiesinc.com

The post BrightDrive Joins the Autoware Foundation! appeared first on Autoware.

The Autoware Foundation is growing its engineering team to accelerate AI-driven autonomy in open source.

As we continue developing next-generation end-to-end AI systems, we’re looking for engineers who can bridge research and deployment, turning neural networks into real-world autonomy.

In this role, you’ll:
Design and train machine learning models for perception and control
Build scalable data and training pipelines
Optimize networks for edge deployment and simulation environments
Collaborate across global open-source teams

If you have strong experience in C++, Python, PyTorch, and ROS 2, and want to make an impact in the world’s leading open-source autonomous driving project, we’d love to hear from you.

Apply at: auto@autoware.org
More details: bit.ly/EmbodiedAIEngineer 

The post We’re hiring – Embodied AI Engineer appeared first on Autoware.

Headquartered in Beijing, China, Neolix operates more than 10,000 autonomous delivery vehicles worldwide — making it the largest commercial robo-van fleet in existence. With deep expertise in autonomous logistics, Neolix is poised to play a pivotal role in shaping deployment-ready autonomy through the Low-Speed Autonomy Working Group (LSA WG).

As part of their membership, Neolix plans to:
Contribute cost-efficient, vision-based autonomy solutions

Share proven regulatory collaboration experience from working with governments to enable AV testing and legislation

Launch a Deployment Insights Forum to share lessons from millions of kilometers of commercial operations

Support a Hardware Reference Initiative to accelerate real-world validation and integration

Through this collaboration, the Autoware Foundation gains unique access to operational expertise at scale, while Neolix benefits from our global ecosystem of over 100 members that drive the future of open-source autonomous mobility.

We’re thrilled to welcome Neolix on board — and to work together on advancing safe, cost-effective, and deployment-ready autonomy worldwide.

Learn more about Neolix > https://www.neolix.ai/

The post Neolix Holding Inc. Joins The Autoware Foundation! appeared first on Autoware.

Based in Cairo, Egypt, Garraio brings strong expertise in automotive cybersecurity, embedded systems, and functional safety compliance. Their focus with the Foundation is to help demonstrate an automotive-grade reference implementation of the Autoware Privately Owned Vehicle (PoV) stack on real hardware.

As part of their membership, Garraio plans to:

Deploy Autoware’s Vision AI models and PoV stack on automotive middleware and hardware for L2–L3 ADAS/AD applications

Contribute FTEs for the development of the PoV stack

Share insights on expanding AUTOSAR integration within Autoware

Collaborate on joint marketing and awareness efforts to engage automotive OEMs

Through this collaboration, the Autoware Foundation will be able to showcase a more production-ready, standards-aligned reference stack, while Garraio strengthens its engagement with the global open-source community and automotive ecosystem.

We’re very excited to welcome Garraio on board — and to see how their contributions will help advance the path toward safe and open-source autonomous driving.

Visit Garraio’s website > https://garraio.com/

The post Garraio LLC. Joins The Autoware Foundation! appeared first on Autoware.

Production-level middleware such as Iceoryx (and Iceoryx2) supports true zero-copy IPC, but only for messages with static size, and thus cannot be adopted in Autoware. Autoware extensively uses unsized message types (e.g., message types containing C++’s std::vector) as part of its design goal to handle multiple use cases within a single codebase. Even at the conceptual level (e.g., in academic papers), no ROS 2–compatible middleware has ever existed that supports true zero-copy IPC for arbitrary ROS 2 messages. True zero-copy IPC for unsized messages was proposed in TZC [IROS ‘19] and LOT [IROS ‘21], but they only support runtime-resizable arrays specialized for TZC/LOT, not arbitrary ROS 2 messages with properties like std::vector.

To address this problem, we invented a new IPC technique and developed a new ROS 2–compatible middleware, Agnocast. With minimal code changes to existing ROS 2 applications, Agnocast enables true zero-copy IPC for arbitrary ROS 2 message types. In this blog post, we introduce Agnocast and its integration into Autoware.

Agnocast GitHub repository: GitHub – tier4/agnocast: True Zero Copy Communication Middleware for Unsized ROS 2 Message Types. 

How to Use Agnocast

Agnocast coexists with the ROS 2 stack without requiring changes to ROS 2, and is unaffected by changes to the RMW implementation.

To introduce Agnocast, the following changes and operations are necessary:

1. Installation of dependencies
2. Insertion of the kernel module
3. Modifications to ROS 2 app’s source code
4. Modifications to launch files

See details in the Agnocast GitHub repository README.

1. Installation of dependencies

To use Agnocast, two packages must be installed in addition to the client library: a library loaded via LD_PRELOAD for hooking heap allocations (agnocast-heaphook), and a kernel module (agnocast-kmod). Both are distributed through TIER IV’s PPA as of August 2025, with the latest version being v2.1.2.

Shell
sudo add-apt-repository ppa:t4-system-software/agnocast
sudo apt update
sudo apt install agnocast-heaphook-v2.1.2 agnocast-kmod-v2.1.2

Next, install the client library agnocastlib. As of August 2025, it is only available as a source build, but it will soon be distributed through the ROS build farm.

Shell
git clone --branch 2.1.2 --depth 1 https://github.com/tier4/agnocast.git
source /opt/ros/humble/setup.bash
rosdep install -y --from-paths src --ignore-src --rosdistro $ROS_DISTRO
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release
source install/setup.bash

2. Insertion of the kernel module

Load the installed kernel module. You may also configure systemd to automatically load it at system startup.

Shell
sudo modprobe agnocast

3. Modifications to ROS 2 app’s source code

Only the smart pointer type that wraps the message type and the publish/subscribe functions need to be modified. Agnocast provides a smart pointer, agnocast::ipc_shared_ptr, which manages the lifetime of message objects transferred between processes. The only required change for publisher and subscriber functions is to change their namespace from rclcpp to agnocast.

4. Modifications to launch files

In the launch file, environment variables such as LD_PRELOAD need to be set so that agnocast-heaphook is applied to processes participating in Agnocast communication. Additionally, for ComposableNode, the Agnocast-specific executor must be specified in the launch file.

New IPC Technology behind Agnocast

The production-grade Agnocast (tier4/agnocast) has been developed based on a paper of new IPC technology and its prototype. The paper, titled “ROS 2 Agnocast: Supporting Unsized Message Types for True Zero-Copy Publish/Subscribe IPC” was accepted by IEEE ISORC 2025. If you are interested in more details, we encourage you to read the paper.

The new IPC technology behind Agnocast is primarily based on two elements: memory mapping that allows data structures containing pointers to be shared across processes, and a smart pointer that manages metadata such as reference counts within the kernel module.

For processes participating in Agnocast communication, all heap allocations and deallocations are intercepted via LD_PRELOAD and redirected to a specified virtual address range. This address range is mapped to shared memory. Subscribers map the publisher’s heap region as read-only at the same offset in their own virtual address space.

In this shared address range, raw pointers remain valid across processes (if they do not point outside the shared memory region), thereby enabling true zero-copy IPC in Agnocast. For details on why such a drastic approach is necessary, please refer to the paper mentioned above.

As explained above, an Agnocast-specific smart pointer type (agnocast::ipc_shared_ptr) is provided for wrapping ROS 2 messages. While normal smart pointer types (e.g., std::shared_ptr) have their own data structures (e.g., reference counts) in the user-space address space, the Agnocast-specific smart pointer maintains them within the kernel module (agnocast-kmod).

This is necessary because updates to cross-process metadata must be transactional—either fully succeed or roll back—without leaving an inconsistent state. For simplicity of implementation, Agnocast adopts the former approach by implementing metadata operations as kernel module system calls, ensuring that updates are completed regardless of the timing of process termination.

Because the objects may be referenced by multiple processes, their lifetime management—that is, the logic for determining when to free them—differs from that of ordinary smart pointers. The kernel module also monitors process exits to ensure that the data structures remain valid, even if a process terminates unexpectedly.

Integration into Autoware

As of August 2025, Agnocast has already been integrated into autonomous bus projects at TIER IV. The introduction of Agnocast has resolved the challenge of combining efficient IPC for large sensor data with fault isolation for safety.

Agnocast is being introduced not only into internal projects at TIER IV but also into the open-source Autoware project. The initial integration targets are as follows:

• https://github.com/tier4/nebula/pull/335 
• https://github.com/autowarefoundation/autoware_universe/pull/10812 

Since Agnocast is still in an experimental stage, its integration can be enabled or disabled at build time using the environment variable ENABLE_AGNOCAST. For details, please refer to the autoware_agnocast_wrapper README.

Interested in learning more? A talk on Agnocast will be given at ROSCon 2025! We will also soon publish detailed documentation of Agnocast. Integration into Autoware is currently being discussed in the discussion in the awf/autoware repository.

The post Agnocast: A True Zero-Copy Publish/Subscribe IPC appeared first on Autoware.

NomadicML brings deep expertise in machine learning infrastructure — powering the processing of millions of hours of driving footage to enable scalable, end-to-end AI development. Their vision strongly aligns with Autoware’s mission, as they see tremendous synergy with our open-source approach to autonomous driving.

As part of their membership, they commit to:

Integrate the NomadicML Platform and offer utility for intelligent data curation to automatically identify valuable training data

Provide dedicated resources and consultation to support Autoware’s AI-first, end-to-end model development

In addition, at later stages of their engagement, NomadicML will help design and implement modern MLOps pipelines for efficient large-scale model training, enabling faster iteration and scalability for Autoware’s AI-first future.

Here’s a good example of how NomadicML can be useful to the community:

In a recent blog post, they demonstrated how their two-step pipeline transforms the open-source Honda Driving Dataset (HDD) from raw video into structured, training-ready datasets. This showcases how the NomadicML Platform can streamline data curation and accelerate model development.

Read the full post here: Efficiently Curating Video Driving Datasets using the NomadicML Platform

https://www.nomadicml.com/blog/Efficiently%20Curating%20Video%20Driving%20Datasets%20using%20the%20NomadicML%20Platform

NomadicML will initially participate in the Privately Owned Vehicle Working Group, while also exploring opportunities to contribute across other working groups as their journey with Autoware evolves.

We’re excited to have NomadicML on board and look forward to accelerating Autoware’s transition to an AI-first future together!

Visit NomadicML’s website to learn more about them

https://www.nomadicml.com

The post NomadicML Joins The Autoware Foundation! appeared first on Autoware.

The Vision

As autonomous vehicle systems grow in complexity, simulation has become essential for bridging the gap between conceptual design and real-world deployment. Yet, creating simulations that accurately reflect realistic vehicle dynamics, sensor characteristics, and environmental conditions — while also enabling real-time interactivity — remains a major challenge. Traditional simulations often fall short in supporting these “autonomy-oriented” demands, where back-end physics and front-end graphics must be balanced with equal fidelity.

To truly enable simulation-driven design, testing, and validation of autonomous systems, we envision a shift from static, fixed-parameter virtual models to dynamic and adaptive digital twins. These autonomy-oriented digital twins capture the full system-of-systems-level interactions — including vehicles, sensors, actuators, infrastructure and environment — while offering seamless integration with autonomy software stacks.

This blog presents our approach to building such digital twins across different vehicle scales, using a unified real2sim2real workflow to support robust development and deployment of the Autoware stack. Our goal is to close the loop between simulation and reality, enabling smarter, faster, and more scalable autonomy developments.

Digital Twins

To demonstrate our framework across different operational scales, we worked with a diverse fleet of autonomous vehicles — from small-scale experimental platforms to full-sized commercial vehicles. These included Nigel (1:14 scale), RoboRacer (1:10 scale), Hunter SE (1:5 scale), and OpenCAV (1:1 scale).

Each platform was equipped with sensors tailored to its size and function. Smaller vehicles like Nigel and RoboRacer featured hobby-grade sensors such as encoders, IMUs, RGB/D cameras, 2D LiDARs, and indoor positioning systems (IPS). Larger platforms, such as Hunter SE and OpenCAV, were retrofitted with different variants of 3D LiDARs and other industry-grade sensors. Actuation setups also varied by scale. While the smaller platforms relied on basic throttle and steering actuators, OpenCAV included a full powertrain model with detailed control over throttle, brakes, steering, and handbrakes — mirroring real-world vehicle commands.

For digital twinning, we adopted the AutoDRIVE Simulator, a high-fidelity platform built for autonomy-centric applications. Each digital twin was calibrated to match its physical counterpart in terms of its perception characteristics as well as system dynamics, ensuring a reliable real2sim transfer.

Autoware API

The core API development and integration with Autoware stack for all the virtual/real vehicles was accomplished using AutoDRIVE Devkit. Specifically, AutoDRIVE’s Autoware API builds on top of its ROS 2 API, which is streamlined to work with the Autoware Core/Universe stack. It is fully compatible with AutoDRIVE Simulator as well as AutoDRIVE Testbed, ensuring a seamless sim2real transfer, without change of any perception, planning, or control algorithms/parameters.

The exact inputs, outputs, and configurations of perception, planning, and control modules vary with the underlying vehicle platform. Therefore, to keep the overall project clean and well-organized, a multitude of custom meta-packages were developed within the Autoware stack to handle different perception, planning, and control algorithms using different input and output information in the form of independent individual packages. Additionally, a separate meta-package was created to handle different vehicles viz. Nigel, RoboRacer, Hunter SE, and OpenCAV. Each package for a particular vehicle hosts vehicle-specific parameter description configurations for perception, planning, and control algorithms, environment maps, RViz configurations, API scripts, teleoperation programs, and user-convenient launch files for getting started quickly and easily.

Applications and Use Cases

Following is a brief summary of the potential applications and use cases, which align well with the different ODDs proposed by the Autoware Foundation:

• Autonomous Valet Parking (AVP): Mapping of a parking lot, localization within the created map and autonomous driving within the parking lot.
• Cargo Delivery: Autonomous mobile robots for the transport of goods between multiple points or last-mile delivery.
• Racing: Autonomous racing using small-scale (e.g. RoboRacer) and full-scale (e.g. Indy Autonomous Challenge) vehicles running the Autoware stack.
• Robo-Bus/Shuttle: Fully autonomous (Level 4) buses and shuttles operating on public roads with predefined routes and stops.
• Robo-Taxi: Fully autonomous (Level 4) taxis operating in dense urban environments to pick-up and drop passengers from point-A to point-B.
• Off-Road Exploration: The Autoware Foundation has recently introduced an off-road ODD. Such off-road deployments could be applied for agricultural, military or extra-terrestrial applications.

Getting Started

You can get started with AutoDRIVE and Autoware today! Here are a few useful resources to take that first step towards immersing yourself within the Autoware Universe:

• GitHub Repository: This repository is a fork of the upstream Autoware Universe repository, which contains the AutoDRIVE-Autoware integration APIs and demos.
• Documentation: This documentation provides detailed steps for installation as well as setting up the turn-key demos.
• YouTube Playlist: This playlist contains videos right from the installation tutorial all the way up to various turn-key demos.
• Research Paper: This paper can help provide a scientific viewpoint on why and how the AutoDRIVE-Autoware integration is useful.

What’s Next?

PIXKIT 2.0 Digital Twin in AutoDRIVE

We are working on digitally twinning more and more Autoware-supported platforms (e.g., PIXKIT) using the AutoDRIVE Ecosystem, thereby expanding its serviceability. We hope that this will lower the barrier of entry for students and researchers who are getting started with the Autoware stack itself, or the different Autoware-enabled autonomous vehicles.

The post A Tale of Two Open-Source Ecosystems: Scaling Autonomy with AutoDRIVE & Autoware appeared first on Autoware.

Key Highlights

Research Showcase: Work of many CoE representatives was highlighted in the Autoware Foundation social media channels to bring visibility and recognition to work.

Roadmap Taskforce: Carried over the conversation on the work that has been done at the Roadmap task force to inform the CoE members.

Off-Road Autonomy: Progress on datasets, training, and simulation for terrestrial and space exploration use cases.

Collaboration Opportunities: Upcoming EU projects, NASA/Space ROS alignment, and discussions on dataset standards and affordable platforms.

Autoware CoE Research Showcase

This month’s meeting highlighted a range of recent academic contributions from CoE members:

• Personalized Autonomy: Dr. Ziran Wang presented ongoing work using LLMs and VLMs to make behavioral planners more transparent and understandable to drivers.
• Vehicle Dynamics: Associate Prof. Hormoz Marzbani shared progress on scalable tire dynamics modeling and learning for control, supporting safer and more adaptive driving behavior.
• Automated Bug Detection: The UC Irvine team (Josh Garcia and Alfred Chen) demonstrated tools for automated bug finding and fixing, applied not only to Autoware but also to Apollo and OpenPilot. Their efforts led to NSF CAREER Awards for both professors.
• Clemson AutoDrive Platform: Venkat and his students showcased results from their simulation racing leagues with 60–70 teams, which ran without software crashes. Their digital twin environments are now being extended beyond racing to support off-road autonomy research.

Autoware Roadmap Taskforce Overview

The CoE meeting also reviewed progress from the Autoware Roadmap Taskforce, which launched earlier this year to coordinate execution across working groups. The taskforce is structured into four phases (P1–P4, three months each) and nine working groups, spanning core AV development, enabling technologies, and production/validation.

Three main objectives guide the effort:

• Incorporate cutting-edge AI-first technologies as Autoware transitions from v1.0 to v2.0.
• Deliver a production-ready stack that members can commercialize.
• Expand deployments of Autoware to more vehicles and increase autonomous mileage.

This structured approach ensures that research advances from CoE members can connect directly to Autoware’s roadmap, supporting the transition from lab prototypes to production deployments.

Off-Road Working Group Focus

The Off-Road WG, led by Po-Jen Wang, is taking an end-to-end approach to autonomy in extreme environments, spanning both terrestrial and space applications.

• Terrestrial vehicles: Off-road racing and mining vehicles, where LiDAR-based perception can be applied.
• Space exploration: Mars rovers and Lunar Terrain Vehicles, where harsh conditions make LiDAR impractical, requiring vision-based perception pipelines.

A modified version of the AutoSeg foundation model is being applied, trained on off-road datasets to deliver three key perception capabilities:

• Free space detection (drivable vs. non-drivable areas)
• Object detection (structures, vehicles, vulnerable living beings, etc.)
• Terrain classification (paved, dirt, vegetation, snow, etc.)

Planning and control modules are being adapted for rough terrain, with tighter coupling between perception and control to ensure stability in challenging conditions.

Dataset Integration and Training Progress

To support robust off-road perception, CoE members have combined six open datasets — including Rellis3D, Goose, ORFD, Yamaha-CMU, CaSSeD, and OFFSED — under a unified labeling scheme. A custom parsing and configuration framework has been developed to standardize classes and formats across sources.

Early training results are promising:

• Free space segmentation models have reached ~80% IoU, showing reliable detection of drivable areas.

Work continues on object detection and terrain classification, with initial tests already demonstrating generalization on unseen data.

While the dataset size (~22k images) remains smaller than typical on-road datasets, discussions are underway with potential industry contributors to expand the pool of off-road training data.

Simulation Environments

The Off-Road WG is extending Autoware’s simulation capabilities to cover both terrestrial and space-focused use cases:

• Mining environments: New vehicle and terrain models are being developed in CARLA 0.10, enabling realistic testing of heavy-duty off-road applications.
• Off-road racing: A scalable Isaac Sim RoboRacer model is being upgraded from 1/10th to 1/5th scale. A configurable racetrack generator has been built, allowing randomized parameters such as track width, banking, and corner angles.
• Mars environment: A digital twin has been created based on NASA Perseverance rover locations, with terrain models verified against rover images.
• Lunar environment: An environment based on a candidate Artemis landing site at the lunar South Pole has been developed, complete with detailed terrain and rock assets.

These environments provide realistic testbeds for validating perception, planning, and control pipelines in conditions ranging from industrial sites to planetary surfaces.

Collaboration Opportunities and Next Steps & Suggestions

The August meeting also highlighted upcoming opportunities for joint work and cross-university collaboration:

• Poznan University : Preparing a real off-road project with potential EU funding, including a 700 m² covered test facility with basalt sand for lunar rover analog studies.
• Virginia Polytechnic Institute and State University : Collecting small-scale airport data and opening access to off-road test sections. Alignment with Space ROS standards is in progress through NASA’s Picnic team.
• Standardized Platforms: Suggestions were raised for creating a common, affordable platform, similar to F1TENTH, to accelerate off-road autonomy research.
• Simulation & Physics: Interest in converging simulators and advancing physics models for granular media was shared by several members.
• Dataset Guidelines: Discussions began around tiered dataset requirements to ensure consistency across different projects.

The August CoE meeting marked a strong restart after the summer break, with new research results, simulation progress, and cross-university collaborations pointing toward impactful outcomes. From personalized autonomy and scalable vehicle dynamics to lunar and Martian testbeds, the CoE community continues to expand the boundaries of what Autoware can achieve in research and education.

We look forward to the September meeting and the next wave of updates from our university partners.

The post Autoware Centers of Excellence Steering Committee August 2025 Update appeared first on Autoware.

One of the key events this year was a local workshop hosted at UCI in March 2025. The workshop brought together researchers from multiple institutions with the goal of eliciting requirements for a shared, cloud-based research infrastructure to support the development and testing of autonomous driving systems. Rather than focusing on a particular software stack, the workshop centered on identifying technical, logistical, and collaborative needs that such an infrastructure must address. Participants shared perspectives on scenario generation, simulation at scale, data management, and tool interoperability—laying the groundwork for a future platform that could support reproducible, cross-institutional research in autonomous driving systems.

Complementing this effort was UCI’s organization of the SE4ADS (Software Engineering for Autonomous Driving Systems) workshop at ICSE 2025. SE4ADS serves as a growing forum for advancing software engineering research tailored to the needs of autonomous driving systems. The 2025 edition featured work on simulation-based testing, requirements integration, and safety certification. Discussions also addressed broader concerns around responsible software practices and long-term maintainability, particularly in the context of open-source autonomous systems such as Autoware. The workshop underscored a shared commitment to developing engineering foundations that can support the unique complexity and risk profile of autonomous software.

With these community needs in mind, Yuqi is now leading the design and development of a Cloud-based Autonomous Driving Systems Research Infrastructure (CADRI). Building on insights from both the UCI-hosted workshop and the SE4ADS forum, this effort aims to create a scalable, interoperable platform that supports reproducible experimentation. A key advantage of the cloud-based approach is its ability to significantly reduce upfront costs, allowing researchers to perform large-scale testing and development without substantial investment in specialized hardware. This initiative builds on Yuqi’s earlier work in scenario-based testing, including DoppelTest [1] and scenoRITA [2], two frameworks for generating scenario-based tests. He also maintains a key dependency for the SVL simulator, helping ensure that the simulation tool remains accessible to the research community. In parallel, Xiang has been working on migrating tools originally developed for other ADS platforms onto Autoware, thereby broadening tool compatibility and reinforcing Autoware’s role as an open-source foundation for reproducible research.

In Yuntianyi’s latest research, he has been emphasizing Autoware as he led the development of ConfVE [4], a tool designed to identify failures in autonomous driving systems that arise from alternative configurations. Misconfiguration is a known risk factor in real-world deployments, and ConfVE aims to prevent such issues by identifying inconsistent or unsafe parameter combinations early in the development cycle. As part of this approach, Yuntianyi also developed a Scenario Record Analyzer—an automated tool capable of detecting nine distinct types of violations in Autoware driving scenario records, providing a robust mechanism for validating ADS behavior against safety and performance requirements. This work leveraged HD map and scenario data from Autoware Evaluator, obtained through a collaboration with the Autoware Operational Design Domain (ODD) Working Group. The partnership provided access to realistic, systematically generated test scenarios that reflect the ODD characteristics of Autoware’s target deployment environments, enabling ConfVE and the Scenario Record Analyzer to be validated under conditions closely resembling real-world usage. More recently, Yuntianyi presented A Comprehensive Study of Bug-Fix Patterns in Autonomous Driving Systems [5] at FSE 2025. This large-scale analysis examined over 1,300 real-world bug-fix instances from two leading open-source platforms (i.e., Autoware and Apollo) and introduced a taxonomy encompassing 15 syntactic and 27 semantic bug-fix patterns, capturing both code-level changes (e.g., conditional modifications, data structure corrections) and domain-specific modifications (e.g., path planning optimization, module integration and interaction). Yuntianyi’s work on ConfVE and the bug-fix pattern benchmark also contributes to the CADRI project, where he serves as a project leader. His contributions provide foundational components for the Toolkit Service, enrich the ADS analytics oracles, and supply a curated dataset repository, thereby strengthening CADRI’s capability to support comprehensive analysis, testing, and improvement of autonomous driving systems.

Besides the research, Yuntianyi and Yuqi contributed to the DevOps Dojo project within the Autoware OpenADKit Working Group. As part of this effort, they refactored approximately 15% of the total Autoware ROS nodes, enhancing maintainability and consistency in the codebase. Yuntianyi also developed an automated configuration refactoring tool for Autoware ROS nodes, enabling developers to standardize and update configurations more efficiently. This tool has accelerated the development workflow, reduced manual intervention, and improved configuration reliability across the Autoware ecosystem.

While Josh approaches autonomous driving from a software engineering perspective, focusing on faults that affect system reliability and correctness, Alfred brings a security lens to the field, concentrating on vulnerabilities in autonomous vehicles. Specifically, Alfred’s team focused on evaluating the robustness of autonomous driving systems by leveraging component-level vulnerabilities using methods such as adversarial scenarios, patches, and objects. Their efforts have contributed to a Platform for Auto-driving Safety and Security (PASS) [6], a modular and extensible simulation-based evaluation framework specifically for evaluating system-level effectiveness of existing attacks or defenses across different autonomous driving models. Building on top of PASS, Chi has been spending his recent efforts on designing and developing an adversarial scenario generation framework for Autoware using the CARLA simulation environment.

With the growing complexity and expanding deployment ambitions, the need for rigorous, collaborative, and scalable engineering practices in autonomous driving systems has never been more urgent. Josh and Alfred’s teams are helping to meet this need by integrating empirical insights with tool development, infrastructure planning, and community engagement. Their work, ranging from scenario-based test generation to large-scale bug fix analyses, demonstrates how software engineering research can directly contribute to the development of safer and more reliable autonomous systems. Through close collaboration with the Autoware Foundation and a commitment to open, reproducible experimentation via efforts like CADRI, they are contributing essential building blocks for a more robust, transparent, and evidence-driven research ecosystem in autonomous driving systems.

References

[1] Yuqi Huai, Yuntianyi Chen, Sumaya Almanee, Tuan Ngo, Xiang Liao, Ziwen Wan, Qi Alfred Chen, and Joshua Garcia. 2023. Doppelgänger Test Generation for Revealing Bugs in Autonomous Driving Software. In Proceedings of the 45th International Conference on Software Engineering (ICSE ’23). IEEE Press, 2591–2603. https://doi.org/10.1109/ICSE48619.2023.00216

[2] Yuqi Huai, Sumaya Almanee, Yuntianyi Chen, Xiafa Wu, Qi Alfred Chen, and Joshua Garcia, “scenoRITA: Generating Diverse, Fully Mutable, Test Scenarios for Autonomous Vehicle Planning,” in IEEE Transactions on Software Engineering, vol. 49, no. 10, pp. 4656-4676, 1 Oct. 2023, doi: 10.1109/TSE.2023.3309610.

[3] Yuqi Huai, 2023, SORA SVL Server. Available at https://github.com/YuqiHuai/SORA-SVL (Accessed: 30 June 2025).

[4] Yuntianyi Chen, Yuqi Huai, Shilong Li, Changnam Hong, and Joshua Garcia. 2024. Misconfiguration Software Testing for Failure Emergence in Autonomous Driving Systems. Proc. ACM Softw. Eng. 1, FSE, Article 85 (July 2024), 24 pages. https://doi.org/10.1145/3660792

[5] Yuntianyi Chen, Yuqi Huai, Yirui He, Shilong Li, Changnam Hong, Qi Alfred Chen, and Joshua Garcia. 2025. A Comprehensive Study of Bug-Fix Patterns in Autonomous Driving Systems. Proc. ACM Softw. Eng. 2, FSE, Article FSE018 (July 2025), 23 pages. https://doi.org/10.1145/3715733

[6] Hu, Zhisheng, Shen, Junjie, Guo, Shengjian, Zhang, Xinyang, Zhong, Zhenyu, Chen, Qi Alfred, and Li, Kang. PASS: A System-Driven Evaluation Platform for Autonomous Driving Safety and Security. Retrieved from https://par.nsf.gov/biblio/10359464. NDSS Workshop on Automotive and Autonomous Vehicle Security (AutoSec).

The post Advancing Software Testing for Autonomous Driving Systems: A Year of Collaboration and Contribution at UCI appeared first on Autoware.

As part of their membership, SODA.Auto will work on deploying Autoware’s camera-based neural network models on automotive-grade hardware, integrated with the SODA SDV Framework and Applications Library. The company already has touchpoints with the Autoware ecosystem — for example, through the University of Pennsylvania’s AV4EV initiative, where SODA.Sim was used to validate the AV4EV go-kart platform.

Looking ahead, SODA.Auto aims to deliver a first proof-of-concept (PoC) of this development, with a target to showcase it at CES 2026, while also engaging in joint marketing and go-to-market activities to raise awareness with automotive players.

The SODA.Auto team has expressed interest in contributing to the Privately Owned Vehicle (PoV) Working Group and the Open AD Kit Working Group, with the potential to expand their involvement as collaboration with the Autoware community deepens.

We’re excited to welcome SODA.Auto as a new member of the Autoware Foundation and look forward to advancing open, software-defined, and autonomous mobility together!

Learn more about SODA.Auto at: https://soda.auto/

Explore SODA.Auto’s ecosystem page: https://autoware.org/autowareio/soda-auto/

The post SODA.Auto joins the Autoware Foundation! appeared first on Autoware.