SuperSLAM: Accurate Real-Time SLAM with Deep Learned Features

Alpha software.

SuperSLAM is a real-time stereo and RGB-D visual SLAM system. SuperPoint detects features and LightGlue matches them on a TensorRT FP16 backend, with a GTSAM optimization core and pose-graph loop closure.

Results

Run on an NVIDIA RTX PRO 1000 (Blackwell, laptop, 8 GB) with an Intel Core Ultra 5 235H, TensorRT 10.11, CUDA 12.9, FP16. fps is the per-frame tracking rate (front-end plus window smoother); every sequence runs above its camera rate (KITTI 10 Hz, EuRoC 20 Hz, TUM 30 Hz). ATE is SE3-aligned RMSE. Per-sequence trajectory plots are in PLOTS.md.

KITTI (stereo, window 10)

seq	ATE RMSE (m)	ATE mean (m)	RPE RMSE (m)	t_rel (%)	r_rel (deg/m)	fps
00	1.582	1.238	0.398	0.76	0.0034	79
01	375.893	340.771	2.607	46.10	0.0322	48
02	7.908	5.945	0.395	1.02	0.0034	71
03	2.291	1.687	0.290	4.66	0.0153	79
04	0.646	0.575	0.121	0.72	0.0012	72
05	4.187	2.719	0.438	1.19	0.0046	71
06	2.222	1.954	0.468	1.56	0.0079	68
07	15.857	8.421	3.935	6.51	0.0356	77
08	6.946	5.897	0.286	1.34	0.0047	73
09	3.991	3.626	0.095	1.80	0.0065	71
10	2.113	1.745	0.089	0.79	0.0063	78

Sequence 01 is the highway: distant features give no parallax, scale drifts, and the run diverges (a known failure for feature SLAM).

EuRoC (stereo)

seq	ATE RMSE (m)	ATE mean (m)	ATE max (m)	RPE RMSE (m)	fps
MH_01_easy	0.059	0.048	0.225	0.910	145
MH_02_easy	0.067	0.062	0.133	0.848	87
MH_03_medium	0.104	0.092	0.257	1.155	23
MH_04_difficult	0.253	0.243	0.416	1.187	44
MH_05_difficult	0.090	0.070	0.608	1.126	158
V1_01_easy	0.102	0.094	0.184	0.913	182
V1_02_medium	0.068	0.062	0.161	0.998	158
V1_03_difficult	0.126	0.103	0.585	0.890	173
V2_01_easy	0.093	0.079	0.300	0.697	162
V2_02_medium	0.129	0.110	0.405	0.892	122
V2_03_difficult	diverged				186

TUM RGB-D

Standard

seq	ATE RMSE (m)	ATE mean (m)	ATE max (m)	RPE RMSE (m)	fps
fr1_desk	0.079	0.067	0.171	0.068	64
fr2_xyz	0.013	0.012	0.045	0.025	141
fr3_long_office_household	0.044	0.041	0.104	0.027	179

Dynamic (moving people)

seq	ATE RMSE (m)	ATE mean (m)	ATE max (m)	RPE RMSE (m)	fps
fr3_sitting_static	0.030	0.022	0.080	0.017	119
fr3_sitting_xyz	0.060	0.053	0.171	0.074	112
fr3_sitting_rpy	0.070	0.042	0.381	0.096	111
fr3_sitting_halfsphere	0.088	0.066	0.308	0.128	107
fr3_walking_static	0.266	0.183	0.893	0.494	87
fr3_walking_halfsphere	0.436	0.360	1.232	0.521	91
fr3_walking_xyz	0.525	0.374	1.492	0.494	77
fr3_walking_rpy	0.682	0.570	1.337	0.550	88

Low-motion (sitting) sequences hold; high-motion (walking) sequences degrade, as for any feature SLAM without explicit dynamic-object handling.

TartanAir (stereo)

seq	ATE RMSE (m)	ATE mean (m)	RPE RMSE (m)	fps
P000	0.225	0.185	1.425	165
P001	0.575	0.551	1.300	154
P002	0.217	0.133	1.524	147
P003	0.068	0.061	1.698	145
P004	0.098	0.075	1.698	141
P005	0.605	0.436	1.247	139
P006	0.813	0.637	1.937	157

The KITTI segment metric (t_rel) is undefined here: TartanAir trajectories are too short for the 100-800 m segments.

TartanGround (stereo)

seq	ATE RMSE (m)	ATE mean (m)	RPE RMSE (m)	t_rel (%)	fps
P0000	2.582	1.934	1.505	20.58	98
P0001	0.290	0.238	1.408	22.36	115
P0002	1.346	1.134	1.484	24.82	109
P0003	0.400	0.254	1.444	17.73	127
P0004	0.969	0.821	1.552	16.98	96

Quick start

Install the command-line tools (Ubuntu):

sudo apt install git make docker.io nvidia-container-toolkit gh
curl -LsSf https://astral.sh/uv/install.sh | sh        # uv, the Python tool runner

Then, from a fresh clone on a machine with an NVIDIA GPU:

