Editorial: Robotics software engineering

Editorial: Robotics Software Engineering Robotics software engineering stands at the confluence of multiple disciplines, where physical interaction with dynamic and uncertain environments amplifies the complexity of traditional software challenges. As robots become indispensable in domains such as manufacturing, healthcare, transportation, and exploration, they must exhibit high levels of autonomy, adaptability, robustness, and safety. Achieving these qualities requires not only technical breakthroughs in algorithms and hardware but also a strong foundation in software engineering principles tailored to the unique demands of robotics. Robotics inherently involves multidisciplinary integration: navigation, motion planning, manipulation, perception, control, and human-robot interaction must all coalesce within a coherent software framework. Engineering such systems requires careful coordination among experts from each domain, whose contributions must interoperate reliably, often in real time. Further challenges arise from operating in environments that are partially observable, dynamic, and sometimes adversarial, raising the stakes for ensuring correctness, security, and resilience. This Research Topic, Robotics Software Engineering, brings together a diverse collection of contributions aimed at addressing foundational and emerging challenges in this space. Rather than presenting a simple catalogue of articles, this editorial aims to situate these works within broader themes shaping the future of robotics software. Bringing Rigor to Robotics: Model-Based Engineering and Formal Methods As robotic applications become more safety-critical, ensuring correctness through formal verification becomes not just desirable but necessary. Yet, formal methods remain difficult to apply due to the manual effort involved in creating models and extracting system parameters. Lukas Dust and his colleagues at the Mälardalen University (Sweden) address this head-on with a model-driven methodology for the automated formal verification of ROS 2 systems. By integrating model transformation pipelines with real execution traces, this work demonstrates how verification can become more modular, reusable, and accessible to non-experts. The toolchain lowers the barrier to rigorous analysis, allowing developers to iteratively assess critical system properties like timing and scheduling without being formal methods specialists. Similarly, Ana Cavalcanti (University of York, UK) and her colleagues propose RoboArch, an architectural modeling language layered atop the formal DSL RoboChart, that advances the discipline by providing verifiable architectural abstractions. Applied in industrial contexts like nuclear robotics, RoboArch emphasizes the value of model-driven design for bridging informal software practices and formal correctness in real-world systems. Architectures for Adaptivity and Reusability Adaptation is a recurring theme in robotic systems, where conditions often change unpredictably. Several contributions explore adaptive software architectures as key enablers of robustness and long-term autonomy. ROSA, a knowledge-driven framework for robot self-adaptation proposed by Gustavo Rezende Silva (TU Delft, Netherlands) and colleagues, exemplifies this direction. It captures application-specific knowledge in structured models and reasons over them at runtime to guide both task execution and architectural configuration—a co-adaptation capability rarely addressed in robotics. Complementing this, the survey on ontology-enabled autonomy by Esther Aguado (Universidad Politécnica de Madrid, Spain) examines how semantic knowledge and reasoning improve robot behavior in open-ended environments. By analyzing trends in the use of ontologies for fault recovery, mission planning, and behavior selection, the article highlights how structured, declarative knowledge can foster more explainable and dependable autonomy. The contribution by Sven Schneider (Hochschule Bonn-Rhein-Sieg, Germany and KU Leuven, Belgium) and colleagues, Semantic Composition of Robotic Solver Algorithms, introduces a composable, graph-based methodology for algorithm synthesis. By leveraging standards from the Semantic Web, the authors enable the reuse and symbolic generation of solver code across application domains, from kinematics to probabilistic inference. These developments advance the field toward software that not only adapts itself but also explains its logic, a key step for collaborative and trustworthy robots. Improving Software Quality through Early Validation and Testing Traditional debugging and validation approaches are inadequate for robotics, where errors discovered at runtime can lead to costly damage or unsafe behavior. Therefore, early and automated validation is crucial. With EzSkiROS, Momina Rizwan (Lund University) and colleagues tackle this issue using embedded domain-specific languages (DSLs) that enable early error detection in robotic skill composition. By embedding checks in the design and deployment phases, the approach catches both high-level contract violations and low-level implementation bugs before they manifest during execution. This shift left in the validation pipeline shortens the debugging loop and improves overall safety. At the other end of the deployment pipeline, with AAT4IRS, Marcela G. dos Santos (Université du Québec à Chicoutimi, Canada) and colleagues introduce a novel framework for automated acceptance testing in industrial robotic systems. Built on behavior-driven development principles, this approach uses natural language to specify test scenarios, enabling cross-functional collaboration between engineers and stakeholders. Mutation testing results show strong fault detection capability, indicating the practical utility of the framework in high-stakes industrial environments. Simulation-based testing also receives attention. Despite its potential, it remains underused due to the complexity of scenario definition. To address this, the article by Argentina Ortega (University of Bremen and Ruhr University Bochum, Germany) and colleagues presents a composable scenario framework for testing mobile robots in virtual environments. By enabling developers to incrementally build and reuse complex scenarios, the approach reduces overhead while improving test coverage and configuration error detection. Foundations and Infrastructure: Languages, Patterns, and Performance The underlying infrastructure of robotic software must be efficient, reliable, and extensible. Several contributions examine foundational aspects, including runtime patterns, data structures, and energy consumption. The study by Maria I. Artigas (KU Leuven and Flanders Make, Belgium) and colleagues introduces software coordination patterns such as acquire-release and cache-awareness, alongside data structures like Petri nets and finite state machines, to support real-time task execution. The proposed runtime infrastructure separates event firing from handling, facilitating distributed deployment and enabling consistent coordination across multiple robots. The contribution by Michel Albonico (Federal University of Technology of Paraná, Brazil) and colleagues addresses an increasingly important concern—energy efficiency—by comparing the resource usage of ROS 2 nodes written in C++ and Python. Empirical results confirm that C++ outperforms Python in energy consumption, particularly in high-frequency communication tasks, offering valuable guidance for developers optimizing for battery-powered or resource-constrained platforms. Containerization also emerges as a promising strategy for scalable integration. Giuseppe Cotugno (Ocado Technology, UK) and colleagues propose a containerized approach for multiform robotic architectures that demonstrates how virtualization can simplify third-party component integration without compromising performance. Evaluated in a real-world industrial robot, this method shows that modern software engineering practices like containerization can be successfully adapted to robotics, reducing setup complexity while maintaining real-time guarantees. Toward a Mature Discipline of Robotic Software Engineering Taken together, the articles in this Research Topic reflect a field that is rapidly maturing—seeking not only functional solutions to robotic problems but principled, reusable, and verifiable engineering practices. From architectural modeling to energy-aware programming, from scenario-based testing to self-adaptive reasoning, each contribution addresses a facet of the broader challenge: how to engineer robotic systems that are not only intelligent, but also trustworthy, maintainable, and ready for real-world deployment. This Research Topic fosters synergy between academia and industry, theoretical rigor and practical deployment. It invites the community to further explore the foundational questions of variability, modularity, reusability, validation, and automation in robotic software development. As robots increasingly share our spaces and tasks, the importance of sound engineering for their software only grows. We hope these contributions inspire continued innovation and cross-disciplinary collaboration in the journey toward robust and dependable robotic systems.