fastforks/depth-anything-3

Depth Anything 3 (fastforks)

Depth Anything 3 (Lin et al. 2025, ByteDance): monocular depth from a DINOv2 ViT with DPT heads; relative (Mono), metric (Metric), any-view depth with camera (Large, Giant) and Giant aligned to Metric (Nested).

This repo is the model card only: it holds no weights. fastforks downloads the authors' weights from the links below and checks them against the SHA-256 in the model card. Code: https://github.com/kleinicke/fastforks. Kernels for the kernels backend: https://huggingface.co/fastforks/kernels. Original code: https://github.com/ByteDance-Seed/Depth-Anything-3 at 3d835ec.

Author weight repos: https://huggingface.co/depth-anything/DA3-GIANT-1.1, https://huggingface.co/depth-anything/DA3-LARGE-1.1, https://huggingface.co/depth-anything/DA3METRIC-LARGE, https://huggingface.co/depth-anything/DA3MONO-LARGE, https://huggingface.co/depth-anything/DA3NESTED-GIANT-LARGE-1.1.

Task: depth. Tier: experimental. Outputs: depth, confidence, intrinsics, mask, sky. Backends: portable, kernels.

Input: one RGB image. Output: a depth or inverse-depth map. kind (a card field, result.kind) says what the numbers mean: metric = metres; scale_invariant, affine_invariant and affine_invariant_inverse are relative (unknown scale or shift, not metres). Metric models that use the focal length take model(image, intrinsics=K) (K [3, 3], pixels of the input): metric3d-vit-large and da3metric-large need it for correct metres (da3metric-large: metres = output x focal / 300; without intrinsics= a 300 px focal length is assumed, wrong for a real camera). unidepth-v2-vitl14, unik3d-vitl, depth-pro and MoGe estimate the camera themselves (given intrinsics= replace fx); zoedepth-nk and the relative models (da3mono-large too) take none.

Variants

Weights are the authors' files (not hosted here). SHA-256 shortened to 12 hex digits; the full hashes are in card.toml.

variant	weights (author link)	SHA-256	weights licence	commercial use
da3-giant-1.1@1	model.safetensors	1e47a08338ca	CC-BY-NC-4.0	no
da3-large-1.1@1	model.safetensors	739905c423cf	CC-BY-NC-4.0	no
da3metric-large@1	model.safetensors	bbea5b0b3ee3	Apache-2.0	yes
da3mono-large@1	model.safetensors	7a799a7f95eb	Apache-2.0	yes
da3nested-giant-large-1.1@1	model.safetensors	8ebe871a022e	CC-BY-NC-4.0	no

Licence

Original-code strings, recorded as they are (research-use package; check them before any other use). Code: Apache-2.0. Files: LICENSE.

Training data: Public academic datasets only (model cards); teacher-student training on synthetic and real multi-view data per the paper.

• Licence note: The Mono and Metric weights are Apache-2.0 but their training data terms are unchecked (a note only); the other variants' weights are CC-BY-NC-4.0 (no).

Licence evidence: https://github.com/ByteDance-Seed/Depth-Anything-3/blob/main/README.md (Model Cards table) and the Hugging Face model cards (DA3-LARGE-1.1's card says Apache 2.0, the repository table CC BY-NC 4.0; the table is recorded)

Input size

any H x W >= 8, resized or padded inside the model (ViT patch 14) Tested up to (portable, fp16, RTX 5060 Ti 16 GB): da3-giant-1.1 3000x4000 (5.1 GiB peak allocated, 5.4 reserved); da3-large-1.1 3000x4000 (1.9 GiB peak allocated, 2.2 reserved); da3metric-large 3000x4000 (1.9 GiB peak allocated, 2.1 reserved); da3mono-large 3000x4000 (1.9 GiB peak allocated, 2.1 reserved); da3nested-giant-large-1.1 3000x4000 (6.3 GiB peak allocated, 6.7 reserved)

Speed and memory

Depth, Middlebury 2014 half, 994x1482

model	time (ms): original fp32	original	portable	kernels	kernels speed-up: vs original	vs portable	peak memory (MiB, allocated / reserved): original	portable	kernels
da3-giant-1.1	409.52	227.05	81.84	44.19	5.1x	1.9x	8590 / 8718	2638 / 4608	2628 / 2710
da3-large-1.1	207.67	165.63	37.36	17.13	9.7x	2.2x	3374 / 3472	992 / 1350	985 / 1090
da3metric-large	127.57	85.12	24.08	14.71	5.8x	1.6x	2996 / 3050	815 / 1328	811 / 868
da3mono-large	127.23	85.15	23.93	14.56	5.8x	1.6x	2997 / 3052	818 / 1328	814 / 868
da3nested-giant-large-1.1	532.85	308.25	107.96	58.23	5.3x	1.9x	10332 / 10402	3275 / 5914	3271 / 3378

