This dataset contains per-Gaussian features computed from Splataverse splats of Sketchfab (Objaverse) and Smithsonian Open Access objects. Every object keeps the Creative Commons license of its source (CC BY, CC BY-SA, CC BY-NC, CC BY-NC-SA or CC0; see metadata/attribution.csv). By requesting access you agree to follow each object's license, including attribution and non-commercial terms where they apply, and to cite Splataverse.

Splataverse: lifted features (100K)

Per-Gaussian 2D foundation-model features lifted onto the released Splataverse Gaussian splats, for training models that predict features directly on a 3D Gaussian splat (feature 3DGS without per-scene optimization). It is the training data of the Splataverse feature-prediction models and of the planned direct feature-3DGS challenge.

99,296 objects, 1.11 TB: 98,146 training objects (the train_100k tier of Splataverse split v4) and the 1,150 validation objects, in one block of uncompressed tar shards. The split v4 test objects are deliberately not included: their targets stay hidden for evaluation.

Each object carries three teachers:

head	teacher	dim	objects
DINO	DINOv3 ViT-B/16 (`facebook/dinov3-vitb16-pretrain-lvd1689m`), patch tokens at 512 px	768	all
CLIP	OpenAI CLIP ViT-B/32 (open_clip `ViT-B-32-quickgelu`), MaskCLIP dense tokens in the image-text space	512	all
DeFM	DeFM ViT-L/14 on rendered depth, 518 px	1024	Smithsonian only (`defm_valid`)

plus a global CLIP embedding per object (clip_global) and per view (clip_global_views).

This dataset contains derived data only. Features are computed from renders of the published splats, never from the source meshes. No source mesh, texture or image is included. The splats themselves are in maxwildersmith/splataverse-sketchfab and maxwildersmith/splataverse-smithsonian; metadata/objects.parquet gives the exact file (splat_repo, splat_path) for every object.

This dataset is public with manual access approval. Request access on this page, then authenticate with your approved Hugging Face account.

Layout

data/shard_XXXX.tar        # uncompressed tar of <uid>.npz, up to 500 objects and about 3 GB per shard
metadata/index.json        # uid -> [shard path, byte offset, byte size] of its .npz inside the tar
metadata/objects.parquet   # one row per object: split, tiers, source, license, attribution, splat file, shard, sizes
metadata/attribution.csv   # uid, license, title, author, author URL and source URL per object
metadata/recipe.json       # views, resolutions, teachers and aggregation
splits/val.txt             # 1,150 validation uids
splits/train_{1k,5k,10k,25k,50k,100k}.txt   # nested training tiers, restricted to objects in this block
splits/train_100k_not_in_block.txt          # train_100k uids without lifted features (see below)
load_lift.py               # minimal reader (numpy + huggingface_hub)

The training tiers are nested (1k is inside 5k is inside 10k ...) and follow Splataverse split v4. Each list contains only objects that are in this block:

list	objects
`val`	1,150
`train_1k`	999
`train_5k`	4,984
`train_10k`	9,885
`train_25k`	24,806
`train_50k`	49,788
`train_100k`	98,146

1,854 objects of the v4 train_100k list have no lifted features: 1,852 had no valid result in the original lift run and 2 were dropped when the features were regenerated. They are listed in splits/train_100k_not_in_block.txt. The validation set is complete. Every split is a uid list over the same block, so no data is duplicated.

What is in one object

Each <uid>.npz holds features for two subsets of the object's Gaussians, plus the splat attributes of those Gaussians (copied from the released splat, positions normalized to [-0.5, 0.5]^3) so that a model can be trained without decoding the full splat.

