Robot Vacuums are a pretty common item in many households around the world. They've also become a fairly standard item for robot hobbyists to hack on and use as cheap, open platforms for experiments in mobile bases. The classic "Turtlebot" platform has seen many incarnations, as the iRobot Create series, the Kobuki base, the Neato BotVac and now lives on in the "Hackerbot" from HackerBot Industries(https://www.hackerbot.co/). It has an open command set, options for an arm, animated head and SDK to support the development of character-like human-robot interactions. It does autonomous mapping of whatever space it was in at the push of a button. Unfortunately, the map is stored in an internal proprietary format, accessible through an app you download onto your phone.
I have a number of robots at home and in my lab, all of which run ROS. Surely there must be some way to hack out the map and convert it into a ROS-compatible format that my other robots could use! My talk would be discussing the steps I took to make this happen, the FOSS packages I used and the resulting tool.
This is not my first excursion into hacking robot mapping and sensors, so I'll also present some tips and tricks I've learned over the years to make seemingly proprietary robot subsystems more open and generally usable.
Mapping tool GitHub: https://github.com/jetdillo/hackerbot-maptools
Hackerbot Base: https://www.hackerbot.co/
My robot consulting business: https://www.familiarrobotics.com
When building a robot you want to make sure your set up is perfect. This means good calibration for your sensors, good configurations for your sensors, good synchronization between sensors, good data logging practices and much much more!
In this talk Roland and Sam will talk about their experiences with poorly configured robots, the importance of visualisation and the (open source) tools they use to solve their problems.
As robotics systems grow more complex, bringing together all types of specialties from algorithm/ML developers, control engineers, to safety engineers, has become increasingly painful, especially when working with large, brittle stacks like C++ and ROS.
This talk shares the journey of building Copper-rs, a Rust first robot runtime to make robotics development simpler, safer, and more predictable. Rust’s mix of performance, memory safety, and fearless concurrency offers a foundation for systems that don’t collapse under their own complexity.
Built entirely in the open, Copper-rs has grown out of the Rust for Robotics community and explores how we can take the openness and collaboration that made ROS successful and bring those values into a new generation of deterministic, Rust-based robotics systems.
The copper-rs project is an Apache v2 project available at https://github.com/copper-project/copper-rs
ROS 2 is tied to specific Ubuntu versions, which limits platform choice and can introduce additional configuration complexity. In this talk, I will explain how to run ROS 2 on non-standard platforms using Apptainer, a practical alternative to Docker. I explain why Apptainer works well for robotics: it enables easy access to USB and serial devices, supports GPUs, and runs GUI programs like rviz without configuration. The talk ends with a short look at when the package manager Pixi might even let you avoid containers altogether. Being less tied to a specific Ubuntu release makes robot development more flexible.
Just1 is an open-source robotics platform built for learning and rapid experimentation. It supports manual and autonomous navigation, path following, and obstacle avoidance. With a bill of materials around $250, it offers an affordable way to explore robotics, ROS 2, and autonomous behaviors.
The hardware includes a Raspberry Pi 4, mecanum wheels, TT motors, a 2D LiDAR, Raspberry Pi camera, and an IMU. The software stack is based on ROS 2 Jazzy, with RTAB-Map for SLAM, Nav2, and Foxglove integration.
I created Just1 as a simple, low-cost platform to experiment and to share with the community. Upcoming work focuses on simulation support (Gazebo / NVIDIA Isaac).
The learning curve for ROS2 can be steep, often requiring the installation and resolution of diverse software dependencies across operating systems, sensors, network configurations and robotic platforms. By combining virtual machines (VMs), with their off-the-shelf, ready-to-use environments resources and modern container registry workflows, we can reduce this complexity and enables learners to focus more directly on developing ROS2 skills. This approach also offers a smoother onboarding process for participants with varying levels of technical experience. In this talk, we share hands-on insights from our hackathon, which explored a distributed setup involving two servers located in different University College London (UCL) departments --Advanced Research Computing (ARC) and Civil, Environmental and Geomatic Engineering (CEGE)-- connected via a Zero Overhead Network Protocol (Zenoh) router with 10 GbE connectivity. One server from CEGE was connected to physical sensors --laser scanners, Inertial Measurement Units, and cameras-- with data streamed through the ROSBridge suite and Zenoh. On the ARC server and platforms (unified-AI and condenser), participants worked with off-the-shelf VMs and within containerised environments running ROS 2 Humble on Ubuntu 22.04. Five to ten participants accessed live sensor data via the ROSBridge Suite to visualise streams, perform object recognition and segmentation, and analyse outputs. They experimented with network constraints by varying sample rates, data types, and file sizes, and explored the trade-off between CPU usage for core ROS 2 packages and GPU demands for intensive tasks. Lessons on containerisation for virtual machines, managing dependencies, understanding latency and bandwidth, balancing resources, and cost considerations were shared, alongside next steps and a call for collaboration to advance ROS 2 skills and infrastructure in academia.
See the link to our hackathon for further details, the discussion forum, and ways to get involved: https://github.com/UCL-CyberPhysicalSystems/hackathon-01
Building localization and navigation systems requires a lot of time, effort and statistical analysis over multiple scenarios. There are multiple sparse tools out there to create specific KPIs around datasets but almost none that provide end to end integration test scenarios, KPIs and automatic report generation for localization systems. Last year, at FOSDEM, we presented beluga - https://github.com/Ekumen-OS/beluga - a Monte Carlo Localization Framework for robotics. This year, we would like to present one of the tools we built for this project, Lambkin, the Localization and Mapping BenchmarKINg system that allows to orchestrate test runs of your code, data, KPIs and report generation all in one platform. You can find the code here: https://github.com/Ekumen-OS/lambkin
ROS2’s interface generation can be a major bottleneck in the build process, especially for large projects. The rosidl toolchain, while reliable, is slow due to its Python-based code generation and inefficient use of CPU resources. rosidlcpp (https://github.com/TonyWelte/rosidlcpp) tackles these challenges by reimplementing the rosidl generators in C++. However, switching to C++ is only one of the ways rosidlcpp achieves faster builds. This talk will walk through the optimization journey behind rosidlcpp. We’ll cover how the build inefficiencies were diagnosed and the techniques used to address them.
More than two decades have passed since the first steps of the Gazebo simulator, one of the early attempts to provide a fully-featured 3D environment for robotics simulation. Rewritten into modular libraries, the new Gazebo preserved most of the internals from the previous era even if new features have been added continuously.
Meantime, especially in the last 5 years, the field of robotics simulation has experienced a rapid transformation. A new generation of simulators has emerged (Isaac Sim, O3DE, Carla, etc.) showing powerful rendering capabilities and advanced physics engines, supported by GPU acceleration to enhance realism and performance. These developments have not only changed the landscape of simulation, but have also created new opportunities for integrating AI, machine learning, and robotics in more complex and scalable virtual environments.
Are there any plans to push Gazebo into the modern features? The talk will provide information directly from one of the members of the Gazebo core team about existing roadmaps, funded projects, proof of concepts and any internal discussions on what could come for Gazebo in the future.
Rust offers many advantages for robotics. One key benefit is its memory safety, which helps prevent critical bugs in complex systems. Additionally, its high performance is essential for real-time applications, while safe concurrency allows for efficient parallel processing, crucial for multi-core robotic systems.
This talk will present rclrs (https://github.com/ros2-rust/ros2_rust), the Rust client library for ROS 2, and its accompanying tooling. rclrs is being developed in the open by a community of Rust and ROS enthusiasts. Support for Rust is now part of ROS 2 rolling and will be shipped in the next ROS 2 releases.
In this talk, we will discuss the open hardware and open-source software available today for creating open-source robots, taking the Upkie wheeled bipeds as our working example:
On the software side, we will go through the core robotics libraries used by the robots: Gymnasium, moteus, and PyBullet, as well as libraries for developing robot behaviors, such as Stable-Baselines3 for reinforcement learning and qpmpc for model predictive control. We will compare model-based and AI-driven approaches to implement new behaviors on Upkies, discussing what has worked and not worked so far, as well as future plans for the project like integrating vision for perceptive locomotion.
On the hardware side, we will describe how Upkies use mjbots actuators and PCB cards, which are fully open source (down to motor-driver firmware and KiCad electronics files!). Upkies can be built from off-the-shelf components for around $3,000, making experimentation with bipedal robots more accessible to hobbyists and educators. We will finally conclude by releasing version 2 of the robot hardware with an on-stage demonstration.
Building robots, whether industrial arms or autonomous vehicles, often comes with middleware pain that drains valuable engineering time. Issues like communication delays, execution inconsistencies, poor scalability, and nondeterministic behavior are common and frustrating. Most developers want to focus on their application, not on becoming middleware experts.
This talk introduces iceoryx2, the next generation of the widely used zero-copy middleware Eclipse iceoryx. It is written in Rust, with additional bindings for C, C++, Python, and C#, and runs on a variety of operating systems. iceoryx2 is already used in robotics, automotive, medical, finance, and other domains where high-throughput and low-latency communication are critical.
We will walk through common middleware pain points in robotic systems and show how iceoryx2’s architecture and feature set help eliminate or significantly reduce them.
Many ROS developers know PX4 exists but never get the chance to actually poke at it. This talk gives you that chance. We walk through a complete precision landing pipeline using PX4, ROS 2, OpenCV, Aruco markers, and Gazebo, built the same way we teach it in our hands on workshops.
We start with the pieces of the PX4 architecture that matter to you as a ROS developer, then show how the PX4 ROS 2 interface works, including the PX4 ROS 2 Library by Auterion that makes message handling feel familiar instead of foreign. From there we jump into simulation with Gazebo, run OpenCV based Aruco detection, and wire it all into a precision landing controller.
The heart of the session is practical. We take the tag pose produced by OpenCV in the camera optical frame, transform it into the body frame and world frame, and use it to run an approach phase with PI velocity control. We cover the spiral search pattern for when the tag is not visible, and the land detection feedback that lets the system finish the job safely.
To make it easy to try everything at home, we will provide a Docker container and an open repository with all the source code and configuration you need to reproduce the pipeline on your own machine.
If you have ever thought about connecting your ROS and OpenCV skills to PX4 but did not know where to start, this talk will get you there with a smile and a working example you can take home.
Have you ever wanted to build your own robot but felt overwhelmed by the complexity of dependencies, compilers, and unstable C++ code? Then why not use Rust? In this talk, we aim to convince you that ROS 2-Rust allows the creation of a state-of-the-art stack that is simple, safe, robust, memory-safe, and highly-performant, drastically reducing the time spent debugging runtime crashes. We will also show how to take advantage of Cargo, the Rust package manager, to ease dependency management.
In order to demonstrate our postulate, we have open-sourced a repository that allows everyone to create a minimal, teleoperable rover from scratch. This shows how ROS 2-Rust can further reduce the barrier to entry in the world of robotics.
This project also displays how we used Pixi to simplify the entire development workflow, allowing any developer to clone our open-source repository and achieve a fully working, cross-platform ROS 2 and Rust environment with just a single Pixi install command.
Join us to see how this modern toolchain transforms complex robotics projects into an accessible and enjoyable open-source experience. We aim to inspire you to start your own rover project and show that building your first robot is now as simple as that.
Simulation has evolved to be a key part of robotics development. Nevertheless, existing simulators such as Gazebo and O3DE tend to be time consuming to set up, computationally heavy and out of the box often simulate systems too idealistically, leading to systems that work in simulation but fail in the real world.
The new ROS 2 package vehicle_dynamics_sim aims to resolve this situation for the specific case of mobile platforms by providing an easy to configure and lightweight vehicle dynamics simulator focused on realistic actuator dynamics. It by default simulates real world imperfections such as dead time and acceleration limits, comes with six vehicle types (four bicycle/Ackermann + differential + omni/mecanum) and is fully configured through a minimum of ROS parameters. The two main use cases are trajectory following controller development and automated validation (CI).
ROS is a popular and widely used middleware, ecosystem, and environment for robotics development. It's become quite popular in research environments and for early prototyping, but it's not as common to see it in production environments. Why is that?
In this talk, I'll go over my experience productionising ROS in professional settings, what gaps ROS has, and how you all can avoid the pitfalls, issues, and hellholes I've dug myself into multiple times through my career. This will include ROS message serialisation and how to mesh it with other serialisation formats, how you can leverage Bazel to generate real ROS build artifacts with rules_ros2, and how to integrate all the above into a real robot in production with OTA updates.
ArduPilot is a trusted, versatile, and open source autopilot system supporting many vehicle types: multi-copters, traditional helicopters, fixed wing aircraft, boats, submarines, rovers and more. The source code is developed by a large community of professionals and enthusiasts. https://ardupilot.org/
ArduPilot is a well known autopilot for drones but it is often associated to only hobby or academic work. This talk will showcase some advanced features and integration of ArduPilot. The talk will present for each type of vehicle some interesting less known features and provide focused explanation on dual autopilot (or more) and advanced video feed usage with BlueOS (https://bluerobotics.com/what-is-blueos/).
This should give idea how far people can integrate and what crazy idea are possible with ArduPilot from hobbyist to industrial grade, all staying FOSS and documented, of course !
I won't speak about rockets nor GPS denied things. If time permits FROST quantum interoperability will be detailed.
What if you could build an autonomous, outdoor collaborative robot using free, open-source tools and community-driven software? That’s exactly what we did at Botronics. In this talk, we will take you behind the scenes of iXi, our autonomous golf trolley, showing how we use open-source technologies, from high level behaviors and control to simulation, fleet management, monitoring, and user interfaces, to build a real-world robotic system deployed outdoors.
You’ll see how tools like ROS 2, Gazebo, Nav2, BalenaOS, Docker, Telegraf, Grafana, Rviz2, and React/React Native come together into a production stack to deploy one of the first outdoor collaborative robots. More than just engineering talk, the objective is to provide a return of experience and lessons learned about what open-source robotics can enable outside the lab: reproducible development, remote deployment, full observability, and real user-facing applications.
If you are interested in taking robotics beyond prototypes, building autonomous systems that work in the real world, this session will show you what’s possible using open source stacks from end to end.
ROS 2 was designed to be independent of its underlying communication middleware — a powerful architectural feature, but one that introduces complexity and overhead.
While working on rmw_zenoh, we kept wondering: What if we streamlined the ROS 2 layers and built a Rust-native stack from Zenoh up to the RCL API? Could it improve performance? Would it be easier to extend? And could we still support existing RCL-C/C++/Python packages through C bindings?
This led us to develop ROS-Z, a Rust/Zenoh-native RCL stack, fully interoperable with ROS 2 via rmw_zenoh. In this talk, we’ll explore our design choices, share performance insights, and highlight the some of the unique features we’ve added to push innovation even further.
EasyNav is a fully open-source navigation framework for robots, designed to be lightweight, modular, and suitable for real-time execution. The project is motivated by the limitations of existing systems, which are tightly coupled to a single environment representation and often introduce unnecessary computational overhead. EasyNav decouples navigation from the underlying map structure, enabling costmaps, gridmaps, NavMap, or other models to be used interchangeably. Its architecture is built around a minimal core and open, extensible stacks that group controllers, planners, localizers, and map managers. The framework is designed to be easy to inspect, modify, and extend through its clear plugin interfaces. This talk will present the motivation, architecture, main features, and evaluation results in simulation and real robots, showing how an open-source approach improves flexibility, transparency, and performance in complex scenarios.
Links: - https://easynavigation.github.io - https://github.com/EasyNavigation/
AutoAPMS is a heavily extensible development framework for behavior-based ROS 2 applications. It provides a highly modular integration of behavior trees, implements a powerful execution engine and offers convenient CLI tooling for deploying behaviors with ease.
The intention of this project is to make it significantly more user-friendly and less error prone to develop autonomous robotics with behavior trees. The core packages are written in C++ and a supplementary Python API exposes high-level features for scripting.
The framework relies on the popular BehaviorTree.CPP library under the hood and offers a Nav2-agnostic approach for using it within the ROS 2 ecosystem. It was inspired by BehaviorTree.ROS2 and can be considered a spiritual successor. AutoAPMS took the core ideas of the behavior tree paradigm and supercharged it with the following features:
ament_cmake and ament_indexros2cli extension for working with the system directly from the command linePlotJuggler is an open source QT/C++ application that allow developers to visuale and analyze timeseries from logs, that it is very popular in the robotics and drones community.
It supports both static files and real-time streaming.
Its plugin-based architecture makes it easy to extend; this allowed people to add more and more formats, in terms of streaming transport (Websocked, MQTT, ZeroMQ, UDP, ROS2, etc.), serialization protocols (DDS, Protobuf, JSON, Proprietary) and file formats (rosbags, PX4 logs, CSV, Arrow Parquet, etc).
Furthermore, it includes a Lua-based data editor that allows the user to manipulate and transform data, effectively replacing the need for those "short-lived" Python scripts that people in this community would create to quickly analyze their data.
Its Github repository (https://github.com/facontidavide/PlotJuggler) is approaching its 10th anniversary, with 5.5K stars, 2500+ commits and 120+ contributors.