Speridlabs' open Idol model turns a single photo into a 3D object

Speridlabs released Idol on October 28, 2026. Idol is an open model that takes one photograph, render or generated image of an object and outputs a 3D version that can be rotated. Its weights are published on Hugging Face under the Apache-2.0 licence, and the model card records 20,689 downloads in the last month.

Idol’s output is a 3D Gaussian splat. This is a way of representing an object as many small, coloured, semi-transparent blobs called Gaussians, which a viewer renders from any angle. Idol generates up to 1,048,576 of them, “including the sides the picture never showed,” and writes them to a standard 3DGS .ply file. Speridlabs says the model runs on consumer GPUs, with a 7.2 GB memory peak.

What Idol generates from a single image

Idol targets a specific gap. A builder has one picture of an object and wants something rotatable. That job usually needs a multi-view reconstruction, which requires many photos taken from around the object. Idol works in stages:

1. It removes the background.
2. It frames the object.
3. It generates the Gaussians.

For each image it writes three files:

• the .ply splat, which opens in any Gaussian splat viewer;
• the cropped input image the model actually saw;
• a JSON file with the camera position it predicted for the input.

A mode setting controls how much room the crop leaves around the object:

• synthetic (the default) is for renders and generated images. The object fills 1/1.2 of the frame.
• real is for photographs. The object fills 1/1.7 of the frame.

The project gallery covers furniture, food and small objects, and characters and creatures. ComfyUI Wiki notes that characters “come from the same recipe, with no separate model path”. The demo offers 93 more ready-to-run examples and also accepts users’ own images.

The name invites confusion. A separate academic project, IDOL (“Instant Photorealistic 3D Human Creation”), was accepted to CVPR 2025. It reconstructs animatable 3D humans from a single image. It is not Speridlabs’ model.

Inside the model: a small generator and two decoders

The README describes Idol’s core as “a 370M-parameter rectified-flow transformer, conditioned on DINOv3 and FLUX.2 VAE features of the image”. A rectified-flow transformer is a type of diffusion model that turns random noise into an output over a series of steps. Idol’s transformer generates the object as a latent, a compressed internal description. Two decoders then turn that latent into Gaussians:

• An octree decoder (50.8M parameters) decides where the Gaussians sit in space.
• A Gaussian decoder (237.3M parameters) predicts their attributes.

ComfyUI Wiki adds up the generator and both decoders to 0.66B parameters. LibreYOLO describes Idol as “a 0.66B-parameter rectified-flow transformer”. That differs from the README’s 370M figure for the transformer alone. The two figures fit together if 0.66B is read as the whole generative stack. Three supporting models bring a full request to about 1.80B parameters: BiRefNet for background removal, the DINOv3 ViT-H+/16 image encoder and the FLUX.2 VAE.

LibreYOLO reports that Idol builds on TripoSplat, Tripo AI’s single-image-to-Gaussians model.

Component	Parameters	Weights in VRAM
DiT (denoiser)	370.6M	~0.8–1.0 GB
Octree decoder	50.8M	~0.1–0.2 GB
Gaussian decoder	237.3M	~0.5–0.9 GB
BiRefNet (background removal)	220.7M	~0.44 GB
DINOv3 ViT-H+/16	840.6M	~1.68 GB
FLUX.2 VAE	84.1M	~0.17 GB
Full request	~1.80B	~3.7–4.4 GB of weights, 7.2 GB peak

Figures from Speridlabs’ model card.

Detail is a runtime setting, not a fixed budget

The number of Gaussians can be set anywhere from 32,768 to 1,048,576, in multiples of 32, with a default of 262,144. On the project page, the same lamp produces a 0.4 MB file at the lowest setting and 12.2 MB at the highest. ComfyUI Wiki notes that this lets one object serve “a blockout or a final asset”. LibreYOLO compares this with the rivals’ limits: TripoSplat tops out at 262,144 Gaussians and LGM defaults to 65,536.

Other settings trade speed against quality:

• Sampling steps default to 50. Fewer steps are faster but lose some detail.
• Classifier-free guidance strength sets how strictly the object follows the image.
• Time-shift parameter balances effort between the overall shape and fine detail.
• Fixed seed reproduces the same object again.

A faster sampling path is on by default on GPU. Speridlabs says it is about 1.7x faster with the same output quality. It compiles the denoiser with torch.compile, batches the guided and unguided passes together, and uses cuDNN attention with TF32 matrix maths. The first image in each process is slower while the compile happens.

How Idol compares with TripoSplat, TRELLIS and LGM

LibreYOLO groups Idol with three other open models that turn a single image into Gaussian splats:

• TripoSplat from VAST / Tripo AI (MIT licence, 2026)
• TRELLIS from Microsoft (MIT licence, 2024). It can also output meshes and radiance fields.
• LGM from 3DTopia (MIT licence, 2024). It first generates four views of the object, then predicts Gaussians from them in a single pass.

Speridlabs ran all four models on one H100 each. It scored two things:

• Fit to the input view: PSNR, SSIM, LPIPS and silhouette IoU, which compare a render from the input camera with the input image.
• Consistency from seven new viewpoints: DINOv2 and CLIP similarity, plus a “sharpness distance” that measures how far the sharpness of the unseen sides is from the input’s.

