EasyNav: A Modular Architecture for Real-Time Navigation Across Heterogeneous Robot Environments

Francisco Martín Rico, Francisco Miguel Moreno, Juan Sebastián Cely Gutiérrez, Esther Aguado, Miguel Ángel De Miguel Paraíso, José Miguel GuerreroarXiv 2026 · arXiv

TL;DR

EasyNav is a modular navigation architecture for ROS 2 that replaces implicit data flows with an explicit, shared, and time-stamped "navigation state." By treating timing and frame consistency as first-class design constraints rather than emergent properties, it achieves a massive reduction in reaction latency (up to 90% faster than Nav2) while consuming significantly fewer CPU and memory resources.

What Problem Does This Paper Address?

Most modern robot navigation stacks, including the industry-standard Nav2, suffer from "architectural drift." As they integrate more complex sensors (3D LiDAR, GPS) and varied environment representations (2D costmaps, 3D meshes, semantic maps), the underlying data flows become tangled.

In these systems, timing and coordinate frame consistency are often "emergent"—meaning they depend on how the operating system happens to schedule various callbacks. This leads to two major issues:

  1. High Latency: A delay between a sensor detecting an obstacle and the controller reacting to it.
  2. Inconsistency: Components might process data that is geometrically or temporally mismatched, leading to navigation errors in dynamic or multi-level environments.

Methods

The authors introduce EasyNav, which organizes navigation around a strict separation of concerns and explicit data control. Key innovations include:

  • The NavState (Blackboard): Instead of components sending messages directly to each other, they interact exclusively through a shared, thread-safe blackboard. Every entry in this state is a tuple: (key, value, timestamp, frame). This ensures that any component reading the state knows exactly how "fresh" the data is and what coordinate system it belongs to.
  • Explicit Contracts: Components must formally declare which keys they read and write. This makes the pipeline "well-formed" and allows for easy swapping of modules (e.g., swapping a 2D planner for a 3D one) as long as they satisfy the state's requirements.
  • RTTFBuffer: A dedicated real-time transformation buffer. Unlike standard ROS 2 TF listeners that can introduce delays while waiting for transforms to be published, this buffer ensures immediate availability for internally generated transforms.
  • Reactive Scheduling: EasyNav uses a "trigger propagation" model. When new sensor data arrives, it can trigger downstream components (like the controller) to run immediately, overriding their nominal execution rates to improve reaction time.

Datasets

The architecture was validated using real-world robotic experiments rather than static datasets:

  • Indoor Scenario: A TurtleBot 4 navigating a structured environment with narrow passages using 2D LiDAR and costmaps.
  • Outdoor Scenario: A Summit XL robot traversing a 2.75km route across a university campus using 3D LiDAR, GPS, and IMU.
  • Heterogeneous Setup: Tests involving multi-level surfaces and non-planar maps to demonstrate the architecture's ability to handle diverse environment representations simultaneously.

Key Insights and Ideas

  • Timing as a Design Objective: The biggest "aha" moment is that determinism shouldn't be left to the middleware's scheduler. By baking validity timestamps into the shared state, EasyNav ensures that navigation decisions are only made using temporally consistent data.
  • Decoupling via State, Not Interfaces: By focusing on a shared state rather than shared interfaces, the system becomes representation-agnostic. A planner doesn't care if the "map" is a grid or a mesh, as long as it can find the data it needs in the NavState.
  • Monolithic Execution for Efficiency: While modular in design, EasyNav runs as a single monolithic process. This eliminates the overhead of inter-process communication (IPC) that often plagues distributed ROS 2 setups.

Key Results

The performance gains over Nav2 (under matched conditions) are substantial:

  • Reaction Latency:
    • Indoors: Reduced from 377 ms to 33 ms.
  • Outdoors: Reduced from 71 ms to 8 ms.
  • Computational Efficiency:
    • CPU Usage: EasyNav showed a mean reduction of ~11-17 percentage points in CPU utilization.
  • Memory: In outdoor trials, EasyNav used only 93.83 MB of RAM compared to Nav2’s 249.7 MB.
  • Command Freshness: EasyNav consistently computed new velocity commands at the full nominal rate (e.g., 60Hz), whereas Nav2 often resorted to republishing old commands to maintain the publication frequency.

Limitations and Future Work

  • Ablation Studies: The paper presents the combined results of the new architecture. The authors note that they haven't yet isolated the specific contribution of the perception-triggered execution mechanism versus the shared state itself.
  • Heterogeneous Characterization: While they qualitatively demonstrated the use of multiple map types (like NavMap meshes), a rigorous quantitative evaluation of how different representations interact and impact performance is left for future research.
  • Tooling: The authors suggest that future work should include automated tools to check the "well-formedness" of navigation pipelines at assembly time based on the declared read/write keys.

Summary updated

Abstract

Most robot navigation stacks implicitly bind mapping, localization, planning, and control to specific representations and data flows, yielding architectures hard to extend, compare experimentally, or reason about end-to-end timing. This is critical in heterogeneous scenarios, where multiple spatial representations, sensing modalities, and coordinate frames coexist and evolve at different rates. This paper presents a navigation architecture centered on an explicit, shared navigation state that serves as the sole interaction interface between modular components. Constraining mapping, localization, planning, and control to operate over this shared state enables interchangeable, representation-agnostic pipelines under explicit compatibility and timing contracts. We realize this architecture as EasyNav, an open source ROS 2 framework, and validate it through real-robot experiments, including indoor navigation with laser sensing and large-scale indoor-outdoor navigation with GPS and 3D LiDAR across multi-level routes. Compared with Nav2 under matched conditions, EasyNav reduces reaction latency from 377 to 33 ms indoors and from 71 to 8 ms outdoors, while also using less CPU and memory.
BibTeX
@misc{rico2026easynav,
  author = {Francisco Martín Rico and Francisco Miguel Moreno and Juan Sebastián Cely Gutiérrez and Esther Aguado and Miguel Ángel De Miguel Paraíso and José Miguel Guerrero},
  title = {{EasyNav: A Modular Architecture for Real-Time Navigation Across Heterogeneous Robot Environments}},
  year = {2026},
  eprint = {2611.19894},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.19894},
}
Figure