NeuPAN: Direct Point Robot Navigation with End-to-End Model-based Learning

Table of Contents

• News
• Introduction
• Demonstrations
• Why NeuPAN
• Quick Start
• Examples
• Configuration
• Advanced Usage
  • DUNE Model Training
  • ROS Integration
  • Real World Deployment
• Current Limitations
• FAQ
• License
• Citation

News

• 2025-12-25: Our NeuPAN planner is integrated into the odin-nav-stack project, feel free to try it out!
• 2025-04-24: We provide the python 3.8 compatible NeuPAN version available on py38 branch.
• 2025-03-26: Available on IEEE Transactions on Robotics.
• 2025-03-25: Code released!
• 2025-02-04: Our paper is accepted by T-RO 2025!

Introduction

NeuPAN (Neural Proximal Alternating-minimization Network) is an end-to-end, real-time, map-free, and easy-to-deploy MPC based robot motion planner. By integrating learning-based and optimization-based techniques, NeuPAN directly maps obstacle points data to control actions in real-time by solving an end-to-end mathematical model with numerous point-level collision avoidance constraints. This eliminates middle modules design to avoid error propagation and achieves high accuracy, allowing the robot to navigate in cluttered and unknown environments efficiently and safely.

Demonstrations

More real world demonstrations are available on the project page.

https://github.com/user-attachments/assets/7e53b88c-aba9-4eea-8708-9bbf0d0305fc

https://github.com/user-attachments/assets/e37c5775-6e80-4cb5-9320-a04b54792e0e

https://github.com/user-attachments/assets/71eef683-a996-488f-b51b-89e149d0cc6e

https://github.com/user-attachments/assets/fb3f2992-da00-4730-872f-8f3bb8b29163

Why NeuPAN

Quick Start

Requirements: Python >= 3.10

# Install NeuPAN
git clone https://github.com/hanruihua/NeuPAN
cd NeuPAN
pip install -e .

# Install IR-SIM for running examples
pip install ir-sim

# Run your first example
cd example
python run_exp.py -e corridor -d diff

IR-SIM Examples

You can run examples implemented on IR-SIM in the example folder to see the navigation performance of diff (differential), acker (ackermann) and omni (Omnidirectional) robot powered by NeuPAN in IR-SIM. Scenarios include:

• convex_obs (convex obstacles)
• corridor (corridor)
• dyna_non_obs (dynamic nonconvex obstacles)
• dyna_obs (dynamic obstacles)
• non_obs (nonconvex obstacles)
• pf (path following)
• pf_obs (path following with obstacles)
• polygon_robot (polygon robot)
• reverse (car reverse parking)
• dune training
• LON training

Some demonstrations run by run_exp.py are shown below:

python run_exp.py -e non_obs -d acker	python run_exp.py -e dyna_non_obs -d acker
python run_exp.py -e polygon_robot -d diff	python run_exp.py -e dyna_obs -d diff -v
python run_exp.py -e corridor -d acker	python run_exp.py -e corridor -d diff
python run_exp.py -e dyna_non_obs -d omni	python run_exp.py -e dyna_obs -d omni

[!NOTE] The pretrained DUNE model provided in these examples are trained under the size of the robot. If you adjust the size of the robot, you must retrain the DUNE model by referring to the DUNE Training example.

[!NOTE] Since the optimization solver cvxpy is not supported on GPU, we recommend using the CPU device to run the NeuPAN algorithm. Thus, the hardware platform with more powerful CPU (e.g. Intel i7) is recommended to achieve higher frequency and better performance. However, you can still use the GPU device to train the DUNE model for acceleration.

Configuration

Since there are quite a lot of parameters setting for the Neupan planner, we provide a YAML file to initialize the parameters in NeuPAN.

Advanced Usage

DUNE Model Training

To train a DUNE model for your own robot with a specific convex geometry, you can refer to the example/dune_train folder. Specifically, the convex geometry is defined in the robot section by the vertices (or length and width for rectangle) when the robot is in the initial state (coordinate origin). The training parameters can be adjusted in the train section.

