Best Depth Estimation Models: How to Choose

Choosing a depth estimation model comes down to three things: whether you need distances in meters or just relative depth, where it will run, and whether its license permits your use. For relative depth and research, Depth Anything and Marigold are strong models to evaluate first. For metric depth from an unknown camera, look at Depth Pro and UniDepth; if you know your camera's focal length, Metric3D v2 and Depth Anything 3 Metric are also options. For edge hardware, shortlist Depth Anything V2 Small and the MiDaS v3.1 Swin2-Tiny and LeViT models, then measure latency on your device. For low-latency depth on NVIDIA GPUs alongside other Ultralytics YOLO tasks, also evaluate Ultralytics YOLO26 depth. This guide compares nine monocular depth models and gives a decision path for picking one.

If you're new to the task, start with what monocular depth estimation is. This page is about choosing a model.

Relative or metric depth: decide this first#

• Relative depth tells you which pixels are closer or farther, up to an unknown scale. It's enough for scene understanding, background effects and ranking objects by distance.
• Metric depth gives distances in meters. You need it to measure, to plan a robot's motion or to fuse depth with other sensors.

Metric models reach real scale in different ways. Some estimate the camera's focal length themselves, some need you to supply it, and some carry a fixed scale that you calibrate for your camera. How a model gets its scale can matter more in practice than a few points of benchmark accuracy. For background on the two kinds, see the depth estimation glossary entry.

Fig 1. The same factory photo processed by Depth Anything V2 Small, which predicts relative depth (nearer or farther, with no units), and by Ultralytics YOLO26s-depth, which predicts meters: about 1.5 m to the parts bin, 4.1 m to the engineer and 13.8 m to the far doors. The photo was generated for this article; both depth maps are real model outputs. The distances are predictions from the released checkpoint, uncalibrated for this camera, not measurements.

Depth estimation models compared#

Models are listed alphabetically, not ranked. We leave out cross-model accuracy figures because each paper uses its own benchmark protocol, so the results aren't directly comparable. Licenses were checked in October 2026 and apply per checkpoint.

How to choose a depth estimation model#

Work through these questions in order:

1. Do you need meters? If not, start with Depth Anything V2 or Depth Anything 3, or MiDaS if you want an MIT license.
2. Do you know your camera's intrinsics? If you don't, pick a model that estimates them: Depth Pro or UniDepth. If you do, Metric3D v2 and Depth Anything 3 Metric can use them.
3. Where will it run? If server latency isn't a constraint, the large foundation models are a good fit. For low-latency depth on NVIDIA GPUs alongside other YOLO tasks, consider Ultralytics YOLO26 depth and measure performance on your edge device, such as NVIDIA Jetson. Other candidates include Depth Anything V2 Small, the MiDaS v3.1 Swin2-Tiny and LeViT models. CPU latency depends on the processor, runtime, input resolution and model. Benchmark your exact configuration; Fig 3 gives one example for small Ultralytics YOLO26 depth models. See the edge section below.
4. Can you use the license? Check the exact checkpoint. Several families mix Apache 2.0 small models with non-commercial large ones.
5. Can you calibrate or fine-tune? If you can collect about 50 to 150 labeled images from your own camera, with a few measured points per image, test a calibrated or fine-tuned model against a zero-shot one on your own scenes. In Ultralytics' tests with YOLO26s-depth (150 images per camera, 5 measured points per image), calibrating this way brought its scale within about 1% of a full ground-truth fit, against 4% to 46% off before calibration. That figure measures how well the scale was recovered, not overall depth accuracy.

Then test two or three candidates on images from your own camera at your deployment resolution.

Fig 2. Predicted distance to selected detected cars and people, combining Ultralytics YOLO26x detection with Ultralytics YOLO26s-depth: 3.6 m to the nearest parked car, 6.9 m to the car on the right and 7.0 m to the labeled person on the right. The photo was generated for this article; the boxes and distances are real model outputs, uncalibrated for this camera. They are predictions, not measured distances.

The models in more detail#

Listed alphabetically.

Depth Anything 3#

Depth Anything 3 from ByteDance Seed extends Depth Anything from single images to any number of views. Its main models estimate depth and camera pose together, and dedicated variants handle monocular relative depth (DA3Mono-Large) and monocular metric depth (DA3Metric-Large). Output: relative depth from the main and Mono models; metric depth with a supplied focal length from DA3Metric-Large, or directly from the non-commercial Nested model. Sizes: 0.08B (Small) to 1.15B (Giant), plus the 1.40B Nested model, as listed on the project's model cards. License: Small, Base, Metric-Large and Mono-Large are Apache 2.0; Large, Giant and Nested are CC BY-NC 4.0. Best for: multi-view scenes and 3D reconstruction. Trade-off: the strongest checkpoints are non-commercial.

Depth Anything V2#

Depth Anything V2 is a widely available open model for relative depth, with robust results across indoor, outdoor and unusual scenes. The project also publishes metric checkpoints fine-tuned for indoor scenes (up to 20 m) and outdoor scenes (up to 80 m). Sizes: Small 24.8M, Base 97.5M, Large 335.3M. License: Small is Apache 2.0; Base and Large are CC-BY-NC-4.0. Best for: general-purpose relative depth. Trade-off: if you need commercial use, you're limited to the Small model, and the metric checkpoints can't predict beyond their fixed maximum depth.

Depth Pro#

Depth Pro from Apple predicts metric depth from a single image without camera intrinsics, and estimates the focal length itself. Apple reports a 2.25-megapixel depth map in 0.3 seconds on a standard GPU, with sharp boundaries around fine structures. License: Apple's own license covers the code and the weights. Best for: metric depth from photos where you don't control the camera. Trade-off: it's a server-class model, not an edge model, and you should read its license before commercial use.

Marigold#

Marigold repurposes a pretrained image diffusion model for depth, trained only on synthetic data. It produces very detailed relative depth. License: code under Apache 2.0, models under RAIL++-M. Best for: offline work where detail matters more than speed, such as content creation and dataset generation. Trade-off: it supports one-step inference; ensembling for better accuracy multiplies the cost, so measure whether it meets your latency needs.

Metric3D v2#

Metric3D v2 predicts metric depth and surface normals from a single image, with ViT-Small, ViT-Large and ViT-giant2 checkpoints, including ONNX exports. License: the code is BSD-2-Clause; check the terms for the checkpoint you use. Best for: 3D reconstruction and robotics pipelines that also need surface normals. Trade-off: it maps images to a canonical camera, so you need a correct focal length for the scale to be right.

MiDaS#

MiDaS from Intel's ISL made robust relative depth practical by training on a mix of datasets. Version 3.1 ranges from a BEiT-Large model for quality down to Swin2-Tiny and LeViT models intended for embedded devices, plus a legacy MiDaS v2.1 small model in OpenVINO format for Intel CPUs and mobile examples for iOS and Android. License: MIT. Best for: a permissive, well-documented baseline. Trade-off: it predates the newer foundation models, and Intel has archived the repository, so it no longer receives fixes. Compare it with a newer model on your own images.

Ultralytics YOLO26 depth#

Ultralytics YOLO26 supports depth estimation (announced in July 2026) in five sizes from 6.3M (n) to 57.0M (x) parameters at 768 pixels. They predict depth in meters with a log-depth head that spans roughly 0.02 to 150 meters, so one model covers indoor rooms and outdoor scenes. The released weights carry a single global scale; for accurate absolute depth on a specific camera, model.calibrate() fits the scale on about 50 to 150 labeled images, where a few measured points per image are enough, without retraining. In our batch-1 TensorRT FP16 benchmark on an NVIDIA T4 at about 768-pixel input, inference-only latency (excluding pre- and post-processing) ranges from 2.7 ms (n) to 13.6 ms (x), and all five sizes had lower latency than Depth Anything V2 Small. This is a latency comparison, not a shared accuracy evaluation. Models export to ONNX, TensorRT, CoreML, OpenVINO and other formats, and train with the same Python API and CLI as detection, segmentation and pose. License: AGPL-3.0, or an Ultralytics Enterprise license for closed-source commercial use. Best for: low-latency depth on NVIDIA GPUs alongside other YOLO tasks; measure on your edge device. Trade-offs: absolute scale depends on calibration for your camera, and its accuracy isn't compared with the foundation models here under a shared protocol, so test it on your own data.

UniDepth V2#

UniDepth predicts metric depth and the camera's intrinsics from a single RGB image, and can use known intrinsics when you have them. License: CC BY-NC 4.0. Best for: research and prototypes that need metric depth from unknown cameras. Trade-off: the license rules out commercial use.

ZoeDepth#

ZoeDepth combines relative depth pretraining with metric heads for indoor (NYU) and outdoor (KITTI) scenes. License: MIT. Best for: a permissively licensed metric model when your scenes resemble its indoor or outdoor training domains. Trade-off: it was trained for specific indoor and outdoor domains, while newer metric models such as UniDepth and Metric3D v2 were designed for varied cameras. Intel has archived the repository, so it no longer receives fixes.

Depth estimation on edge devices#

On edge hardware the question shifts from "most accurate" to "accurate enough at my frame rate". Three groups of models fit:

• Small versions of large families. Depth Anything V2 Small (24.8M parameters, Apache 2.0) is one option, with a permissive license. The MiDaS v3.1 Swin2-Tiny and LeViT models are designed for embedded devices.
• Real-time task models. Ultralytics YOLO26 depth runs at 2.7 ms (n) to 13.6 ms (x) inference-only at batch 1, excluding pre- and post-processing, on a Tesla T4 with TensorRT FP16. It exports to TensorRT for NVIDIA Jetson, CoreML for Apple devices and OpenVINO for Intel CPUs; export support is not an edge-device benchmark.
• Lightweight research models. FastDepth (MIT) was built for embedded systems and demonstrated on an NVIDIA Jetson TX2. Lite-Mono (MIT) has 2.2M to 8.7M parameters, trained on driving data from KITTI.

Measure inference latency on your target device after export, at the resolution you'll deploy. To choose the hardware, see picking the right edge device. For export options, see our guide to model deployment options.

Fig 3. Ultralytics YOLO26n-depth (89 to 96 ms) and YOLO26s-depth (124 to 128 ms) on the same store photo, on an Apple M4 CPU (PyTorch, 768-pixel input, from image to finished depth map). Laptop timings vary with background load, so read them as ranges. The photo was generated for this article; the depth maps and timings are real.

Depth estimation for robotics#

Robots usually need metric depth, stable from frame to frame, at the robot's control rate. Three practical paths:

• Monocular metric models suit robots with a single RGB camera. Use a model that handles your camera: Metric3D v2 or Depth Anything 3 Metric with known intrinsics, or a calibrated Ultralytics YOLO26 depth model when you need low-latency onboard inference on an NVIDIA GPU alongside other YOLO tasks; measure on your robot's computer.
• Stereo models such as NVIDIA's FoundationStereo compute metric depth from a calibrated camera pair. The research release is for non-commercial use; NVIDIA lists a TAO version for commercial use. See stereo vision for how stereo compares with monocular depth.
• Depth sensors (stereo depth cameras, structured light or LiDAR) measure depth directly.

When a monocular model isn't the right choice: for safety-critical decisions such as collision avoidance near people, use a depth sensor or stereo pair and treat monocular depth as a complement, for example to fill gaps where the sensor returns no data.

Fig 4. Predicted distances read from one Ultralytics YOLO26s-depth map: 3.1 m to a point on the floor, 5.7 m to the robot and about 23 m to the end of the aisle. The photo was generated for this article; the readings are real model outputs, uncalibrated for this camera, so they are predictions, not measurements.

How to test depth models on your own camera#

• Collect about 50 to 150 labeled images from the deployment camera, at deployment resolution and lens settings, with a few measured points per image. Public benchmarks such as NYU Depth V2 (indoor) and KITTI (driving) are useful for a first comparison, but results on your own camera decide.
• A rangefinder measures straight-line distance, while calibration needs depth along the camera axis: measure points near the image center, convert off-center readings to camera-axis depth using the camera intrinsics, or collect depth with a depth sensor.
• Compare candidates on δ1 and absolute relative error against those measurements, and time each one on the target device. For metric models, score the raw output without rescaling each image to match the ground truth; per-image alignment hides exactly the scale errors you need to find.
• For a metric model with a fixed scale, calibrate it on part of the data and test on the rest. Ultralytics YOLO26 depth includes this as model.calibrate().