Idol Turbo

A distilled, few-step version of speridlabs/idol.
One picture of an object in, up to a million 3D Gaussians out — in 5 guidance-free steps instead of 50 guided ones.

Showcase

Five objects, three panels each: the input image, the turbo at 5 steps (guidance-free, ~0.75s), and the original model at 5 steps (with CFG, 2× the evaluations). The backpack was held out of training:

What this is

Idol Turbo is Idol's flow-matching denoiser distilled for speed:

• 5 sampling steps, no classifier-free guidance — 100 network evaluations (50 steps × CFG) down to 5, a 20× NFE reduction (~0.75s on an H200; 0.66s at 4 steps, ~1.0s at 8).
• Distilled with a Glance-style phase-LoRA recipe (arXiv 2512.02899): two rank-32 low-rank experts — a Slow-LoRA for the high-noise phase, a Fast-LoRA for the low-noise phase (switch at t=0.5) — trained by regression against the teacher's CFG-composed velocity, so guidance is folded into the weights. 29.4M trainable params; the base model is untouched.
• v5 recipe: 4,650 teacher records (50-step CFG 3.0 trajectories) across 93 diverse single-object images, 2,000 training steps (~25 min on one H200). The breadth fixes the early version's main weakness — objects unlike its 10-image training set.

ComfyUI

The turbo works with the Comfy-Org/Idol repack and its TripoSplat workflows — the LoRA keys are compatible (verified: identical module paths) and pre-scaled for strength 1.0:

📂 ComfyUI/
├── 📂 models/
│   ├── 📂 diffusion_models/
│   │   └── idol_fp16.safetensors              ← from Comfy-Org/Idol
│   ├── 📂 clip_vision/
│   │   └── dino_v3_vit_h_bf16.safetensors     ← from Comfy-Org/Idol
│   ├── 📂 vae/
│   │   ├── flux2-vae.safetensors              ← from Comfy-Org/Idol
│   │   └── idol_decoder_fp16.safetensors      ← from Comfy-Org/Idol
│   ├── 📂 loras/
│   │   ├── idol_turbo_slow_comfy.safetensors  ← this repo, loras/
│   │   └── idol_turbo_fast_comfy.safetensors  ← this repo, loras/

Sampling settings: 5 steps, CFG 1.0 (guidance is folded into the LoRA — CFG 1.0 disables the duplicate guidance pass, which is where the 2× comes from). The two LoRA files are phase experts — slow covers the high-noise steps, fast the low-noise steps:

• Full fidelity: chain two sampler stages. Stage 1 runs the first ~4 of 5 steps (shifted t = 1.0 → 0.5) with idol_turbo_slow_comfy at strength 1.0; stage 2 finishes (t = 0.5 → 0) with idol_turbo_fast_comfy. Use KSampler (Advanced): add_noise enabled on stage 1, disabled on stage 2, start_at_step/end_at_step to split.
• Simple: just idol_turbo_slow_comfy for the whole run — at 5 steps, 4 of the 5 steps fall in its phase; expect only a small late-detail cost.

Honest caveat: the LoRA weights and key compatibility are verified, but the two-stage split hasn't been run inside ComfyUI itself — if the fast stage looks off, the simple slow-only path is the safe default.

Step ladder: teacher / naive / turbo (current v5 weights)

Same inputs, same seed, orthographic splat renders. Down the step counts, the naive sampler loses color (backpack goes near-black at 4) and structure (dragon melts at 4); the distilled student holds both, guidance-free, at a fraction of the evaluations:

Recommended default: 5 steps — the turbo-versus-naive gap is widest around 4–6 steps: naive visibly fades there while the turbo still lands close to the teacher. At 8 both are good; below 4 both degrade (turbo more slowly).

Turbo vs naive at 6 steps, with inputs

Honest status

LoRA-scale distill trained on 93 rendered single-object images. Strengths: demo-style single objects (including types it never trained on), guidance-free 4–8 steps, ~16–20× fewer evaluations than the base pipeline. Weaknesses: some inputs come out softer than the 50-step teacher, colors can run warm at 4 steps, and highly saturated objects can land slightly less vivid than the earliest 10-image checkpoint. The base speridlabs/idol at 50 steps is the quality reference. All training runs, metrics and eval renders: akhaliq/idol-turbo-runs.

Usage (Python)

Requires the idol SDK (pip install git+https://github.com/speridlabs/idol-sdk.git) and access to Idol's two gated encoders: facebook/dinov3-vith16plus-pretrain-lvd1689m and black-forest-labs/FLUX.2-dev.

from idol import IdolPipeline
from huggingface_hub import hf_hub_download
import importlib.util

spec = importlib.util.spec_from_file_location(
    "turbo", hf_hub_download("akhaliq/idol-turbo", "turbo.py"))
turbo = importlib.util.module_from_spec(spec)
spec.loader.exec_module(turbo)

pipeline = IdolPipeline.from_pretrained("akhaliq/idol-turbo")
turbo.patch_pipeline_for_turbo(pipeline, "akhaliq/idol-turbo")

output = pipeline("photo.jpg", mode="real", seed=42, steps=5, cfg_strength=0.0)
output.gaussian.save_ply("photo.ply")

This repo is a drop-in weights replacement: denoiser.safetensors, decoder.safetensors, decoder_gs.safetensors, birefnet.safetensors and config.json are identical to speridlabs/idol; idol_turbo_lora.safetensors + turbo.py add the distilled experts and the guidance-free sampler for the SDK path, and loras/ holds the ComfyUI-format phase LoRAs.

License

Apache-2.0, inherited from speridlabs/idol. All credit for the base model to Speri Labs.