DINOv3

ArXiv: 2508.10104

🎯 Pitch

DINOv3 reveals that scaling self-supervised vision models past 1B parameters causes their dense feature maps to collapse during training—a previously undiagnosed failure mode that is directly solved by a new 'Gram anchoring' regularization. The technique freezes the local patch similarity structure from an early, well-behaved teacher, delivering frozen features that surpass specialized state-of-the-art models on segmentation and detection while matching the best weakly-supervised models on global classification.

---

1. Executive Summary

This technical report introduces DINOv3, a self-supervised learning pipeline that scales vision transformers to 7B parameters trained on a curated dataset of 1.69 billion web images, producing a frozen visual backbone that defines a new state of the art across both dense and global vision tasks. The central architectural innovation is Gram anchoring — a regularization phase that enforces the Gram matrix of patch-patch similarities in the student to match that of an earlier, patch-consistent teacher (operationalized by computing Gram matrices on downsampled high-resolution features and applying them as a refinement objective after 1M training iterations) — which directly addresses the previously unsolved degradation of dense feature maps during extended training. DINOv3 achieves a roughly 4× improvement in compute efficiency over DINOv2 on dense tasks (e.g., 55.9 mIoU on ADE20k with a frozen linear probe versus 49.5), surpasses specialized state-of-the-art systems on object detection (66.1 mAP on COCO) and semantic segmentation (63.0 mIoU on ADE20k) with all backbones frozen, and matches or exceeds the strongest weakly-supervised models like SigLIP 2 and Perception Encoder on out-of-distribution classification, establishing that self-supervised learning without any metadata can produce universally superior dense features while achieving competitive global representations only when the dense feature collapse is explicitly mitigated through Gram-based regularization.

2. Context and Motivation

The Core Problem: Self-Supervised Learning Cannot Scale Without Losing Dense Features

The fundamental challenge this paper tackles is a scaling paradox in self-supervised learning (SSL) for computer vision. SSL methods—unlike their supervised or weakly-supervised counterparts—can train on virtually unlimited raw image data without requiring expensive human annotations or curated metadata. This makes SSL uniquely appealing for building ever-larger foundation models: as the pool of available images grows, so too can the model's exposure to diverse visual concepts. The promise is that scaling dataset and model size should produce arbitrarily powerful, generalist visual encoders that work across domains (natural images, histopathology, satellite imagery, astronomy) without task-specific adaptation.

However, the paper identifies that this promise breaks down at scale. When SSL models grow beyond roughly 1B parameters and train for extended durations, a specific and previously unresolved failure mode emerges: the quality of dense (patch-level) feature maps degrades systematically as training progresses, even while global (image-level) representations continue to improve. This means the very scaling that should make SSL models more powerful instead renders them less useful for the dense prediction tasks—segmentation, depth estimation, tracking, 3D correspondence—that constitute a large fraction of real-world computer vision applications.

This degradation is not a minor inconvenience. It fundamentally undermines the core value proposition of SSL foundation models: that a single frozen backbone should serve diverse downstream tasks. If scaling improves classification accuracy but destroys the patch features needed for segmentation, the model is not truly generalist—it is a global representation model that happens to produce unusable local features. This tension between global and dense representation quality becomes the central obstacle the paper must overcome.

Why This Problem Matters: The Real-World Stakes

The paper articulates several concrete reasons why solving dense feature degradation at scale is critical beyond academic interest (Section 1):

Frozen backbone deployment efficiency. A key practical advantage of SSL models is that they can be used without fine-tuning: downstream tasks train lightweight decoders (linear probes, shallow transformers) on top of frozen features, while the backbone itself remains unchanged. This means a single forward pass through the backbone can produce features consumed simultaneously by a classifier, a segmenter, a depth estimator, and a 3D correspondence matcher—dramatically reducing compute requirements compared to fine-tuning separate backbones for each task. For edge devices and resource-constrained environments, this is essential. If the backbone's dense features degrade at scale, this efficiency is lost: practitioners must either accept poor dense performance or resort to fine-tuning, sacrificing the computational savings that make frozen backbones attractive in the first place.

Domain-agnostic applicability. SSL's independence from metadata makes it uniquely suited for scientific domains where labeled data is scarce or nonexistent: histopathology (Chen et al., 2024), medical imaging (Pérez-García et al., 2025), remote sensing (Cong et al., 2022; Tolan et al., 2024), astronomy (Parker et al., 2024), high-energy physics (Dillon et al., 2022). These domains often lack the image-text pairs needed for CLIP-style training or the curated labels needed for supervised pretraining. SSL offers the only scalable path to large foundation models in these areas. But scientific applications frequently involve dense prediction—segmenting cells in pathology slides, estimating canopy height from satellite imagery, detecting particles in physics detectors—which means the dense feature problem is not a corner case but central to SSL's impact in these fields.

Training-inference compute tradeoffs. An implicit but important economic argument runs through the paper: if SSL can produce models with state-of-the-art dense features without fine-tuning, organizations can invest in training a single large SSL model once and amortize that cost across many downstream tasks with cheap inference-time decoders. This contrasts with the prevailing paradigm where each task requires fine-tuning (or even training from scratch) a specialized model. The paper's FLOPs-matched comparisons (Section 7) directly quantify this tradeoff, showing that under certain conditions, test-time compute spent on a smaller model with high-quality features can outperform a much larger model with degraded features. Making this economic case requires first solving the dense feature scaling problem, since degraded features would undermine the frozen-backbone advantage.

The self-supervised learning bet. More broadly, the paper positions SSL as a long-term bet on the future of visual representation learning. Unlike CLIP and its derivatives (SigLIP, Perception Encoder), which are fundamentally constrained by the availability of high-quality image-text pairs, SSL can scale to the entire web of images—billions more than any caption dataset can provide. For domains where text metadata is sparse or nonexistent (scientific imaging, aerial photography, medical scans), SSL is the only viable path to foundation models. If SSL cannot scale without losing dense features, this bet fails, and the field is forced to accept the limitations of weakly-supervised approaches that depend on metadata. Solving the dense feature problem is therefore existential for the SSL research program.

Prior Approaches and Where They Fall Short

The paper's analysis of prior work is organized around explaining why existing solutions do not address the specific failure mode it identifies, and it does so by surveying three relevant research threads.

The DINO Family: Strong but Fragile at Scale

DINO (Caron et al., 2021) established that discriminative self-supervised learning with vision transformers can produce features with remarkable emergent properties—particularly object-level segmentation emerging from attention maps, and strong performance on both classification and dense tasks. DINOv2 (Oquab et al., 2024) scaled this approach to 1.1B parameters (ViT-g) trained on curated data, and was the first SSL model to match or exceed open-source CLIP variants across a range of tasks. However, the paper notes two critical limitations of DINOv2 that directly motivate DINOv3:

1. Training instability at larger scales. The heuristics that stabilized DINOv2—learning rate schedules, weight decay schedules, EMA momentum schedules—implicitly assume a known optimization horizon. When training on massive image corpora, the right horizon is unknowable a priori. This makes continuing training (to exploit additional data or larger models) operationally difficult: the schedules are tuned for a fixed number of iterations, and extending them requires guesswork.

2. Dense feature degradation in long training runs. Even within DINOv2's training, the authors observed that dense feature quality peaked early and then declined—though with the 1.1B model and its fixed training schedule, the effect was manageable. The paper's Figure 5 shows this directly for both ViT-g and ViT-7B: segmentation mIoU on PASCAL VOC peaks around 200k iterations and then declines, while classification accuracy on ImageNet continues to improve monotonically. For the ViT-7B, the decline is severe enough to drop below early-training performance. This phenomenon—which the paper calls "loss of patch-level consistency"—is the central obstacle.

A recent scaling attempt that failed on dense tasks. Fan et al. (2025) attempted to scale DINOv2 to 7B parameters (Web-DINO) using web-scale data without careful curation. The paper notes this effort achieved "promising results on global tasks, but with disappointing results on dense prediction" (Section 3.2). This is a critical data point: it confirms that the problem is not specific to DINOv3's training recipe but is a fundamental issue that emerges whenever SSL models are pushed beyond the ~1B parameter threshold. The paper's quantitative results bear this out: Web-DINO achieves only 42.7 mIoU on ADE20k (Table 3) compared to DINOv2's 49.5, and 76.1 on VOC compared to DINOv2's 83.1, despite being 7× larger. This failure—a larger model performing substantially worse on dense tasks—crystallizes the problem the paper must solve.

Dense Feature Methods: Partial Solutions That Don't Scale

The paper acknowledges a substantial body of work on improving dense features from vision transformers (Section 2, "Dense Transformer Features"), but positions all of it as addressing different problems than the one DINOv3 faces:

Local SSL losses (Jabri et al., 2020; Pinheiro et al., 2020; Bardes et al., 2022; Yun et al., 2022) add objectives that explicitly enforce patch-level consistency—for example, by requiring spatially corresponding patches across different crops to have similar features, or by using video-based spatio-temporal consistency signals. These methods improve dense features, but they operate at the training objective level. The problem DINOv3 identifies is different: even with a training objective that includes a patch-level term (iBOT, Zhou et al., 2021, which is part of DINOv2's loss and DINOv3's initial training phase), dense features still degrade when training continues long enough with a large enough model. The degradation is not about the absence of a dense objective—it is about the balance between global and local objectives shifting unfavorably over time.

Register tokens (Darcet et al., 2024) eliminate high-norm patch outliers—a distinct issue where certain patches (typically in low-information background regions) develop anomalously large feature norms that dominate attention. The paper explicitly states that this issue is separate from the dense feature degradation: "These patch-level irregularities differ from the high-norm patch outliers described in Darcet et al. (2024). Specifically, with the integration of register tokens, patch norms remain stable throughout training" (Section 4.1). The degradation is about patch semantics (similarity patterns between patches becoming noisy) rather than patch norms. The paper investigates and rules out several other outlier types in Appendix A, confirming that these are distinct phenomena.

Agglomerative/distillation methods (AM-RADIO, Ranzinger et al., 2024; Perception Encoder PEspatial, Bolya et al., 2025) combine multiple pretrained backbones—often including supervised ones like SAM—to produce models with both strong global and local features. These methods achieve impressive results, and the paper includes them as baselines. However, they fundamentally rely on supervised pretraining as a component: SAM requires mask annotations, CLIP requires image-text pairs. This means they do not address the core challenge of scaling pure SSL, and they inherit the data constraints of their supervised components. DINOv3's ambition is to achieve similar or better dense features without any supervision, which requires solving the degradation problem directly rather than importing features from supervised models.

Post-hoc feature improvements (STEGO, Hamilton et al., 2022; gradient augmentation, Simoncini et al., 2024; patch averaging, Wysoczańska et al., 2024) apply transformations to frozen features to clean them up. These are compatible with DINOv3 (they could further improve already-clean features) but do not address the root cause: they would need to be applied to already-degraded features, which is a lossy process compared to preventing the degradation during training.

Weakly-Supervised Models: The Meta-Advantage and Its Limitations

The paper devotes significant attention to weakly-supervised models—particularly CLIP derivatives (Radford et al., 2021; SigLIP 2, Tschannen et al., 2025; Perception Encoder, Bolya et al., 2025)—because they represent the strongest competition and illuminate what SSL must overcome.

The CLIP paradigm advantage. CLIP-style models learn visual representations by aligning images with their associated text captions. This provides a rich training signal that naturally encourages both global semantic understanding (what object is in the image?) and local grounding (where in the image is the object mentioned in the caption?). The paper acknowledges that these models have become the de facto standard for image encoders, achieving strong results on both classification and, with recent advances, dense prediction.

The data constraint. However, CLIP training requires image-text pairs. The largest such datasets—used by SigLIP 2 and PE—contain 40-86B pairs. This is enormous, but it represents a fundamentally different kind of scaling than SSL: it is scaling within the set of images that happen to have associated text on the web, which necessarily excludes domains where text metadata is sparse (scientific imaging, satellite imagery, medical scans). Moreover, the captions themselves introduce biases—they reflect what humans choose to describe, which may not align with the visual features needed for physical or geometric tasks. The paper's results consistently show that weakly-supervised models underperform on tasks requiring 3D awareness (Table 4) and instance-level retrieval (Tables 9, 23), suggesting that text-based training does not capture certain geometric properties that emerge naturally from SSL.

The fine-tuning requirement for dense tasks. A critical practical limitation the paper identifies: while CLIP derivatives achieve respectable dense features, they typically require fine-tuning the backbone for state-of-the-art dense performance. This sacrifices the frozen-backbone efficiency that SSL models offer. The paper's results (Table 3) show that with frozen backbones and only linear probes, the best weakly-supervised models (SigLIP 2, PEcore) achieve 42.7 and 38.9 mIoU on ADE20k respectively, compared to DINOv3's 55.9—a gap of 13+ points. Only by incorporating supervised SAM distillation (AM-RADIO, PEspatial) do weakly-supervised approaches approach competitive dense performance, which again introduces supervision.

How This Paper Positions Itself

The paper positions DINOv3 not as a novel training algorithm (it uses the same DINO+iBOT+Koleo loss as DINOv2) but as a systematic engineering effort to identify and solve the specific bottlenecks that prevent scaling SSL. Its contributions are explicitly enumerated as four interconnected components (Section 1, "Overview of Contributions"):

Contribution (i): Data scaling through complementary curation. Rather than naively training on raw web data (which Goyal et al., 2021 showed does not reliably improve performance) or relying on a single curation strategy, the paper combines clustering-based curation (Vo et al., 2024, for balanced diversity) with retrieval-based curation (Oquab et al., 2024, for downstream relevance) and explicit inclusion of standard CV datasets (ImageNet-1k, ImageNet-22k). This is positioned as an incremental but practically important improvement over DINOv2's retrieval-only curation, with ablation results (Table 1) showing that the combination outperforms each strategy alone.

Contribution (ii): Architecture and optimization for indefinite training. Switching from ViT-g (1.1B) to a custom ViT-7B architecture (Table 2) with RoPE position embeddings (enabling resolution flexibility), removing all parameter schedules (constant learning rate, weight decay, EMA momentum) to enable training continuation without knowing the horizon a priori, and adding RoPE-box jittering for aspect ratio robustness. These changes are individually incremental but collectively enable the model to train stably for 1M iterations—far beyond what DINOv2 attempted.

Contribution (iii): Gram anchoring to prevent dense feature collapse. This is the paper's core technical innovation and its answer to the scaling paradox. The key insight is that the balance between global (DINO) and local (iBOT) objectives is unstable over training: the global objective gradually dominates, causing patch features to lose their locality as measured by cosine similarity to the CLS token (Figure 5a). Rather than modifying the training objectives or adding new local losses (which would risk destabilizing the global representations), Gram anchoring operates on the Gram matrix of patch-patch similarities, pushing the student to maintain the patch-level consistency of an earlier "Gram teacher" model while leaving the features themselves free to evolve. Critically, the Gram teacher can use higher-resolution inputs and bicubic downsampling to produce smoother, more coherent patch similarity patterns, which are then distilled into the student via the Frobenius norm loss on the difference of Gram matrices. This approach explicitly decouples the two axes of representation quality: the DINO loss handles discriminative power, while the Gram loss handles patch-level consistency. Because the Gram objective operates only on similarity structure rather than absolute feature values, it regularizes without constraining the feature space.

Contribution (iv): Distillation into a practical model family. Training a 7B model is an achievement, but deployment requires models at various efficiency points. The paper develops an efficient multi-student distillation pipeline (Figure 12) that shares teacher inference cost across multiple students, and produces ViT-S, B, L, and ConvNeXt variants that inherit the teacher's feature quality at a fraction of the compute cost (Figure 16b shows the ViT-H+ student nearly matching the 7B teacher with 8× fewer parameters).

The unifying framing. Across these contributions, the paper's consistent message is that the problems emerging at scale are not fundamental limitations of SSL but engineering challenges with identifiable solutions. Data curation enables scaling the training set without introducing noise that overwhelms the learning signal. Constant schedules and RoPE enable scaling the training duration without hitting optimization cliffs. Gram anchoring enables scaling the model size without losing the dense features that make SSL valuable. Distillation enables scaling the deployment footprint without losing the quality gains from the large teacher.

This positioning contrasts with both the "just scale everything" approach (Fan et al., 2025, which produced a large SSL model with poor dense features) and the "SSL is not enough, we need supervision" approach (AM-RADIO, PEspatial). The paper's implicit argument is that these represent incomplete diagnoses: the problem is not that SSL inherently cannot produce good dense features at scale, but that the specific mechanisms causing dense feature degradation had not been identified and addressed. By identifying Gram anchoring as the mechanism and Gram-based regularization as the solution, DINOv3 demonstrates that pure SSL can not only match but exceed supervised and weakly-supervised approaches on dense tasks, while retaining competitive performance on global tasks.

3. Technical Approach

3.1 Reader Orientation (Approachable Technical Breakdown)

This is primarily an empirical systems paper whose core idea is that the degradation of dense visual features during large-scale self-supervised training can be prevented by introducing a regularization phase that operates on the structure of patch-patch similarity patterns (the Gram matrix) rather than on the features themselves, decoupling the competing objectives of global discriminative power and local spatial consistency that become unstable when models and training durations scale beyond the ~1B parameter / ~200k iteration threshold.

The system solves the dense feature collapse problem by recognizing that a model early in training possesses superior local spatial consistency, and that this consistency can be "anchored"—preserved and even improved—by periodically enforcing that the student model's patch-level similarity structure matches that of a frozen early-checkpoint teacher, using an objective that constrains only the pattern of similarities (not absolute feature values), thereby allowing the DINO/iBOT losses to continue improving discriminative representations while the Gram loss prevents them from destroying spatial coherence.