make build-image-tensorrt10                                        # container (Ubuntu 24.04, TensorRT 10)
uv run python scripts/models/download_onnx_engine_superpoint.py    # prebuilt ONNX models (~90 MB)
uv run python scripts/models/download_onnx_engine_lightglue.py
uv run python scripts/models/download_onnx_engine_eigenplaces.py
make build-engines-tensorrt10                                      # TensorRT engines for this GPU
make build-superslam                                               # compile SuperSLAM

uv run python scripts/datasets/download_kitti.py --out ~/datasets/kitti
make run-superslam-kitti                                           # writes results/kitti/00.txt
make evaluate-superslam-kitti                                      # ATE and RPE

make help lists every target. Every Python step runs through uv, which builds a throwaway environment, so nothing is installed globally.

conda or pipx, Docker Compose version, bare-metal dependencies

uv via conda or pipx:

conda install -c conda-forge git make gh uv
pipx install uv

Docker Compose v2 2.30 or newer is required for the gpus: key in compose.yaml. Check with docker compose version. On an older Compose, edit compose.yaml: comment out gpus: all and uncomment the deploy: block.

A bare-metal build (no Docker) also needs CUDA 12.9, TensorRT 10.11, cuDNN 9, and the C++ libraries. One script installs them:

bash scripts/setup/install_dependencies.sh        # Ubuntu 22.04 or 24.04

Usage

# Datasets, downloaded into ~/datasets/<name>
uv run python scripts/datasets/download_kitti.py --out ~/datasets/kitti
uv run python scripts/datasets/download_euroc.py --out ~/datasets/euroc --area machine_hall
uv run python scripts/datasets/download_tum.py   --out ~/datasets/tum --seq fr2_xyz

# Run, writing the trajectory into results/<dataset>/
make run-superslam-kitti SEQUENCE=00
make run-superslam-euroc EUROC=MH_01_easy
make run-superslam-tum   TUM=rgbd_dataset_freiburg2_xyz

# Evaluate: ATE and RPE
make evaluate-superslam-kitti
make evaluate-superslam-euroc
make evaluate-superslam-tum

Per-dataset tuning knobs (window size, loop thresholds, and others) live in the dataset YAML under examples, in the Backend, Tracking, and loop sections. Each knob also reads a SUPERSLAM_* environment variable; precedence is the environment variable, then the YAML value, then the default.

The GTSAM optimization core builds and tests without a GPU:

make test-superslam

TensorRT 10 or 11, other GPUs, bare-metal build, cleaning

TensorRT 10 or 11. TensorRT 10 is the default and tested path. For 11:

make build-image-tensorrt11
make build-engines-tensorrt11

An engine built for one TensorRT version does not load under the other, so rebuild the engines after switching. TensorRT 10 or newer is required for LightGlue (opset-18 ONNX).

Other GPUs. The code targets Ampere (sm_86), Ada (sm_89), and Blackwell (sm_120). To move to a different NVIDIA GPU, rebuild the engines (they are GPU-architecture specific):

make build-engines-tensorrt10 && make build-superslam

Bare-metal (no Docker).

bash scripts/setup/install_dependencies.sh
source ~/.bashrc
cmake -S . -B build-tensorrt -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_CUDA_ARCHITECTURES="86;89;120"
cmake --build build-tensorrt -j"$(nproc)"
bash scripts/rebuild_engines.sh
./examples/kitti examples/stereo/KITTI00-02.yaml ~/datasets/kitti/dataset/sequences/00 --no-viewer

Cleaning. make clean-engines, clean-weights, clean-build, clean-results, clean-images, or clean-all. Every target is safe to re-run.

The .onnx.data sidecar, and publishing models

.onnx.data. Some models ship as a pair: model.onnx holds the graph, and model.onnx.data holds the large weight tensors. LightGlue and EigenPlaces are stored this way, so both files must sit in weights/ together. The download scripts fetch the sidecar automatically. The SuperPoint ONNX has inline weights and no .data file.

Publishing the prebuilt ONNX (maintainers). The download scripts pull from a GitHub Release. Name each release weights-<YYYYMMDDHHMMSS> and point the downloaders at it by setting DEFAULT_TAG in scripts/models/_release.py:

TAG="weights-$(date +%Y%m%d%H%M%S)"
gh release create "$TAG" weights/superpoint_dense_dynamic_batch.onnx \
  weights/lightglue_superpoint.onnx weights/lightglue_superpoint.onnx.data \
  weights/eigenplaces_resnet18_512.onnx weights/eigenplaces_resnet18_512.onnx.data

To regenerate the ONNX from source, see scripts/models/download_weights_*.py and the converters in utils.

Citation

@software{wagh_superslam,
  author = {Wagh, Aditya},
  title  = {SuperSLAM: Accurate Real-Time SLAM with Deep Learned Features},
  year   = {2026},
  url    = {https://github.com/adityamwagh/SuperSLAM}
}

License

Licensed under the LGPL. For questions or issues, open an issue on GitHub.

Acknowledgements

Code and ideas come from these projects:

• SuperPoint
• LightGlue
• EigenPlaces
• GTSAM
• TensorRT
• AirVO
• ORB_SLAM2
• SuperPoint-SuperGlue-TensorRT

Star History