Robot navigation is the technology of planning a path from the current position to a goal on a map, then following it while avoiding obstacles. A classical pipeline like Nav2 — the one newbot uses — remains the mainstream choice in practice, while research into end-to-end approaches built on reinforcement learning and Vision-Language models is expanding fast.

ROS 2ROS 2 / Nav2

Image: Robot Operating System logo, Wikimedia Commons (CC BY-SA 4.0)

The Classical Pipeline: Separating the Costmap from Path Planning

A classical navigation stack, epitomized by Nav2, builds a costmap (a 2D map representing obstacle risk) from sensor data, then runs global path planning and local trajectory following as separate modules on top of it. Each module's role is clear, and the resulting behavior is easy for a person to understand and tune, but its ability to adapt to an unanticipated environment (an unfamiliar obstacle shape, a dense crowd) has real limits. newbot also uses this classical pipeline — see "How Mapping and Autonomous Navigation Work" for implementation details.

The Underlying Kinematics: Differential-Drive Velocity Conversion

Whatever navigation method is used, what a controller ultimately outputs comes down to a pair of values: translational velocity v and angular velocity \omega. For a differential-drive robot like newbot (two wheels, left and right), the foundation underneath is the kinematic model that converts this pair into left/right wheel speeds v_l, v_r.

v = \frac{v_r + v_l}{2}, \qquad \omega = \frac{v_r - v_l}{L}

L is the distance between the left and right wheels (the tread width). The inverse transform is used to go the other way — from a planned (v, \omega) to a target speed for each wheel. This simple pair of equations captures the fundamental constraint of differential drive itself (no sideways movement; turning always requires a speed difference between the wheels) — no matter how sophisticated the costmap or path planning gets, the motors are ultimately driven through this kinematic model. newbot's implementation is also covered in "How Safe Velocity Control Works."

Inside Nav2: Costmap, Controller, Behavior Tree

Looking a bit more concretely at how the modules inside the classical pipeline cooperate: Nav2 builds its costmap (a 2D map representing obstacle risk) by stacking multiple "layers." A layer reflecting static map data, a layer that detects and tracks dynamic obstacles from camera or depth-sensor data, a layer that rewrites the costmap based on rules — stacking layers with different roles like this lets a variety of information sources, more than any single algorithm could represent on its own, get integrated into one map representation.

The controller_server, responsible for following the path, drives the robot along the most recently planned global path, referencing the local costmap while also working with supporting plugins — a progress checker and a goal checker. The behavior_server, which handles recovery behaviors (rotating in place, backing up), is designed to reference the same local costmap as the controller_server in real time, an efficient setup that avoids holding a duplicate environment-representation object in more than one place.

What controls the order and conditions under which these individual servers get called is the Behavior Tree. Nav2 uses a library called BehaviorTree.CPP, where a tree-structured node, each time it's "ticked" (triggered to execute), calls into an action server — the planner, the controller, a behavior server. This design lets complex branching logic — "if path planning fails, retry up to N times before switching to a different recovery behavior" — get rearranged purely through the Behavior Tree's configuration, without touching any individual server's code.

The Spread of End-to-End Learned Navigation

The current running counter to the classical pipeline is end-to-end, learning-based navigation that outputs actions directly from raw sensor input. In realistic cooperative scenes like passing through a door, some reports show learning-based methods outperforming model-based ones, and deep reinforcement learning (DRL) has become one of the major trends in ROS-based navigation research. Algorithms like TD3 (Twin-Delayed DDPG), DDPG, and DQN have been applied to real-time object detection, tracking, and navigation, and hybrid methods that combine imitation learning (learning an initial policy from expert demonstrations) with reinforcement learning (continuously improving that policy) have also emerged.

The Direction of Navigation Foundation Models

