[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"project-83420":3},{"id":4,"name":5,"fullName":6,"owner":7,"repo":5,"description":8,"homepage":9,"htmlUrl":10,"language":11,"languages":10,"totalLinesOfCode":10,"stars":12,"forks":13,"watchers":14,"openIssues":14,"contributorsCount":15,"subscribersCount":15,"size":15,"stars1d":13,"stars7d":16,"stars30d":16,"stars90d":15,"forks30d":15,"starsTrendScore":17,"compositeScore":18,"rankGlobal":10,"rankLanguage":10,"license":19,"archived":20,"fork":20,"defaultBranch":21,"hasWiki":20,"hasPages":20,"topics":22,"createdAt":10,"pushedAt":10,"updatedAt":23,"readmeContent":24,"aiSummary":10,"trendingCount":15,"starSnapshotCount":15,"syncStatus":25,"lastSyncTime":26,"discoverSource":27},83420,"ZipSplat","cvg\u002FZipSplat","cvg","ZipSplat: Fewer Gaussians, Better Splats","",null,"Python",94,6,1,0,38,32,77.34,"Apache License 2.0",false,"main",[],"2026-06-12 04:01:41","\u003Cp align=\"center\">\n  \u003Ch1 align=\"center\">ZipSplat: Fewer Gaussians, Better Splats\u003C\u002Fh1>\n  \u003Cp align=\"center\">\n    \u003Ca href=\"https:\u002F\u002Fveichta.com\">Alexander Veicht\u003C\u002Fa>\n    · \u003Ca href=\"https:\u002F\u002Fsunghwanhong.github.io\">Sunghwan Hong\u003C\u002Fa>\n    · \u003Ca href=\"https:\u002F\u002Fscholar.google.com\u002Fcitations?user=U9-D8DYAAAAJ\">Dániel Baráth\u003C\u002Fa>\n    · \u003Ca href=\"https:\u002F\u002Fpeople.inf.ethz.ch\u002Fmarc.pollefeys\u002F\">Marc Pollefeys\u003C\u002Fa>\n    \u003Cbr>\n    \u003Csub>ETH Zürich  ·  Microsoft\u003C\u002Fsub>\n  \u003C\u002Fp>\n  \u003Ch2 align=\"center\">\n    \u003Ca href=\"https:\u002F\u002Farxiv.org\u002Fabs\u002F2606.05102\">Paper\u003C\u002Fa>\n    |\n    \u003Ca href=\"https:\u002F\u002Fveichta.com\u002Fzipsplat\">Project Page\u003C\u002Fa>\n  \u003C\u002Fh2>\n\u003C\u002Fp>\n\n\u003Cp align=\"center\">\n  \u003Cimg src=\"assets\u002Fteaser.png\" alt=\"ZipSplat teaser\" width=\"100%\">\n  \u003Cbr>\n  \u003Cem>ZipSplat decouples Gaussian placement from the pixel grid, reconstructing a scene from a few\n  unposed images in under a second, with higher quality from far fewer Gaussians.\u003C\u002Fem>\n\u003C\u002Fp>\n\n---\n\nZipSplat is a feed-forward model for 3D Gaussian Splatting: it reconstructs a scene from a few\nunposed images in a single forward pass, with no poses, intrinsics, or per-scene optimization.\nInstead of emitting one Gaussian per pixel, it compresses the input views into a compact set of\nscene tokens and decodes each into a small group of Gaussians, reaching state-of-the-art quality\nwith far fewer Gaussians and a single knob to trade quality for size. This repository hosts the\n[inference](#inference), [evaluation](#evaluation), and [training](#training) code for ZipSplat,\ntogether with our pretrained weights.\n\n## Setup and demo\n\nWe provide a standalone inference package [`zipsplat`](zipsplat) that requires only minimal\ndependencies and Python >= 3.10. First clone the repository and install it:\n\n```bash\ngit clone https:\u002F\u002Fgithub.com\u002Fcvg\u002FZipSplat.git && cd ZipSplat\npython -m pip install -e .\n# optional: xformers' fused SwiGLU kernel the released checkpoint was trained with (small speedup)\npython -m pip install -e \".[xformers]\"\n```\n\nRendering uses [gsplat](https:\u002F\u002Fgithub.com\u002Fnerfstudio-project\u002Fgsplat) and requires a CUDA GPU; the\npretrained weights are downloaded automatically on first use.\n\nThe easiest way to try ZipSplat is the interactive viewer: reconstruct a scene and explore it live\nin your browser. Drag the **compression** slider to trade Gaussians for quality in real time, and\ntoggle **token coloring** to see how each token's group of Gaussians is placed:\n\n```bash\npip install \"zipsplat[viewer]\"\npython -m zipsplat.viewer assets\u002Fexamples\u002Fdrone.mp4   # or assets\u002Fexamples\u002Foffice\u002F, or your own dir\u002Fglob\u002Fvideo\n```\n\n## Inference\n\nHere is a minimal usage example:\n\n```python\nimport math, torch\nfrom zipsplat import ZipSplat, Camera, Pose, load_image, viz\n\nmodel = ZipSplat(weights=\"zipsplat\").cuda().eval()\nimages = [load_image(p) for p in paths] # raw images, any size (auto-resized)\ngaussians = model(images)[0] # feed-forward 3D Gaussians\n\n# render a novel view\ncamera = Camera.from_fov(math.radians(60), w=512, h=512)\npose = Pose.from_Rt(torch.eye(3), torch.zeros(3)) # identity pose\nrgb, info = gaussians.render(camera, pose)\n\n# export\ngaussians.save_ply(\"scene.ply\")                             # open in any 3DGS viewer\nviz.turntable(gaussians, \"turntable.mp4\", sweep_deg=None)   # wiggle orbit video\n```\n\n`gaussians` is a [`Gaussians`](zipsplat\u002Fgaussians.py) object; `gaussians.save_ply(...)` writes a standard 3DGS `.ply` you can\ndrop into [SuperSplat](https:\u002F\u002Fplaycanvas.com\u002Fsupersplat\u002Feditor) or any Gaussian-splat viewer.\n\n\u003Cdetails>\n\u003Csummary>\u003Cb>Input: images, a video, or a single image\u003C\u002Fb>\u003C\u002Fsummary>\n\n```python\nfrom zipsplat import load_image, load_video\n\n# multiple images (any sizes; center-cropped to square and resized internally)\ngaussians = model([load_image(p) for p in paths])[0]\n\n# a single image\ngaussians = model([load_image(\"photo.jpg\")])[0]\n\n# a video clip (evenly samples num_frames across the clip)\ngaussians = model(load_video(\"assets\u002Fexamples\u002Fdrone.mp4\", num_frames=24))[0]\n```\n\nThe model handles 1-24+ views; more views give wider coverage, fewer give a tighter reconstruction.\n\u003C\u002Fdetails>\n\n\u003Cdetails>\n\u003Csummary>\u003Cb>Compression: fewer Gaussians\u003C\u002Fb>\u003C\u002Fsummary>\n\n`compression` is the query-sampling ratio in `(0, 1]`. `1.0` (default) uses every token; lower values\nrun k-means to keep a subset, shrinking the Gaussian count with graceful quality falloff.\n\n```python\ngaussians = model(images, compression=1.0)   # full quality\ngaussians = model(images, compression=0.25)  # ~4x fewer Gaussians\nprint(gaussians.num_gaussians)\n```\n\u003C\u002Fdetails>\n\n\u003Cdetails>\n\u003Csummary>\u003Cb>Rendering\u003C\u002Fb>\u003C\u002Fsummary>\n\n```python\n# a single view (scalar camera\u002Fpose) or a batch of views ([V])\nrgb, info = gaussians.render(camera, pose)               # mode=\"RGB\" by default\nrgbd, _ = gaussians.render(camera, pose, mode=\"RGB+ED\")  # append expected depth\n```\n\nCameras\u002Fposes are moved to the scene's device automatically. `info[\"alphas\"]` holds the rendered\nopacity. Build cameras with `Camera.from_fov`, `Camera.from_focal`, or `Camera.from_K`.\n\u003C\u002Fdetails>\n\n\u003Cdetails>\n\u003Csummary>\u003Cb>Turntable video\u003C\u002Fb>\u003C\u002Fsummary>\n\n```python\nfrom zipsplat import viz\n\nviz.turntable(gaussians, \"orbit.mp4\")                  # full 360-degree turntable\nviz.turntable(gaussians, \"wiggle.mp4\", sweep_deg=None) # gentle wiggle (best for front-facing scenes)\n```\n\u003C\u002Fdetails>\n\n\u003Cdetails>\n\u003Csummary>\u003Cb>Camera priors (optional)\u003C\u002Fb>\u003C\u002Fsummary>\n\nIf you have calibrated cameras and poses, pass them with `use_priors=True` to inject them into the\nbackbone. Intrinsics are adjusted automatically for the internal resize.\n\n```python\ngaussians = model(images, cameras=cameras, poses=poses, use_priors=True)\n```\n\u003C\u002Fdetails>\n\n## Models\n\n| Name       | Backbone  | Train res | Notes                                      |\n| ---------- | --------- | --------- | ------------------------------------------ |\n| `zipsplat` | DA3-Giant | 252 px    | Default release checkpoint (RE10K + DL3DV) |\n\nWeights are hosted on the [Hugging Face Hub](https:\u002F\u002Fhuggingface.co\u002Fveichta\u002Fzipsplat) and fetched on\nfirst use. You can also pass a local path or URL: `ZipSplat(weights=\"path\u002Fto\u002Fcheckpoint.tar\")`.\n\n## Training and evaluation\n\nThe training and evaluation code lives in [`splatfactory`](splatfactory), a general library for\nfeed-forward Gaussian Splatting. It streams large multi-view datasets, composes models and\nlosses through Hydra configs, trains across multiple GPUs, and benchmarks novel-view synthesis on a\nsuite of standard datasets. ZipSplat is the model we train with it; the recipes below reproduce the\nreleased checkpoint and the paper tables.\n\n### Setup\n\n`splatfactory` needs a CUDA toolchain to build two compiled extensions\n([gsplat](https:\u002F\u002Fgithub.com\u002FJoannaCCJH\u002Fgsplat) for rasterization and\n[fused-ssim](https:\u002F\u002Fgithub.com\u002Frahul-goel\u002Ffused-ssim) for the SSIM loss), so install in this order:\n\n```bash\n# from the repo root\nconda create -n splatfactory python=3.12 -y && conda activate splatfactory\nconda install -c nvidia cuda-toolkit -y                      # provides nvcc for the kernels below\n\n# 1) torch first (CUDA build), then the training package + its core deps\npip install torch torchvision --index-url https:\u002F\u002Fdownload.pytorch.org\u002Fwhl\u002Fcu128\npip install -e splatfactory\u002F\n\n# 2) CUDA extensions need a built torch present, so disable build isolation\npip install --no-build-isolation --use-pep517 \\\n    git+https:\u002F\u002Fgithub.com\u002FJoannaCCJH\u002Fgsplat.git \\\n    git+https:\u002F\u002Fgithub.com\u002Frahul-goel\u002Ffused-ssim\u002F\npython -c \"from gsplat.cuda._backend import _C\"              # sanity check\n\n# optional: xformers' fused SwiGLU kernel the released checkpoint was trained with\npip install -e \"splatfactory\u002F[xformers]\"\n```\n\nWe use a [gsplat fork](https:\u002F\u002Fgithub.com\u002FJoannaCCJH\u002Fgsplat) rather than upstream because it exposes\na per-Gaussian `activated` flag from the rasterizer. Training uses it to detach Gaussians that were\nalready rendered from the geometry (chamfer) loss, so that term only supervises the Gaussians the\nimages don't already constrain. Inference works with stock gsplat; this fork only matters for\ntraining.\n\n\u003Cdetails>\n\u003Csummary>\u003Cb>Preparing the data\u003C\u002Fb>\u003C\u002Fsummary>\n\nEvery dataset is converted into a common format: uncompressed tar shards of scenes (images,\ncameras, poses, and optional depth) written under `data\u002F\u003Cdataset>\u002F\u003CHxW>\u002F{train,test}-scenes\u002F`. The\nshipped configs point `data.dataset_dir` at these paths, so the default commands below produce\nexactly what training and evaluation expect. Each dataset has a `download` step (fetch the raw data)\nand a `convert` step (pack it into shards); add `--num-workers N` to parallelize either. **For\nevaluation you only need the test split**, so pass `--split test` to `convert` where available.\n\n\u003Cdetails>\n\u003Csummary>\u003Cb>RE10K\u003C\u002Fb>\u003C\u002Fsummary>\n\nA single archive (pixelSplat\u002FMVSplat format) packed into shards at 360x640:\n\n```bash\n# download -> data\u002Fre10k\u002Fraw\u002Fre10k.zip\npython -m splatfactory.datasets.scripts.re10k.download\n# convert -> data\u002Fre10k\u002F360x640\u002F{train,test}-scenes\npython -m splatfactory.datasets.scripts.re10k.convert --num-workers 8\n# evaluation only: just the test split\npython -m splatfactory.datasets.scripts.re10k.convert --split test\n```\n\u003C\u002Fdetails>\n\n\u003Cdetails>\n\u003Csummary>\u003Cb>DL3DV\u003C\u002Fb>\u003C\u002Fsummary>\n\nGated on Hugging Face, so accept the dataset terms and run `huggingface-cli login` first. We use the\n960P release (540x960). Redistribution is not permitted; the script pulls directly from Hugging Face\nper the DL3DV terms.\n\n```bash\n# download -> data\u002Fdl3dv\u002Fraw\u002F960P\u002F\u003Cbatch>\u002F\u003Chash>.zip  (one zip per scene)\npython -m splatfactory.datasets.scripts.dl3dv.download --resolution 960P --num-workers 4\n# convert -> data\u002Fdl3dv\u002F540x960\u002F{train,test}-scenes\npython -m splatfactory.datasets.scripts.dl3dv.convert --resolution 960P --num-workers 8\n# evaluation only: just the test split\npython -m splatfactory.datasets.scripts.dl3dv.convert --resolution 960P --split test\n```\n\u003C\u002Fdetails>\n\n\u003Cdetails>\n\u003Csummary>\u003Cb>MipNeRF360\u003C\u002Fb> (evaluation only)\u003C\u002Fsummary>\n\nA single ~3.6 GB archive, converted from COLMAP poses into one shard per scene at 822x1236 (the 7\npublic scenes). The whole dataset is an evaluation set, so there is no train\u002Ftest split to select.\n\n```bash\n# download -> data\u002Fmipnerf360\u002Fraw\u002F360_v2.zip\npython -m splatfactory.datasets.scripts.mipnerf360.download\n# convert -> data\u002Fmipnerf360\u002F822x1236\u002Ftest-scenes\npython -m splatfactory.datasets.scripts.mipnerf360.convert\n```\n\u003C\u002Fdetails>\n\nTwo optional post-processing tools operate on any shard directory:\n[`repack`](splatfactory\u002Fdatasets\u002Fscripts\u002Frepack.py) re-buckets shards to a uniform size, and\n[`resize`](splatfactory\u002Fdatasets\u002Fscripts\u002Fresize.py) writes a fixed-resolution copy (e.g. `--size\n252`) to a new directory.\n\n**Depth.** Every dataset needs per-view depth maps, for both training and evaluation: training uses them for\nthe depth and chamfer loss, and the data pipeline uses them to normalize each scene's scale. The\nshards from `convert` carry images and poses but no depth; add it in place with\nthe [`extract_depth`](splatfactory\u002Fdatasets\u002Fscripts\u002Fextract_depth.py) script, which runs DA3 on each\nscene (needs a GPU and the `depth-anything-3` package). Run it on every shard directory you train or\nevaluate on:\n\n```bash\npython -m splatfactory.datasets.scripts.extract_depth data\u002Fre10k\u002F360x640\u002Ftrain-scenes\npython -m splatfactory.datasets.scripts.extract_depth data\u002Fre10k\u002F360x640\u002Ftest-scenes\npython -m splatfactory.datasets.scripts.extract_depth data\u002Fdl3dv\u002F540x960\u002Ftrain-scenes\npython -m splatfactory.datasets.scripts.extract_depth data\u002Fdl3dv\u002F540x960\u002Ftest-scenes\npython -m splatfactory.datasets.scripts.extract_depth data\u002Fmipnerf360\u002F822x1236\u002Ftest-scenes\n```\n\nIt can be parallelized across GPUs with torchrun:\n`torchrun --nproc_per_node=4 -m splatfactory.datasets.scripts.extract_depth \u003Cshard-dir>`.\n\n\u003C\u002Fdetails>\n\n## Evaluation\n\nWith the data prepared, evaluate the **released model** with the `zipsplat_eval` config; its weights\nare downloaded automatically, so no local checkpoint is needed:\n\n```bash\npython -m splatfactory.eval.run \u003Cbenchmark> --conf zipsplat_eval eval.num_views=\u003CN>\n```\n\nEach benchmark renders held-out target views and reports PSNR, SSIM, and LPIPS, writing results to\n`outputs\u002Fresults\u002F`. `eval.num_views=N` sets how many context views the model sees, while the scenes\nand context\u002Ftarget views are fixed by the indices in `splatfactory\u002Feval\u002Findices\u002F`, so runs are\nexactly reproducible. To score one of your own training runs instead, pass `--checkpoint \u003Cexp>` in\nplace of `--conf zipsplat_eval`. The per-benchmark commands below cover the protocols we report:\n\n\u003Cdetails>\n\u003Csummary>\u003Cb>DL3DV\u003C\u002Fb> (6 \u002F 12 \u002F 24 context views)\u003C\u002Fsummary>\n\nEvaluate the released model (append `model.eval_use_priors=true` to feed ground-truth camera priors):\n\n```bash\npython -m splatfactory.eval.run dl3dv_benchmark --conf zipsplat_eval eval.num_views=6\npython -m splatfactory.eval.run dl3dv_benchmark --conf zipsplat_eval eval.num_views=12\npython -m splatfactory.eval.run dl3dv_benchmark --conf zipsplat_eval eval.num_views=24\n# with ground-truth camera priors:\npython -m splatfactory.eval.run dl3dv_benchmark --conf zipsplat_eval eval.num_views=6 model.eval_use_priors=true\n```\n\nEvaluate your own checkpoint:\n\n```bash\npython -m splatfactory.eval.run dl3dv_benchmark --checkpoint \u003Cexp_name> eval.num_views=6\n```\n\nResults (PSNR \u002F SSIM \u002F LPIPS, pose-free; DA3 and YoNoSplat for reference):\n\n| Method                | 6 views               | 12 views              | 24 views              |\n| --------------------- | --------------------- | --------------------- | --------------------- |\n| DA3                   | 23.77 \u002F 0.795 \u002F 0.165 | 22.38 \u002F 0.736 \u002F 0.208 | 21.69 \u002F 0.711 \u002F 0.229 |\n| YoNoSplat             | 24.10 \u002F 0.783 \u002F 0.160 | 22.73 \u002F 0.736 \u002F 0.200 | 22.01 \u002F 0.710 \u002F 0.223 |\n| **ZipSplat**          | 25.24 \u002F 0.804 \u002F 0.172 | 24.27 \u002F 0.767 \u002F 0.197 | 24.14 \u002F 0.768 \u002F 0.198 |\n| **ZipSplat + priors** | 25.34 \u002F 0.810 \u002F 0.169 | 24.37 \u002F 0.773 \u002F 0.194 | 24.23 \u002F 0.773 \u002F 0.194 |\n\n\u003C\u002Fdetails>\n\n\u003Cdetails>\n\u003Csummary>\u003Cb>RE10K\u003C\u002Fb> (6 context views)\u003C\u002Fsummary>\n\nEvaluate the released model (append `model.eval_use_priors=true` to feed ground-truth camera priors):\n\n```bash\npython -m splatfactory.eval.run re10k_benchmark --conf zipsplat_eval eval.num_views=6\n# with ground-truth camera priors:\npython -m splatfactory.eval.run re10k_benchmark --conf zipsplat_eval eval.num_views=6 model.eval_use_priors=true\n```\n\nEvaluate your own checkpoint:\n\n```bash\npython -m splatfactory.eval.run re10k_benchmark --checkpoint \u003Cexp_name> eval.num_views=6\n```\n\nResults (pose-free; DA3 and YoNoSplat for reference):\n\n| Method                | PSNR  | SSIM  | LPIPS |\n| --------------------- | ----- | ----- | ----- |\n| DA3                   | 20.90 | 0.724 | 0.234 |\n| YoNoSplat             | 24.99 | 0.835 | 0.151 |\n| **ZipSplat**          | 26.20 | 0.842 | 0.158 |\n| **ZipSplat + priors** | 27.19 | 0.872 | 0.143 |\n\n\u003C\u002Fdetails>\n\n\u003Cdetails>\n\u003Csummary>\u003Cb>MipNeRF360\u003C\u002Fb> (32 \u002F 64 \u002F 128 context views)\u003C\u002Fsummary>\n\nEvaluate the released model (append `model.eval_use_priors=true` to feed ground-truth camera priors):\n\n```bash\npython -m splatfactory.eval.run mipnerf360_benchmark --conf zipsplat_eval eval.num_views=32\npython -m splatfactory.eval.run mipnerf360_benchmark --conf zipsplat_eval eval.num_views=64\npython -m splatfactory.eval.run mipnerf360_benchmark --conf zipsplat_eval eval.num_views=128\n# with ground-truth camera priors:\npython -m splatfactory.eval.run mipnerf360_benchmark --conf zipsplat_eval eval.num_views=32 model.eval_use_priors=true\n```\n\nEvaluate your own checkpoint:\n\n```bash\npython -m splatfactory.eval.run mipnerf360_benchmark --checkpoint \u003Cexp_name> eval.num_views=32\n```\n\nResults (PSNR \u002F SSIM \u002F LPIPS, pose-free; DA3 and YoNoSplat for reference):\n\n| Method                | 32 views              | 64 views              | 128 views             |\n| --------------------- | --------------------- | --------------------- | --------------------- |\n| DA3                   | 20.94 \u002F 0.577 \u002F 0.295 | 20.30 \u002F 0.554 \u002F 0.311 | 20.19 \u002F 0.568 \u002F 0.306 |\n| YoNoSplat             | 17.62 \u002F 0.409 \u002F 0.465 | 17.77 \u002F 0.413 \u002F 0.466 | 17.16 \u002F 0.409 \u002F 0.509 |\n| **ZipSplat**          | 21.72 \u002F 0.594 \u002F 0.325 | 22.18 \u002F 0.615 \u002F 0.298 | 22.29 \u002F 0.624 \u002F 0.290 |\n| **ZipSplat + priors** | 22.95 \u002F 0.655 \u002F 0.276 | 23.31 \u002F 0.675 \u002F 0.260 | 23.37 \u002F 0.683 \u002F 0.255 |\n\n\u003C\u002Fdetails>\n\n\n\n## Training\n\nZipSplat is initialized from the DA3-Giant backbone, so first download those weights into `weights\u002F`\nand convert them to the `.pth` layout the backbone expects:\n\n```bash\nhuggingface-cli download depth-anything\u002FDA3-GIANT model.safetensors --local-dir weights\nmv weights\u002Fmodel.safetensors weights\u002Fda3-giant.safetensor\npython -m splatfactory.models.encoders.dav3_encoder --size giant   # -> weights\u002Fda3-giant.pth\n```\n\nWith the data prepared (including the depth maps) and the backbone in place, start training from the\nrepo root:\n\n```bash\n# single GPU\npython -m splatfactory.train zipsplat --conf zipsplat\n# multiple GPUs on one node\ntorchrun --nproc_per_node=4 -m splatfactory.train zipsplat --conf zipsplat --distributed\n```\n\n`zipsplat` is the experiment name (checkpoints are written to `outputs\u002Ftraining\u002Fzipsplat\u002F`); use any\nname you like. The released model trains on the 50\u002F50 RE10K + DL3DV mix at 252px for 450K steps; our\nrun used 16 GPUs (4 nodes x 4) at a global batch size of 384, so scale `data.batch_size` to your\nhardware. Add `--restore` to resume an interrupted run. Configs are [Hydra](https:\u002F\u002Fhydra.cc), so\nanything can be overridden from the command line, e.g. a smaller backbone:\n\n```bash\npython -m splatfactory.models.encoders.dav3_encoder --size small   # -> weights\u002Fda3-small.pth\npython -m splatfactory.train zipsplat-da3s --conf zipsplat model\u002Fbackbone=da3s data.batch_size=96\n```\n\nTo log training to [TensorBoard](https:\u002F\u002Fwww.tensorflow.org\u002Ftensorboard) or\n[Weights & Biases](https:\u002F\u002Fwandb.ai), set `train.writer`:\n\n```bash\ntorchrun --nproc_per_node=4 -m splatfactory.train zipsplat --conf zipsplat --distributed train.writer=tensorboard\n```\n\nThe trained model can then be evaluated by its experiment name (see [Evaluation](#evaluation)):\n\n```bash\npython -m splatfactory.eval.run dl3dv_benchmark --checkpoint zipsplat --tag zipsplat-retrained eval.num_views=6\n```\n\n## BibTeX\n\n```bibtex\n@article{veicht2026zipsplat,\n  title   = {ZipSplat: Fewer Gaussians, Better Splats},\n  author  = {Veicht, Alexander and Hong, Sunghwan and Bar{\\'a}th, D{\\'a}niel and Pollefeys, Marc},\n  journal = {arXiv preprint arXiv:2606.05102},\n  year    = {2026}\n}\n```\n\n## License\n\nThe **code** in this repository (the `zipsplat` and `splatfactory` packages) is released under the\n[Apache-2.0 License](LICENSE).\n\nThe **pretrained weights** are released separately under\n[CC BY-NC 4.0](https:\u002F\u002Fcreativecommons.org\u002Flicenses\u002Fby-nc\u002F4.0\u002F), **non-commercial use only**. This\nis required by their dependencies: the released checkpoint is initialized from\n[DA3-Giant](https:\u002F\u002Fhuggingface.co\u002Fdepth-anything\u002FDA3-GIANT) (CC BY-NC 4.0) and trained on\n[DL3DV-10K](https:\u002F\u002Fgithub.com\u002FDL3DV-10K\u002FDataset) (CC BY-NC 4.0). See the\n[Hugging Face model card](https:\u002F\u002Fhuggingface.co\u002Fveichta\u002Fzipsplat) for the full weights license and\ndataset attribution.\n\n## Acknowledgements\n\n`splatfactory` is built mainly on the excellent [glue-factory](https:\u002F\u002Fgithub.com\u002Fcvg\u002Fglue-factory)\ntraining framework. Our model is initialized from the\n[Depth Anything 3](https:\u002F\u002Fhuggingface.co\u002Fdepth-anything\u002FDA3-GIANT) backbone, and rendering uses\n[gsplat](https:\u002F\u002Fgithub.com\u002Fnerfstudio-project\u002Fgsplat). We thank the authors of these projects for\nreleasing their code and models.\n",2,"2026-06-11 04:11:07","CREATED_QUERY"]