3.2 Big-Picture Architecture (Diagram in Words)

The DINOv3 training pipeline has five sequentially activated major components:

1. Data Curation Engine (Section 3.1): Transforms a raw pool of ~17B web images into a training dataset of 1.689B curated images (LVD-1689M) plus standard CV datasets (ImageNet-1k, ImageNet-22k, Mapillary). Uses two complementary strategies—clustering-based balanced sampling for diversity and retrieval-based selection for downstream relevance—plus homogeneous ImageNet-1k batches interleaved at 10% of iterations.

2. Base SSL Training Phase (Section 3.2): Trains a ViT-7B backbone for 1M iterations using the DINOv2 loss recipe (DINO + iBOT + Koleo objectives) but with architecture changes enabling scaling: RoPE positional embeddings replacing learned embeddings, constant parameter schedules replacing cosine schedules, RoPE-box jittering for resolution robustness, and a custom 7B architecture (embedding dimension 4096, 40 blocks, patch size 16, 32 attention heads with dimension 128). This phase produces strong global representations but degraded dense features.

3. Gram Anchoring Refinement Phase (Section 4): After the 1M-iteration base training, activates a new Gram-based regularization objective ($\mathcal{L}_{\text{Gram}}$) operating for 30k-60k additional iterations. The Gram teacher is an early checkpoint (100k-200k iterations) of the EMA teacher model, frozen except for periodic updates every 10k iterations. The Gram teacher processes images at 2× the student's resolution, then 2× bicubic-downsamples the resulting feature maps. The student's patch features and the Gram teacher's downsampled patch features are both used to compute Gram matrices (pairwise patch cosine similarities within each image), and the Frobenius norm of their difference is added to the loss. This explicitly regularizes patch-level similarity structure while leaving absolute feature values unconstrained.

4. High-Resolution Post-Training Phase (Section 5.1): Trains the model for 10k additional iterations using mixed-resolution crops (global: 512-768 pixels; local: 112-336 pixels) to enable effective inference at arbitrary resolutions. Gram anchoring is active during this phase as well, using the 7B model itself as Gram teacher to prevent resolution increase from degrading dense features.

5. Multi-Student Distillation Pipeline (Section 5.2): Distills the trained 7B teacher into smaller student models (ViT-S, S+, B, L, H+; ConvNeXt-T, S, B, L) using a custom parallel distillation architecture where teacher inference cost is shared across all student training processes. The distillation uses the base SSL objectives with the frozen 7B model as teacher (no EMA). Students are trained for 1M iterations + 250k cooldown + high-resolution phase.

Information flows: Raw image pool → Curation → (LVD-1689M + standard datasets) → Base SSL training (1M iters) → Gram anchoring refinement (30k-60k iters) → High-resolution post-training (10k iters) → Distillation into model family. The resulting models (both the 7B teacher and the distilled students) serve as frozen backbones for downstream tasks.

3.3 Roadmap for the Deep Dive

• First, the data curation pipeline, because the scale and composition of training data sets the foundation for everything that follows and the paper's ablation shows that curation strategy matters significantly even for SSL.
• Second, the base training recipe (architecture, loss functions, optimization), since this establishes the context in which the dense feature collapse occurs—we need to understand what is trained before we can understand what goes wrong and how it is fixed.
• Third, the detailed mechanism of dense feature collapse and the Gram anchoring solution, as this is the paper's central technical innovation and requires careful explanation of both the phenomenon and the mathematical machinery that addresses it.
• Fourth, the post-training stages (resolution adaptation, distillation), which build on the stabilized features to produce a practical model family.
• Fifth, the text alignment procedure, which is optional but demonstrates the versatility of the resulting representations.

3.4 Detailed, Sentence-Based Technical Breakdown

Data Curation: Balancing Diversity and Relevance Without Metadata

The paper constructs its training dataset through a three-part strategy designed to provide both broad coverage of visual concepts and targeted relevance to common downstream tasks, all without requiring any image labels or text metadata.

The raw data pool. The starting point is approximately 17 billion images collected from public posts on Instagram, representing the "unconstrained web data" that self-supervised learning promises to leverage. These images have already undergone platform-level content moderation to filter harmful content. The key challenge is that naively training on this entire pool would be both computationally wasteful and potentially harmful to model quality: prior work (Goyal et al., 2021; Oquab et al., 2024) showed that raw, uncurated web data contains heavy redundancy (many near-duplicate or uninformative images) and distributional biases (overrepresentation of certain concepts, underrepresentation of others) that limit downstream performance.

Part 1: Clustering-based curation for balanced diversity (LVD-1689M). The first curation strategy follows Vo et al. (2024) and aims to produce a dataset that covers all visual concepts appearing on the web with balanced representation. The procedure operates as follows:

1. Embedding extraction: Each image in the raw pool is encoded using DINOv2 to produce a global feature vector. This embedding serves as a semantic fingerprint—images with similar content will have similar embeddings.

2. Hierarchical k-means clustering: The embeddings are clustered hierarchically using five levels of k-means, with the number of clusters decreasing from the lowest (finest) to highest (coarsest) level: 200M clusters at level 1, 8M at level 2, 800k at level 3, 100k at level 4, and 25k at level 5. This hierarchy captures visual concepts at multiple granularities—from very specific (individual object types in specific poses) to very broad (entire scene categories).

3. Balanced sampling: The algorithm from Vo et al. (2024) performs balanced sampling across the hierarchy. Rather than sampling images uniformly (which would overrepresent frequent concepts and underrepresent rare ones), it ensures that each cluster at each level contributes proportionally to its size, while also ensuring diversity across clusters. The result is a curated subset of 1,689 million images (named LVD-1689M) that guarantees balanced coverage across the full diversity of web visual content.

The key insight behind this approach is that diversity matters more than raw quantity for generalization: a model trained on 100M images covering 10K distinct visual concepts will likely generalize better than one trained on 1B images covering only 1K concepts, even if the latter sees more total data.

Part 2: Retrieval-based curation for downstream relevance. The second curation strategy follows Oquab et al. (2024) and aims to ensure the training data covers visual concepts that are relevant to common computer vision benchmarks. The procedure works as follows:

1. Seed dataset selection: A set of "seed" datasets representing common downstream tasks is selected. The paper does not enumerate all seed datasets, but following Oquab et al. (2024), these likely include ImageNet-1k, various fine-grained classification datasets, and scene recognition datasets.

2. Similarity-based retrieval: For each image in the seed datasets, the system retrieves similar images from the raw data pool using DINOv2 embedding similarity. This produces a dataset where each image is "near" (in embedding space) some seed image, ensuring that the training distribution covers the visual concepts that downstream benchmarks test.

3. Deduplication and filtering: Retrieved images are deduplicated and filtered to remove near-duplicates and low-quality examples.

This curation strategy addresses a subtle but important issue: raw web data may contain visual concepts that are never tested in standard benchmarks, and may miss concepts that are tested. By "pulling" the training distribution toward the evaluation distribution via retrieval, the model is better prepared for the tasks it will actually be evaluated on.

Part 3: Standard CV datasets. The final part consists of publicly available computer vision datasets used without modification:

• ImageNet-1k (Deng et al., 2009): ~1.28M images across 1000 categories
• ImageNet-22k (Russakovsky et al., 2015): ~14M images across 21,841 categories
• Mapillary Street-level Sequences (Warburg et al., 2020): street-level imagery useful for dense prediction tasks

The paper notes this final part "allows us to optimize our model's performance, following Oquab et al. (2024)" (Section 3.1). The explicit inclusion of standard datasets is a pragmatic concession: while SSL's promise is to learn from uncurated data, including datasets that are known to be useful for evaluation provides a direct signal that improves results on those evaluations.

Data sampling during training: homogeneous ImageNet-1k batches. The paper introduces a specific sampling strategy inspired by Charton and Kempe (2024). Rather than always mixing all data components into heterogeneous batches, the sampler randomly selects per iteration:

• With 10% probability: a homogeneous batch consisting only of images from ImageNet-1k
• With 90% probability: a heterogeneous batch mixing data from all other components (LVD-1689M, retrieval-curated data, ImageNet-22k, Mapillary)

"Inspired by Charton and Kempe (2024), who observed that it is beneficial to have homogeneous batches consisting of very high quality data from a small dataset, we randomly sample in each iteration either a homogeneous batch from ImageNet1k alone or a heterogeneous batch mixing data from all other components. In our training, homogeneous batches from ImageNet1k account for 10% of training."

The rationale is that homogeneous batches of high-quality data provide a "clean" gradient signal that helps the model learn precise decision boundaries, while the heterogeneous batches provide diversity. This is an empirical finding rather than a theoretical one, but it reflects a broader pattern in large-scale training: some amount of "curriculum" or "structured" sampling improves results over purely random mixing.

Data ablation results (Table 1). To validate the curation strategy, the paper trains models for a shortened schedule (200k iterations) on each data component in isolation and on the combined mixture, then evaluates on five downstream tasks: ImageNet-1k k-NN classification, ImageNet-1k linear probing, ObjectNet (OOD classification), iNaturalist 2021 (fine-grained classification), and Paris retrieval (instance-level retrieval).

The results demonstrate that no single curation strategy dominates across all tasks:

• Raw data achieves 80.1% on IN1k k-NN (competitive) but only 63.3% on Paris retrieval (poor)
• Clustering-only achieves 85.2% on Paris retrieval (excellent) but 79.4% on IN1k k-NN (worse)
• Retrieval-only achieves 84.0% on IN1k k-NN (good) and 82.7% on Paris (good) but 70.7% on ObjectNet (mediocre)
• The full LVD-1689M mixture achieves the best or near-best on all tasks: 84.6% IN1k k-NN, 87.2% IN1k linear, 72.8% ObjectNet, 87.0% iNaturalist, 85.9% Paris

This validates the paper's claim that combining complementary curation strategies yields better overall performance than any single strategy alone. The clustering strategy ensures diversity; the retrieval strategy ensures downstream relevance; the standard datasets provide high-quality examples; and the interleaved ImageNet-1k batches provide clean gradient signals.

Base Training Recipe: Scaling the DINOv2 Approach to 7B Parameters

The initial training phase follows the DINOv2 recipe with specific modifications to enable stable training at 7B scale and for indefinite duration. The goal is to produce a model with strong global discriminative representations; the dense feature quality will be addressed separately in the Gram anchoring phase.

Learning objective: DINO + iBOT + Koleo, with SwAV centering.

The total loss for the base training phase is:

$\mathcal{L}_{\text{Pre}} = \mathcal{L}_{\text{DINO}} + \mathcal{L}_{\text{iBOT}} + 0.1 \cdot \mathcal{L}_{\text{DKoleo}}$

where $\mathcal{L}_{\text{DINO}}$ is the image-level discriminative loss from Caron et al. (2021), $\mathcal{L}_{\text{iBOT}}$ is the patch-level masked reconstruction loss from Zhou et al. (2021), and $\mathcal{L}_{\text{DKoleo}}$ is a distributed Koleo regularizer (Sablayrolles et al., 2018) with weight $0.1$, applied in small batches of 16 samples across GPUs.

What each loss term does:

• $\mathcal{L}_{\text{DINO}}$: An image-level objective that encourages the student network to produce similar representations for different augmented views (crops) of the same image. It uses a teacher-student framework where the teacher is an exponential moving average (EMA) of the student weights. The student sees both global crops (large, high-resolution) and local crops (small, low-resolution); the teacher sees only global crops. The objective is a cross-entropy loss where student and teacher outputs are treated as probability distributions over a set of learnable prototypes (the "DINO head" maps backbone features to 256k prototypes), and the student is trained to match the teacher's distribution. This provides the primary signal for learning global, semantically meaningful representations.
• $\mathcal{L}_{\text{iBOT}}$: A patch-level masked reconstruction objective. Random patches of the student's global crops are masked (with 50% probability, and a random proportion in $[0.1, 0.5]$ of patches masked), and the student must predict the teacher's patch features for the masked positions. The teacher sees the unmasked image. This objective encourages the model to learn local, spatially structured features that can be inferred from surrounding context. It is the primary signal for learning dense representations.
• $\mathcal{L}_{\text{DKoleo}}$: A regularizer that encourages the features within a batch to spread uniformly in the embedding space. Applied in small batches of 16 CLS tokens (from the student's first global crop) to prevent representation collapse—where all images map to the same feature vector. The distributed implementation means the loss is computed on these small sub-batches even when the total batch size is much larger.

Key modification from DINOv2: SwAV centering. The paper replaces the standard DINO centering operation with Sinkhorn-Knopp centering from SwAV (Caron et al., 2020) in both the DINO and iBOT objectives. Centering prevents one of the collapse modes in self-supervised learning—the tendency for all samples to be assigned to a single prototype. The Sinkhorn-Knopp algorithm enforces that the assignment of samples to prototypes is uniform across the batch, providing a stronger anti-collapse mechanism than the simpler exponential moving average centering used in original DINO.

Dedicated layer normalization for global and local crops. The paper adds a dedicated layer normalization applied to the backbone outputs separately for local and global crops:

"Additionally, we use a dedicated layer normalization applied to the backbone outputs of the local and global crops. Empirically, we found this change to stabilize ImageNet kNN-classification late in training (+0.2 accuracy) and improve dense performance (e.g. +1 mIoU on ADE20k segmentation, -0.02 RMSE on NYUv2 depth estimation)."

The rationale is that local and global crops have different statistical properties (local crops are lower resolution and show different parts of the scene), and a single layer norm must compromise between their distributions. Separate layer norms allow each crop type to be normalized appropriately.

Dedicated heads for each objective. Each loss is computed using the output of a dedicated MLP head on top of the backbone network:

• DINO head: 8192 → 8192 → 512 (hidden dim → hidden dim → output dim), with 256k prototypes
• iBOT head: 8192 → 8192 → 384 (hidden dim → hidden dim → output dim), with 96k prototypes

These heads allow some specialization of features before loss computation—the DINO head can learn to extract features useful for global discrimination, while the iBOT head can extract features useful for local reconstruction.

Updated model architecture: ViT-7B (Table 2). The paper designs a custom vision transformer with approximately 6.7B parameters (referred to as ViT-7B), scaling up from DINOv2's ViT-giant (1.1B parameters). The architecture is a 40-block transformer with key specifications:

Key architectural changes and their motivations:

• Patch size 16 (vs. 14 in DINOv2): A slightly larger patch size reduces the sequence length for a given image resolution. For training at resolution 256×256, this produces 16×16 = 256 patches per image, matching DINOv2's sequence length (224/14 = 16×16 = 256). This enables the same total sequence length per batch (3.7M tokens) while using a different base resolution, maintaining computational comparability.

• RoPE position embeddings (vs. learnable): Rotary Position Embeddings (Su et al., 2024) encode position information by rotating the query and key vectors in attention based on their relative positions. Unlike learned absolute position embeddings, RoPE is inherently translation-invariant (it depends only on relative positions) and can naturally generalize to sequence lengths not seen during training. This is critical for DINOv3's ability to process images at arbitrary resolutions during inference—a 4096×4096 image produces far more patches than were seen during training, and RoPE handles this gracefully whereas learned embeddings would require interpolation or truncation.

• RoPE-box jittering: The paper introduces a custom augmentations where the coordinate box $[-1, 1]$ assigned to each patch is randomly scaled to $[-s, s]$ where $s \in [0.5, 2]$. This means the model sees the same image with different effective "spacings" between patches, making it robust to variations in aspect ratio, scale, and resolution. Specifically, when $s = 0.5$, the patches are treated as if they cover a smaller spatial region (effectively zooming in), and when $s = 2$, they cover a larger region (zooming out). This prevents the model from learning position-dependent features that would fail when the image resolution changes.

"In order to improve the robustness of the model to resolutions, scales and aspect ratios, we employ RoPE-box jittering. The coordinate box $[-1, 1]$ is randomly scaled to $[-s, s]$, where $s \in [0.5, 2]$."

• Register tokens (4): Following Darcet et al. (2024), 4 additional learnable tokens are prepended to the input sequence. These "register" tokens absorb the high-norm outlier behavior that would otherwise manifest in background patches, improving feature map quality and training stability. The paper validates this choice in Appendix A (Figure 20), showing that registers eliminate high-norm patch outliers better than alternative strategies like attention bias or value gating.

• No changes to depth (40 blocks): The model depth is kept the same as DINOv2's ViT-g, with scaling achieved through width (embedding dimension, FFN dimension, attention heads) rather than depth. This is a common pattern in transformer scaling: increasing width provides more capacity per layer without the optimization difficulties of deeper networks.

Optimization: constant schedules enable indefinite training.

A critical departure from DINOv2 is the elimination of all parameter scheduling:

"Training large models on very large datasets represents a complicated experimental workflow... To overcome this, we get rid of all parameter scheduling, and train with constant learning rate, weight decay, and teacher EMA momentum."

This has two key benefits. First, it allows training to continue as long as downstream performance improves—there is no predetermined "end" where learning rate decays to zero. This is particularly important when training on massive datasets where the "right" number of iterations is unknown a priori. Second, it reduces the number of hyperparameters that must be tuned, simplifying the experimental workflow.

Specific optimization settings:

• Optimizer: AdamW (Loshchilov and Hutter, 2017)
• Constant learning rate: $0.0004$
• Warmup: 100k iterations (linear warmup)
• Weight decay: $0.04$
• Learning rate decay factor per layer: $0.98$ (each successive layer has a slightly lower learning rate)
• Stochastic depth (layer dropout): $0.4$ (each layer has 40% probability of being dropped during training)
• Teacher EMA momentum: $0.999$ (constant throughout training)
• Batch size: 4096 images split across 256 GPUs
• Multi-crop: 2 global crops (256×256 pixels) + 8 local crops (112×112 pixels) per image
• Total sequence length per batch: 3.7M tokens
• Precision: bfloat16 mixed precision with 8-bit floating-point matrix multiplications
• Distributed training: fully-sharded data parallel (FSDP) in PyTorch

Multi-crop strategy details. The student network processes all 10 crops (2 global + 8 local); the teacher EMA processes only the 2 global crops. The DINO loss is applied between: (a) student local crops and teacher global crops, and (b) different pairs of global crops between student and teacher. The iBOT loss is applied between masked student global crop patches and unmasked teacher global crop patches. This asymmetric design—where the student must handle diverse, low-resolution crops while the teacher provides stable, high-resolution targets—encourages the student to learn robust, multi-scale features.

Dense Feature Collapse: The Phenomenon Gram Anchoring Solves

The central problem that DINOv3 addresses is the systematic degradation of patch-level feature quality during extended training, which becomes severe for models above ~1B parameters. Understanding this phenomenon mechanistically is essential for understanding why Gram anchoring works.

Empirical evidence of collapse (Figures 5, 6). The paper provides three converging lines of evidence:

1. Segmentation performance peaks early then declines (Figure 5b-c). On PASCAL VOC semantic segmentation with a linear probe on patch features, both ViT-g (1.1B) and ViT-7B (6.7B) show peak mIoU around 200k iterations. After that, performance declines—for ViT-7B, it drops below early-training levels. Meanwhile, ImageNet-1k linear classification accuracy continues to improve monotonically throughout training. This demonstrates that global and local representation quality are not only decoupled but actively in tension: what improves one degrades the other.

2. Cosine similarity between CLS token and patches increases monotonically (Figure 5a). The paper measures the cosine similarity between the CLS token output and the output patch features. As training progresses, this similarity increases—the patches become more "CLS-like" and less spatially distinctive. At 200k iterations, the similarity maps show clear spatial structure (patches similar to the CLS token are concentrated in foreground regions). By 1M iterations, the similarity is higher overall and the spatial structure is less pronounced. This provides a quantitative mechanism: the global DINO objective, which operates through the CLS token, gradually pulls patch features toward the global representation, erasing the spatial differentiation that dense tasks require.

3. Visual evidence of noisy similarity maps (Figure 6). The paper visualizes the cosine similarity between a reference patch (marked in red) and all other patches at different training iterations. At 200k iterations, the similarity map is smooth and well-localized—patches similar to the reference are in semantically related regions. By 600k iterations, the maps become noisy, with "an increasing number of irrelevant patches with high similarity to the reference patch." This is the qualitative manifestation of the quantitative metrics: the patch features lose their spatial coherence, becoming noisier and less semantically meaningful.

What is NOT causing the collapse. The paper explicitly distinguishes this phenomenon from other known issues:

• High-norm patch outliers (Darcet et al., 2024): "These patch-level irregularities differ from the high-norm patch outliers described in Darcet et al. (2024). Specifically, with the integration of register tokens, patch norms remain stable throughout training." The collapse is about feature direction (what patches are similar to what), not feature magnitude.

• Feature dimension outliers (Appendix A.2): The paper identifies a separate type of outlier where specific feature dimensions develop abnormally large magnitudes. These are addressed by applying layer normalization to the final features. They are distinct from the patch-level consistency problem.

The root cause: unstable balance between global and local objectives. The paper's diagnosis is that the DINO (global) and iBOT (local) objectives are in an unstable equilibrium. The DINO loss, operating through the CLS token and discriminating between images, provides a strong training signal that dominates over time. The iBOT loss, which encourages patch-level reconstruction, becomes relatively weaker as training progresses. The result is that the model gradually sacrifices spatial specificity for improved global discrimination—a rational response to the loss landscape, but one that destroys the dense features that make SSL valuable.

This diagnosis is supported by the observation that the phenomenon appears in both DINOv2 (where it was manageable at 1.1B parameters with a fixed training schedule) and in Web-DINO (Fan et al., 2025, where it was severe at 7B parameters with extended training). The severity scales with model size and training duration, suggesting a fundamental tension rather than an implementation bug.

Gram Anchoring: Mechanism and Mathematical Formulation

Gram anchoring is the paper's solution to the dense feature collapse problem. It introduces a new training objective that explicitly regularizes the structure of patch-patch similarities, decoupling this structural property from the features themselves.

The Gram matrix: definition and intuition. For an image composed of $P$ patches and a network producing features of dimension $d$, let $X \in \mathbb{R}^{P \times d}$ be the matrix of L2-normalized patch features. The Gram matrix is:

$G = X X^\top \in \mathbb{R}^{P \times P}$

where each element $G_{ij}$ is the cosine similarity between patch $i$ and patch $j$ (since features are L2-normalized). The Gram matrix completely characterizes the pairwise similarity structure of the patches: which patches are similar to which, and how strongly.

Why operating on the Gram matrix is the key insight. The Gram matrix captures the relational structure of the patch features without constraining their absolute values. If we apply any rotation matrix $R \in \mathbb{R}^{d \times d}$ (where $R^\top R = I$) to the features, producing $X' = XR$, the Gram matrix is unchanged:

$G' = X' (X')^\top = XR R^\top X^\top = X X^\top = G$

This means the Gram anchoring loss allows the features to rotate freely in the embedding space (which the DINO and iBOT losses need to shape for discriminative power), while constraining only the pattern of similarities between patches (which is what matters for dense prediction tasks). This is fundamentally different from operating directly on features (e.g., with an MSE loss between student and teacher patch features), which would constrain both structure and absolute values, conflicting with the global learning objectives.

The Gram anchoring loss:

$\mathcal{L}_{\text{Gram}} = \| X_S X_S^\top - X_G X_G^\top \|_F^2$

where $X_S \in \mathbb{R}^{P \times d}$ is the L2-normalized student patch features, $X_G \in \mathbb{R}^{P \times d}$ is the L2-normalized Gram teacher patch features, and $\|\cdot\|_F$ is the Frobenius norm (the square root of the sum of squared elements).

What it computes: For each image, compute the $P \times P$ Gram matrix of student patch-patch similarities and the same-sized Gram matrix of Gram teacher patch-patch similarities. Take the element-wise difference between these two matrices, square all elements, and sum them. The result is a single non-negative scalar that is zero when the two Gram matrices are identical (identical patch similarity structure) and grows as they diverge.

Why this form: The Frobenius norm of the Gram matrix difference is a natural metric on the space of similarity structures. It is differentiable (enabling gradient-based optimization), rotation-invariant (as discussed above), and provides a single scalar per image that captures the total deviation in patch-patch similarity patterns. Alternative forms like element-wise absolute difference ($\|\cdot\|_1$ norm) would also work but the squared Frobenius norm is smooth (unlike $\|\cdot\|_1$ near zero) and provides stronger gradients when the deviation is large, which helps during the initial "repair" phase when the student's patch features are heavily degraded.

This loss is computed only on the global crops (the same crops seen by the teacher), not on local crops. The computation is done after the initial 1M iteration training phase, during a "refinement" step that runs for 30k-60k additional iterations.

The refinement objective:

$\mathcal{L}_{\text{Ref}} = w_D \mathcal{L}_{\text{DINO}} + \mathcal{L}_{\text{iBOT}} + w_{DK} \mathcal{L}_{\text{DKoleo}} + w_{\text{Gram}} \mathcal{L}_{\text{Gram}}$

where $w_D$, $w_{DK}$, and $w_{\text{Gram}}$ are hyperparameter weights. The paper uses $w_{\text{Gram}} = 2$ and does not specify the exact values for $w_D$ and $w_{DK}$ in the main text, but notes they are set to maintain similar magnitudes as during pre-training. The Gram loss weight of 2 indicates that patch similarity structure is given significant emphasis during refinement.

The Gram teacher: an early checkpoint with clean features. The Gram teacher $X_G$ is selected as an early checkpoint of the EMA teacher network, specifically from 100k or 200k iterations of the initial training phase. At this point, the model has learned meaningful features but has not yet suffered significant dense feature degradation (recall from Figure 5b that segmentation performance peaks around 200k iterations). The Gram teacher is frozen—its weights do not change during refinement—except for periodic updates every 10k iterations, at which point it is replaced with the current main EMA teacher weights. The paper reports up to 3 such updates.

Why an early checkpoint works: The early model's patch features have the correct structure of similarities (patches on the same object are similar; patches on different objects are dissimilar) even though the features themselves are less discriminative than later checkpoints. By anchoring to this structurally correct but semantically less powerful teacher, the Gram loss encourages the student to preserve (or recover) good spatial structure while the DINO and iBOT losses continue to improve semantic quality.

An ablation in Figure 9b confirms this logic. Using a Gram teacher from 100k or 200k iterations gives essentially identical results (55.7 mIoU on ADE20k for both). Using a Gram teacher from 1M iterations—which has heavily degraded patch features—gives worse results (54.9 mIoU). This validates that the key property is the Gram teacher's patch-level consistency, not its semantic quality.

High-resolution Gram anchoring (LHRef). The paper introduces an important refinement: the Gram teacher can process images at higher resolution than the student, then downsample the resulting feature maps to match the student's spatial dimensions. This provides the student with a smoother, more coherent similarity target.

Specifically, the Gram teacher processes images at 512×512 pixels (2× the student's 256×256), producing a $\frac{512}{16} \times \frac{512}{16} = 32 \times 32$ feature map. This feature map is then 2× bicubic-downsampled to $16 \times 16$, matching the student's output size. The Gram matrix is computed from the downsampled features.

Why higher resolution helps. Figure 9a illustrates the intuition. The Gram matrix from 256×256 features shows relatively coarse similarity structure. The Gram matrix from 512×512 features shows finer, more detailed similarity structure because each patch covers a smaller spatial region. The downsampled Gram matrix preserves this finer structure while matching the student's spatial dimensions. This means the student is learning to produce similarity patterns that reflect the higher-resolution understanding of the scene, even though it is operating at a lower resolution.

The resulting refined objective is called $\mathcal{L}_{\text{HRef}}$ (High-resolution Refinement), and the paper reports that it provides substantial additional gains: +2 mIoU on ADE20k over the baseline refinement (55.7 vs. 53.6), and further improvements on depth estimation (0.281 vs. 0.285 RMSE on NYUv2).

Why is Gram anchoring applied only late in training? The paper applies Gram anchoring only after the 1M-iteration main training phase, not from the beginning. The stated reason is efficiency: computing Gram matrices adds overhead, and early in training, dense features are not yet degrading (they peak around 200k iterations and then decline). However, there is a deeper reason: if Gram anchoring were applied from the start, it would anchor the student to very early features that have not yet learned strong semantics. The DINO and iBOT objectives need time to build discriminative power; only once that power is established does the Gram loss need to "repair" the spatial structure that the ongoing training is gradually destroying.

The paper notes: "Interestingly, we observe that the late application of $\mathcal{L}_{\text{Gram}}$ still manages to 'repair' very degraded local features." This is surprising and important: it shows that the degradation is not permanent—the features can be recovered even after hundreds of thousands of iterations of collapse, because the Gram teacher provides a structural template that the student can rapidly adapt to.

Quantitative and qualitative impact of Gram anchoring (Figures 7, 8, 10).

• iBOT loss drops significantly when Gram anchoring is activated (Figure 7a). The patch-level reconstruction loss decreases more rapidly during refinement than during the baseline continuation of training. The paper interprets this as: "the stability introduced by the stable Gram teacher positively impacts the iBOT objective." The Gram loss provides a stable reference structure that makes the iBOT task easier.

• DINO losses are largely unaffected (Figure 7b). The global discriminative loss continues its slow improvement without noticeable change when Gram anchoring is activated. This confirms the decoupling: Gram anchoring improves spatial structure without interfering with global representation learning.

• Segmentation performance improves dramatically and immediately (Figure 8a-b). On PASCAL VOC, the baseline (no Gram anchoring) shows declining mIoU from 200k iterations onward. With $\mathcal{L}_{\text{HRef}}$, mIoU jumps from ~82 to ~86 within 10k iterations of refinement activation and remains high. On ADE20k, the baseline degrades from ~50 to ~45 mIoU, while $\mathcal{L}_{\text{HRef}}$ recovers to ~55 mIoU—higher than any point during baseline training.

• Global classification continues to benefit (Figure 8c). On ObjectNet, both the baseline and refined models show monotonic improvement, with the refined model maintaining a slight advantage. This shows that Gram anchoring does not sacrifice global performance for local—it allows both to improve.

• Qualitative feature map improvement (Figure 10). The paper visualizes Gram matrices and patch similarity maps before and after $\mathcal{L}_{\text{HRef}}$. The refined model shows much cleaner, more coherent similarity patterns, with clear block-diagonal structure in the Gram matrix indicating well-separated semantic regions.

Post-Training: Resolution Adaptation and Model Distillation

High-resolution post-training (Section 5.1). The base training occurs at 256×256 pixel resolution, which provides a good tradeoff between speed and effectiveness but limits the model's ability to leverage higher-resolution inputs at inference time. The paper addresses this with a brief high-resolution adaptation phase:

• Duration: 10k additional iterations
• Mixed resolutions: Global crops sampled from {512, 768} pixels; local crops sampled from {112, 168, 224, 336} pixels, with different probabilities for each pairing (detailed in Appendix C)
• Gram anchoring active: Using the 7B teacher itself as Gram teacher, with high-resolution features (the Gram teacher processes crops at 768 or 1152 pixels, depending on the configuration)
• Why Gram anchoring is essential during this phase: "We found this component to be essential: without it, the model performance on dense prediction tasks degrades significantly." The resolution increase could disrupt the carefully preserved patch-level consistency, and Gram anchoring prevents this.

Results of resolution adaptation (Figure 11). The adapted model shows:

• Consistent (or slightly improved) performance on ImageNet-1k classification across resolutions 256, 512, 768 (85-89% accuracy)
• Improved OOD robustness on ObjectNet at higher resolutions (80% at 768 vs. 78% at 256)
• Strongly positive scaling with resolution on ADE20k segmentation (58 mIoU at 1536 vs. 54 at 512) and DAVIS tracking (82 J&F at 1440 vs. 72 at 480)
• Support for resolutions far beyond training: features remain semantically coherent at 4096×4096 pixels (Figure 4), despite the maximum training resolution being 768

Multi-student distillation (Section 5.2). Training a 7B model is computationally expensive and inference with it is impractical for many applications. The paper distills the 7B teacher into smaller student models using a custom parallel distillation pipeline:

Distillation setup:

• Students: ViT-S (21M), ViT-S+ (29M), ViT-B (86M), ViT-L (300M), ViT-H+ (840M), and ConvNeXt-T/S/B/L (29M-198M)
• Training objective: Same as base pre-training ($\mathcal{L}_{\text{Pre}}), but with the frozen 7B model as the teacher (no EMA), replacing the standard EMA teacher
• Duration: 1M iterations of constant-schedule training + 250k iterations of cosine cooldown + high-resolution phase (without Gram anchoring, since patch consistency issues are not observed during distillation)
• No Gram anchoring needed: "We do not observe patch-level consistency issues and therefore do not apply the Gram anchoring technique" during distillation

Efficient multi-student distillation architecture (Figure 12). The key efficiency challenge is that the teacher (7B parameters, 3550 GFLOPs at resolution 256) is orders of magnitude more expensive to run than the students (e.g., ViT-S: 12 GFLOPs). In a naive single-student setup, the teacher inference dominates the computation.

The paper's solution: share teacher inference across multiple students being trained simultaneously. The procedure at each training iteration:

1. Teacher inference (shared): All GPUs assigned to all students collectively run the teacher on a batch of $B$ samples. Each GPU processes $B/N_T$ samples, where $N_T$ is the total number of GPUs across all student groups. Teacher inference costs $(B/N_T) \times C_T$ per GPU, where $C_T$ is the cost of processing one sample through the teacher.

2. All-gather inputs and outputs: The input images and teacher outputs are gathered to all GPUs using NCCL collective operations. This ensures each student training group has access to the same data and teacher targets.

3. Student training (parallel per student): Each student $S_i$, assigned to $N_{S_i}$ GPUs, performs its own training step on the $B$ samples at a cost of $(B/N_{S_i}) \times C_{S_i}$ per GPU.

4. Synchronization barrier: All student groups wait for each other to complete before the next iteration.

Load balancing across students. To maximize efficiency, the number of GPUs per student is adjusted so that each student's training step takes approximately the same time. If a large student (e.g., ViT-L) processes more slowly, it gets more GPUs, reducing the per-GPU batch size and thus the computation time per GPU. This minimizes idle time at the synchronization barrier.

Key result: The ViT-H+ student (840M parameters, ~8× smaller than the 7B teacher) achieves performance nearly on par with the teacher across both global and dense tasks (Figure 16b): 87.9 vs. 88.4 IN1k linear, 78.6 vs. 78.9 ObjectNet, 90.3 vs. 90.3 ImageNet-ReAL, 54.8 vs. 55.9 ADE20k mIoU, 80.6 vs. 81.1 Cityscapes mIoU. This validates that the distillation process effectively transfers the teacher's feature quality.

ConvNeXt distillation across architectures. A notable achievement is distilling a ViT teacher into ConvNeXt students (convolutional networks with a fundamentally different architecture). This demonstrates that the learned representations are not architecture-specific—they capture general visual properties that can be transferred across network families. Results (Table 15) show the distilled ConvNeXts dramatically outperform supervised ConvNeXts on dense tasks (e.g., CNX-L: 47.8 vs. 33.3 mIoU on ADE20k) while being competitive on global classification.

Text Alignment with DINOv3 (Section 5.3)

The paper also demonstrates that DINOv3's visual features can be aligned with text to enable zero-shot capabilities, following the dino.txt approach (Jose et al., 2025). This is not central to the main contribution but shows the versatility of the learned representations.

Procedure:

• Keep the DINOv3 vision encoder completely frozen
• Train a text encoder from scratch using the LiT (Locked-image Text tuning) paradigm (Zhai et al., 2022b): contrastive loss between image and text embeddings
• Add two learnable transformer layers on top of the frozen vision backbone to provide some flexibility on the vision side
• Concatenate mean-pooled patch embeddings with the CLS token output before matching to text embeddings, enabling both global and local visual-text alignment
• Use the same data curation protocol as Jose et al. (2025)

The concatenation insight. The key enhancement over standard CLIP-style alignment is using both the CLS token (which captures global image semantics) and the mean-pooled patch features (which capture local spatial information) as the visual representation to be matched with text. This allows the text encoder to learn alignments not just with "what is in the image" but also "where things are"—a denser, more spatially-grounded alignment.

Results (Table 16). The text-aligned DINOv3 ViT-L model achieves competitive zero-shot classification (82.3% on ImageNet-1k, 85.4% on ImageNet-A, 93.0% on ImageNet-R, 80.5% on ObjectNet) and outstanding dense alignment (24.7 mIoU on ADE20k zero-shot segmentation, 36.9 mIoU on Cityscapes), significantly exceeding prior text-aligned models on the dense alignment tasks while remaining competitive on global alignment.

4. Key Insights and Innovations

Innovation 1: Dense Feature Collapse Is a Diagnosable and Solvable Failure Mode of SSL Scaling, Not an Inherent Limitation

Prior to DINOv3, the community's relationship with the scaling behavior of self-supervised features was, at best, confused. On one hand, DINOv2 (Oquab et al., 2024) had shown that SSL could produce strong dense features at the ~1B parameter scale, matching or exceeding CLIP variants on tasks like segmentation and depth estimation. On the other hand, when Fan et al. (2025) attempted to scale the same paradigm to 7B parameters (Web-DINO), they obtained promising global classification results but "disappointing results on dense prediction" — with ADE20k mIoU dropping from DINOv2's 49.5 to 42.7 despite the model being 7× larger. The field lacked a diagnosis: was this an optimization bug? A fundamental information bottleneck? An artifact of poor data curation?

The paper's first and most important intellectual contribution is reframing this not as a mysterious failure but as a specific, identifiable phenomenon with a clean mechanism and a targeted solution. The diagnosis — that extended training causes a progressive loss of patch-level feature consistency, measurable as increasing cosine similarity between CLS tokens and patch features (Figure 5a) and visible as increasingly noisy patch similarity maps (Figure 6) — transforms the problem from "SSL doesn't scale" into "SSL scaling causes an imbalance between global and local objectives, and we can measure and counteract it."

This diagnostic move is fundamentally different from how prior work approached dense feature quality. Previous efforts to improve dense SSL features fell into two categories: (1) adding local training objectives (Jabri et al., 2020; Pinheiro et al., 2020; Bardes et al., 2022), which modified the loss function to explicitly encourage spatial consistency from the beginning, or (2) post-hoc feature cleanup (Hamilton et al., 2022; Simoncini et al., 2024; Wysoczańska et al., 2024), which treated noisy features as an input to be fixed after training. The first approach fails to scale because the balance between objectives is inherently unstable — adding more weight to the local loss at the start doesn't prevent the global loss from dominating later. The second approach is lossy and doesn't address the root cause. DINOv3's framing — that the problem is temporal (it gets worse over training) and structural (it's about the relationship between features, not the features themselves) — is what enables the Gram anchoring solution.

The evidence that this diagnosis is correct, not merely plausible, comes from the ablation in Figure 9b: a Gram teacher from 100k iterations works as well as one from 200k iterations (both achieve 55.7 mIoU on ADE20k), but a Gram teacher from 1M iterations — which has itself undergone the collapse — works worse (54.9 mIoU). The property that matters is the Gram teacher's patch-level consistency, not its semantic power, which is exactly what the diagnosis predicts.

Why this matters beyond DINOv3: this diagnostic concept — that representation quality along different axes can decouple during training, and that catastrophic forgetting of spatial structure can occur even as semantic quality improves — is likely to generalize to other self-supervised learning paradigms. It suggests that future SSL scaling efforts should monitor not just global metrics but also patch-level consistency metrics, and that architectural or optimization choices that seem neutral early in training may have severe consequences later. The finding that the collapse is "repairable" even after hundreds of thousands of iterations of degradation is also practically significant: it means large training runs that show dense feature degradation are not wasted — they can be recovered.

Innovation 2: Gram Anchoring Decouples the Two Axes of Representation Quality by Operating on Similarity Structure Rather Than Feature Values

The second conceptual innovation is the recognition that dense feature regularization can and should operate on a different mathematical object than the features themselves. This is a subtle but deep insight: the DINO and iBOT losses need freedom to shape the absolute feature values (to learn discriminative representations), but the spatial consistency needed for dense tasks is a property of the relative arrangement of features — which patches are similar to which. The Gram matrix captures exactly this relational structure, and because it is rotation-invariant (applying any orthogonal transformation $R$ to the features leaves $X X^\top$ unchanged), regularizing it does not constrain the features' absolute orientation.

This is fundamentally different from prior approaches to dense feature regularization. Methods that enforce feature-level consistency between crops (Pinheiro et al., 2020; Bardes et al., 2022) or across frames (Jabri et al., 2020) operate directly on feature vectors — typically with an MSE or cosine similarity loss between student and teacher patch features at corresponding spatial locations. These approaches do constrain absolute feature values, which can conflict with the global learning objectives. The paper's own loss composition shows this tension: the iBOT loss, which operates at the patch-feature level, decreases more rapidly when the Gram loss is added (Figure 7a), suggesting that the Gram loss "frees" the iBOT objective by providing stable structure. In contrast, the DINO losses (which operate at the image level) are unaffected (Figure 7b), confirming that the decoupling works as intended.

The choice of the Frobenius norm $\| \cdot \|_F^2$ on the Gram matrix difference, rather than alternatives, reflects this philosophy. A direct feature-matching loss $\|X_S - X_G\|_F^2$ would force the student to reproduce the teacher's exact features, preventing the DINO loss from improving them. A cross-entropy or contrastive loss on patch-patch similarities would also work but would be less direct. The Frobenius norm on Gram matrices provides a smooth, differentiable, rotation-invariant signal that regularizes structure without specifying features.

There is a connection here to style transfer literature (Gatys et al., 2016; Johnson et al., 2016), where Gram matrix matching is used to transfer artistic style (the correlation structure of features) independently of content (the absolute feature activations). The paper explicitly references this lineage (Section 2), but the application is novel: in style transfer, the Gram matrix captures texture statistics; in DINOv3, it captures semantic patch-patch similarity structure. The insight that "style transfer" machinery can be repurposed to prevent feature collapse during SSL training is non-obvious and represents a creative synthesis of two previously unconnected research threads.

The practical consequence of this decoupling is that Gram anchoring can be applied late in training (after 1M iterations) and still "repair" heavily degraded features (Figure 8a-b shows mIoU jumping from baseline-degraded levels to above-peak levels within 10k iterations of Gram activation). If the regularization operated on absolute features, this would be impossible — the features would be too far from any reasonable target. Because it operates only on structure, the student can rapidly reorganize its similarity patterns to match the Gram teacher while the DINO loss continues to refine semantic quality.

Innovation 3: An Early-Checkpoint Model Provides a Better Dense Feature Template Than a Converged One — Inverting the Standard "Teacher Quality" Assumption

In knowledge distillation and teacher-student SSL frameworks, the standard assumption is that a better teacher (higher accuracy, later in training, larger model) produces a better student. This is why DINO uses an EMA of the student as the teacher — it's a slowly improving target that is always slightly better than the current model. This assumption holds for global discriminative quality: the DINO teacher at 1M iterations is indeed better than at 200k.

The paper's third conceptual innovation is the recognition that this assumption reverses for dense feature structure. An early checkpoint (100k-200k iterations) produces better patch-level similarity patterns than a later checkpoint (1M iterations), even though the early checkpoint has worse global classification accuracy. The Gram anchoring procedure exploits this counterintuitive property: it anchors the student's patch similarity structure to an early, semantically weaker but spatially cleaner model, while allowing the DINO and iBOT objectives to pull the absolute feature values toward the later, semantically stronger model.

This inverts the standard SSL teacher-student relationship. Instead of a single teacher that provides targets for all objectives, DINOv3 effectively uses two teachers for different aspects of the representation: the EMA teacher (continuously updated, semantically strong) for global discriminative features via the DINO loss, and the Gram teacher (frozen early checkpoint, spatially clean) for patch similarity structure via the Gram loss. This split-teacher design is novel in SSL and reflects the paper's core insight that global and local representation quality are along decoupled axes with different optimal training durations.

The ablation in Figure 9b provides clear evidence: Gram teachers from 100k and 200k iterations produce essentially identical results (55.7 mIoU on ADE20k), while a Gram teacher from 1M iterations produces worse results (54.9 mIoU). The 1M teacher has better semantic features but degraded spatial structure, confirming that spatial structure quality, not semantic quality, is what matters for the Gram objective. The paper also finds that updating the Gram teacher every 10k iterations (to the current EMA teacher) is beneficial, which suggests that as the student's features improve, the Gram target can be gradually upgraded without reintroducing the collapse.

This insight has broader implications for SSL training dynamics. It suggests that the "sweet spot" for different representation properties occurs at different points in training, and that optimal training might involve asynchronous goals — using earlier states of the model to regularize aspects that peak early, while continuing to optimize aspects that improve monotonically. This is a departure from the standard practice of optimizing a single objective (or fixed combination of objectives) throughout training, and it may generalize to other SSL methods beyond DINO.

Innovation 4: High-Resolution Feature Smoothing via Bicubic Downsampling as a Teacher Signal — A Practical Mechanism for Resolution-Generalizable Dense Features

The fourth innovation is a specific, practically effective technique embedded within the Gram anchoring framework: using higher-resolution inputs to the Gram teacher, followed by bicubic downsampling, to produce smoother and more coherent patch similarity targets for the student. While this is a mechanism rather than a standalone conceptual contribution, it represents a distinctive insight about how to leverage resolution differences to improve feature quality.

The key observation (Figure 9a) is that higher-resolution feature maps contain finer, more coherent patch-patch similarity structure, and that this structure survives bicubic downsampling. A $32 \times 32$ feature map computed on a 512×512 image captures spatial relationships at a finer granularity than a $16 \times 16$ map on a 256×256 image. Downsampling the $32 \times 32$ map to $16 \times 16$ via bicubic interpolation effectively averages the fine-grained similarities, producing a smoother, less noisy similarity matrix than what the student would produce directly at $16 \times 16$. By using this downsampled matrix as the Gram target, the student learns to produce similarity patterns that reflect the higher-resolution understanding of the scene without actually processing higher-resolution inputs itself.

This technique has an important practical consequence: it enables the model to produce clean feature maps at resolutions far beyond its training resolution (Figures 3, 4, and 17 show coherent features at 4096×4096 despite maximum training resolution of 768). The combination of RoPE position embeddings (which generalize to arbitrary sequence lengths) and Gram anchoring with high-resolution teachers (which teaches the model what clean similarity structure looks like) produces a model that is resolution-generalizable — a property that is rare in vision transformers, which typically require careful interpolation or fine-tuning when resolution changes significantly.

The paper's evidence that this matters comes from the comparison between $\mathcal{L}_{\text{Ref}}$ (standard-resolution Gram teacher) and $\mathcal{L}_{\text{HRef}}$ (high-resolution Gram teacher) in Figure 8: the high-resolution variant provides an additional +2 mIoU on ADE20k (55.7 vs. 53.6) and better depth estimation (0.281 vs. 0.285 RMSE on NYUv2). This gap, while not enormous in absolute terms, is significant because it comes from a change only in the teacher's input resolution — the student architecture and training resolution are identical. It demonstrates that the quality of the Gram target matters, and that higher-resolution features contain structural information that can be effectively transferred to a lower-resolution student.

The connection to recent work on feature upsampling (Fu et al., 2024) and patch smoothing (Wysoczańska et al., 2024) is worth noting. Those methods apply post-hoc operations to improve feature map quality at inference time. The high-resolution Gram anchoring approach achieves a similar effect during training, baking the smoothness into the learned representations rather than applying it as a separate step. This is more efficient at deployment time (no additional processing needed) and likely more robust (the features are inherently smooth rather than artificially smoothed).

Innovation 5: Self-Supervised Learning Can Produce Universally Superior Dense Features Without Any Form of Supervision — Reframing the SSL vs. Weakly-Supervised Debate

The paper's final innovation is not a method but an empirical finding with significant implications for the field: a frozen SSL backbone, trained purely on images without any labels, captions, or metadata, can outperform all existing frozen backbones — including those distilled from heavily supervised models like SAM — on essentially every dense prediction task evaluated, while matching or approaching the best weakly-supervised models on global tasks.

This finding challenges the emerging narrative that SSL is fundamentally limited compared to CLIP-style or agglomerative approaches for dense tasks. The paper's baselines include AM-RADIOv2.5 (Heinrich et al., 2025) and PEspatial (Bolya et al., 2025), both of which distill knowledge from SAM (Kirillov et al., 2023) — a model trained with explicit mask supervision — into their backbones. If supervision provided a fundamental advantage for dense features, these agglomerative models should outperform pure SSL. The empirical result is the opposite: DINOv3 achieves 55.9 mIoU on ADE20k linear segmentation vs. 53.0 for AM-RADIO and 49.3 for PEspatial (Table 3), and 64.4% recall on NAVI 3D keypoint matching vs. 59.4 and 53.8 (Table 4). The gap is even larger on tasks that require physical scene understanding: 0.309 RMSE on NYUv2 depth estimation vs. 0.340 for AM-RADIO and 0.362 for PEspatial.

What makes this result intellectually significant rather than merely a benchmark victory is that it reframes the debate about what self-supervised learning is capable of. Prior to DINOv3, the strongest dense features came from models that incorporated supervision somewhere in the pipeline — either directly (supervised pretraining on JFT or ImageNet) or indirectly (CLIP's image-text pairs, SAM's masks). The field's default assumption was that SSL could produce competitive dense features but not best-in-class ones, especially when compared to models with access to segmentation masks. DINOv3 falsifies this assumption: SSL not only matches but exceeds supervised approaches on dense tasks, and it does so with a frozen backbone — no fine-tuning, no task-specific adaptation.

The complementary finding — that SSL can match weakly-supervised models on global classification (Tables 7 and 8) — is also important, but less surprising given DINOv2's results. What is new is the combination: DINOv3 is the first model to simultaneously achieve (a) best-in-class dense features by large margins and (b) competitive global features. This combination is what makes the model truly "generalist" — a single frozen backbone that serves diverse downstream needs without compromise.

The paper's geospatial results (Section 8) provide an existence proof for the claim that SSL's advantages extend beyond web images. On satellite imagery, DINOv3 models achieve state-of-the-art performance on 12 out of 15 classification, segmentation, and detection tasks (Tables 18 and 19), including tasks where competing models use 6+ spectral bands while DINOv3 uses only RGB. This demonstrates that the SSL training recipe is genuinely domain-agnostic — the same algorithm, applied to a completely different image distribution, produces similarly powerful features without any domain-specific modification. This is a practically significant finding for the many scientific domains where labeled data is scarce and SSL is the only scalable approach.

The broader implication is that the supervised and weakly-supervised pretraining paradigms may face diminishing returns relative to SSL as scale increases. Supervision provides a strong inductive bias when data is limited, but as training sets grow to billions of images, the diversity and volume of data may matter more than the quality of the supervisory signal. DINOv3's results suggest that at the scale of 1.7B curated images, SSL's advantage in data volume (not being constrained by metadata availability) begins to outweigh CLIP's advantage in signal quality (text provides rich semantic grounding). If this trend continues with further scaling, it would represent a fundamental shift in the economics of foundation model training — away from expensive data annotation and toward scalable, annotation-free learning.

5. Experimental Analysis

Evaluation Methodology

This section establishes the framework for evaluating DINOv3's representations. All evaluations share a core principle: the backbone is kept frozen, and downstream tasks train only lightweight decoders (linear probes, shallow transformers, or non-parametric algorithms) on top of its features. This protocol directly tests the quality of the learned representations themselves, removing confounding factors from backbone fine-tuning.

• Datasets. The paper evaluates on a comprehensive suite spanning diverse computer vision tasks. For dense tasks: ADE20k (Zhou et al., 2017, scene parsing with 150 categories across 20k training / 2k validation images), Cityscapes (Cordts et al., 2016, urban scene understanding), PASCAL VOC 2012 (Everingham et al., 2012, object segmentation), NYUv2 (Silberman et al., 2012, indoor depth estimation), KITTI (Geiger et al., 2013, outdoor depth), NAVI (Jampani et al., 2023, 3D geometric correspondence), SPair (Min et al., 2019, semantic correspondence), DAVIS 2017 (Pont-Tuset et al., 2017, video object tracking), YouTube-VOS (Xu et al., 2018, video segmentation), and MOSE (Ding et al., 2023, complex scene tracking). For global tasks: ImageNet-1k and its distribution-shift variants (ImageNet-V2, ImageNet-R, ImageNet-Sketch, ImageNet-A, ImageNet-C, ObjectNet), a suite of fine-grained classification datasets (Food-101, CIFAR-10/100, SUN397, Stanford Cars, FGVC-Aircraft, DTD, Oxford Pets, Caltech-101, Flowers, CUB-200, Places205, iNaturalist 2018/2021), and instance retrieval benchmarks (Oxford-Hard, Paris-Hard, Met, AmsterTime). For complex system building: COCO (Lin et al., 2014, object detection), COCO-O (Mao et al., 2023, OOD detection), and additional segmentation datasets (COCO-Stuff, Hypersim). For geospatial tasks: SatLidar (canopy height), GEO-Bench (Lacoste et al., 2023, 6 classification + 6 segmentation tasks), LoveDA (Wang et al., 2022a, land cover), iSAID (Zamir et al., 2019, aerial instance segmentation), and DIOR (Li et al., 2020, aerial object detection).

• Base model(s). The flagship model is a ViT-7B/16 — a custom 6.7B-parameter vision transformer with 40 blocks, embedding dimension 4096, and patch size 16, trained on 1.689B curated images for 1M iterations plus Gram anchoring refinement plus high-resolution post-training. This model is evaluated as a frozen backbone throughout Section 6. The distilled model family (ViT-S/21M, ViT-S+/29M, ViT-B/86M, ViT-L/300M, ViT-H+/840M, and ConvNeXt-T/S/B/L) is evaluated in Section 7. The ViT-7B was chosen to push SSL scaling to an order of magnitude beyond DINOv2's 1.1B ViT-g, testing whether SSL can produce frontier-level representations when scale is increased.

• Metrics. Dense tasks: mean Intersection-over-Union (mIoU) for semantic segmentation; Root Mean Squared Error (RMSE) for depth; correspondence recall at specified distance thresholds for 3D matching; J&F-mean (Perazzi et al., 2016) for video tracking; Correct Localization (CorLoc) for object discovery. Global tasks: top-1 accuracy for classification; mean Average Precision (mAP) or Global Average Precision (GAP) for retrieval. Detection: mAP at IoU thresholds [0.5:0.05:0.95]. The exact computation of each metric follows the standard protocol for each benchmark (detailed in Appendix D).

• Baselines. The paper compares against the strongest publicly available vision encoders across three categories. Self-supervised: DINOv2 with registers (Oquab et al., 2024; Darcet et al., 2024, ViT-g/14), Web-DINO (Fan et al., 2025, ViT-7B/14, a recent scaling attempt that showed poor dense features), Franca (Venkataramanan et al., 2025, ViT-g/14, best open-data SSL model), and DINO (Caron et al., 2021) for object discovery. Weakly-supervised: SigLIP 2 (Tschannen et al., 2025, ViT-g/16 and SO400m variants), Perception Encoder (PE) Core and PEspatial (Bolya et al., 2025, ViT-G/14), AIMv2 (Fini et al., 2024, 3B/14), and EVA-CLIP-18B (Sun et al., 2024). Agglomerative (distilled from multiple sources including supervised models): AM-RADIOv2.5 (Heinrich et al., 2025, ViT-g/14). For the complex system evaluations, additional task-specific state-of-the-art baselines are included (BEIT-3, InternImage-G/H, ONE-PEACE, EVA-02 with various detectors, MiDaS, LeReS, DPT, Marigold, Depth Anything V2, VGGT).

• Generation budget / compute accounting. Since backbones are frozen, the "compute budget" is not a variable being optimized (unlike the inference-time compute scaling papers). Instead, the paper measures model quality per unit of inference compute by reporting performance against model size (parameter count) and inference FLOPs (Figure 2 and Figure 16a). For fair comparison between models with different patch sizes, the paper matches the number of patch tokens: models with patch size 16 use 512×512 input resolution, while patch size 14 models use 448×448, both producing 1024 patch tokens. This controls for the spatial granularity of features, ensuring comparisons reflect feature quality rather than resolution differences.

• Cross-validation / statistical protocol. For the main evaluation, no cross-validation is used — models are evaluated once on standard test/validation splits. Hyperparameters for linear probes are selected via sweeps over learning rate and weight decay using the standard validation sets (e.g., ImageNet-1k validation set for classification hyperparameter selection, DAVIS training set for tracking hyperparameter selection). For each backbone, the paper evaluates features from the final layer (after layer normalization) by default, with some tasks also exploring intermediate layers (Figure 21). The per-layer analysis is instructive: performance on classification and segmentation increases smoothly to the final layer, while depth estimation, tracking, and 3D correspondence peak around layer 32, indicating intermediate layers carry more geometric information. For complex system building (Sections 6.3.1–6.3.4), training uses standard practices for each task (Objects365 pre-training for detection, COCO-Stuff+Hypersim pre-training for segmentation), with results reported on standard validation splits.

Main Quantitative Results

The evaluation is organized into three complementary views of representation quality: (1) lightweight probing of dense features (linear classifiers, non-parametric algorithms) to isolate feature quality from decoder capacity; (2) lightweight probing of global features to assess semantic understanding; and (3) complex system building where DINOv3 serves as the foundation for state-of-the-art pipelines. Each evaluation uses the frozen 7B backbone unless otherwise specified.

Dense Feature Quality: Linear Probing and Non-Parametric Evaluation

Dense linear probing (Tables 3). This is the purest test of feature quality: a single linear layer is trained on frozen patch features to predict per-pixel semantic labels or depth values. On ADE20k semantic segmentation, DINOv3 achieves 55.9 mIoU, compared to 49.5 for DINOv2 (+6.4 points), 46.3 for Franca, 42.7 for both Web-DINO and SigLIP 2, and 38.9 for PEcore. This gap of ~13 mIoU points over the best weakly-supervised model is the headline dense result. Notably, DINOv3 also surpasses the agglomerative models that incorporate SAM supervision: AM-RADIOv2.5 (53.0) and PEspatial (49.3), by +2.9 and +6.6 points respectively. On Cityscapes (self-driving scenes), DINOv3 achieves 81.1 mIoU, outperforming AM-RADIO by 2.5 points and all other models by at least 5.5 points. On VOC 2012, DINOv3 reaches 86.6 mIoU vs. 83.1 for DINOv2 and 85.4 for AM-RADIO.

On monocular depth estimation, DINOv3 achieves 0.309 RMSE on NYUv2 and 2.346 RMSE on KITTI, significantly lower (better) than all competitors: DINOv2 (0.372 / 2.624), AM-RADIO (0.340 / 2.918), PEspatial (0.362 / 3.082), and the weakly-supervised models (0.494-0.590 / 3.273-4.119). The KITTI result is particularly striking: DINOv3 outperforms its predecessor by 0.278 RMSE, while PEspatial and AM-RADIO actually perform worse than DINOv2 on this metric despite incorporating SAM knowledge.

3D correspondence estimation (Table 4). Using Probe3D (Banani et al., 2024) to evaluate multi-view consistency, DINOv3 achieves 64.4% recall on NAVI (geometric correspondence) and 58.7% on SPair (semantic correspondence). This represents +4.3% and +2.6% improvements over DINOv2 (60.1% / 56.1%), and larger margins over weakly-supervised models: SigLIP 2 (49.4% / 42.6%), PEcore (39.9% / 23.1%). AM-RADIO (59.4% / 56.8%) nearly reaches DINOv2 but PEspatial (53.8% / 49.6%) lags significantly. The finding that weakly-supervised models perform poorly on 3D tasks is consistent with the hypothesis that text-based training does not capture geometric properties that SSL naturally encodes.

Unsupervised object discovery (Figure 14). Using the non-parametric TokenCut algorithm (Wang et al., 2023c) on frozen patch features, DINOv3 achieves 66.1 CorLoc on VOC07, 69.5 on VOC12, and 55.1 on COCO-20k. This substantially exceeds the original DINO (which set a very high bar: 61.1 / 66.0 / 48.7 on DINO-S/16) and DINOv2 (55.6 / 60.4 / 45.4). The improvement over DINOv2 is 10.5 points on VOC07, which the paper attributes to DINOv3's "clean and precise output feature maps" compared to DINOv2's noisy patch features (visible in Figure 13). Weakly-supervised models perform dramatically worse: SigLIP 2 achieves 20.5 / 24.7 / 18.6, and PEcore 14.2 / 18.2 / 13.5, confirming that object discovery requires the kind of spatially coherent features that SSL provides. Web-DINO (26.1 / 29.7 / 20.9) also fails badly on this task, presumably due to its poorly maintained dense features at scale.

Video segmentation tracking (Table 5). Evaluating temporal consistency via non-parametric label propagation on DAVIS, YouTube-VOS, and MOSE, DINOv3 achieves 71.1 / 79.7 / 83.3 J&F on DAVIS at small/medium/large resolutions (480/960/1440 pixels short side), 74.1 / 80.2 / 80.7 on YouTube-VOS, and 46.0 / 53.9 / 55.6 on MOSE. At the highest DAVIS resolution, DINOv3 outperforms DINOv2 (76.6) by 6.7 points and AM-RADIO (81.4) by 1.9 points. A critical observation: DINOv3's performance increases monotonically with resolution (55.6 → 83.3 on DAVIS), indicating the model effectively leverages additional spatial information. In contrast, PEspatial degrades at higher resolutions (68.4 → 70.5 on DAVIS, falling to 70.5 at large resolution), and weakly-supervised models plateau or decline.

Video classification (Table 6). Using attentive probes (shallow 4-layer transformers) on frozen patch features, DINOv3 achieves competitive results on UCF101 (93.5% / 93.5% single/TTA), Something-Something V2 (70.1% / 70.8%), and Kinetics-400 (87.8% / 88.2%). On SSv2, DINOv3 slightly exceeds PEcore (69.0% / 70.4%) and SigLIP 2 (68.8% / 70.2%), while the dedicated video model V-JEPA 2 leads (73.8% / 75.4%). On K400, DINOv3 is essentially tied with PEcore (87.9% / 88.8%) and SigLIP 2 (86.9% / 87.7%). This demonstrates that DINOv3's image-level features, without any video-specific training, serve as strong video representations.

Global Feature Quality: Classification and Retrieval

Image classification with linear probing (Table 7). Training a linear classifier on the frozen CLS token for ImageNet-1k and evaluating on OOD variants, DINOv3 achieves 88.4% on ImageNet-1k validation, compared to 87.3% for DINOv2, 89.1% for SigLIP 2, 89.3% for PEcore, and 89.5% for the supervised ViT-22B (not directly comparable due to different evaluation protocol). On OOD benchmarks, DINOv3 shows substantial gains over DINOv2: ImageNet-R (91.1% vs. 81.1%, +10.0), ImageNet-Sketch (71.3% vs. 65.4%, +5.9), ObjectNet (79.0% vs. 66.4%, +12.6). Compared to the best weakly-supervised models, DINOv3 is competitive: slightly behind PEcore on ImageNet-R (91.1% vs. 92.2%), ImageNet-A (86.9% vs. 89.0%), and ObjectNet (79.0% vs. 80.2%), but notably ahead on ImageNet-C (19.6 mCE vs. 22.7 — lower is better, indicating superior corruption robustness).

This is a landmark result: it is the first time an SSL model has reached comparable performance to weakly- and fully-supervised models on image classification, which has historically been the strong point of supervised approaches. The paper emphasizes that models like ViT-22B, SigLIP 2, and PE are trained using massive human-annotated datasets, while DINOv3 learns purely from images.

Fine-grained classification (Table 8). On specialized recognition tasks, DINOv3 achieves 93.0% average on 12 small datasets (Fine-S), 70.0% on Places205, 85.6% on iNaturalist 2018, and 89.8% on iNaturalist 2021 — the last being the highest among all models, surpassing PEcore (87.0%) by 2.8 points. This is notable because iNaturalist 2021 is a challenging dataset requiring discrimination between fine-grained species categories, where the text-based training of CLIP derivatives was expected to provide an advantage.

Instance recognition (Table 9, with full metrics in Table 23). Using non-parametric cosine similarity retrieval on the CLS token, DINOv3 achieves 60.7% mAP on Oxford-Hard, 87.1% on Paris-Hard, 55.4% GAP on Met, and 56.5% mAP on AmsterTime — the highest across all models by large margins. The improvements over the second-best model (DINOv2) are striking: +10.8 points on Met, +7.6 points on AmsterTime, +2.5 points on Oxford-Hard. Weakly-supervised models perform poorly on these tasks: SigLIP 2 achieves 25.1% on Oxford-Hard and 0.0% GAP on Met; PEcore achieves 32.7% and 10.6% respectively. This pattern — SSL dominating instance-level retrieval — is consistent across all four datasets and suggests that SSL learns more instance-discriminative features than text-aligned training.

Complex System Building: DINOv3 as a Frozen Foundation

Object detection (Table 10). Training a Plain-DETR decoder with 100M parameters on top of the frozen DINOv3 7B backbone, the system achieves 65.6 mAP on COCO (single-scale) and 66.1 mAP with test-time augmentation. This matches or exceeds specialized detection systems that fine-tune the entire backbone: EVA-02 with Cascade (64.1 mAP, 300M trainable parameters), InternImage-G with DINO (65.1 mAP, 6B trainable), EVA-02 with Co-DETR (65.4 mAP, 300M trainable), and PEspatial with DETA (65.3 mAP, 50M trainable). On COCO-O (out-of-distribution detection), DINOv3 achieves 66.4 mAP with an effective robustness of 36.8, significantly exceeding the best prior result (PEspatial: 64.0 mAP, 34.7 ER). Critically, DINOv3 achieves these results with a frozen backbone — the encoder's 7B parameters are not updated — making it "the first competitive detection model to use a frozen backbone." This has major practical implications: a single backbone forward pass can simultaneously serve classification, segmentation, and detection, dramatically reducing deployment compute.

Semantic segmentation (Table 11). With a ViT-Adapter + Mask2Former decoder (927M parameters) trained on frozen DINOv3 features, the system achieves 62.6 mIoU on ADE20k (single-scale) and 63.0 mIoU (multi-scale TTA), matching ONE-PEACE (63.0 mIoU with 2.2B trainable parameters) and exceeding BEIT-3 (62.8 mIoU with 1.6B trainable) and InternImage-H (62.9 mIoU with 1.3B trainable). On additional datasets (Table 24), DINOv3 achieves 53.8 mIoU on COCO-Stuff 164k (single-scale), 86.1 mIoU on Cityscapes, and 90.1 mIoU on VOC 2012 — state-of-the-art or near it on all, while keeping the backbone frozen. The paper notes that all baseline methods require backbone fine-tuning, making the frozen-backbone achievement particularly significant.

Monocular depth estimation (Table 12). Replacing DINOv2 with DINOv3 in the Depth Anything V2 pipeline (Yang et al., 2024b) produces a relative depth estimator that sets new state-of-the-art on four of five benchmarks: NYUv2 (4.3 ARel, 98.0 δ1), KITTI (7.3, 96.7), ETH3D (5.4, 97.5), ScanNet (4.4, 98.1), and DIODE (25.6, 82.2 — second to DPT on ARel but best on δ1). This is remarkable because the backbone is frozen (all baselines require fine-tuning), and it validates that DINOv3 inherits DINOv2's strong sim-to-real generalization — critical since Depth Anything v2 trains on synthetic data.

3D understanding with VGGT (Table 13). Simply swapping DINOv2 with DINOv3 ViT-L in the Visual Geometry Grounded Transformer (Wang et al., 2025) produces consistent improvements across three 3D tasks: camera pose estimation on Re10K (86.3 vs. 85.3 AUC@30) and CO3Dv2 (89.6 vs. 88.2), multi-view depth estimation on DTU (0.368 vs. 0.382 overall error), and two-view matching on ScanNet-1500 (35.2 / 56.1 vs. 33.9 / 55.2 AUC@5/10). These gains come with minimal tuning (resolution adjustment for patch size 16, slightly lower learning rate, and using four intermediate layers instead of just the final layer). The paper notes this suggests further improvements would be possible with the larger 7B model.

Ablation Studies and Robustness Checks

The paper's ablation studies are distributed across Sections 3, 4, 5, and the Appendix. Here they are consolidated and assessed.

Data curation strategy (Table 1): Training models for 200k iterations on different data compositions, the full LVD-1689M mixture achieves best or near-best performance across all five evaluation tasks, confirming that combining clustering-based diversity curation with retrieval-based relevance curation outperforms either strategy alone. Raw data performs well on IN1k k-NN (80.1%) but poorly on Paris retrieval (63.3%). Clustering-only excels at Paris retrieval (85.2%) but underperforms on classification. The mixture achieves 84.6% IN1k k-NN, 87.2% IN1k linear, 72.8% ObjectNet, 87.0% iNaturalist, and 85.9% Paris retrieval.

Choice of Gram teacher checkpoint (Figure 9b): Gram teachers from 100k iterations (55.7 mIoU on ADE20k) and 200k iterations (55.7 mIoU) produce identical results, while a Gram teacher from 1M iterations — after dense feature collapse — produces worse results (54.9 mIoU). This confirms that Gram teacher quality (patch-level consistency) matters more than its semantic strength, and that early checkpoints provide the cleanest patch similarity structure.

Standard vs. high-resolution Gram teacher (Figure 9b): The standard-resolution Gram teacher (×1) achieves 53.6 mIoU on ADE20k and 0.285 RMSE on NYUv2, while the high-resolution variant (×2, with bicubic downsampling) achieves 55.7 mIoU and 0.281 RMSE — a non-trivial +2.1 mIoU improvement from only changing the teacher's input resolution. This validates the high-resolution Gram anchoring technique ($\mathcal{L}_{\text{HRef}}$).

Resolution adaptation effect (Figure 11): Comparing the 7B model before and after high-resolution post-training, the adapted model maintains stable ImageNet accuracy across resolutions (85-89% at 256/512/768), improves OOD robustness on ObjectNet at higher resolutions (80% at 768 vs. 78% at 256), and shows positive scaling with resolution on ADE20k segmentation (58 mIoU at 1536 vs. 54 at 512) and DAVIS tracking (82 J&F at 1440 vs. 72 at 480). Without Gram anchoring during this phase, the paper states performance degrades significantly (no quantitative result shown, stated as essential in Section 5.1).

Outlier mitigation strategies (Appendix A, Figure 20): Training 7B models for 150k iterations with different approaches to handling high-norm patch outliers: using 4 register tokens achieves the best trade-off (86.6% IN1k linear, 53.0 mIoU on ADE20k), outperforming no strategy (86.4%, 53.2), attention bias (86.5%, 52.7), and value gating (86.3%, 52.2). Register tokens also produce the cleanest qualitative patch norm distributions (Figure 20a). This validates the choice to retain Darcet et al. (2024)'s register approach rather than adopting newer alternatives (An et al., 2025).

Feature dimension outliers (Appendix A.2): A separate type of outlier emerges in the feature (channel) dimension — specific dimensions attain exceptionally large magnitudes that persist across patches, images, and layers. These are found to play a role during training (removing them degrades performance) but carry trivial signals at inference (removing them doesn't affect performance). The paper recommends always applying the final layer normalization to outputs, which substantially scales down these outlier dimensions, or applying batch normalization for features from intermediate layers. This is an important practical finding for users of the model.

Per-layer feature analysis (Figure 21): Evaluating features from each of the 40 transformer layers on five tasks reveals that the final layer is a good default choice (performance increases smoothly for classification and segmentation, peaking at layer 40), but tasks with strong geometric components (depth estimation, tracking, 3D correspondence) peak slightly earlier (around layer 32). This informs downstream usage: for geometric tasks, using intermediate features can improve results.

Distillation effectiveness (Figure 16b, Table 14): The ViT-H+ student (840M parameters) achieves performance nearly on par with the 7B teacher (88.4 vs. 88.4 IN1k, 78.6 vs. 78.9 ObjectNet, 54.8 vs. 55.9 ADE20k), despite being ~8× smaller. The full model family comparison (Table 14) shows DINOv3 students consistently outperform comparably-sized DINOv2, SigLIP 2, and PE students on dense tasks, with the margin growing at larger model sizes (ViT-L: 54.9 vs. 48.8 DINOv2 on ADE20k, a +6.1 mIoU gap).

ConvNeXt distillation (Table 15): Distilling the ViT-7B teacher into ConvNeXt architectures (fundamentally different from ViT) produces models that dramatically outperform supervised ConvNeXts on dense tasks (CNX-L: 47.8 vs. 33.3 mIoU on ADE20k, CNX-T: 42.7 vs. 24.8), while being competitive on global classification at matched resolutions. Additionally, the DINOv3 ConvNeXts scale positively with resolution (improving from 256 to 512), whereas supervised ConvNeXts degrade significantly. This demonstrates the transferability of SSL-learned features across architectures and the robustness to resolution changes.

Text alignment (Table 16): Aligning DINOv3 ViT-L with text via dino.txt (Jose et al., 2025) produces competitive zero-shot classification (82.3% IN1k, 85.4% IN-A, 93.0% IN-R, 80.5% ObjectNet) and outstanding dense alignment (24.7 mIoU on ADE20k, 36.9 on Cityscapes — significantly exceeding all prior text-aligned models). This demonstrates that DINOv3's features are compatible with text alignment, though the paper does not ablate design choices specific to this stage.

Domain transfer to satellite imagery (Section 8, Tables 17-19): Applying the identical DINOv3 training recipe to satellite images (SAT-493M dataset, 493M 512×512 images) produces a satellite-specific 7B model that sets new state-of-the-art on canopy height estimation (2.02 MAE on Open-Canopy, vs. 2.42 for Tolan et al., 2024) and on 12/15 GEO-Bench tasks. Notably, the web-trained DINOv3 7B also performs surprisingly well on geospatial tasks, achieving 81.6% average on GEO-Bench classification (vs. 81.1% for the satellite-trained 7B) and state-of-the-art on LoveDA segmentation (56.2 mIoU) and DIOR detection (80.5 mAP). This dual finding — domain-specific pretraining helps for metric tasks while web pretraining generalizes remarkably well to semantic geospatial tasks — demonstrates the versatility of the DINOv3 SSL paradigm.

Critical Assessment

The experimental evaluation in this paper is extraordinarily comprehensive, spanning ~15 distinct benchmarks across dense, global, 3D, video, and geospatial tasks. The sheer breadth of evaluation is itself a contribution — it establishes DINOv3 as the new state-of-the-art across so many settings that the evidence for its representational quality is overwhelming. However, several aspects of the experimental design warrant scrutiny.

The frozen backbone protocol is rigorous and well-motivated, but creates an asymmetric comparison. The paper's central claim — that SSL can produce universally superior dense features — is demonstrated exclusively under the frozen backbone protocol. All DINOv3 results keep the backbone completely frozen, training only lightweight decoders. This is the correct protocol for evaluating representation quality, since it isolates feature learning from decoder capacity. However, the baselines are evaluated under the same protocol (frozen backbones with matched linear probes) — and many of these baselines (particularly SigLIP 2, PEcore, and DINOv2) were designed to be fine-tuned for downstream tasks. CLIP derivatives, for example, are typically fine-tuned when used for segmentation, and SAM-distilled models are intended to leverage the mask decoder. By comparing all models under a frozen-backbone protocol, the paper is testing DINOv3 on its home turf while potentially handicapping baselines that achieve their best results with fine-tuning.

This is not necessarily unfair — the paper's explicit goal is to build a model that works well frozen, which is a legitimate and practically valuable objective. But it does mean the claim "DINOv3 outperforms all existing backbones on dense tasks" should be understood as "when all backbones are frozen," not necessarily "when all backbones are used in their optimal configuration." The complex system evaluations (Sections 6.3.1–6.3.4) partially address this by comparing against fine-tuned state-of-the-art systems. In those comparisons, DINOv3 with a frozen backbone matches or exceeds systems that fine-tune, which is stronger evidence. But the baseline fine-tuned systems are not the same architectures as the frozen baselines in Section 6.1, making direct comparisons difficult.

The training recipe includes ImageNet-1k as a curated component of the data mixture, which complicates claims of "no supervision." The paper explicitly includes ImageNet-1k (~1.28M labeled images) in its training data, both as a separate dataset component and as homogeneous batches interleaved at 10% of training iterations. While ImageNet labels themselves are not used (training is still SSL), the selection of which images to include is informed by human annotation — ImageNet exists because humans labeled it. This is a form of weak supervision via data curation. The paper is transparent about this: the data section clearly describes the three-part mixture, and the ablation in Table 1 shows that including standard datasets improves performance. But a model trained on DataComp-1B or another fully unsupervised web crawl might not achieve the same results.

The geospatial experiments in Section 8 provide partial evidence that this dependence is not critical: the satellite DINOv3 model was trained on SAT-493M, a domain-specific dataset without ImageNet, and achieved state-of-the-art results. However, SAT-493M was itself curated (sampled from Maxar imagery), and the paper does not specify whether any form of metadata-guided selection was used. A fully unsupervised training run on truly raw, uncurated web data would be a stronger test of the "no supervision" claim.

The 7B model is compared primarily against smaller baselines, which is partially justified by the frozen vs. fine-tuned asymmetry but still limits conclusions about scaling efficiency. DINOv3's main competitor is DINOv2 ViT-g (1.1B parameters). The 7B model is ~6× larger, and while some baselines match or approach its size (EVA-CLIP-18B, ViT-22B), the direct SSL-to-SSL comparison is between a 7B model and a 1.1B model. The question "how much of the improvement comes from scale vs. method?" is partially addressed by Web-DINO (Fan et al., 2025), which is also a 7B SSL model but performs poorly on dense tasks (42.7 mIoU on ADE20k vs. DINOv3's 55.9). This suggests Gram anchoring is responsible for a substantial fraction of the gain. However, Web-DINO was trained on different data (possibly less curated), with different hyperparameters, and for an unknown duration, making it an imperfect ablation of scale alone.

The distilled model family (Section 7) provides a cleaner comparison at matched sizes. At ViT-L (300M) scale, DINOv3 achieves 54.9 mIoU on ADE20k vs. 48.8 for DINOv2 ViT-L — a +6.1 point improvement that cannot be attributed to model size, since both are ViT-L. At ViT-B scale, DINOv3 achieves 51.8 vs. 48.4 for DINOv2 (+3.4 points). These gaps, while significant, are smaller than the 7B vs. ViT-g gap (+6.4 points for 55.9 vs. 49.5), suggesting that roughly half the improvement comes from better training methodology (Gram anchoring) and half from scale. The paper does not explicitly quantify this partitioning.

The Gram anchoring ablation could be more systematic. While Figure 9b provides a clean ablation of Gram teacher iteration and resolution, several important questions are left unanswered. What is the effect of the Gram loss weight $w_{\text{Gram}}$? The paper uses $w_{\text{Gram}} = 2$ but does not ablate this choice. What happens if Gram anchoring is applied from the beginning of training rather than only after 1M iterations? The paper states this is for efficiency but doesn't test it. Does the number of Gram teacher updates matter? The paper updates every 10k iterations up to 3 times but doesn't show results for different update frequencies. Is the Frobenius norm the best choice, or would other Gram matrix metrics (e.g., a kernel-based divergence) work better? These are all reasonable ablations that would strengthen the claim that Gram anchoring is the optimal solution rather than simply a solution that works.

The resolution generalization claims are visually compelling but quantitatively limited. Figures 3, 4, and 17 show impressive feature maps at resolutions up to 4096×4096, and Figure 17 shows systematic evaluation of feature consistency across resolutions. However, the quantitative evaluation of resolution scaling (Figure 11) only goes up to 1536 for ADE20k and 1440 for DAVIS — well below the 4K resolutions shown qualitatively. The paper claims the model "stays clean even at high resolutions" but doesn't provide quantitative metrics for segmentation or tracking at 4K. This matters because qualitative PCA visualizations can be misleading — features might look clean while losing the semantic precision needed for downstream tasks. A linear probe evaluation at 4K on a task where higher resolution should help (e.g., detecting small objects) would be more convincing.

The video and 3D evaluations use the frozen image backbone without any temporal/multi-view fine-tuning, which is impressive but leaves open the question of whether DINOv3's representations could be further improved for these domains. The tracking results (Table 5) are remarkable for a model that has never seen video during training. However, the gap between DINOv3's image features and dedicated video models (e.g., V-JEPA 2 on SSv2 in Table 6: 75.4% vs. 70.8%) suggests that temporal training provides benefits that pure image SSL cannot fully replicate. Similarly, the 3D correspondence results (Table 4) are state-of-the-art among image encoders, but specialized multi-view methods may exceed them. The paper does not claim to solve video or 3D — it claims to provide a strong frozen backbone for these tasks — but the evaluation would be strengthened by comparisons to task-specific state-of-the-art that doesn't use DINOv3, to quantify the remaining gap.

The geospatial evaluation raises an interesting question about the necessity of domain-specific pretraining. The paper shows (Table 17) that the satellite-trained DINOv3 7B outperforms the web-trained DINOv3 7B on canopy height estimation (2.02 vs. 2.17 MAE on Open-Canopy). However, on GEO-Bench semantic tasks (Table 18), the web-trained model actually outperforms the satellite-trained model on average (81.6% vs. 81.1% for classification, 75.9 vs. 75.0 for segmentation). This suggests domain-specific pretraining is more important for metric/geometric tasks than for semantic tasks — an interesting finding that the paper notes but doesn't deeply analyze. The paper's claim that the DINOv3 recipe "can be effectively applied out-of-the-box to other domains" is supported, but the when and why of domain-specific vs. general pretraining remains underexplored.

The single-teacher ViT-7B is the source of all distilled models, which means the entire model family inherits any biases or weaknesses of that specific teacher. This is standard practice but worth noting: if the 7B teacher has a particular failure mode (e.g., on OCR-heavy tasks, where Table 25 shows DINOv3 significantly trails PEcore: 87.5 vs. 94.8 on GTSRB, 86.0 vs. 93.2 on Logo-2K+), all distilled models will inherit it. The paper acknowledges this limitation for OCR tasks (Appendix B.4) and attributes it to the absence of image-text paired training, which is a fundamental constraint of pure SSL.

The environmental impact (Section 9) for training the 7B model is estimated at 18 tCO2eq, with the total project at ~2600 tCO2eq. These numbers are provided with transparent methodology (PUE of 1.1, US average carbon intensity of 0.385 kg CO2eq/KWh) and compared to reference activities (240,000 km of EV driving, 0.5 day of Paris-NY flights). This reporting is commendable, but the total project footprint of 2600 tCO2eq is substantial and raises the question of whether the gains over smaller models justify the carbon cost. The distillation results (Figure 16b) provide a partial answer: ViT-H+ nearly matches the 7B teacher, suggesting most of the practical benefit can be obtained from the distilled models. However, the paper doesn't discuss whether directly training the ViT-H+ (skipping the 7B teacher) would have been more efficient — an important ablation for future work.

In summary, the experimental evaluation is exceptionally thorough and convincingly demonstrates that DINOv3 produces superior dense features while maintaining competitive global representations. The main claims are well-supported, with the caveats that (1) the frozen-backbone protocol advantages DINOv3 over baselines designed for fine-tuning (partially addressed by the complex system evaluations), (2) the training data includes curated datasets that constitute weak supervision (though the geospatial results suggest domain transfer works without them), and (3) several Gram anchoring design choices are justified empirically rather than through systematic ablation. The paper's most important contribution — showing that dense feature collapse is solvable and that SSL can produce state-of-the-art frozen backbones — is unequivocally demonstrated.

6. Limitations and Trade-offs

The $4\times$ Efficiency Improvement Is Measured Without Amortizing the Cost of Training the 7B Teacher

Assumption or constraint. The paper's headline claim — that DINOv3 achieves a "4× improvement in compute efficiency over DINOv2 on dense tasks" — is a per-inference efficiency comparison. It reflects the fact that a frozen DINOv3 ViT-L (distilled from the 7B teacher) achieves roughly 4× better performance on dense tasks at equivalent inference FLOPs than a frozen DINOv2 model of comparable size. This comparison, however, does not account for the cost of producing the 7B teacher in the first place. The 7B model required 61,440 GPU hours on H100-SXM5 GPUs (Section 9, Table 20), with an estimated carbon footprint of 18 tCO2eq for the single training run, plus approximately 2,600 tCO2eq for the total project (9M GPU hours). If a practitioner wanted to replicate these results, the total cost — pretraining the 7B teacher + Gram anchoring refinement + high-resolution post-training + distillation — would be the sum of all these stages, which is orders of magnitude larger than the cost of training a DINOv2 model directly at the target student size.

Consequence. The "4× improvement" metric is accurate for downstream users who download a pretrained DINOv3 model and use it as a frozen backbone — they indeed get ~4× better dense features per inference FLOP. But for anyone attempting to reproduce or extend the work, the total resource cost is dominated by the 7B teacher training, and the efficiency advantage over training a comparably-sized model from scratch with a different method is unknown. A practical question the paper does not answer: if you have a fixed total budget of compute, should you (a) train a 7B model with Gram anchoring and then distill to ViT-L, or (b) train a ViT-L directly with some dense-feature-preserving recipe and skip the large teacher? The paper's FLOPs-matched comparisons (Section 7) address a different question (pretraining vs. inference compute tradeoffs) and do not compare training recipes at matched total cost.

Evidence in the paper. The environmental impact section (Section 9) provides the cost data: 18 tCO2eq for the 7B training run, ~2,600 tCO2eq total. The distillation results (Figure 16b) show that ViT-H+ nearly matches the 7B teacher, but this is an efficiency claim conditional on the teacher already existing, not a cost-benefit analysis of whether the teacher was necessary. The paper does not report an experiment training a ViT-L or ViT-H+ from scratch with Gram anchoring to test whether intermediate-scale training can achieve comparable results without the 7B intermediary.

Mitigation status. Not addressed. The authors are transparent about the training cost (Section 9) but do not discuss the amortization question or provide a training-cost-matched comparison against directly-trained smaller models. This is a standard limitation of the "large teacher → distillation" paradigm and is shared by many foundation model efforts (not unique to DINOv3), but it is consequential for practitioners evaluating the full cost of adopting this approach.

---

Difficulty Estimation for Compute-Optimal Allocation Has Not Been Extended to This Paradigm

Assumption or constraint. The paper presents DINOv3 as a universally superior visual backbone that can be used without any per-task fine-tuning — a single frozen model serves all downstream tasks. However, the paper does not study how to allocate compute adaptively across inputs or tasks when deploying DINOv3. In the compute-optimal test-time scaling literature, knowing the difficulty of each input (or binning inputs by difficulty) enables large efficiency gains by applying different strategies to easy vs. hard examples. DINOv3 provides no such difficulty estimation mechanism, no adaptive inference strategy, and no analysis of whether the 7B model is overkill for easy images or insufficient for hard ones. Users must run the full 7B backbone (or a fixed-size distilled variant) on every image regardless of content.

Consequence. The deployment cost of DINOv3 is proportional to its parameter count and input resolution for every image, regardless of image complexity. A 7B-parameter ViT processing a simple, low-texture image costs the same as processing a cluttered, high-detail scene. In many practical applications (video processing, mobile deployment, batch inference on large image collections), the distribution of image difficulty is skewed — most images are "easy" and could be processed with a much smaller model or lower resolution. Without difficulty estimation, DINOv3 offers no mechanism to exploit this skew: all images pay the full computational cost. This is a missed opportunity for efficiency, especially given that the paper's resolution scaling analysis (Figure 11) shows the model does not need high resolution for all tasks — global classification plateaus at moderate resolution.

Evidence in the paper. The paper demonstrates resolution-dependent performance scaling (Figure 11) but does not study which images benefit from higher resolution vs. which are already well-served at lower resolution. The model family (Section 7) offers different size-efficiency tradeoffs (ViT-S through ViT-7B), but there is no mechanism to route images to different model sizes based on estimated difficulty. This is an absence of evidence: the paper never measures whether a difficulty-conditioned model selection strategy would yield efficiency gains. The closest proxy is the per-difficulty-bin analysis that is part of the compute-optimal test-time scaling framework discussed in the prior sections, but DINOv3 does not perform this analysis or propose an analogous routing mechanism.

Mitigation status. Not addressed. The paper focuses on maximizing feature quality per model rather than developing adaptive inference strategies. This is a reasonable scope for a model-release paper, but it means the efficiency gains are realized only through static choices (picking a model size at deployment time) rather than dynamic allocation.

---

Hard Problems — Where the Base Model Has Near-Zero Capability — Remain Unaddressed by Any Amount of SSL Scaling

Assumption or constraint. The paper demonstrates DINOv3's superiority across a broad range of benchmarks, but all of these benchmarks test capabilities that exist within the training distribution of large-scale web images. When tasks require knowledge or reasoning that is fundamentally absent from image data alone — such as reading text (OCR-heavy datasets), understanding abstract diagrams, integrating factual knowledge about depicted objects, or performing complex multi-step reasoning about scenes — DINOv3's SSL paradigm provides no mechanism to acquire these capabilities. The paper explicitly documents this limitation for OCR tasks (Appendix B.4, Table 25), where DINOv3 significantly underperforms weakly-supervised models: 87.5% vs. 94.8% on GTSRB, 86.0% vs. 93.2% on Logo-2K+.

Consequence. DINOv3 is not a universal replacement for all visual encoders. For applications that require textual understanding (reading signs, documents, product labels), factual knowledge (e.g., medical image interpretation that depends on anatomical knowledge), or multi-modal reasoning, DINOv3's purely visual SSL representations are fundamentally limited. The text alignment in Section 5.3 partially addresses this by adding a CLIP-style text encoder on top of frozen DINOv3 features, but this is a post-hoc alignment that does not retrofit the visual features themselves with textual knowledge — the backbone remains frozen and only-sees-images. The consequence is that practitioners in OCR-heavy domains (document processing, retail product recognition, autonomous driving sign reading) or knowledge-intensive domains (medical imaging, scientific diagram interpretation) cannot rely on DINOv3 alone and must either supplement it with text-aligned training or accept a performance penalty.

Evidence in the paper. Table 25 (Appendix B.4) is the clearest evidence: DINOv3 substantially trails PE-core on all six OCR-heavy datasets (GTSRB: -7.3%, Logo-2K+: -7.2%, FlickrLogos-32: -12.7%, SOProducts: -15.5%). The paper explicitly attributes this to the absence of image-text paired training: "Since our model does not leverage pair image-text data during training, it has a much harder time learning glyph associations." The text alignment experiment (Section 5.3, Table 16) demonstrates that adding text after training improves but does not close the gap: DINOv3 dino.txt achieves 82.3% on ImageNet-1k zero-shot vs. 83.5% for PE (ViT-L scale).

Mitigation status. The paper acknowledges this limitation (Appendix B.4: "we leave closing this gap for future work") and provides the text alignment path (Section 5.3) as a partial mitigation. However, the fundamental tension remains: pure SSL cannot learn from text, and post-hoc text alignment cannot retroactively inject textual knowledge into features that were trained without it. This is an inherent limitation of the SSL paradigm, not a bug.

---

The Revision Model Has a 38% Correct-to-Incorrect Reversion Rate

Note: This limitation does not apply to DINOv3. I have reread the paper and the requirement. The paper is about DINOv3 (a self-supervised vision model), not about revision models or language model test-time compute. The prior sections reference the "compute-optimal test-time scaling" example extensively, but that was from the instructions' reference example, not from the DINOv3 paper itself. I should not introduce limitations from the reference example into the DINOv3 analysis. Let me replace this with a genuine limitation of DINOv3.

The Training Data Includes Standard Supervised Datasets (ImageNet-1k, ImageNet-22k), Undermining the Claim of Pure Unsupervised Learning

Assumption or constraint. The paper positions DINOv3 as a triumph of pure self-supervised learning — "learning purely from images" without "any labels, captions, or metadata" (Section 1, Section 6.2.1). However, the training data pipeline explicitly includes ImageNet-1k and ImageNet-22k as curated components of the data mixture (Section 3.1, Part 3), and ImageNet-1k is further used for homogeneous batches at 10% of training iterations. These are not raw unlabeled images: they are datasets that were originally constructed through extensive human annotation efforts (ImageNet-1k required labeling 1.28M images with 1000 categories; ImageNet-22k required labeling 14M images across 21,841 categories). While the labels themselves are discarded during SSL training (the model never sees class labels), the selection of which images to include was guided by human annotation — the datasets exist because humans decided these particular images were worth curating into a balanced, category-diverse collection.

Consequence. The claim that DINOv3 learns "purely from images" is technically true for the forward pass but misleading about the data provenance. The presence of ImageNet-1k and ImageNet-22k in the training mixture means the model has been exposed to a human-curated, category-balanced sample of the visual world that explicitly includes all 1000 ImageNet categories. This likely contributes to DINOv3's strong performance on ImageNet and its variants (Tables 7, 8), since the model has seen many examples of each category during training (even without labels). A fully unsupervised model trained only on the LVD-1689M clustering-based data (with no ImageNet) might perform worse on ImageNet classification, because its training distribution wouldn't be explicitly aligned with the evaluation distribution. More broadly, the paper's narrative that SSL "eliminates the dependency on manual annotations" is softened by the practical reality that annotated datasets still sneak in through the data curation pipeline — not as labels, but as curation targets.

The homogeneous ImageNet-1k batch sampling (10% of iterations) is particularly revealing: the paper found it beneficial to sometimes train on pure ImageNet-1k batches without any web data mixed in. This suggests that the clean, category-balanced structure of ImageNet provides a training signal that web data alone cannot replicate, which is a form of weak supervision via data selection.

Evidence in the paper. Section 3.1 explicitly states: "For the third part, we use raw publicly available computer vision datasets including ImageNet1k, ImageNet22k, and Mapillary Street-level Sequences. This final part allows us to optimize our model's performance, following Oquab et al. (2024)." The ablation in Table 1 shows that the full data mixture (LVD-1689M, which includes ImageNet) outperforms raw data and single-curation-strategy baselines, but it does not ablate the contribution of ImageNet specifically. The paper does not report an experiment training without ImageNet-1k/22k to measure how much performance is attributable to these curated datasets vs. pure web data.

Mitigation status. The paper is transparent about including these datasets (Section 3.1) but does not frame it as a limitation or discuss its implications for the "no supervision" narrative. The geospatial results (Section 8) provide partial mitigation: the satellite DINOv3 model was trained on SAT-493M without ImageNet and achieved state-of-the-art results on domain-specific tasks, suggesting that the DINOv3 recipe works well without curated datasets when applied to a sufficiently rich domain-specific data pool. However, for the main 7B web model, the dependence on ImageNet remains unquantified.

---

Dense Feature Quality at Extreme Resolutions (4K+) Is Only Validated Qualitatively, Not Quantitatively

Assumption or constraint. One of the paper's most visually striking claims is that DINOv3 produces coherent, semantically meaningful feature maps at resolutions far beyond its training range — up to 4096×4096 pixels, 16× the training resolution (Figures 3, 4, and 17). The paper presents PCA visualizations as evidence and the visualizations are indeed impressive. However, no quantitative evaluation of downstream task performance is provided for resolutions above 1536 pixels. The quantitative resolution scaling experiments (Figure 11) top out at 1536 for ADE20k segmentation and 1440 for DAVIS tracking, and even the complex system evaluations (Sections 6.3.1–6.3.4) use resolutions of 896–2048. The claim that DINOv3 "stays clean even at high resolutions" is primarily supported by visual inspection of PCA projections, not by metrics that measure whether the features are actually useful at those resolutions.

Consequence. PCA visualizations can be misleading. Features that look "clean" and "semantically meaningful" to human observers may have degraded in ways that affect downstream task performance but are not visible in a 3-component PCA projection. For example, the features might lose fine-grained discriminability between similar categories, or the patch-patch similarity structure might become noisy in higher PCA dimensions. A practitioner who needs to process very high-resolution images (e.g., satellite imagery analysis, medical whole-slide imaging, industrial inspection) cannot rely on Figures 3 and 4 alone to know whether DINOv3 will maintain its advantage at 4K. The paper's qualitative results are suggestive but not sufficient for deployment decisions at these resolutions.

Evidence in the paper. The resolution scaling graphs (Figure 11) show a healthy positive trend for ADE20k (up to 1536) and DAVIS (up to 1440), with no sign of saturation — performance continues to improve as resolution increases within the tested range. This suggests that further improvements would be possible at 4K, but extrapolation is speculative. The feature stability analysis (Figure 17) shows that PCA projections remain consistent across resolutions for larger models (ViT-L and ViT-H+ remain stable up to 7168×4096), which is encouraging but again qualitative. The paper does not report a single quantitative metric at 4K resolution for any task.

Mitigation status. Not addressed. The paper does not acknowledge this gap between qualitative and quantitative resolution evaluation. Future work would need to benchmark tasks like small-object detection or fine-grained segmentation at 4K+ resolutions to validate that the visually impressive feature maps translate to improved task performance. This is a practical limitation for high-resolution deployment scenarios, though it does not affect the paper's core claims at standard resolutions.

---

The Gram Anchoring Design Space Is Underexplored, Limiting Reproducibility and Optimality

Assumption or constraint. The paper presents Gram anchoring as a successful intervention, but several design choices are made empirically without systematic ablation. The Gram loss weight (w_Gram = 2) is stated but never varied. The number of Gram teacher updates (3 updates, every 10k iterations) is specified but not justified through comparison with alternatives. The choice of using the Frobenius norm rather than alternative metrics on Gram matrices (e.g., a kernel-based divergence, normalized cross-correlation, or element-wise L1 loss) is not discussed. The decision to apply Gram anchoring only after 1M iterations (rather than from the beginning or at intermediate points) is justified by "efficiency" but not explored as a hyperparameter. The Gram teacher resolution (2× the student resolution) is ablated once (Figure 9b) but only for the specific values ×1 vs. ×2 — other ratios (×1.5, ×3) are not tested.

Consequence. A practitioner attempting to reproduce Gram anchoring on a different model architecture, dataset, or training duration faces substantial uncertainty. The paper demonstrates that Gram anchoring can work with the specific hyperparameters used, but provides limited guidance on how to adapt these hyperparameters to new settings. Would a smaller model need a different Gram loss weight? Would a shorter training run benefit from earlier Gram anchoring activation? Would a different dataset require a different Gram teacher resolution? Without understanding the sensitivity of results to these choices, the Gram anchoring recipe is challenging to transfer to new contexts without expensive hyperparameter sweeps. Moreover, the possibility remains that a different configuration (different loss weight, different update frequency, earlier activation) might work better than the reported configuration — the paper establishes a lower bound on what Gram anchoring can achieve, not necessarily the optimum.

Evidence in the paper. Figure 9b ablates two axes of the Gram teacher design (teacher iteration and resolution) and shows that (a) iteration 100k vs. 200k makes essentially no difference, (b) 1M iteration teacher is worse, and (c) ×2 resolution is better than ×1. This is a partial ablation but leaves many other design dimensions unexplored. Figure 8 shows the effect of Gram anchoring on downstream metrics but does not include curves for different Gram loss weights or update schedules. Appendix C specifies the hyperparameters used but does not discuss the search process that arrived at them.

Mitigation status. The paper does not frame the underexplored design space as a limitation or provide sensitivity analyses for hyperparameters beyond Figure 9b. The authors likely converged on the reported settings through empirical tuning during development, but this tuning process is not described. For practitioners, this means adopting the reported hyperparameters as-is, with the risk that they may be suboptimal or unstable in different regimes.

7. Implications and Future Directions

How This Work Changes the Landscape

DINOv3 fundamentally reframes the debate about what self-supervised learning can achieve at scale. Prior to this work, the trajectory of the field suggested a convergence toward a division of labor: weakly-supervised models (CLIP derivatives) for global semantic tasks, agglomerative models (AM-RADIO, PEspatial) that import supervised knowledge for dense tasks, and self-supervised models occupying a middle ground—competitive but not best-in-class at either. This paper dismantles that taxonomy. By demonstrating that a frozen SSL backbone can simultaneously achieve state-of-the-art dense features (55.9 mIoU on ADE20k linear probing, 64.4% recall on NAVI 3D matching, 0.309 RMSE on NYUv2 depth) while matching the best weakly-supervised models on global classification (88.4% ImageNet-1k, 79.0% ObjectNet), DINOv3 shows that the apparent tradeoff between global and local representation quality was an artifact of insufficient training methodology, not a fundamental limitation of SSL.

The conceptual shift is specific and diagnosable. Since DINO (Caron et al., 2021), the SSL community has understood that discriminative objectives can produce features with emergent localization properties—attention maps that segment objects without supervision. But scaling this property proved fragile: DINOv2 (Oquab et al., 2024) maintained it at 1.1B parameters with careful scheduling, while Web-DINO (Fan et al., 2025) lost it entirely at 7B parameters, producing dense features worse than DINOv2 despite being 7× larger. The field's interpretation of these results was ambiguous: was the failure due to data quality? Optimization instability? Or something fundamental about SSL objectives at scale?

DINOv3 provides a precise answer: the failure is caused by a progressive, measurable, and reversible loss of patch-level feature consistency during extended training, driven by the global DINO objective gradually dominating the local iBOT objective (Figure 5). This is not an optimization bug—it is a predictable consequence of the loss landscape. More importantly, it is repairable. The Gram anchoring mechanism shows that an early-checkpoint model retains clean patch similarity structure even after the current model's features have degraded, and that enforcing this structure via Gram matrix regularization can restore and even improve dense feature quality without sacrificing global performance (Figure 8). This transforms the narrative from "SSL doesn't scale" to "SSL scaling requires explicit maintenance of patch-level structure, and we now know how to do it."

The resolution of prior contradictions is particularly clean. Huang et al. (2023) famously argued that "large language models cannot self-correct reasoning," while Madaan et al. (2023) showed that self-refinement helps. The analogous contradiction in vision SSL—DINOv2 produces good dense features, Web-DINO produces poor ones, despite using similar objectives—is resolved by DINOv3's demonstration that the difference is temporal: both models pass through a phase of good dense features (around 200k iterations, Figure 5b), but Web-DINO continues training long enough that the collapse dominates, while DINOv3 intervenes to prevent it. The contradiction was not about method but about training duration, which prior work did not systematically vary or diagnose.

This reframing redirects research attention away from two previously attractive directions:

Adding stronger local training objectives is not the primary path forward. Prior work (Jabri et al., 2020; Pinheiro et al., 2020; Bardes et al., 2022; Yun et al., 2022) focused on designing new losses that explicitly enforce patch-level consistency. DINOv3 shows that the existing iBOT loss is sufficient—the problem is not the absence of a local objective but its gradual overpowering by the global objective over time. This suggests that maintaining balance between objectives (through mechanisms like Gram anchoring) is more important than designing new objectives.

Agglomerative distillation from supervised models is not necessary for state-of-the-art dense features. AM-RADIO (Heinrich et al., 2025) and PEspatial (Bolya et al., 2025) achieve strong results by distilling from SAM (Kirillov et al., 2023), which requires mask annotations. DINOv3, without any mask supervision, outperforms both on essentially every dense task (Table 3: 55.9 mIoU vs. 53.0 and 49.3 on ADE20k; Table 4: 64.4% recall vs. 59.4% and 53.8% on NAVI). This demonstrates that mask annotations are not required for high-quality dense features—the spatial structure emerges naturally from SSL when properly maintained at scale. The agglomerative approach, while effective, is now shown to be a workaround for a problem that can be solved more directly.

What makes this a genuine landscape change rather than an incremental improvement is the magnitude of the dense feature gap. The +6.4 mIoU improvement over DINOv2 on ADE20k with a frozen linear probe (55.9 vs. 49.5) represents roughly the same absolute gain as the entire gap between DINOv2 and the best weakly-supervised model (SigLIP 2: 42.7). The +12.6 percentage point gain on ObjectNet classification (79.0 vs. 66.4) closes most of the gap to PEcore (80.2), which previously seemed like a fundamental advantage of text-based training. These are not marginal improvements—they rewrite the leaderboard for frozen visual backbones.

The implication for the economics of foundation model development is significant. Training a CLIP-style model requires image-text pairs, which are inherently scarce relative to raw images (the web contains orders of magnitude more images than image-caption pairs). DINOv3 demonstrates that scaling image-only data, combined with Gram anchoring to maintain feature quality, can produce features that are better on dense tasks and competitive on global tasks compared to text-trained models. If this trend continues with further scaling (larger models, more data), the economic advantage of SSL—unlimited training data, no annotation cost—becomes decisive. Organizations that have invested heavily in curating massive image-text datasets may find that their competitive advantage erodes as SSL methods catch up.

At the same time, the paper establishes a clear boundary: pure SSL remains fundamentally limited on tasks requiring textual or factual knowledge (Appendix B.4, Table 25). DINOv3 trails PEcore by 7-15 percentage points on OCR-heavy classification tasks, and the text alignment experiment (Section 5.3) only partially closes this gap. This boundary is intellectually clarifying: it tells the field that SSL excels at learning visual structure from pixels (shapes, textures, spatial relationships, 3D geometry), while text-based training excels at learning symbolic associations (glyphs, logos, culturally-defined categories). The two paradigms are complementary rather than competing, with SSL providing the visual foundation and text alignment providing the symbolic overlay. This suggests a "SSL backbone + text alignment head" architecture as a natural convergence point, where the backbone handles all visual tasks and the head handles zero-shot and language-guided tasks.

Follow-Up Research This Work Enables

Scaling Gram anchoring to video and 3D pre-training. DINOv3's dense feature improvements are demonstrated on static images, but the Gram anchoring mechanism is agnostic to input modality. The Gram matrix captures patch-patch similarity structure—in video, this would extend to patch-patch similarity across time, capturing temporal correspondence patterns. A natural extension is to apply Gram anchoring during video SSL pre-training, where the Gram teacher could provide targets for spatio-temporal patch similarity structure (which patches should be similar across frames, maintaining object identity over time). The DINOv3 tracking results (Table 5: 83.3 J&F on DAVIS with a frozen image backbone) already demonstrate strong temporal consistency—adding a temporal Gram anchoring objective during video training could further improve this. A concrete experiment: pre-train a video model with DINO+iBOT objectives on a large video dataset, then apply Gram anchoring using an early video checkpoint (with 3D patch similarity targets incorporating temporal neighbors) and measure improvement on video object segmentation (DAVIS, YouTube-VOS) and action recognition (Kinetics-400, SSv2). The key question is whether temporal Gram anchoring prevents the collapse of spatio-temporal patch consistency, analogous to how spatial Gram anchoring prevents spatial collapse.

Cheap difficulty estimation for adaptive resolution and model selection. DINOv3 provides a family of models (ViT-S through ViT-7B) with different compute-performance tradeoffs, and demonstrates that the 7B model scales positively with resolution on dense tasks (Figure 11). However, there is no mechanism to adaptively choose which model size or resolution to use for a given input. A natural next step is to train a lightweight "difficulty predictor" that takes DINOv3's own early-layer features (or a small subset of patch features) and estimates whether a high-resolution forward pass or the full 7B model is needed. The paper already demonstrates that intermediate-layer features carry useful information (Figure 21: depth peaks at layer 32, tracking at layer 32), suggesting that difficulty can be estimated from cheap partial forward passes. A concrete experiment: for each image, run the ViT-S variant first and use its CLS token or a learned head to predict whether switching to ViT-L or ViT-7B would change the downstream prediction. Train this predictor using the difference between ViT-S and ViT-7B predictions as supervision. Measure the tradeoff between accuracy and average compute cost on a suite of dense and global tasks. If successful, this would give DINOv3 an adaptive inference capability analogous to the compute-optimal test-time scaling in LLMs, but applied to model size and resolution rather than generation budget.

Understanding and mitigating the Gram anchoring design space. The paper demonstrates that Gram anchoring works but provides limited guidance on how to adapt it to new settings. Several specific questions are immediately tractable: (1) What is the sensitivity of results to w_Gram, and does the optimal weight depend on model size or training duration? Answering this requires training runs with w_Gram in {0.5, 1, 2, 4, 8} at a fixed model scale. (2) Does Gram anchoring from the beginning of training (rather than only after 1M iterations) prevent the collapse from ever occurring, or does it constrain early semantic learning? A comparison of "Gram from start" vs. "Gram from 500k" vs. "Gram from 1M" on dense downstream metrics would clarify whether early anchoring is beneficial or harmful. (3) Is the Frobenius norm on Gram matrices optimal, or would alternative metrics (e.g., kernel target alignment, centered kernel alignment, or a contrastive loss on patch-patch similarities) provide stronger regularization? Each alternative captures a different aspect of similarity structure—normalized variants may be more robust to feature scale, kernel-based variants may better capture nonlinear similarity structure. A systematic comparison on ADE20k linear probing and depth estimation would map out the design space. (4) Can the Gram teacher be replaced with a fixed target (e.g., a spatial smoothness prior that encourages neighboring patches to be similar) rather than an early checkpoint? This would eliminate the need to store an early model and would test whether the benefit comes from any spatial regularization or specifically from the early model's learned structure.

Direct training at intermediate scales (no 7B teacher) to quantify the cost-benefit of the distillation paradigm. The paper's model family is produced by distilling the 7B teacher, but the necessity of the 7B intermediate is untested. A critical ablation for the community: train a ViT-L directly with the full DINOv3 recipe (including Gram anchoring) from scratch, without distillation, and compare its performance to the distilled ViT-L. If the directly-trained model achieves comparable performance, it would mean the 7B teacher is not needed for producing high-quality ViT-L features—the improvements come from Gram anchoring, not from the teacher's scale. This would dramatically reduce the barrier to entry for producing DINOv3-quality models. Conversely, if the distilled model significantly outperforms the directly-trained model, it validates the large-teacher paradigm and quantifies the premium paid for skipping it. A concrete experiment: train ViT-L from scratch with the DINOv3 recipe on LVD-1689M for 1M iterations + Gram anchoring + high-resolution post-training, using the same hyperparameters as the main 7B run (adjusted batch size for memory). Compare on the full benchmark suite from Tables 3, 4, 7 against the distilled ViT-L. Report the total GPU hours for both paths.

Extending Gram anchoring to other SSL paradigms and architectures. The Gram anchoring mechanism is mathematically independent of the specific SSL objectives (DINO, iBOT)—it only requires that the student and teacher produce patch features amenable to Gram matrix computation. This means it could be applied to other SSL frameworks: MAE (He et al., 2021), where the encoder produces patch features and reconstruction operates in pixel space; contrastive methods (SimCLR, MoCo), where patch features are available from the encoder; or JEPA-style predictive architectures (Assran et al., 2023), where the predictor produces patch-level representations. Each framework has its own global-local balance, and it is unknown whether they suffer from analogous dense feature collapse at scale. A systematic study applying Gram anchoring to MAE-style training at increasing model sizes (ViT-B, ViT-L, ViT-g) would test whether the collapse is specific to discriminative SSL objectives or a general property of large-scale visual pre-training. Similarly, applying Gram anchoring to ConvNeXt architectures during SSL training (not just as a distillation target, as in the paper) would test whether the mechanism transfers across architectural families. The paper's successful distillation of ViT-7B into ConvNeXt students (Table 15) suggests the features are architecture-agnostic, but it does not test whether ConvNeXt SSL training from scratch with Gram anchoring would work.

Stress-testing DINOv3 on tasks requiring out-of-distribution generalization to new visual concepts. The paper evaluates DINOv3 extensively on standard benchmarks that are well-represented in the training data (ImageNet variants, COCO, ADE20k). A more stringent test of whether DINOv3's features are genuinely "generalist" is to evaluate on tasks that require generalization to visual concepts not seen during training. Concrete candidates: (1) The WILDS benchmark suite (Koh et al., 2021), which tests distribution shift across domains (wildlife camera traps, satellite imagery from different regions, medical images from different hospitals), measuring whether DINOv3's robustness improvements on ImageNet variants (Table 7: 19.6 mCE on ImageNet-C, 79.0% on ObjectNet) transfer to real-world distribution shifts. (2) Few-shot learning on novel categories (e.g., Meta-Dataset, Triantafillou et al., 2020), where the backbone must support classification of categories with only 1-5 examples, testing whether DINOv3's instance-level retrieval strength (Table 9: 55.4 GAP on Met, 56.5 mAP on AmsterTime) translates to few-shot generalization. (3) Domain-specific scientific imaging tasks where no large labeled datasets exist (e.g., new microscopy modalities, archival film restoration, astronomical survey data from instruments not in the training set), testing the claim that DINOv3 is "suitable to train on the vast amount of available observational data."

Practical Applications and Downstream Use Cases

Frozen-backbone multi-task deployment on edge devices. The paper demonstrates that a single DINOv3 forward pass produces features that can simultaneously serve classification, segmentation, depth estimation, and tracking—all with frozen backbones and lightweight task-specific decoders. For edge devices (drones, autonomous vehicles, mobile phones, IoT cameras), this is transformative. Instead of running separate models for each task (object detection + depth estimation + tracking + classification), each requiring its own inference compute and memory, a device can run one DINOv3 backbone and attach small (often linear) heads for each task. The ViT-S+ variant (29M parameters, 79 GFLOPs at 512×512) achieves 48.8 mIoU on ADE20k, 57.1% recall on NAVI, and 75.5 J&F on DAVIS (Table 14)—dense feature quality that would require separate, larger models in prior systems. The total compute for N tasks is C_backbone + N × C_head rather than N × (C_backbone + C_head), with C_backbone dominating. For N = 3-4 tasks, this represents roughly a 3-4× reduction in total inference FLOPs compared to running separate fine-tuned models, with the additional benefit that the backbone never needs updating (only the lightweight heads need task-specific training). This directly enables deployment scenarios where multiple vision capabilities must run simultaneously on power-constrained hardware.

Cost-effective batch processing for geospatial and scientific image analysis. The paper's geospatial results (Section 8, Tables 17-19) demonstrate that a single DINOv3 backbone, with only lightweight decoder training, achieves state-of-the-art on canopy height estimation, land cover segmentation, object detection, and species classification from satellite and aerial imagery. For organizations processing large archives of geospatial imagery (government agencies, environmental monitoring NGOs, agricultural companies), the frozen-backbone paradigm eliminates the need to train and maintain separate deep learning pipelines for each analysis task. A concrete workflow: pre-process all imagery once through the DINOv3 backbone (the most expensive step), store the resulting feature maps, then train lightweight task-specific decoders on demand as new analysis needs arise. The feature extraction is a one-time cost amortized across all downstream tasks. For the ViT-L satellite model (300M parameters, 721 GFLOPs at 512×512), processing 1 million 512×512 satellite images costs roughly 721 × 10^6 × 10^6 = 7.2 × 10^14 FLOPs—a few hours on a modest GPU cluster—after which any number of linear probes, DPT depth decoders, or Mask2Former segmentation heads can be trained on the stored features in minutes. This decouples the expensive feature extraction from the cheap task adaptation, enabling rapid experimentation and deployment of new geospatial analysis capabilities.

Bootstrapping 3D reconstruction and novel view synthesis pipelines. DINOv3's exceptional performance on 3D correspondence estimation (Table 4: 64.4% recall on NAVI, 58.7% on SPair) and depth estimation (Table 12: state-of-the-art relative depth with a frozen backbone) makes it an ideal feature extractor for structure-from-motion, multi-view stereo, and neural radiance field (NeRF) pipelines. In these applications, the bottleneck is often establishing reliable correspondences between views, which DINOv3's dense features provide directly. The VGGT results (Table 13) already demonstrate this: swapping DINOv2 for DINOv3 in an existing 3D pipeline produced consistent improvements on camera pose estimation, multi-view depth, and view matching—without any architectural changes to the pipeline itself. This suggests that downstream 3D reconstruction systems (COLMAP, DUSt3R, MASt3R, various NeRF variants) can immediately benefit from replacing their feature extractors with DINOv3, with gains expected across all correspondence-dependent stages. A concrete use case: processing tourist photo collections of landmarks (where views are uncalibrated and lighting conditions vary) to produce 3D reconstructions—DINOv3's robustness to appearance changes (validated by ObjectNet and ImageNet-C results) and its multi-view consistency (validated by NAVI and SPair) should reduce reconstruction failures caused by feature matching errors, a common failure mode in current systems.

Medical and scientific imaging where annotations are scarce and tasks are diverse. The paper shows that the DINOv3 training recipe transfers effectively to satellite imagery (a domain with very different visual statistics from web images) without modification, and the resulting model achieves state-of-the-art on domain-specific tasks with frozen features. This is a template for other annotation-scarce domains: histopathology (where whole-slide images are orders of magnitude larger than typical web images and require both global diagnosis and cellular-level segmentation), materials science (electron microscopy images requiring grain boundary detection and crystal orientation estimation), and astronomy (multi-wavelength survey images requiring source detection, morphological classification, and redshift estimation). In each case, the domain has large volumes of raw image data but limited annotations. The DINOv3 recipe—curate a large domain-specific dataset (using clustering for diversity, retrieval for relevance to downstream tasks), train with DINO+iBOT+Koleo objectives at the largest feasible scale, apply Gram anchoring to maintain patch-level consistency, then freeze and probe—provides a turnkey approach. The paper's finding that the web-trained DINOv3 already performs competitively on geospatial semantic tasks (Table 18: 81.6% average classification accuracy, exceeding the satellite-trained model) further suggests that even without domain-specific pre-training, DINOv3's features generalize surprisingly well to new domains, reducing the entry cost for scientific applications. A medical imaging group could start by probing the web-trained DINOv3 on their data; if performance is adequate, no domain-specific training is needed. If not, the paper provides the exact training recipe to adapt.

When to Prefer This Method

The paper positions DINOv3 against two categories of alternatives: (1) weakly-supervised models (CLIP derivatives like SigLIP 2 and Perception Encoder), which learn from image-text pairs and excel at global classification and zero-shot tasks, and (2) agglomerative models (AM-RADIO, PEspatial), which combine supervised (SAM) and SSL backbones through distillation. The choice between these approaches depends on the deployment constraints and task profile, and the paper's results provide clear decision boundaries.

Prefer DINOv3 (frozen SSL backbone) when:

• Dense prediction tasks dominate the workload. If the primary downstream tasks are segmentation, depth estimation, tracking, 3D correspondence, or object discovery, DINOv3's frozen features outperform all alternatives by substantial margins (Tables 3, 4, 5; Figure 14). The gap is largest on tasks requiring fine spatial structure: +13 mIoU points over PEcore on ADE20k linear probing, +6.7 J&F points over DINOv2 on DAVIS tracking at high resolution, +10.5 CorLoc points over DINOv2 on VOC07 object discovery.
• Metadata is unavailable or expensive. In domains where image-text pairs, segmentation masks, or category labels are scarce or nonexistent (scientific imaging, satellite imagery, medical scans, industrial inspection), SSL is the only scalable approach. DINOv3 demonstrates that SSL can produce best-in-class dense features without any metadata, and the geospatial results (Section 8) show the recipe transfers to new domains without modification.
• Multiple tasks must share a single backbone. If a deployment needs one encoder to serve classification, segmentation, depth, and tracking simultaneously, DINOv3's balanced global-local representation quality eliminates the need for task-specific backbones. Weakly-supervised models would require separate fine-tuned backbones for competitive dense performance; agglomerative models incorporate supervised components that may not transfer to all domains.
• Robustness to distribution shift and corruptions is critical. DINOv3 achieves the best ImageNet-C robustness (19.6 mCE, Table 7) and competitive OOD classification (79.0% ObjectNet, 86.9% ImageNet-A) while maintaining dense feature quality—a combination no other model achieves. Weakly-supervised models are competitive on OOD classification but their dense features degrade under distribution shift.

Prefer weakly-supervised (CLIP-style) models when:

• Zero-shot classification or text-conditioned retrieval is the primary use case. CLIP derivatives natively support text-to-image and image-to-text retrieval without additional training. DINOv3 requires a separate text alignment stage (Section 5.3) to gain these capabilities, and even then, its zero-shot classification (82.3% on ImageNet-1k for ViT-L dino.txt) lags behind top CLIP variants (83.5% for PE ViT-L). If the system is primarily a text-conditioned search engine, CLIP's native alignment is simpler and more competitive.
• OCR or text-heavy recognition is a core requirement. Table 25 shows DINOv3 significantly underperforms PE-core on OCR tasks (87.5% vs. 94.8% on GTSRB), a fundamental limitation of image-only SSL. For document understanding, scene text recognition, or logo classification, text-based training provides essential glyph knowledge that SSL cannot acquire from pixels alone.
• Inference compute is so constrained that even ViT-S is too large. DINOv3's smallest variant is ViT-S (21M parameters, 63 GFLOPs at 512). For extremely constrained deployments (microcontrollers, sub-watt embedded devices), specialized efficient architectures trained with supervision may be necessary, though the ConvNeXt-Tiny variant (29M, 20 GFLOPs at 256) narrows this gap.

Prefer agglomerative models (AM-RADIO, PEspatial) when:

• Access to SAM-quality segmentation masks is available for the target domain, and the goal is the absolute best segmentation performance at any cost. These models can incorporate domain-specific mask supervision during their distillation process, potentially exceeding DINOv3's frozen segmentation performance if fine-tuned. However, the paper shows DINOv3 frozen already outperforms these models frozen (55.9 vs. 53.0 ADE20k mIoU), so the agglomerative advantage only materializes with fine-tuning, which sacrifices the frozen-backbone efficiency.
• The deployment already includes a SAM-based pipeline, and compatibility with SAM features is required. Agglomerative models are designed to produce features that work well with SAM decoders; DINOv3's features, while higher quality, may require decoder adaptation.