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:
- Tiny — The core code is compact (~2,000 lines of code), making it easy to understand and modify.
- Robust — Designed to work reliably across different scenes and real-world conditions.
- Multiple robot platforms — Aiming for "out-of-the-box" support for various robot types.
- 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:
- Clone the repository and run a check script to verify the environment
- Open the project in VS Code with the Dev Containers extension
- 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 controltinynav/cpp/— C++ backend for performance-critical operationstinynav/models/— Pretrained models and conversion scriptsscripts/— 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:
- High-optimization neural network models supporting real-time perception at ≥30 frames per second
- Improved map module consistency and accuracy
- 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