Idol Turbo in ComfyUI: Image to 3D Gaussian Splat in 5 Steps

Idol turns a single photo of an object into a 3D Gaussian splat you can orbit. Its one downside is speed: it runs 50 guided steps, which works out to 100 network passes per object.

Idol Turbo fixes that. It is a pair of small distilled LoRAs that cut the work to 5 guidance-free steps, which is 20 times fewer network passes. On an H200 that is about 0.75 seconds per object, and it runs on top of the normal Idol model with no new base weights.

This guide covers the files and folders, the two ways to wire it in ComfyUI (simple and two-stage), the Python path, settings, quality trade-offs, and fixes for common errors.

What Idol Turbo Is

Idol is a 0.66B single-image-to-3D model from Speridlabs. It is a retrained TripoSplat model that outputs a standard 3DGS .ply splat with up to about a million Gaussians. If you have not set it up yet, start with my Idol in ComfyUI guide, which covers the base install, the viewer and export formats.

Idol Turbo does not replace the model. It adds two small LoRA “experts” that teach the same model to finish in 5 steps without classifier-free guidance. The base weights are unchanged, so the denoiser, decoder and encoders are exactly the same files.

The release is by akhaliq on Hugging Face, building on Speridlabs’ base model, and it keeps Idol’s Apache-2.0 licence.

How the Two LoRAs Work

Diffusion works in two broad phases. Early, high-noise steps decide the overall shape. Late, low-noise steps add fine detail. Idol Turbo trains a separate expert for each phase:

This is the “Glance-style” phase-LoRA recipe from the paper arXiv 2512.02899. Both LoRAs are rank 32, with 29.4M trainable parameters in total.

Training was light: 4,650 teacher records from 93 single-object images, 2,000 steps, about 25 minutes on one H200. The training runs, metrics and evaluation renders are public in the idol-turbo-runs dataset.

Files and Folders

You need the Comfy-Org repack of Idol plus the two Turbo LoRAs:

The model card does not list file sizes. Check the Files tab on each repo before downloading. The LoRA keys are already compatible with the repack and pre-scaled for strength 1.0.

You also need a ComfyUI build with native TripoSplat support. Any current Desktop, portable or git install has it.

ComfyUI Setup: Simple (Recommended)

This is the safe default. It uses only the slow LoRA for every step, at a small cost in late detail.

1. Open a TripoSplat or Idol image-to-splat workflow. The ComfyUI-Idol template from my base Idol guide works, as do the stock TripoSplat templates.
2. Point the loaders at the Comfy-Org repack files: idol_fp16 in Load Diffusion Model, dino_v3_vit_h_bf16 in the CLIP vision loader, flux2-vae for conditioning, and idol_decoder_fp16 for decode.
3. Add a LoRA loader (LoraLoaderModelOnly) right after the diffusion model. Choose idol_turbo_slow_comfy.safetensors at strength 1.0.
4. Set the KSampler to 5 steps and CFG 1.0.
5. Run. Then save as .ply or .spz as usual.

Setting CFG to 1.0 matters. It switches off the second “unconditional” pass, which is half of where the speed-up comes from. Base Idol in ComfyUI uses CFG 4.0, so remember to change it.

ComfyUI Setup: Two-Stage (Full Fidelity)

This matches how the LoRAs were trained, with each expert handling its own phase. It needs two samplers.

1. Make two model branches from the same diffusion model: one with the slow LoRA and one with the fast LoRA, both at 1.0.
2. Add a first KSampler (Advanced) on the slow branch: steps 5, CFG 1.0, start_at_step 0, end_at_step 4, add_noise enabled, return_with_leftover_noise enabled.
3. Add a second KSampler (Advanced) on the fast branch: steps 5, CFG 1.0, start_at_step 4, end_at_step 5, add_noise disabled. Feed it the first sampler’s latent.
4. Decode and save as normal.

An honest warning: the author says this two-stage split has not been tested inside ComfyUI. The model card describes the switch as roughly the first 4 of 5 steps (t = 1.0 to 0.5). If results look worse than the simple path, go back to slow-only.

Python SDK Setup

If you prefer scripts, the repo is a drop-in replacement for Idol’s weights plus a turbo.py sampler.

