Speridlabs Idol: Open Apache-2.0 Model Turns One Image Into a 3D Gaussian Splat

Speridlabs has released Idol, an open image-to-3D model that turns one picture of an object into a 3D Gaussian splat. According to the model card on Hugging Face, it writes up to 1,048,576 Gaussians as a standard .ply, peaks at 7.2 GB of VRAM, and ships under Apache 2.0 with code, weights and a hosted demo. The release landed on October 28, 2026.

If you build games, product viewers, AR scenes or just want to feed generated images into a 3D pipeline, this is one more open option to try next to the models we have already covered, such as Meta's SAM 3D Objects work and the Scenario 3D collection. This post explains what Idol produces, how to run it, what its own benchmark table shows, and where the claims need independent checking.

Idol at a glance #

What does Idol actually do? #

Idol is a single-image 3D generator. You give it one picture and it produces a cloud of 3D Gaussians: small, soft, colored blobs that together render as an object from any angle. This is the representation behind 3D Gaussian splatting, which has become popular because splats render fast in real time and capture fine detail like fur, glass and fabric better than plain meshes.

The key word is including the sides the picture never showed. A single photo only sees one face of an object. Idol has to imagine the back, the underside and the hidden parts, which is why it is a generative model and not a classic reconstruction tool. The same split shows up in our coverage of Meta's GenIA, where the hard part is making a generated 3D guess agree with the photo you started from.

Video: Speridlabs

The reel above is Speridlabs' own demo from the model card. The card's gallery also shows an armchair, an avocado, a lamp, an axolotl, a lollipop, grapes and a castle. These are curated examples, so expect the best case.

How is the model built? #

The card gives a component table rather than a paper, so here is what it states and nothing more:

Together that is about 1.80 billion parameters in a full request, although the part Speridlabs trained, the DiT plus the two decoders, is only around 659M parameters. Keep that distinction in mind when you compare sizes with other models.

The sampling knobs are the usual diffusion ones. Steps default to 50, classifier-free guidance strength to 3.0, and a time-shift setting to 3.0: higher spends more steps on overall shape, lower on fine detail. The card says an optimized path is on by default on GPU, giving roughly 1.7x speed with the same output quality by compiling the denoiser with torch.compile, batching the guided and unguided passes, and using cuDNN attention.

How do I run Idol? #

The setup has one catch: you must accept the terms of two gated models on Hugging Face before the first run.

1. Accept the terms for facebook/dinov3-vith16plus-pretrain-lvd1689m andblack-forest-labs/FLUX.2-dev (only its VAE is downloaded), then log in withhf auth login or setHF_TOKEN .
2. Install the code.

git clone https://github.com/speridlabs/idol-sdk.git
cd idol-sdk
pip install -e .

1. Generate. The weights (about 3 GB) download automatically on the first run.

python -m idol.sample --image photo.jpg --mode real
python -m idol.sample --image renders/ --mode synthetic --out outputs

Each image yields three files: a .ply splat, the processed input image, and a camera JSON with the predicted camera of the input. From Python, the card shows IdolPipeline.from_pretrained("speridlabs/idol"), calling it with an image path, a mode, a seed and num_gaussians.

Pick --mode real for photographs and synthetic (the default) for renders and generated images; the mode only changes how much room the crop leaves around the object. Use --num_gaussians anywhere from 32,768 to 1,048,576 (a multiple of 32; the default is 262,144), and fix --seed to reproduce an object.

If you do not have a suitable GPU, the hosted demo Space is the fastest way to try it. For a wider pipeline that goes from image to a rigged game character, see our guide to an AI image-to-3D rigged game character pipeline.

How fast is it on different GPUs? #

Speridlabs published request times at 50 steps for 262,144 Gaussians, median over 8 images, one GPU per machine:

Two things stand out. First, a consumer RTX 4090 or 5090 gets a splat in 14 to 19 seconds, which is practical for iteration. Second, the RTX 3080 with 10 GB fits within the 7.2 GB peak but takes 46 seconds, so the low-VRAM claim is about fitting, not about speed. The card's header also says it "can run in under 2 seconds"; the table does not show that for 262,144 Gaussians at 50 steps, so that figure presumably refers to fewer steps or Gaussians. The card does not say which, and we have not reproduced it.

How does Idol compare with TRELLIS and LGM? #

Speridlabs compared Idol with TripoSplat, TRELLIS and LGM, scoring at the input view and at seven new views, all on one H100 per model. This table is the authors' own:

How to read it honestly:

• Idol leads on SSIM, LPIPS, IoU, DINOv2, CLIP and sharpness distance. The margins over TRELLIS and TripoSplat are small on the input-view metrics (IoU 0.862 vs 0.860 for TripoSplat) and larger on the novel-view metrics (DINOv2 0.781 vs 0.743 and 0.754).
• LGM has the best PSNR and is about six times faster (1.1 s), but uses only 65,536 Gaussians by default. The card itself notes LGM's PSNR is high despite visibly blurry results, because PSNR averages squared pixel error.
• The card does not name the test set or how many objects it contains, and the benchmark has not been replicated by a third party at the time of writing. It compares at settings Speridlabs chose (50 steps and 262,144 Gaussians for Idol and TripoSplat, the paper setting for TRELLIS, defaults for LGM).
• The metrics are mostly perceptual similarity scores. None of them tells you whether the geometry is clean enough for 3D printing, physics or animation.

In short: a credible sign that Idol is competitive with the open splat generators, from the people who made it. Run it on your own objects before you switch.

What are the limits and open questions? #

• Single objects only. The input is "one picture of an object." Scenes, rooms and multi-object layouts are not what it targets; for scene-scale generation see our posts onTencent's HY-World 2.0 andWorld Labs' Atlas .
• The hidden side is a guess. Anything the photo did not show is generated. Two seeds can give different backs. That is a feature for concept work and a risk for anything that must match a real product.
• Splats are not meshes. The output is a.ply of Gaussians. Game engines and CAD tools usually want meshes, so you need a splat-to-mesh step or a splat-capable renderer.
• Gated encoders. The Apache 2.0 license covers Idol. You still need to accept DINOv3 and FLUX.2-dev terms, and you should read them if you plan commercial use.
• NVIDIA only. The setup lists an NVIDIA GPU with CUDA. Apple Silicon and AMD are not mentioned.
• No paper yet. The card links no paper describing training data or method, so details like the training set are unknown to us. Whether the license covers the training data's provenance is likewise not stated.
• Early adoption. The Hugging Face repo was created on October 28, 2026 and showed 39 likes and 14 downloads when we checked, so there is little community testing yet.

What this means if you build with 3D #

The trend is clear. Open image-to-3D models now fit in consumer VRAM and finish in seconds, and the output format is shifting from meshes to splats. If you make assets, the practical workflow is: generate or choose a clean single-object image, remove clutter, run Idol in synthetic or real mode, view the .ply, and compare against a TRELLIS or Hunyuan-style mesh pipeline for your use case.

A few prompts to try, adapted to the way the card describes inputs:

• Feed a product photo on a plain background with --mode real and compare seeds 42, 43 and 44 to see how much the back changes.
• Feed a generated character render with --mode synthetic and--num_gaussians 1048576 for the highest-detail splat.
• Cut steps to 25 with --steps and measure the quality loss yourself; the card says fewer steps are faster but lose some detail.
• Combine with an image generator: for example, create the input with an open text-to-image model such as MOSS-Image , then lift it to 3D.

Agents that script 3D tools are also getting better at this loop. Our guide to Meshy skills for Hermes Agent shows a hosted version of the same idea, and Idol gives you a local, open alternative to benchmark it against.

What we verified and what we did not #

We read the model card, its component and benchmark tables and the hosted video. We did not run the model ourselves for this post, so the speed and quality figures above are Speridlabs' reported numbers.

Related reading #

Details reflect the model card and repository as of October 30, 2026. Check the Idol model card for changes.