MiDaS

MiDaS is a family of networks for monocular depth estimation from the Intelligent Systems Lab at Intel Labs. Given one RGB image, a MiDaS model predicts a dense map of relative inverse depth, correct only up to an unknown scale and shift. The method was first released in July 2019 with a preprint by Lasinger, Ranftl, Schindler and Koltun, and published as Ranftl, Lasinger, Hafner, Schindler and Koltun (2022) in IEEE Transactions on Pattern Analysis and Machine Intelligence. Its contribution is a training recipe rather than an architecture: a loss that is invariant to the scale and shift of each image’s labels, so that datasets with incompatible depth annotations can be mixed; a multi-objective way of mixing them; a new data source of stereo frames from 3D films; and evaluation by zero-shot transfer to datasets never used in training. The released models moved from a convolutional encoder–decoder (v2.1) to the dense prediction transformer, DPT, built on vision transformers (v3.0), and then to a zoo of transformer backbones (v3.1).

This article reads the paper in the authors’ copy on Vladlen Koltun’s publication page (a pre-publication version headed “Vol. XX, No. XX, 2020”); section, equation, figure and table numbers below are from that copy and may differ in the published version. Version details come from the official repository’s README, release notes and code at a pinned commit (references), DPT (Ranftl, Bochkovskiy and Koltun, 2021, with its supplement) and Depth Anything (Yang et al., 2024), both read in their CVF open-access copies. The MiDaS v3.1 technical report (Birkl, Wofk and Müller, 2023) was not read, so v3.1 is described from the README and code only.

Problem Addressed

Supervised depth networks of the late 2010s were typically trained on a single dataset, such as NYU Depth v2 indoors or KITTI street scenes, and the paper argues that such models generalize poorly to unconstrained images because no single dataset is large, diverse and accurately labelled at once (Sections 1 and 2). Larger and more varied sources existed, but their labels are not interchangeable (Section 5): laser scanners and RGB-D cameras give metric depth, structure from motion gives depth up to an unknown scale, and stereo footage with unknown calibration gives disparity up to an unknown scale and an unknown shift. A loss that compares the network’s output with each label directly cannot use all three. Why one image fixes depth only up to scale, and why uncalibrated stereo adds a shift, is derived in the monocular depth estimation article; MiDaS’s response was to give up on metric output and learn the part every dataset agrees on, the shape of inverse depth.

The authors also proposed a different test. Instead of a held-out split of a training dataset, which shares its biases, they test on datasets never seen in training, which they call zero-shot cross-dataset transfer, as a closer proxy for performance “in the wild” (Sections 1 and 7).

Architecture

All MiDaS models are encoder–decoders that output one non-negative value per pixel, read as inverse depth up to scale and shift. In the official code every depth head ends in a ReLU (non_negative=True in midas/midas_net.py and midas/dpt_depth.py).

Convolutional encoder and decoder (v2 and v2.1)

The paper starts from the ResNet-based multi-scale architecture of Xian et al. (ReDWeb) and swaps encoders (Section 6). It compared ResNet-50, ResNet-101, DenseNet-161 and ResNeXt-101 pretrained on ImageNet, and a ResNeXt-101 pretrained on a large weakly supervised image corpus before ImageNet (WSL). ImageNet accuracy predicted depth accuracy, the WSL encoder was best, with up to 15% relative improvement over ResNet-50, and a randomly initialized ResNet-50 was on average 35% worse than its pretrained counterpart (Figure 4 and text). All later experiments use ResNeXt-101-WSL.

In the code, the v2.1 large model (MidasNet) loads ResNeXt-101 32×8d WSL weights through PyTorch Hub, projects the outputs of its four ResNet stages to 256 channels, and fuses them from coarse to fine with four RefineNet-style fusion blocks built from residual convolution units. Its head is a 3×3 convolution to 128 channels, ×2 bilinear upsampling, a 3×3 convolution to 32 channels with ReLU, and a 1×1 convolution to one channel with ReLU. The v2.1 small model (MidasNet_small) uses an EfficientNet-Lite3 encoder with 64 base decoder features. DPT’s Table 9 counts 105 million parameters for the MiDaS convolutional model.

