OmniNav

A General-Purpose Navigation Simulation Platform for Embodied AI

---

Table of Contents

1. What is OmniNav?
2. Key Features
3. Quick Installation
4. Quick Start
5. Architecture
6. Documentation
7. Contributing
8. License and Acknowledgments
9. Citation

What is OmniNav?

OmniNav is a general-purpose navigation simulation platform built on top of the Genesis physics engine, designed for Embodied AI / Robotics Navigation / Sim2Real applications. It is simultaneously multiple things:

1. A unified navigation benchmark for evaluating navigation and obstacle avoidance algorithms.
2. A plug-and-play algorithm framework supporting both classical planners and neural network-based methods (VLA/VLN).
3. A robot-agnostic platform with built-in support for quadruped, wheeled, and humanoid robots.
4. A high-fidelity simulation environment with GPU-accelerated physics and photo-realistic rendering.

OmniNav aims to:

• Simplify navigation research by providing a ready-to-use benchmark with standardized evaluation metrics.
• Bridge the Sim2Real gap with high-fidelity physics simulation and optional ROS2 integration.
• Accelerate algorithm development with a modular, extensible architecture.

Key Features

• 🚀 High Performance: Leverages Genesis engine for GPU-accelerated physics simulation (43M+ FPS on RTX 4090).
• 🔌 Plug-and-Play Algorithms: Easy integration of classical planners, RL policies, and VLA/VLN models.
• 📊 Built-in Evaluation: Pre-defined navigation tasks with standard metrics (SPL, Success Rate, Collision Rate).
• 🤖 Multi-Robot Support: Quadruped (Go2), wheeled robots, and extensible to other platforms.
• 🌐 ROS2 Compatible: Optional ROS2 bridge for Sim2Real deployment.
• 📦 Scene Import: Support for USD, GLB, OBJ, and custom scene assets.
• 🎨 Photo-Realistic Rendering: Ray-tracing based rendering for realistic visual observations.
• 🔧 Configuration-Driven: Hydra-based configuration for flexible experiment management.

Quick Installation

Prerequisites

• Python > 3.10 (Recommended: 3.13)
• CUDA-compatible GPU (recommended)
• PyTorch (see official instructions)

Install from Source

# Clone repository
git clone https://github.com/Royalvice/OmniNav.git
cd OmniNav

# Initialize Genesis submodule (Required)
git submodule update --init external/Genesis

# Initialize ROS2 submodule (Optional)
# git submodule update --init external/genesis_ros

# Create virtual environment
python -m venv .venv
.venv\Scripts\activate  # Windows
# source .venv/bin/activate  # Linux/macOS

# Install dependencies and OmniNav
pip install -r requirements.txt
pip install -e .

Quick Start

Basic Example

from omninav import OmniNavEnv

# Create environment with default configuration
env = OmniNavEnv(config_path="configs")
obs = env.reset()

# Run navigation loop
while not env.is_done:
    action = env.algorithm.step(obs)  # Or use your own algorithm
    obs, info = env.step(action)

# Get evaluation results
result = env.get_result()
print(f"Success: {result.success}")
print(f"SPL: {result.metrics.get('spl', 0):.3f}")

Using Custom Algorithm

from omninav import OmniNavEnv
import numpy as np

env = OmniNavEnv(config_path="configs")
obs = env.reset()

while not env.is_done:
    # Your custom navigation logic
    robot_pos = obs["robot_state"].position
    goal_pos = obs.get("goal_position", [5.0, 0.0, 0.0])
    
    # Simple proportional controller
    direction = np.array(goal_pos[:2]) - robot_pos[:2]
    cmd_vel = np.array([direction[0] * 0.5, direction[1] * 0.5, 0.0])
    
    obs, info = env.step(cmd_vel)

env.close()

Architecture

┌─────────────────────────────────────────────────────────────────┐
│                     Interface Layer                              │
│              Python API (OmniNavEnv) / ROS2 Bridge               │
├─────────────────────────────────────────────────────────────────┤
│       Evaluation Layer        │      Algorithm Layer             │
│    Tasks & Metrics (SPL...)   │   (Pluggable Algorithms)         │
├─────────────────────────────────────────────────────────────────┤
│                     Locomotion Layer                             │
│           Kinematic Control / RL Policy (Extensible)             │
├─────────────────────────────────────────────────────────────────┤
│       Robot Layer             │       Asset Layer                │
│   Go2 / Go2w / Custom Robots  │   Scene Loaders (USD/GLB/OBJ)    │
├─────────────────────────────────────────────────────────────────┤
│                      Core Layer                                  │
│              Genesis Simulation Manager Wrapper                  │
└─────────────────────────────────────────────────────────────────┘

Documentation

Comprehensive documentation is available at: https://royalvice.github.io/OmniNav/

• Getting Started: Installation and basic usage
• Tutorials: Step-by-step guides for common tasks
• API Reference: Complete API documentation
• Configuration Guide: Hydra configuration system

Contributing

The OmniNav project welcomes contributions from the community:

• Pull requests for new features or bug fixes
• Bug reports through GitHub Issues
• Suggestions to improve usability and documentation

License and Acknowledgments

OmniNav is licensed under the Apache-2.0 License.

OmniNav is built on top of these excellent open-source projects:

• Genesis - High-performance physics engine for Embodied AI
• Hydra - Framework for elegantly configuring complex applications
• OmegaConf - Hierarchical configuration system

Citation

If you use OmniNav in your research, please consider citing:

@misc{OmniNav,
  author = {OmniNav Contributors},
  title = {OmniNav: A General-Purpose Navigation Simulation Platform for Embodied AI},
  year = {2025},
  url = {https://github.com/Royalvice/OmniNav}
}