[!NOTE] The DUNE model only needs to be trained once for a new robot geometry. This trained model can be used in various environments without retraining.

ROS Integration

We provide a ROS wrapper for NeuPAN. You can refer to the neupan_ros repo to see the details. The Gazebo demonstrations are shown below:

https://github.com/user-attachments/assets/1d5eb028-0d22-4741-8899-40a3ea7caab4

Real World Deployment

• You can easily deploy the NeuPAN algorithm on a real robot platform using neupan_ros. Currently, NeuPAN supports the kinematics of differential drive robots, Ackermann robots and omni-directional robots (see the robot section in the YAML file). For robots with other kinematics, you can modify the constraints in the NRMP layer to suit your needs.

• The DUNE model trained in simulation can be directly applied in the real world without retraining.

• NeuPAN solves the mathematical optimization problem in real time. Thus, its performance is influenced by three main factors: 1) the computing power of the CPU-based hardware platform; 2) the adjustment of the parameters in the adjust section; and 3) the naive initial path provided by the user.

• We recommend using a hardware platform with a powerful CPU to enable NeuPAN to run at a control frequency higher than 10 Hz. You can run the provided examples to observe the forward time cost of NeuPAN. To reduce this cost, adjust parameters such as receding, nrmp_max_num, dune_max_num, iter_num, and iter_threshold to make NeuPAN run faster. In our experience, an Intel i7 CPU is capable of running NeuPAN at a control frequency higher than 15 Hz.

• The adjust parameters are used to tune the weights of the state cost, speed cost, and collision avoidance cost. These parameters influence NeuPAN's behavior, making it either more aggressive or more conservative. You can adjust or train these parameters to achieve better performance for your specific workspace. Additionally, these parameters can be fine-tuned in real time for different scenarios.

• The naive initial path can be generated from the provided waypoints or derived from a global planner like A* without accounting for obstacles. This path serves as a simple, rough initial guess for NeuPAN. We offer functionality to generate the initial path from given waypoints as either:

  • direct lines for differential drive robots,
  • Dubins' paths for forward Ackermann vehicles, or
  • Reeds-Shepp paths for forward and backward Ackermann vehicles.

Current Limitations

• CPU-bound optimization: The NRMP layer uses cvxpy which does not support GPU acceleration, so inference speed depends on CPU performance.
• Supported kinematics: Currently limited to differential drive, Ackermann, and omnidirectional robots. Other kinematics require modifying the NRMP constraints.
• Convex robot geometry: The DUNE model assumes convex robot shapes. Non-convex robots need to be approximated by convex hulls.
• Parameter tuning: Performance in specific environments may require tuning the adjust parameters for optimal results.

FAQ

If there are any technical issues, please feel free to open an issue or contact me (hanrh@connect.hku.hk). Contributions to make this project better are also welcome.

License

This project is licensed under the GNU General Public License v3.0.

Citation

If you find this code or paper is helpful, please kindly star :star: this repository and cite our paper by the following BibTeX entry:

@ARTICLE{10938329,
  author={Han, Ruihua and Wang, Shuai and Wang, Shuaijun and Zhang, Zeqing and Chen, Jianjun and Lin, Shijie and Li, Chengyang and Xu, Chengzhong and Eldar, Yonina C. and Hao, Qi and Pan, Jia},
  journal={IEEE Transactions on Robotics},
  title={NeuPAN: Direct Point Robot Navigation With End-to-End Model-Based Learning},
  year={2025},
  volume={41},
  number={},
  pages={2804-2824},
  doi={10.1109/TRO.2025.3554252}}

For using IR-SIM platform, please consider citing the following paper:

@article{han2026ir,
  title={IR-SIM: A Lightweight Skill-Native Simulator for Navigation, Learning, and Benchmarking},
  author={Han, Ruihua and Wang, Shuai and Li, Chengyang and Gao, Rui and Wang, Xinyi and Liu, Zhe and Li, Guoliang and Lu, Yupu and Hao, Qi and Pan, Jia and Zhao, Hengshuang},
  journal={arXiv preprint arXiv:2606.08729},
  year={2026}
}