DPT decoder and transformer backbones (v3.0 and v3.1)

MiDaS v3.0, released in April 2021 according to the README’s changelog, replaced the convolutional encoder with DPT (Ranftl, Bochkovskiy and Koltun, 2021). A ViT turns the image into tokens, either from 16×16 patches (DPT-Base, DPT-Large) or from ResNet-50 features (DPT-Hybrid). Reassemble blocks take the tokens of four transformer layers, fold the readout (class) token into the others, place the tokens back on the patch grid, and resample them to 1/32, 1/16, 1/8 and 1/4 of the input resolution. RefineNet-based fusion blocks then combine the four maps from coarse to fine, upsampling by two at each stage (DPT, Section 3). For ViT-Large the tapped layers are 6, 12, 18 and 24; DPT-Hybrid taps the first two ResNet stages and layers 9 and 12. The depth head has three convolutions: it halves the features, upsamples to the input resolution, maps to 32 channels and then to one non-negative inverse depth (DPT supplement, Section 1). Batch normalization is disabled in the depth decoder. Because the transformer keeps one token per patch at every layer and attends globally, the authors argue it gives finer and more globally coherent predictions than a downsampling CNN (Sections 1 and 3).

The v3.1 release (December 2022) kept the DPT decoder and added backbones: BEiT, Swin, SwinV2, Next-ViT and LeViT (README changelog). In midas/dpt_depth.py each backbone has its own set of tapped blocks; hierarchical backbones (Swin, SwinV2, Next-ViT, LeViT) can only be tapped within each stage’s range, and LeViT uses three stages instead of four. The model names give the backbone and the square training resolution, from dpt_beit_large_512 (345 million parameters in the README table) down to dpt_levit_224 (51 million) and dpt_swin2_tiny_256 (42 million).

Training

Disparity space and the scale-and-shift-invariant loss

MiDaS predicts in disparity space, inverse depth up to scale and shift, and compares each prediction with its label only after both have been aligned (Section 5). The monocular depth estimation article gives the alignments and losses: the closed-form least-squares fit of $(s, t)$ behind $\mathcal{L}_{\text{ssimse}}$, and the robust normalization of prediction and label separately by their median and mean absolute deviation, used with absolute residuals in $\mathcal{L}_{\text{ssimae}}$ and, trimmed, in $\mathcal{L}_{\text{ssitrim}}$ (Eqs. 1–7). Three further points of the paper concern the choice of loss.

• Why disparity. The paper calls disparity space numerically stable and compatible with common representations of relative depth (Section 5). Unlike Eigen et al.’s scale-invariant log loss, which it rewrites as $\mathcal{L}_{\text{silog}}(z, z^*) = \min_s \frac{1}{2M}\sum_i (\log(e^s z_i) - \log z_i^*)^2$ (Eq. 8), the disparity losses also absorb a global shift.
• Why trimming. $\mathcal{L}_{\text{ssitrim}}$ drops the 20% largest residuals in every image, $U_m = 0.8M$, a value set from experiments on ReDWeb. The stated reasoning is that ground-truth outliers should never influence training, rather than only being down-weighted as in an M-estimator (Eq. 7).
• Which loss won. Networks were trained on ReDWeb and validated on ReDWeb, MegaDepth and 3D Movies (Figure 3). The paper’s four losses, $\mathcal{L}_{\text{ssimse}}$, $\mathcal{L}_{\text{ssimae}}$, $\mathcal{L}_{\text{ssitrim}}$ and a scale-invariant but not shift-invariant MSE in disparity ($t = 0$), each combined with the gradient-matching term below, beat on average the ordinal loss of Chen et al., the scale-invariant log loss (also with gradient matching) and the normalized multiscale gradient loss of Wang et al., and the trimmed loss had the best mean. The text says the trimmed loss gave the lowest validation error over all datasets; in the figure, the log loss with gradient matching is slightly ahead of it on MegaDepth alone.