Model (setting)	PSNR ↑	SSIM ↑	LPIPS ↓	IoU ↑	DINOv2 ↑	CLIP ↑	Sharpness dist. ↓	Request time ↓
Idol (50 steps, 262,144 Gaussians)	12.25	0.726	0.213	0.862	0.781	0.885	0.81	6.8 s
TripoSplat (50 steps, 262,144 Gaussians)	11.76	0.712	0.225	0.860	0.743	0.868	1.03	9.9 s
TRELLIS (paper setting, 50 + 50 steps)	11.89	0.716	0.235	0.845	0.754	0.868	0.97	7.1 s
LGM (default, 65,536 Gaussians)	12.46	0.722	0.237	0.834	0.575	0.784	1.22	1.1 s

Speridlabs’ own benchmark, mean scores on one H100 per model.

In Speridlabs’ evaluation, Idol leads every column except PSNR and request time. LGM posts the highest PSNR despite visibly blurry results. The card explains that PSNR averages squared pixel error, so it rewards blur. LibreYOLO reads the table as follows:

• Idol vs TripoSplat is the cleanest comparison, because Idol builds on TripoSplat and both use the same settings. Idol is better on all seven quality metrics and takes about 31% less time.
• Idol vs LGM: LGM is about six times faster, but its new-view scores are far lower. LibreYOLO says the object “often stops looking like itself once you turn it around.”

LibreYOLO adds a caveat: “this is Speridlabs’ benchmark of their own model.” It notes that the code and weights of all four models are public, so anyone can rerun the comparison.

An early hands-on comparison

LibreYOLO also ran Idol, TripoSplat and TRELLIS itself. It used 41 images, mixing photos of real sculptures and buildings with examples from the Idol demo. Each model ran with the same seed and 50 steps on one RTX 4090. On many simple objects all three did well, and Idol and TripoSplat often looked close. Where the outputs differed, LibreYOLO says it was “usually Idol that holds up.” For example, Idol kept the flowers on a Jeff Koons sculpture recognisable all the way round, while TRELLIS turned them into blotches. LibreYOLO picked the six examples where the models differed most to show, so these examples illustrate the differences rather than measure them.

Access, licence and hardware requirements

The Idol weights are tagged Apache-2.0 on Hugging Face. There is one complication. Idol reads its input through two gated models on Hugging Face, and users must accept those models’ terms with a Hugging Face account and log in before running Idol:

• facebook/dinov3-vith16plus-pretrain-lvd1689m
• black-forest-labs/FLUX.2-dev (Idol downloads only its VAE)

Teams planning commercial use should review those terms in addition to Idol’s own licence.

Setup works as follows:

• The code installs from the idol-sdk repository.
• It needs Python 3.10+, PyTorch 2.5+ and an NVIDIA GPU with CUDA.
• On first run, the roughly 3 GB of Idol weights and both encoders download automatically.
• If the encoders are not yet accessible, Idol stops before downloading anything and says what is missing.

Idol ships as Python code, not as a ComfyUI node. A community node, Nynxz/ComfyUI-Idol, wraps the same weights, and a Hugging Face Space runs a demo in the browser. At the time of writing, no hosted inference provider on Hugging Face serves the model. The model page lists six fine-tunes, four quantized versions and 15 Spaces built on Idol.

What it means for builders, and the caveats

Idol is a practical option for teams building game, e-commerce or AR pipelines that start from a single product shot or a generated image. The output is a standard .ply splat, and level of detail can be set per request. Memory needs are modest: ComfyUI Wiki notes that the 7.2 GB peak lets Idol run on a 10 GB card instead of a datacentre GPU.

Several caveats apply:

• The speed claim is not reproduced by the published table. The card says Idol “can run in under 2 seconds”. ComfyUI Wiki points out that no row in the card’s own table matches this. The fastest entry is 3.4 s on a B300 for 262,144 Gaussians, so the site advises treating the table as the reference.
• Consumer cards are much slower. The card lists 14.1 s on an RTX 5090, 19.1 s on an RTX 4090 and 46.2 s on an RTX 3080.
• Some objects remain hard. ComfyUI Wiki calls thin structures and translucency “the hard cases for a splat decoder”.
• The quality lead rests mainly on the maker’s own numbers. The only independent check in these sources is LibreYOLO’s qualitative side-by-side.
• Splats are not meshes. Workflows that need meshes would have to convert the splat. Among the four models compared, TRELLIS is the one that outputs meshes directly.

What to watch next

Key things to watch:

• Independent benchmarks. All four models’ code and weights are public, so third-party reruns of Speridlabs’ benchmark are the obvious next test.
• Integrations and hosting. These include a first-party ComfyUI integration, which does not exist yet, and hosted inference providers taking on the model.
• Community builds. The six fine-tunes and four quantized versions already listed suggest an ecosystem is forming. Whether quantization lowers the memory floor further is an open question.
• The speed claim. It remains to be seen whether Speridlabs reconciles its sub-two-second claim with its own timing table.