A newer current is the attempt to train navigation itself as a "foundation model." A framework that combines offline video pretraining with post-training via reinforcement learning in simulation (S2E: Seeing-to-Experiencing) is designed to strengthen interactivity while preserving generalization performance. Research folding Vision-Language models into navigation (Navi2Gaze, for example) is also progressing, exploring a direction where the navigation target is specified not by coordinates on a map but by natural language or a goal image (this overlaps with the VLA field too — see "Technology Trends in VLA" for details).

Social Navigation

For an indoor robot operating in an environment where people are moving around, taking a "human-like" path — not just avoiding obstacles — has become an important research theme in its own right. In the social-navigation field, three challenges are typically identified as the main research problems: models that can accurately predict human movement, learning environments that realistically simulate crowded settings, and evaluation metrics that can capture the complexity of the real world. Active research combines multiple families of reinforcement-learning algorithms — value-based, policy-based, actor-critic — with a range of neural network architectures — feedforward, recurrent, convolutional, graph, transformer.

Concrete Results from Learning-Based Navigation: 2026 by the Numbers

Research through 2026 has increasingly backed claims with concrete numbers rather than vague "improved performance." CORE Planner (June 2026), which explores unknown environments with no prior map, combines a sparse visibility-graph representation with a transformer and reports a 13% reduction in travel distance over the traditional FAR Planner and up to 48% over other learning-based baselines, while also achieving zero-shot sim-to-real transfer with no additional training. FlashNav (June 2026), which dramatically cuts training time itself, strips unnecessary rendering and high-fidelity physics out of the simulation and runs a GPU-resident training pipeline, reaching a 100% success rate with policy training completed in under 20 seconds on an RTX 5090 — and it successfully transfers the trained policy to physical robots.

Quantitative progress is showing up in social navigation too. HUMA (July 2026), a hybrid approach that selectively activates VLM (Vision-Language Model) reasoning only when people are nearby while otherwise relying on the computational efficiency of a reinforcement-learning policy, reports task-success improvements of 20% and 3% on the Social-MP3D and Social-HM3D benchmarks, respectively. The key design decision isn't "always run the expensive reasoning" but "run it only when it's actually needed" — a choice that reconciles the tradeoff between accuracy and compute cost.

Navigation Foundation Models Getting Concrete: VLN Implementation Examples

The "navigation foundation model" direction (S2E and the like) has crystallized into more concrete implementations through 2026. SuperMap (August 2026, accepted at RSS 2026) integrates high-frequency geometric SLAM with asynchronous open-vocabulary perception to build a 4D scene graph (space plus time) that supports compositional queries over object semantics and relationships. It's designed to maintain stable object identity — matching and re-recognizing objects in 3D space — even in dynamic environments, and it functions as a foundation for robot navigation driven by natural-language instructions.

A lighter-weight example is GemNav (July 2026), which adapts a frozen, pretrained multimodal LLM to handle waypoint navigation via discrete tokens. It needs no dedicated visual encoder, and it's positioned as a "data-efficient alternative" — achieving zero-shot transfer to unseen indoor and outdoor environments from a small amount of training data, without fully fine-tuning a large foundation model. There's also an offline Vision-Language Navigation approach (July 2026) that runs entirely on-device with no cloud dependency, combining open-vocabulary object detection, prompt-based segmentation, and LiDAR geometry to estimate outdoor goal locations using nothing but a small language model. Taken together, these point to "navigation you instruct in natural language" moving from a research topic toward something actually implemented.

Where Things Stand in Practice

Right now, none of this is at the point of replacing a classical pipeline like Nav2. Learning-based methods show strong results in research settings, but the cost of verifying reproducibility and safety on real hardware is high, and deployment into production and mass use remains limited. newbot's own design — a classical path planner paired with an independent safety-supervision layer, including a physical kill switch (see "How Safe Velocity Control Works" for details) — can be read as a reflection of the field's practical state of the art. Even as learning-based methods move toward practical use, the realistic choice, at least for the foreseeable future, looks to be a hybrid built around classical safety mechanisms.

References

#Navigation #Reinforcement Learning #Nav2