The full loss adds a multi-scale gradient-matching term, adapted from MegaDepth’s to disparity space, which biases depth discontinuities to be sharp and to coincide with those of the ground truth (Eq. 11):

$$\mathcal{L}_{\text{reg}}(\hat d, \hat d^*) = \frac{1}{M}\sum_{k=1}^{K}\sum_{i=1}^{M}\Big(\big|\nabla_x R_i^k\big| + \big|\nabla_y R_i^k\big|\Big), \qquad R_i = \hat d_i - \hat d_i^*,$$

where $R^k$ is the residual map at scale $k$, with $K = 4$ scales, each halving the resolution. For a training set $l$ with $N_l$ images the loss is

$$\mathcal{L}_l = \frac{1}{N_l}\sum_{n=1}^{N_l} \mathcal{L}_{\text{ssi}}\big(\hat d^n, (\hat d^*)^n\big) + \alpha\,\mathcal{L}_{\text{reg}}\big(\hat d^n, (\hat d^*)^n\big), \qquad \alpha = 0.5$$

(Eq. 12). Ground-truth disparities are shifted and scaled to $[0, 1]$ for all datasets (Section 6).

Training data

The paper’s five training sets are listed in its Table 1, with their annotation type, which is what the loss must reconcile:

Dataset	Source of labels	Depth given	Images
DIML Indoor	RGB-D (Kinect v2)	metric	220K
MegaDepth	structure from motion and multi-view stereo	no scale	130K
ReDWeb	stereo from the web	no scale and shift	3,600
WSVD	stereo videos from the web	no scale and shift	1.5M
3D Movies (new)	stereo frames from films	no scale and shift	75K

WSVD is distributed only as links to videos, so the authors regenerated its ground truth following the original authors’ procedure (Section 3).

3D Movies. The new dataset comes from 23 Blu-ray films shot with physical stereo cameras, chosen for diversity (Section 4). Stereo film is made for comfortable viewing, not measurement: focal length, baseline and convergence change between scenes, disparities are both positive and negative, and the zero-disparity plane is often moved in post-production. Frames were extracted at 1920×1080, centre-cropped to 1880×800, split into clips with FFmpeg’s scene detection, and sampled at 4 frames per second for training. Because stereo matchers of the time assumed positive disparities, the authors took the horizontal component of an optical flow estimate in both directions as disparity, marked pixels failing a 2-pixel left–right check as invalid, rejected frames by rules adopted from WSVD (too much vertical disparity, a horizontal range under 10 pixels, or fewer than 70% of pixels passing the check), and set sky pixels, found by a semantic segmentation network, to the image’s minimum disparity. Nineteen films gave 75,074 training frames, two gave 3,058 validation frames and two gave 788 test frames (Table 2).

One dataset at a time. Fine-tuned from the ReDWeb model on each other dataset alone, every dataset improved some test sets similar to it (DIML on the indoor ones, MegaDepth on ETH3D) but lowered the average over the six zero-shot test sets, so that none beat the small, curated ReDWeb on average (Tables 3 and 4). 3D Movies generalized better than WSVD, which the authors attribute to the higher-quality stereo of a controlled production.

Later versions. DPT trained on MIX 6, the five datasets above plus ApolloScape, IRS, TartanAir, HRWSI and BlendedMVS, about 1.4 million images (DPT, Section 4.1). The README says MiDaS v2.1 was trained on 10 datasets; its list at the v2.1 release names nine of them, and the current README adds HRWSI, which completes the same ten as MIX 6. In our reading v2.1 large is the convolutional model DPT retrained on MIX 6, since DPT’s numbers for that model match the README’s for v2.1 (see Performance). For v3.1 the README lists 12 datasets: the ten plus KITTI and NYU Depth v2, used with the split of the BTS method. A v3.1 model therefore has no zero-shot result on those two benchmarks.

Multi-objective mixing

How should a minibatch draw from datasets of 3,600 and 1.5 million images? The naive strategy takes equal parts from each dataset in every minibatch. The multi-objective strategy treats each dataset as a task with its own loss $\mathcal{L}_l$ and seeks an approximate Pareto optimum, a point where no dataset’s loss can be lowered without raising another’s, using the algorithm of Sener and Koltun (2018) on

$$\min_\theta \big(\mathcal{L}_1(\theta), \ldots, \mathcal{L}_L(\theta)\big)^\top$$

with parameters $\theta$ shared across datasets (Section 5, Eq. 13). The authors built five mixtures by adding datasets in order of their single-dataset value: MIX 1 is ReDWeb and DIML; MIX 2 adds 3D Movies; MIX 3 adds MegaDepth; MIX 4 is all except 3D Movies; MIX 5 is all five (Table 5). With naive mixing, adding datasets usually helped but not always: the mean relative improvement over the ReDWeb baseline fell from 18.3% (MIX 1) to 17.3% (MIX 2). With multi-objective mixing it rose from 16.6% to 22.4% for MIX 5, against 19.5% for naive MIX 5 (Tables 6 and 8). MIX 4 without 3D Movies reached 21.6%.

DPT also used multi-objective optimization with Adam. Because its batch size of 16 is not divisible by the number of datasets, it built each minibatch by first drawing datasets uniformly at random and then sampling from them (DPT, Section 4.1).

Procedure

In the paper (Section 6), the encoder starts from pretrained weights and the decoder from random ones. Adam uses a learning rate of $10^{-4}$ for the new layers and $10^{-5}$ for the pretrained ones. The only augmentations are horizontal flips with probability 0.5 and random crops resized to 384×384. Minibatches hold eight images per dataset, an “epoch” is 72,000 images, and training runs 60 epochs, starting from the model pretrained on ReDWeb; the experiments took about six GPU-months in total (Section 1). DPT kept the protocol with learning rates of $10^{-5}$ for the backbone and $10^{-4}$ for the decoder, random square 384-pixel crops after resizing the longer side to 384, 60 epochs of 72,000 steps with batch size 16, after 60 epochs of pretraining on ReDWeb, HRWSI and BlendedMVS.

At the pinned commit the official repository holds inference, export and demo code but no training code, and Depth Anything’s authors write that they reproduced MiDaS’s training because its code was not released (Yang et al., 2024, Section 3.1).

Inference

The input is one RGB image of any size; no intrinsics are needed. In the official run.py and midas/model_loader.py, the image is resized with bicubic interpolation to the model’s resolution, keeping the aspect ratio where the backbone allows it (all except Swin, SwinV2 and LeViT, which need square inputs, and the OpenVINO model) and rounding both sides to multiples of 32, then normalized: with ImageNet mean and standard deviation for the v2.1 models and with mean and standard deviation 0.5 for the DPT models. The network output is upsampled bicubically to the input size. The script writes it as a floating-point PFM file and as a PNG stretched to the image’s own minimum and maximum (an 8-bit inferno colour map by default, 16-bit grayscale with --grayscale). So a saved PNG carries an arbitrary scale and shift on top of the model’s, and two images’ PNGs cannot be compared.

The output is relative inverse depth: larger values are nearer, and the unknown scale and shift differ from image to image. Turning it into metric depth needs at least two known depths in the image (in our reading, since two unknowns are fitted), or a model trained for metric output, such as ZoeDepth below; the monocular depth estimation article’s example shows what alignment in inverse depth recovers. The DPT models ran at speeds comparable to the convolutional model on a GPU (DPT, Table 9), and the README lists frames per second for every model on an RTX 3090, from 5.7 for dpt_beit_large_512 to 90 for midas_v21_small_256, and 22 frames per second for the small model through OpenVINO on an Intel Core i7-1185G7 CPU.

Performance

Zero-shot protocol

The paper tests on six datasets never used in training, each with a metric that fits its ground truth (Section 6):

• DIW, sparse human-annotated ordinal pairs: the official test set of 74,441 images, scored by the weighted human disagreement rate (WHDR). The ablations use a 10,000-image validation set drawn from DIW’s training set instead.
• ETH3D, laser scans: all 454 images with ground truth, by AbsRel.
• MPI Sintel, synthetic: all 1,064 images, by AbsRel on pixels with ground-truth depth below 72 m.
• KITTI: 161 images, the intersection of the official depth validation set (with its improved ground truth) and the Eigen test split, by the percentage of pixels with $\delta = \max(z/z^*, z^*/z) > 1.25$.
• NYU Depth v2: the official 654 test images, by the same percentage.
• TUM RGB-D: the dynamic subset with people indoors, 1,815 images, by the same percentage.

Every prediction, including those of the compared methods, is aligned to the ground truth in scale and shift per image by least squares in inverse depth; predictions are capped at 72, 80, 10 and 10 m for ETH3D, KITTI, NYU and TUM. Test images are resized so that the longer side is 384 pixels and the shorter a multiple of 32 (for KITTI the shorter side is set to 384 instead). Lower is better for every metric. Because the alignment removes scale and shift, these numbers measure the shape of the inverse depth only, not metric accuracy.

Results of the paper

Table 11 of the paper (absolute errors, zero-shot rows only; WHDR and $\delta > 1.25$ in percent):

Model	Training data	DIW	ETH3D	Sintel	KITTI	NYU	TUM
MiDaS, ResNeXt-101-WSL	MIX 5	12.46	0.129	0.327	23.90	9.55	14.29
MiDaS, ResNet-50 (“small”)	MIX 5	12.48	0.155	0.330	21.81	15.73	17.00
Xian et al.	ReDWeb	14.59	0.186	0.422	34.08	27.00	25.02
Wang et al.	WSVD	19.09	0.205	0.390	31.92	29.57	20.18
Li and Snavely	MegaDepth	23.15	0.181	0.385	36.29	27.52	29.54
Li et al.	Mannequin Challenge	26.52	0.183	0.405	47.94	18.57	17.71
Casser et al.	Cityscapes	32.80	0.235	0.422	21.15	39.58	37.18

The full model was best on five of the six test sets; on KITTI, Casser et al.’s model trained on Cityscapes street scenes (21.15) and the ResNet-50 variant (21.81) were better. The small variant has the architecture of Xian et al., and it too beat every earlier zero-shot model, from which the authors conclude that the gain comes from the training scheme and not only from capacity. The lower part of the same table shows models fine-tuned on one of the test datasets: Godard et al.’s KITTI model reached 5.53 on KITTI and Fu et al.’s NYU model 8.69 on NYU, but both did much worse than MiDaS on the other five sets. The multi-objective MIX 5 row of Table 9 repeats these numbers except on DIW (12.27 against 12.46), which in our reading reflects the DIW validation set used for the mixing ablations.

Later versions

DPT’s Table 1 uses the same protocol and reports relative change against the MIX 5 model:

Model	Training data	DIW	ETH3D	Sintel	KITTI	NYU	TUM
DPT-Large	MIX 6	10.82	0.089	0.270	8.46	8.32	9.97
DPT-Hybrid	MIX 6	11.06	0.093	0.274	11.56	8.69	10.89
MiDaS (convolutional)	MIX 6	12.95	0.116	0.329	16.08	8.71	12.51
MiDaS (convolutional)	MIX 5	12.46	0.129	0.327	23.90	9.55	14.29