key	dtype, shape	meaning
`dense_src_idx`	int64 (D,)	indices of a random subset of the object's Gaussians, in the order of the released `.spz` file; D = clip(1% of N, 2048, 4096), or N for objects with fewer Gaussians
`dense_dino_targets`, `dense_clip_targets`, `dense_defm_targets`	float16 (D,768), (D,512), (D,1024)	lifted per-Gaussian features of those Gaussians (DeFM all zeros unless `defm_valid`)
`dense_observed`	bool (D,)	Gaussian was visible in at least one view; unobserved rows are zero and should be masked
`dense_xyz`, `dense_log_scales`, `dense_quats`, `dense_opacity`, `dense_rgb`	float32	normalized position, log scale, wxyz quaternion, opacity and color of the same Gaussians
`center_local_idx`	int64 (P,)	P <= 1,024 farthest-point-sampled patch centers, as indices into the `touched_*` arrays
`patch_dino_targets`, `patch_clip_targets`, `patch_defm_targets`	float16 (P, C)	features pooled around each center over its 64 nearest observed Gaussians (Gaussian-weighted)
`patch_target_valid`	bool (P,)	the center had at least one observed neighbor
`touched_xyz`, `touched_log_scales`, `touched_quats`, `touched_opacity`, `touched_rgb`	float32 (T, ...)	the centers and their neighbors (T <= 65,536)
`clip_global`	float32 (512,)	L2-normalized mean of the 16 per-view CLIP image embeddings
`clip_global_views`	float16 (16, 512)	per-view CLIP image embeddings
`norm_center`, `norm_scale`	float32	`xyz_normalized = (xyz - norm_center) * norm_scale` maps the released splat into the unit cube
`uid`, `hf_source`, `defm_valid`, `n_gaussians_full`, `n_touched`, `n_centers`, `n_views`, `dino_model`, `clip_model`, `defm_model`	scalars	identifiers and recipe tags

The full splat has 0.9M Gaussians per object on average (n_gaussians_full); features are released for the sampled subsets only. Features are stored as computed, in float16, and are not normalized (DINO and DeFM features have their native scale). One Smithsonian validation object (871c570f-7e59-5fc1-a1a1-085ccb72e97a) has a dense subset of 131,072 Gaussians.

How the features were computed

Each splat is normalized to the unit cube and rendered with gsplat from 16 turntable views (20 degrees elevation, 40 degree field of view, 512 x 512, grey background). The renders go through DINOv3 and CLIP (MaskCLIP dense mode); for Smithsonian objects, depth renders at 518 x 518 also go through DeFM. Each Gaussian's feature is the mean over views of the feature map sampled bilinearly at its projected center, weighted by the Gaussian's alpha times transmittance at that pixel (its occlusion-aware contribution), so hidden Gaussians do not inherit the features of the surface in front of them. Details are in metadata/recipe.json.

Loading

from huggingface_hub import hf_hub_download
import sys; sys.path.insert(0, hf_hub_download("Splataverse/lifted-features", "load_lift.py", repo_type="dataset").rsplit("/", 1)[0])
from load_lift import LiftedFeatures

ds = LiftedFeatures()
uid = ds.uids("train_1k")[0]
x = ds.get_remote(uid)        # one object over an HTTP range request; ds.get(uid) downloads its shard instead
x["dense_clip_targets"][x["dense_observed"]]

The tars are also plain WebDataset-style shards (<uid>.npz members) and can be streamed with any tar reader. To get the matching full splats:

import pandas as pd
from huggingface_hub import hf_hub_download
meta = pd.read_parquet(hf_hub_download("Splataverse/lifted-features", "metadata/objects.parquet", repo_type="dataset"))
row = meta.set_index("uid").loc[uid]
spz = hf_hub_download(row.splat_repo, row.splat_path, repo_type="dataset")

Intended use

Training and evaluating models that predict per-Gaussian semantic features (CLIP, DINO, DeFM) directly from 3D Gaussian splats, and the Splataverse direct feature-3DGS challenge. Validation features are provided for model selection; the challenge is scored on held-out objects whose features are not public. The features inherit the biases of their teachers and of the object collections (mostly user-uploaded Sketchfab models and museum scans).

Licensing and attribution

Every object keeps the license of its source object, and that license also applies to its features:

license	train	val	total
CC BY 4.0	76,606	763	77,369
CC BY-SA 4.0	5,738	121	5,859
CC BY-NC 4.0	3,063	27	3,090
CC BY-NC-SA 4.0	7,620	67	7,687
CC0 1.0	5,119	172	5,291

Sources: 97,069 Sketchfab objects from Objaverse (author and model page per object in metadata/attribution.csv) and 2,227 Smithsonian Open Access objects (CC0, credit the Smithsonian Institution). The collection has no blanket commercial-use license: filter on license to drop the non-commercial objects (10,777) if you need to. When you redistribute or show results derived from specific objects, credit their authors as the license requires. The teacher models (DINOv3, CLIP, DeFM) have their own licenses; check them for your use of their features. Manual access approval does not replace any of these terms.

Part of Splataverse.

Citation

@misc{splataverse2026,
  title  = {Splataverse},
  author = {TODO},
  year   = {2026},
  note   = {Citation to be added}
}

Downloads last month: -

Total file size:

1.11 TB