diff --git a/.github/workflows/deploy-pages.yml b/.github/workflows/deploy-pages.yml
new file mode 100644
index 0000000..e94a0b8
--- /dev/null
+++ b/.github/workflows/deploy-pages.yml
@@ -0,0 +1,57 @@
+name: deploy github pages
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+env:
+  CARGO_TERM_COLOR: always
+  RUST_BACKTRACE: 1
+
+
+jobs:
+  deploy:
+    runs-on: macos-latest
+
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v3
+
+      - name: setup nightly rust toolchain with caching
+        uses: brndnmtthws/rust-action@v1
+        with:
+          toolchain: nightly
+          components: rustfmt, clippy
+          enable-sccache: "false"
+
+      - name: install wasm32-unknown-unknown
+        run: rustup target add wasm32-unknown-unknown
+
+      - name: install wasm-bindgen-cli
+        run: cargo install wasm-bindgen-cli
+
+      # - name: install wasm-opt
+      #   run: cargo install wasm-opt --locked
+
+      - name: build wasm artifacts
+        run: cargo build -p bevy_burn_depth --target wasm32-unknown-unknown --release --no-default-features --features "web"
+
+      # - name: optimize wasm artifacts
+      #   run: wasm-opt -O -ol 100 -s 100 -o ./target/wasm32-unknown-unknown/release/bevy_burn_depth_opt.wasm ./target/wasm32-unknown-unknown/release/bevy_burn_depth.wasm
+
+      - name: generate bindings with wasm-bindgen
+        run: wasm-bindgen --out-dir ./crates/bevy_burn_depth/www/out/ --target web ./target/wasm32-unknown-unknown/release/bevy_burn_depth.wasm
+
+      - name: copy assets
+        run: mkdir -p ./crates/bevy_burn_depth/www/assets && cp -r ./assets/* ./crates/bevy_burn_depth/assets/ && cp -r ./crates/bevy_burn_depth/assets/* ./crates/bevy_burn_depth/www/assets/
+
+      - name: deploy to github pages
+        uses: JamesIves/github-pages-deploy-action@v4
+        with:
+          folder: ./crates/bevy_burn_depth/www
+          branch: www
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 726cc82..5a3f2b6 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -34,4 +34,4 @@ jobs:
         enable-sccache: "false"
 
     - name: test (default)
-      run: cargo test --no-default-features --features backend_ndarray
+      run: cargo test --no-default-features --features=backend_ndarray
diff --git a/.gitignore b/.gitignore
index 5e79b24..1cd4b19 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,10 +10,11 @@ out/
 !tool/*.py
 *.mpk
 
+__pycache__/
+
 *.ply
 *.gcloud
 *.safetensors
-assets/model/
 
 __pycache__/
 
@@ -24,11 +25,11 @@ test_depth.png
 screenshots/
 headless_output/
 www/assets/
-crates/bevy_burn_dino/assets/
-crates/bevy_burn_dino/www/assets/
+crates/bevy_burn_depth/assets/
+crates/bevy_burn_depth/www/assets/
 
 assets/images/
-assets/models/
+assets/model/
 assets/pca/
 output/
 sandbox/
diff --git a/Cargo.lock b/Cargo.lock
index 8c664a9..427edbf 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -97,6 +97,15 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "aligned"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "377e4c0ba83e4431b10df45c1d4666f178ea9c552cac93e60c3a88bf32785923"
+dependencies = [
+ "as-slice",
+]
+
 [[package]]
 name = "aligned-vec"
 version = "0.6.4"
@@ -192,22 +201,22 @@ dependencies = [
 
 [[package]]
 name = "anstyle-query"
-version = "1.1.4"
+version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.10"
+version = "3.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -225,6 +234,15 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "ar_archive_writer"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0c269894b6fe5e9d7ada0cf69b5bf847ff35bc25fc271f08e1d080fce80339a"
+dependencies = [
+ "object",
+]
+
 [[package]]
 name = "arbitrary"
 version = "1.4.2"
@@ -242,7 +260,7 @@ checksum = "0ae92a5119aa49cdbcf6b9f893fe4e1d98b04ccbf82ee0584ad948a44a734dea"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -263,6 +281,15 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "175571dd1d178ced59193a6fc02dde1b972eb0bc56c892cde9beeceac5bf0f6b"
 
+[[package]]
+name = "as-slice"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "516b6b4f0e40d50dcda9365d53964ec74560ad4284da2e7fc97122cd83174516"
+dependencies = [
+ "stable_deref_trait",
+]
+
 [[package]]
 name = "ash"
 version = "0.38.0+1.3.281"
@@ -280,7 +307,7 @@ checksum = "f548ad2c4031f2902e3edc1f29c29e835829437de49562d8eb5dc5584d3a1043"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -383,6 +410,26 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
+[[package]]
+name = "av-scenechange"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f321d77c20e19b92c39e7471cf986812cbb46659d2af674adc4331ef3f18394"
+dependencies = [
+ "aligned",
+ "anyhow",
+ "arg_enum_proc_macro",
+ "arrayvec",
+ "log",
+ "num-rational",
+ "num-traits",
+ "pastey",
+ "rayon",
+ "thiserror 2.0.17",
+ "v_frame",
+ "y4m",
+]
+
 [[package]]
 name = "av1-grain"
 version = "0.2.5"
@@ -406,73 +453,12 @@ dependencies = [
  "arrayvec",
 ]
 
-[[package]]
-name = "axum"
-version = "0.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a18ed336352031311f4e0b4dd2ff392d4fbb370777c9d18d7fc9d7359f73871"
-dependencies = [
- "axum-core",
- "base64",
- "bytes",
- "form_urlencoded",
- "futures-util",
- "http",
- "http-body",
- "http-body-util",
- "hyper",
- "hyper-util",
- "itoa",
- "matchit",
- "memchr",
- "mime",
- "percent-encoding",
- "pin-project-lite",
- "serde_core",
- "serde_json",
- "serde_path_to_error",
- "serde_urlencoded",
- "sha1",
- "sync_wrapper",
- "tokio",
- "tokio-tungstenite",
- "tower",
- "tower-layer",
- "tower-service",
- "tracing",
-]
-
-[[package]]
-name = "axum-core"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59446ce19cd142f8833f856eb31f3eb097812d1479ab224f54d72428ca21ea22"
-dependencies = [
- "bytes",
- "futures-core",
- "http",
- "http-body",
- "http-body-util",
- "mime",
- "pin-project-lite",
- "sync_wrapper",
- "tower-layer",
- "tower-service",
- "tracing",
-]
-
 [[package]]
 name = "base64"
 version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
-[[package]]
-name = "base64ct"
-version = "1.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55248b47b0caf0546f7988906588779981c43bb1bc9d0c44087278f80cdb44ba"
-
 [[package]]
 name = "bevy"
 version = "0.17.2"
@@ -613,24 +599,23 @@ dependencies = [
  "bevy_macro_utils",
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
 name = "bevy_burn"
-version = "0.4.1"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ff62e1c3105d1ce251eca77f6db3e4d9718f174444507e6205c9bd5fbd95363"
+checksum = "64914097c9eb2cda89bc7a8f4b4d31789c48c0ed09e01fd42e252d89a998861d"
 dependencies = [
  "bevy",
  "burn",
  "burn-core",
  "burn-cubecl",
- "burn-fusion",
+ "burn-cubecl-fusion",
  "burn-wgpu",
  "bytemuck",
  "console_error_panic_hook",
- "cubecl",
  "getrandom 0.3.4",
  "wasm-bindgen",
  "web-sys",
@@ -645,6 +630,8 @@ dependencies = [
  "bevy_args",
  "bevy_burn",
  "burn",
+ "burn-cubecl-fusion",
+ "burn-wgpu",
  "burn_depth",
  "clap",
  "console_error_panic_hook",
@@ -739,7 +726,7 @@ checksum = "b8c733807158f8fcac68e23222e69ed91a6492ae9410fc2c145b9bb182cfd63e"
 dependencies = [
  "bevy_macro_utils",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -796,7 +783,7 @@ dependencies = [
  "bevy_macro_utils",
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -846,7 +833,7 @@ checksum = "714273aa7f285c0aaa874b7fbe37fe4e6e45355e3e6f3321aefa1b78cda259e0"
 dependencies = [
  "bevy_macro_utils",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -1005,8 +992,8 @@ dependencies = [
  "parking_lot",
  "proc-macro2",
  "quote",
- "syn 2.0.109",
- "toml_edit 0.23.7",
+ "syn 2.0.110",
+ "toml_edit",
 ]
 
 [[package]]
@@ -1021,7 +1008,7 @@ dependencies = [
  "glam",
  "itertools 0.14.0",
  "libm",
- "rand 0.9.2",
+ "rand",
  "rand_distr",
  "serde",
  "smallvec",
@@ -1182,7 +1169,7 @@ dependencies = [
  "indexmap",
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
  "uuid",
 ]
 
@@ -1244,7 +1231,7 @@ dependencies = [
  "bevy_macro_utils",
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -1344,7 +1331,7 @@ checksum = "5c3e4e32b1b96585740a2b447661af7db1b9d688db5e4d96da50461cd8f5ce63"
 dependencies = [
  "bevy_macro_utils",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -1572,7 +1559,7 @@ dependencies = [
  "regex",
  "rustc-hash 1.1.0",
  "shlex",
- "syn 2.0.109",
+ "syn 2.0.110",
  "which",
 ]
 
@@ -1593,7 +1580,7 @@ dependencies = [
  "regex",
  "rustc-hash 2.1.1",
  "shlex",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -1635,9 +1622,12 @@ dependencies = [
 
 [[package]]
 name = "bitstream-io"
-version = "2.6.0"
+version = "4.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6099cdc01846bc367c4e7dd630dc5966dccf36b652fae7a74e17b640411a91b2"
+checksum = "60d4bd9d1db2c6bdf285e223a7fa369d5ce98ec767dec949c6ca62863ce61757"
+dependencies = [
+ "core2",
+]
 
 [[package]]
 name = "blake3"
@@ -1649,7 +1639,7 @@ dependencies = [
  "arrayvec",
  "cc",
  "cfg-if 1.0.4",
- "constant_time_eq 0.3.1",
+ "constant_time_eq",
 ]
 
 [[package]]
@@ -1711,9 +1701,9 @@ dependencies = [
 
 [[package]]
 name = "built"
-version = "0.7.7"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56ed6191a7e78c36abdb16ab65341eefd73d64d303fffccdbb00d51e4205967b"
+checksum = "f4ad8f11f288f48ca24471bbd51ac257aaeaaa07adae295591266b792902ae64"
 
 [[package]]
 name = "bumpalo"
@@ -1729,7 +1719,6 @@ checksum = "0291ea5c68786545e239a02f63331cfe39da7485164ae05197d5be6f148d0557"
 dependencies = [
  "burn-autodiff",
  "burn-candle",
- "burn-collective",
  "burn-core",
  "burn-cpu",
  "burn-cuda",
@@ -1737,12 +1726,9 @@ dependencies = [
  "burn-ndarray",
  "burn-nn",
  "burn-optim",
- "burn-remote",
  "burn-rocm",
  "burn-router",
  "burn-store",
- "burn-tch",
- "burn-train",
  "burn-wgpu",
 ]
 
@@ -1775,24 +1761,6 @@ dependencies = [
  "half",
 ]
 
-[[package]]
-name = "burn-collective"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78abb99dcf39d0eeca7caf4606afba32924036ed7c387342a0bb855e936ba93c"
-dependencies = [
- "burn-common",
- "burn-communication",
- "burn-tensor",
- "bytes",
- "futures",
- "log",
- "rmp-serde",
- "serde",
- "tokio",
- "tokio-util",
-]
-
 [[package]]
 name = "burn-common"
 version = "0.19.1"
@@ -1804,30 +1772,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "burn-communication"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "675c33a2bd0b3861dc672d5f1c9b8469ce1fbb8cbd191b247767fdd2a76f08bf"
-dependencies = [
- "axum",
- "burn-common",
- "burn-tensor",
- "bytes",
- "derive-new",
- "futures",
- "futures-util",
- "log",
- "rmp-serde",
- "serde",
- "serde_bytes",
- "tokio",
- "tokio-tungstenite",
- "tokio-util",
- "tracing-core",
- "tracing-subscriber",
-]
-
 [[package]]
 name = "burn-core"
 version = "0.19.1"
@@ -1849,7 +1793,7 @@ dependencies = [
  "num-traits",
  "portable-atomic",
  "portable-atomic-util",
- "rand 0.9.2",
+ "rand",
  "regex",
  "rmp-serde",
  "serde",
@@ -1895,7 +1839,7 @@ dependencies = [
  "hashbrown 0.15.5",
  "log",
  "num-traits",
- "rand 0.9.2",
+ "rand",
  "serde",
  "spin 0.10.0",
  "text_placeholder",
@@ -1947,14 +1891,14 @@ dependencies = [
  "image",
  "r2d2",
  "r2d2_sqlite",
- "rand 0.9.2",
+ "rand",
  "rmp-serde",
  "rusqlite",
  "sanitize-filename",
  "serde",
  "serde_json",
  "serde_rusqlite",
- "strum 0.27.2",
+ "strum",
  "tempfile",
  "thiserror 2.0.17",
 ]
@@ -1968,7 +1912,7 @@ dependencies = [
  "derive-new",
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -2008,7 +1952,7 @@ dependencies = [
  "rust-format",
  "serde",
  "serde_json",
- "syn 2.0.109",
+ "syn 2.0.110",
  "thiserror 2.0.17",
  "tracing-core",
  "tracing-subscriber",
@@ -2038,10 +1982,8 @@ dependencies = [
  "burn-common",
  "burn-ir",
  "burn-tensor",
- "bytemuck",
  "const-random",
  "derive-new",
- "itertools 0.14.0",
  "libm",
  "macerator",
  "matrixmultiply",
@@ -2049,8 +1991,7 @@ dependencies = [
  "num-traits",
  "paste",
  "portable-atomic-util",
- "rand 0.9.2",
- "seq-macro",
+ "rand",
  "spin 0.10.0",
 ]
 
@@ -2078,33 +2019,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "burn-remote"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcb8e7c0d5466776f884b951ba94eac61ea0c340e7ed2b547a790e303f360c0c"
-dependencies = [
- "async-channel",
- "axum",
- "burn-common",
- "burn-communication",
- "burn-ir",
- "burn-router",
- "burn-tensor",
- "bytes",
- "derive-new",
- "futures-util",
- "log",
- "rmp-serde",
- "serde",
- "serde_bytes",
- "tokio",
- "tokio-tungstenite",
- "tokio-util",
- "tracing-core",
- "tracing-subscriber",
-]
-
 [[package]]
 name = "burn-rocm"
 version = "0.19.1"
@@ -2155,22 +2069,6 @@ dependencies = [
  "zip 6.0.0",
 ]
 
-[[package]]
-name = "burn-tch"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddf3bc363952fcb0d3d92daec70e04111d94beb5c48aded06ee6719d0b22f8a8"
-dependencies = [
- "burn-common",
- "burn-tensor",
- "cc",
- "half",
- "libc",
- "log",
- "tch",
- "torch-sys",
-]
-
 [[package]]
 name = "burn-tensor"
 version = "0.19.1"
@@ -2186,35 +2084,12 @@ dependencies = [
  "half",
  "hashbrown 0.15.5",
  "num-traits",
- "rand 0.9.2",
+ "rand",
  "rand_distr",
  "serde",
  "serde_bytes",
 ]
 
-[[package]]
-name = "burn-train"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0f1553197d50668823a4bafc187c62439df49b218973f0ca79e034b57ce38d6"
-dependencies = [
- "async-channel",
- "burn-core",
- "burn-ndarray",
- "burn-optim",
- "derive-new",
- "log",
- "nvml-wrapper",
- "ratatui",
- "rstest",
- "serde",
- "sysinfo 0.37.2",
- "systemstat",
- "tracing-appender",
- "tracing-core",
- "tracing-subscriber",
-]
-
 [[package]]
 name = "burn-wgpu"
 version = "0.19.1"
@@ -2229,7 +2104,7 @@ dependencies = [
 
 [[package]]
 name = "burn_depth"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "burn",
  "burn-import",
@@ -2245,6 +2120,7 @@ dependencies = [
  "safetensors 0.6.2",
  "serde",
  "serde_json",
+ "stacker",
  "wasm-bindgen",
  "web-sys",
  "wgpu",
@@ -2252,13 +2128,14 @@ dependencies = [
 
 [[package]]
 name = "burn_dino"
-version = "0.5.2"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96141bff70c0b3bb6ab51ab8e9b01fce0a61332115f361fb42212e830fa2dcd8"
+checksum = "8900f0381f8d2b9c919d4ad976049b89dc2b9db01fa7866f466810d0eff3ba38"
 dependencies = [
  "burn",
  "console_error_panic_hook",
  "safetensors 0.6.2",
+ "serde",
  "wasm-bindgen",
  "web-sys",
 ]
@@ -2280,7 +2157,7 @@ checksum = "f9abbd1bc6865053c427f7198e6af43bfdedc55ab791faed4fbd361d789575ff"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -2297,25 +2174,9 @@ checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
 
 [[package]]
 name = "bytes"
-version = "1.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
-
-[[package]]
-name = "bytesize"
-version = "1.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e93abca9e28e0a1b9877922aacb20576e05d4679ffa78c3d6dc22a26a216659"
-
-[[package]]
-name = "bzip2"
-version = "0.4.4"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdb116a6ef3f6c3698828873ad02c3014b3c85cadb88496095628e3ef1e347f8"
-dependencies = [
- "bzip2-sys",
- "libc",
-]
+checksum = "b35204fbdc0b3f4446b89fc1ac2cf84a8a68971995d0bf2e925ec7cd960f9cb3"
 
 [[package]]
 name = "bzip2"
@@ -2326,16 +2187,6 @@ dependencies = [
  "libbz2-rs-sys",
 ]
 
-[[package]]
-name = "bzip2-sys"
-version = "0.1.13+1.0.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225bff33b2141874fe80d71e07d6eec4f85c5c216453dd96388240f96e1acc14"
-dependencies = [
- "cc",
- "pkg-config",
-]
-
 [[package]]
 name = "calloop"
 version = "0.13.0"
@@ -2362,7 +2213,7 @@ dependencies = [
  "memmap2",
  "num-traits",
  "num_cpus",
- "rand 0.9.2",
+ "rand",
  "rand_distr",
  "rayon",
  "safetensors 0.4.5",
@@ -2381,32 +2232,17 @@ dependencies = [
  "unicode-normalization",
 ]
 
-[[package]]
-name = "cassowary"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df8670b8c7b9dae1793364eafadf7239c40d669904660c5960d74cfd80b46a53"
-
 [[package]]
 name = "cast"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
-[[package]]
-name = "castaway"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dec551ab6e7578819132c713a93c022a05d60159dc86e7a7050223577484c55a"
-dependencies = [
- "rustversion",
-]
-
 [[package]]
 name = "cc"
-version = "1.2.45"
+version = "1.2.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35900b6c8d709fb1d854671ae27aeaa9eec2f8b01b364e1619a40da3e6fe2afe"
+checksum = "b97463e1064cb1b1c1384ad0a0b9c8abd0988e2a91f52606c80ef14aadb63e36"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -2429,16 +2265,6 @@ dependencies = [
  "nom 7.1.3",
 ]
 
-[[package]]
-name = "cfg-expr"
-version = "0.15.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d067ad48b8650848b989a59a86c6c36a995d02d2bf778d45c3c5d57bc2718f02"
-dependencies = [
- "smallvec",
- "target-lexicon",
-]
-
 [[package]]
 name = "cfg-if"
 version = "0.1.10"
@@ -2536,7 +2362,7 @@ dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -2581,7 +2407,7 @@ checksum = "fe6d2e5af09e8c8ad56c969f2157a3d4238cebc7c55f0a517728c38f7b200f81"
 dependencies = [
  "serde",
  "termcolor",
- "unicode-width 0.2.0",
+ "unicode-width",
 ]
 
 [[package]]
@@ -2615,20 +2441,6 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "compact_str"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b79c4069c6cad78e2e0cdfcbd26275770669fb39fd308a752dc110e83b9af32"
-dependencies = [
- "castaway",
- "cfg-if 1.0.4",
- "itoa",
- "rustversion",
- "ryu",
- "static_assertions",
-]
-
 [[package]]
 name = "comrak"
 version = "0.39.1"
@@ -2704,12 +2516,6 @@ version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "87ca1caa64ef4ed453e68bb3db612e51cf1b2f5b871337f0fcab1c8f87cc3dff"
 
-[[package]]
-name = "constant_time_eq"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"
-
 [[package]]
 name = "constant_time_eq"
 version = "0.3.1"
@@ -2848,6 +2654,15 @@ dependencies = [
  "objc",
 ]
 
+[[package]]
+name = "core2"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b49ba7ef1ad6107f8824dbe97de947cbaac53c44e7f9756a1fba0d37c1eec505"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "cosmic-text"
 version = "0.14.2"
@@ -2987,41 +2802,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
-name = "crossterm"
-version = "0.28.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "829d955a0bb380ef178a640b91779e3987da38c9aea133b20614cfed8cdea9c6"
-dependencies = [
- "bitflags 2.10.0",
- "crossterm_winapi",
- "mio",
- "parking_lot",
- "rustix 0.38.44",
- "signal-hook",
- "signal-hook-mio",
- "winapi",
-]
-
-[[package]]
-name = "crossterm_winapi"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acdd7c62a3665c7f6830a51635d9ac9b23ed385797f70a83bb8bafe9c572ab2b"
-dependencies = [
- "winapi",
-]
-
-[[package]]
-name = "crunchy"
-version = "0.2.4"
+name = "crunchy"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
 
 [[package]]
 name = "crypto-common"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
 dependencies = [
  "generic-array",
  "typenum",
@@ -3103,7 +2893,7 @@ dependencies = [
  "parking_lot",
  "portable-atomic",
  "portable-atomic-util",
- "rand 0.9.2",
+ "rand",
  "sanitize-filename",
  "serde",
  "serde_bytes",
@@ -3193,7 +2983,7 @@ dependencies = [
  "half",
  "log",
  "serde",
- "sysinfo 0.36.1",
+ "sysinfo",
  "tracel-llvm",
  "tracel-llvm-bundler",
 ]
@@ -3279,7 +3069,7 @@ dependencies = [
  "prettyplease 0.2.37",
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -3291,7 +3081,7 @@ dependencies = [
  "darling 0.21.3",
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -3356,7 +3146,7 @@ dependencies = [
  "cubecl-std",
  "half",
  "num-traits",
- "rand 0.9.2",
+ "rand",
  "serde",
 ]
 
@@ -3372,7 +3162,7 @@ dependencies = [
  "half",
  "num-traits",
  "pretty_assertions",
- "rand 0.9.2",
+ "rand",
  "serde",
 ]
 
@@ -3399,7 +3189,7 @@ dependencies = [
  "serde_json",
  "spin 0.10.0",
  "thiserror 2.0.17",
- "toml 0.9.8",
+ "toml",
  "variadics_please",
  "wasm-bindgen-futures",
 ]
@@ -3445,9 +3235,9 @@ dependencies = [
 
 [[package]]
 name = "cudarc"
-version = "0.17.7"
+version = "0.17.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff0da1a70ec91e66731c1752deb9fda3044f1154fe4ceb5873e3f96ed34cafa3"
+checksum = "0bf99ab37ee7072d64d906aa2dada9a3422f1d975cdf8c8055a573bc84897ed8"
 dependencies = [
  "libloading",
 ]
@@ -3489,7 +3279,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "strsim",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -3503,7 +3293,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "strsim",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -3514,7 +3304,7 @@ checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead"
 dependencies = [
  "darling_core 0.20.11",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -3525,7 +3315,7 @@ checksum = "d38308df82d1080de0afee5d069fa14b0326a88c14f15c5ccda35b4a6c414c81"
 dependencies = [
  "darling_core 0.21.3",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -3571,7 +3361,7 @@ checksum = "2cdc8d50f426189eef89dac62fabfa0abb27d5cc008f25bf4156a0203325becc"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -3582,7 +3372,7 @@ checksum = "1e567bd82dcff979e4b03460c307b3cdc9e96fde3d73bed1496d2bc75d9dd62a"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -3602,7 +3392,7 @@ checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
  "unicode-xid",
 ]
 
@@ -3676,7 +3466,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -3838,7 +3628,7 @@ checksum = "1796db3d892515842ca2dfb11124c4bb4a9e58d9f2c5c1072e5bca1b2334507b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -3856,7 +3646,7 @@ dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -3877,7 +3667,7 @@ dependencies = [
  "darling 0.21.3",
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -3897,7 +3687,7 @@ checksum = "44f23cf4b44bfce11a86ace86f8a73ffdec849c9fd00a386a53d278bd9e81fb3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -3959,9 +3749,9 @@ dependencies = [
 
 [[package]]
 name = "exr"
-version = "1.73.0"
+version = "1.74.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f83197f59927b46c04a183a619b7c29df34e63e63c7869320862268c0ef687e0"
+checksum = "4300e043a56aa2cb633c01af81ca8f699a321879a7854d3896a0ba89056363be"
 dependencies = [
  "bit_field",
  "half",
@@ -4007,7 +3797,7 @@ checksum = "a0aca10fb742cb43f9e7bb8467c91aa9bcb8e3ffbc6a6f7389bb93ffc920577d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -4033,9 +3823,9 @@ dependencies = [
 
 [[package]]
 name = "find-msvc-tools"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52051878f80a721bb68ebfbc930e07b65ba72f2da88968ea5c06fd6ca3d3a127"
+checksum = "3a3076410a55c90011c298b04d0cfa770b00fa04e1e3c97d3f6c9de105a03844"
 
 [[package]]
 name = "fixedbitset"
@@ -4170,7 +3960,7 @@ checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -4274,7 +4064,7 @@ checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -4289,12 +4079,6 @@ version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
 
-[[package]]
-name = "futures-timer"
-version = "3.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f288b0a4f20f9a56b5d1da57e2227c661b7b16168e2f72365f57b63326e29b24"
-
 [[package]]
 name = "futures-util"
 version = "0.3.31"
@@ -4552,9 +4336,9 @@ dependencies = [
 
 [[package]]
 name = "generic-array"
-version = "0.14.9"
+version = "0.14.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
 dependencies = [
  "typenum",
  "version_check",
@@ -4599,9 +4383,9 @@ dependencies = [
 
 [[package]]
 name = "gif"
-version = "0.13.3"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ae047235e33e2829703574b54fdec96bfbad892062d97fed2f76022287de61b"
+checksum = "f954a9e9159ec994f73a30a12b96a702dde78f5547bcb561174597924f7d4162"
 dependencies = [
  "color_quant",
  "weezl",
@@ -4705,7 +4489,7 @@ checksum = "bd47b05dddf0005d850e5644cae7f2b14ac3df487979dbfff3b56f20b1a6ae46"
 dependencies = [
  "bytemuck",
  "libm",
- "rand 0.9.2",
+ "rand",
  "serde_core",
 ]
 
@@ -4832,7 +4616,7 @@ dependencies = [
  "cfg-if 1.0.4",
  "crunchy",
  "num-traits",
- "rand 0.9.2",
+ "rand",
  "rand_distr",
  "serde",
  "zerocopy",
@@ -4991,17 +4775,11 @@ version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
 
-[[package]]
-name = "httpdate"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
-
 [[package]]
 name = "hyper"
-version = "1.7.0"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb3aa54a13a0dfe7fbe3a59e0c76093041720fdc77b110cc0fc260fafb4dc51e"
+checksum = "2ab2d4f250c3d7b1c9fcdff1cece94ea4e2dfbec68614f7b87cb205f24ca9d11"
 dependencies = [
  "atomic-waker",
  "bytes",
@@ -5011,7 +4789,6 @@ dependencies = [
  "http",
  "http-body",
  "httparse",
- "httpdate",
  "itoa",
  "pin-project-lite",
  "pin-utils",
@@ -5034,14 +4811,14 @@ dependencies = [
  "tokio",
  "tokio-rustls",
  "tower-service",
- "webpki-roots 1.0.4",
+ "webpki-roots",
 ]
 
 [[package]]
 name = "hyper-util"
-version = "0.1.17"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c6995591a8f1380fcb4ba966a252a4b29188d51d2b89e3a252f5305be65aea8"
+checksum = "52e9a2a24dc5c6821e71a7030e1e14b7b632acac55c40e9d2e082c621261bb56"
 dependencies = [
  "base64",
  "bytes",
@@ -5171,9 +4948,9 @@ dependencies = [
 
 [[package]]
 name = "image"
-version = "0.25.8"
+version = "0.25.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "529feb3e6769d234375c4cf1ee2ce713682b8e76538cb13f9fc23e1400a591e7"
+checksum = "e6506c6c10786659413faa717ceebcb8f70731c0a60cbae39795fdf114519c1a"
 dependencies = [
  "bytemuck",
  "byteorder-lite",
@@ -5189,8 +4966,8 @@ dependencies = [
  "rayon",
  "rgb",
  "tiff",
- "zune-core",
- "zune-jpeg",
+ "zune-core 0.5.0",
+ "zune-jpeg 0.5.5",
 ]
 
 [[package]]
@@ -5219,15 +4996,6 @@ dependencies = [
  "hashbrown 0.16.0",
 ]
 
-[[package]]
-name = "indoc"
-version = "2.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
-dependencies = [
- "rustversion",
-]
-
 [[package]]
 name = "inout"
 version = "0.1.4"
@@ -5237,19 +5005,6 @@ dependencies = [
  "generic-array",
 ]
 
-[[package]]
-name = "instability"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "435d80800b936787d62688c927b6490e887c7ef5ff9ce922c6c6050fca75eb9a"
-dependencies = [
- "darling 0.20.11",
- "indoc",
- "proc-macro2",
- "quote",
- "syn 2.0.109",
-]
-
 [[package]]
 name = "interpolate_name"
 version = "0.2.4"
@@ -5258,7 +5013,7 @@ checksum = "c34819042dc3d3971c46c2190835914dfbe0c3c13f61449b2997f4e9722dfa60"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -5292,15 +5047,6 @@ version = "1.70.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
 
-[[package]]
-name = "itertools"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
-dependencies = [
- "either",
-]
-
 [[package]]
 name = "itertools"
 version = "0.13.0"
@@ -5549,15 +5295,6 @@ dependencies = [
  "imgref",
 ]
 
-[[package]]
-name = "lru"
-version = "0.12.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "234cf4f4a04dc1f57e24b96cc0cd600cf2af460d4161ac5ecdd0af8e1f3b2a38"
-dependencies = [
- "hashbrown 0.15.5",
-]
-
 [[package]]
 name = "lru-slab"
 version = "0.1.2"
@@ -5599,7 +5336,7 @@ dependencies = [
  "darling 0.20.11",
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -5620,12 +5357,6 @@ dependencies = [
  "regex-automata",
 ]
 
-[[package]]
-name = "matchit"
-version = "0.8.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3"
-
 [[package]]
 name = "matrixmultiply"
 version = "0.3.10"
@@ -5633,10 +5364,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a06de3016e9fae57a36fd14dba131fccf49f74b40b7fbdb472f96e361ec71a08"
 dependencies = [
  "autocfg",
- "num_cpus",
- "once_cell",
  "rawpointer",
- "thread-tree",
 ]
 
 [[package]]
@@ -5701,12 +5429,6 @@ dependencies = [
  "paste",
 ]
 
-[[package]]
-name = "mime"
-version = "0.3.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
-
 [[package]]
 name = "minimal-lexical"
 version = "0.2.1"
@@ -5730,7 +5452,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "69d83b0086dc8ecf3ce9ae2874b2d1290252e2a30720bea58a5c6639b0092873"
 dependencies = [
  "libc",
- "log",
  "wasi",
  "windows-sys 0.61.2",
 ]
@@ -5867,7 +5588,6 @@ dependencies = [
  "portable-atomic",
  "portable-atomic-util",
  "rawpointer",
- "rayon",
 ]
 
 [[package]]
@@ -6088,7 +5808,7 @@ checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -6161,39 +5881,7 @@ dependencies = [
  "proc-macro-crate",
  "proc-macro2",
  "quote",
- "syn 2.0.109",
-]
-
-[[package]]
-name = "num_threads"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c7398b9c8b70908f6371f47ed36737907c87c52af34c268fed0bf0ceb92ead9"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "nvml-wrapper"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d5c6c0ef9702176a570f06ad94f3198bc29c524c8b498f1b9346e1b1bdcbb3a"
-dependencies = [
- "bitflags 2.10.0",
- "libloading",
- "nvml-wrapper-sys",
- "static_assertions",
- "thiserror 1.0.69",
- "wrapcenum-derive",
-]
-
-[[package]]
-name = "nvml-wrapper-sys"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd23dbe2eb8d8335d2bce0299e0a07d6a63c089243d626ca75b770a962ff49e6"
-dependencies = [
- "libloading",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -6446,6 +6134,15 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "object"
+version = "0.32.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "offset-allocator"
 version = "0.2.0"
@@ -6482,7 +6179,7 @@ dependencies = [
  "protobuf-codegen",
  "regex",
  "serde",
- "strum 0.27.2",
+ "strum",
 ]
 
 [[package]]
@@ -6544,17 +6241,6 @@ dependencies = [
  "windows-link 0.2.1",
 ]
 
-[[package]]
-name = "password-hash"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7676374caaee8a325c9e7a2ae557f216c5563a171d6997b0ef8a65af35147700"
-dependencies = [
- "base64ct",
- "rand_core 0.6.4",
- "subtle",
-]
-
 [[package]]
 name = "paste"
 version = "1.0.15"
@@ -6562,16 +6248,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
 [[package]]
-name = "pbkdf2"
-version = "0.11.0"
+name = "pastey"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83a0692ec44e4cf1ef28ca317f14f8f07da2d95ec3fa01f86e4467b725e60917"
-dependencies = [
- "digest",
- "hmac",
- "password-hash",
- "sha2",
-]
+checksum = "35fb2e5f958ec131621fdd531e9fc186ed768cbe395337403ae56c17a74c68ec"
 
 [[package]]
 name = "pbkdf2"
@@ -6622,7 +6302,7 @@ checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -6805,7 +6485,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
 dependencies = [
  "proc-macro2",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -6814,7 +6494,7 @@ version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "219cb19e96be00ab2e37d6e299658a0cfa83e52429179969b0f0121b4ac46983"
 dependencies = [
- "toml_edit 0.23.7",
+ "toml_edit",
 ]
 
 [[package]]
@@ -6842,7 +6522,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "52717f9a02b6965224f95ca2a81e2e0c5c43baacd28ca057577988930b6c3d5b"
 dependencies = [
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -6897,6 +6577,16 @@ dependencies = [
  "thiserror 1.0.69",
 ]
 
+[[package]]
+name = "psm"
+version = "0.1.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d11f2fedc3b7dafdc2851bc52f277377c5473d378859be234bc7ebb593144d01"
+dependencies = [
+ "ar_archive_writer",
+ "cc",
+]
+
 [[package]]
 name = "pulp"
 version = "0.18.22"
@@ -6976,7 +6666,7 @@ dependencies = [
  "bytes",
  "getrandom 0.3.4",
  "lru-slab",
- "rand 0.9.2",
+ "rand",
  "ring",
  "rustc-hash 2.1.1",
  "rustls",
@@ -7045,35 +6735,14 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "019b4b213425016d7d84a153c4c73afb0946fbb4840e4eece7ba8848b9d6da22"
 
-[[package]]
-name = "rand"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
-dependencies = [
- "libc",
- "rand_chacha 0.3.1",
- "rand_core 0.6.4",
-]
-
 [[package]]
 name = "rand"
 version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
 dependencies = [
- "rand_chacha 0.9.0",
- "rand_core 0.9.3",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
-dependencies = [
- "ppv-lite86",
- "rand_core 0.6.4",
+ "rand_chacha",
+ "rand_core",
 ]
 
 [[package]]
@@ -7083,16 +6752,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
 dependencies = [
  "ppv-lite86",
- "rand_core 0.9.3",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
-dependencies = [
- "getrandom 0.2.16",
+ "rand_core",
 ]
 
 [[package]]
@@ -7111,7 +6771,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a8615d50dcf34fa31f7ab52692afec947c4dd0ab803cc87cb3b0b4570ff7463"
 dependencies = [
  "num-traits",
- "rand 0.9.2",
+ "rand",
 ]
 
 [[package]]
@@ -7122,47 +6782,27 @@ checksum = "c3d6831663a5098ea164f89cff59c6284e95f4e3c76ce9848d4529f5ccca9bde"
 
 [[package]]
 name = "rangemap"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f93e7e49bb0bf967717f7bd674458b3d6b0c5f48ec7e3038166026a69fc22223"
-
-[[package]]
-name = "ratatui"
-version = "0.29.0"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eabd94c2f37801c20583fc49dd5cd6b0ba68c716787c2dd6ed18571e1e63117b"
-dependencies = [
- "bitflags 2.10.0",
- "cassowary",
- "compact_str",
- "crossterm",
- "indoc",
- "instability",
- "itertools 0.13.0",
- "lru",
- "paste",
- "strum 0.26.3",
- "time",
- "unicode-segmentation",
- "unicode-truncate",
- "unicode-width 0.2.0",
-]
+checksum = "acbbbbea733ec66275512d0b9694f34102e7d5406fdbe2ad8d21b28dce92887c"
 
 [[package]]
 name = "rav1e"
-version = "0.7.1"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd87ce80a7665b1cce111f8a16c1f3929f6547ce91ade6addf4ec86a8dda5ce9"
+checksum = "43b6dd56e85d9483277cde964fd1bdb0428de4fec5ebba7540995639a21cb32b"
 dependencies = [
+ "aligned-vec",
  "arbitrary",
  "arg_enum_proc_macro",
  "arrayvec",
+ "av-scenechange",
  "av1-grain",
  "bitstream-io",
  "built",
  "cfg-if 1.0.4",
  "interpolate_name",
- "itertools 0.12.1",
+ "itertools 0.14.0",
  "libc",
  "libfuzzer-sys",
  "log",
@@ -7171,23 +6811,21 @@ dependencies = [
  "noop_proc_macro",
  "num-derive",
  "num-traits",
- "once_cell",
  "paste",
  "profiling",
- "rand 0.8.5",
- "rand_chacha 0.3.1",
+ "rand",
+ "rand_chacha",
  "simd_helpers",
- "system-deps",
- "thiserror 1.0.69",
+ "thiserror 2.0.17",
  "v_frame",
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "ravif"
-version = "0.11.20"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5825c26fddd16ab9f515930d49028a630efec172e903483c94796cfe31893e6b"
+checksum = "ef69c1990ceef18a116855938e74793a5f7496ee907562bd0857b6ac734ab285"
 dependencies = [
  "avif-serialize",
  "imgref",
@@ -7328,12 +6966,6 @@ version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
 
-[[package]]
-name = "relative-path"
-version = "1.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba39f3699c378cd8970968dcbff9c43159ea4cfbd88d43c00b22f2ef10a435d2"
-
 [[package]]
 name = "renderdoc-sys"
 version = "1.1.0"
@@ -7378,7 +7010,7 @@ dependencies = [
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "web-sys",
- "webpki-roots 1.0.4",
+ "webpki-roots",
 ]
 
 [[package]]
@@ -7445,35 +7077,6 @@ version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6c20b6793b5c2fa6553b250154b78d6d0db37e72700ae35fad9387a46f487c97"
 
-[[package]]
-name = "rstest"
-version = "0.26.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5a3193c063baaa2a95a33f03035c8a72b83d97a54916055ba22d35ed3839d49"
-dependencies = [
- "futures-timer",
- "futures-util",
- "rstest_macros",
-]
-
-[[package]]
-name = "rstest_macros"
-version = "0.26.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c845311f0ff7951c5506121a9ad75aec44d083c31583b2ea5a30bcb0b0abba0"
-dependencies = [
- "cfg-if 1.0.4",
- "glob",
- "proc-macro-crate",
- "proc-macro2",
- "quote",
- "regex",
- "relative-path",
- "rustc_version",
- "syn 2.0.109",
- "unicode-ident",
-]
-
 [[package]]
 name = "rusqlite"
 version = "0.37.0"
@@ -7552,7 +7155,6 @@ version = "0.23.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "533f54bc6a7d4f647e46ad909549eda97bf5afc1585190ef692b4286b198bd8f"
 dependencies = [
- "log",
  "once_cell",
  "ring",
  "rustls-pki-types",
@@ -7620,16 +7222,6 @@ version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
 
-[[package]]
-name = "safetensors"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d93279b86b3de76f820a8854dd06cbc33cfa57a417b19c47f6a25280112fb1df"
-dependencies = [
- "serde",
- "serde_json",
-]
-
 [[package]]
 name = "safetensors"
 version = "0.4.5"
@@ -7744,7 +7336,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -7760,17 +7352,6 @@ dependencies = [
  "serde_core",
 ]
 
-[[package]]
-name = "serde_path_to_error"
-version = "0.1.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10a9ff822e371bb5403e391ecd83e182e0e77ba7f6fe0160b795797109d1b457"
-dependencies = [
- "itoa",
- "serde",
- "serde_core",
-]
-
 [[package]]
 name = "serde_rusqlite"
 version = "0.40.1"
@@ -7781,15 +7362,6 @@ dependencies = [
  "serde_core",
 ]
 
-[[package]]
-name = "serde_spanned"
-version = "0.6.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
-dependencies = [
- "serde",
-]
-
 [[package]]
 name = "serde_spanned"
 version = "1.0.3"
@@ -7858,17 +7430,6 @@ dependencies = [
  "signal-hook-registry",
 ]
 
-[[package]]
-name = "signal-hook-mio"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b75a19a7a740b25bc7944bdee6172368f988763b744e3d4dfe753f6b4ece40cc"
-dependencies = [
- "libc",
- "mio",
- "signal-hook",
-]
-
 [[package]]
 name = "signal-hook-registry"
 version = "1.4.6"
@@ -7996,6 +7557,19 @@ version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 
+[[package]]
+name = "stacker"
+version = "0.1.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1f8b29fb42aafcea4edeeb6b2f2d7ecd0d969c48b4cf0d2e64aafc471dd6e59"
+dependencies = [
+ "cc",
+ "cfg-if 1.0.4",
+ "libc",
+ "psm",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "stackfuture"
 version = "0.3.0"
@@ -8014,35 +7588,13 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
-[[package]]
-name = "strum"
-version = "0.26.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06"
-dependencies = [
- "strum_macros 0.26.4",
-]
-
 [[package]]
 name = "strum"
 version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
 dependencies = [
- "strum_macros 0.27.2",
-]
-
-[[package]]
-name = "strum_macros"
-version = "0.26.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "rustversion",
- "syn 2.0.109",
+ "strum_macros",
 ]
 
 [[package]]
@@ -8054,7 +7606,7 @@ dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -8092,9 +7644,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.109"
+version = "2.0.110"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f17c7e013e88258aa9543dcbe81aca68a667a9ac37cd69c9fbc07858bfe0e2f"
+checksum = "a99801b5bd34ede4cf3fc688c5919368fea4e4814a4664359503e6015b280aea"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -8118,7 +7670,7 @@ checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -8172,47 +7724,6 @@ dependencies = [
  "windows 0.61.3",
 ]
 
-[[package]]
-name = "sysinfo"
-version = "0.37.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16607d5caffd1c07ce073528f9ed972d88db15dd44023fa57142963be3feb11f"
-dependencies = [
- "libc",
- "memchr",
- "ntapi",
- "objc2-core-foundation",
- "objc2-io-kit",
- "windows 0.61.3",
-]
-
-[[package]]
-name = "system-deps"
-version = "6.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3e535eb8dded36d55ec13eddacd30dec501792ff23a0b1682c38601b8cf2349"
-dependencies = [
- "cfg-expr",
- "heck",
- "pkg-config",
- "toml 0.8.23",
- "version-compare",
-]
-
-[[package]]
-name = "systemstat"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5021f5184d44b26fb184acd689671bbe1e4bbd24bbdaa6bc7ec383fad32d2033"
-dependencies = [
- "bytesize",
- "lazy_static",
- "libc",
- "nom 7.1.3",
- "time",
- "winapi",
-]
-
 [[package]]
 name = "taffy"
 version = "0.7.7"
@@ -8236,29 +7747,6 @@ dependencies = [
  "xattr",
 ]
 
-[[package]]
-name = "target-lexicon"
-version = "0.12.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
-
-[[package]]
-name = "tch"
-version = "0.22.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e09b91610202dc4820c21eb474a42b386ef69f323b1c0902b5472ba7456ebb5"
-dependencies = [
- "half",
- "lazy_static",
- "libc",
- "ndarray",
- "rand 0.8.5",
- "safetensors 0.3.3",
- "thiserror 1.0.69",
- "torch-sys",
- "zip 0.6.6",
-]
-
 [[package]]
 name = "tempfile"
 version = "3.23.0"
@@ -8318,7 +7806,7 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -8329,16 +7817,7 @@ checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
-]
-
-[[package]]
-name = "thread-tree"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffbd370cb847953a25954d9f63e14824a36113f8c72eecf6eccef5dc4b45d630"
-dependencies = [
- "crossbeam-channel",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -8361,7 +7840,7 @@ dependencies = [
  "half",
  "quick-error",
  "weezl",
- "zune-jpeg",
+ "zune-jpeg 0.4.21",
 ]
 
 [[package]]
@@ -8371,14 +7850,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "91e7d9e3bb61134e77bde20dd4825b97c010155709965fedf0f49bb138e52a9d"
 dependencies = [
  "deranged",
- "itoa",
- "libc",
  "num-conv",
- "num_threads",
  "powerfmt",
  "serde",
  "time-core",
- "time-macros",
 ]
 
 [[package]]
@@ -8387,16 +7862,6 @@ version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b"
 
-[[package]]
-name = "time-macros"
-version = "0.2.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30cfb0125f12d9c277f35663a0a33f8c30190f4e4574868a330595412d34ebf3"
-dependencies = [
- "num-conv",
- "time-core",
-]
-
 [[package]]
 name = "tiny-keccak"
 version = "2.0.2"
@@ -8451,23 +7916,10 @@ dependencies = [
  "libc",
  "mio",
  "pin-project-lite",
- "signal-hook-registry",
  "socket2",
- "tokio-macros",
  "windows-sys 0.61.2",
 ]
 
-[[package]]
-name = "tokio-macros"
-version = "2.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.109",
-]
-
 [[package]]
 name = "tokio-rustls"
 version = "0.26.4"
@@ -8478,18 +7930,6 @@ dependencies = [
  "tokio",
 ]
 
-[[package]]
-name = "tokio-tungstenite"
-version = "0.28.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d25a406cddcc431a75d3d9afc6a7c0f7428d4891dd973e4d54c56b46127bf857"
-dependencies = [
- "futures-util",
- "log",
- "tokio",
- "tungstenite",
-]
-
 [[package]]
 name = "tokio-util"
 version = "0.7.17"
@@ -8503,18 +7943,6 @@ dependencies = [
  "tokio",
 ]
 
-[[package]]
-name = "toml"
-version = "0.8.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
-dependencies = [
- "serde",
- "serde_spanned 0.6.9",
- "toml_datetime 0.6.11",
- "toml_edit 0.22.27",
-]
-
 [[package]]
 name = "toml"
 version = "0.9.8"
@@ -8523,22 +7951,13 @@ checksum = "f0dc8b1fb61449e27716ec0e1bdf0f6b8f3e8f6b05391e8497b8b6d7804ea6d8"
 dependencies = [
  "indexmap",
  "serde_core",
- "serde_spanned 1.0.3",
- "toml_datetime 0.7.3",
+ "serde_spanned",
+ "toml_datetime",
  "toml_parser",
  "toml_writer",
  "winnow",
 ]
 
-[[package]]
-name = "toml_datetime"
-version = "0.6.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c"
-dependencies = [
- "serde",
-]
-
 [[package]]
 name = "toml_datetime"
 version = "0.7.3"
@@ -8548,19 +7967,6 @@ dependencies = [
  "serde_core",
 ]
 
-[[package]]
-name = "toml_edit"
-version = "0.22.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
-dependencies = [
- "indexmap",
- "serde",
- "serde_spanned 0.6.9",
- "toml_datetime 0.6.11",
- "winnow",
-]
-
 [[package]]
 name = "toml_edit"
 version = "0.23.7"
@@ -8568,7 +7974,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6485ef6d0d9b5d0ec17244ff7eb05310113c3f316f2d14200d4de56b3cb98f8d"
 dependencies = [
  "indexmap",
- "toml_datetime 0.7.3",
+ "toml_datetime",
  "toml_parser",
  "winnow",
 ]
@@ -8588,21 +7994,6 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df8b2b54733674ad286d16267dcfc7a71ed5c776e4ac7aa3c3e2561f7c637bf2"
 
-[[package]]
-name = "torch-sys"
-version = "0.22.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aef40c585e342df95b66a1fa7c923188623999c2b657227befb481dfb03a6a42"
-dependencies = [
- "anyhow",
- "cc",
- "libc",
- "serde",
- "serde_json",
- "ureq",
- "zip 0.6.6",
-]
-
 [[package]]
 name = "tower"
 version = "0.5.2"
@@ -8616,7 +8007,6 @@ dependencies = [
  "tokio",
  "tower-layer",
  "tower-service",
- "tracing",
 ]
 
 [[package]]
@@ -8699,7 +8089,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "regex",
- "syn 2.0.109",
+ "syn 2.0.110",
  "tracel-llvm-bundler",
  "tracel-tblgen-rs",
  "unindent",
@@ -8734,24 +8124,11 @@ version = "0.1.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
 dependencies = [
- "log",
  "pin-project-lite",
  "tracing-attributes",
  "tracing-core",
 ]
 
-[[package]]
-name = "tracing-appender"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3566e8ce28cc0a3fe42519fc80e6b4c943cc4c8cef275620eb8dac2d3d4e06cf"
-dependencies = [
- "crossbeam-channel",
- "thiserror 1.0.69",
- "time",
- "tracing-subscriber",
-]
-
 [[package]]
 name = "tracing-attributes"
 version = "0.1.30"
@@ -8760,7 +8137,7 @@ checksum = "81383ab64e72a7a8b8e13130c49e3dab29def6d0c7d76a03087b3cf71c5c6903"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -8843,23 +8220,6 @@ version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2c591d83f69777866b9126b24c6dd9a18351f177e49d625920d19f989fd31cf8"
 
-[[package]]
-name = "tungstenite"
-version = "0.28.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8628dcc84e5a09eb3d8423d6cb682965dea9133204e8fb3efee74c2a0c259442"
-dependencies = [
- "bytes",
- "data-encoding",
- "http",
- "httparse",
- "log",
- "rand 0.9.2",
- "sha1",
- "thiserror 2.0.17",
- "utf-8",
-]
-
 [[package]]
 name = "twox-hash"
 version = "2.1.2"
@@ -8977,28 +8337,11 @@ version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
 
-[[package]]
-name = "unicode-truncate"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3644627a5af5fa321c95b9b235a72fd24cd29c648c2c379431e6628655627bf"
-dependencies = [
- "itertools 0.13.0",
- "unicode-segmentation",
- "unicode-width 0.1.14",
-]
-
 [[package]]
 name = "unicode-width"
-version = "0.1.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
-
-[[package]]
-name = "unicode-width"
-version = "0.2.0"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"
+checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
 
 [[package]]
 name = "unicode-xid"
@@ -9030,24 +8373,6 @@ version = "0.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae"
 
-[[package]]
-name = "ureq"
-version = "2.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02d1a66277ed75f640d608235660df48c8e3c19f3b4edb6a263315626cc3c01d"
-dependencies = [
- "base64",
- "flate2",
- "log",
- "once_cell",
- "rustls",
- "rustls-pki-types",
- "serde",
- "serde_json",
- "url",
- "webpki-roots 0.26.11",
-]
-
 [[package]]
 name = "url"
 version = "2.5.7"
@@ -9060,12 +8385,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "utf-8"
-version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
-
 [[package]]
 name = "utf8_iter"
 version = "1.0.4"
@@ -9086,7 +8405,7 @@ checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2"
 dependencies = [
  "getrandom 0.3.4",
  "js-sys",
- "rand 0.9.2",
+ "rand",
  "serde",
  "wasm-bindgen",
 ]
@@ -9136,7 +8455,7 @@ checksum = "41b6d82be61465f97d42bd1d15bf20f3b0a3a0905018f38f9d6f6962055b0b5c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -9145,12 +8464,6 @@ version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
 
-[[package]]
-name = "version-compare"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03c2856837ef78f57382f06b2b8563a2f512f7185d732608fd9176cb3b8edf0e"
-
 [[package]]
 name = "version_check"
 version = "0.9.5"
@@ -9242,7 +8555,7 @@ dependencies = [
  "bumpalo",
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
  "wasm-bindgen-shared",
 ]
 
@@ -9275,15 +8588,6 @@ dependencies = [
  "wasm-bindgen",
 ]
 
-[[package]]
-name = "webpki-roots"
-version = "0.26.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
-dependencies = [
- "webpki-roots 1.0.4",
-]
-
 [[package]]
 name = "webpki-roots"
 version = "1.0.4"
@@ -9295,9 +8599,9 @@ dependencies = [
 
 [[package]]
 name = "weezl"
-version = "0.1.10"
+version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a751b3277700db47d3e574514de2eced5e54dc8a5436a3bf7a0b248b2cee16f3"
+checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"
 
 [[package]]
 name = "wgpu"
@@ -9614,7 +8918,7 @@ checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -9625,7 +8929,7 @@ checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -9636,7 +8940,7 @@ checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -9647,7 +8951,7 @@ checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -10045,18 +9349,6 @@ version = "0.46.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
 
-[[package]]
-name = "wrapcenum-derive"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a76ff259533532054cfbaefb115c613203c73707017459206380f03b3b3f266e"
-dependencies = [
- "darling 0.20.11",
- "proc-macro2",
- "quote",
- "syn 2.0.109",
-]
-
 [[package]]
 name = "writeable"
 version = "0.6.2"
@@ -10130,6 +9422,12 @@ version = "0.8.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3ae8337f8a065cfc972643663ea4279e04e7256de865aa66fe25cec5fb912d3f"
 
+[[package]]
+name = "y4m"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a5a4b21e1a62b67a2970e6831bc091d7b87e119e7f9791aef9702e3bef04448"
+
 [[package]]
 name = "yansi"
 version = "1.0.1"
@@ -10173,7 +9471,7 @@ checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
  "synstructure",
 ]
 
@@ -10185,7 +9483,7 @@ checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
  "synstructure",
 ]
 
@@ -10212,7 +9510,7 @@ checksum = "88d2b8d9c68ad2b9e4340d7832716a4d21a22a1154777ad56ea55c51a9cf3831"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -10232,7 +9530,7 @@ checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
  "synstructure",
 ]
 
@@ -10253,7 +9551,7 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -10286,27 +9584,7 @@ checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.109",
-]
-
-[[package]]
-name = "zip"
-version = "0.6.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "760394e246e4c28189f19d488c058bf16f564016aefac5d32bb1f3b51d5e9261"
-dependencies = [
- "aes",
- "byteorder",
- "bzip2 0.4.4",
- "constant_time_eq 0.1.5",
- "crc32fast",
- "crossbeam-utils",
- "flate2",
- "hmac",
- "pbkdf2 0.11.0",
- "sha1",
- "time",
- "zstd 0.11.2+zstd.1.5.2",
+ "syn 2.0.110",
 ]
 
 [[package]]
@@ -10332,8 +9610,8 @@ checksum = "eb2a05c7c36fde6c09b08576c9f7fb4cda705990f73b58fe011abf7dfb24168b"
 dependencies = [
  "aes",
  "arbitrary",
- "bzip2 0.6.1",
- "constant_time_eq 0.3.1",
+ "bzip2",
+ "constant_time_eq",
  "crc32fast",
  "deflate64",
  "flate2",
@@ -10342,13 +9620,13 @@ dependencies = [
  "indexmap",
  "lzma-rust2",
  "memchr",
- "pbkdf2 0.12.2",
+ "pbkdf2",
  "ppmd-rust",
  "sha1",
  "time",
  "zeroize",
  "zopfli",
- "zstd 0.13.3",
+ "zstd",
 ]
 
 [[package]]
@@ -10369,32 +9647,13 @@ dependencies = [
  "simd-adler32",
 ]
 
-[[package]]
-name = "zstd"
-version = "0.11.2+zstd.1.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20cc960326ece64f010d2d2107537f26dc589a6573a316bd5b1dba685fa5fde4"
-dependencies = [
- "zstd-safe 5.0.2+zstd.1.5.2",
-]
-
 [[package]]
 name = "zstd"
 version = "0.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
 dependencies = [
- "zstd-safe 7.2.4",
-]
-
-[[package]]
-name = "zstd-safe"
-version = "5.0.2+zstd.1.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d2a5585e04f9eea4b2a3d1eca508c4dee9592a89ef6f450c11719da0726f4db"
-dependencies = [
- "libc",
- "zstd-sys",
+ "zstd-safe",
 ]
 
 [[package]]
@@ -10422,6 +9681,12 @@ version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f423a2c17029964870cfaabb1f13dfab7d092a62a29a89264f4d36990ca414a"
 
+[[package]]
+name = "zune-core"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "111f7d9820f05fd715df3144e254d6fc02ee4088b0644c0ffd0efc9e6d9d2773"
+
 [[package]]
 name = "zune-inflate"
 version = "0.2.54"
@@ -10437,7 +9702,16 @@ version = "0.4.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "29ce2c8a9384ad323cf564b67da86e21d3cfdff87908bc1223ed5c99bc792713"
 dependencies = [
- "zune-core",
+ "zune-core 0.4.12",
+]
+
+[[package]]
+name = "zune-jpeg"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc6fb7703e32e9a07fb3f757360338b3a567a5054f21b5f52a666752e333d58e"
+dependencies = [
+ "zune-core 0.5.0",
 ]
 
 [[patch.unused]]
diff --git a/Cargo.toml b/Cargo.toml
index c7591fb..f5baef3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "burn_depth"
 description = "burn depth pro model inference"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2024"
 authors = ["mosure <mitchell@mosure.me>"]
 license = "MIT OR Apache-2.0"
@@ -62,8 +62,8 @@ backend_wgpu = ["burn/wgpu", "burn_dino/backend_wgpu", "half"]
 
 
 [dependencies]
-burn = "0.19"
-burn_dino = { version = "0.5.2", default-features = false }
+burn_dino = { version = "0.6", default-features = false }
+image = { version = "0.25", default-features = false, features = ["png", "jpeg"] }
 
 half = { version = "2", optional = true }
 
@@ -75,6 +75,14 @@ serde_json = { version = "1.0", optional = true }
 safetensors = { version = "0.6", optional = true }
 
 
+[dependencies.burn]
+version = "0.19"
+default-features = false
+features = [
+  "std",
+]
+
+
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 console_error_panic_hook = "0.1"
 wasm-bindgen = "0.2"
@@ -91,14 +99,17 @@ features = [
   'Window',
 ]
 
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+stacker = "0.1"
+
 
 [dev-dependencies]
 criterion = { version = "0.7", features = ["html_reports"] }
 futures-intrusive = { version = "0.5.0" }
-image = { version = "0.25", default-features = false, features = ["png", "jpeg"] }
 pollster = { version = "0.4.0" }
 safetensors = "0.6"
 wgpu = "26.0"
+clap = { version = "4.5", features = ["derive"] }
 
 
 [patch.crates-io]
@@ -139,6 +150,16 @@ path = "example/inference.rs"
 name = "correctness"
 path = "example/correctness.rs"
 
+[[example]]
+name = "da3_small_correctness"
+path = "example/da3_small_correctness.rs"
+required-features = ["backend_ndarray"]
+
+[[example]]
+name = "da3_wgpu_loader"
+path = "example/da3_wgpu_loader.rs"
+required-features = ["backend_wgpu"]
+
 
 [[bench]]
 name = "inference_benchmark"
@@ -153,6 +174,11 @@ harness = false
 
 
 [[bin]]
-name = "import"
-path = "tool/import.rs"
+name = "import_depth_pro"
+path = "tool/import_depth_pro.rs"
+required-features = ["import"]
+
+[[bin]]
+name = "import_da3"
+path = "tool/import_da3.rs"
 required-features = ["import"]
diff --git a/README.md b/README.md
index 04efc2f..8b54198 100644
--- a/README.md
+++ b/README.md
@@ -18,7 +18,6 @@ burn [depth pro](https://github.com/apple/ml-depth-pro) model inference
 use burn::prelude::*;
 use burn_depth::{InferenceBackend, model::depth_pro::DepthPro};
 
-// NdArray backend (alternatively: burn::backend::Cuda, burn::backend::Cpu)
 let device = <InferenceBackend as Backend>::Device::default();
 
 let model = DepthPro::<InferenceBackend>::load(&device, "assets/model/depth_pro.mpk")?;
@@ -31,9 +30,27 @@ let result = model.infer(input, None);
 // result.focallength_px: Tensor<InferenceBackend, 1> with shape [1]
 ```
 
+### switching between depth_pro and depth anything 3
+
+```bash
+cargo run --example inference -- \
+  --model depth-pro \
+  --checkpoint assets/model/depth_pro.mpk \
+  --image assets/image/test.jpg
+
+cargo run --example inference -- \
+  --model depth-anything3 \
+  --checkpoint assets/model/da3_metric_large.mpk \
+  --image assets/image/test.jpg
+```
+
 
 ## setup
 
 - download [`depth_pro.pt`](https://github.com/apple/ml-depth-pro/blob/main/get_pretrained_models.sh) to `assets/model/`
-- `cargo run --bin import --features import`
-- `cargo run --example inference`
+- `cargo run --bin import_depth_pro --features import`
+
+- download [`da3_metric_large.safetensors`](https://huggingface.co/depth-anything/Depth-Anything-V3) to `assets/model/`
+- `cargo run --bin import_da3 --features import`
+
+- `cargo run --example inference -- --help`
diff --git a/assets/model/da3_small.mpk b/assets/model/da3_small.mpk
new file mode 100644
index 0000000..5fc0d2f
Binary files /dev/null and b/assets/model/da3_small.mpk differ
diff --git a/bench/inference.rs b/bench/inference.rs
index 2eaf170..a7c7a43 100644
--- a/bench/inference.rs
+++ b/bench/inference.rs
@@ -3,7 +3,10 @@
 use burn::prelude::*;
 use burn_depth::{
     InferenceBackend,
-    model::depth_pro::{DepthPro, DepthProConfig},
+    model::{
+        depth_anything3::{DepthAnything3, DepthAnything3Config},
+        depth_pro::{DepthPro, DepthProConfig},
+    },
 };
 use criterion::{Criterion, Throughput, criterion_group, criterion_main};
 use std::hint::black_box;
@@ -17,16 +20,43 @@ criterion_main!(depth_pro_benchmarks);
 
 fn inference_benchmark(c: &mut Criterion) {
     let device = <InferenceBackend as Backend>::Device::default();
-    let model = DepthPro::<InferenceBackend>::new(&device, DepthProConfig::default());
-    let image_size = model.img_size();
-    let input: Tensor<InferenceBackend, 4> = Tensor::zeros([1, 3, image_size, image_size], &device);
     let bench_device = device.clone();
 
+    let depth_pro = DepthPro::<InferenceBackend>::new(&device, DepthProConfig::default());
+    let pro_size = depth_pro.img_size();
+    let pro_input = Tensor::<InferenceBackend, 4>::zeros([1, 3, pro_size, pro_size], &device);
+
+    let depth_anything_large =
+        DepthAnything3::<InferenceBackend>::new(&device, DepthAnything3Config::metric_large());
+    let da3_large_size = depth_anything_large.img_size();
+    let da3_large_input =
+        Tensor::<InferenceBackend, 4>::zeros([1, 3, da3_large_size, da3_large_size], &device);
+
+    let depth_anything_small =
+        DepthAnything3::<InferenceBackend>::new(&device, DepthAnything3Config::small());
+    let da3_small_size = depth_anything_small.img_size();
+    let da3_small_input =
+        Tensor::<InferenceBackend, 4>::zeros([1, 3, da3_small_size, da3_small_size], &device);
+
     let mut group = c.benchmark_group("burn_depth_inference");
     group.throughput(Throughput::Elements(1));
     group.bench_function("depth_pro_infer", |b| {
         b.iter(|| {
-            let output = model.infer(input.clone());
+            let output = depth_pro.infer(pro_input.clone());
+            InferenceBackend::sync(&bench_device);
+            black_box(output);
+        });
+    });
+    group.bench_function("depth_anything3_metric_large_infer", |b| {
+        b.iter(|| {
+            let output = depth_anything_large.infer(da3_large_input.clone());
+            InferenceBackend::sync(&bench_device);
+            black_box(output);
+        });
+    });
+    group.bench_function("depth_anything3_small_infer", |b| {
+        b.iter(|| {
+            let output = depth_anything_small.infer(da3_small_input.clone());
             InferenceBackend::sync(&bench_device);
             black_box(output);
         });
diff --git a/crates/bevy_burn_depth/Cargo.toml b/crates/bevy_burn_depth/Cargo.toml
index 17702da..281a8bf 100644
--- a/crates/bevy_burn_depth/Cargo.toml
+++ b/crates/bevy_burn_depth/Cargo.toml
@@ -31,7 +31,7 @@ perftest = []
 [dependencies]
 bevy_args = "2.0"
 bevy_burn = "0.4"
-burn_depth = { path = "../../", default-features = false, features = ["backend_wgpu"] }
+burn_depth = { path = "../../", default-features = false }
 clap = { version = "4.5", features = ["derive"] }
 futures = { version = "0.3", optional = true }
 futures-intrusive = "0.5"
@@ -75,7 +75,25 @@ features = [
   # "fusion",
   "std",
   # "template",
-  "wgpu",
+  # "wgpu",
+]
+
+[dependencies.burn-cubecl-fusion]
+version = "0.19"
+default-features = false
+features = [
+  "std",
+  # "std",
+]
+
+
+[dependencies.burn-wgpu]
+version = "0.19"
+default-features = false
+features = [
+  "fusion",
+  # "std",
+  # "template",
 ]
 
 
diff --git a/crates/bevy_burn_depth/src/lib.rs b/crates/bevy_burn_depth/src/lib.rs
index 5614fba..3102ddc 100644
--- a/crates/bevy_burn_depth/src/lib.rs
+++ b/crates/bevy_burn_depth/src/lib.rs
@@ -3,25 +3,27 @@ use std::sync::{Arc, Mutex};
 use burn::prelude::*;
 use burn_depth::{
     inference::infer_from_rgb,
-    model::depth_pro::DepthPro,
+    model::{depth_anything3::DepthAnything3, prepare_depth_anything3_image, PreparedModelImage},
 };
-use image::RgbImage;
+use image::{imageops, RgbImage};
 
 pub mod platform;
 
 pub async fn process_frame<B: Backend>(
     frame: RgbImage,
-    model: Arc<Mutex<DepthPro<B>>>,
+    model: Arc<Mutex<DepthAnything3<B>>>,
     device: B::Device,
+    patch_size: usize,
+    preferred_resolution: Option<usize>,
+    normalize_relative_depth: bool,
 ) -> Tensor<B, 3> {
-    let width = frame.width() as usize;
-    let height = frame.height() as usize;
+    let patch_size = patch_size.max(1);
+    let (frame, width, height) = prepare_input_frame(frame, patch_size, preferred_resolution);
     let pixels = frame.into_raw();
 
     let inference = {
         let guard = model.lock().expect("depth model poisoned");
-        infer_from_rgb(&*guard, &pixels, width, height, &device)
-            .expect("failed to run inference")
+        infer_from_rgb(&*guard, &pixels, width, height, &device).expect("failed to run inference")
     };
 
     let depth_map: Tensor<B, 2> = inference.depth.squeeze_dim(0);
@@ -29,31 +31,35 @@ pub async fn process_frame<B: Backend>(
     let height = dims[0];
     let width = dims[1];
 
-    let min_depth = depth_map
-        .clone()
-        .min()
-        .into_scalar_async()
-        .await
-        .elem::<f32>();
-    let max_depth = depth_map
-        .clone()
-        .max()
-        .into_scalar_async()
-        .await
-        .elem::<f32>();
-    let range = (max_depth - min_depth).max(f32::EPSILON);
+    let display_tensor = if normalize_relative_depth {
+        let min_depth = depth_map
+            .clone()
+            .min()
+            .into_scalar_async()
+            .await
+            .elem::<f32>();
+        let max_depth = depth_map
+            .clone()
+            .max()
+            .into_scalar_async()
+            .await
+            .elem::<f32>();
+        let range = (max_depth - min_depth).max(f32::EPSILON);
 
-    let normalized = depth_map
-        .sub_scalar(min_depth)
-        .div_scalar(range)
-        .clamp(0.0, 1.0)
-        .reshape([height as i32, width as i32, 1]);
+        depth_map
+            .sub_scalar(min_depth)
+            .div_scalar(range)
+            .clamp(0.0, 1.0)
+            .reshape([height as i32, width as i32, 1])
+    } else {
+        depth_map.clone().reshape([height as i32, width as i32, 1])
+    };
 
     let rgb = Tensor::<B, 3>::cat(
         vec![
-            normalized.clone(),
-            normalized.clone(),
-            normalized.clone(),
+            display_tensor.clone(),
+            display_tensor.clone(),
+            display_tensor.clone(),
         ],
         2,
     );
@@ -62,3 +68,61 @@ pub async fn process_frame<B: Backend>(
 
     Tensor::<B, 3>::cat(vec![rgb, alpha], 2).reshape([height as i32, width as i32, 4])
 }
+
+fn prepare_input_frame(
+    mut frame: RgbImage,
+    patch_size: usize,
+    preferred_resolution: Option<usize>,
+) -> (RgbImage, usize, usize) {
+    if let Some(mut target) = preferred_resolution {
+        target = target.max(patch_size).max(1);
+        let PreparedModelImage {
+            rgb, width, height, ..
+        } = prepare_depth_anything3_image(&frame, target)
+            .expect("failed to prepare Depth Anything input frame");
+        return (rgb, width, height);
+    }
+
+    let mut width = frame.width() as usize;
+    let mut height = frame.height() as usize;
+    let alignment = patch_size * 4;
+    let align_down = |value: usize| -> usize {
+        if value < patch_size {
+            value
+        } else if value >= alignment {
+            let rem = value % alignment;
+            if rem == 0 {
+                value
+            } else {
+                value - rem
+            }
+        } else {
+            let rem = value % patch_size;
+            if rem == 0 {
+                value
+            } else {
+                value - rem
+            }
+        }
+    };
+
+    let crop_width = align_down(width).max(1);
+    let crop_height = align_down(height).max(1);
+
+    if crop_width != width || crop_height != height {
+        let offset_x = (width - crop_width) / 2;
+        let offset_y = (height - crop_height) / 2;
+        frame = imageops::crop_imm(
+            &frame,
+            offset_x as u32,
+            offset_y as u32,
+            crop_width as u32,
+            crop_height as u32,
+        )
+        .to_image();
+        width = crop_width;
+        height = crop_height;
+    }
+
+    (frame, width, height)
+}
diff --git a/crates/bevy_burn_depth/src/main.rs b/crates/bevy_burn_depth/src/main.rs
index f565c8d..ca98f93 100644
--- a/crates/bevy_burn_depth/src/main.rs
+++ b/crates/bevy_burn_depth/src/main.rs
@@ -15,26 +15,22 @@ use bevy::{
     ecs::world::CommandQueue,
     prelude::*,
     render::{
+        RenderPlugin,
         render_resource::{Extent3d, TextureDimension, TextureFormat, TextureUsages},
         settings::{RenderCreation, WgpuFeatures, WgpuSettings},
-        RenderPlugin,
     },
-    tasks::{block_on, futures_lite::future, AsyncComputeTaskPool, Task},
+    tasks::{AsyncComputeTaskPool, Task, block_on, futures_lite::future},
     ui::widget::ImageNode,
-    window::WindowResolution,
 };
-use bevy_args::{parse_args, Deserialize, Parser, Serialize};
-use bevy_burn::{BevyBurnBridgePlugin, BevyBurnHandle, BindingDirection, TransferKind};
+use bevy_args::{Deserialize, Parser, Serialize, parse_args};
+use bevy_burn::{BevyBurnBridgePlugin, BevyBurnHandle, BindingDirection, BurnDevice, TransferKind};
 use bevy_burn_depth::{platform::camera::receive_image, process_frame};
-use burn::{
-    backend::wgpu::graphics::AutoGraphicsApi,
-    backend::wgpu::{init_setup_async, Wgpu},
-    prelude::*,
-};
-use burn_depth::model::depth_pro::{DepthPro, DepthProConfig};
+use burn::prelude::*;
+use burn_depth::model::depth_anything3::{DepthAnything3, DepthAnything3Config};
+use burn_wgpu::Wgpu;
 use image::RgbImage;
 
-const DEFAULT_CHECKPOINT: &str = "assets/model/depth_pro.mpk";
+const DEFAULT_CHECKPOINT: &str = "assets/model/da3_small.mpk";
 const MAX_IN_FLIGHT_TASKS: usize = 1;
 
 #[derive(Resource, Clone, Debug, Serialize, Deserialize, Parser, Reflect)]
@@ -52,6 +48,9 @@ pub struct BevyBurnDepthConfig {
 
     #[arg(long)]
     pub image_path: Option<PathBuf>,
+
+    #[arg(long, default_value = "true")]
+    pub normalize_relative_depth: bool,
 }
 
 impl Default for BevyBurnDepthConfig {
@@ -61,6 +60,7 @@ impl Default for BevyBurnDepthConfig {
             show_fps: true,
             checkpoint: PathBuf::from(DEFAULT_CHECKPOINT),
             image_path: None,
+            normalize_relative_depth: true,
         }
     }
 }
@@ -69,16 +69,24 @@ impl Default for BevyBurnDepthConfig {
 mod io {
     use std::path::Path;
 
-    use burn::prelude::*;
-    use burn_depth::model::depth_pro::{DepthPro, DepthProConfig};
+    use burn::{
+        prelude::*,
+        record::{HalfPrecisionSettings, NamedMpkFileRecorder},
+    };
+    use burn_depth::model::depth_anything3::{
+        DepthAnything3, DepthAnything3Config, with_model_load_stack,
+    };
 
     pub async fn load_model<B: Backend>(
-        config: DepthProConfig,
+        config: DepthAnything3Config,
         checkpoint: &Path,
         device: &B::Device,
-    ) -> DepthPro<B> {
-        DepthPro::load_with_config(device, config, checkpoint)
-            .expect("failed to load DepthPro checkpoint")
+    ) -> DepthAnything3<B> {
+        let recorder = NamedMpkFileRecorder::<HalfPrecisionSettings>::new();
+        with_model_load_stack(|| {
+            DepthAnything3::new(device, config).load_file(checkpoint, &recorder, device)
+        })
+        .expect("failed to load Depth Anything 3 checkpoint")
     }
 }
 
@@ -88,18 +96,20 @@ mod io {
         prelude::*,
         record::{HalfPrecisionSettings, NamedMpkBytesRecorder, Recorder},
     };
-    use burn_depth::model::depth_pro::{DepthPro, DepthProConfig};
+    use burn_depth::model::depth_anything3::{
+        DepthAnything3, DepthAnything3Config, with_model_load_stack,
+    };
     use js_sys::Uint8Array;
     use wasm_bindgen::JsCast;
     use wasm_bindgen_futures::JsFuture;
-    use web_sys::{window, Request, RequestInit, RequestMode, Response};
+    use web_sys::{Request, RequestInit, RequestMode, Response, window};
 
     pub async fn load_model<B: Backend>(
-        config: DepthProConfig,
+        config: DepthAnything3Config,
         checkpoint: &str,
         device: &B::Device,
-    ) -> DepthPro<B> {
-        let mut opts = RequestInit::new();
+    ) -> DepthAnything3<B> {
+        let opts = RequestInit::new();
         opts.set_method("GET");
         opts.set_mode(RequestMode::Cors);
 
@@ -125,18 +135,46 @@ mod io {
         bytes.copy_to(&mut data);
 
         let record = NamedMpkBytesRecorder::<HalfPrecisionSettings>::default()
-            .load(data, &Default::default())
+            .load(data, device)
             .expect("failed to decode checkpoint");
 
-        let model = DepthPro::new(device, config);
-        model.load_record(record)
+        with_model_load_stack(|| {
+            let model = DepthAnything3::new(device, config);
+            model.load_record(record)
+        })
     }
 }
 
 #[derive(Resource)]
-struct DepthModel<B: Backend> {
-    device: B::Device,
-    model: Arc<Mutex<DepthPro<B>>>,
+struct DepthModelState {
+    checkpoint: PathBuf,
+    config: DepthAnything3Config,
+    preferred_resolution: Option<usize>,
+    model: Option<Arc<Mutex<DepthAnything3<Wgpu>>>>,
+    load_task: Option<Task<DepthModelLoadResult>>,
+    normalize_relative_depth: bool,
+}
+
+impl DepthModelState {
+    fn new(
+        checkpoint: PathBuf,
+        config: DepthAnything3Config,
+        normalize_relative_depth: bool,
+    ) -> Self {
+        Self {
+            checkpoint,
+            preferred_resolution: Some(config.image_size),
+            config,
+            model: None,
+            load_task: None,
+            normalize_relative_depth,
+        }
+    }
+}
+
+struct DepthModelLoadResult {
+    model: DepthAnything3<Wgpu>,
+    resolution: usize,
 }
 
 #[derive(Resource)]
@@ -166,11 +204,16 @@ struct ProcessDepth(Task<CommandQueue>);
 
 fn process_frames(
     mut commands: Commands,
-    depth_model: Res<DepthModel<Wgpu>>,
+    depth_model: Res<DepthModelState>,
     depth_texture: Res<DepthTexture>,
     static_frame: Res<StaticFrame>,
     active_tasks: Query<&ProcessDepth>,
+    burn_device: Option<Res<BurnDevice>>,
 ) {
+    let Some(model) = depth_model.model.as_ref() else {
+        return;
+    };
+
     let Some(image_entity) = depth_texture.entity else {
         return;
     };
@@ -179,6 +222,18 @@ fn process_frames(
         return;
     }
 
+    let Some(burn_device) = burn_device else {
+        return;
+    };
+
+    if !burn_device.is_ready() {
+        return;
+    }
+
+    let normalize_relative_depth = depth_model.normalize_relative_depth;
+    let device = burn_device.device().unwrap().clone();
+    let model = model.clone();
+
     let frame_source = if let Some(frame) = static_frame.0.as_ref() {
         Some((**frame).clone())
     } else {
@@ -188,13 +243,21 @@ fn process_frames(
     if let Some(frame) = frame_source {
         let thread_pool = AsyncComputeTaskPool::get();
         let task_entity = commands.spawn_empty().id();
-        let device = depth_model.device.clone();
-        let model = depth_model.model.clone();
 
+        let patch_size = depth_model.config.patch_size;
+        let preferred_resolution = depth_model.preferred_resolution;
         let task = thread_pool.spawn({
             let target = image_entity;
             async move {
-                let tensor = process_frame(frame, model.clone(), device.clone()).await;
+                let tensor = process_frame(
+                    frame,
+                    model.clone(),
+                    device.clone(),
+                    patch_size,
+                    preferred_resolution,
+                    normalize_relative_depth,
+                )
+                .await;
                 let [tensor_height, tensor_width, _] = tensor.dims();
 
                 let mut queue = CommandQueue::default();
@@ -260,6 +323,97 @@ fn process_frames(
     }
 }
 
+fn begin_depth_model_load(
+    mut depth_model: ResMut<DepthModelState>,
+    burn_device: Option<Res<BurnDevice>>,
+) {
+    if depth_model.model.is_some() || depth_model.load_task.is_some() {
+        return;
+    }
+
+    let Some(burn_device) = burn_device else {
+        return;
+    };
+
+    if !burn_device.is_ready() {
+        return;
+    }
+
+    let checkpoint = depth_model.checkpoint.clone();
+    let config = depth_model.config.clone();
+    let device = burn_device.device().unwrap().clone();
+
+    log("loading depth model...");
+    log(&format!("checkpoint: {}", checkpoint.display()));
+
+    depth_model.load_task = Some(spawn_depth_model_load_task(config, checkpoint, device));
+}
+
+#[cfg(feature = "native")]
+fn spawn_depth_model_load_task(
+    config: DepthAnything3Config,
+    checkpoint: PathBuf,
+    device: <Wgpu as Backend>::Device,
+) -> Task<DepthModelLoadResult> {
+    AsyncComputeTaskPool::get().spawn(async move {
+        log("begin load_model task (native)...");
+        let depth = io::load_model::<Wgpu>(config, checkpoint.as_path(), &device).await;
+        log("load_model task finished.");
+        let resolution = depth.img_size();
+        DepthModelLoadResult {
+            model: depth,
+            resolution,
+        }
+    })
+}
+
+#[cfg(feature = "web")]
+fn spawn_depth_model_load_task(
+    config: DepthAnything3Config,
+    checkpoint: PathBuf,
+    device: <Wgpu as Backend>::Device,
+) -> Task<DepthModelLoadResult> {
+    let checkpoint = normalize_web_checkpoint(&checkpoint);
+    AsyncComputeTaskPool::get().spawn(async move {
+        let depth = io::load_model::<Wgpu>(config, &checkpoint, &device).await;
+        let resolution = depth.img_size();
+        DepthModelLoadResult {
+            model: depth,
+            resolution,
+        }
+    })
+}
+
+#[cfg(feature = "web")]
+fn normalize_web_checkpoint(path: &Path) -> String {
+    let normalized = path.to_string_lossy().replace('\\', "/");
+    if normalized.starts_with("./")
+        || normalized.starts_with('/')
+        || normalized.starts_with("http://")
+        || normalized.starts_with("https://")
+        || normalized.starts_with("data:")
+    {
+        normalized
+    } else {
+        format!("./{normalized}")
+    }
+}
+
+fn finish_depth_model_load(mut depth_model: ResMut<DepthModelState>) {
+    let Some(task) = depth_model.load_task.as_mut() else {
+        return;
+    };
+
+    if let Some(result) = block_on(future::poll_once(task)) {
+        log(&format!(
+            "depth model ready (inference resolution: {}px)",
+            result.resolution
+        ));
+        depth_model.model = Some(Arc::new(Mutex::new(result.model)));
+        depth_model.load_task = None;
+    }
+}
+
 fn handle_tasks(
     mut commands: Commands,
     mut diagnostics: Diagnostics,
@@ -281,17 +435,6 @@ fn handle_tasks(
     }
 }
 
-#[cfg(target_arch = "wasm32")]
-fn depth_image_setup() -> (&'static [u8], TextureFormat, TransferKind, TextureUsages) {
-    (
-        &[0u8; 4],
-        TextureFormat::Rgba8UnormSrgb,
-        TransferKind::Cpu,
-        TextureUsages::COPY_SRC | TextureUsages::COPY_DST | TextureUsages::TEXTURE_BINDING,
-    )
-}
-
-#[cfg(not(target_arch = "wasm32"))]
 fn depth_image_setup() -> (&'static [u8], TextureFormat, TransferKind, TextureUsages) {
     (
         &[0u8; 16],
@@ -306,10 +449,22 @@ fn depth_image_setup() -> (&'static [u8], TextureFormat, TransferKind, TextureUs
 
 fn setup_ui(
     mut commands: Commands,
-    depth: Res<DepthModel<Wgpu>>,
     mut depth_texture: ResMut<DepthTexture>,
     mut images: ResMut<Assets<Image>>,
+    burn_device: Option<Res<BurnDevice>>,
 ) {
+    if depth_texture.entity.is_some() {
+        return;
+    }
+
+    let Some(burn_device) = burn_device else {
+        return;
+    };
+
+    if !burn_device.is_ready() {
+        return;
+    }
+
     let size = Extent3d {
         width: depth_texture.width.max(1),
         height: depth_texture.height.max(1),
@@ -349,7 +504,7 @@ fn setup_ui(
                                 depth_texture.width.max(1) as usize,
                                 4,
                             ],
-                            &depth.device,
+                            burn_device.device().unwrap(),
                         ),
                         upload: true,
                         direction: BindingDirection::BurnToBevy,
@@ -388,7 +543,7 @@ pub fn viewer_app(args: BevyBurnDepthConfig) -> App {
     let primary_window = Some(Window {
         mode: bevy::window::WindowMode::Windowed,
         prevent_default_event_handling: false,
-        resolution: WindowResolution::new(1024, 1024),
+        resolution: bevy::window::WindowResolution::new(1024, 1024),
         title,
         #[cfg(feature = "perftest")]
         present_mode: bevy::window::PresentMode::AutoNoVsync,
@@ -482,31 +637,11 @@ fn fps_update_system(
     }
 }
 
-async fn run_app(args: BevyBurnDepthConfig) {
+fn run_app(args: BevyBurnDepthConfig) {
     log("running app...");
     log(&format!("{args:?}"));
 
-    let device = Default::default();
-    init_setup_async::<AutoGraphicsApi>(&device, Default::default()).await;
-    log("device created");
-
-    let config = DepthProConfig::default();
-
-    log("loading depth model...");
-
-    #[cfg(feature = "native")]
-    let depth = io::load_model::<Wgpu>(config.clone(), args.checkpoint.as_path(), &device).await;
-
-    #[cfg(feature = "web")]
-    let depth = io::load_model::<Wgpu>(
-        config.clone(),
-        args.checkpoint.to_string_lossy().as_ref(),
-        &device,
-    )
-    .await;
-
-    let image_size = depth.img_size();
-    log(&format!("depth model ready (inference resolution: {image_size}px)"));
+    let config = DepthAnything3Config::small();
 
     let static_frame = args.image_path.as_ref().map(|path| {
         image::open(path)
@@ -525,13 +660,22 @@ async fn run_app(args: BevyBurnDepthConfig) {
 
     app.insert_resource(depth_texture);
     app.insert_resource(StaticFrame(static_frame.clone()));
-    app.insert_resource(DepthModel {
-        device: device.clone(),
-        model: Arc::new(Mutex::new(depth)),
-    });
-
-    app.add_systems(Startup, setup_ui);
-    app.add_systems(Update, (handle_tasks, process_frames));
+    app.insert_resource(DepthModelState::new(
+        args.checkpoint.clone(),
+        config,
+        args.normalize_relative_depth,
+    ));
+    app.add_systems(
+        Update,
+        (
+            setup_ui,
+            begin_depth_model_load,
+            finish_depth_model_load,
+            handle_tasks,
+            process_frames,
+        )
+            .chain(),
+    );
 
     log("launching Bevy application...");
     app.run();
@@ -542,17 +686,17 @@ async fn run_app(args: BevyBurnDepthConfig) {
     }
 }
 
-pub fn log(message: &str) {
+pub fn log(_message: &str) {
     #[cfg(debug_assertions)]
     #[cfg(target_arch = "wasm32")]
     {
-        web_sys::console::log_1(&message.into());
+        web_sys::console::log_1(&_message.into());
     }
 
     #[cfg(debug_assertions)]
     #[cfg(not(target_arch = "wasm32"))]
     {
-        println!("{message}");
+        println!("{_message}");
     }
 }
 
@@ -563,7 +707,7 @@ fn main() {
         if args.image_path.is_none() {
             std::thread::spawn(bevy_burn_depth::platform::camera::native_camera_thread);
         }
-        futures::executor::block_on(run_app(args));
+        run_app(args);
     }
 
     #[cfg(target_arch = "wasm32")]
@@ -573,6 +717,6 @@ fn main() {
         #[cfg(debug_assertions)]
         console_error_panic_hook::set_once();
 
-        wasm_bindgen_futures::spawn_local(run_app(args));
+        run_app(args);
     }
 }
diff --git a/crates/bevy_burn_depth/www/index.html b/crates/bevy_burn_depth/www/index.html
index 6652545..dc6b379 100644
--- a/crates/bevy_burn_depth/www/index.html
+++ b/crates/bevy_burn_depth/www/index.html
@@ -1,7 +1,7 @@
 <html>
   <head>
     <meta charset="UTF-8" />
-    <title>bevy_burn_dino</title>
+    <title>bevy_burn_depth</title>
     <style>
       body {
         width: 100%;
@@ -40,7 +40,7 @@
     </style>
   </head>
   <script type="module">
-    import init, { frame_input } from './out/bevy_burn_dino.js'
+    import init, { frame_input } from './out/bevy_burn_depth.js'
     init()
     document.querySelector('.loading').style.display = 'none'
 
diff --git a/example/correctness.rs b/example/correctness.rs
index b364edf..b4daf5a 100644
--- a/example/correctness.rs
+++ b/example/correctness.rs
@@ -1,19 +1,82 @@
 #![recursion_limit = "256"]
 
-use std::{convert::TryInto, f32::consts::PI, path::Path};
+use std::{
+    convert::TryInto,
+    f32::consts::PI,
+    io::Write,
+    path::{Path, PathBuf},
+};
 
 use burn::{
     nn::interpolate::{Interpolate2dConfig, InterpolateMode},
     prelude::*,
+    record::{HalfPrecisionSettings, NamedMpkFileRecorder},
 };
 use burn_depth::{
     InferenceBackend,
     inference::rgb_to_input_tensor,
-    model::depth_pro::{DepthPro, HeadDebug, layers::encoder::EncoderDebug},
+    model::{
+        depth_anything3::{DepthAnything3, DepthAnything3Config, with_model_load_stack},
+        depth_pro::{DepthPro, HeadDebug, layers::encoder::EncoderDebug},
+        prepare_depth_anything3_image,
+    },
 };
+use clap::{Parser, ValueEnum};
 use image::GenericImageView;
 use safetensors::tensor::{SafeTensors, TensorView};
 
+#[derive(Parser, Debug)]
+#[command(
+    author,
+    version,
+    about = "Compare Burn inference against PyTorch references for DepthPro or Depth Anything 3."
+)]
+struct Args {
+    #[arg(long, value_enum, default_value_t = ModelArg::DepthPro)]
+    model: ModelArg,
+    #[arg(long, value_name = "PATH")]
+    checkpoint: Option<PathBuf>,
+    #[arg(long, value_name = "PATH")]
+    reference: Option<PathBuf>,
+    #[arg(long, value_name = "PATH")]
+    image: Option<PathBuf>,
+    #[arg(long, default_value_t = false)]
+    dump_input: bool,
+}
+
+#[derive(Clone, Copy, Debug, ValueEnum)]
+enum ModelArg {
+    DepthPro,
+    DepthAnything3,
+}
+
+impl ModelArg {
+    fn default_checkpoint(self) -> &'static str {
+        match self {
+            ModelArg::DepthPro => "assets/model/depth_pro.mpk",
+            ModelArg::DepthAnything3 => "assets/model/da3_metric_large.mpk",
+        }
+    }
+
+    fn default_reference(self) -> &'static str {
+        match self {
+            ModelArg::DepthPro => "assets/image/test.safetensors",
+            ModelArg::DepthAnything3 => "assets/image/test_da3_reference.safetensors",
+        }
+    }
+
+    fn default_image(self) -> &'static str {
+        "assets/image/test.jpg"
+    }
+
+    fn label(self) -> &'static str {
+        match self {
+            ModelArg::DepthPro => "DepthPro",
+            ModelArg::DepthAnything3 => "Depth Anything 3",
+        }
+    }
+}
+
 #[derive(Clone)]
 struct FeatureTensor {
     data: Vec<f32>,
@@ -65,7 +128,7 @@ struct BurnOutputs {
     fovx: f32,
     fovy: f32,
     encoder_features: Vec<FeatureTensor>,
-    decoder_fusions: Vec<FeatureTensor>,
+    // decoder_fusions: Vec<FeatureTensor>,
     encoder_merge_latent0: FeatureTensor,
     encoder_merge_latent1: FeatureTensor,
     encoder_latent0_tokens: FeatureTensor,
@@ -76,8 +139,8 @@ struct BurnOutputs {
     encoder_merge_x1: FeatureTensor,
     encoder_merge_x2: FeatureTensor,
     canonical_inverse_depth: FeatureTensor,
-    decoder_feature: FeatureTensor,
-    decoder_lowres_feature: FeatureTensor,
+    // decoder_feature: FeatureTensor,
+    // decoder_lowres_feature: FeatureTensor,
     head_conv0: FeatureTensor,
     head_deconv: FeatureTensor,
     head_conv1: FeatureTensor,
@@ -221,11 +284,21 @@ fn feature_tensor_to_tensor(
     )
 }
 
-fn compute_burn_outputs(image_path: &Path) -> Result<BurnOutputs, Box<dyn std::error::Error>> {
+fn compute_burn_outputs(
+    image_path: &Path,
+    checkpoint_path: &Path,
+) -> Result<BurnOutputs, Box<dyn std::error::Error>> {
     let device = <InferenceBackend as Backend>::Device::default();
-    let checkpoint = Path::new("assets/model/depth_pro.mpk");
 
-    let model = DepthPro::<InferenceBackend>::load(&device, checkpoint)
+    if !checkpoint_path.exists() {
+        return Err(format!(
+            "Burn checkpoint `{}` missing. Run the importer first.",
+            checkpoint_path.display()
+        )
+        .into());
+    }
+
+    let model = DepthPro::<InferenceBackend>::load(&device, checkpoint_path)
         .map_err(|err| format!("failed to load checkpoint: {err}"))?;
 
     let image = image::open(image_path)?;
@@ -302,7 +375,7 @@ fn compute_burn_outputs(image_path: &Path) -> Result<BurnOutputs, Box<dyn std::e
     let (
         _canonical_decoder,
         decoder_feature_tensor,
-        decoder_lowres_tensor,
+        _decoder_lowres_tensor,
         decoder_fusion_tensors,
         _,
     ) = model.forward_with_decoder(feature_input.clone());
@@ -337,10 +410,10 @@ fn compute_burn_outputs(image_path: &Path) -> Result<BurnOutputs, Box<dyn std::e
         shape: canonical_shape,
     };
 
-    let decoder_feature = tensor_to_feature(decoder_feature_tensor)
-        .map_err(|err| format!("failed to fetch decoder feature: {err}"))?;
-    let decoder_lowres_feature = tensor_to_feature(decoder_lowres_tensor)
-        .map_err(|err| format!("failed to fetch decoder lowres feature: {err}"))?;
+    // let decoder_feature = tensor_to_feature(decoder_feature_tensor)
+    //     .map_err(|err| format!("failed to fetch decoder feature: {err}"))?;
+    // let decoder_lowres_feature = tensor_to_feature(decoder_lowres_tensor)
+    //     .map_err(|err| format!("failed to fetch decoder lowres feature: {err}"))?;
     let mut decoder_fusions = Vec::with_capacity(decoder_fusion_tensors.len());
     for (idx, fusion) in decoder_fusion_tensors.into_iter().enumerate() {
         decoder_fusions.push(
@@ -391,7 +464,7 @@ fn compute_burn_outputs(image_path: &Path) -> Result<BurnOutputs, Box<dyn std::e
         fovx,
         fovy,
         encoder_features: burn_features,
-        decoder_fusions,
+        // decoder_fusions,
         encoder_merge_latent0,
         encoder_merge_latent1,
         encoder_latent0_tokens,
@@ -402,8 +475,8 @@ fn compute_burn_outputs(image_path: &Path) -> Result<BurnOutputs, Box<dyn std::e
         encoder_merge_x1,
         encoder_merge_x2,
         canonical_inverse_depth: canonical_feature,
-        decoder_feature,
-        decoder_lowres_feature,
+        // decoder_feature,
+        // decoder_lowres_feature,
         head_conv0,
         head_deconv,
         head_conv1,
@@ -435,6 +508,25 @@ fn compute_stats(burn: &[f32], reference: &[f32]) -> (f32, f32, f32) {
     (mean_abs, max_abs, max_rel)
 }
 
+fn compare_feature(name: &str, burn: &FeatureTensor, reference: &Option<FeatureTensor>) {
+    match reference {
+        Some(torch_feature) => {
+            if torch_feature.shape != burn.shape {
+                println!(
+                    "{name}: shape mismatch torch={:?} burn={:?}",
+                    torch_feature.shape, burn.shape
+                );
+                return;
+            }
+
+            let (mean_abs, max_abs, max_rel) =
+                compute_stats(burn.data.as_slice(), torch_feature.data.as_slice());
+            println!("{name}: mean abs={mean_abs:.6}, max abs={max_abs:.6}, max rel={max_rel:.6}");
+        }
+        None => println!("{name}: torch reference missing; skipping comparison"),
+    }
+}
+
 fn compare_decoder_with_reference(
     torch_reference: &TorchReference,
 ) -> Result<(), Box<dyn std::error::Error>> {
@@ -571,11 +663,45 @@ fn compare_decoder_with_reference(
 
     Ok(())
 }
-
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let image_path = Path::new("assets/image/test.jpg");
-    let reference_path = Path::new("assets/image/test.safetensors");
+    let args = Args::parse();
+    let model = args.model;
+    let image = args
+        .image
+        .unwrap_or_else(|| PathBuf::from(model.default_image()));
+    let reference = args
+        .reference
+        .unwrap_or_else(|| PathBuf::from(model.default_reference()));
+    let checkpoint = args
+        .checkpoint
+        .unwrap_or_else(|| PathBuf::from(model.default_checkpoint()));
+
+    println!(
+        "{} correctness: image={}, checkpoint={}, reference={}",
+        model.label(),
+        image.display(),
+        checkpoint.display(),
+        reference.display()
+    );
+
+    match model {
+        ModelArg::DepthPro => {
+            run_depth_pro(image.as_path(), reference.as_path(), checkpoint.as_path())
+        }
+        ModelArg::DepthAnything3 => run_da3(
+            image.as_path(),
+            reference.as_path(),
+            checkpoint.as_path(),
+            args.dump_input,
+        ),
+    }
+}
 
+fn run_depth_pro(
+    image_path: &Path,
+    reference_path: &Path,
+    checkpoint_path: &Path,
+) -> Result<(), Box<dyn std::error::Error>> {
     if !reference_path.exists() {
         return Err(format!(
             "Torch reference `{}` missing. Run `python tool/correctness.py` first.",
@@ -586,7 +712,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let torch_reference = load_torch_reference(reference_path)?;
     compare_decoder_with_reference(&torch_reference)?;
-    let burn_outputs = compute_burn_outputs(image_path)?;
+    let burn_outputs = compute_burn_outputs(image_path, checkpoint_path)?;
 
     if burn_outputs.height != torch_reference.depth_shape[0]
         || burn_outputs.width != torch_reference.depth_shape[1]
@@ -646,241 +772,13 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                 max_diff = max_diff.max(diff);
             }
             let mean_diff = diff_sum / burn_outputs.canonical_inverse_depth.data.len() as f32;
-            let (canon_mean_abs, canon_max_abs, canon_max_rel) = compute_stats(
-                &burn_outputs.canonical_inverse_depth.data,
-                &canonical_ref.data,
-            );
-            println!(
-                "Canonical inverse depth diff: mean abs={canon_mean_abs:.6}, max abs={canon_max_abs:.6}, max rel={canon_max_rel:.6}"
-            );
             println!("Canonical inverse depth mean diff: {mean_diff:.6}");
-            println!("Canonical inverse depth diff range: min={min_diff:.6}, max={max_diff:.6}");
+            println!("Canonical inverse depth diff range: ({min_diff:.6}, {max_diff:.6})");
         }
     } else {
         println!("Torch reference missing canonical inverse depth; skipping comparison.");
     }
 
-    if let Some(decoder_ref) = torch_reference.decoder_feature.as_ref() {
-        if burn_outputs.decoder_feature.shape != decoder_ref.shape {
-            println!(
-                "Decoder feature shape mismatch: torch {:?}, burn {:?}",
-                decoder_ref.shape, burn_outputs.decoder_feature.shape
-            );
-        } else {
-            let mut diff_sum = 0.0f32;
-            let mut min_diff = f32::INFINITY;
-            let mut max_diff = f32::NEG_INFINITY;
-            let mut max_abs_seen = 0.0f32;
-            let mut max_index = 0usize;
-            let mut max_pair = (0.0f32, 0.0f32);
-            for (idx, (&burn_value, &torch_value)) in burn_outputs
-                .decoder_feature
-                .data
-                .iter()
-                .zip(decoder_ref.data.iter())
-                .enumerate()
-            {
-                let diff = burn_value - torch_value;
-                diff_sum += diff;
-                min_diff = min_diff.min(diff);
-                max_diff = max_diff.max(diff);
-                let abs = diff.abs();
-                if abs > max_abs_seen {
-                    max_abs_seen = abs;
-                    max_index = idx;
-                    max_pair = (burn_value, torch_value);
-                }
-            }
-            let mean_diff = diff_sum / burn_outputs.decoder_feature.data.len() as f32;
-            let (mean_abs, max_abs, max_rel) =
-                compute_stats(&burn_outputs.decoder_feature.data, &decoder_ref.data);
-            println!(
-                "Decoder feature diff: mean abs={mean_abs:.6}, max abs={max_abs:.6}, max rel={max_rel:.6}"
-            );
-            println!(
-                "Decoder feature mean diff={mean_diff:.6}, range=({min_diff:.6}, {max_diff:.6})"
-            );
-            if max_abs > 1e-3 {
-                let coords =
-                    flat_index_to_coords(max_index, burn_outputs.decoder_feature.shape.as_slice());
-                println!(
-                    "Decoder feature max diff at {:?}: burn={:.6}, torch={:.6}, diff={:.6}",
-                    coords, max_pair.0, max_pair.1, max_abs
-                );
-            }
-        }
-    } else {
-        println!("Torch reference missing decoder feature; skipping comparison.");
-    }
-
-    if let Some(decoder_lowres_ref) = torch_reference.decoder_lowres_feature.as_ref() {
-        if burn_outputs.decoder_lowres_feature.shape != decoder_lowres_ref.shape {
-            println!(
-                "Decoder lowres feature shape mismatch: torch {:?}, burn {:?}",
-                decoder_lowres_ref.shape, burn_outputs.decoder_lowres_feature.shape
-            );
-        } else {
-            let mut diff_sum = 0.0f32;
-            let mut min_diff = f32::INFINITY;
-            let mut max_diff = f32::NEG_INFINITY;
-            let mut max_abs_seen = 0.0f32;
-            let mut max_index = 0usize;
-            let mut max_pair = (0.0f32, 0.0f32);
-            for (idx, (&burn_value, &torch_value)) in burn_outputs
-                .decoder_lowres_feature
-                .data
-                .iter()
-                .zip(decoder_lowres_ref.data.iter())
-                .enumerate()
-            {
-                let diff = burn_value - torch_value;
-                diff_sum += diff;
-                min_diff = min_diff.min(diff);
-                max_diff = max_diff.max(diff);
-                let abs = diff.abs();
-                if abs > max_abs_seen {
-                    max_abs_seen = abs;
-                    max_index = idx;
-                    max_pair = (burn_value, torch_value);
-                }
-            }
-            let mean_diff = diff_sum / burn_outputs.decoder_lowres_feature.data.len() as f32;
-            let (mean_abs, max_abs, max_rel) = compute_stats(
-                &burn_outputs.decoder_lowres_feature.data,
-                &decoder_lowres_ref.data,
-            );
-            println!(
-                "Decoder lowres feature diff: mean abs={mean_abs:.6}, max abs={max_abs:.6}, max rel={max_rel:.6}"
-            );
-            println!(
-                "Decoder lowres feature mean diff={mean_diff:.6}, range=({min_diff:.6}, {max_diff:.6})"
-            );
-            if max_abs > 1e-3 {
-                let coords = flat_index_to_coords(
-                    max_index,
-                    burn_outputs.decoder_lowres_feature.shape.as_slice(),
-                );
-                println!(
-                    "Decoder lowres max diff at {:?}: burn={:.6}, torch={:.6}, diff={:.6}",
-                    coords, max_pair.0, max_pair.1, max_abs
-                );
-            }
-        }
-    } else {
-        println!("Torch reference missing decoder lowres feature; skipping comparison.");
-    }
-
-    if burn_outputs.decoder_fusions.len() == torch_reference.decoder_fusions.len() {
-        for (idx, (burn_fusion, torch_fusion)) in burn_outputs
-            .decoder_fusions
-            .iter()
-            .zip(torch_reference.decoder_fusions.iter())
-            .enumerate()
-        {
-            if burn_fusion.shape != torch_fusion.shape {
-                println!(
-                    "Decoder fusion {idx} shape mismatch: torch {:?}, burn {:?}",
-                    torch_fusion.shape, burn_fusion.shape
-                );
-                continue;
-            }
-
-            let mut diff_sum = 0.0f32;
-            let mut min_diff = f32::INFINITY;
-            let mut max_diff = f32::NEG_INFINITY;
-            let mut max_abs_seen = 0.0f32;
-            let mut max_index = 0usize;
-            let mut max_pair = (0.0f32, 0.0f32);
-            for (flat_index, (&burn_value, &torch_value)) in burn_fusion
-                .data
-                .iter()
-                .zip(torch_fusion.data.iter())
-                .enumerate()
-            {
-                let diff = burn_value - torch_value;
-                diff_sum += diff;
-                min_diff = min_diff.min(diff);
-                max_diff = max_diff.max(diff);
-                let abs = diff.abs();
-                if abs > max_abs_seen {
-                    max_abs_seen = abs;
-                    max_index = flat_index;
-                    max_pair = (burn_value, torch_value);
-                }
-            }
-            let mean_diff = diff_sum / burn_fusion.data.len() as f32;
-            let (mean_abs, max_abs, max_rel) =
-                compute_stats(burn_fusion.data.as_slice(), torch_fusion.data.as_slice());
-            println!(
-                "Decoder fusion {idx}: mean abs={mean_abs:.6}, max abs={max_abs:.6}, max rel={max_rel:.6}"
-            );
-            println!(
-                "Decoder fusion {idx}: mean diff={mean_diff:.6}, range=({min_diff:.6}, {max_diff:.6})"
-            );
-            if max_abs > 1e-3 {
-                let coords = flat_index_to_coords(max_index, burn_fusion.shape.as_slice());
-                println!(
-                    "Decoder fusion {idx} max diff at {:?}: burn={:.6}, torch={:.6}, diff={:.6}",
-                    coords, max_pair.0, max_pair.1, max_abs
-                );
-            }
-        }
-    } else {
-        println!(
-            "Skipping decoder fusion comparison (torch={}, burn={}).",
-            torch_reference.decoder_fusions.len(),
-            burn_outputs.decoder_fusions.len()
-        );
-    }
-
-    let compare_feature = |name: &str, burn: &FeatureTensor, torch_opt: &Option<FeatureTensor>| {
-        if let Some(torch_feat) = torch_opt.as_ref() {
-            if burn.shape != torch_feat.shape {
-                println!(
-                    "{name} shape mismatch: torch {:?}, burn {:?}",
-                    torch_feat.shape, burn.shape
-                );
-            } else {
-                let mut diff_sum = 0.0f32;
-                let mut min_diff = f32::INFINITY;
-                let mut max_diff = f32::NEG_INFINITY;
-                let mut max_abs_seen = 0.0f32;
-                let mut max_index = 0usize;
-                let mut max_pair = (0.0f32, 0.0f32);
-                for (idx, (&burn_value, &torch_value)) in
-                    burn.data.iter().zip(torch_feat.data.iter()).enumerate()
-                {
-                    let diff = burn_value - torch_value;
-                    diff_sum += diff;
-                    min_diff = min_diff.min(diff);
-                    max_diff = max_diff.max(diff);
-                    let abs = diff.abs();
-                    if abs > max_abs_seen {
-                        max_abs_seen = abs;
-                        max_index = idx;
-                        max_pair = (burn_value, torch_value);
-                    }
-                }
-                let mean_diff = diff_sum / burn.data.len() as f32;
-                let (mean_abs, max_abs, max_rel) =
-                    compute_stats(burn.data.as_slice(), torch_feat.data.as_slice());
-                println!(
-                    "{name}: mean abs={mean_abs:.6}, max abs={max_abs:.6}, max rel={max_rel:.6}"
-                );
-                println!("{name}: mean diff={mean_diff:.6}, range=({min_diff:.6}, {max_diff:.6})");
-                if max_abs > 1e-3 {
-                    let coords = flat_index_to_coords(max_index, burn.shape.as_slice());
-                    println!(
-                        "{name}: max abs diff at {:?}: burn={:.6}, torch={:.6}, diff={:.6}",
-                        coords, max_pair.0, max_pair.1, max_abs
-                    );
-                }
-            }
-        } else {
-            println!("Torch reference missing {name}; skipping comparison.");
-        }
-    };
-
     compare_feature(
         "Encoder latent0 tokens",
         &burn_outputs.encoder_latent0_tokens,
@@ -1005,3 +903,217 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         Err("Burn output deviates from Torch reference beyond tolerance.".into())
     }
 }
+
+struct Da3Reference {
+    depth: Vec<f32>,
+    height: usize,
+    width: usize,
+}
+
+struct Da3Outputs {
+    depth: Vec<f32>,
+    height: usize,
+    width: usize,
+}
+
+fn run_da3(
+    image_path: &Path,
+    reference_path: &Path,
+    checkpoint_path: &Path,
+    dump_input: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if !reference_path.exists() {
+        return Err(format!(
+            "DA3 reference `{}` missing. Run `python tool/correctness_da3.py` first.",
+            reference_path.display()
+        )
+        .into());
+    }
+
+    let reference = load_da3_reference(reference_path)?;
+    let outputs = compute_da3_outputs(image_path, checkpoint_path, dump_input)?;
+    compare_da3(&reference, &outputs)
+}
+
+fn load_da3_reference(path: &Path) -> Result<Da3Reference, Box<dyn std::error::Error>> {
+    let bytes = std::fs::read(path)?;
+    let tensors = SafeTensors::deserialize(&bytes)?;
+    let depth_view = tensors.tensor("metric_depth")?;
+    let mut shape = depth_view.shape().to_vec();
+    if shape.len() == 2 {
+        shape.push(1);
+    }
+    if shape.len() != 3 {
+        return Err(format!(
+            "DA3 reference `metric_depth` must be rank 3, got shape {:?}",
+            depth_view.shape()
+        )
+        .into());
+    }
+    let height = shape[0];
+    let width = shape[1];
+    let data = tensor_view_to_vec(&depth_view);
+    Ok(Da3Reference {
+        depth: data,
+        height,
+        width,
+    })
+}
+
+fn compute_da3_outputs(
+    image_path: &Path,
+    checkpoint_path: &Path,
+    dump_input: bool,
+) -> Result<Da3Outputs, Box<dyn std::error::Error>> {
+    let device = <InferenceBackend as Backend>::Device::default();
+    if !checkpoint_path.exists() {
+        return Err(format!(
+            "DA3 Burn checkpoint `{}` missing. Run the importer first.",
+            checkpoint_path.display()
+        )
+        .into());
+    }
+
+    let recorder = NamedMpkFileRecorder::<HalfPrecisionSettings>::new();
+    let model = with_model_load_stack(|| {
+        DepthAnything3::<InferenceBackend>::new(&device, DepthAnything3Config::metric_large())
+            .load_file(checkpoint_path, &recorder, &device)
+    })
+    .map_err(|err| format!("Failed to load DA3 checkpoint: {err}"))?;
+    let target = model.img_size();
+
+    let base_rgb = image::open(image_path)
+        .map_err(|err| format!("Failed to open image `{}`: {err}", image_path.display()))?
+        .to_rgb8();
+    let prepared = prepare_depth_anything3_image(&base_rgb, target)
+        .map_err(|err| format!("Failed to prepare DA3 input: {err}"))?;
+    let resized = prepared.rgb;
+    if std::env::var("DA3_DUMP_RESIZED").is_ok() {
+        let dump_path = Path::new("target/da3_resized_burn.rgb");
+        if let Some(parent) = dump_path.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+        std::fs::write(dump_path, resized.as_raw())?;
+        println!(
+            "Wrote Burn-resized RGB bytes to {} (set DA3_DUMP_RESIZED= to disable).",
+            dump_path.display()
+        );
+    }
+    let tensor =
+        rgb_to_input_tensor::<InferenceBackend>(resized.as_raw(), target, target, &device)?;
+    if dump_input {
+        let dump_path = Path::new("target/da3_input_tensor.bin");
+        if let Some(parent) = dump_path.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+        let tensor_data = tensor.clone().into_data().convert::<f32>();
+        let shape = tensor_data.shape.as_slice();
+        let values = tensor_data
+            .to_vec::<f32>()
+            .map_err(|err| format!("Failed to read input tensor: {err:?}"))?;
+        let mut file = std::fs::File::create(dump_path)?;
+        for &dim in shape {
+            let dim_u32 = u32::try_from(dim)
+                .map_err(|_| format!("Input tensor dimension {dim} exceeds u32 range"))?;
+            file.write_all(&dim_u32.to_le_bytes())?;
+        }
+        for value in values {
+            file.write_all(&value.to_le_bytes())?;
+        }
+        println!("Dumped DA3 input tensor to {}", dump_path.display());
+    }
+    let prediction = model.infer(tensor);
+    let depth_data = prediction.depth.into_data().convert::<f32>();
+    let shape = depth_data.shape.as_slice().to_vec();
+    let values = depth_data
+        .to_vec::<f32>()
+        .map_err(|err| format!("Failed to read DA3 depth tensor: {err:?}"))?;
+
+    Ok(Da3Outputs {
+        depth: values,
+        height: shape[1],
+        width: shape[2],
+    })
+}
+
+fn compare_da3(
+    reference: &Da3Reference,
+    outputs: &Da3Outputs,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if reference.height != outputs.height || reference.width != outputs.width {
+        return Err(format!(
+            "shape mismatch: torch {}x{}, burn {}x{}",
+            reference.height, reference.width, outputs.height, outputs.width
+        )
+        .into());
+    }
+
+    let mut sum_abs = 0.0f32;
+    let mut sum_signed = 0.0f32;
+    let mut max_abs = 0.0f32;
+    let mut max_rel = 0.0f32;
+    let mut dot = 0.0f32;
+    let mut ref_norm = 0.0f32;
+    let mut max_index = 0usize;
+    let mut max_pair = (0.0f32, 0.0f32);
+    for (idx, (&burn, &torch)) in outputs.depth.iter().zip(reference.depth.iter()).enumerate() {
+        let diff = (burn - torch).abs();
+        sum_abs += diff;
+        sum_signed += burn - torch;
+        if diff > max_abs {
+            max_abs = diff;
+            max_index = idx;
+            max_pair = (burn, torch);
+        }
+        if torch.abs() > 1e-6 {
+            max_rel = max_rel.max(diff / torch.abs());
+        }
+        dot += burn * torch;
+        ref_norm += torch * torch;
+    }
+    let ls_scale = if ref_norm > 0.0 { dot / ref_norm } else { 1.0 };
+    let mean_abs = sum_abs / outputs.depth.len() as f32;
+    let mean_signed = sum_signed / outputs.depth.len() as f32;
+    println!("DA3 mean abs diff: {mean_abs:.6}");
+    println!("DA3 mean signed diff (burn - torch): {mean_signed:.6}");
+    println!("DA3 max abs diff:  {max_abs:.6}");
+    println!("DA3 max rel diff:  {max_rel:.6}");
+    let coords = (max_index / reference.width, max_index % reference.width);
+    println!(
+        "DA3 worst pixel at (row={}, col={}): burn={:.6}, torch={:.6}, diff={:.6}",
+        coords.0, coords.1, max_pair.0, max_pair.1, max_abs
+    );
+    println!("DA3 LS scale (burn ≈ scale * torch): {ls_scale:.6}");
+    if reference.width > 32 && reference.height > 32 {
+        let border = 16;
+        let mut center_sum = 0.0f32;
+        let mut center_max = 0.0f32;
+        let mut center_count = 0usize;
+        for row in border..reference.height - border {
+            for col in border..reference.width - border {
+                let idx = row * reference.width + col;
+                let diff = (outputs.depth[idx] - reference.depth[idx]).abs();
+                center_sum += diff;
+                center_max = center_max.max(diff);
+                center_count += 1;
+            }
+        }
+        if center_count > 0 {
+            let center_mean = center_sum / center_count as f32;
+            println!(
+                "DA3 center region mean abs diff: {center_mean:.6}, max abs diff: {center_max:.6}"
+            );
+        }
+    }
+
+    const DA3_MAX_ABS: f32 = 5e-3;
+    const DA3_MEAN_ABS: f32 = 1e-3;
+    const DA3_MAX_REL: f32 = 1e-2;
+
+    if mean_abs <= DA3_MEAN_ABS && max_abs <= DA3_MAX_ABS && max_rel <= DA3_MAX_REL {
+        println!("Depth Anything 3 output matches PyTorch reference within tolerance.");
+        Ok(())
+    } else {
+        Err("Depth Anything 3 output deviates beyond tolerance.".into())
+    }
+}
diff --git a/example/da3_small_correctness.rs b/example/da3_small_correctness.rs
new file mode 100644
index 0000000..8195134
--- /dev/null
+++ b/example/da3_small_correctness.rs
@@ -0,0 +1,514 @@
+use std::{
+    env,
+    path::{Path, PathBuf},
+};
+
+use burn::backend::ndarray::{NdArray, NdArrayDevice};
+use burn::prelude::*;
+use burn::record::{HalfPrecisionSettings, NamedMpkFileRecorder};
+use burn_depth::{
+    inference::rgb_to_input_tensor,
+    model::{
+        depth_anything3::{
+            DepthAnything3, DepthAnything3Config, DepthTrace, with_model_load_stack,
+        },
+        prepare_depth_anything3_image,
+    },
+};
+use image::RgbImage;
+use safetensors::tensor::{SafeTensors, TensorView};
+
+type NdBackend = NdArray<f32>;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let handle = std::thread::Builder::new()
+        .name("da3_small_correctness".into())
+        .stack_size(64 * 1024 * 1024)
+        .spawn(|| run().map_err(|err| err.to_string()))
+        .map_err(|err| format!("Failed to spawn correctness thread: {err}"))?;
+    handle
+        .join()
+        .map_err(|_| -> Box<dyn std::error::Error> { "Correctness thread panicked".into() })?
+        .map_err(|err: String| err.into())
+}
+
+fn run() -> Result<(), Box<dyn std::error::Error>> {
+    let mut args = env::args();
+    let _exe = args.next();
+    let reference_path = args
+        .next()
+        .map(PathBuf::from)
+        .unwrap_or_else(|| PathBuf::from("assets/image/test_da3_small_reference.safetensors"));
+    let image_path = args
+        .next()
+        .unwrap_or_else(|| "assets/image/test.jpg".to_string());
+
+    let device = NdArrayDevice::default();
+    println!("Loading Depth Anything 3 small checkpoint...");
+    let config = DepthAnything3Config::small();
+    let recorder = NamedMpkFileRecorder::<HalfPrecisionSettings>::new();
+    let model = with_model_load_stack(|| {
+        DepthAnything3::<NdBackend>::new(&device, config).load_file(
+            "assets/model/da3_small.mpk",
+            &recorder,
+            &device,
+        )
+    })
+    .map_err(|err| format!("Failed to load DA3 small checkpoint: {err}"))?;
+
+    println!(
+        "Checkpoint ready; loading reference tensors from {}...",
+        reference_path.display()
+    );
+    let reference = load_reference(&reference_path)?;
+    println!(
+        "Reference tensors loaded (depth {:?}); preparing input tensor...",
+        reference.depth.shape
+    );
+    let input_tensor = if let Some(metric_input) = &reference.metric_input {
+        println!(
+            "Using embedded metric_input tensor from {}",
+            reference_path.display()
+        );
+        tensor_from_reference::<4>(metric_input, &device)
+            .map_err(|err| format!("Failed to build reference input tensor: {err}"))?
+    } else {
+        println!(
+            "Reference `{}` lacks metric_input; falling back to prepared RGB `{image_path}`.",
+            reference_path.display()
+        );
+        let prepared = load_prepared_image(&image_path, model.img_size())?;
+        rgb_to_input_tensor::<NdBackend>(
+            prepared.rgb.as_raw(),
+            prepared.width,
+            prepared.height,
+            &device,
+        )?
+    };
+
+    println!("Running DA3 small inference...");
+    let (refined, trace) = model.infer_with_trace(input_tensor);
+
+    println!("Inference finished; analyzing outputs...");
+    analyze_tensor3("final depth", Some(&refined.depth), Some(&reference.depth));
+    analyze_tensor3(
+        "depth confidence",
+        refined.depth_confidence.as_ref(),
+        reference.depth_confidence.as_ref(),
+    );
+    analyze_tensor4("aux (ray)", refined.aux.as_ref(), reference.aux.as_ref());
+    analyze_tensor3(
+        "aux confidence",
+        refined.aux_confidence.as_ref(),
+        reference.aux_confidence.as_ref(),
+    );
+    analyze_tensor3(
+        "pose encoding",
+        refined.pose_encoding.as_ref(),
+        reference.pose_encoding.as_ref(),
+    );
+    analyze_tensor4(
+        "extrinsics",
+        refined.extrinsics.as_ref(),
+        reference.extrinsics.as_ref(),
+    );
+    analyze_tensor4(
+        "intrinsics",
+        refined.intrinsics.as_ref(),
+        reference.intrinsics.as_ref(),
+    );
+    analyze_backbone_tokens(&trace, &reference.backbone_tokens);
+    analyze_aux_stage_necks(
+        "inference aux_stage",
+        trace.aux_stage_necks.as_ref(),
+        &reference.aux_stage_necks,
+    );
+    analyze_tensor4(
+        "aux logits",
+        trace.aux_logits.as_ref(),
+        reference.aux_logits.as_ref(),
+    );
+    analyze_tensor4(
+        "aux head_input",
+        trace.aux_head_input.as_ref(),
+        reference.aux_head_input.as_ref(),
+    );
+    analyze_head_with_reference_tokens(&model, &device, &reference)?;
+
+    Ok(())
+}
+
+struct PreparedInput {
+    width: usize,
+    height: usize,
+    rgb: RgbImage,
+}
+
+fn load_prepared_image(path: &str, target: usize) -> Result<PreparedInput, String> {
+    let rgb = image::open(path)
+        .map_err(|err| format!("Failed to open image `{path}`: {err}"))?
+        .to_rgb8();
+    let prepared = prepare_depth_anything3_image(&rgb, target)?;
+    Ok(PreparedInput {
+        width: prepared.width,
+        height: prepared.height,
+        rgb: prepared.rgb,
+    })
+}
+
+#[derive(Clone)]
+struct ReferenceTensor {
+    shape: Vec<usize>,
+    data: Vec<f32>,
+}
+
+struct ReferenceDa3 {
+    metric_input: Option<ReferenceTensor>,
+    depth: ReferenceTensor,
+    depth_confidence: Option<ReferenceTensor>,
+    aux: Option<ReferenceTensor>,
+    aux_confidence: Option<ReferenceTensor>,
+    pose_encoding: Option<ReferenceTensor>,
+    extrinsics: Option<ReferenceTensor>,
+    intrinsics: Option<ReferenceTensor>,
+    backbone_tokens: Vec<ReferenceTensor>,
+    aux_stage_necks: Vec<ReferenceTensor>,
+    aux_logits: Option<ReferenceTensor>,
+    aux_head_input: Option<ReferenceTensor>,
+}
+
+fn load_reference(path: &Path) -> Result<ReferenceDa3, Box<dyn std::error::Error>> {
+    let bytes = std::fs::read(path)?;
+    let tensors = SafeTensors::deserialize(&bytes)?;
+    let depth = read_required(&tensors, "depth")?;
+    Ok(ReferenceDa3 {
+        metric_input: read_optional(&tensors, "metric_input"),
+        depth,
+        depth_confidence: read_optional(&tensors, "depth_confidence"),
+        aux: read_optional(&tensors, "ray"),
+        aux_confidence: read_optional(&tensors, "ray_confidence"),
+        pose_encoding: read_optional(&tensors, "pose_encoding"),
+        extrinsics: read_optional(&tensors, "extrinsics"),
+        intrinsics: read_optional(&tensors, "intrinsics"),
+        backbone_tokens: load_backbone_tokens(&tensors),
+        aux_stage_necks: load_aux_stage_necks(&tensors),
+        aux_logits: read_optional(&tensors, "aux_logits"),
+        aux_head_input: read_optional(&tensors, "aux_head_input"),
+    })
+}
+
+fn read_required(
+    tensors: &SafeTensors<'_>,
+    name: &str,
+) -> Result<ReferenceTensor, Box<dyn std::error::Error>> {
+    let view = tensors
+        .tensor(name)
+        .map_err(|err| format!("Reference tensor `{name}` missing: {err}"))?;
+    Ok(ReferenceTensor {
+        shape: view.shape().to_vec(),
+        data: tensor_view_to_vec(&view),
+    })
+}
+
+fn read_optional(tensors: &SafeTensors<'_>, name: &str) -> Option<ReferenceTensor> {
+    tensors.tensor(name).ok().map(|view| ReferenceTensor {
+        shape: view.shape().to_vec(),
+        data: tensor_view_to_vec(&view),
+    })
+}
+
+fn load_backbone_tokens(tensors: &SafeTensors<'_>) -> Vec<ReferenceTensor> {
+    let mut result = Vec::new();
+    for idx in 0usize.. {
+        let key = format!("backbone_tokens.stage{idx}");
+        match tensors.tensor(&key) {
+            Ok(view) => result.push(ReferenceTensor {
+                shape: view.shape().to_vec(),
+                data: tensor_view_to_vec(&view),
+            }),
+            Err(_) => break,
+        }
+    }
+    result
+}
+
+fn load_aux_stage_necks(tensors: &SafeTensors<'_>) -> Vec<ReferenceTensor> {
+    let mut result = Vec::new();
+    for idx in 0usize.. {
+        let key = format!("aux_stage_necks.stage{idx}");
+        match tensors.tensor(&key) {
+            Ok(view) => result.push(ReferenceTensor {
+                shape: view.shape().to_vec(),
+                data: tensor_view_to_vec(&view),
+            }),
+            Err(_) => break,
+        }
+    }
+    result
+}
+
+fn tensor_view_to_vec(view: &TensorView) -> Vec<f32> {
+    view.data()
+        .chunks_exact(4)
+        .map(|chunk| f32::from_le_bytes(chunk.try_into().unwrap()))
+        .collect()
+}
+
+fn convert_reference_tokens(
+    tensors: &[ReferenceTensor],
+    device: &NdArrayDevice,
+) -> Result<Vec<Tensor<NdBackend, 3>>, String> {
+    tensors
+        .iter()
+        .map(|tensor| tensor_from_reference::<3>(tensor, device))
+        .collect()
+}
+
+fn reference_depth_hw(reference: &ReferenceDa3) -> Result<(usize, usize), String> {
+    let shape = reference.depth.shape.as_slice();
+    match shape {
+        [_, h, w] => Ok((*h, *w)),
+        [h, w] => Ok((*h, *w)),
+        _ => Err(format!(
+            "Depth reference shape {:?} is not supported",
+            reference.depth.shape
+        )),
+    }
+}
+
+fn analyze_head_with_reference_tokens(
+    model: &DepthAnything3<NdBackend>,
+    device: &NdArrayDevice,
+    reference: &ReferenceDa3,
+) -> Result<(), String> {
+    if reference.backbone_tokens.is_empty() {
+        println!("Reference lacks backbone tokens; skipping head-only comparison.");
+        return Ok(());
+    }
+    let tokens = convert_reference_tokens(&reference.backbone_tokens, device)?;
+    let (height, width) = reference_depth_hw(reference)?;
+    let (head_result, aux_stage_necks, aux_logits, aux_head_input) =
+        model.infer_from_tokens(&tokens, height, width);
+    println!("--- Head-only comparison using Torch backbone tokens ---");
+    analyze_tensor3(
+        "head depth",
+        Some(&head_result.depth),
+        Some(&reference.depth),
+    );
+    analyze_tensor3(
+        "head depth_confidence",
+        head_result.depth_confidence.as_ref(),
+        reference.depth_confidence.as_ref(),
+    );
+    analyze_tensor4("head aux", head_result.aux.as_ref(), reference.aux.as_ref());
+    analyze_tensor3(
+        "head aux_confidence",
+        head_result.aux_confidence.as_ref(),
+        reference.aux_confidence.as_ref(),
+    );
+    analyze_aux_stage_necks(
+        "head aux_stage",
+        aux_stage_necks.as_ref(),
+        &reference.aux_stage_necks,
+    );
+    analyze_tensor4(
+        "head aux_logits",
+        aux_logits.as_ref(),
+        reference.aux_logits.as_ref(),
+    );
+    analyze_tensor4(
+        "head aux_head_input",
+        aux_head_input.as_ref(),
+        reference.aux_head_input.as_ref(),
+    );
+
+    Ok(())
+}
+
+fn tensor_from_reference<const D: usize>(
+    reference: &ReferenceTensor,
+    device: &NdArrayDevice,
+) -> Result<Tensor<NdBackend, D>, String> {
+    if reference.shape.len() != D {
+        return Err(format!(
+            "reference tensor rank {} does not match expected {D}",
+            reference.shape.len()
+        ));
+    }
+    let dims = reshape_dims::<D>(&reference.shape)?;
+    Ok(Tensor::<NdBackend, 1>::from_floats(reference.data.as_slice(), device).reshape(dims))
+}
+
+fn reshape_dims<const D: usize>(shape: &[usize]) -> Result<[i32; D], String> {
+    if shape.len() != D {
+        return Err(format!(
+            "shape {:?} cannot be reshaped into {}-D tensor",
+            shape, D
+        ));
+    }
+    let mut dims = [0i32; D];
+    for (idx, &dim) in shape.iter().enumerate() {
+        dims[idx] = dim
+            .try_into()
+            .map_err(|_| format!("dimension {dim} exceeds i32::MAX"))?;
+    }
+    Ok(dims)
+}
+
+fn analyze_tensor3(
+    label: &str,
+    tensor: Option<&Tensor<NdBackend, 3>>,
+    reference: Option<&ReferenceTensor>,
+) {
+    match (tensor, reference) {
+        (Some(tensor), Some(reference)) => {
+            let data = tensor.clone().into_data().convert::<f32>();
+            let values = data
+                .to_vec::<f32>()
+                .expect("failed to read tensor values for comparison");
+            compare_tensors(label, &values, reference);
+        }
+        (Some(_), None) => println!("{label}: missing Torch reference tensor"),
+        (None, Some(_)) => println!("{label}: model did not emit this tensor"),
+        (None, None) => println!("{label}: not available in either model or reference"),
+    }
+}
+
+fn analyze_tensor4(
+    label: &str,
+    tensor: Option<&Tensor<NdBackend, 4>>,
+    reference: Option<&ReferenceTensor>,
+) {
+    match (tensor, reference) {
+        (Some(tensor), Some(reference)) => {
+            let data = tensor.clone().into_data().convert::<f32>();
+            let values = data
+                .to_vec::<f32>()
+                .expect("failed to read tensor values for comparison");
+            compare_tensors(label, &values, reference);
+        }
+        (Some(_), None) => println!("{label}: missing Torch reference tensor"),
+        (None, Some(_)) => println!("{label}: model did not emit this tensor"),
+        (None, None) => println!("{label}: not available in either model or reference"),
+    }
+}
+
+fn analyze_backbone_tokens(trace: &DepthTrace<NdBackend>, reference: &[ReferenceTensor]) {
+    if reference.is_empty() {
+        println!("Reference lacks backbone token traces; skipping backbone comparison.");
+        return;
+    }
+    if trace.backbone_tokens.len() != reference.len() {
+        println!(
+            "Backbone token stage count mismatch: model={}, reference={}",
+            trace.backbone_tokens.len(),
+            reference.len()
+        );
+    }
+    for idx in 0..reference.len() {
+        let label = format!("backbone_tokens.stage{idx}");
+        let Some(burn_tensor) = trace.backbone_tokens.get(idx) else {
+            println!("{label}: model did not emit this stage");
+            continue;
+        };
+        let (values, shape) = tensor3_to_vec(burn_tensor);
+        if values.len() != reference[idx].data.len() {
+            println!(
+                "{label}: size mismatch model={} reference={} (model shape {:?}, reference shape {:?})",
+                values.len(),
+                reference[idx].data.len(),
+                shape,
+                reference[idx].shape
+            );
+            continue;
+        }
+        compare_tensors(&label, &values, &reference[idx]);
+    }
+}
+
+fn compare_tensors(label: &str, burn: &[f32], reference: &ReferenceTensor) {
+    if burn.len() != reference.data.len() {
+        println!(
+            "{label}: size mismatch model={} reference={} for shape {:?}",
+            burn.len(),
+            reference.data.len(),
+            reference.shape
+        );
+        return;
+    }
+    let mut mae = 0.0f64;
+    let mut max_abs = 0.0f32;
+    let mut min_val = f32::MAX;
+    let mut max_val = f32::MIN;
+    for (lhs, rhs) in burn.iter().zip(reference.data.iter()) {
+        let diff = (lhs - rhs).abs();
+        mae += diff as f64;
+        if diff > max_abs {
+            max_abs = diff;
+        }
+        if lhs.is_finite() {
+            min_val = min_val.min(*lhs);
+            max_val = max_val.max(*lhs);
+        }
+    }
+    if !burn.is_empty() {
+        mae /= burn.len() as f64;
+    }
+    println!(
+        "{label}: shape {:?}, mae={mae:.6}, max_abs={max_abs:.6}, range=[{min_val:.4}, {max_val:.4}]",
+        reference.shape
+    );
+}
+
+fn tensor3_to_vec(tensor: &Tensor<NdBackend, 3>) -> (Vec<f32>, Vec<usize>) {
+    let data = tensor.clone().into_data().convert::<f32>();
+    let shape = data.shape.clone();
+    let values = data
+        .to_vec::<f32>()
+        .expect("failed to read backbone tensor values");
+    (values, shape)
+}
+
+fn tensor4_to_vec(tensor: &Tensor<NdBackend, 4>) -> (Vec<f32>, Vec<usize>) {
+    let data = tensor.clone().into_data().convert::<f32>();
+    let shape = data.shape.clone();
+    let values = data
+        .to_vec::<f32>()
+        .expect("failed to read aux tensor values");
+    (values, shape)
+}
+
+fn analyze_aux_stage_necks(
+    label_prefix: &str,
+    burn: Option<&Vec<Tensor<NdBackend, 4>>>,
+    reference: &[ReferenceTensor],
+) {
+    if reference.is_empty() {
+        println!("{label_prefix}: reference lacks aux stage tensors; skipping.");
+        return;
+    }
+    match burn {
+        Some(stages) => {
+            for idx in 0..reference.len() {
+                let label = format!("{label_prefix}.stage{idx}");
+                let Some(stage) = stages.get(idx) else {
+                    println!("{label}: model did not emit this stage");
+                    continue;
+                };
+                let (values, shape) = tensor4_to_vec(stage);
+                if values.len() != reference[idx].data.len() {
+                    println!(
+                        "{label}: size mismatch model={} reference={} (model shape {:?}, reference shape {:?})",
+                        values.len(),
+                        reference[idx].data.len(),
+                        shape,
+                        reference[idx].shape
+                    );
+                    continue;
+                }
+                compare_tensors(&label, &values, &reference[idx]);
+            }
+        }
+        None => println!("{label_prefix}: model did not emit aux stage tensors"),
+    }
+}
diff --git a/example/da3_wgpu_loader.rs b/example/da3_wgpu_loader.rs
new file mode 100644
index 0000000..dda9858
--- /dev/null
+++ b/example/da3_wgpu_loader.rs
@@ -0,0 +1,24 @@
+#![recursion_limit = "512"]
+
+use burn::prelude::*;
+use burn::record::{HalfPrecisionSettings, NamedMpkFileRecorder};
+use burn_depth::model::depth_anything3::{
+    DepthAnything3, DepthAnything3Config, with_model_load_stack,
+};
+
+type WgpuBackend = burn::backend::Wgpu<f32>;
+
+fn main() {
+    let device = <WgpuBackend as Backend>::Device::default();
+    let config = DepthAnything3Config::small();
+    println!("constructing Depth Anything 3 (wgpu)...");
+    println!("loading checkpoint...");
+    let recorder = NamedMpkFileRecorder::<HalfPrecisionSettings>::new();
+    let checkpoint = "assets/model/da3_small.mpk";
+    with_model_load_stack(|| {
+        DepthAnything3::<WgpuBackend>::new(&device, config)
+            .load_file(checkpoint, &recorder, &device)
+    })
+    .expect("failed to load checkpoint");
+    println!("load finished.");
+}
diff --git a/example/inference.rs b/example/inference.rs
index 56ebacd..66b9dc1 100644
--- a/example/inference.rs
+++ b/example/inference.rs
@@ -1,39 +1,112 @@
 #![recursion_limit = "256"]
 
-use std::{fs, path::Path};
+use std::{
+    fs,
+    path::{Path, PathBuf},
+};
 
 use burn::prelude::*;
-use burn_depth::{InferenceBackend, inference::infer_from_rgb, model::depth_pro::DepthPro};
+use burn_depth::{
+    InferenceBackend,
+    inference::{DepthPrediction, infer_from_rgb},
+    model::{AnyDepthModel, DepthModelKind, ImageCropRegion, PreparedModelImage},
+};
+use clap::{Parser, ValueEnum};
 use image::GenericImageView;
 
+#[derive(Parser, Debug)]
+#[command(author, version, about = "Run depth inference using Burn checkpoints.")]
+struct Args {
+    #[arg(long, value_enum, default_value_t = ModelArg::DepthPro)]
+    model: ModelArg,
+
+    #[arg(long, value_name = "PATH")]
+    checkpoint: Option<PathBuf>,
+
+    #[arg(long, value_name = "PATH", default_value = "assets/image/test.jpg")]
+    image: PathBuf,
+
+    #[arg(long, value_name = "PATH")]
+    output: Option<PathBuf>,
+}
+
+#[derive(Clone, Copy, Debug, ValueEnum)]
+enum ModelArg {
+    DepthPro,
+    DepthAnything3,
+}
+
+impl From<ModelArg> for DepthModelKind {
+    fn from(value: ModelArg) -> Self {
+        match value {
+            ModelArg::DepthPro => DepthModelKind::DepthPro,
+            ModelArg::DepthAnything3 => DepthModelKind::DepthAnything3,
+        }
+    }
+}
+
 fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args = Args::parse();
     let device = <InferenceBackend as Backend>::Device::default();
+    let kind: DepthModelKind = args.model.into();
 
-    let checkpoint_path = Path::new("assets/model/depth_pro.mpk");
-    if !checkpoint_path.exists() {
+    let checkpoint = args
+        .checkpoint
+        .unwrap_or_else(|| PathBuf::from(kind.default_checkpoint()));
+    if !checkpoint.exists() {
         return Err(format!(
-            "Checkpoint `{}` not found. Run `cargo run --bin import --features import` first.",
-            checkpoint_path.display()
+            "Checkpoint `{}` not found. Provide --checkpoint or run the appropriate importer first.",
+            checkpoint.display()
         )
         .into());
     }
 
-    let model = DepthPro::<InferenceBackend>::load(&device, checkpoint_path)
-        .map_err(|err| format!("Failed to load checkpoint: {err}"))?;
+    let model = AnyDepthModel::load(kind, &device, &checkpoint)?;
 
-    let image_path = Path::new("assets/image/test.jpg");
-    let image = image::open(image_path)
+    let image_path = args.image;
+    let image = image::open(&image_path)
         .map_err(|err| format!("Failed to load image `{}`: {err}", image_path.display()))?;
-
     let (orig_width, orig_height) = image.dimensions();
-    let rgb = image.to_rgb8();
-    let width = orig_width as usize;
-    let height = orig_height as usize;
+    let base_rgb = image.to_rgb8();
+    let PreparedModelImage {
+        width,
+        height,
+        rgb,
+        crop: crop_region,
+    } = model.prepare_input_image(&base_rgb)?;
+
+    let result =
+        infer_from_rgb::<InferenceBackend, _>(&model, rgb.as_raw(), width, height, &device)
+            .map_err(|err| format!("Failed to run inference: {err}"))?;
 
-    let result = infer_from_rgb::<InferenceBackend>(&model, rgb.as_raw(), width, height, &device)
-        .map_err(|err| format!("Failed to run inference: {err}"))?;
+    let restore_dims = if width as u32 != orig_width || height as u32 != orig_height {
+        Some((orig_width as usize, orig_height as usize))
+    } else if crop_region.is_some() {
+        Some((orig_width as usize, orig_height as usize))
+    } else {
+        None
+    };
 
-    let depth_data = result.depth.clone().into_data().convert::<f32>();
+    let depth_path = args
+        .output
+        .unwrap_or_else(|| image_path.with_file_name("depth.png"));
+    save_depth_map(&result, &depth_path, crop_region, restore_dims)?;
+    log_intrinsics(&result);
+    println!(
+        "Model `{}` wrote normalized depth map to {}",
+        kind.as_str(),
+        depth_path.display()
+    );
+    Ok(())
+}
+
+fn save_depth_map<B: Backend>(
+    prediction: &DepthPrediction<B>,
+    output_path: &Path,
+    crop: Option<ImageCropRegion>,
+    target_dims: Option<(usize, usize)>,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let depth_data = prediction.depth.clone().into_data().convert::<f32>();
     let shape = depth_data.shape.clone();
     if shape.len() != 3 {
         return Err(format!("Expected depth tensor with 3 dimensions, got {shape:?}.").into());
@@ -45,18 +118,36 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         return Err(format!("Example expects batch size of 1, got {batch}.").into());
     }
 
-    let values = depth_data
+    let mut values = depth_data
         .to_vec::<f32>()
         .map_err(|err| format!("Failed to read depth tensor values: {err:?}"))?;
+    let mut save_width = width;
+    let mut save_height = height;
+
+    if let Some(region) = crop {
+        values = crop_depth_field(&values, save_width, save_height, region)?;
+        save_width = region.width;
+        save_height = region.height;
+    }
+
+    if let Some((target_width, target_height)) = target_dims {
+        if target_width != save_width || target_height != save_height {
+            values = resize_depth_field(
+                &values,
+                save_width,
+                save_height,
+                target_width,
+                target_height,
+            );
+            save_width = target_width;
+            save_height = target_height;
+        }
+    }
     let (mut min_depth, mut max_depth) = (f32::INFINITY, f32::NEG_INFINITY);
     for &value in &values {
         if value.is_finite() {
-            if value < min_depth {
-                min_depth = value;
-            }
-            if value > max_depth {
-                max_depth = value;
-            }
+            min_depth = min_depth.min(value);
+            max_depth = max_depth.max(value);
         }
     }
     if !min_depth.is_finite() || !max_depth.is_finite() {
@@ -76,34 +167,131 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         })
         .collect();
 
-    let width_u32 = u32::try_from(width)
-        .map_err(|_| format!("Depth width {width} exceeds supported output range"))?;
-    let height_u32 = u32::try_from(height)
-        .map_err(|_| format!("Depth height {height} exceeds supported output range"))?;
+    let width_u32 = u32::try_from(save_width)
+        .map_err(|_| format!("Depth width {save_width} exceeds valid range"))?;
+    let height_u32 = u32::try_from(save_height)
+        .map_err(|_| format!("Depth height {save_height} exceeds valid range"))?;
     let depth_image = image::GrayImage::from_vec(width_u32, height_u32, pixels)
         .ok_or_else(|| format!("Depth tensor size mismatch {shape:?}"))?;
 
-    let output_path = image_path.with_file_name("test_depth.png");
     if let Some(parent) = output_path.parent() {
         fs::create_dir_all(parent)?;
     }
-    depth_image.save(&output_path)?;
+    depth_image.save(output_path)?;
+    Ok(())
+}
 
-    let focal_data = result.focallength_px.clone().into_data().convert::<f32>();
-    let focal_values = focal_data
-        .to_vec::<f32>()
-        .map_err(|err| format!("Failed to read focal length tensor: {err:?}"))?;
-    let fovy_values = result
-        .fovy_rad
-        .clone()
-        .into_data()
-        .convert::<f32>()
-        .to_vec::<f32>()
-        .map_err(|err| format!("Failed to read focal length tensor: {err:?}"))?;
-    println!("depth shape: {:?}", result.depth.shape());
-    println!("focal length (px): {:?}", focal_values);
-    println!("fovy (rad): {:?}", fovy_values);
-    println!("Saved normalized depth map to {}", output_path.display());
+fn resize_depth_field(
+    values: &[f32],
+    src_width: usize,
+    src_height: usize,
+    dst_width: usize,
+    dst_height: usize,
+) -> Vec<f32> {
+    if src_width == dst_width && src_height == dst_height {
+        return values.to_vec();
+    }
+    let mut output = vec![0.0f32; dst_width * dst_height];
+    let scale_x = if dst_width > 1 {
+        src_width as f32 / dst_width as f32
+    } else {
+        0.0
+    };
+    let scale_y = if dst_height > 1 {
+        src_height as f32 / dst_height as f32
+    } else {
+        0.0
+    };
 
-    Ok(())
+    for y in 0..dst_height {
+        let src_y = if dst_height > 1 {
+            (y as f32 + 0.5) * scale_y - 0.5
+        } else {
+            0.0
+        };
+        for x in 0..dst_width {
+            let src_x = if dst_width > 1 {
+                (x as f32 + 0.5) * scale_x - 0.5
+            } else {
+                0.0
+            };
+            output[y * dst_width + x] =
+                sample_depth_bilinear(values, src_width, src_height, src_x, src_y);
+        }
+    }
+
+    output
+}
+
+fn sample_depth_bilinear(values: &[f32], width: usize, height: usize, x: f32, y: f32) -> f32 {
+    if width == 0 || height == 0 {
+        return 0.0;
+    }
+    let clamp = |value: f32, max: usize| -> usize {
+        if max == 0 {
+            0
+        } else {
+            value.clamp(0.0, max as f32) as usize
+        }
+    };
+
+    let x0 = clamp(x.floor(), width - 1);
+    let y0 = clamp(y.floor(), height - 1);
+    let x1 = clamp(x0 as f32 + 1.0, width - 1);
+    let y1 = clamp(y0 as f32 + 1.0, height - 1);
+
+    let fx = x - x0 as f32;
+    let fy = y - y0 as f32;
+
+    let index = |px: usize, py: usize| -> f32 { values[py * width + px] };
+
+    let top = index(x0, y0) * (1.0 - fx) + index(x1, y0) * fx;
+    let bottom = index(x0, y1) * (1.0 - fx) + index(x1, y1) * fx;
+
+    top * (1.0 - fy) + bottom * fy
+}
+
+fn crop_depth_field(
+    values: &[f32],
+    width: usize,
+    height: usize,
+    region: ImageCropRegion,
+) -> Result<Vec<f32>, String> {
+    if region.x + region.width > width || region.y + region.height > height {
+        return Err(format!(
+            "Crop region {:?} exceeds depth tensor bounds {width}x{height}",
+            region
+        ));
+    }
+    let mut output = Vec::with_capacity(region.width * region.height);
+    for row in 0..region.height {
+        let src_y = region.y + row;
+        let start = src_y * width + region.x;
+        output.extend_from_slice(&values[start..start + region.width]);
+    }
+    Ok(output)
+}
+
+fn log_intrinsics<B: Backend>(prediction: &DepthPrediction<B>) {
+    if let Some(focal) = prediction.focallength_px.clone() {
+        let focal_values = focal
+            .into_data()
+            .convert::<f32>()
+            .to_vec::<f32>()
+            .unwrap_or_default();
+        println!("Focal length (px): {:?}", focal_values);
+    } else {
+        println!("Focal length (px): not provided by this model");
+    }
+
+    if let Some(fovy) = prediction.fovy_rad.clone() {
+        let fovy_values = fovy
+            .into_data()
+            .convert::<f32>()
+            .to_vec::<f32>()
+            .unwrap_or_default();
+        println!("Vertical FOV (rad): {:?}", fovy_values);
+    } else {
+        println!("Vertical FOV (rad): not provided by this model");
+    }
 }
diff --git a/src/inference.rs b/src/inference.rs
index 682d498..2791094 100644
--- a/src/inference.rs
+++ b/src/inference.rs
@@ -1,6 +1,63 @@
 use burn::prelude::*;
 
-use crate::model::depth_pro::{DepthPro, DepthProInference};
+use crate::model::{
+    AnyDepthModel,
+    depth_anything3::DepthAnything3,
+    depth_pro::{DepthPro, DepthProInference},
+};
+
+#[derive(Debug, Clone)]
+pub struct DepthPrediction<B: Backend> {
+    pub depth: Tensor<B, 3>,
+    pub focallength_px: Option<Tensor<B, 1>>,
+    pub fovy_rad: Option<Tensor<B, 1>>,
+}
+
+impl<B: Backend> DepthPrediction<B> {
+    pub fn has_intrinsics(&self) -> bool {
+        self.focallength_px.is_some() || self.fovy_rad.is_some()
+    }
+}
+
+pub trait DepthModel<B: Backend> {
+    fn infer_depth(&self, input: Tensor<B, 4>) -> DepthPrediction<B>;
+}
+
+impl<B: Backend> From<DepthProInference<B>> for DepthPrediction<B> {
+    fn from(value: DepthProInference<B>) -> Self {
+        Self {
+            depth: value.depth,
+            focallength_px: Some(value.focallength_px),
+            fovy_rad: Some(value.fovy_rad),
+        }
+    }
+}
+
+impl<B: Backend> DepthModel<B> for DepthPro<B> {
+    fn infer_depth(&self, input: Tensor<B, 4>) -> DepthPrediction<B> {
+        self.infer(input).into()
+    }
+}
+
+impl<B: Backend> DepthModel<B> for DepthAnything3<B> {
+    fn infer_depth(&self, input: Tensor<B, 4>) -> DepthPrediction<B> {
+        let result = self.infer(input);
+        DepthPrediction {
+            depth: result.depth,
+            focallength_px: None,
+            fovy_rad: None,
+        }
+    }
+}
+
+impl<B: Backend> DepthModel<B> for AnyDepthModel<B> {
+    fn infer_depth(&self, input: Tensor<B, 4>) -> DepthPrediction<B> {
+        match self {
+            AnyDepthModel::DepthPro(model) => model.infer_depth(input),
+            AnyDepthModel::DepthAnything3(model) => model.infer_depth(input),
+        }
+    }
+}
 
 /// Converts packed RGB bytes into a normalized tensor suitable for `DepthPro::infer`.
 ///
@@ -57,15 +114,15 @@ pub fn rgb_to_input_tensor<B: Backend>(
 /// This helper combines [`rgb_to_input_tensor`] and [`DepthPro::infer`], making it
 /// convenient to integrate inference in external applications without reimplementing
 /// the preprocessing pipeline.
-pub fn infer_from_rgb<B: Backend>(
-    model: &DepthPro<B>,
+pub fn infer_from_rgb<B: Backend, M: DepthModel<B>>(
+    model: &M,
     rgb: &[u8], // TODO: use an image type here
     width: usize,
     height: usize,
     device: &B::Device,
-) -> Result<DepthProInference<B>, String> {
+) -> Result<DepthPrediction<B>, String> {
     let input = rgb_to_input_tensor::<B>(rgb, width, height, device)?;
-    Ok(model.infer(input))
+    Ok(model.infer_depth(input))
 }
 
 #[cfg(test)]
@@ -97,7 +154,10 @@ mod tests {
         ];
         assert_eq!(values.len(), expected.len());
         for (value, expected) in values.iter().zip(expected.iter()) {
-            assert!((value - expected).abs() < 1e-6);
+            assert!(
+                (value - expected).abs() < 1e-2,
+                "value {value} diverged from expected {expected}"
+            );
         }
     }
 
diff --git a/src/lib.rs b/src/lib.rs
index 0ee50ad..702848f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -3,23 +3,23 @@
 pub mod inference;
 pub mod model;
 
-#[cfg(feature = "backend_cpu")]
-use burn::backend::Cpu;
+#[cfg(feature = "backend_ndarray")]
+use burn::backend::NdArray;
 
 #[cfg(feature = "backend_cuda")]
 use burn::backend::Cuda;
 
-#[cfg(feature = "backend_ndarray")]
-use burn::backend::NdArray;
-
 #[cfg(feature = "backend_cpu")]
-pub type InferenceBackend = Cpu;
+use burn::backend::Cpu;
+
+#[cfg(feature = "backend_ndarray")]
+pub type InferenceBackend = NdArray;
 
 #[cfg(feature = "backend_cuda")]
 pub type InferenceBackend = Cuda;
 
-#[cfg(feature = "backend_ndarray")]
-pub type InferenceBackend = NdArray;
+#[cfg(feature = "backend_cpu")]
+pub type InferenceBackend = Cpu;
 
 #[cfg(test)]
 mod tests {
@@ -32,10 +32,7 @@ mod tests {
     use burn::backend::NdArray as NdArrayBackend;
 
     #[cfg(feature = "backend_wgpu")]
-    use burn::backend::{
-        Wgpu,
-        wgpu::{RuntimeOptions, graphics::AutoGraphicsApi, init_setup},
-    };
+    use burn::backend::wgpu::{RuntimeOptions, graphics::AutoGraphicsApi, init_setup};
 
     use burn::prelude::*;
     use std::any::type_name;
@@ -50,9 +47,9 @@ mod tests {
     use half::f16;
 
     #[cfg(feature = "backend_wgpu")]
-    type WgpuHalfBackend = Wgpu<f16>;
+    type WgpuHalfBackend = burn::backend::Wgpu<f16>;
     #[cfg(feature = "backend_wgpu")]
-    type WgpuF32Backend = Wgpu<f32>;
+    type WgpuF32Backend = burn::backend::Wgpu<f32>;
 
     #[cfg(feature = "backend_wgpu")]
     static WGPU_FEATURES: OnceLock<Result<Features, String>> = OnceLock::new();
diff --git a/src/model/depth_anything3/camera.rs b/src/model/depth_anything3/camera.rs
new file mode 100644
index 0000000..5c087a7
--- /dev/null
+++ b/src/model/depth_anything3/camera.rs
@@ -0,0 +1,536 @@
+use burn::{
+    config::Config,
+    module::Module,
+    nn::{Dropout, DropoutConfig, Gelu, LayerNorm, LayerNormConfig, Linear, LinearConfig},
+    prelude::*,
+    tensor::activation::relu,
+};
+use burn_dino::layers::{
+    block::{Block, BlockConfig},
+    layer_scale::LayerScaleConfig,
+};
+
+#[derive(Config, Debug)]
+pub struct CameraEncoderConfig {
+    pub dim_out: usize,
+    pub dim_in: usize,
+    pub trunk_depth: usize,
+    pub target_dim: usize,
+    pub num_heads: usize,
+    pub mlp_ratio: usize,
+    #[config(default = "0.01")]
+    pub init_values: f32,
+}
+
+impl Default for CameraEncoderConfig {
+    fn default() -> Self {
+        Self {
+            dim_out: 1024,
+            dim_in: 9,
+            trunk_depth: 4,
+            target_dim: 9,
+            num_heads: 16,
+            mlp_ratio: 4,
+            init_values: 0.01,
+        }
+    }
+}
+
+#[derive(Config, Debug)]
+pub struct CameraDecoderConfig {
+    pub dim_in: usize,
+}
+
+impl Default for CameraDecoderConfig {
+    fn default() -> Self {
+        Self { dim_in: 1536 }
+    }
+}
+
+#[derive(Module, Debug)]
+pub struct CameraEncoder<B: Backend> {
+    pose_branch: PoseBranch<B>,
+    trunk: Vec<Block<B>>,
+    token_norm: LayerNorm<B>,
+    trunk_norm: LayerNorm<B>,
+    target_dim: usize,
+}
+
+impl<B: Backend> CameraEncoder<B> {
+    pub fn new(device: &B::Device, config: CameraEncoderConfig) -> Self {
+        let pose_branch = PoseBranch::new(device, config.dim_in, config.dim_out);
+        let mut trunk = Vec::with_capacity(config.trunk_depth);
+        let mut block_config = BlockConfig {
+            attn: burn_dino::layers::attention::AttentionConfig {
+                dim: config.dim_out,
+                num_heads: config.num_heads,
+                ..Default::default()
+            },
+            layer_scale: LayerScaleConfig {
+                dim: config.dim_out,
+            }
+            .into(),
+            mlp_ratio: config.mlp_ratio as f32,
+        };
+        block_config.attn.qkv_bias = true;
+        block_config.attn.quiet_softmax = false;
+        for _ in 0..config.trunk_depth {
+            trunk.push(block_config.init(device));
+        }
+        Self {
+            pose_branch,
+            trunk,
+            token_norm: LayerNormConfig::new(config.dim_out).init(device),
+            trunk_norm: LayerNormConfig::new(config.dim_out).init(device),
+            target_dim: config.target_dim,
+        }
+    }
+
+    pub fn forward(
+        &self,
+        extrinsics: Tensor<B, 4>,
+        intrinsics: Tensor<B, 4>,
+        image_height: usize,
+        image_width: usize,
+    ) -> Tensor<B, 2> {
+        let pose_encoding = extri_intri_to_pose_encoding(
+            extrinsics,
+            intrinsics,
+            image_height,
+            image_width,
+            self.target_dim,
+        );
+        let mut tokens = self.pose_branch.forward(pose_encoding);
+        tokens = self.token_norm.forward(tokens);
+        for block in &self.trunk {
+            tokens = block.forward(tokens.clone(), None, None);
+        }
+        let tokens = self.trunk_norm.forward(tokens);
+        tokens.mean_dim(1).squeeze_dim::<2>(1)
+    }
+}
+
+#[derive(Module, Debug)]
+pub struct CameraDecoder<B: Backend> {
+    backbone_1: Linear<B>,
+    backbone_2: Linear<B>,
+    fc_t: Linear<B>,
+    fc_qvec: Linear<B>,
+    fc_fov: Linear<B>,
+}
+
+impl<B: Backend> CameraDecoder<B> {
+    pub fn new(device: &B::Device, config: CameraDecoderConfig) -> Self {
+        Self {
+            backbone_1: LinearConfig::new(config.dim_in, config.dim_in)
+                .with_bias(true)
+                .init(device),
+            backbone_2: LinearConfig::new(config.dim_in, config.dim_in)
+                .with_bias(true)
+                .init(device),
+            fc_t: LinearConfig::new(config.dim_in, 3)
+                .with_bias(true)
+                .init(device),
+            fc_qvec: LinearConfig::new(config.dim_in, 4)
+                .with_bias(true)
+                .init(device),
+            fc_fov: LinearConfig::new(config.dim_in, 2)
+                .with_bias(true)
+                .init(device),
+        }
+    }
+
+    pub fn forward(
+        &self,
+        features: Tensor<B, 3>,
+        camera_encoding: Option<Tensor<B, 3>>,
+        image_height: usize,
+        image_width: usize,
+    ) -> CameraPrediction<B> {
+        let dims = features.shape().dims::<3>();
+        let batch = dims[0];
+        let views = dims[1];
+        let channels = dims[2];
+        let flattened = features.reshape([batch as i32 * views as i32, channels as i32]);
+        let hidden = relu(
+            self.backbone_2
+                .forward(relu(self.backbone_1.forward(flattened))),
+        );
+
+        let trans = self.fc_t.forward(hidden.clone());
+        let quat = if let Some(encoding) = camera_encoding.as_ref() {
+            encoding
+                .clone()
+                .reshape([
+                    batch as i32 * views as i32,
+                    encoding.shape().dims::<3>()[2] as i32,
+                ])
+                .slice([0..batch as i32 * views as i32, 3..7])
+        } else {
+            self.fc_qvec.forward(hidden.clone())
+        };
+
+        let fov = if let Some(encoding) = camera_encoding.as_ref() {
+            encoding
+                .clone()
+                .reshape([
+                    batch as i32 * views as i32,
+                    encoding.shape().dims::<3>()[2] as i32,
+                ])
+                .slice([
+                    0..batch as i32 * views as i32,
+                    (encoding.shape().dims::<3>()[2] - 2) as i32
+                        ..encoding.shape().dims::<3>()[2] as i32,
+                ])
+        } else {
+            relu(self.fc_fov.forward(hidden.clone()))
+        };
+
+        let pose_encoding =
+            Tensor::cat(vec![trans, quat, fov], 1).reshape([batch as i32, views as i32, 9]);
+        let (extrinsics, intrinsics) =
+            pose_encoding_to_extri_intri(pose_encoding.clone(), image_height, image_width);
+        CameraPrediction {
+            pose_encoding,
+            extrinsics,
+            intrinsics,
+        }
+    }
+}
+
+pub struct CameraPrediction<B: Backend> {
+    pub pose_encoding: Tensor<B, 3>,
+    pub extrinsics: Tensor<B, 4>,
+    pub intrinsics: Tensor<B, 4>,
+}
+
+#[derive(Module, Debug)]
+struct PoseBranch<B: Backend> {
+    fc1: Linear<B>,
+    fc2: Linear<B>,
+    activation: Gelu,
+    drop: Dropout,
+}
+
+impl<B: Backend> PoseBranch<B> {
+    fn new(device: &B::Device, dim_in: usize, dim_out: usize) -> Self {
+        Self {
+            fc1: LinearConfig::new(dim_in, dim_out / 2)
+                .with_bias(true)
+                .init(device),
+            fc2: LinearConfig::new(dim_out / 2, dim_out)
+                .with_bias(true)
+                .init(device),
+            activation: Gelu::new(),
+            drop: DropoutConfig::new(0.0).init(),
+        }
+    }
+
+    fn forward(&self, tensor: Tensor<B, 3>) -> Tensor<B, 3> {
+        let x = self.activation.forward(self.fc1.forward(tensor));
+        self.fc2.forward(self.drop.forward(x))
+    }
+}
+
+fn extri_intri_to_pose_encoding<B: Backend>(
+    extrinsics: Tensor<B, 4>,
+    intrinsics: Tensor<B, 4>,
+    image_height: usize,
+    image_width: usize,
+    target_dim: usize,
+) -> Tensor<B, 3> {
+    let device = extrinsics.device();
+    let dims = extrinsics.shape().dims::<4>();
+    let batch = dims[0];
+    let views = dims[1];
+    let total = (batch * views) as i32;
+
+    let w2c = extrinsics.reshape([total, 3, 4]);
+    let rotation = w2c.clone().slice([0..total, 0..3, 0..3]);
+    let translation = w2c.slice([0..total, 0..3, 3..4]).reshape([total, 3, 1]);
+
+    let c2w_rotation = rotation.clone().permute([0, 2, 1]);
+    let c2w_translation = -c2w_rotation.clone().matmul(translation).squeeze_dim::<2>(2);
+    let quaternion = matrix_to_quaternion(c2w_rotation.clone(), &device);
+
+    let intr = intrinsics.reshape([total, 3, 3]);
+    let fx = intr.clone().slice([0..total, 0..1, 0..1]).reshape([total]);
+    let fy = intr.slice([0..total, 1..2, 1..2]).reshape([total]);
+
+    let width_half = scalar_tensor(total, image_width as f32 / 2.0, &device);
+    let height_half = scalar_tensor(total, image_height as f32 / 2.0, &device);
+    let fov_w = approx_atan_positive(width_half.clone() / fx, &device) * 2.0;
+    let fov_h = approx_atan_positive(height_half.clone() / fy, &device) * 2.0;
+
+    let translation_flat = c2w_translation.clone();
+    let fov_tensor = Tensor::cat(
+        vec![
+            fov_h.clone().reshape([total, 1]),
+            fov_w.clone().reshape([total, 1]),
+        ],
+        1,
+    );
+
+    Tensor::cat(vec![translation_flat, quaternion.clone(), fov_tensor], 1).reshape([
+        batch as i32,
+        views as i32,
+        target_dim as i32,
+    ])
+}
+
+fn pose_encoding_to_extri_intri<B: Backend>(
+    pose: Tensor<B, 3>,
+    image_height: usize,
+    image_width: usize,
+) -> (Tensor<B, 4>, Tensor<B, 4>) {
+    let device = pose.device();
+    let dims = pose.shape().dims::<3>();
+    let batch = dims[0];
+    let views = dims[1];
+    let total = (batch * views) as i32;
+    let flat = pose.clone().reshape([total, 9]);
+
+    let translation = flat.clone().slice([0..total, 0..3]).reshape([total, 3, 1]);
+    let quaternion = flat.clone().slice([0..total, 3..7]);
+    let fov = flat.slice([0..total, 7..9]);
+
+    let rotation = quaternion_to_matrix(quaternion, &device);
+    let rotation_t = rotation.clone().permute([0, 2, 1]);
+    let translation_w2c =
+        (-rotation_t.clone().matmul(translation).squeeze_dim::<2>(2)).unsqueeze_dim::<3>(2);
+    let extrinsics = Tensor::cat(vec![rotation_t, translation_w2c], 2).reshape([
+        batch as i32,
+        views as i32,
+        3,
+        4,
+    ]);
+
+    let fov_h = fov.clone().slice([0..total, 0..1]).reshape([total]);
+    let fov_w = fov.slice([0..total, 1..2]).reshape([total]);
+    let half = scalar_tensor(total, 0.5, &device);
+    let tan_half_h = (fov_h.clone() * half.clone()).sin() / (fov_h.clone() * half.clone()).cos();
+    let tan_half_w = (fov_w.clone() * half.clone()).sin() / (fov_w.clone() * half.clone()).cos();
+    let height_half = scalar_tensor(total, image_height as f32 / 2.0, &device);
+    let width_half = scalar_tensor(total, image_width as f32 / 2.0, &device);
+    let fy = height_half.clone() / tan_half_h;
+    let fx = width_half.clone() / tan_half_w;
+    let zeros = scalar_tensor(total, 0.0, &device);
+    let ones = scalar_tensor(total, 1.0, &device);
+
+    let row0 = Tensor::cat(
+        vec![
+            fx.clone().reshape([total, 1]),
+            zeros.clone().reshape([total, 1]),
+            width_half.clone().reshape([total, 1]),
+        ],
+        1,
+    );
+    let row1 = Tensor::cat(
+        vec![
+            zeros.clone().reshape([total, 1]),
+            fy.clone().reshape([total, 1]),
+            height_half.clone().reshape([total, 1]),
+        ],
+        1,
+    );
+    let row2 = Tensor::cat(
+        vec![
+            zeros.clone().reshape([total, 1]),
+            zeros.clone().reshape([total, 1]),
+            ones.clone().reshape([total, 1]),
+        ],
+        1,
+    );
+
+    let intrinsics = Tensor::cat(
+        vec![
+            row0.clone().unsqueeze_dim::<3>(1),
+            row1.clone().unsqueeze_dim::<3>(1),
+            row2.clone().unsqueeze_dim::<3>(1),
+        ],
+        1,
+    )
+    .reshape([batch as i32, views as i32, 3, 3]);
+
+    (extrinsics, intrinsics)
+}
+
+fn scalar_tensor<B: Backend>(len: i32, value: f32, device: &B::Device) -> Tensor<B, 1> {
+    Tensor::<B, 1>::ones([len], device) * value
+}
+
+fn quaternion_to_matrix<B: Backend>(quat: Tensor<B, 2>, device: &B::Device) -> Tensor<B, 3> {
+    let total = quat.shape().dims::<2>()[0] as i32;
+    let x = quat.clone().slice([0..total, 0..1]).reshape([total]);
+    let y = quat.clone().slice([0..total, 1..2]).reshape([total]);
+    let z = quat.clone().slice([0..total, 2..3]).reshape([total]);
+    let w = quat.slice([0..total, 3..4]).reshape([total]);
+
+    let xx = x.clone() * x.clone();
+    let yy = y.clone() * y.clone();
+    let zz = z.clone() * z.clone();
+    let xy = x.clone() * y.clone();
+    let xz = x.clone() * z.clone();
+    let yz = y.clone() * z.clone();
+    let wx = w.clone() * x.clone();
+    let wy = w.clone() * y.clone();
+    let wz = w.clone() * z.clone();
+
+    let ones = scalar_tensor(total, 1.0, device);
+    let two = ones.clone() * 2.0;
+
+    let row0 = Tensor::cat(
+        vec![
+            (ones.clone() - two.clone() * (yy.clone() + zz.clone())).reshape([total, 1]),
+            (two.clone() * (xy.clone() - wz.clone())).reshape([total, 1]),
+            (two.clone() * (xz.clone() + wy.clone())).reshape([total, 1]),
+        ],
+        1,
+    );
+    let row1 = Tensor::cat(
+        vec![
+            (two.clone() * (xy.clone() + wz.clone())).reshape([total, 1]),
+            (ones.clone() - two.clone() * (xx.clone() + zz.clone())).reshape([total, 1]),
+            (two.clone() * (yz.clone() - wx.clone())).reshape([total, 1]),
+        ],
+        1,
+    );
+    let row2 = Tensor::cat(
+        vec![
+            (two.clone() * (xz.clone() - wy.clone())).reshape([total, 1]),
+            (two.clone() * (yz.clone() + wx.clone())).reshape([total, 1]),
+            (ones.clone() - two.clone() * (xx.clone() + yy.clone())).reshape([total, 1]),
+        ],
+        1,
+    );
+
+    Tensor::cat(
+        vec![
+            row0.clone().unsqueeze_dim::<3>(1),
+            row1.clone().unsqueeze_dim::<3>(1),
+            row2.clone().unsqueeze_dim::<3>(1),
+        ],
+        1,
+    )
+    .reshape([total, 3, 3])
+}
+
+fn matrix_to_quaternion<B: Backend>(rotation: Tensor<B, 3>, device: &B::Device) -> Tensor<B, 2> {
+    let total = rotation.shape().dims::<3>()[0] as i32;
+    let m00 = rotation
+        .clone()
+        .slice([0..total, 0..1, 0..1])
+        .reshape([total]);
+    let m01 = rotation
+        .clone()
+        .slice([0..total, 0..1, 1..2])
+        .reshape([total]);
+    let m02 = rotation
+        .clone()
+        .slice([0..total, 0..1, 2..3])
+        .reshape([total]);
+    let m10 = rotation
+        .clone()
+        .slice([0..total, 1..2, 0..1])
+        .reshape([total]);
+    let m11 = rotation
+        .clone()
+        .slice([0..total, 1..2, 1..2])
+        .reshape([total]);
+    let m12 = rotation
+        .clone()
+        .slice([0..total, 1..2, 2..3])
+        .reshape([total]);
+    let m20 = rotation
+        .clone()
+        .slice([0..total, 2..3, 0..1])
+        .reshape([total]);
+    let m21 = rotation
+        .clone()
+        .slice([0..total, 2..3, 1..2])
+        .reshape([total]);
+    let m22 = rotation.slice([0..total, 2..3, 2..3]).reshape([total]);
+
+    let ones = scalar_tensor(total, 1.0, device);
+    let quarter = ones.clone() * 0.25;
+    let eps = scalar_tensor(total, 1e-6, device);
+
+    let trace = m00.clone() + m11.clone() + m22.clone();
+    let s_trace = ((trace.clone() + ones.clone()).clamp_min(1e-6).sqrt() * 2.0).reshape([total]);
+    let qw_trace = (quarter.clone() * s_trace.clone()).reshape([total, 1]);
+    let qx_trace = ((m21.clone() - m12.clone()) / s_trace.clone()).reshape([total, 1]);
+    let qy_trace = ((m02.clone() - m20.clone()) / s_trace.clone()).reshape([total, 1]);
+    let qz_trace = ((m10.clone() - m01.clone()) / s_trace.clone()).reshape([total, 1]);
+    let quat_trace = Tensor::stack(vec![qx_trace, qy_trace, qz_trace, qw_trace], 1);
+
+    let s_x = ((ones.clone() + m00.clone() - m11.clone() - m22.clone())
+        .clamp_min(1e-6)
+        .sqrt()
+        * 2.0)
+        .reshape([total]);
+    let qx_x = (quarter.clone() * s_x.clone()).reshape([total, 1]);
+    let qw_x = ((m21.clone() - m12.clone()) / (s_x.clone() + eps.clone())).reshape([total, 1]);
+    let qy_x = ((m01.clone() + m10.clone()) / (s_x.clone() + eps.clone())).reshape([total, 1]);
+    let qz_x = ((m02.clone() + m20.clone()) / (s_x.clone() + eps.clone())).reshape([total, 1]);
+    let quat_x = Tensor::stack(vec![qx_x, qy_x, qz_x, qw_x], 1);
+
+    let s_y = ((ones.clone() + m11.clone() - m00.clone() - m22.clone())
+        .clamp_min(1e-6)
+        .sqrt()
+        * 2.0)
+        .reshape([total]);
+    let qy_y = (quarter.clone() * s_y.clone()).reshape([total, 1]);
+    let qw_y = ((m02.clone() - m20.clone()) / (s_y.clone() + eps.clone())).reshape([total, 1]);
+    let qx_y = ((m01.clone() + m10.clone()) / (s_y.clone() + eps.clone())).reshape([total, 1]);
+    let qz_y = ((m12.clone() + m21.clone()) / (s_y.clone() + eps.clone())).reshape([total, 1]);
+    let quat_y = Tensor::stack(vec![qx_y, qy_y, qz_y, qw_y], 1);
+
+    let s_z = ((ones.clone() + m22.clone() - m00.clone() - m11.clone())
+        .clamp_min(1e-6)
+        .sqrt()
+        * 2.0)
+        .reshape([total]);
+    let qz_z = (quarter.clone() * s_z.clone()).reshape([total, 1]);
+    let qw_z = ((m10 - m01) / (s_z.clone() + eps.clone())).reshape([total, 1]);
+    let qx_z = ((m02.clone() + m20.clone()) / (s_z.clone() + eps.clone())).reshape([total, 1]);
+    let qy_z = ((m12.clone() + m21.clone()) / (s_z.clone() + eps.clone())).reshape([total, 1]);
+    let quat_z = Tensor::stack(vec![qx_z, qy_z, qz_z, qw_z], 1);
+
+    let mask_trace = trace.clone().greater_elem(0.0).float();
+    let cond_x =
+        m00.clone().greater(m11.clone()).float() * m00.clone().greater(m22.clone()).float();
+    let mask_x = (ones.clone() - mask_trace.clone()) * cond_x;
+    let cond_y = m11.clone().greater(m22.clone()).float();
+    let mask_y = (ones.clone() - mask_trace.clone() - mask_x.clone()) * cond_y;
+    let mask_z = ones.clone() - mask_trace.clone() - mask_x.clone() - mask_y.clone();
+
+    let mask_trace = mask_trace.reshape([total, 1]);
+    let mask_x = mask_x.reshape([total, 1]);
+    let mask_y = mask_y.reshape([total, 1]);
+    let mask_z = mask_z.reshape([total, 1]);
+
+    quat_trace * mask_trace + quat_x * mask_x + quat_y * mask_y + quat_z * mask_z
+}
+
+fn approx_atan_positive<B: Backend>(x: Tensor<B, 1>, device: &B::Device) -> Tensor<B, 1> {
+    let dims = x.shape().dims::<1>()[0] as i32;
+    let ones = scalar_tensor(dims, 1.0, device);
+    let abs_x = x.clone();
+    let coeff_a = scalar_tensor(dims, 0.2447, device);
+    let coeff_b = scalar_tensor(dims, 0.0663, device);
+    let pi_over_4 = scalar_tensor(dims, core::f32::consts::FRAC_PI_4, device);
+    let pi_over_2 = scalar_tensor(dims, core::f32::consts::FRAC_PI_2, device);
+
+    let approximation = |v: Tensor<B, 1>| {
+        let term = coeff_a.clone() + coeff_b.clone() * v.clone();
+        (pi_over_4.clone() * v.clone()) - v.clone() * (v.clone() - ones.clone()) * term
+    };
+
+    let small = approximation(abs_x.clone());
+    let inv = ones.clone() / abs_x.clone().clamp_min(1e-6);
+    let large = pi_over_2.clone() - approximation(inv);
+
+    let mask_small = abs_x.clone().lower_equal_elem(1.0).float();
+    let mask_large = ones.clone() - mask_small.clone();
+    small * mask_small + large * mask_large
+}
diff --git a/src/model/depth_anything3/dpt.rs b/src/model/depth_anything3/dpt.rs
new file mode 100644
index 0000000..15d1fd3
--- /dev/null
+++ b/src/model/depth_anything3/dpt.rs
@@ -0,0 +1,1248 @@
+use crate::model::depth_anything3::interpolate::resize_bilinear;
+use burn::{
+    config::Config,
+    module::{Ignored, Module},
+    nn::{
+        LayerNorm, LayerNormConfig,
+        conv::{Conv2d, Conv2dConfig, ConvTranspose2d, ConvTranspose2dConfig},
+    },
+    prelude::*,
+    tensor::activation::relu,
+};
+use burn_dino::model::dino::DinoIntermediate;
+
+#[derive(Config, Debug)]
+pub struct DepthAnything3HeadConfig {
+    pub dim_in: usize,
+    pub features: usize,
+    pub out_channels: [usize; 4],
+    pub output_dim: usize,
+    pub activation: HeadActivation,
+    #[config(default = "HeadActivation::ExpP1")]
+    pub conf_activation: HeadActivation,
+    pub down_ratio: usize,
+    #[config(default = "true")]
+    pub pos_embed: bool,
+    #[config(default = "false")]
+    pub dual_head: bool,
+    #[config(default = "4")]
+    pub aux_levels: usize,
+    #[config(default = "5")]
+    pub aux_out1_conv_num: usize,
+    #[config(default = "7")]
+    pub aux_output_dim: usize,
+    #[config(default = "true")]
+    pub aux_use_layer_norm: bool,
+    #[config(default = "None")]
+    pub aux_layer_norm_stages: Option<Vec<usize>>,
+}
+
+impl DepthAnything3HeadConfig {
+    pub fn metric_large() -> Self {
+        Self {
+            dim_in: 1024,
+            features: 256,
+            out_channels: [256, 512, 1024, 1024],
+            output_dim: 1,
+            activation: HeadActivation::Exp,
+            conf_activation: HeadActivation::Exp,
+            down_ratio: 1,
+            pos_embed: true,
+            dual_head: false,
+            aux_levels: 4,
+            aux_out1_conv_num: 5,
+            aux_output_dim: 7,
+            aux_use_layer_norm: true,
+            aux_layer_norm_stages: None,
+        }
+    }
+
+    pub fn small() -> Self {
+        let aux_levels = 4;
+        Self {
+            dim_in: 768,
+            features: 64,
+            out_channels: [48, 96, 192, 384],
+            output_dim: 2,
+            activation: HeadActivation::Exp,
+            conf_activation: HeadActivation::ExpP1,
+            down_ratio: 1,
+            pos_embed: true,
+            dual_head: true,
+            aux_levels,
+            aux_out1_conv_num: 5,
+            aux_output_dim: 7,
+            aux_use_layer_norm: true,
+            aux_layer_norm_stages: Some(vec![0]),
+        }
+    }
+}
+
+fn build_layer_norm_flags(levels: usize, default: bool, custom: Option<&Vec<usize>>) -> Vec<bool> {
+    let mut flags = vec![default; levels];
+    if let Some(indices) = custom
+        && !indices.is_empty()
+    {
+            flags.fill(false);
+            for &idx in indices {
+                if idx < levels {
+                    flags[idx] = true;
+                }
+            }
+    }
+    flags
+}
+
+#[derive(Config, Debug)]
+pub enum HeadActivation {
+    Linear,
+    Exp,
+    ExpP1,
+    ExpM1,
+    Relu,
+    Sigmoid,
+    Softplus,
+    Tanh,
+}
+
+#[allow(clippy::derivable_impls)]
+impl Default for HeadActivation {
+    fn default() -> Self {
+        HeadActivation::Linear
+    }
+}
+
+#[derive(Module, Debug)]
+pub struct DepthAnything3Head<B: Backend> {
+    projects: Vec<Conv2d<B>>,
+    resize_layers: Vec<ResizeOp<B>>,
+    scratch: Scratch<B>,
+    activation: Ignored<HeadActivation>,
+    down_ratio: Ignored<usize>,
+    project_input_dim: Ignored<usize>,
+    pos_embed: bool,
+}
+
+#[derive(Module, Debug)]
+pub struct DualDepthAnything3Head<B: Backend> {
+    norm: LayerNorm<B>,
+    projects: Vec<Conv2d<B>>,
+    resize_layers: Vec<ResizeOp<B>>,
+    scratch: Scratch<B>,
+    activation: Ignored<HeadActivation>,
+    conf_activation: Ignored<HeadActivation>,
+    down_ratio: Ignored<usize>,
+    pos_embed: bool,
+    aux_levels: Ignored<usize>,
+    aux_output_dim: Ignored<usize>,
+    project_input_dim: Ignored<usize>,
+}
+
+pub struct DualHeadOutput<B: Backend> {
+    pub depth_logits: Tensor<B, 4>,
+    pub depth: Tensor<B, 3>,
+    pub depth_confidence: Tensor<B, 3>,
+    pub aux_logits: Tensor<B, 4>,
+    pub aux: Tensor<B, 4>,
+    pub aux_confidence: Tensor<B, 3>,
+    pub aux_stage_necks: Vec<Tensor<B, 4>>,
+    pub aux_head_input: Tensor<B, 4>,
+}
+
+impl<B: Backend> DualDepthAnything3Head<B> {
+    pub fn new(device: &B::Device, config: DepthAnything3HeadConfig) -> Self {
+        let mut projects = Vec::with_capacity(4);
+        for &channels in &config.out_channels {
+            projects.push(
+                Conv2dConfig::new([config.dim_in, channels], [1, 1])
+                    .with_bias(true)
+                    .init(device),
+            );
+        }
+
+        let resize_layers = vec![
+            ResizeOp::conv_transpose(
+                ConvTranspose2dConfig::new(
+                    [config.out_channels[0], config.out_channels[0]],
+                    [4, 4],
+                )
+                .with_stride([4, 4])
+                .with_bias(true)
+                .init(device),
+            ),
+            ResizeOp::conv_transpose(
+                ConvTranspose2dConfig::new(
+                    [config.out_channels[1], config.out_channels[1]],
+                    [2, 2],
+                )
+                .with_stride([2, 2])
+                .with_bias(true)
+                .init(device),
+            ),
+            ResizeOp::identity(),
+            ResizeOp::conv(
+                Conv2dConfig::new([config.out_channels[3], config.out_channels[3]], [3, 3])
+                    .with_padding(burn::nn::PaddingConfig2d::Explicit(1, 1))
+                    .with_stride([2, 2])
+                    .with_bias(true)
+                    .init(device),
+            ),
+        ];
+
+        let aux_config = ScratchAuxConfig {
+            levels: config.aux_levels.max(1),
+            out1_conv_num: config.aux_out1_conv_num.max(1),
+            output_dim: config.aux_output_dim.max(2),
+            layer_norm_flags: build_layer_norm_flags(
+                config.aux_levels.max(1),
+                config.aux_use_layer_norm,
+                config.aux_layer_norm_stages.as_ref(),
+            ),
+        };
+
+        let scratch = Scratch::new(
+            device,
+            &config.out_channels,
+            config.features,
+            config.output_dim,
+            Some(aux_config),
+        );
+
+        Self {
+            norm: LayerNormConfig::new(config.dim_in).init(device),
+            projects,
+            resize_layers,
+            scratch,
+            activation: Ignored(config.activation),
+            conf_activation: Ignored(config.conf_activation),
+            down_ratio: Ignored(config.down_ratio.max(1)),
+            pos_embed: config.pos_embed,
+            aux_levels: Ignored(config.aux_levels.max(1)),
+            aux_output_dim: Ignored(config.aux_output_dim.max(2)),
+            project_input_dim: Ignored(config.dim_in),
+        }
+    }
+
+    pub fn forward_dual(
+        &self,
+        hooks: &[DinoIntermediate<B>],
+        height: usize,
+        width: usize,
+        patch_start_idx: usize,
+        patch_size: usize,
+    ) -> DualHeadOutput<B> {
+        assert!(
+            hooks.len() >= 4,
+            "DualDepthAnything3Head expects at least 4 hook tensors, got {}",
+            hooks.len()
+        );
+        let ph = height / patch_size;
+        let pw = width / patch_size;
+
+        let mut resized = Vec::with_capacity(4);
+        for (stage, hook) in hooks.iter().enumerate().take(4) {
+            let tokens = hook.patches.clone();
+            resized.push(self.prepare_stage(tokens, stage, ph, pw, patch_start_idx, height, width));
+        }
+
+        let fused_main = self.fuse_main(&resized);
+        let main_logits = self.build_main_logits(fused_main, height, width);
+
+        let (aux_logits, aux_stage_necks, aux_head_input) =
+            self.build_aux_logits(&resized, height, width);
+
+        let depth = self.select_main_channel(&main_logits, 0);
+        let depth_confidence = self.select_conf_channel(&main_logits);
+        let aux = self.select_aux_values(&aux_logits);
+        let aux_confidence = self.select_aux_confidence(&aux_logits);
+
+        DualHeadOutput {
+            depth_logits: main_logits,
+            depth,
+            depth_confidence,
+            aux_logits,
+            aux,
+            aux_confidence,
+            aux_stage_necks,
+            aux_head_input,
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn prepare_stage(
+        &self,
+        tokens: Tensor<B, 3>,
+        stage: usize,
+        ph: usize,
+        pw: usize,
+        patch_start_idx: usize,
+        height: usize,
+        width: usize,
+    ) -> Tensor<B, 4> {
+        let dims = tokens.shape().dims::<3>();
+        let batch = dims[0];
+        let mut selected = tokens;
+        if patch_start_idx > 0 {
+            selected = selected.slice([
+                0..batch as i32,
+                patch_start_idx as i32..dims[1] as i32,
+                0..dims[2] as i32,
+            ]);
+        }
+        let normalized = self.norm.forward(selected);
+        let projected = self.projects[stage].forward(normalized.permute([0, 2, 1]).reshape([
+            batch as i32,
+            self.project_input_dim.0 as i32,
+            ph as i32,
+            pw as i32,
+        ]));
+
+        let mut projected = projected;
+        if self.pos_embed {
+            projected = add_position_embedding(projected, width, height);
+        }
+        self.resize_layers[stage].forward(projected)
+    }
+
+    fn fuse_main(&self, features: &[Tensor<B, 4>]) -> Tensor<B, 4> {
+        let l1 = self.scratch.layer1_rn.forward(features[0].clone());
+        let l2 = self.scratch.layer2_rn.forward(features[1].clone());
+        let l3 = self.scratch.layer3_rn.forward(features[2].clone());
+        let l4 = self.scratch.layer4_rn.forward(features[3].clone());
+
+        let mut out = self.scratch.refinenet4.forward(l4, None, Some(hw(&l3)));
+        out = self
+            .scratch
+            .refinenet3
+            .forward(out, Some(l3), Some(hw(&l2)));
+        out = self
+            .scratch
+            .refinenet2
+            .forward(out, Some(l2), Some(hw(&l1)));
+        self.scratch.refinenet1.forward(out, Some(l1), None)
+    }
+
+    fn build_main_logits(&self, fused: Tensor<B, 4>, height: usize, width: usize) -> Tensor<B, 4> {
+        let mut fused = self.scratch.output_conv1.forward(fused);
+        let target = [
+            (height / self.down_ratio.0).max(1),
+            (width / self.down_ratio.0).max(1),
+        ];
+        fused = resize_bilinear(fused, target, true);
+        if self.pos_embed {
+            fused = add_position_embedding(fused, width, height);
+        }
+        self.scratch.output_conv2.forward(fused)
+    }
+
+    fn build_aux_logits(
+        &self,
+        features: &[Tensor<B, 4>],
+        height: usize,
+        width: usize,
+    ) -> (Tensor<B, 4>, Vec<Tensor<B, 4>>, Tensor<B, 4>) {
+        let aux1 = self
+            .scratch
+            .refinenet1_aux
+            .as_ref()
+            .expect("aux refinenet1 missing");
+        let aux2 = self
+            .scratch
+            .refinenet2_aux
+            .as_ref()
+            .expect("aux refinenet2 missing");
+        let aux3 = self
+            .scratch
+            .refinenet3_aux
+            .as_ref()
+            .expect("aux refinenet3 missing");
+        let aux4 = self
+            .scratch
+            .refinenet4_aux
+            .as_ref()
+            .expect("aux refinenet4 missing");
+        let output_conv1_aux = self
+            .scratch
+            .output_conv1_aux
+            .as_ref()
+            .expect("aux pre heads missing");
+        let output_conv2_aux = self
+            .scratch
+            .output_conv2_aux
+            .as_ref()
+            .expect("aux output heads missing");
+
+        let l1 = self.scratch.layer1_rn.forward(features[0].clone());
+        let l2 = self.scratch.layer2_rn.forward(features[1].clone());
+        let l3 = self.scratch.layer3_rn.forward(features[2].clone());
+        let l4 = self.scratch.layer4_rn.forward(features[3].clone());
+
+        let mut aux_out = aux4.forward(l4.clone(), None, Some(hw(&l3)));
+        let mut aux_levels = Vec::with_capacity(self.aux_levels.0);
+        if self.aux_levels.0 >= 4 {
+            aux_levels.push(aux_out.clone());
+        }
+        aux_out = aux3.forward(aux_out, Some(l3), Some(hw(&l2)));
+        if self.aux_levels.0 >= 3 {
+            aux_levels.push(aux_out.clone());
+        }
+        aux_out = aux2.forward(aux_out, Some(l2), Some(hw(&l1)));
+        if self.aux_levels.0 >= 2 {
+            aux_levels.push(aux_out.clone());
+        }
+        aux_out = aux1.forward(aux_out, Some(l1.clone()), None);
+        aux_levels.push(aux_out);
+
+        let mut processed = Vec::with_capacity(aux_levels.len());
+        for (idx, aux) in aux_levels.iter().enumerate() {
+            let neck = output_conv1_aux
+                .get(idx)
+                .expect("missing aux neck")
+                .forward(aux.clone());
+            processed.push(neck);
+        }
+
+        let mut last = processed
+            .last()
+            .cloned()
+            .expect("aux levels must not be empty");
+        if self.pos_embed {
+            last = add_position_embedding(last, width, height);
+        }
+        let head_input = if self.pos_embed {
+            add_position_embedding(last.clone(), width, height)
+        } else {
+            last.clone()
+        };
+        let logits = output_conv2_aux
+            .last()
+            .expect("missing aux output head")
+            .forward(head_input.clone());
+        (logits, processed, head_input)
+    }
+
+    fn select_main_channel(&self, tensor: &Tensor<B, 4>, index: usize) -> Tensor<B, 3> {
+        let dims = tensor.shape().dims::<4>();
+        let channel = tensor
+            .clone()
+            .slice([
+                0..dims[0] as i32,
+                index as i32..index as i32 + 1,
+                0..dims[2] as i32,
+                0..dims[3] as i32,
+            ])
+            .squeeze_dim(1);
+        self.activate_scalar(channel, self.activation.0.clone())
+    }
+
+    fn select_conf_channel(&self, tensor: &Tensor<B, 4>) -> Tensor<B, 3> {
+        let dims = tensor.shape().dims::<4>();
+        let channel = tensor
+            .clone()
+            .slice([
+                0..dims[0] as i32,
+                (dims[1] - 1) as i32..dims[1] as i32,
+                0..dims[2] as i32,
+                0..dims[3] as i32,
+            ])
+            .squeeze_dim(1);
+        self.activate_scalar(channel, self.conf_activation.0.clone())
+    }
+
+    fn select_aux_values(&self, tensor: &Tensor<B, 4>) -> Tensor<B, 4> {
+        let dims = tensor.shape().dims::<4>();
+        tensor.clone().slice([
+            0..dims[0] as i32,
+            0..(self.aux_output_dim.0 - 1) as i32,
+            0..dims[2] as i32,
+            0..dims[3] as i32,
+        ])
+    }
+
+    fn select_aux_confidence(&self, tensor: &Tensor<B, 4>) -> Tensor<B, 3> {
+        let dims = tensor.shape().dims::<4>();
+        let channel = tensor
+            .clone()
+            .slice([
+                0..dims[0] as i32,
+                (self.aux_output_dim.0 - 1) as i32..self.aux_output_dim.0 as i32,
+                0..dims[2] as i32,
+                0..dims[3] as i32,
+            ])
+            .squeeze_dim(1);
+        self.activate_scalar(channel, self.conf_activation.0.clone())
+    }
+
+    fn activate_scalar(&self, tensor: Tensor<B, 3>, kind: HeadActivation) -> Tensor<B, 3> {
+        match kind {
+            HeadActivation::Linear => tensor,
+            HeadActivation::Exp => tensor.exp(),
+            HeadActivation::ExpP1 => tensor.exp().add_scalar(1.0),
+            HeadActivation::ExpM1 => tensor.exp().add_scalar(-1.0),
+            HeadActivation::Relu => relu(tensor),
+            HeadActivation::Sigmoid => {
+                sigmoid_tensor(tensor.clone().unsqueeze_dim::<4>(1)).squeeze_dim::<3>(1)
+            }
+            HeadActivation::Softplus => {
+                (tensor.clone().unsqueeze_dim::<4>(1).exp().add_scalar(1.0))
+                    .log()
+                    .squeeze_dim::<3>(1)
+            }
+            HeadActivation::Tanh => tanh_tensor(tensor.unsqueeze_dim::<4>(1)).squeeze_dim::<3>(1),
+        }
+    }
+}
+
+impl<B: Backend> DepthAnything3Head<B> {
+    pub fn new(device: &B::Device, config: DepthAnything3HeadConfig) -> Self {
+        let mut projects = Vec::with_capacity(4);
+        for &channels in &config.out_channels {
+            projects.push(
+                Conv2dConfig::new([config.dim_in, channels], [1, 1])
+                    .with_bias(true)
+                    .init(device),
+            );
+        }
+
+        let resize_layers = vec![
+            ResizeOp::conv_transpose(
+                ConvTranspose2dConfig::new(
+                    [config.out_channels[0], config.out_channels[0]],
+                    [4, 4],
+                )
+                .with_stride([4, 4])
+                .with_bias(true)
+                .init(device),
+            ),
+            ResizeOp::conv_transpose(
+                ConvTranspose2dConfig::new(
+                    [config.out_channels[1], config.out_channels[1]],
+                    [2, 2],
+                )
+                .with_stride([2, 2])
+                .with_bias(true)
+                .init(device),
+            ),
+            ResizeOp::identity(),
+            ResizeOp::conv(
+                Conv2dConfig::new([config.out_channels[3], config.out_channels[3]], [3, 3])
+                    .with_padding(burn::nn::PaddingConfig2d::Explicit(1, 1))
+                    .with_stride([2, 2])
+                    .with_bias(true)
+                    .init(device),
+            ),
+        ];
+
+        let scratch = Scratch::new(
+            device,
+            &config.out_channels,
+            config.features,
+            config.output_dim,
+            None,
+        );
+        Self {
+            projects,
+            resize_layers,
+            scratch,
+            activation: Ignored(config.activation),
+            down_ratio: Ignored(config.down_ratio.max(1)),
+            project_input_dim: Ignored(config.dim_in),
+            pos_embed: config.pos_embed,
+        }
+    }
+
+    pub fn forward(
+        &self,
+        hooks: &[Tensor<B, 3>],
+        height: usize,
+        width: usize,
+        patch_start_idx: usize,
+        patch_size: usize,
+    ) -> Tensor<B, 3> {
+        let activated = self.forward_raw(hooks, height, width, patch_start_idx, patch_size);
+        self.select_depth_channel(activated)
+    }
+
+    pub fn forward_raw(
+        &self,
+        hooks: &[Tensor<B, 3>],
+        height: usize,
+        width: usize,
+        patch_start_idx: usize,
+        patch_size: usize,
+    ) -> Tensor<B, 4> {
+        assert!(
+            hooks.len() >= 4,
+            "DepthAnything3Head expects at least 4 hook tensors, got {}",
+            hooks.len()
+        );
+        let ph = height / patch_size;
+        let pw = width / patch_size;
+
+        let mut resized = Vec::with_capacity(4);
+        for (stage, hook) in hooks.iter().enumerate().take(4) {
+            let tokens = hook.clone();
+            resized.push(self.prepare_stage(tokens, stage, ph, pw, patch_start_idx, height, width));
+        }
+
+        let fused = self.fuse(resized);
+        let fused = self.scratch.output_conv1.forward(fused);
+        let target = [
+            (ph * patch_size) / self.down_ratio.0,
+            (pw * patch_size) / self.down_ratio.0,
+        ];
+        let mut fused = resize_bilinear(fused, target, true);
+        if self.pos_embed {
+            fused = self.add_pos_embed(fused, width, height);
+        }
+        let logits = self.scratch.output_conv2.forward(fused);
+        self.apply_activation(logits)
+    }
+
+    pub fn select_depth_channel(&self, tensor: Tensor<B, 4>) -> Tensor<B, 3> {
+        let dims = tensor.shape().dims::<4>();
+        if dims[1] == 1 {
+            tensor.squeeze_dim(1)
+        } else {
+            tensor
+                .slice([
+                    0..dims[0] as i32,
+                    0..1,
+                    0..dims[2] as i32,
+                    0..dims[3] as i32,
+                ])
+                .squeeze_dim(1)
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn prepare_stage(
+        &self,
+        tokens: Tensor<B, 3>,
+        stage_idx: usize,
+        ph: usize,
+        pw: usize,
+        patch_start_idx: usize,
+        image_height: usize,
+        image_width: usize,
+    ) -> Tensor<B, 4> {
+        let dims = tokens.shape().dims::<3>();
+        let batch = dims[0];
+        let tokens_per_stage = dims[1];
+        let channels = dims[2];
+        let patch_tokens = ph * pw;
+        let end_idx = patch_start_idx + patch_tokens;
+
+        assert!(
+            tokens_per_stage >= end_idx,
+            "Hook tensor for stage {stage_idx} does not have enough patch tokens"
+        );
+        debug_assert_eq!(
+            tokens_per_stage,
+            patch_start_idx + patch_tokens,
+            "Unexpected token count at stage {stage_idx}"
+        );
+
+        let x = tokens.slice([0..batch, patch_start_idx..end_idx, 0..channels]);
+        let x = self.apply_token_norm(x);
+
+        let x = x
+            .permute([0, 2, 1])
+            .reshape([batch as i32, channels as i32, ph as i32, pw as i32]);
+        let x = ensure_channels(x, self.project_input_dim.0);
+        let mut x = self.projects[stage_idx].forward(x);
+        if self.pos_embed {
+            x = self.add_pos_embed(x, image_width, image_height);
+        }
+        self.resize_layers[stage_idx].forward(x)
+    }
+
+    fn fuse(&self, feats: Vec<Tensor<B, 4>>) -> Tensor<B, 4> {
+        let mut it = feats.into_iter();
+        let l1 = it.next().expect("missing l1");
+        let l2 = it.next().expect("missing l2");
+        let l3 = it.next().expect("missing l3");
+        let l4 = it.next().expect("missing l4");
+
+        let l1_rn = self.scratch.layer1_rn.forward(l1);
+        let l2_rn = self.scratch.layer2_rn.forward(l2);
+        let l3_rn = self.scratch.layer3_rn.forward(l3);
+        let l4_rn = self.scratch.layer4_rn.forward(l4);
+
+        let mut out = self
+            .scratch
+            .refinenet4
+            .forward(l4_rn.clone(), None, Some(hw(&l3_rn)));
+        out = self
+            .scratch
+            .refinenet3
+            .forward(out, Some(l3_rn.clone()), Some(hw(&l2_rn)));
+        out = self
+            .scratch
+            .refinenet2
+            .forward(out, Some(l2_rn.clone()), Some(hw(&l1_rn)));
+        self.scratch.refinenet1.forward(out, Some(l1_rn), None)
+    }
+
+    fn apply_activation(&self, tensor: Tensor<B, 4>) -> Tensor<B, 4> {
+        match self.activation.0 {
+            HeadActivation::Linear => tensor,
+            HeadActivation::Exp => tensor.exp(),
+            HeadActivation::ExpP1 => tensor.exp().add_scalar(1.0),
+            HeadActivation::ExpM1 => tensor.exp().add_scalar(-1.0),
+            HeadActivation::Relu => relu(tensor),
+            HeadActivation::Sigmoid => sigmoid_tensor(tensor),
+            HeadActivation::Softplus => (tensor.exp().add_scalar(1.0)).log(),
+            HeadActivation::Tanh => tanh_tensor(tensor),
+        }
+    }
+}
+
+fn hw<B: Backend>(tensor: &Tensor<B, 4>) -> [usize; 2] {
+    let dims = tensor.shape().dims::<4>();
+    [dims[2], dims[3]]
+}
+
+fn ensure_channels<B: Backend>(input: Tensor<B, 4>, desired: usize) -> Tensor<B, 4> {
+    let dims = input.shape().dims::<4>();
+    let current = dims[1];
+    if current == desired {
+        return input;
+    }
+
+    if current > desired {
+        return input.slice([
+            0..dims[0] as i32,
+            0..desired as i32,
+            0..dims[2] as i32,
+            0..dims[3] as i32,
+        ]);
+    }
+
+    let pad = desired - current;
+    let device = input.device();
+    let zeros = Tensor::<B, 4>::zeros(
+        [dims[0] as i32, pad as i32, dims[2] as i32, dims[3] as i32],
+        &device,
+    );
+
+    Tensor::cat(vec![input, zeros], 1)
+}
+
+impl<B: Backend> DepthAnything3Head<B> {
+    fn apply_token_norm(&self, tokens: Tensor<B, 3>) -> Tensor<B, 3> {
+        let (var, mean) = tokens.clone().var_mean_bias(2);
+        tokens.sub(mean).div(var.add_scalar(TOKEN_NORM_EPS).sqrt())
+    }
+
+    fn add_pos_embed(
+        &self,
+        tensor: Tensor<B, 4>,
+        image_width: usize,
+        image_height: usize,
+    ) -> Tensor<B, 4> {
+        if !self.pos_embed {
+            return tensor;
+        }
+        add_position_embedding(tensor, image_width, image_height)
+    }
+}
+
+const TOKEN_NORM_EPS: f32 = 1e-5;
+const POS_EMBED_RATIO: f32 = 0.1;
+const POS_EMBED_OMEGA0: f32 = 100.0;
+
+fn build_positional_embedding(
+    channels: usize,
+    height: usize,
+    width: usize,
+    image_width: usize,
+    image_height: usize,
+) -> Vec<f32> {
+    if channels == 0 {
+        return vec![];
+    }
+    let aspect_ratio = image_width as f32 / image_height as f32;
+    let diag_factor = (aspect_ratio * aspect_ratio + 1.0).sqrt();
+    let span_x = aspect_ratio / diag_factor;
+    let span_y = 1.0 / diag_factor;
+
+    let left_x = -span_x * (width as f32 - 1.0) / width as f32;
+    let right_x = span_x * (width as f32 - 1.0) / width as f32;
+    let top_y = -span_y * (height as f32 - 1.0) / height as f32;
+    let bottom_y = span_y * (height as f32 - 1.0) / height as f32;
+
+    let x_coords = linspace(left_x, right_x, width);
+    let y_coords = linspace(top_y, bottom_y, height);
+
+    let mut chw = vec![0.0f32; height * width * channels];
+    let x_channels = channels / 2;
+    let y_channels = channels - x_channels;
+
+    let embed_x_table: Vec<Vec<f32>> = x_coords
+        .iter()
+        .map(|&x| make_sincos_embedding(x_channels, x))
+        .collect();
+    let embed_y_table: Vec<Vec<f32>> = y_coords
+        .iter()
+        .map(|&y| make_sincos_embedding(y_channels, y))
+        .collect();
+
+    for (x_idx, embed_x) in embed_x_table.iter().enumerate() {
+        for (y_idx, embed_y) in embed_y_table.iter().enumerate() {
+            let pixel_index = x_idx * height + y_idx;
+            for (i, &value) in embed_x.iter().enumerate() {
+                let channel = i;
+                let dst = channel * height * width + pixel_index;
+                chw[dst] = value;
+            }
+            for (i, &value) in embed_y.iter().enumerate() {
+                let channel = x_channels + i;
+                let dst = channel * height * width + pixel_index;
+                chw[dst] = value;
+            }
+        }
+    }
+
+    chw
+}
+
+fn add_position_embedding<B: Backend>(
+    tensor: Tensor<B, 4>,
+    image_width: usize,
+    image_height: usize,
+) -> Tensor<B, 4> {
+    let dims = tensor.shape().dims::<4>();
+    let batch = dims[0];
+    let channels = dims[1];
+    let height = dims[2];
+    let width = dims[3];
+    let embedding = build_positional_embedding(channels, height, width, image_width, image_height);
+    let mut repeated = Vec::with_capacity(embedding.len() * batch);
+    for _ in 0..batch {
+        repeated.extend_from_slice(&embedding);
+    }
+    let device = tensor.device();
+    let embed_tensor = Tensor::<B, 1>::from_floats(repeated.as_slice(), &device).reshape([
+        batch as i32,
+        channels as i32,
+        height as i32,
+        width as i32,
+    ]);
+    let expanded = embed_tensor.expand(tensor.shape());
+    tensor + expanded.mul_scalar(POS_EMBED_RATIO)
+}
+
+fn linspace(start: f32, end: f32, steps: usize) -> Vec<f32> {
+    if steps <= 1 {
+        return vec![start];
+    }
+    let step = (end - start) / (steps as f32 - 1.0);
+    (0..steps).map(|i| start + step * i as f32).collect()
+}
+
+fn make_sincos_embedding(dim: usize, position: f32) -> Vec<f32> {
+    if dim == 0 {
+        return Vec::new();
+    }
+    let half = dim / 2;
+    let mut values = Vec::with_capacity(dim);
+    for i in 0..half {
+        let exponent = if half > 0 {
+            i as f32 / half as f32
+        } else {
+            0.0
+        };
+        let omega = POS_EMBED_OMEGA0.powf(-exponent);
+        let input = position * omega;
+        values.push(input.sin());
+    }
+    let remaining = dim - half;
+    for i in 0..remaining {
+        let exponent = if remaining > 0 {
+            i as f32 / remaining as f32
+        } else {
+            0.0
+        };
+        let omega = POS_EMBED_OMEGA0.powf(-exponent);
+        let input = position * omega;
+        values.push(input.cos());
+    }
+    values
+}
+
+#[derive(Module, Debug)]
+struct ResizeOp<B: Backend> {
+    conv_t: Option<ConvTranspose2d<B>>,
+    conv: Option<Conv2d<B>>,
+}
+
+impl<B: Backend> ResizeOp<B> {
+    fn identity() -> Self {
+        Self {
+            conv_t: None,
+            conv: None,
+        }
+    }
+
+    fn conv_transpose(layer: ConvTranspose2d<B>) -> Self {
+        Self {
+            conv_t: Some(layer),
+            conv: None,
+        }
+    }
+
+    fn conv(layer: Conv2d<B>) -> Self {
+        Self {
+            conv_t: None,
+            conv: Some(layer),
+        }
+    }
+
+    fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 4> {
+        if let Some(layer) = &self.conv_t {
+            layer.forward(x)
+        } else if let Some(layer) = &self.conv {
+            layer.forward(x)
+        } else {
+            x
+        }
+    }
+}
+
+#[derive(Module, Debug, Clone)]
+struct ScratchAuxConfig {
+    levels: usize,
+    out1_conv_num: usize,
+    output_dim: usize,
+    layer_norm_flags: Vec<bool>,
+}
+
+#[derive(Module, Debug)]
+struct Scratch<B: Backend> {
+    layer1_rn: Conv2d<B>,
+    layer2_rn: Conv2d<B>,
+    layer3_rn: Conv2d<B>,
+    layer4_rn: Conv2d<B>,
+    refinenet1: FeatureFusionBlock<B>,
+    refinenet2: FeatureFusionBlock<B>,
+    refinenet3: FeatureFusionBlock<B>,
+    refinenet4: FeatureFusionBlock<B>,
+    output_conv1: Conv2d<B>,
+    output_conv2: ConvStack<B>,
+    refinenet1_aux: Option<FeatureFusionBlock<B>>,
+    refinenet2_aux: Option<FeatureFusionBlock<B>>,
+    refinenet3_aux: Option<FeatureFusionBlock<B>>,
+    refinenet4_aux: Option<FeatureFusionBlock<B>>,
+    output_conv1_aux: Option<Vec<AuxPreHead<B>>>,
+    output_conv2_aux: Option<Vec<AuxOutputHead<B>>>,
+    aux_levels: usize,
+}
+
+impl<B: Backend> Scratch<B> {
+    fn new(
+        device: &B::Device,
+        in_channels: &[usize; 4],
+        base_features: usize,
+        output_dim: usize,
+        aux_config: Option<ScratchAuxConfig>,
+    ) -> Self {
+        let refinenet1 = FeatureFusionBlock::new(device, base_features, true);
+        let refinenet2 = FeatureFusionBlock::new(device, base_features, true);
+        let refinenet3 = FeatureFusionBlock::new(device, base_features, true);
+        let refinenet4 = FeatureFusionBlock::new(device, base_features, false);
+
+        let (
+            refinenet1_aux,
+            refinenet2_aux,
+            refinenet3_aux,
+            refinenet4_aux,
+            output_conv1_aux,
+            output_conv2_aux,
+            aux_levels,
+        ) = if let Some(config) = aux_config {
+            let aux1 = FeatureFusionBlock::new(device, base_features, true);
+            let aux2 = FeatureFusionBlock::new(device, base_features, true);
+            let aux3 = FeatureFusionBlock::new(device, base_features, true);
+            let aux4 = FeatureFusionBlock::new(device, base_features, false);
+            let mut pre_heads = Vec::with_capacity(config.levels);
+            for _ in 0..config.levels {
+                pre_heads.push(AuxPreHead::new(device, base_features, config.out1_conv_num));
+            }
+
+            let mut output_heads = Vec::with_capacity(config.levels);
+            for idx in 0..config.levels {
+                let use_ln = config.layer_norm_flags.get(idx).copied().unwrap_or(false);
+                output_heads.push(AuxOutputHead::new(
+                    device,
+                    base_features / 2,
+                    32,
+                    config.output_dim,
+                    use_ln,
+                ));
+            }
+
+            (
+                Some(aux1),
+                Some(aux2),
+                Some(aux3),
+                Some(aux4),
+                Some(pre_heads),
+                Some(output_heads),
+                config.levels,
+            )
+        } else {
+            (None, None, None, None, None, None, 0)
+        };
+
+        Self {
+            layer1_rn: conv3x3(device, in_channels[0], base_features),
+            layer2_rn: conv3x3(device, in_channels[1], base_features),
+            layer3_rn: conv3x3(device, in_channels[2], base_features),
+            layer4_rn: conv3x3(device, in_channels[3], base_features),
+            refinenet1,
+            refinenet2,
+            refinenet3,
+            refinenet4,
+            output_conv1: Conv2dConfig::new([base_features, base_features / 2], [3, 3])
+                .with_padding(burn::nn::PaddingConfig2d::Explicit(1, 1))
+                .with_bias(true)
+                .init(device),
+            output_conv2: ConvStack::new(device, base_features / 2, output_dim, 32),
+            refinenet1_aux,
+            refinenet2_aux,
+            refinenet3_aux,
+            refinenet4_aux,
+            output_conv1_aux,
+            output_conv2_aux,
+            aux_levels,
+        }
+    }
+}
+
+#[derive(Module, Debug)]
+struct AuxPreHead<B: Backend> {
+    layers: Vec<Conv2d<B>>,
+}
+
+impl<B: Backend> AuxPreHead<B> {
+    fn new(device: &B::Device, channels: usize, count: usize) -> Self {
+        let mut layers = Vec::with_capacity(count);
+        let mut in_ch = channels;
+        for idx in 0..count {
+            let out_ch = if idx % 2 == 0 { channels / 2 } else { channels };
+            layers.push(
+                Conv2dConfig::new([in_ch, out_ch], [3, 3])
+                    .with_padding(burn::nn::PaddingConfig2d::Explicit(1, 1))
+                    .with_bias(true)
+                    .init(device),
+            );
+            in_ch = out_ch;
+        }
+        Self { layers }
+    }
+
+    fn forward(&self, input: Tensor<B, 4>) -> Tensor<B, 4> {
+        let mut x = input;
+        for conv in &self.layers {
+            x = conv.forward(x);
+        }
+        x
+    }
+}
+
+#[derive(Module, Debug)]
+struct LayerNorm2d<B: Backend> {
+    layer_norm: LayerNorm<B>,
+}
+
+impl<B: Backend> LayerNorm2d<B> {
+    fn new(device: &B::Device, channels: usize) -> Self {
+        let layer_norm: LayerNorm<B> = LayerNormConfig::new(channels).init(device);
+        Self { layer_norm }
+    }
+
+    fn forward(&self, input: Tensor<B, 4>) -> Tensor<B, 4> {
+        let dims = input.shape().dims::<4>();
+        let reshaped = input
+            .clone()
+            .permute([0, 2, 3, 1])
+            .reshape([(dims[0] * dims[2] * dims[3]) as i32, dims[1] as i32]);
+        let normalized = self.layer_norm.forward(reshaped);
+        normalized
+            .reshape([
+                dims[0] as i32,
+                dims[2] as i32,
+                dims[3] as i32,
+                dims[1] as i32,
+            ])
+            .permute([0, 3, 1, 2])
+    }
+}
+
+#[derive(Module, Debug)]
+struct AuxOutputHead<B: Backend> {
+    reduce: Conv2d<B>,
+    norm: Option<LayerNorm2d<B>>,
+    project: Conv2d<B>,
+}
+
+impl<B: Backend> AuxOutputHead<B> {
+    fn new(
+        device: &B::Device,
+        in_channels: usize,
+        mid_channels: usize,
+        out_channels: usize,
+        use_layer_norm: bool,
+    ) -> Self {
+        let reduce = Conv2dConfig::new([in_channels, mid_channels], [3, 3])
+            .with_padding(burn::nn::PaddingConfig2d::Explicit(1, 1))
+            .with_bias(true)
+            .init(device);
+        let norm = if use_layer_norm {
+            Some(LayerNorm2d::new(device, mid_channels))
+        } else {
+            None
+        };
+        let project = Conv2dConfig::new([mid_channels, out_channels], [1, 1])
+            .with_bias(true)
+            .init(device);
+
+        Self {
+            reduce,
+            norm,
+            project,
+        }
+    }
+
+    fn forward(&self, input: Tensor<B, 4>) -> Tensor<B, 4> {
+        let mut x = self.reduce.forward(input);
+        if let Some(norm) = &self.norm {
+            x = norm.forward(x);
+        }
+        x = relu(x);
+        self.project.forward(x)
+    }
+}
+
+#[derive(Module, Debug)]
+struct FeatureFusionBlock<B: Backend> {
+    residual1: Option<ResidualConvUnit<B>>,
+    residual2: ResidualConvUnit<B>,
+    out_conv: Conv2d<B>,
+}
+
+impl<B: Backend> FeatureFusionBlock<B> {
+    fn new(device: &B::Device, channels: usize, has_residual: bool) -> Self {
+        let residual1 = if has_residual {
+            Some(ResidualConvUnit::new(device, channels))
+        } else {
+            None
+        };
+        Self {
+            residual1,
+            residual2: ResidualConvUnit::new(device, channels),
+            out_conv: Conv2dConfig::new([channels, channels], [1, 1])
+                .with_bias(true)
+                .init(device),
+        }
+    }
+
+    fn forward(
+        &self,
+        top: Tensor<B, 4>,
+        lateral: Option<Tensor<B, 4>>,
+        size: Option<[usize; 2]>,
+    ) -> Tensor<B, 4> {
+        let mut y = top;
+        if let (Some(residual), Some(lat)) = (&self.residual1, lateral) {
+            y = y + residual.forward(lat);
+        }
+
+        y = self.residual2.forward(y);
+        let current_hw = hw(&y);
+        let target = size.unwrap_or([current_hw[0] * 2, current_hw[1] * 2]);
+        y = resize_bilinear(y, target, true);
+        self.out_conv.forward(y)
+    }
+}
+
+#[derive(Module, Debug)]
+struct ResidualConvUnit<B: Backend> {
+    conv1: Conv2d<B>,
+    conv2: Conv2d<B>,
+}
+
+impl<B: Backend> ResidualConvUnit<B> {
+    fn new(device: &B::Device, channels: usize) -> Self {
+        let conv = |in_ch, out_ch| {
+            Conv2dConfig::new([in_ch, out_ch], [3, 3])
+                .with_padding(burn::nn::PaddingConfig2d::Explicit(1, 1))
+                .with_bias(true)
+                .init(device)
+        };
+
+        Self {
+            conv1: conv(channels, channels),
+            conv2: conv(channels, channels),
+        }
+    }
+
+    fn forward(&self, input: Tensor<B, 4>) -> Tensor<B, 4> {
+        let x = self.conv1.forward(relu(input.clone()));
+        let x = self.conv2.forward(relu(x));
+        x + input
+    }
+}
+
+#[derive(Module, Debug)]
+struct ConvStack<B: Backend> {
+    conv1: Conv2d<B>,
+    conv2: Conv2d<B>,
+}
+
+impl<B: Backend> ConvStack<B> {
+    fn new(
+        device: &B::Device,
+        in_channels: usize,
+        out_channels: usize,
+        mid_channels: usize,
+    ) -> Self {
+        let conv1 = Conv2dConfig::new([in_channels, mid_channels], [3, 3])
+            .with_padding(burn::nn::PaddingConfig2d::Explicit(1, 1))
+            .with_bias(true)
+            .init(device);
+        let conv2 = Conv2dConfig::new([mid_channels, out_channels], [1, 1])
+            .with_bias(true)
+            .init(device);
+        Self { conv1, conv2 }
+    }
+
+    fn forward(&self, input: Tensor<B, 4>) -> Tensor<B, 4> {
+        let x = relu(self.conv1.forward(input));
+        self.conv2.forward(x)
+    }
+}
+
+fn conv3x3<B: Backend>(device: &B::Device, in_channels: usize, out_channels: usize) -> Conv2d<B> {
+    Conv2dConfig::new([in_channels, out_channels], [3, 3])
+        .with_padding(burn::nn::PaddingConfig2d::Explicit(1, 1))
+        .with_bias(false)
+        .init(device)
+}
+
+fn sigmoid_tensor<B: Backend>(tensor: Tensor<B, 4>) -> Tensor<B, 4> {
+    tensor
+        .clone()
+        .mul_scalar(-1.0)
+        .exp()
+        .add_scalar(1.0)
+        .recip()
+}
+
+fn tanh_tensor<B: Backend>(tensor: Tensor<B, 4>) -> Tensor<B, 4> {
+    let exp = tensor.clone().mul_scalar(2.0).exp();
+    let ones = exp.clone().ones_like();
+    let numerator = exp.clone() - ones.clone();
+    numerator / (exp + ones)
+}
diff --git a/src/model/depth_anything3/interpolate.rs b/src/model/depth_anything3/interpolate.rs
new file mode 100644
index 0000000..d4dab80
--- /dev/null
+++ b/src/model/depth_anything3/interpolate.rs
@@ -0,0 +1,47 @@
+use burn::{
+    nn::interpolate::{Interpolate2dConfig, InterpolateMode},
+    prelude::*,
+    tensor::Tensor,
+};
+
+pub fn resize_bilinear<B: Backend>(
+    input: Tensor<B, 4>,
+    output_size: [usize; 2],
+    _align_corners: bool,
+) -> Tensor<B, 4> {
+    let dims = input.shape().dims::<4>();
+    let batch = dims[0];
+    let channels = dims[1];
+    let in_height = dims[2];
+    let in_width = dims[3];
+    let device = input.device();
+
+    let contiguous = Tensor::<B, 4>::zeros(
+        [
+            batch as i32,
+            channels as i32,
+            in_height as i32,
+            in_width as i32,
+        ],
+        &device,
+    )
+    .slice_assign(
+        [
+            0..batch as i32,
+            0..channels as i32,
+            0..in_height as i32,
+            0..in_width as i32,
+        ],
+        input.clone(),
+    );
+
+    if [in_height, in_width] == output_size {
+        return contiguous;
+    }
+
+    Interpolate2dConfig::new()
+        .with_output_size(Some(output_size))
+        .with_mode(InterpolateMode::Linear)
+        .init()
+        .forward(contiguous)
+}
diff --git a/src/model/depth_anything3/mod.rs b/src/model/depth_anything3/mod.rs
new file mode 100644
index 0000000..57c5684
--- /dev/null
+++ b/src/model/depth_anything3/mod.rs
@@ -0,0 +1,516 @@
+use burn::{
+    module::{Ignored, Module},
+    prelude::*,
+};
+use burn_dino::model::dino::{
+    DinoIntermediate, DinoVisionTransformer, DinoVisionTransformerConfig,
+};
+
+use camera::{CameraDecoder, CameraEncoder, CameraPrediction};
+mod camera;
+mod dpt;
+mod interpolate;
+
+pub use camera::{CameraDecoderConfig, CameraEncoderConfig};
+pub use dpt::{
+    DepthAnything3Head, DepthAnything3HeadConfig, DualDepthAnything3Head, DualHeadOutput,
+    HeadActivation,
+};
+
+mod stack_guard {
+    #[cfg(not(target_arch = "wasm32"))]
+    use stacker::maybe_grow;
+
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn with_model_load_stack<R>(f: impl FnOnce() -> R) -> R {
+        // Windows threads default to a 1MB stack which isn't enough for DepthAnything3's
+        // checkpoint load graph on the WGPU backend. Borrow a larger stack temporarily
+        // so Module::load_record can recurse safely.
+        const STACK_SIZE: usize = 32 * 1024 * 1024;
+        const RED_ZONE: usize = 2 * 1024 * 1024;
+        maybe_grow(STACK_SIZE, RED_ZONE, f)
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    pub fn with_model_load_stack<R>(f: impl FnOnce() -> R) -> R {
+        f()
+    }
+}
+
+pub use stack_guard::with_model_load_stack;
+
+#[derive(Config, Debug)]
+pub struct DepthAnything3Config {
+    pub image_size: usize,
+    pub patch_size: usize,
+    pub hook_block_ids: Vec<usize>,
+    pub head: DepthAnything3HeadConfig,
+    #[config(default = "None")]
+    pub camera_encoder: Option<CameraEncoderConfig>,
+    #[config(default = "None")]
+    pub camera_decoder: Option<CameraDecoderConfig>,
+
+    #[config(default = "None")]
+    pub checkpoint_uri: Option<String>,
+}
+
+impl Default for DepthAnything3Config {
+    fn default() -> Self {
+        Self {
+            image_size: 518,
+            patch_size: 14,
+            hook_block_ids: vec![4, 11, 17, 23],
+            head: DepthAnything3HeadConfig::metric_large(),
+            camera_encoder: None,
+            camera_decoder: None,
+            checkpoint_uri: Some("assets/model/da3_metric_large.mpk".to_string()),
+        }
+    }
+}
+
+impl DepthAnything3Config {
+    pub fn metric_large() -> Self {
+        Self::default()
+    }
+
+    pub fn small() -> Self {
+        Self {
+            image_size: 518,
+            patch_size: 14,
+            hook_block_ids: vec![5, 7, 9, 11],
+            head: DepthAnything3HeadConfig::small(),
+            camera_encoder: Some(CameraEncoderConfig {
+                dim_out: 384,
+                ..CameraEncoderConfig::default()
+            }),
+            camera_decoder: Some(CameraDecoderConfig { dim_in: 768 }),
+            checkpoint_uri: Some("assets/model/da3_small.mpk".to_string()),
+        }
+    }
+}
+
+#[derive(Module, Debug)]
+struct Backbone<B: Backend> {
+    pretrained: DinoVisionTransformer<B>,
+}
+
+impl<B: Backend> Backbone<B> {
+    fn new(device: &B::Device, config: &DepthAnything3Config) -> Self {
+        let mut vit_config = if config.head.dim_in >= 1024 {
+            DinoVisionTransformerConfig::vitl(Some(config.image_size), Some(config.patch_size))
+        } else {
+            DinoVisionTransformerConfig::vits(Some(config.image_size), Some(config.patch_size))
+        };
+        vit_config.register_token_count = 0;
+        vit_config.use_register_tokens = false;
+        vit_config.use_mask_token = false;
+        vit_config.block_config.attn.quiet_softmax = false;
+        if config.head.dual_head {
+            vit_config.alt_block_start = Some(4);
+            vit_config.qk_norm_block_start = Some(4);
+            vit_config.rope_block_start = Some(4);
+            vit_config.cat_token = true;
+            vit_config.use_camera_tokens = true;
+        }
+        Self {
+            pretrained: vit_config.init(device),
+        }
+    }
+
+    fn forward_with_hooks(
+        &self,
+        input: Tensor<B, 4>,
+        hook_blocks: &[usize],
+        camera_token: Option<Tensor<B, 2>>,
+    ) -> (Tensor<B, 3>, Vec<DinoIntermediate<B>>) {
+        let (output, hooks, _) = self.pretrained.forward_with_intermediate_tokens_ext(
+            input,
+            hook_blocks,
+            &[],
+            camera_token,
+        );
+        (output.x_norm_patchtokens, hooks)
+    }
+}
+
+#[derive(Module, Debug)]
+pub struct DepthAnything3<B: Backend> {
+    backbone: Backbone<B>,
+    head_mono: Option<DepthAnything3Head<B>>,
+    head_dual: Option<DualDepthAnything3Head<B>>,
+    camera_encoder: Option<CameraEncoder<B>>,
+    camera_decoder: Option<CameraDecoder<B>>,
+    img_size: Ignored<usize>,
+    patch_size: Ignored<usize>,
+    hook_block_ids: Ignored<Vec<usize>>,
+    patch_token_start: Ignored<usize>,
+}
+
+pub struct DepthAnything3Inference<B: Backend> {
+    pub depth: Tensor<B, 3>,
+    pub depth_confidence: Option<Tensor<B, 3>>,
+    pub aux: Option<Tensor<B, 4>>,
+    pub aux_confidence: Option<Tensor<B, 3>>,
+    pub pose_encoding: Option<Tensor<B, 3>>,
+    pub extrinsics: Option<Tensor<B, 4>>,
+    pub intrinsics: Option<Tensor<B, 4>>,
+}
+
+pub struct DepthTrace<B: Backend> {
+    pub backbone_tokens: Vec<Tensor<B, 3>>,
+    pub aux_stage_necks: Option<Vec<Tensor<B, 4>>>,
+    pub aux_logits: Option<Tensor<B, 4>>,
+    pub aux_head_input: Option<Tensor<B, 4>>,
+}
+
+enum HeadForwardOutput<B: Backend> {
+    Mono(Tensor<B, 4>),
+    Dual(DualHeadOutput<B>),
+}
+
+impl<B: Backend> DepthAnything3<B> {
+    pub fn new(device: &B::Device, config: DepthAnything3Config) -> Self {
+        let backbone = Backbone::new(device, &config);
+        let (head_mono, head_dual) = if config.head.dual_head {
+            (
+                None,
+                Some(DualDepthAnything3Head::new(device, config.head.clone())),
+            )
+        } else {
+            (
+                Some(DepthAnything3Head::new(device, config.head.clone())),
+                None,
+            )
+        };
+        let camera_encoder = config
+            .camera_encoder
+            .clone()
+            .map(|cfg| CameraEncoder::new(device, cfg));
+        let camera_decoder = config
+            .camera_decoder
+            .clone()
+            .map(|cfg| CameraDecoder::new(device, cfg));
+        Self {
+            backbone,
+            head_mono,
+            head_dual,
+            camera_encoder,
+            camera_decoder,
+            img_size: Ignored(config.image_size),
+            patch_size: Ignored(config.patch_size),
+            hook_block_ids: Ignored(config.hook_block_ids),
+            patch_token_start: Ignored(1),
+        }
+    }
+
+    pub fn infer(&self, input: Tensor<B, 4>) -> DepthAnything3Inference<B> {
+        self.infer_with_context(input, None, None)
+    }
+
+    pub fn infer_with_camera(
+        &self,
+        input: Tensor<B, 4>,
+        extrinsics: Tensor<B, 4>,
+        intrinsics: Tensor<B, 4>,
+    ) -> DepthAnything3Inference<B> {
+        self.infer_with_context(input, Some(extrinsics), Some(intrinsics))
+    }
+
+    pub fn infer_with_trace(
+        &self,
+        input: Tensor<B, 4>,
+    ) -> (DepthAnything3Inference<B>, DepthTrace<B>) {
+        let (head_output, camera_prediction, hooks) =
+            self.forward_with_camera_internal(input, None, None);
+        let aux_stage_necks = match &head_output {
+            HeadForwardOutput::Dual(output) => Some(output.aux_stage_necks.clone()),
+            _ => None,
+        };
+        let aux_logits = match &head_output {
+            HeadForwardOutput::Dual(output) => Some(output.aux_logits.clone()),
+            _ => None,
+        };
+        let aux_head_input = match &head_output {
+            HeadForwardOutput::Dual(output) => Some(output.aux_head_input.clone()),
+            _ => None,
+        };
+        let inference = self.finalize_inference(head_output, camera_prediction);
+        let backbone_tokens = hooks
+            .into_iter()
+            .map(|hook| hook.patches)
+            .collect::<Vec<_>>();
+        (
+            inference,
+            DepthTrace {
+                backbone_tokens,
+                aux_stage_necks,
+                aux_logits,
+                aux_head_input,
+            },
+        )
+    }
+
+    pub fn infer_raw(&self, input: Tensor<B, 4>) -> Tensor<B, 4> {
+        match self.forward_with_camera(input, None, None).0 {
+            HeadForwardOutput::Mono(logits) => logits,
+            HeadForwardOutput::Dual(output) => output.depth_logits,
+        }
+    }
+
+    #[allow(clippy::type_complexity)]
+    pub fn infer_from_tokens(
+        &self,
+        patches: &[Tensor<B, 3>],
+        height: usize,
+        width: usize,
+    ) -> (
+        DepthAnything3Inference<B>,
+        Option<Vec<Tensor<B, 4>>>,
+        Option<Tensor<B, 4>>,
+        Option<Tensor<B, 4>>,
+    ) {
+        let expected_tokens =
+            (height / self.patch_size.0).max(1) * (width / self.patch_size.0).max(1);
+        let patch_start = patches
+            .first()
+            .map(|tensor| tensor.shape().dims::<3>()[1])
+            .filter(|&tokens| tokens == expected_tokens)
+            .map(|_| 0)
+            .unwrap_or(self.patch_token_start.0);
+        let head_output = if let Some(head) = &self.head_mono {
+            let inputs = patches.to_vec();
+            HeadForwardOutput::Mono(head.forward_raw(
+                &inputs,
+                height,
+                width,
+                patch_start,
+                self.patch_size.0,
+            ))
+        } else if let Some(head) = &self.head_dual {
+            let hooks = patches
+                .iter()
+                .cloned()
+                .map(|patches| DinoIntermediate {
+                    patches,
+                    camera: None,
+                })
+                .collect::<Vec<_>>();
+            HeadForwardOutput::Dual(head.forward_dual(
+                &hooks,
+                height,
+                width,
+                patch_start,
+                self.patch_size.0,
+            ))
+        } else {
+            panic!("DepthAnything3 has no head variant configured");
+        };
+        let aux_stage_necks = match &head_output {
+            HeadForwardOutput::Dual(output) => Some(output.aux_stage_necks.clone()),
+            _ => None,
+        };
+        let aux_logits = match &head_output {
+            HeadForwardOutput::Dual(output) => Some(output.aux_logits.clone()),
+            _ => None,
+        };
+        let aux_head_input = match &head_output {
+            HeadForwardOutput::Dual(output) => Some(output.aux_head_input.clone()),
+            _ => None,
+        };
+        let inference = self.finalize_inference(head_output, None);
+        (inference, aux_stage_necks, aux_logits, aux_head_input)
+    }
+
+    fn select_depth_channel(&self, tensor: Tensor<B, 4>) -> Tensor<B, 3> {
+        if let Some(head) = &self.head_mono {
+            head.select_depth_channel(tensor)
+        } else {
+            panic!("DepthAnything3 mono head not configured");
+        }
+    }
+
+    fn infer_with_context(
+        &self,
+        input: Tensor<B, 4>,
+        extrinsics: Option<Tensor<B, 4>>,
+        intrinsics: Option<Tensor<B, 4>>,
+    ) -> DepthAnything3Inference<B> {
+        let (head_output, camera_prediction) =
+            self.forward_with_camera(input, extrinsics, intrinsics);
+        self.finalize_inference(head_output, camera_prediction)
+    }
+
+    fn forward_with_camera(
+        &self,
+        input: Tensor<B, 4>,
+        extrinsics: Option<Tensor<B, 4>>,
+        intrinsics: Option<Tensor<B, 4>>,
+    ) -> (HeadForwardOutput<B>, Option<CameraPrediction<B>>) {
+        let (head_output, camera_prediction, _) =
+            self.forward_with_camera_internal(input, extrinsics, intrinsics);
+        (head_output, camera_prediction)
+    }
+
+    fn forward_with_camera_internal(
+        &self,
+        input: Tensor<B, 4>,
+        extrinsics: Option<Tensor<B, 4>>,
+        intrinsics: Option<Tensor<B, 4>>,
+    ) -> (
+        HeadForwardOutput<B>,
+        Option<CameraPrediction<B>>,
+        Vec<DinoIntermediate<B>>,
+    ) {
+        let dims = input.shape().dims::<4>();
+        let height = dims[2];
+        let width = dims[3];
+        assert_eq!(
+            height % self.patch_size.0,
+            0,
+            "Input height {height} must be divisible by patch size {}",
+            self.patch_size.0
+        );
+        assert_eq!(
+            width % self.patch_size.0,
+            0,
+            "Input width {width} must be divisible by patch size {}",
+            self.patch_size.0
+        );
+
+        let camera_token = match (&self.camera_encoder, extrinsics, intrinsics) {
+            (Some(encoder), Some(extr), Some(intr)) => {
+                Some(encoder.forward(extr, intr, height, width))
+            }
+            _ => None,
+        };
+
+        let (_, hooks) =
+            self.backbone
+                .forward_with_hooks(input, &self.hook_block_ids.0, camera_token);
+        assert!(
+            hooks.len() >= self.hook_block_ids.0.len(),
+            "Backbone returned fewer hooks ({}) than requested ({})",
+            hooks.len(),
+            self.hook_block_ids.0.len()
+        );
+        let patch_start = 0;
+        let head_output = if let Some(head) = &self.head_mono {
+            let patches: Vec<Tensor<B, 3>> =
+                hooks.iter().map(|hook| hook.patches.clone()).collect();
+            HeadForwardOutput::Mono(head.forward_raw(
+                &patches,
+                height,
+                width,
+                patch_start,
+                self.patch_size.0,
+            ))
+        } else if let Some(head) = &self.head_dual {
+            HeadForwardOutput::Dual(head.forward_dual(
+                &hooks,
+                height,
+                width,
+                patch_start,
+                self.patch_size.0,
+            ))
+        } else {
+            panic!("DepthAnything3 has no head variant configured");
+        };
+        let camera_prediction = self.decode_camera(&hooks, height, width);
+        (head_output, camera_prediction, hooks)
+    }
+
+    pub fn img_size(&self) -> usize {
+        self.img_size.0
+    }
+
+    pub fn patch_size(&self) -> usize {
+        self.patch_size.0
+    }
+
+    fn decode_camera(
+        &self,
+        hooks: &[DinoIntermediate<B>],
+        height: usize,
+        width: usize,
+    ) -> Option<CameraPrediction<B>> {
+        let decoder = self.camera_decoder.as_ref()?;
+        let hook = hooks.last()?;
+        let camera_tokens = hook.camera.as_ref()?;
+        let features = camera_tokens.clone().unsqueeze_dim::<3>(1);
+        Some(decoder.forward(features, None, height, width))
+    }
+
+    fn finalize_inference(
+        &self,
+        head_output: HeadForwardOutput<B>,
+        camera_prediction: Option<CameraPrediction<B>>,
+    ) -> DepthAnything3Inference<B> {
+        let (pose_encoding, extrinsics, intrinsics) = if let Some(prediction) = camera_prediction {
+            (
+                Some(prediction.pose_encoding),
+                Some(prediction.extrinsics),
+                Some(prediction.intrinsics),
+            )
+        } else {
+            (None, None, None)
+        };
+        match head_output {
+            HeadForwardOutput::Mono(logits) => {
+                let depth = self.select_depth_channel(logits);
+                DepthAnything3Inference {
+                    depth,
+                    depth_confidence: None,
+                    aux: None,
+                    aux_confidence: None,
+                    pose_encoding,
+                    extrinsics,
+                    intrinsics,
+                }
+            }
+            HeadForwardOutput::Dual(output) => DepthAnything3Inference {
+                depth: output.depth,
+                depth_confidence: Some(output.depth_confidence),
+                aux: Some(output.aux),
+                aux_confidence: Some(output.aux_confidence),
+                pose_encoding,
+                extrinsics,
+                intrinsics,
+            },
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::InferenceBackend;
+    #[cfg(feature = "backend_wgpu")]
+    use burn::record::{HalfPrecisionSettings, Record};
+
+    #[test]
+    fn depth_anything3_emits_depth_tensor() {
+        let device = <InferenceBackend as Backend>::Device::default();
+        let config = DepthAnything3Config::metric_large();
+        let model = DepthAnything3::<InferenceBackend>::new(&device, config);
+        let input = Tensor::<InferenceBackend, 4>::zeros([1, 3, 518, 518], &device);
+        let output = model.infer(input);
+        assert_eq!(output.depth.shape().dims(), [1, 518, 518]);
+    }
+
+    #[cfg(feature = "backend_wgpu")]
+    #[test]
+    fn depth_anything3_wgpu_record_roundtrip() {
+        type TestBackend = burn::backend::Wgpu<f32>;
+        let device = <TestBackend as Backend>::Device::default();
+        let config = DepthAnything3Config::small();
+        let model = DepthAnything3::<TestBackend>::new(&device, config);
+        let record_item = model
+            .clone()
+            .into_record()
+            .into_item::<HalfPrecisionSettings>();
+        let _ = <DepthAnything3<TestBackend> as Module<TestBackend>>::Record::from_item(
+            record_item,
+            &device,
+        );
+    }
+}
diff --git a/src/model/depth_pro/layers/encoder.rs b/src/model/depth_pro/layers/encoder.rs
index f5fcb10..b0d5c47 100644
--- a/src/model/depth_pro/layers/encoder.rs
+++ b/src/model/depth_pro/layers/encoder.rs
@@ -292,13 +292,27 @@ impl<B: Backend> DepthProEncoder<B> {
         let batch = dims[0];
         let tokens = dims[1];
         let dim = dims[2];
-
-        let embeddings = if cls_token_offset > 0 {
-            embeddings.slice([0..batch, cls_token_offset..tokens, 0..dim])
+        let spatial_tokens = width * height;
+        assert!(
+            spatial_tokens <= tokens,
+            "cannot reshape {tokens} tokens into {width}x{height}"
+        );
+        let has_room_for_offset = tokens
+            .checked_sub(cls_token_offset)
+            .map(|remaining| remaining >= spatial_tokens)
+            .unwrap_or(false);
+        let offset = if has_room_for_offset {
+            cls_token_offset
         } else {
-            embeddings
+            tokens - spatial_tokens
         };
 
+        let embeddings = embeddings.slice([
+            0..batch,
+            offset..offset + spatial_tokens,
+            0..dim,
+        ]);
+
         embeddings
             .reshape([batch as i32, height as i32, width as i32, dim as i32])
             .permute([0, 3, 1, 2])
@@ -337,8 +351,12 @@ impl<B: Backend> DepthProEncoder<B> {
             "DepthPro encoder expects at least two hook tokens"
         );
 
-        let x_pyramid_encodings =
-            self.reshape_feature(patch_output.x_norm_patchtokens, self.out_size, self.out_size, 0);
+        let x_pyramid_encodings = self.reshape_feature(
+            patch_output.x_norm_patchtokens,
+            self.out_size,
+            self.out_size,
+            0,
+        );
 
         let len0 = x0_split.tensor.shape().dims::<4>()[0];
         let len1 = x1_split.tensor.shape().dims::<4>()[0];
diff --git a/src/model/mod.rs b/src/model/mod.rs
index 4ef4c80..ffdddb2 100644
--- a/src/model/mod.rs
+++ b/src/model/mod.rs
@@ -1 +1,210 @@
+pub mod depth_anything3;
 pub mod depth_pro;
+
+use burn::{
+    module::Module,
+    prelude::*,
+    record::{HalfPrecisionSettings, NamedMpkFileRecorder},
+};
+use image::{
+    RgbImage,
+    imageops::{self, FilterType},
+};
+use std::path::Path;
+
+use depth_anything3::DepthAnything3Config;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum DepthModelKind {
+    DepthPro,
+    DepthAnything3,
+}
+
+impl DepthModelKind {
+    pub fn default_checkpoint(self) -> &'static str {
+        match self {
+            DepthModelKind::DepthPro => "assets/model/depth_pro.mpk",
+            DepthModelKind::DepthAnything3 => "assets/model/da3_metric_large.mpk",
+        }
+    }
+
+    pub fn as_str(self) -> &'static str {
+        match self {
+            DepthModelKind::DepthPro => "depth-pro",
+            DepthModelKind::DepthAnything3 => "depth-anything-3",
+        }
+    }
+}
+
+#[allow(clippy::large_enum_variant)]
+#[derive(Clone, Debug)]
+pub enum AnyDepthModel<B: Backend> {
+    DepthPro(depth_pro::DepthPro<B>),
+    DepthAnything3(depth_anything3::DepthAnything3<B>),
+}
+
+impl<B: Backend> AnyDepthModel<B> {
+    pub fn load(
+        kind: DepthModelKind,
+        device: &B::Device,
+        checkpoint: &Path,
+    ) -> Result<Self, String> {
+        match kind {
+            DepthModelKind::DepthPro => depth_pro::DepthPro::<B>::load(device, checkpoint)
+                .map(Self::DepthPro)
+                .map_err(|err| format!("Failed to load DepthPro checkpoint: {err}")),
+            DepthModelKind::DepthAnything3 => Self::load_depth_anything3(device, checkpoint),
+        }
+    }
+
+    fn load_depth_anything3(device: &B::Device, checkpoint: &Path) -> Result<Self, String> {
+        let recorder = NamedMpkFileRecorder::<HalfPrecisionSettings>::new();
+        let checkpoint_hint = checkpoint
+            .file_name()
+            .and_then(|name| name.to_str())
+            .unwrap_or_default()
+            .to_ascii_lowercase();
+
+        let mut configs = Vec::from([
+            DepthAnything3Config::metric_large(),
+            DepthAnything3Config::small(),
+        ]);
+
+        if checkpoint_hint.contains("small") {
+            configs.swap(0, 1);
+        }
+
+        let mut last_err = None;
+        for config in configs {
+            let config_clone = config.clone();
+            let recorder_clone = recorder.clone();
+            let attempt = depth_anything3::with_model_load_stack(move || {
+                depth_anything3::DepthAnything3::new(device, config_clone).load_file(
+                    checkpoint,
+                    &recorder_clone,
+                    device,
+                )
+            });
+            match attempt {
+                Ok(model) => return Ok(Self::DepthAnything3(model)),
+                Err(err) => last_err = Some(err),
+            }
+        }
+
+        Err(format!(
+            "Failed to load Depth Anything 3 checkpoint `{}`: {}",
+            checkpoint.display(),
+            last_err
+                .map(|err| err.to_string())
+                .unwrap_or_else(|| "unknown error".to_string())
+        ))
+    }
+
+    pub fn kind(&self) -> DepthModelKind {
+        match self {
+            Self::DepthPro(_) => DepthModelKind::DepthPro,
+            Self::DepthAnything3(_) => DepthModelKind::DepthAnything3,
+        }
+    }
+
+    pub fn as_depth_pro(&self) -> Option<&depth_pro::DepthPro<B>> {
+        if let Self::DepthPro(model) = self {
+            Some(model)
+        } else {
+            None
+        }
+    }
+
+    pub fn as_depth_anything3(&self) -> Option<&depth_anything3::DepthAnything3<B>> {
+        if let Self::DepthAnything3(model) = self {
+            Some(model)
+        } else {
+            None
+        }
+    }
+
+    pub fn preferred_input_resolution(&self) -> Option<usize> {
+        match self {
+            Self::DepthPro(_) => None,
+            Self::DepthAnything3(model) => Some(model.img_size()),
+        }
+    }
+
+    pub fn prepare_input_image(&self, image: &RgbImage) -> Result<PreparedModelImage, String> {
+        match self {
+            Self::DepthPro(_) => Ok(PreparedModelImage {
+                width: image.width() as usize,
+                height: image.height() as usize,
+                rgb: image.clone(),
+                crop: None,
+            }),
+            Self::DepthAnything3(model) => prepare_depth_anything3_image(image, model.img_size()),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct ImageCropRegion {
+    pub x: usize,
+    pub y: usize,
+    pub width: usize,
+    pub height: usize,
+}
+
+#[derive(Clone, Debug)]
+pub struct PreparedModelImage {
+    pub width: usize,
+    pub height: usize,
+    pub rgb: RgbImage,
+    pub crop: Option<ImageCropRegion>,
+}
+
+pub fn prepare_depth_anything3_image(
+    image: &RgbImage,
+    target: usize,
+) -> Result<PreparedModelImage, String> {
+    if target == 0 {
+        return Err("depth_anything3 requires a non-zero target resolution".to_string());
+    }
+    let (orig_width, orig_height) = (image.width() as usize, image.height() as usize);
+    if orig_width == target && orig_height == target {
+        return Ok(PreparedModelImage {
+            width: target,
+            height: target,
+            rgb: image.clone(),
+            crop: None,
+        });
+    }
+
+    let shortest = orig_width.min(orig_height).max(1) as f32;
+    let scale = target as f32 / shortest;
+    let mut scaled_width = ((orig_width as f32) * scale).round() as usize;
+    let mut scaled_height = ((orig_height as f32) * scale).round() as usize;
+    scaled_width = scaled_width.max(target);
+    scaled_height = scaled_height.max(target);
+
+    let resized = imageops::resize(
+        image,
+        scaled_width as u32,
+        scaled_height as u32,
+        FilterType::CatmullRom,
+    );
+
+    let crop_x = (scaled_width.saturating_sub(target)) / 2;
+    let crop_y = (scaled_height.saturating_sub(target)) / 2;
+    let cropped = imageops::crop_imm(
+        &resized,
+        crop_x as u32,
+        crop_y as u32,
+        target as u32,
+        target as u32,
+    )
+    .to_image();
+
+    Ok(PreparedModelImage {
+        width: target,
+        height: target,
+        rgb: cropped,
+        crop: None,
+    })
+}
diff --git a/tool/correctness_da3.py b/tool/correctness_da3.py
new file mode 100644
index 0000000..34eec1f
--- /dev/null
+++ b/tool/correctness_da3.py
@@ -0,0 +1,315 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+import math
+import numpy as np
+import torch
+from PIL import Image
+from safetensors.torch import load_file, save_file
+
+REPO_SRC = Path("target/depth-anything-3/src").resolve()
+sys.path.append(str(REPO_SRC))
+
+from depth_anything_3.cfg import create_object, load_config  # type: ignore  # noqa: E402
+from depth_anything_3.model.utils.transform import (  # type: ignore  # noqa: E402
+    pose_encoding_to_extri_intri,
+)
+from depth_anything_3.utils.geometry import affine_inverse  # type: ignore  # noqa: E402
+
+
+def load_model(checkpoint: Path, config: Path, device: torch.device) -> torch.nn.Module:
+    cfg = load_config(str(config))
+    model = create_object(cfg).to(device)
+    weights = load_file(str(checkpoint))
+    trimmed = {
+        key.replace("model.", "", 1): value
+        for key, value in weights.items()
+        if key.startswith("model.")
+    }
+    model.load_state_dict(trimmed, strict=False)
+    model.eval()
+    return model
+
+
+def cubic_weight(x: float, a: float = -0.75) -> float:
+    abs_x = abs(x)
+    abs_x2 = abs_x * abs_x
+    abs_x3 = abs_x2 * abs_x
+    if abs_x <= 1.0:
+        return (a + 2.0) * abs_x3 - (a + 3.0) * abs_x2 + 1.0
+    if abs_x < 2.0:
+        return a * abs_x3 - 5.0 * a * abs_x2 + 8.0 * a * abs_x - 4.0 * a
+    return 0.0
+
+
+def resize_bicubic(array: np.ndarray, size: int) -> np.ndarray:
+    src_h, src_w, channels = array.shape
+    if src_h == size and src_w == size:
+        return array.copy()
+
+    dst = np.zeros((size, size, channels), dtype=np.float32)
+    scale_x = src_w / size
+    scale_y = src_h / size
+
+    for y in range(size):
+        src_y = (y + 0.5) * scale_y - 0.5
+        y_int = math.floor(src_y)
+        for x in range(size):
+            src_x = (x + 0.5) * scale_x - 0.5
+            x_int = math.floor(src_x)
+            accum = np.zeros(channels, dtype=np.float32)
+            weight_sum = np.float32(0.0)
+            for m in range(-1, 3):
+                wy = np.float32(cubic_weight(src_y - (y_int + m)))
+                sy = min(max(y_int + m, 0), src_h - 1)
+                for n in range(-1, 3):
+                    wx = np.float32(cubic_weight(src_x - (x_int + n)))
+                    sx = min(max(x_int + n, 0), src_w - 1)
+                    weight = wy * wx
+                    accum += weight * array[sy, sx]
+                    weight_sum += weight
+            if weight_sum != 0.0:
+                accum /= weight_sum
+            dst[y, x] = accum
+
+    return np.clip(np.floor(dst + 0.5), 0, 255).astype(np.uint8)
+
+
+def load_burn_input(path: Path) -> torch.Tensor:
+    with path.open("rb") as handle:
+        dims = [int.from_bytes(handle.read(4), "little") for _ in range(4)]
+        data = np.frombuffer(handle.read(), dtype=np.float32)
+    batch, channels, height, width = dims
+    tensor = data.reshape(batch, channels, height, width)
+    path.unlink(missing_ok=True)
+    return torch.from_numpy(tensor).unsqueeze(1)
+
+
+def preprocess(image_path: Path, size: int) -> torch.Tensor:
+    image = Image.open(image_path).convert("RGB")
+    array = np.asarray(image)
+    resized = resize_bicubic(array, size)
+    if os.environ.get("DA3_DUMP_RESIZED"):
+        dump_path = Path("target/da3_resized_torch.rgb")
+        dump_path.parent.mkdir(parents=True, exist_ok=True)
+        dump_path.write_bytes(resized.tobytes())
+        print(f"Wrote PyTorch-resized RGB bytes to {dump_path}")
+    array = torch.from_numpy(resized).permute(2, 0, 1).float() / 255.0
+    mean = torch.tensor([0.485, 0.456, 0.406]).view(3, 1, 1)
+    std = torch.tensor([0.229, 0.224, 0.225]).view(3, 1, 1)
+    tensor = ((array - mean) / std).unsqueeze(0).unsqueeze(0)
+    return tensor
+
+
+def collect_aux_stage_necks(
+    head: torch.nn.Module,
+    feats,
+    height: int,
+    width: int,
+) -> tuple[list[torch.Tensor], torch.Tensor | None, torch.Tensor | None]:
+    modules = getattr(head.scratch, "output_conv1_aux", None)
+    if modules is None:
+        return [], None
+    captured = {}
+    handles = []
+    logits_capture: dict[str, torch.Tensor] = {}
+    logits_handle = None
+    logits_pre_handle = None
+
+    def logits_hook(_module, _input, output):
+        logits_capture["tensor"] = output.detach().cpu()
+
+    def logits_pre_hook(_module, inputs):
+        if isinstance(inputs, tuple) and inputs:
+            logits_capture["input"] = inputs[0].detach().cpu()
+
+    def make_hook(idx: int):
+        def hook(_module, _input, output):
+            captured[idx] = output.detach().cpu()
+
+        return hook
+
+    for idx, module in enumerate(modules):
+        handles.append(module.register_forward_hook(make_hook(idx)))
+    target_module = getattr(head.scratch, "output_conv2_aux", None)
+    if target_module:
+        logits_pre_handle = target_module[-1].register_forward_pre_hook(logits_pre_hook)
+        logits_handle = target_module[-1].register_forward_hook(logits_hook)
+    try:
+        with torch.inference_mode():
+            head(feats, height, width, patch_start_idx=0)
+    finally:
+        for handle in handles:
+            handle.remove()
+        if logits_handle:
+            logits_handle.remove()
+        if logits_pre_handle:
+            logits_pre_handle.remove()
+    if not captured:
+        return [], None, None
+    B, S, _, _ = feats[0][0].shape
+    stages = []
+    for idx in range(len(captured)):
+        tensor = captured[idx]
+        dims = tensor.shape
+        reshaped = tensor.reshape(B, S, dims[1], dims[2], dims[3])
+        stages.append(reshaped[:, 0].contiguous())
+    logits = None
+    if "tensor" in logits_capture:
+        tensor = logits_capture["tensor"]
+        dims = tensor.shape
+        logits = tensor.reshape(B, S, dims[1], dims[2], dims[3])[:, 0].contiguous()
+    head_input = None
+    if "input" in logits_capture:
+        tensor = logits_capture["input"]
+        dims = tensor.shape
+        head_input = tensor.reshape(B, S, dims[1], dims[2], dims[3])[:, 0].contiguous()
+    return stages, logits, head_input
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Generate Depth Anything 3 PyTorch references for correctness tests."
+    )
+    parser.add_argument(
+        "--checkpoint",
+        type=Path,
+        default=Path("assets/model/da3_metric_large.safetensors"),
+        help="Path to the official DA3 safetensors checkpoint.",
+    )
+    parser.add_argument(
+        "--config",
+        type=Path,
+        default=Path(
+            "target/depth-anything-3/src/depth_anything_3/configs/da3metric-large.yaml"
+        ),
+        help="Model config file to instantiate the PyTorch network.",
+    )
+    parser.add_argument(
+        "--image",
+        type=Path,
+        default=Path("assets/image/test.jpg"),
+        help="RGB image used to build the reference.",
+    )
+    parser.add_argument(
+        "--out",
+        type=Path,
+        default=Path("assets/image/test_da3_reference.safetensors"),
+        help="Destination safetensors path.",
+    )
+    parser.add_argument(
+        "--resize",
+        type=int,
+        default=518,
+        help="Square resolution applied before inference (default: 518).",
+    )
+    parser.add_argument(
+        "--skip-intermediates",
+        action="store_true",
+        help="Do not dump intermediate backbone tokens to the reference file.",
+    )
+    parser.add_argument(
+        "--device",
+        type=str,
+        choices=["cpu", "cuda"],
+        default="cpu",
+        help="Device used to run the PyTorch reference (default: cpu).",
+    )
+    args = parser.parse_args()
+
+    requested_device = args.device
+    if requested_device == "cuda" and not torch.cuda.is_available():
+        print("CUDA requested but not available; falling back to CPU.")
+        requested_device = "cpu"
+    device = torch.device(requested_device)
+    model = load_model(args.checkpoint, args.config, device)
+    if os.environ.get("DA3_LOAD_INPUT"):
+        tensor = load_burn_input(Path(os.environ["DA3_LOAD_INPUT"]))
+    elif Path("target/da3_input_tensor.bin").exists():
+        tensor = load_burn_input(Path("target/da3_input_tensor.bin"))
+    else:
+        tensor = preprocess(args.image, args.resize)
+    tensor_for_save = tensor.clone()
+    tensor = tensor.to(device)
+    with torch.inference_mode():
+        feats, aux_feats = model.backbone(
+            tensor,
+            cam_token=None,
+            export_feat_layers=[],
+        )
+        raw_feats = feats
+        output = model._process_depth_head(feats, tensor.shape[-2], tensor.shape[-1])
+        pose_encoding = None
+        extrinsics = None
+        intrinsics = None
+        if model.cam_dec is not None:
+            pose_encoding = model.cam_dec(raw_feats[-1][1])
+            c2w, ixt = pose_encoding_to_extri_intri(
+                pose_encoding, (tensor.shape[-2], tensor.shape[-1])
+            )
+            extrinsics = affine_inverse(c2w)
+            intrinsics = ixt
+        aux_stage_necks, aux_logits, aux_head_input = collect_aux_stage_necks(
+            model.head, raw_feats, tensor.shape[-2], tensor.shape[-1]
+        )
+    depth = output["depth"].detach().cpu().squeeze(1)
+    depth_conf = output["depth_conf"].detach().cpu().squeeze(1)
+    ray = output.get("ray", None)
+    if ray is not None:
+        ray = ray.detach().cpu()
+        if ray.ndim == 5:
+            ray = ray.squeeze(1)
+        ray = ray.permute(0, 3, 1, 2).contiguous()
+    ray_conf = output.get("ray_conf", None)
+    if ray_conf is not None:
+        ray_conf = ray_conf.detach().cpu()
+        if ray_conf.ndim == 4:
+            ray_conf = ray_conf.squeeze(1)
+    metric_depth = depth.contiguous()
+    metric_input = tensor_for_save.squeeze(1).contiguous()
+    tensors_to_save = {
+        "depth": metric_depth,
+        "metric_input": metric_input,
+        "depth_confidence": depth_conf.contiguous(),
+    }
+    if ray is not None:
+        tensors_to_save["ray"] = ray.contiguous()
+    if ray_conf is not None:
+        tensors_to_save["ray_confidence"] = ray_conf.contiguous()
+    if pose_encoding is not None:
+        tensors_to_save["pose_encoding"] = pose_encoding.detach().cpu().contiguous()
+    if extrinsics is not None:
+        tensors_to_save["extrinsics"] = extrinsics.detach().cpu().contiguous()
+    if intrinsics is not None:
+        tensors_to_save["intrinsics"] = intrinsics.detach().cpu().contiguous()
+    if not args.skip_intermediates:
+        B, S, N, C = raw_feats[0][0].shape
+        for idx, feat in enumerate(raw_feats):
+            tokens = (
+                feat[0]
+                .reshape(B * S, N, C)
+                .detach()
+                .cpu()
+                .contiguous()
+            )
+            tensors_to_save[f"backbone_tokens.stage{idx}"] = tokens
+        if aux_stage_necks:
+            for idx, stage in enumerate(aux_stage_necks):
+                tensors_to_save[f"aux_stage_necks.stage{idx}"] = stage.contiguous()
+        if aux_logits is not None:
+            tensors_to_save["aux_logits"] = aux_logits.contiguous()
+        if aux_head_input is not None:
+            tensors_to_save["aux_head_input"] = aux_head_input.contiguous()
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    save_file(tensors_to_save, str(args.out))
+    print(f"Saved DA3 reference tensors to {args.out}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tool/correctness.py b/tool/correctness_depth_pro.py
similarity index 100%
rename from tool/correctness.py
rename to tool/correctness_depth_pro.py
diff --git a/tool/import_da3.rs b/tool/import_da3.rs
new file mode 100644
index 0000000..277e323
--- /dev/null
+++ b/tool/import_da3.rs
@@ -0,0 +1,284 @@
+use std::path::PathBuf;
+
+use burn::{
+    backend::NdArray,
+    module::Module,
+    record::{HalfPrecisionSettings, NamedMpkFileRecorder},
+    tensor::backend::Backend,
+};
+use burn_depth::model::depth_anything3::{DepthAnything3, DepthAnything3Config};
+use burn_store::{
+    ApplyResult, KeyRemapper, ModuleSnapshot, PyTorchToBurnAdapter, SafetensorsStore,
+};
+use clap::{Parser, ValueEnum};
+
+type ImportBackend = NdArray<f32>;
+
+#[derive(Parser, Debug)]
+#[command(
+    author,
+    version,
+    about = "Convert DA3 safetensors weights into Burn checkpoints"
+)]
+struct Args {
+    #[arg(long, value_enum, default_value_t = ModelVariant::MetricLarge)]
+    variant: ModelVariant,
+
+    #[arg(long, value_name = "PATH")]
+    checkpoint: Option<PathBuf>,
+
+    #[arg(long, value_name = "PATH")]
+    output: Option<PathBuf>,
+
+    #[arg(long, value_name = "BOOL", default_value_t = false)]
+    dry_run: bool,
+
+    #[arg(long, value_name = "PATH")]
+    dump_template: Option<PathBuf>,
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args = Args::parse();
+    let checkpoint = args
+        .checkpoint
+        .unwrap_or_else(|| args.variant.default_checkpoint());
+    let output = args.output.unwrap_or_else(|| args.variant.default_output());
+
+    if !checkpoint.exists() {
+        return Err(format!("Checkpoint `{}` not found.", checkpoint.display()).into());
+    }
+
+    let device = <ImportBackend as Backend>::Device::default();
+    let config = args.variant.config();
+    let mut model = DepthAnything3::<ImportBackend>::new(&device, config.clone());
+    let head_prefix = if config.head.dual_head {
+        "head_dual"
+    } else {
+        "head_mono"
+    };
+
+    if let Some(path) = &args.dump_template {
+        export_template(&model, path)?;
+        if args.dry_run {
+            return Ok(());
+        }
+    }
+
+    let remapper = KeyRemapper::new()
+        .add_pattern(r"^model\.", "")?
+        .add_pattern(r"^head\.", format!("{head_prefix}."))?
+        .add_pattern(
+            r"^cam_dec\.backbone\.0\.(weight|bias)$",
+            "camera_decoder.backbone_1.$1",
+        )?
+        .add_pattern(
+            r"^cam_dec\.backbone\.2\.(weight|bias)$",
+            "camera_decoder.backbone_2.$1",
+        )?
+        .add_pattern(r"^cam_dec\.fc_t\.(weight|bias)$", "camera_decoder.fc_t.$1")?
+        .add_pattern(
+            r"^cam_dec\.fc_qvec\.(weight|bias)$",
+            "camera_decoder.fc_qvec.$1",
+        )?
+        .add_pattern(
+            r"^cam_dec\.fc_fov\.0\.(weight|bias)$",
+            "camera_decoder.fc_fov.$1",
+        )?
+        .add_pattern(r"^cam_dec\.", "camera_decoder.")?
+        .add_pattern(r"^cam_enc\.", "camera_encoder.")?
+        .add_pattern(r"^(backbone\.pretrained\..*\.norm\d+)\.weight$", "$1.gamma")?
+        .add_pattern(r"^(backbone\.pretrained\..*\.norm\d+)\.bias$", "$1.beta")?
+        .add_pattern(r"^(backbone\.pretrained\.norm)\.weight$", "$1.gamma")?
+        .add_pattern(r"^(backbone\.pretrained\.norm)\.bias$", "$1.beta")?
+        .add_pattern(
+            r"^(backbone\.pretrained\..*\.attn\.q_norm)\.weight$",
+            "$1.gamma",
+        )?
+        .add_pattern(
+            r"^(backbone\.pretrained\..*\.attn\.q_norm)\.bias$",
+            "$1.beta",
+        )?
+        .add_pattern(
+            r"^(backbone\.pretrained\..*\.attn\.k_norm)\.weight$",
+            "$1.gamma",
+        )?
+        .add_pattern(
+            r"^(backbone\.pretrained\..*\.attn\.k_norm)\.bias$",
+            "$1.beta",
+        )?
+        .add_pattern(
+            &format!(r"^({head_prefix}\..*norm\d*)\.weight$"),
+            "$1.gamma",
+        )?
+        .add_pattern(&format!(r"^({head_prefix}\..*norm\d*)\.bias$"), "$1.beta")?
+        .add_pattern(
+            &format!(r"^({head_prefix}\.resize_layers\.(0|1))\.weight$"),
+            "$1.conv_t.weight",
+        )?
+        .add_pattern(
+            &format!(r"^({head_prefix}\.resize_layers\.(0|1))\.bias$"),
+            "$1.conv_t.bias",
+        )?
+        .add_pattern(
+            &format!(r"^({head_prefix}\.resize_layers\.3)\.weight$"),
+            "$1.conv.weight",
+        )?
+        .add_pattern(
+            &format!(r"^({head_prefix}\.resize_layers\.3)\.bias$"),
+            "$1.conv.bias",
+        )?
+        .add_pattern(
+            &format!(r"^({head_prefix}\.scratch\.output_conv2)\.0\.(weight|bias)$"),
+            "$1.conv1.$2",
+        )?
+        .add_pattern(
+            &format!(r"^({head_prefix}\.scratch\.output_conv2)\.2\.(weight|bias)$"),
+            "$1.conv2.$2",
+        )?
+        .add_pattern(
+            &format!(r"^({head_prefix}\.scratch\.refinenet\d+)\.resConfUnit1\."),
+            "$1.residual1.",
+        )?
+        .add_pattern(
+            &format!(r"^({head_prefix}\.scratch\.refinenet\d+)\.resConfUnit2\."),
+            "$1.residual2.",
+        )?
+        .add_pattern(
+            &format!(r"^({head_prefix}\.scratch\.refinenet\d+_aux)\.resConfUnit1\."),
+            "$1.residual1.",
+        )?
+        .add_pattern(
+            &format!(r"^({head_prefix}\.scratch\.refinenet\d+_aux)\.resConfUnit2\."),
+            "$1.residual2.",
+        )?
+        .add_pattern(
+            &format!(r"^({head_prefix}\.scratch\.output_conv1_aux\.\d+)\.(\d+)\.(weight|bias)$"),
+            "$1.layers.$2.$3",
+        )?
+        .add_pattern(
+            &format!(r"^({head_prefix}\.scratch\.output_conv2_aux\.\d+)\.0\.(weight|bias)$"),
+            "$1.reduce.$2",
+        )?
+        .add_pattern(
+            &format!(r"^({head_prefix}\.scratch\.output_conv2_aux\.\d+)\.2\.weight$"),
+            "$1.norm.layer_norm.gamma",
+        )?
+        .add_pattern(
+            &format!(r"^({head_prefix}\.scratch\.output_conv2_aux\.\d+)\.2\.bias$"),
+            "$1.norm.layer_norm.beta",
+        )?
+        .add_pattern(
+            &format!(r"^({head_prefix}\.scratch\.output_conv2_aux\.\d+)\.5\.(weight|bias)$"),
+            "$1.project.$2",
+        )?
+        .add_pattern(
+            &format!(
+                r"^({head_prefix}\.scratch\.output_conv2_aux\.\d+\.norm\.layer_norm)\.weight$"
+            ),
+            "$1.gamma",
+        )?
+        .add_pattern(
+            &format!(r"^({head_prefix}\.scratch\.output_conv2_aux\.\d+\.norm\.layer_norm)\.bias$"),
+            "$1.beta",
+        )?
+        .add_pattern(r"^(camera_encoder\..*norm\d+)\.weight$", "$1.gamma")?
+        .add_pattern(r"^(camera_encoder\..*norm\d+)\.bias$", "$1.beta")?
+        .add_pattern(r"^(camera_encoder\..*norm)\.weight$", "$1.gamma")?
+        .add_pattern(r"^(camera_encoder\..*norm)\.bias$", "$1.beta")?
+        .add_pattern(
+            r"^(camera_encoder\.pose_branch\.fc1)\.(weight|bias)$",
+            "$1.$2",
+        )?
+        .add_pattern(
+            r"^(camera_encoder\.pose_branch\.fc2)\.(weight|bias)$",
+            "$1.$2",
+        )?;
+    let mut store = SafetensorsStore::from_file(&checkpoint);
+    store = store
+        .remap(remapper)
+        .with_from_adapter(PyTorchToBurnAdapter::default())
+        .allow_partial(true);
+
+    println!("Loading {}", checkpoint.display());
+    let result = model
+        .load_from(&mut store)
+        .map_err(|err| format!("Failed to apply checkpoint: {err}"))?;
+    report_result(&result);
+
+    if args.dry_run {
+        println!("Dry run enabled; checkpoint not written.");
+        return Ok(());
+    }
+
+    let recorder = NamedMpkFileRecorder::<HalfPrecisionSettings>::new();
+    model
+        .save_file(output.clone(), &recorder)
+        .map_err(|err| format!("Failed to save checkpoint: {err}"))?;
+    println!("Saved Burn checkpoint to {}", output.display());
+    Ok(())
+}
+
+#[derive(Copy, Clone, Debug, ValueEnum)]
+enum ModelVariant {
+    MetricLarge,
+    Small,
+}
+
+impl ModelVariant {
+    fn config(self) -> DepthAnything3Config {
+        match self {
+            ModelVariant::MetricLarge => DepthAnything3Config::metric_large(),
+            ModelVariant::Small => DepthAnything3Config::small(),
+        }
+    }
+
+    fn default_checkpoint(self) -> PathBuf {
+        match self {
+            ModelVariant::MetricLarge => PathBuf::from("assets/model/da3_metric_large.safetensors"),
+            ModelVariant::Small => PathBuf::from("assets/model/da3_small.safetensors"),
+        }
+    }
+
+    fn default_output(self) -> PathBuf {
+        match self {
+            ModelVariant::MetricLarge => PathBuf::from("assets/model/da3_metric_large.mpk"),
+            ModelVariant::Small => PathBuf::from("assets/model/da3_small.mpk"),
+        }
+    }
+}
+
+fn report_result(result: &ApplyResult) {
+    println!(
+        "Applied {} tensors ({} skipped, {} missing, {} unused).",
+        result.applied.len(),
+        result.skipped.len(),
+        result.missing.len(),
+        result.unused.len()
+    );
+    if !result.missing.is_empty() {
+        for key in &result.missing {
+            println!("Missing tensor: {key}");
+        }
+    }
+    if !result.unused.is_empty() {
+        for key in &result.unused {
+            println!("Unused tensor: {key}");
+        }
+    }
+}
+
+fn export_template<B: Backend>(
+    model: &DepthAnything3<B>,
+    path: &PathBuf,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let mut paths: Vec<String> = model
+        .clone()
+        .collect(None, None)
+        .into_iter()
+        .map(|snapshot| snapshot.full_path())
+        .collect();
+    paths.sort();
+    std::fs::write(path, paths.join("\n"))?;
+    println!("Wrote template paths to {}", path.display());
+    Ok(())
+}
diff --git a/tool/import.rs b/tool/import_depth_pro.rs
similarity index 100%
rename from tool/import.rs
rename to tool/import_depth_pro.rs