Modern autonomous systems — from self-driving cars and unmanned aerial vehicles (UAVs) to marine robots and industrial co-bots — depend fundamentally on software architectures capable of real-time sensing, decision-making, and control. While mechanical and electronic components define what a system can do, the software stack defines how it does it — how it perceives the world, interprets data, plans actions, and interacts safely with its environment ^[1,2]. Autonomy software differs from conventional embedded or enterprise software in several critical ways:

• It operates under strict real-time constraints.
• It must integrate data from heterogeneous sensors.
• It needs robust fault tolerance and safety compliance.
• It supports continuous learning and adaptation through AI.
• It often spans distributed systems, connecting vehicles, edge servers, and cloud services.

This combination of safety-critical engineering and AI-driven decision-making makes autonomy software one of the most challenging areas in modern computing.

Autonomy software must achieve four key functional objectives ^[3,4]:

• Perception – sensing and interpreting the environment (via LiDAR, radar, cameras, sonar, etc.).
• Localisation – estimating the system’s precise position and orientation in the world.
• Planning – generating paths or behaviours that fulfil mission goals while avoiding obstacles.
• Control – executing actions safely and stably, compensating for environmental changes.

Each of these objectives corresponds to distinct software layers and modules in the autonomy stack.

These characteristics drive architectural decisions and the choice of frameworks (e.g., ROS, AUTOSAR Adaptive, DDS).

Autonomy software is layered, combining multiple software technologies:

• Low-level embedded firmware (real-time control and drivers).
• Middleware and communication frameworks (data exchange and scheduling).
• High-level AI algorithms (perception, decision-making).
• Supervisory or cloud-level systems (fleet management, updates, data analytics).

The combination of these layers forms the autonomy software stack, which enables complex behaviour while maintaining reliability. A defining aspect of autonomy software is its reliance on middleware — frameworks that manage interprocess communication (IPC), data distribution, and time synchronisation across distributed computing nodes. Some of the widely used standards:

• ROS / ROS 2 (Robot Operating System): Modular publish-subscribe communication.
• DDS (Data Distribution Service): Real-time, QoS-based messaging standard.
• MQTT / ZeroMQ: Lightweight protocols for cloud and IoT integration.

A complete software stack is a layered collection of software components, frameworks, and libraries that work together to deliver a complete set of system functionalities. Each layer provides services to the layer above it and depends on the layer below it. Middleware, which is an essential part of the multi-layered architectures, ensures that all layers of the software stack can exchange information deterministically and safely ^[5]. In autonomous systems, the software stack enables integration between:

• Hardware abstraction (sensors, actuators, compute units),
• Middleware (communication and data exchange),
• Application-level modules (AI perception, planning, control), and
• System management (diagnostics, simulation, fleet updates).

It’s the backbone that allows autonomy to function as a cohesive system rather than a set of disconnected modules (Quigley et al., 2009; Maruyama et al., 2016). From a technical perspective, the software stack defines how functionality, data flow, and control are structured within the system.

Each layer isolates complexity by providing a clean interface to the one above.

• Developers can modify one layer (e.g., perception algorithms) without altering lower layers (e.g., drivers).
• Enables easier testing, debugging, and reuse across multiple vehicles or applications.

Autonomous systems rely on real-time responses. The stack architecture ensures:

• Timely communication between perception, planning, and control.
• Deterministic scheduling using RTOS kernels or real-time Linux patches ^[6].
• Synchronisation of data streams from multiple sensors using timestamping and time-sensitive networking (TSN).

Middleware such as ROS 2 or DDS standardises interprocess communication. This allows different vendors’ software modules (e.g., LiDAR driver from Company A and planner from Company B) to work together.

Stack layering supports redundant paths for safety-critical functions. If a perception node fails, a backup process may take over seamlessly — ensuring resilience, especially in aerospace and automotive systems ^[7].

A layered design allows developers to:

• Integrate software components progressively.
• Test them using Hardware-in-the-Loop (HIL) and Software-in-the-Loop (SIL) methods.
• Use simulators (e.g., CARLA, Gazebo, AirSim) to validate upper-layer modules without risking hardware damage.

From a software engineering management perspective, a defined software stack provides structure and governance for the development process, which provides the following main advantages: Division of Labour. Teams can specialise by layer — e.g., one group handles perception, another control, another middleware. This parallelises development and allows use of domain expertise without interference.

Reusability and Version Control Reusable modules and APIs speed up development. Tools like Git, Docker, and CI/CD pipelines ensure traceability, maintainability, and fast updates across distributed teams.

Scalability and Lifecycle Management A well-structured stack can be extended with new sensors or algorithms without re-architecting the entire system. Lifecycle management tools (e.g., ROS 2 launch systems, AUTOSAR Adaptive manifests) maintain version consistency and dependency control.

Quality Assurance (QA) and Certification Layered software stacks make it easier to apply quality control and compliance frameworks, such as: ISO 26262 (Automotive safety software), DO-178C (Aerospace software) or IEC 61508 (Functional safety in automation). Each layer can be validated separately, simplifying documentation and certification workflows.

Cost and Risk Reduction When multiple projects share a unified software stack, the cost of testing, validation, and maintenance drops significantly. This approach underpins industry-wide initiatives like AUTOSAR, which standardises vehicle software to lower integration costs.

In large autonomy projects (e.g., Waymo, Tesla), the software stack also serves as an organisational structure. Teams are aligned with layers:

• Perception team handles sensor fusion and computer vision.
• Planning & Control team develops behavioural logic and trajectory generation.
• Systems team manages middleware and data distribution.
• Infrastructure team maintains OS builds, simulation, and DevOps pipelines.

Thus, the software stack doubles as both a technical architecture and an organisational map for coordination and accountability ^[8].

The Robot Operating System 2 (ROS 2) exemplifies how modular software stacks are implemented:

• Application Layer: Navigation, mapping, perception nodes.
• Middleware Layer: DDS for data exchange, QoS configuration.
• OS Layer: Linux or RTOS with POSIX APIs.
• Hardware Abstraction: Drivers for cameras, IMUs, LiDARs.
• Build & Deployment Layer: CMake, Colcon, Docker for reproducibility.

This layered model has become the foundation for numerous autonomous systems in academia and industry — from mobile robots to autonomous vehicles ^[9]).

In essence, a software stack is not merely a technical artefact — it’s a strategic enabler that aligns engineering processes, organisational structure, and long-term sustainability of autonomous platforms. Autonomy software stack and Development and Maintenance challenges are discussed in the following chapters: