Idol turns a single photo into a 3D Gaussian splat on a gaming GPU
Speridlabs has released Idol, a model that turns one image of an object into a 3D model of up to a million Gaussians in seconds, including the sides the image never shows. It runs on 7.2 GB of VRAM, so a regular gaming graphics card is enough.
What this is about
The team at Speridlabs has released the model Idol on Hugging Face. From a single image of an object, it produces a three-dimensional representation as a 3D Gaussian splat. This is a technique in which a scene or object is made up of a great many small, soft, colored 3D points ("Gaussians"), a bit like a cloud of tiny dabs of paint. Idol takes a photo, a render or an AI-generated image, removes the background, frames the object properly and generates up to 1,048,576 Gaussians. The model also invents the sides the image never showed.
The output is a regular 3DGS file in .ply format that opens in any common Gaussian splat viewer. According to the maker, Idol runs on consumer graphics cards, needs 7.2 GB of VRAM (video memory) and can finish in under two seconds.
How it works and how to get started
Idol reads its input image through two helper models that are available on Hugging Face only after you accept their terms ("gated"): DINOv3 (facebook/dinov3-vith16plus-pretrain-lvd1689m) and the VAE from black-forest-labs/FLUX.2-dev (only the VAE is loaded). A VAE is a building block that translates images into a compact internal representation. Once you have accepted the terms, you log in once with hf auth login or set HF_TOKEN.
Then you clone the speridlabs/idol-sdk repository and install it with pip install -e .. You need Python 3.10+, PyTorch 2.5+ and an NVIDIA GPU with CUDA. There is no separate download step: on the first run, the Idol weights (about 3 GB) and the two encoders are downloaded automatically into the Hugging Face cache. If the encoders haven't been unlocked yet, Idol stops before downloading and tells you what's missing.
Command-line call: python -m idol.sample --image photo.jpg --mode real. For each image, you get a .ply file, an _input.png (the image after background removal and cropping) and a _camera.json with the estimated camera. You can also pass a folder of images. The mode sets the margin around the object: synthetic (default) for renders and generated single-object images, real for photos with more space around the subject.
Key parameters:
| Flag | Default | Effect |
|---|---|---|
| --seed | 42 | The same value gives the same object |
| --steps | 50 | Sampling steps; fewer is faster but less detailed |
| --cfg_strength | 3.0 | How closely the object follows the image |
| --rescale_t | 3.0 | Higher: more steps for the coarse shape; lower: more for fine detail |
| --num_gaussians | 262144 | 32,768 to 1,048,576, a multiple of 32 |
| --dinov3_dtype | bf16 | fp32 needs 1.7 GB more memory |
By default, accelerated sampling is enabled on the GPU (about 1.7x faster at the same quality, according to the maker): the denoiser is compiled with torch.compile, and guided and unguided passes run as a single batch. The first image in each process is slower because of compilation.
Architecture and memory use
In total, a request involves about 1.8 billion parameters (roughly speaking, the knobs the model learned during training), spread across several components: a DiT denoiser with 370.6M, an octree decoder with 50.8M, a Gaussian decoder with 237.3M, BiRefNet for background removal with 220.7M, DINOv3 with 840.6M and the FLUX.2 VAE with 84.1M. The weights take up about 3.7–4.4 GB, and peak usage is 7.2 GB.
Benchmarks and speed
The maker compares Idol with TripoSplat, TRELLIS and LGM (each on an H100). The evaluation covers the input-image view (PSNR, SSIM, LPIPS, IoU) and seven novel views (DINOv2, CLIP, sharpness distance).
| Model | PSNR | SSIM | LPIPS (lower is better) | IoU | DINOv2 | CLIP | Time |
|---|---|---|---|---|---|---|---|
| Idol | 12.25 | 0.726 | 0.213 | 0.862 | 0.781 | 0.885 | 6.8 s |
| TripoSplat | 11.76 | 0.712 | 0.225 | 0.860 | 0.743 | 0.868 | 9.9 s |
| TRELLIS | 11.89 | 0.716 | 0.235 | 0.845 | 0.754 | 0.868 | 7.1 s |
| LGM | 12.46* | 0.722 | 0.237 | 0.834 | 0.575 | 0.784 | 1.1 s |
LGM has the highest PSNR even though its results are visibly blurry, because PSNR averages squared pixel errors. LGM is also the fastest at 1.1 s, but it uses only 65,536 Gaussians. These are the maker's figures; there are no independent tests.
At 50 steps and 262,144 Gaussians (median over 8 images), the timings look like this:
| GPU | VRAM | Time |
|---|---|---|
| B300 | 269 GB | 3.4 s |
| H100 | 80 GB | 6.7 s |
| RTX 5090 | 32 GB | 14.1 s |
| RTX 4090 | 24 GB | 19.1 s |
| RTX 3080 | 10 GB | 46.2 s |
| L4 | 22 GB | 54.6 s |
So the "under 2 seconds" claim only holds with fewer steps or on very fast hardware. On home GPUs with default settings, expect roughly 15 to 50 seconds.
What you need to try it
- An NVIDIA GPU with CUDA and at least about 8–10 GB of VRAM (peak usage is 7.2 GB; the 10 GB RTX 3080 has been tested).
- Around 3 GB for the Idol weights, plus space for the two encoders in the Hugging Face cache.
- Python 3.10+, PyTorch 2.5+, and a Hugging Face account with access to DINOv3 and FLUX.2-dev.
- According to the source, Mac or CPU-only operation isn't supported; an NVIDIA GPU is required. A cloud GPU (for example in Google Colab) is conceivable in principle, but the source doesn't mention it.
Related news: Gaussian splats in Nuke 17
In a related development, Foundry has released Nuke 17.0, its compositing software for VFX. According to Red Shark News, it now has native support for Gaussian splats: artists can import, view, edit, render and export them. That opens up possibilities for set extensions, matte paintings and element integration. In addition, a new USD-based 3D system leaves beta, a new BigCat node trains ML models across dozens to hundreds of shots, and "Field Nodes" non-destructively mask 3D data, including splats. Foundry cites up to 98x faster GPU upscaling. Nuke 17.0 is available to subscribers, with prices starting at £2,909 per year. The sources don't say whether Idol output works directly in Nuke, but the standard .ply format suggests it should.
Our take
Single-image splats are interesting for game assets, prototypes, product visualization or early VFX studies, and Idol lowers the barrier because it runs on consumer hardware. The quality leads in the table are fairly modest (for example, PSNR 12.25 versus 11.76 for TripoSplat) and come from the maker itself. The unseen sides are necessarily guesswork, so they won't be faithful to the real object. The restriction to single objects, the NVIDIA/CUDA requirement and the gated dependencies (FLUX.2-dev has its own license terms) are limitations. The source doesn't name a license for Idol itself.
Related videos
Sources
- Reddit: lokale Modelle & Bild-KI huggingface.co
- redsharknews.com redsharknews.com
Try it yourself: Idol
Explained step by step, no prior knowledge needed – on your own computer or free in your browser.
What can I do with it?
Idol turns a single image of an object into a 3D model as a Gaussian splat. You feed it a photo, a render or an AI image, and the model cuts out the object, frames it and fills in the back and side views. The result is a .ply file that you can rotate and inspect in splat viewers. It runs on gaming graphics cards with about 8–10 GB of VRAM. According to the maker, it beats similar models such as TripoSplat, TRELLIS and LGM on most quality metrics. Limits: it's meant for single objects, not whole scenes, the hidden sides are estimated, and you need NVIDIA CUDA.
Who is it worth it for?
Interesting for 3D hobbyists, game developers, VFX fans and anyone who wants to quickly view image-AI results in 3D. Less suitable if you don't have an NVIDIA card or need an exact reconstruction of a real object.
Ideas: What you can do with it
An AI-generated concept image of a character or item becomes a 3D splat you can inspect. It's a quick way to check whether a design works in 3D.
Photograph an object, run it with --mode real and get a rotatable model for a presentation.
Splats can be used in compositing tools such as Nuke 17, which now supports Gaussian splats. That lets you test elements roughly.
A single object generated with Stable Diffusion is converted to 3D and can be viewed from all sides.
Turn sketches or renders of hobby objects into 3D to judge proportions from every angle.
What your computer needs
There is one variant. You control quality and speed with --num_gaussians (32,768 to 1,048,576) and --steps. For weaker cards (for example 10 GB), start with the default of 262,144 Gaussians and reduce the steps if needed.
- Peak requirement according to the maker: 7.2 GB of VRAM; the weights alone are about 3.7–4.4 GB.
- An NVIDIA GPU with CUDA, Python 3.10+ and PyTorch 2.5+ are required.
- Times at 50 steps: RTX 4090 about 19 s, RTX 5090 about 14 s, RTX 3080 (10 GB) about 46 s.
- --dinov3_dtype fp32 needs about 1.7 GB more memory.
- The first image in each process is slower because torch.compile is compiling.
How do I find out what my computer has?
- Windows: Press Ctrl + Shift + Esc → Task Manager → Performance tab → click GPU on the left. At the bottom you'll see Dedicated GPU memory (that's your VRAM). You'll find system memory under Memory.
- Mac: Apple menu at the top left → About This Mac. You'll see your chip (e.g. M2) and memory (e.g. 16 GB). On Apple chips, graphics and processor share this memory.
- Linux: Type
nvidia-smiin the terminal (shows your graphics card and its memory) andfree -hfor system memory.
Guide
This model runs with its developers' own program (speridlabs/idol-sdk on GitHub). The commands below come from the Model Card and the developers' instructions.
In the browser (no installation)
The developers have an online demo on Hugging Face. You can try the model right away there without installing anything. Sometimes you have to wait a moment for the demo to wake up.
Windows 10 / 11
Windows 10 / 11: not officially tested. The source only lists Linux requirements (NVIDIA graphics card with CUDA) and doesn't mention Windows. It should work with an NVIDIA card, but it's untested. If you don't have an NVIDIA card, use the online demo on Hugging Face (speridlabs/idol Space).
- Check the requirements. You need an NVIDIA graphics card with at least 8 GB of video memory and a current NVIDIA driver. You also need Python 3.10 or newer and Git. Check in PowerShell that everything is there. The nvidia-smi command shows your card.
python --version git --version nvidia-smi - Hugging Face account and access to the image models. Idol uses two helper models that are gated. Log in to Hugging Face and accept the terms on the pages facebook/dinov3-vith16plus-pretrain-lvd1689m and black-forest-labs/FLUX.2-dev. Then create an access token (read access) in your account under Settings. Approval can take a while.
- Download the program. The git clone command downloads the program code to your computer, and cd moves into the new folder.
git clone https://github.com/speridlabs/idol-sdk.git cd idol-sdk - Create a virtual environment. A virtual environment is a separate, clean Python folder just for this program. Once activated, (.venv) appears in front of your prompt. If PowerShell blocks the script, allow it with Set-ExecutionPolicy -Scope Process RemoteSigned.
python -m venv .venv .venv\Scripts\Activate.ps1 - Install Idol. This installs Idol and its packages. Idol needs PyTorch 2.5 or newer with CUDA support. It can take a few minutes. Afterwards, check that PyTorch sees your card: True should appear.
pip install -e . python -c "import torch; print(torch.__version__, torch.cuda.is_available())" - Log in to Hugging Face. Use this command to enter your token once. You won't see the characters when you paste it, which is normal. Without the access from step 2, Idol aborts and tells you what's missing.
hf auth login - Prepare your own image. Put a photo of a single object into the idol-sdk folder as photo.jpg. The object should be clearly visible. Idol removes the background itself.
- Generate your first 3D object. On first launch, Idol automatically downloads about 3 GB of its own weights plus the two image models. This takes a while. The first run is also slower because PyTorch compiles code. Use --mode real for photos and --mode synthetic for computer-generated images.
python -m idol.sample --image photo.jpg --mode real - Result. The folder contains the files photo.ply (the 3D object), photo_input.png and photo_camera.json.
macOS
macOS: not supported. According to the source, Idol needs an NVIDIA graphics card with CUDA. Macs don't have one. Use the online demo on Hugging Face (huggingface.co/spaces/speridlabs/idol) instead, where you can upload your own images.
Linux
Linux: supported. Officially supported: Linux with an NVIDIA graphics card and CUDA. According to the source, tested cards include the RTX 3080 (10 GB), RTX 4090 and RTX 5090. If you don't have an NVIDIA card, use the online demo on Hugging Face.
- Check the requirements. You need an NVIDIA graphics card with at least 8 GB of video memory and the NVIDIA driver with CUDA. You also need Python 3.10 or newer and Git. The nvidia-smi command shows your card. If it isn't available, the driver is missing.
python3 --version git --version nvidia-smi - Hugging Face account and access to the image models. Idol uses two helper models that are gated. Log in to Hugging Face and accept the terms on the pages facebook/dinov3-vith16plus-pretrain-lvd1689m and black-forest-labs/FLUX.2-dev. Then create an access token (read access) in your account under Settings. Approval can take a while.
- Download the program. The git clone command downloads the program code to your computer, and cd moves into the new folder.
git clone https://github.com/speridlabs/idol-sdk.git cd idol-sdk - Create a virtual environment. A virtual environment is a separate, clean Python folder just for this program. Once activated, (.venv) appears in front of your prompt.
python3 -m venv .venv source .venv/bin/activate - Install Idol. This installs Idol and its packages. Idol needs PyTorch 2.5 or newer with CUDA. It can take a few minutes. Afterwards, check that PyTorch sees your card: True should appear.
pip install -e . python -c "import torch; print(torch.__version__, torch.cuda.is_available())" - Log in to Hugging Face. Use this command to enter your token once. You won't see the characters when you paste it, which is normal. Alternatively, set the HF_TOKEN environment variable. Without the access from step 2, Idol aborts and tells you what's missing.
hf auth login - Prepare your own image. Put a photo of a single object into the idol-sdk folder as photo.jpg. The object should be clearly visible. Idol removes the background itself.
- Generate your first 3D object. On first launch, Idol automatically downloads about 3 GB of its own weights plus the two image models. This takes a while. The first run is also slower because PyTorch compiles code. Use --mode real for photos and --mode synthetic for computer-generated images.
python -m idol.sample --image photo.jpg --mode real - Result. The folder contains the files photo.ply (the 3D object), photo_input.png and photo_camera.json.
What to do after your first result
- Open the .ply file in any Gaussian splat viewer to rotate the object and view it from all sides.
- With --seed, the same value gives you the same object; a different value gives a variant. With --steps (default 50) you can compute faster, but with slightly less detail.
- With --num_gaussians (32768 to 1048576, a multiple of 32) you set the level of detail. With --out outputs you save to a folder, and with --image renders/ you process an entire folder of images.
- For a web interface, install pip install -e ".[demo]" and start it with cd demo and then python app.py.
Try it
python -m idol.sample --image photo.jpg --mode realpython -m idol.sample --image renders/ --mode synthetic --out outputspython -m idol.sample --image figur.png --mode synthetic --num_gaussians 1048576python -m idol.sample --image tasse.jpg --mode real --steps 25 --seed 7Python: IdolPipeline.from_pretrained("speridlabs/idol") and pipeline("photo.jpg", mode="real")Tips for better results
- Use --seed for reproducible results; try several seeds if the back doesn't look right.
- More --steps gives more detail; fewer is faster.
- Use --rescale_t to control whether the coarse shape or fine detail gets more attention.
- Check the _input.png to see how the background removal worked.
If something goes wrong
Without access to DINOv3 and FLUX.2-dev on Hugging Face, Idol aborts before downloading: accept the terms and log in with hf auth login.
The wrong mode argument worsens the cropping: use --mode real for photos and synthetic for renders.
Multiple objects or busy scenes work poorly, since the model is designed for a single object.
The first generation takes longer because of torch.compile.
If you're short on VRAM, reduce the number of Gaussians or keep bf16 for DINOv3.
“out of memory,” a crash, or your computer freezes
The model is too big for your VRAM (video memory). Pick a smaller variant from the table above and close other programs, especially games and browsers with lots of tabs.
It runs, but extremely slowly
Your CPU is probably doing the work instead of your graphics card. In Ollama, the PROCESSOR column of ollama ps shows how much runs on the GPU. If it says "100% CPU", update your graphics driver or pick a smaller variant that fits entirely into VRAM (video memory).
“ollama” or “python” is not found
Close the terminal window and open it again so it recognizes the newly installed program. For Python on Windows: reinstall it and check Add python.exe to PATH.
Windows: "Running scripts is disabled on this system"
Run the script with exactly the command above: powershell -ExecutionPolicy Bypass -File try_windows.ps1. This allows execution for this one time only.
Error message when loading the model (version, "trust_remote_code", unknown architecture)
Brand-new models often need the latest software version. With Ollama: update Ollama. With Python: pip install -U transformers in the activated environment. The Model Card usually lists the exact version.
Tokenstrom generates the scripts and notebook automatically. Please take a quick look before running them – they're plain, readable text. Mind the model's license: apache-2.0.
Ask the AI assistant
Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.
The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.
Comments
What do you think? Already tried it? Write it here, no sign-up needed.
Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.