1. Install the SDK: pip install git+https://github.com/speridlabs/idol-sdk.git
2. Request access to the two gated encoders on Hugging Face: facebook/dinov3-vith16plus-pretrain-lvd1689m and black-forest-labs/FLUX.2-dev. Log in with hf auth login.
3. Download turbo.py from akhaliq/idol-turbo, load IdolPipeline, and apply patch_pipeline_for_turbo.
4. Call the pipeline with steps=5 and cfg_strength=0.0, then save the result as a .ply.

The model card’s snippet loads from akhaliq/idol-turbo. The SDK path uses idol_turbo_lora.safetensors, not the two ComfyUI files.

Steps, Speed and Quality

These timings are from an H200. The model card gives no consumer-GPU numbers, and I have not benchmarked it myself yet. Base Idol takes 14.1 s on an RTX 5090 and 19.1 s on an RTX 4090 at 50 steps (Speridlabs’ figures).

Cutting 100 passes to 5 should make consumer cards dramatically faster too, though decoding and file saving add a fixed cost.

The model card says the gap over plain few-step sampling is largest at 4 to 6 steps, which is exactly where you want to work.

Idol Turbo vs Base Idol

My rule of thumb: use Turbo while you iterate on many objects, then rerun your final picks on base Idol at 50 steps if you need the sharpest result.

Tips for Better Splats

• Use clean single-object photos. Turbo was trained on single objects only.
• Keep the subject centred with some space around it.
• Watch saturated colours. Very bright objects can look slightly less vivid. If that matters, try 8 steps.
• Fix warm tints by moving from 4 steps to 5 or more.
• Keep 262,144 Gaussians as in base Idol. Higher counts add size, not detail.
• Prune low-opacity Gaussians before sharing, as shown in my base Idol guide, to remove haze.

Troubleshooting

The LoRA seems to do nothing

Check that the LoRA loader sits between the diffusion model and the sampler, and that you are using the _comfy files, not the SDK’s idol_turbo_lora.safetensors.

Output is a blurry blob

You probably kept CFG at 4.0 or used too few steps. Set CFG to 1.0 and steps to 5.

LoRA key mismatch warnings

The LoRAs are made for the Comfy-Org/Idol repack. If you use the Nynxz-converted files from the original Idol guide and see key warnings, switch the diffusion model to idol_fp16.safetensors from Comfy-Org/Idol.

Two-stage looks worse than simple

The split is untested in ComfyUI. Check that the second sampler has add_noise disabled and starts at step 4. Otherwise use slow-only.

Python: 401 or gated repo error

You need approved access to the DINOv3 and FLUX.2-dev repos, and you need to be logged in with hf auth login.

Out of memory

Lower num_gaussians to 65,536, close other GPU apps, or bypass the sampling preview node.

My Take

Idol Turbo is a neat example of how far a tiny distillation can go: 25 minutes of training and two small LoRAs make a 3D model about 20 times cheaper to run.

For anyone turning lots of product photos or props into splats, that is the difference between a batch job and something close to interactive.

Start with the simple slow-only setup at 5 steps. Keep base Idol around for your final, sharpest renders.

FAQ

What is Idol Turbo?

A distilled, few-step version of Speridlabs Idol. It turns one image into a 3D Gaussian splat in 5 steps instead of 50 guided steps.

How fast is Idol Turbo?

About 0.75 seconds at 5 steps on an H200, according to the model card. Consumer-GPU times are not published yet.

How much VRAM does Idol Turbo need?

About the same as base Idol, roughly 7.2 GB at the default Gaussian count, plus a fraction of a gigabyte for the LoRAs.

Which LoRA should I use?

For ComfyUI, start with only idol_turbo_slow_comfy.safetensors for the whole run. The two-stage slow plus fast setup is more faithful in theory, but untested in ComfyUI.

What CFG should I use?

1.0. Turbo is guidance-free, and CFG 1.0 skips the extra pass.

Is the quality as good as base Idol?

Close, but slightly softer, with warmer colours at 4 steps. At 8 steps the difference is small.

Can I use Idol Turbo commercially?

It is Apache-2.0, inherited from Idol, which allows commercial use. The SDK path also uses gated encoders with their own terms, so check those too.

Sources

• Hugging Face: akhaliq/idol-turbo (model card, files, timings)
• Hugging Face: Comfy-Org/Idol repack
• Hugging Face: idol-turbo-runs (training runs and renders)
• arXiv 2512.02899: phase-LoRA distillation
• ComfyUI Wiki: Idol Turbo news