Startup and first call

model	load (s): original	portable	kernels	first call (s): original	portable	kernels
da3-giant-1.1	12.39	6.29	0.90†	0.68	0.16	0.06
da3-large-1.1	3.46	3.65	0.31†	0.45	0.25	0.03
da3metric-large	2.70	0.35	0.30†	0.28	0.05	0.02
da3mono-large	2.96	4.25	1.44†	0.28	0.09	0.02
da3nested-giant-large-1.1	28.67	13.25	2.73†	1.63	0.55	0.07

torch.compile and TensorRT

model	input	portable ms	compile ms	compile s (cold)	TensorRT fp16 ms	ONNX + build s	kernels ms	peak MiB (alloc / reserved): portable	compile	TensorRT (device)
da3mono-large	994x1482	23.93	21.2	25.0	fails: TensorRT engine build failed	–	14.56	818 / 1328	792 / 828	–

Fixed-size speed and peak memory, all models

model	mode	640x480	1280x720	1920x1080	12 MP 4000x3000
da3-giant-1.1	portable	112.6 ms / 5032 / 5332	90.1 ms / 4930 / 5150	90.3 ms / 4943 / 5150	118.5 ms / 5206 / 5524
da3-giant-1.1	kernels	49.5 ms / 2630 / 3032	36.0 ms / 2562 / 2854	36.7 ms / 2575 / 2886	54.5 ms / 3011 / 3386
da3-large-1.1	portable	45.6 ms / 1733 / 1992	37.8 ms / 1639 / 1814	38.8 ms / 1651 / 1826	51.5 ms / 1938 / 2214
da3-large-1.1	kernels	18.3 ms / 967 / 1218	14.2 ms / 901 / 1068	14.8 ms / 914 / 1108	24.1 ms / 1354 / 1608
da3metric-large	portable	32.3 ms / 1542 / 1652	25.4 ms / 1488 / 1576	26.0 ms / 1502 / 1600	38.1 ms / 1896 / 2184
da3metric-large	kernels	15.7 ms / 805 / 880	12.1 ms / 782 / 838	12.8 ms / 795 / 858	21.5 ms / 1266 / 1570
da3mono-large	portable	32.2 ms / 1542 / 1652	25.2 ms / 1488 / 1576	25.9 ms / 1502 / 1600	38.0 ms / 1896 / 2184
da3mono-large	kernels	15.6 ms / 805 / 880	12.0 ms / 782 / 838	12.6 ms / 795 / 858	21.3 ms / 1266 / 1570
da3nested-giant-large-1.1	portable	145.3 ms / 6309 / 6624	114.9 ms / 6206 / 6432	115.5 ms / 6218 / 6440	151.5 ms / 6482 / 6810
da3nested-giant-large-1.1	kernels	65.6 ms / 3276 / 3658	48.0 ms / 3206 / 3490	48.7 ms / 3220 / 3528	71.2 ms / 3658 / 4168

Fixed-size cells: time (ms) / peak allocated / peak reserved memory (MiB).

Hardware, protocol and caveats: benchmarks (RTX 5060 Ti 16 GB, sm_120). Original = the authors' code at the precision of portable (fp16, or (fp32) where fp16 is unsupported or not finite); original fp32 = its default fp32 run. Peak memory is the torch allocator's.

Accuracy

Parity with the original code

Every variant is checked against golden outputs of the original code at its pinned commit. CPU, float32: max |diff| <= 0.005 vs the original. GPU, float16 (the default), portable and kernels: mean |diff| <= 0.5 % and p99 <= 2 % of the reference's median |value| (absolute error of the output depth).

Usage

from fastforks import depth

# non-commercial weights: run with FASTFORKS_NONCOMMERCIAL=1 in the environment
model = depth.load("da3-giant-1.1")  # mode="auto": the preferred backend from recorded measurements
result = model("room.jpg")
result.depth  # [H, W] float32 tensor; result.kind says what the maps mean
# models that take a camera: model("room.jpg", intrinsics=K), K [3, 3] in pixels
result.backend  # what ran, e.g. Backend(mode='portable', device='cuda:0', dtype='float16')

Install with pip install fastforks (see https://github.com/kleinicke/fastforks). Other variants: da3-giant-1.1, da3-large-1.1, da3metric-large, da3mono-large, da3nested-giant-large-1.1.

Kernels backend

depth.load("da3-giant-1.1", mode="kernels") runs our CUDA kernels (fastbb, dpt_fused). It needs a prebuilt kernel for your GPU architecture (downloaded from https://huggingface.co/fastforks/kernels on first use) and a recent NVIDIA driver; if there is none it raises BackendUnavailableError with the reason and never falls back silently. mode="auto" picks kernels when it can run and logs the choice.