The average relative improvement over the MIX 5 model was more than 23% for DPT-Hybrid and 28% for DPT-Large (DPT, Section 4.1); the abstract says “up to 28%” and the introduction “more than 28%”. In our arithmetic, the means of Table 1’s six relative changes are 28.3% and 23.1%. Retraining the convolutional network on MIX 6 also helped on average, but less, and not on DIW or Sintel, so the authors attribute part of the gain to the architecture and conclude that DPT benefits more from a larger training set. The MIX 6 convolutional row matches, number for number, the README’s v2.1 large model; the v2.1 README of November 2020 already printed these values and the same relative changes against v2, and in our reading it is the same network, though no source says so. DPT’s supplementary Table A1 prints 24.29 for the MIX 5 model on TUM where the main Table 1 and the paper print 14.29.

The README compares every release with the v3.0 DPT-Large model at the same protocol. Its column headers call the KITTI, NYU and TUM metric $\delta_1$, but the values match DPT’s percentages of pixels with $\delta > 1.25$ (for example 8.46 on KITTI for DPT-Large), so lower is better. As printed, at the inference heights of each model’s training resolution:

README model	DIW	ETH3D	Sintel	TUM	KITTI	NYU	Parameters
v3.1 BEiT-L 512 (height 512)	0.1137	0.0659	0.2366	6.13	11.56*	1.86*	345M
v3.1 Swin2-L 384 (square)	0.1106	0.0732	0.2442	8.87	5.84*	2.92*	213M
v3.0 DPT-L 384	0.1082	0.0888	0.2697	9.97	8.46	8.32	344M
v2.1 Large 384	0.1295	0.1155	0.3285	12.51	16.08	8.71	105M
v2.1 Small 256	0.1344	0.1344	0.3370	14.53	29.27	13.43	21M

The asterisks mark results that are not zero-shot, because v3.1 trained on KITTI and NYU Depth v2. The README warns that results at different resolutions, and square against aspect-preserving inputs, are not fully comparable. Its improvement column, an average of error ratios against v3.0 over the six datasets, puts the BEiT-L 512 model 19% better at height 512 and 34% better with square inputs at that height, while the changelog says “about 28%”, the value the table gives for the same model at height 384. DIW did not improve with every release: at height 384 the README gives v3.0 DPT-L a lower WHDR (0.1082) than either v3.1 BEiT-L model (0.1245 and 0.1239).

Depth Anything’s authors compared their models with “the best DPT-BEiT$_{L\text{-}512}$ model from the latest MiDaS v3.1” on six datasets, with AbsRel and $\delta_1$ (the fraction of pixels with $\delta < 1.25$, higher is better) as metrics, so their numbers are not comparable with those above (Yang et al., 2024, Table 2). There, MiDaS v3.1 had AbsRel 0.127 and $\delta_1$ 0.850 on KITTI against 0.076 and 0.947 for Depth Anything ViT-L, which, unlike MiDaS v3.1, saw no KITTI or NYU images in training.

Strengths

• Uses data no single-label method could. Metric RGB-D, scale-free SfM and uncalibrated stereo, including films, train one model (Section 5).
• Generalization tested on unseen data. Results are reported on datasets held out entirely from training; DPT kept the protocol, and Depth Anything also evaluated zero-shot on six unseen datasets (Yang et al., 2024, Section 4.2).
• Robust to unusual inputs. The authors report plausible relative depth on paintings and line drawings as long as some depth cues, such as shading or vanishing points, are present (Section 6, Figure 8).
• A range of sizes. As of November 2026 the repository offers models from 21 to 345 million parameters, with TensorFlow and ONNX versions of v2.1 and an OpenVINO version of the v2.1 small model.

Limitations

