DINO-SLAM: DINO-informed RGB-D SLAM for Neural Implicit and Explicit Representations
July 25, 2025
Abstract
This paper presents DINO-SLAM, a DINO-informed design strategy to enhance implicit (Neural Radiance Field – NeRF) and explicit representations (Gaussian Splatting – GS) in SLAM systems through the more comprehensive semantic understanding enabled by DINO. This latter alone, however, lacks proper 3D geometry understanding, allowing only for marginal improvements. Therefore, we rely on a Scene Geometry Encoder (SGE) to lift DINO features into geometry-aware DINO features (geoDINO), to better understand those geometric relationships that vanilla DINO features fail to capture. Building upon it, we propose two foundational paradigms for NeRF and GS SLAM systems integrating geoDINO features. Compared to state-of-the-art methods, our DINO-informed pipelines achieve superior performance on the Replica, ScanNet, and TUM datasets.
1 Introduction↩︎
Dense simultaneous localization and mapping (SLAM) has emerged as a fundamental technology in robotics and autonomous systems, with extensive applications ranging from mobile robotics to autonomous vehicles. As a core component of spatial intelligence, dense SLAM enables real-time camera localization while constructing detailed environmental maps, thereby facilitating autonomous navigation and scene understanding. Initially, SLAM techniques were primarily hand-crafted algorithms [1]–[5], facing limitations in the presence of challenging lighting conditions and poorly textured environments. The advent of deep learning has further advanced the field, significantly improving pose estimation accuracy through learned features and matching [6]–[8], peaking with the recent breakthroughs in novel view synthesis, notably Neural Radiance Fields (NeRF) [9] and Gaussian Splatting (GS) [10], that have revolutionized this field with new, exciting possibilities. Among these, the possibility of rendering images from novel viewpoints during or after the mapping process is an intriguing side-product not enabled by conventional SLAM systems or even by the most modern feed-forward models [11]–[14]. Nevertheless, current NeRF or GS-based SLAM systems primarily focus on geometric reconstruction and photometric consistency, overlooking higher-level scene understanding necessary for complex scene representation and autonomous navigation. Indeed, on the one hand, these frameworks rely on supervisory signals coming from pixel-wise colors or depth, thus lacking such a higher-level understanding of both those local and global properties that conventional feed-forward vision models can encode in deep features [15], [16]. On the other hand, vision foundation models like DINO [15], [16] excel at extracting high-level features from color images, yet inherently do not take into account the 3D structure of the scene. Therefore, we argue that naively integrating such features into SLAM pipelines could already soften the aforementioned problem, yet only marginally. By contrast, enriching such features with geometry awareness has the potential to further improve performance: we argue this can be achieved by jointly processing such features with the simplest geometry cue available to RGB-D SLAM systems: depth.
In this paper, we propose DINO-SLAM, a novel and general framework that can seamlessly integrate the higher-level scene understanding of a self-supervised foundation model like DINO [15], [16] into the SLAM system. This is achieved by embedding the features extracted by the foundation model directly into the scene representation, either implicit or explicit, learned during the optimization carried out by the SLAM system, yet only after having lifted such features to encode 3D geometry properties of the scene. The foundation of DINO-SLAM is a custom model, the Scene Geometry Encoder (SGE), that jointly processes the DINO features extracted from the color frame with its corresponding depth map to extract a hierarchy of new, higher-level features, namely geoDINO features, encoding both contextual understanding and scene geometry. Building upon this extractor, we establish two specialized paradigms suited for both NeRF-based and GS-based SLAM methods. We demonstrate the wide applicability of our approach through integration with various scene-encoding SLAM methods [17]–[21], over standard benchmarks in the field [22]–[24], where DINO-SLAM achieves state-of-the-art accuracy – as shown in Fig. [fig:teaser].
Our key contributions are:
We introduce DINO-SLAM, a DINO-informed RGB-D SLAM design paradigm significantly boosting the performance of existing SLAM pipelines by embedding enhanced DINO features within scene representations.
Purposely, we develop a Scene Geometry Encoder (SGE) to enrich the scene representations captured by DINO with geometry awareness retrieved from depth maps. The SGE is optimized online alongside the SLAM pipeline. Based on it, we implement two foundational paradigms suitable for both NeRF-based and GS-based SLAM systems.
We validate our wide applicability to neural implicit and explicit SLAM methods by integrating our SGE into various scene representations, such as hash grids, triplanes, 3D Gaussians Splats, and 2D Gaussian Surfels. Experiments on popular datasets [22]–[24] demonstrate the superior performance of our DINO-SLAM pipelines.
2 Related work↩︎
Here, we briefly review the research related to our work. More detailed literature can be found in [25].
Neural Implicit SLAM. With the emergence of NeRF [9], numerous works [17]–[19], [26]–[29] have incorporated such implicit volumetric representation into SLAM frameworks. As the first approach using implicit neural representations for SLAM, iMAP [26] adopts an MLP to map the 3D coordinates to color and volume density. NICE-SLAM [27] further extends the single MLP of iMAP into a hierarchy of MLPs, which improves the quality of dense reconstruction by optimizing a hierarchical representation. Current works further explore different scene encodings, such as hash-tables [17], [30]–[33], neural-point [19], [34], [35], and tri-planes [18], [28], [32], to enhance scene modeling capabilities, or orthogonal features such as uncertainty [36] or quantized queries [37].
Neural Explicit SLAM. Gaussian Splatting (GS) [10], as an explicit radiance field technique, has been recently widely used in SLAM methods. Compared to NeRF-based SLAM, these methods [20], [21], [38]–[44] offer two key advantages: explicit spatial extent mapping and local explicit mapping editability, enabling real-time adjustments and corrections of the scene representations. As pioneers, MonoGS [21] incorporates GS into RGB-D SLAM systems for efficient and high-quality rendering of environments. SplaTAM [20] leverages a group of simplified Gaussians to represent the whole scene, GS-SLAM [39] encodes both appearance and geometry by 3D Gaussians with opacity and spherical harmonics, while WildGS-SLAM [44] learns to ignore moving objects and distractors through uncertainty. Other GS-based systems focus on semantic SLAM [45], [46], adding appearance embeddings [47] or opacity fields [48], performing adaptive densification based on Fourier frequency domain analysis [49], reducing and compressing Gaussians [49], or replacing 3D Gaussians with 2D Gaussian Surfels [50], [51].
DINO-informed Neural Representation. DINO [15] has emerged as a powerful tool in neural scene representations, offering both invariant feature extraction [52], [53] and semantic comprehension [54]–[56]. Mazur et al. [52] extract DINO features that offer flexible semantic representations for scene understanding. Recent works [57]–[61] have already investigated the integration of DINO [15] or DINOv2 [16] features into SLAM pipelines, although for different purposes – i.e., for joint semantic segmentation, mapping, and localization, or to identify and filter out moving subjects in dynamic SLAM pipelines.
As a consequence, both implicit and explicit methods overlooked the potential of DINO features and how their guidance, if properly enriched with geometry awareness, can improve the accuracy of existing SLAM systems. In this paper, we comprehensively explore this path and unveil the real potential of DINO, when properly enhanced with geometry awareness, to boost a variety of SLAM systems characterized by different scene representations, thus suggesting the potential to extend our approach to future SLAM systems based on radiance fields.
3 Method Overview↩︎
We now introduce our DINO-SLAM framework, which supports both neural implicit and explicit representations, as illustrated in Figure 1.
3.1 Scene Geometry Encoder↩︎
Given the strong priors encoded in DINO features [15], we design a Scene Geometry Encoder (SGE) to further enrich these embeddings with geometric understanding and generate more informative, geometry-aware DINO features (geoDINO). These cues guide the scene modeling in our SLAM systems, removing bottlenecks caused by conventional color and depth pixel-wise supervisions, as well as the lack of geometric knowledge in vanilla DINO features. As shown in Figure 2, our encoder can be formalized as a model \(\Phi_{SGE}\) that processes the color \(c\) and depth \(d\) to extract both vanilla DINO \(f_{D}\) and geometry-aware geoDINO features \(f_{gD}\): \[\Phi _{SGE}\left ( c, d \right ) \to \left ( f_{D} ,f_{gD} \right )\]
Specifically, DINO features \(f_{D}\) are obtained through the frozen, ViT-small DINOv2 model [16] and are further processed with an MLP, projecting them into features \(f_{a}\). Concurrently, depth frames are projected by a second MLP into geometric features \(f_{g}\), to encode spatial relations and arrangements. Then, \(f_{a}\) and \(f_{g}\) are used as keys and queries to inject structural geometry information into features \(f_{D}\) by means of an attention module, producing \(f_{atten-d}\): \[f_{atten-d} =softmax\left ( \frac{f_{g} f_{a}^{T} }{\sqrt{d_{a}} } \right ) f_{D}\] As a result, SGE forces DINO features to be re-weighted based on the local 3D structure, encoded by \(f_{g}\), in relation to the whole depth map. This mechanism is repeated, with \(f_{atten-d}\) and \(f_{g}\) being then used as keys and queries for attending over the previous projected features \(f_{a}\) and obtaining enhanced features \(f_{atten-a}\): \[f_{atten-a} =softmax\left ( \frac{f_{g} f_{atten-d}^{T} }{\sqrt{d_{atten-d}} } \right ) f_{a}\] Finally, a further projection performed through a third MLP produces \(f_{atten-a}^{'}\), which are concatenated with \(f_{atten-d}, f_{g}\) to obtain our geoDINO features. These features can be embedded inside any NeRF or GS-based SLAM systems: when doing so, our SGE is optimized online alongside the NeRF or GS backbone in the pipeline, by exploiting two feature losses detailed in the remainder. Our experiments will demonstrate that these higher-level, geometry-aware features are crucial for achieving the best results, whereas embedding DINO features alone in SLAM pipelines yields marginal improvements.
3.2 NeRF-based Pipeline↩︎
Building upon the features extracted by our SGE, we design a first NeRF-based version of DINO-SLAM, illustrated in Figure 3.
Scene Representation. Our NeRF-based pipeline is optimized to render RGB, depth, and vanilla DINO features through ray sampling, leveraging the per-pixel ray casting property inherent to NeRF methods. As illustrated in Figure 3, our framework encodes the sampled points \(x_{i}\) along the rays into some feature representation. In the figure, we show an implementation using tri-planes [18] for which, specifically, we design three distinct tri-planes (\(\tau_{g}\), \(\tau_{a}\), and \(\tau_{D}\)) to learn geometric, appearance, and geoDINO representations separately. Then, three shallow MLPs, each consisting of two fully-connected layers, process these tri-plane encodings to produce the signed distance function (SDF) \(\phi _{g}(x_{i})\), raw colors \(\phi _{a}(x_{i})\), and raw DINO features \(\phi_{D}(x_{i})\). While the vanilla DINO features extracted from images supervise \(\phi_{D}\), the geoDINO features from our SGE supervise the tri-plane encodings \(\tau_{D}\), as detailed in the subsequent sections.
DINO-informed Rendering. We adopt the standard ray-casting process used in NeRF [9]. For all points sampled along a ray \(\left \{ p_{n} \right \}_{n=1}^{N}\), we query TSDF \(\phi _{g}(p_{n})\), raw color \(\phi _{a}(p_{n})\), and raw DINO features \(\phi _{D}(p_{n})\) from the MLPs. We then apply SDF-based rendering to compute volume densities: \[\sigma \left ( p_{n} \right ) = \beta \cdot Sigmoid\left ( -\beta \cdot \phi _{g} \left ( p_{n} \right ) \right )\] where \(\sigma \left ( p_{n} \right )\) represents the volume density and \(\beta\) is a learnable parameter controlling the sharpness of the surface boundary. The termination probability \(w_{n}\), color \(c\), depth \(d\), and estimated DINO features \(f_{D}^{'}\) are rendered using these volume densities: \[\begin{gather} \quad f_{D}^{'} = \sum_{n=1}^{N} w_{n} \phi _{D}\left ( p_{n} \right ) \quad \text{with} \quad w_{n} = exp\left ( -\sum_{k=1}^{n-1} \sigma \left ( p_{k} \right ) \right )\left ( 1-exp\left ( -\sigma \left ( p_{n} \right ) \right ) \right ), \notag \\ \quad\quad c = \sum_{n=1}^{N} w_{n} \phi _{a}\left ( p_{n} \right ),\quad \text{and} \quad d = \sum_{n=1}^{N} w_{n} z_{n} \end{gather}\] where \(z_{n}\) denotes the depth of sampled point \(p_{n}\).
DINO-informed Supervision. We introduce two feature-level losses to enhance scene representation and semantic consistency. As shown in Figure 3, we implement a geoDINO feature loss \(L_{gf}\) to supervise the tri-planes \(\tau _{D}\) responsible for learning enriched spatial and appearance cues. This loss function computes the feature similarity between the tri-planes \(\tau _{D}\) and the geoDINO features \(f_{gD}\): \[L_{gf} = \left \| \tau _{D} - f_{gD} \right \| _{1}\] We further introduce a loss \(L_{Df}\) between predicted and vanilla DINO features: \[L_{Df} = \left \| f_{D}^{'} - f_{D} \right \| _{1}\] Additionally, we employ standard color and depth losses: \[L_{c}=\frac{1}{\vert \;R \;\vert}\sum_{r \in R}\left ( c_{n} - \hat{c}_{n} \right )^{2}, \quad L_{d}=\frac{1}{\vert \;R \;\vert}\sum_{r \in R}\left ( d_{n} - \hat{d}_{n} \right )^{2}\] where \(R\) denotes a batch of rays. \(\hat{c}_{n}\) and \(\hat{d}_{n}\) represent the ground-truth color and depth, respectively. We also incorporate additional loss terms from [18], including free space loss, signed distance loss, and truncation loss.
Mapping and Tracking. Following [18], our mapping process randomly samples \(R\) pixels from a temporal window comprising the current frame, the two most recent frames, and \(W-3\) frames selected from keyframes. Keyframes are systematically selected every \(k\) frames from the input RGB-D sequences. The training process jointly optimizes three components: the tri-planes (\(\tau_{g}\), \(\tau_{a}\), and \(\tau_{D}\)), the decoder MLPs, and camera poses for the selected \(W\) frames. For tracking, we perform pose estimation for every incoming frame.
3.3 GS-based Pipeline↩︎
Driven by the same principles, we propose a second version of DINO-SLAM built over GS, shown in Figure 4.
Scene Representation. Following vanilla GS, the scene is represented through a set of anisotropic Gaussians \(\varsigma\) where each Gaussian primitive \(\varsigma ^{i}\) is characterized by its parameters: color \(c^{i}\), radius \(r^{i}\), and opacity \(o ^{i}\). For continuous spatial representation, each Gaussian is further defined by its mean \(\mu ^{i}\) and covariance \(\Sigma ^{i}\), representing its position and ellipsoidal shape, respectively. As shown in Figure 4, we incorporate the geoDINO features \(f_{gD}\) obtained from our SGE into each Gaussian’s set of parameters, while the vanilla DINO features extracted from images supervise the Gaussians themselves, emulating the NeRF-based pipeline introduced in the previous section. Specifically, each Gaussian \(\varsigma ^{i}\) corresponds to an embedding in the geoDINO feature map. We assign its associated feature \(f_{gD}^{i}\) into the distinct channel of Gaussian \(\varsigma ^{i}\) parameters. This enhanced representation can be formalized through the following Gaussian equation: \[\label{eq95varsigma} \varsigma \left ( x \right ) = o \exp\left ( -\frac{\left \| x-\mu \right \|^{2} }{2r^{2} } \right )\tag{1}\]
DINO-informed Rasterization. Our approach employs iterative rasterization over Gaussians instead of per-pixel ray casting. During rasterization, we project the Gaussians onto the image plane to obtain 2D Gaussians through: \[\label{eq95mu} \mu_{2d}=\pi \left ( T_{CW} \cdot \mu \right ),\Sigma _{2d}=JW\Sigma W^{T}J^{T}\tag{2}\] where \(\mu_{2d}\) and \(\Sigma _{2d}\) represent the position and the covariance of 2D Gaussians, respectively. \(\pi\) denotes the projection operation and \(T_{CW}\) is the camera pose of the viewpoint. \(J\) is the Jacobian of the linear approximation of the projective transformation, and \(W\) is the rotational component of \(T_{CW}\). Through splatting and blending \(N\) Gaussians, we can obtain the rendered feature map \(f_{D}^{'}\) that captures enriched geometric and appearance information: \[f_{D}^{'} = \sum _{i\in N} f_{gD}^{i} \varsigma^{i} \prod_{j=1}^{i-1}(1-\varsigma ^{j} )\] Similarly, we obtain color \(c\) and depth \(d\) through: \[c = \sum _{i\in N} c^{i} \varsigma ^{i} \prod_{j=1}^{i-1}(1-\varsigma ^{j} ), \quad d = \sum _{i\in N} z^{i} \varsigma ^{i} \prod_{j=1}^{i-1}(1-\varsigma ^{j} )\] where \(z^{i}\) is the distance to \(\mu\) along the camera ray.
DINO-informed Supervision. We introduce a DINO-feature loss \(L_{Df}\) to keep semantic consistency and guide the optimization of the enriched scene representation. As illustrated in Figure 4 (b), this loss function measures the feature similarity between the DINO features \(f_{D}\) and the rendered feature maps \(f_{D}^{'}\): \[L_{Df} = \left \| f_{D}^{'}-f_{D} \right \| _{1}\] Similarly, we define color loss and depth loss for the appearance and geometric optimization: \[L_{c} = \left \| c - \hat{c} \right \| _{1}, \quad L_{d} = \left \| d-\hat{d} \right \| _{1}\] where \(\hat{c}\) and \(\hat{d}\) represent the ground-truth color and depth, respectively.
Mapping and Tracking. For mapping and tracking, we adopt the keyframe selection strategy based on co-visibility from [62]. The tracking thread focuses solely on camera pose optimization using color and depth residuals. In the mapping thread, depending on the SLAM pipeline we built upon, we include global bundle adjustment (BA) to address both the forgetting problem and camera drift during significant movements. We measure frame-to-frame motion using optical center distance \(d\) and parallax angle \(r\). When significant motion occurs, \(d\) and \(r\) increase dramatically. Therefore, keyframes are selected when these metrics exceed their respective thresholds \(d_{l}\) and \(r_l\).
4 Experiments↩︎
We now introduce our experiments and discuss the outcome.
Datasets. We conduct our evaluation across three standard datasets: Replica [22], ScanNet [24], and TUM RGB-D [23]. Replica provides photo-realistic indoor scenes specifically designed for evaluating dense reconstruction quality. ScanNet offers extensively annotated real-world data across diverse indoor environments, ranging from small rooms to large scenes. The TUM RGB-D benchmark, instead, features small-scale indoor scenes captured with an external camera system, providing high-precision ground-truth trajectories.
Baselines. To support the generality of our approach, we first inject our DINO-informed design into different NeRF and GS-based SLAM systems characterized by various kinds of scene encoding, including grid-based [17], tri-planes [18], [58], neural points [19], 3D Gaussian Splats [20], [21], and 2D Gaussian Surfels [51]. Furthermore, to fully assess the potential of DINO-SLAM, we compare it against several state-of-the-art methods, focusing on dense mapping, novel view synthesis, and camera tracking.
Metrics. For quantitative evaluation, we adopt standard SLAM metrics [25]: Absolute Trajectory Error (ATE) RMSE for tracking accuracy, and reconstruction quality metrics including accuracy (cm), completion (cm), completion rate (%), depth l1 (cm). Novel view rendering quality is assessed using PSNR (dB), SSIM, and LPIPS.
Implementation Details. All experiments were conducted on a desktop PC equipped with an NVIDIA RTX 3090Ti GPU. In our NeRF-based pipeline, we employ a multi-resolution approach with geometry tri-planes at 24cm/6cm resolution and appearance/DINO tri-planes at 24cm/3cm resolution, the loss weights are configured as 5.0 for encoding feature loss, and 0.01 for DINO-feature loss, \(k\) is set to 4 for keyframe selection. For our GS-based pipeline, we maintain consistency with the original Gaussian Splatting implementation [10], and set the DINO-feature loss weight to 1, \(d_{l}\)=0.7, and \(r_l\)=15.
4.1 Ablation Experiments↩︎
We conduct ablation studies to demonstrate the versatility of DINO-SLAM and assess the impact of each component in the framework.
DINO-SLAM Generality. We prove the wide applicability of DINO-SLAM by integrating our SGE module with various neural implicit and explicit representations: hash-grids (a), tri-planes (b-c), neural points (d), 3D Gaussians Splats (e-f), and 2D Gaussian Surfels (g). Table 1 shows consistent performance improvements on Replica across all encoding architectures when augmented with our SGE. Specifically, we can appreciate how our pipeline can further enhance the results achieved by SLAM systems already exploiting vanilla DINO features for semantic segmentation, such as SNI-SLAM (c), confirming how these features alone are insufficient and that lifting DINO with geometry awareness is crucial to achieve the largest gains. Furthermore, our design also significantly improves state-of-the-art systems such as GauS-SLAM (g), confirming the broad applicability of our SGE and suggesting the potential to extend our methodology to future SLAM systems based on either NeRF or GS. From now on, we will adopt ESLAM and GauS-SLAM to build our NeRF and GS variants of DINO-SLAM.
| Methods | Encoding | Acc.\(\downarrow\) | Comp.\(\downarrow\) | Comp.rate\(\uparrow\) | Depth L1\(\downarrow\) | RMSE(cm)\(\downarrow\) | |
|---|---|---|---|---|---|---|---|
| (a) | Co-SLAM [17] | Hash-grid | 2.10 | 2.08 | 93.44 | 1.51 | 0.86 |
| +DINO | Hash-grid | 1.96 | 2.06 | 93.62 | 1.39 | 0.78 | |
| ESLAM [18] | Tri-planes | 2.18 | 1.75 | 96.46 | 0.94 | 0.63 | |
| +DINO | Tri-planes | 1.88 | 1.60 | 97.22 | 0.63 | 0.49 | |
| SNI-SLAM* [58] | Tri-planes | 1.94 | 1.70 | 96.62 | 0.77 | 0.46 | |
| +DINO | Tri-planes | 1.83 | 1.61 | 97.05 | 0.68 | 0.42 | |
| Methods | Encoding | F1\(\uparrow\) | Pre.\(\uparrow\) | Recall\(\uparrow\) | Depth L1\(\downarrow\) | RMSE(cm)\(\downarrow\) | |
| (d) | Point-SLAM [19] | Neur-points | 89.77 | 96.99 | 83.59 | 0.44 | 0.52 |
| +DINO | Neur-points | 90.77 | 98.33 | 84.30 | 0.41 | 0.46 | |
| Methods | Encoding | PSNR\(\uparrow\) | SSIM\(\uparrow\) | LPIPS\(\downarrow\) | Depth L1\(\downarrow\) | RMSE(cm)\(\downarrow\) | |
| (e) | SplaTAM [20] | 3DGS | 34.11 | 0.968 | 0.102 | 0.73 | 0.36 |
| +DINO | 3DGS | 34.65 | 0.971 | 0.098 | 0.66 | 0.33 | |
| MonoGS [21] | 3DGS | 38.94 | 0.968 | 0.070 | 0.49 | 0.32 | |
| +DINO | 3DGS | 39.56 | 0.972 | 0.047 | 0.45 | 0.29 | |
| GauS-SLAM [51] | 2DGS | 40.25 | 0.991 | 0.027 | 0.43 | 0.06 | |
| +DINO | 2DGS | 41.42 | 0.994 | 0.021 | 0.12 | 0.05 |
| Component | Acc.\(\downarrow\) | Comp.\(\downarrow\) | Comp.rate\(\uparrow\) | Depth L1\(\downarrow\) | RMSE(cm)\(\downarrow\) | |
|---|---|---|---|---|---|---|
| (A) | ESLAM [18] | 2.18 | 1.75 | 96.46 | 0.94 | 0.63 |
| (B) | + vanilla DINO | 2.07 | 1.67 | 96.63 | 0.79 | 0.58 |
| (B’) | + concat(DINO,depth) | 2.03 | 1.67 | 96.78 | 0.75 | 0.56 |
| (C) | + geoDINO | 1.88 | 1.60 | 97.22 | 0.63 | 0.49 |
| Component | PSNR\(\uparrow\) | SSIM\(\uparrow\) | LPIPS\(\downarrow\) | Depth L1\(\downarrow\) | RMSE(cm)\(\downarrow\) | |
| (D) | GauS-SLAM [51] | 40.25 | 0.991 | 0.027 | 0.43 | 0.06 |
| (E) | + vanilla DINO | 40.78 | 0.992 | 0.025 | 0.27 | 0.06 |
| (F) | + geoDINO | 41.42 | 0.994 | 0.021 | 0.12 | 0.05 |
Components Analysis. To support our main claim on the importance of SGE to unveil the real potential of DINO features for SLAM, we conduct an ablation study to measure the impact of both vanilla DINO features and our enhanced geoDINO features, reporting the results achieved on Replica in Table 2. For the NeRF-based pipeline, we assess reconstruction and camera tracking performance, while for the GS-based pipeline, we evaluate the rendering quality and the accuracy of estimated poses.
| Method | Acc.(cm)\(\downarrow\) | Comp.(cm)\(\downarrow\) | Comp.rate(%)\(\uparrow\) | Depth L1(cm)\(\downarrow\) | RMSE(cm)\(\downarrow\) |
|---|---|---|---|---|---|
| iMAP [26] | 3.62 | 4.93 | 80.51 | 4.64 | 7.64 |
| NICE-SLAM [27] | 2.37 | 2.65 | 91.14 | 1.90 | 2.50 |
| Co-SLAM [17] | 2.10 | 2.08 | 93.44 | 1.51 | 0.86 |
| ESLAM [18] | 2.18 | 1.75 | 96.46 | 0.94 | 0.63 |
| Point-SLAM [19] | 1.41 | 3.10 | 88.89 | 0.44 | 0.52 |
| PLGSLAM\(^{\dag}\) [28] | 2.14 | 1.74 | 96.24 | 0.83 | 0.63 |
| HS-SLAM [29] | 1.96 | 1.67 | 96.57 | 0.71 | 0.53 |
| Mamba-SLAM [36] | 2.62 | 2.25 | 92.86 | - | - |
| SNH-SLAM [33] | 2.08 | 1.78 | 96.85 | 1.15 | 0.61 |
| QQ-SLAM [37] | 2.38 | 1.76 | 96.39 | 1.09 | 0.91 |
| SNI-SLAM [58] | 1.94 | 1.70 | 96.62 | 0.77 | 0.46 |
| DINO-SLAM (NeRF) | 1.88 | 1.60 | 97.22 | 0.63 | 0.49 |
| Method | PSNR\(\uparrow\) | SSIM\(\uparrow\) | LPIP\(\downarrow\) | Depth L1(cm)\(\downarrow\) | RMSE(cm)\(\downarrow\) |
| SplaTAM [20] | 34.11 | 0.968 | 0.102 | 0.73 | 0.36 |
| Gaussian-SLAM [39] | 38.90 | 0.993 | 0.069 | 0.68 | 0.31 |
| MonoGS [21] | 38.94 | 0.968 | 0.070 | 0.49 | 0.32 |
| GS-SLAM [38] | 34.27 | 0.975 | 0.082 | 1.16 | 0.50 |
| SEGS-SLAM [47] | 39.42 | 0.975 | 0.021 | - | 0.43 |
| GauS-SLAM [51] | 40.25 | 0.991 | 0.027 | 0.43 | 0.06 |
| SemGauss [57] | 35.03 | 0.982 | 0.062 | 0.50 | 0.33 |
| Hier-SLAM [45] | 35.70 | 0.980 | 0.067 | 0.49 | 0.32 |
| VSS-SLAM [50] | 39.01 | 0.975 | 0.042 | 0.34 | 0.28 |
| FGO-SLAM [48] | 38.35 | 0.973 | 0.082 | 0.71 | - |
| FGS-SLAM [63] | 38.75 | 0.974 | 0.041 | - | 0.15 |
| CGS-SLAM [49] | 34.44 | 0.980 | 0.090 | - | 0.33 |
| VSG-SLAM [46] | 36.86 | 0.987 | 0.061 | 0.40 | 0.37 |
| DINO-SLAM (GS) | 41.42 | 0.994 | 0.021 | 0.12 | 0.05 |
The results reveal a few key insights: by establishing ESLAM and GauS-SLAM without any DINO features as the baselines (A, D), we can observe some improvements obtained by naively embedding vanilla DINO features in both the NeRF and GS-based pipelines (B, E). These findings are not surprising and were already supported by existing literature on semantic SLAM [58]. The lack of geometry awareness by DINO can be partially compensated by simply concatenating depth features \(f_g\) (B’), although with limited effectiveness. On the contrary, employing our SGE to obtain geoDINO features and using these latter significantly boosts the accuracy further, both for mapping/rendering and camera tracking, by doubling the improvement with respect to the one gained with vanilla DINO features on most metrics. This confirms our main claim and the importance of lifting DINO features with geometry awareness, something that cannot be achieved by simply concatenating depth features.
4.2 Comparison with State-Of-The-Art↩︎
We now compare our NeRF and GS variants of DINO-SLAM, built respectively on top of ESLAM and GauS-SLAM, against state-of-the-art SLAM frameworks.
Results on Replica. We begin our experiments on Replica, running our pipelines on 8 diverse scenes following standard practice in the literature. Table 3 compares our DINO-SLAM variants against state-of-the-art SLAM approaches. The table is divided into two sections: at the top, it presents reconstruction and tracking results for NeRF-based methods, while at the bottom, it shows rendering and tracking performance for GS-based methods. All reported values represent averages across the test scenes. The results highlight the effectiveness of our DINO-SLAM paradigms. In particular, our GS-based variant achieves state-of-the-art performance in both rendering quality and tracking accuracy among all GS-based methods. Similarly, our NeRF-based implementation excels in completion, completion rate, and RMSE metrics, while remaining competitive in accuracy and depth L1 error. Figure 5 collects qualitative results that further validate the superiority of DINO-SLAM. The meshes produced by our NeRF-based variant (the two left columns) demonstrate superior surface detail preservation while successfully completing previously missing regions. The rendering results of our GS-based variant (the two right columns) show photo-realistic rendering quality with significantly improved texture detail resolution.
Robustness to depth noise. Since geoDINO enhances DINO with structural knowledge derived from depth, the presence of noise on this latter can harm our framework. In Tab. 4, we compare the performance achieved by GauS-SLAM and DINO-SLAM (GS) when processing depth maps corrupted with Gaussian noise (\(\mu=0,\sigma=0.1\)). Despite the accuracy drops for both, our DINO-SLAM processing noisy depth is still better than GauS-SLAM with noise-free depth, demonstrating that our SGE enjoys some robustness to depth noise.
Results on ScanNet. Our evaluation extends to ScanNet, where we test both DINO-SLAM variants on six sequences of varying complexity, including challenging long trajectories exceeding 5000 frames. As shown in Table 5, our GS-based pipeline significantly outperforms existing GS-based systems, while our NeRF-based pipeline still surpasses most baselines. In this sense, we note that PLGSLAM achieves slightly better results due to its design being specifically tailored for larger scene reconstruction, whereas our contribution is orthogonal to it and could potentially be integrated with such a framework as well.
| PSNR \(\uparrow\) | SSIM \(\uparrow\) | LPIPS \(\downarrow\) | Depth L1 \(\downarrow\) | RMSE \(\downarrow\) | |
|---|---|---|---|---|---|
| Gaus-SLAM | 41.40 | 0.981 | 0.055 | 0.37 | 0.04 |
| w/ Depth Noise | 39.87 | 0.977 | 0.062 | 0.41 | 0.05 |
| DINO-SLAM (GS) | 44.65 | 0.994 | 0.023 | 0.22 | 0.02 |
| w/ Depth Noise | 42.38 | 0.986 | 0.029 | 0.29 | 0.03 |
| Method | 0000 | 0059 | 0106 | 0169 | 0181 | 0207 | Avg. |
|---|---|---|---|---|---|---|---|
| iMAP [26] | 55.9 | 32.0 | 17.5 | 70.5 | 32.1 | 11.9 | 36.7 |
| NICE-SLAM [27] | 12.0 | 14.0 | 7.9 | 10.9 | 13.4 | 6.2 | 10.7 |
| Co-SLAM [17] | 7.1 | 11.1 | 9.4 | 5.9 | 11.8 | 7.1 | 8.7 |
| ESLAM [18] | 7.3 | 8.5 | 7.5 | 6.5 | 9.0 | 5.7 | 7.4 |
| PLGSLAM\(\dag\) [28] | - | - | - | - | - | - | 6.8 |
| Point-SLAM [19] | 10.2 | 7.8 | 8.7 | 22.2 | 14.8 | 9.5 | 12.2 |
| Mamba-SLAM [36] | - | 10.0 | 7.8 | 10.1 | 12.4 | 4.7 | - |
| SNH-SLAM [33] | 6.7 | 8.1 | 7.7 | 7.3 | 10.6 | 6.3 | 7.8 |
| QQ-SLAM [37] | 7.0 | 9.5 | 8.8 | 6.5 | 13.3 | 5.9 | 8.5 |
| DINO-SLAM (NeRF) | 7.6 | 7.5 | 7.0 | 5.9 | 8.6 | 4.7 | 6.9 |
| SplaTAM [20] | 12.8 | 10.1 | 17.7 | 12.1 | 11.1 | 7.5 | 11.9 |
| MonoGS [21] | 9.8 | 32.1 | 8.9 | 10.7 | 21.8 | 7.9 | 15.2 |
| GauS-SLAM [51] | 9.3 | 7.1 | 7.0 | 7.4 | 17.5 | 6.2 | 9.1 |
| Hier-SLAM [45] | 11.5 | 9.6 | 17.8 | 11.9 | 10.0 | 7.3 | 11.4 |
| CGS-SLAM [49] | 11.3 | 9.2 | 16.3 | 11.0 | 10.8 | 6.5 | 10.8 |
| VSG-SLAM [46] | 11.6 | - | - | 11.0 | 10.7 | 6.1 | - |
| DINO-SLAM (GS) | 8.5 | 6.5 | 6.2 | 6.6 | 10.5 | 5.8 | 7.3 |
| Method | fr1_desk | fr2_xyz | fr3_office | Avg. |
|---|---|---|---|---|
| iMAP [26] | 4.90 | 2.00 | 5.80 | 4.23 |
| NICE-SLAM [27] | 2.70 | 1.80 | 3.00 | 2.50 |
| Co-SLAM [17] | 2.40 | 1.70 | 2.40 | 2.17 |
| ESLAM [18] | 2.47 | 1.11 | 2.42 | 2.00 |
| Point-SLAM [19] | 4.34 | 1.31 | 3.48 | 3.04 |
| QQ-SLAM [37] | 2.61 | 1.70 | 2.70 | 2.34 |
| DINO-SLAM (NeRF) | 2.39 | 1.14 | 2.27 | 1.93 |
| SplaTAM [20] | 3.35 | 1.24 | 5.16 | 3.27 |
| MonoGS [21] | 1.50 | 1.44 | 1.49 | 1.47 |
| GS-SLAM [38] | 3.30 | 1.30 | 6.60 | 3.73 |
| SEGS-SLAM [47] | 3.19 | 0.37 | 1.03 | 1.53 |
| GauS-SLAM [51] | 1.82 | 1.34 | 1.46 | 1.54 |
| FGS-SLAM [63] | 2.50 | 1.50 | 2.10 | 2.00 |
| VSS-SLAM [50] | 1.56 | 1.39 | 1.51 | 1.49 |
| DINO-SLAM (GS) | 1.77 | 1.07 | 1.41 | 1.42 |
Results on TUM. To further validate our approach, we run experiments on three widely-used sequences from the TUM RGB-D dataset, including both short and long trajectories. As shown in Table 6, although not excelling on all of the single sequences, both implementations of DINO-SLAM achieve superior pose estimation accuracy on average, outperforming all existing methods. These results confirm that our DINO-SLAM pipelines excel across all standard benchmarks commonly adopted in the field.
| Method | Size(MB)\(\downarrow\) | FPS\(\uparrow\) | Comp.\(\downarrow\) | RMSE\(\downarrow\) |
|---|---|---|---|---|
| Co-SLAM [17] | 6.7 | 7.97 | 2.08 | 0.86 |
| Point-SLAM [19] | 54.8 | 0.23 | 3.10 | 0.52 |
| ESLAM [18] | 27.2 | 4.62 | 1.75 | 0.63 |
| DINO-SLAM (NeRF) | 48.7 | 2.55 | 1.60 | 0.49 |
| Method | Size(MB)\(\downarrow\) | FPS\(\uparrow\) | PSNR\(\uparrow\) | RMSE\(\downarrow\) |
| MonoGS [21] | 28.5 | 0.62 | 38.94 | 0.32 |
| SplaTAM [20] | 265.3 | 0.14 | 34.11 | 0.36 |
| GauS-SLAM [51] | 347.0 | 0.59 | 40.25 | 0.06 |
| DINO-SLAM (GS) | 343.1 | 0.58 | 41.42 | 0.05 |
4.3 Performance Analysis↩︎
We compare our DINO-SLAM pipelines with NeRF-based and GS-based baselines in both FPS (average time required to process per frame in a sequence) and memory usage (total footprint of the encoder and decoder). As shown in Table 7, Co-SLAM is the fastest method, yet its reconstruction accuracy is significantly lower than our NeRF-based SLAM. In contrast, our DINO-SLAM (NeRF) achieves better results with moderate memory requirements, although halving the FPS with respect to its baseline, ESLAM. Besides, concerning GS methods, we can appreciate how DINO-SLAM achieves the best results, with negligible overhead on top of the GauS-SLAM baseline with respect to the complexity of the GS engines.
We conclude with a detailed computational breakdown in Table ¿tbl:tab:breakthrough?, to precisely quantify the overhead introduced by our SGE and the overall DINO-SLAM paradigm. At the top (a), we report the FPS achieved by the different SLAM baselines and their DINO-SLAM counterparts, highlighting a negligible difference in most cases. In the middle (b), we present a detailed runtime analysis of our DINO-SLAM (GS) framework, quantifying the moderate overhead introduced by geoDINO features and our SGE module throughout the optimization pipeline. Finally, at the bottom (c), we report the memory footprint of DINO-SLAM (GS) on different scenes in ScanNet. Even in large scenes, the memory footprint is acceptable, thanks to the pruning strategy already employed by GauS-SLAM.
cc & & Co-SLAM & ESLAM & SNI-SLAM & Point-SLAM & SplaTAM & MonoGS & GauS-SLAM w/o DINO & 7.97 & 4.62 & 0.61 & 0.23 & 0.14 & 0.62 & 0.59 w/ geoDINO & 7.01 & 2.55 & 0.56
& 0.20 & 0.12 & 0.61 & 0.58
& & SGE Forward & Backward & Rendering & Per Frame & Whole Sequence w/o DINO (s) & - & 0.004 & 0.021 & 1.69 & 3387 w/ geoDINO (s) & 0.041 & 0.007 & 0.033 & 1.75 & 3510
& & 0000 & 0059 & 0106 & 0169 & 0181 & 0207 Memory (MB) & 356.7 & 216.2 & 225.1 & 173.6 & 292.3 & 317.5
5 Conclusion↩︎
We presented DINO-SLAM, a DINO-informed dense RGB-D SLAM design paradigm that enhances both neural implicit and explicit representations. We implemented two foundational paradigms suited for both NeRF-based and GS-based SLAM systems built on top of our SGE module, which injects vanilla DINO features with geometry awareness to better capture structural relationships. Our experiments validate the wide applicability and the superior performance achieved by our method. In future work, we will extend DINO-SLAM with more advanced components orthogonal to its design, such as loop-closure and sub-mapping.