Visual-inertial SLAM on low-power edge platforms is constrained by the cost of dense feature extraction and loop closure. Prior GPU ports of ORB-SLAM trade accuracy for speed by approximating the ORB detector, altering the feature set and therefore the estimated trajectory. We present an accuracy-preserving GPU implementation of ORB-SLAM3 for the NVIDIA Jetson Orin Nano, whose GPU ORB front end reproduces the reference CPU detector algorithmically to 94.7% exact keypoint agreement and 99.9% descriptor bit agreement. This work also makes CNN-based loop closure edge-viable through native TensorRT. The visual front end (feature extraction) is offloaded to the GPU while the mapping and optimization back end is kept on the CPU, matching each computation to the hardware it suits. The accuracy is verified by comparing four configurations: the GPU pipeline and the unmodified CPU reference, each run on both the Jetson Orin Nano and a desktop. On EuRoC dataset, all four agree to within 0.10cm in mean absolute trajectory error (SE(3)), so neither the GPU port nor the change of hardware shifts the estimated trajectory. The GPU-versus-CPU comparison is reproducible on TUM-VI and KITTI datasets, so the acceleration is accuracy-preserving rather than approximate. The proposed implementation is competitive with published ORB-SLAM3 on EuRoC, attains sub-centimeter accuracy on five of the six TUM-VI room sequences, and reaches sub-1% relative translation error on nine of eleven KITTI sequences. For loop closure, the generic ONNX-Runtime CUDA/TensorRT execution providers are unusable with our CosPlace ResNet-50 on the embedded platform, whereas a native libnvinfer FP16 engine reduces per-query inference to 2.2ms, a 180x speedup. Learned place recognition therefore runs concurrently with tracking on a 7W device. In monocular-inertial mode the system sustains 32FPS mean over the eleven EuRoC sequences.
Figures & tables
Figure 1. Jetson-ORB-SLAM3 architecture: the GPU (hatched) executes the reference-faithful ORB front end and the TensorRT place-recognition network, the CPU (violet) runs the unmodified ORB-SLAM3 back end. Orange blocks are our contributions, white blocks are existing work; green, magenta, and blue edges carry images, keypoints/descriptors, and loop-closure candidates respectively.
Seq. ↓
Jetson SLAM ( Kumar et al., 2023 )
ORB SLAM3 ( Campos et al., 2021 )
Ours
∣Δ∣
Compute →
Orin Nano
Desktop
Orin Nano
GPU
CPU
Input →
Stereo
Stereo+IMU
Stereo+IMU
# runs →
1
10
5
5
MH01
3.30
3.50
4.09
3.60
0.49
MH02
4.73
2.90
3.45
3.46
0.01
Table 1. ATE (RMSE, cm) on EuRoC dataset. ∣Δ∣ is the per-sequence gap between our GPU pipeline and CPU reference. Lower is better. Bold marks our pipeline where it matches or beats the published reference.
Configuration ↓
SE(3)
Scaled
Orin Nano, GPU (ours)
3.32
2.75
Orin Nano, CPU (stock)
3.40
2.91
Desktop, GPU (ours)
3.39
2.80
Desktop, CPU (stock)
3.30
2.73
Published ORB-SLAM3
2.47
Table 2. Cross-platform mean ATE (cm) on all eleven sequences of the EuRoC dataset (Stereo+IMU). No value is highlighted: the four configurations agree rather than compete.
Figure 2. Estimated vs. ground-truth path of MH01 sequence of EuRoC dataset. The two estimates are visually indistinguishable over the entire sequence. Both curves are the median of five runs, at 4.09 and 3.60 cm respectively.
ORB
Ours
Seq. ↓
SLAM3 ( Campos et al., 2021 )
GPU
CPU
∣Δ∣
Compute →
Desktop
Orin Nano
room1
0.8
0.98
0.78
0.20
room2
1.2
1.08
0.83
0.25
room3
1.1
0.84
0.59
0.25
room4
0.8
0.67
0.76
0.09
Table 3. ATE (RMSE, cm) on TUM-VI room sequences. ∣Δ∣ is the per-sequence gap between our GPU pipeline and CPU reference. Lower is better. Bold marks our pipeline where it matches or beats the published reference.
trel (%)
rrel (°/100 m)
ATE (m)
Seq. ↓
( Mur-Artal and Tardós, 2017 )
Ours
Ours
( Mur-Artal and Tardós, 2017 )
Ours
( Mur-Artal and Tardós, 2017 )
GPU
CPU
∣Δ∣
Desktop
Orin Nano
Orin Nano
Desktop
Orin Nano
Desktop
00
0.70
0.72
0.68
0.04
0.28
0.25
1.31
1.3
01
1.39
1.64
1.65
0.01
0.28
0.21
13.15
10.4
02
0.76
0.77
0.75
0.02
0.26
0.23
6.89
5.7
Table 4. Accuracy on all sequences of the KITTI odometry dataset. ∣Δ∣ is the per-sequence gap between our GPU pipeline and CPU reference. Lower is better. Bold marks our pipeline where it matches or beats the ORB-SLAM2 reference.
Sub-sequence
trel (%)
Benchmark ↓
windows (m)
GPU
CPU ref.
∣Δ∣
TUM-VI ( Schubert et al., 2018 )
5–40
0.134
0.117
0.022
EuRoC ( Burri and others, 2016 )
5–40
0.723
0.725
0.016
KITTI ( Geiger et al., 2012 )
100–800
0.800
0.780
0.036
Table 5. Cross-dataset relative translation error under KITTI’s sub-sequence estimator on Orin Nano. ∣Δ∣ is the mean per-sequence GPU-versus-CPU gap. No value is highlighted: the two arms agree rather than compete.
Stage ↓
Monocular-Inertial
Stereo-Inertial
Sequence →
V101
MH01
ORB extraction (ms)
13.7
38.9
Total tracking (ms/frame)
35.4
76.6
Throughput (FPS)
28.3
13.1
Table 6. Per-stage tracking runtime on the Orin Nano, one representative sequence per mode
Mono-Inertial
Stereo-Inertial
Seq. ↓
Base
Pipe
Base
Pipe
MH01
25.6
30.7
13.5
26.2
MH02
26.4
26.3
13.8
27.3
MH03
31.0
30.5
13.8
27.6
MH04
33.5
32.5
14.7
28.7
MH05
32.4
30.5
14.6
28.5
Table 7. Per-sequence tracking throughput (FPS) on the Orin Nano, all eleven EuRoC sequences, single run. Base is the configuration evaluated for accuracy above; Pipe overlaps ORB extraction with tracking. Bold marks the configuration that clears the 20 Hz camera rate.
Ours
Benchmark ↓
Resolution
GPU
CPU ref.
KITTI (stereo)
1241×376
98.8
111.7
EuRoC (stereo-inertial)
752×480
69.7
62.1
TUM-VI (stereo-inertial)
512×512
78.4
78.3
Table 8. Mean tracking time (ms) across all three benchmarks, Orin Nano, our GPU pipeline against the CPU reference on the same device. Bold marks our pipeline where it beats that reference.
Execution path ↓
Latency (ms)
ONNX-Runtime CUDA/TRT EP
fails to initialize
ONNX-Runtime CPU
∼ 396
TensorRT FP16 GPU (ours)
2.2
Table 9. CosPlace ResNet-50 inference latency per query on the Jetson Orin Nano. Bold marks the fastest path.
Seq. ↓
DBoW2 + CNN
DBoW2 only
no loop closing
MH01
3.91
4.21
3.72
MH02
3.18
3.24
3.61
MH03
2.89
2.74
2.82
MH04
4.64
4.75
4.63
MH05
5.41
5.53
5.94
V101
3.61
3.64
3.77
Table 10. Loop-closure ablation on EuRoC, stereo-inertial on the Orin Nano: median ATE (cm) over five runs per cell. Bold marks the lowest ATE in each row; V203 is listed below the mean because it is excluded from it.
The tracking module of a visual-inertial SLAM system processes incoming image frames and IMU data to estimate the position of the frame in relation to the map. It is important for the tracking to complete in a timely manner for each frame to avoid poor localization or tracking loss. We therefore present a new approach which leverages GPU computing power to accelerate time-consuming components of tracking in order to improve its performance. These components include stereo feature matching and local map tracking. We implement our design inside the ORB-SLAM3 tracking process using CUDA. Our evaluation demonstrates an overall improvement in tracking performance of up to 2.8x on a desktop and Jetson Xavier NX board in stereo-inertial mode, using the well-known SLAM datasets EuRoC and TUM-VI.
Kimia Khabiri, Parsa Hosseininejad, Shishir Gopinath +2
With the growing demand for robotics, autonomous drones, and wearable extended reality systems, the deployment of Visual SLAM on embedded devices remains challenging. Tracking must sustain high frame rates while preserving compute resources for map extension and maintenance. This paper presents GLidE-SLAM, a monocular hybrid indirect-direct framework that addresses this by architectural separation: the system performs GPU-accelerated direct tracking on intermediate frames, while reserving the full indirect pipeline for map extension and global consistency. We leverage highly parallel image-alignment operations for pose-only estimation without depth optimization or map point creation, making the workload suitable for GPU offloading and freeing CPU resources for backend tasks. We implement the direct tracker using vendor-agnostic OpenGL ES~3.1 compute shaders, enabling deployment across a broader range of commodity embedded platforms without requiring CUDA support. To our knowledge, this is the first complete direct photometric pose estimator realized via compute shaders for embedded-class devices. Experiments on target platforms demonstrate up to 9× higher frame rates than the CPU-only baseline while maintaining trajectory accuracy and improving practical deployment across commodity resource-constrained hardware.
Carlos A. Pinheiro de Sousa, Heiko Hamann, Oliver Deussen
The authors are with the Department of Computer and Information Science, University of Konstanz, 78464 Konstanz, Germany.
Visual SLAM systems combine visual tracking with global loop closure to maintain a consistent map and accurate localization. Loop closure is a computationally expensive process as we need to search across the whole map for matches. This paper presents FastLoop, a GPU-accelerated loop closing module to alleviate this computational complexity. We identify key performance bottlenecks in the loop closing pipeline of visual SLAM and address them through parallel optimizations on the GPU. Specifically, we use task-level and data-level parallelism and integrate a GPU-accelerated pose graph optimization. Our implementation is built on top of ORB-SLAM3 and leverages CUDA for GPU programming. Experimental results show that FastLoop achieves an average speedup of 1.4x and 1.3x on the EuRoC dataset and 3.0x and 2.4x on the TUM-VI dataset for the loop closing module on desktop and embedded platforms, respectively, while maintaining the accuracy of the original system.
Soudabeh Mohammadhashemi, Shishir Gopinath, Kimia Khabiri +3