• No metric depth. The output has an unknown scale and shift per image, so it gives no distances. Each video frame is processed alone, so in our reading nothing ties the scale and shift of consecutive frames together; for the paper’s supplementary video, each clip’s inverse depth maps were scaled and shifted jointly for display (Section 6).
• Learned biases. The authors document failure cases (Section 6, Figure 9): the model learned that lower image regions are nearer, which fails on rotated images; paintings, photographs and mirrors are given the depth of what they show; strong edges can create false depth discontinuities; thin structures can be missed; relative placement of disconnected objects can fail; and backgrounds are blurred, which they relate to input resolution and imperfect far-range ground truth.
• Evaluation after alignment hides some errors. Per-image alignment forgives any affine distortion of inverse depth; the monocular depth estimation article shows what each alignment can and cannot repair.
• Reproducibility. The training code was not released, and Depth Anything’s authors report that 3D Movies and WSVD are no longer available (Yang et al., 2024, Section 3.1). WSVD was already distributed only as video links, which the MiDaS paper notes often become unavailable (Section 2).
• Zero-shot claims depend on the version. v3.1 trained on KITTI and NYU Depth v2, so its numbers on those benchmarks are not zero-shot (README; Yang et al., 2024, Table 2).

Historical Importance

MiDaS showed that the label incompatibility between depth datasets could be handled in the loss, so that data could be pooled at scale, and it tested general-purpose depth models by zero-shot cross-dataset transfer, a protocol DPT kept. The depth estimation hub places it between single-dataset supervised networks and the foundation models trained on tens of millions of images. Its successors kept its relative, affine-invariant output and its loss: DPT trained with the trimmed scale-and-shift-invariant loss and gradient matching, ZoeDepth appended a metric depth binning module to a MiDaS decoder (README), and Depth Anything followed MiDaS in relative depth estimation and reproduced its training as the first stage of its own (Yang et al., 2024, Sections 2 and 3.1).

Variants

Release dates are from the README changelog; the GitHub release objects for v3 and v3.1 were published in December 2022.

• v1 (July 2019). The first model, trained on ReDWeb, MegaDepth and 3D Movies with multi-objective mixing (MGDA in the README) and the films sampled at 4 frames per second (v1 README).
• v2 (December 2019). The five-dataset model, called “DS 4” in the v2 README and MIX 5 in the paper (README at v2.1, whose “MiDaS v2 large” row repeats the paper’s MIX 5 numbers). The v2.1 README also lists a “MiDaS v2 small” whose numbers match the paper’s ResNet-50 “Ours – small” row.
• v2.1 (November 2020). The convolutional large model retrained on ten datasets, about 10% more accurate than v2 by the README’s average, and a new small model with an EfficientNet-Lite3 encoder at 256 pixels for phones, with iOS, Android and ROS demos.
• v3.0 (April 2021). DPT-Large and DPT-Hybrid at 384 pixels, about 21% more accurate than v2.1 by the README’s average. The README points to the separate DPT repository for more DPT models.
• v3.1 (December 2022). BEiT, SwinV2, Swin, Next-ViT and LeViT backbones with the DPT decoder, trained on 12 datasets.
• ZoeDepth (Bhat et al., 2023), another Intel Labs project, combines a MiDaS relative-depth model with a metric depth binning module on the decoder (README); the depth estimation hub describes it.
• Depth Anything (Yang et al., 2024) reproduces MiDaS’s affine-invariant training on labeled data and adds large-scale pseudo-labeled images.

Implementations

As of November 2026, the official repository, isl-org/MiDaS, is under the MIT License and provides inference code for all released models with weights on its GitHub releases, models on PyTorch Hub (DPT_BEiT_L_512, DPT_Large, MiDaS, MiDaS_small and others in hubconf.py), TensorFlow and ONNX versions and a ROS package, which the README says support only v2.1, and iOS and Android apps. The README lists two other Intel Labs projects that use MiDaS: ZoeDepth and LDM3D, whose depth maps for supervision were computed with MiDaS. The repository does not include training code.