UniflexAI/tinynav

TinyNav: A lightweight, hackable system to guide your robots anywhere.

TinyNav — A lightweight robot navigation system

TinyNav is an open-source project that helps robots figure out where they are and how to get where they need to go. The README describes it as "a lightweight, hackable system to guide your robots anywhere." It's maintained by a group called Uniflex AI.

What it does

TinyNav gives robots map-based navigation: the robot builds a map of its surroundings, figures out its position within that map (called relocalization), and then plans a path to a destination. The system handles the full pipeline:

  • Perception — processing sensor data (cameras, IMU) to understand the environment
  • Mapping — building and updating the map
  • Planning — computing paths and trajectories
  • Control — sending commands to the robot's motors

Supported hardware

The README lists two robot platforms as the initial focus:

  • Unitree GO2 — a quadruped robot (four-legged)
  • LeKiwi — a wheeled robot

It also supports two camera types:

  • Intel RealSense — a common depth camera
  • Looper — a newer camera that has built-in depth sensing and visual-inertial odometry (VIO), which helps the robot track its motion

For computing hardware, it runs on Jetson Orin (NVIDIA's embedded AI platform) and desktop PCs, with plans to support cheaper platforms like RK3588.

Design goals

The project has four stated goals:

  1. Tiny — The core code is compact (~2,000 lines of code), making it easy to understand and modify.
  2. Robust — Designed to work reliably across different scenes and real-world conditions.
  3. Multiple robot platforms — Aiming for "out-of-the-box" support for various robot types.
  4. Multiple chip platforms — Supporting different computing hardware for broader accessibility.

Key features (from version history)

v0.1 (initial release):

  • Map-based navigation with relocalization and global planning
  • Unitree and LeKiwi robot support
  • Upgraded stereo depth model
  • Tuned RealSense exposure for robotics
  • Gazebo simulation environment
  • Docker image build pipeline

v0.2 added:

  • 3D Gaussian Splatting (3DGS) map representation — a way to visualize maps with high quality and an intuitive editor
  • ESDF-based obstacle avoidance — robots not only avoid obstacles but keep a safe distance
  • Localization benchmark — a standard test to measure improvements
  • CUDA graph optimization — runs at over 20Hz on Jetson Nano, reducing latency
  • Maps stored using a key-value database (shelve) for better performance
  • Over 50 pull requests merged

v0.3 added:

  • IMU-visual fusion — combining inertial measurement data with camera data to improve pitch-angle accuracy
  • Resilient mapping — handles lost messages gracefully, with a redesigned visualization tool
  • Unified model training — a single neural model that handles both perception and planning tasks
  • Improved C++ code quality checks (clang-tidy, Address Sanitizer)

Optional feature: FlexGlue matcher

By default, TinyNav uses a feature-matching algorithm called LightGlue for mapping and relocalization. There's an optional alternative called FlexGlue that's slower but may be useful in certain cases. The README includes benchmark tables showing LightGlue is much faster (e.g., 9.9 ms vs 502.2 ms for a single pair match), but FlexGlue has different consistency characteristics.

How to run it

Prerequisites: git, git-lfs, Docker, and either the NVIDIA Container Toolkit (for PCs) or JetPack SDK 6.2+ (for Jetson Orin).

Quick start:

  1. Clone the repository and run a check script to verify the environment
  2. Open the project in VS Code with the Dev Containers extension
  3. Run a demo script that plays a recorded dataset (ROS bag file) and shows the robot's planning in real time using RViz (a visualization tool)

The demo script streams a pre-recorded dataset, runs the perception and planning modules, and displays the robot's state and planned trajectory.

Project structure

The code is organized into:

  • tinynav/core/ — Python modules for perception, mapping, planning, and control
  • tinynav/cpp/ — C++ backend for performance-critical operations
  • tinynav/models/ — Pretrained models and conversion scripts
  • scripts/ — Shell scripts for demos, Docker management, and data recording

Code size

The README includes a line-of-code table showing roughly 2,660 total lines across all files, with about 1,959 lines of Python, 292 lines of C++, and smaller amounts of shell scripts, Dockerfiles, and config files.

Community and support

  • Bounty program — The project offers paid tasks; a spreadsheet lists available bounties and rewards.
  • Contributors — Five people are listed as code contributors.
  • Sponsors — DeepMirror and Looper Robotics support the project.
  • Contact channels — Discord server and X (Twitter) account are linked.

What's planned next

The README lists three future goals:

  1. High-optimization neural network models supporting real-time perception at ≥30 frames per second
  2. Improved map module consistency and accuracy
  3. End-to-end trajectory planning with integrated semantic information

In plain terms

TinyNav is a compact, open-source "brain" for robots that need to navigate. It takes camera and sensor data, builds a map, figures out where the robot is, and plans a safe path — all in a small enough codebase that developers can easily modify it. It's designed to work with specific off-the-shelf robots (a four-legged Unitree and a wheeled LeKiwi) and runs on NVIDIA's embedded hardware, with a focus on being fast enough for real-time operation.

Related

  • Project
  • Project
  • Project
  • Project
  • Project