3D generation model

Self-host TripoSR: one image, one mesh, half a second

The single-image 3D reconstruction model from Tripo AI and Stability AI. Roughly 6GB of VRAM, MIT across the board. On NexGPU one RTX 3090 takes you from boot to your first .obj.

TripoSR · self-hosted

TripoSR is a feed-forward LRM (Large Reconstruction Model): no diffusion sampling, no SDS optimisation, no multi-view consistency loop. One forward pass produces triplane features, a small NeRF decoder plus marching cubes turns them straight into a mesh. The published figure is under 0.5 seconds for a complete textured mesh on an NVIDIA A100, with roughly 6GB of VRAM for a single image at default options. The checkpoint, model.ckpt, is 1.68GB. Among 3D generative models that routinely ask for tens of gigabytes, that is absurdly small.

The architecture explains the low footprint. The image side is facebook/dino-vitb16 taking 512×512 input at 16×16 patches. The backbone is a 16-layer transformer with 16 attention heads at 64 dims each (1024 channels total), pulling DINO features through 768-dim cross-attention. The triplane tokeniser starts at 32×32 with 1024 channels and the post-processor upsamples to 64×64×40. The decoder is a 9-hidden-layer, 64-neuron SiLU MLP; the renderer uses a radius of 0.87 and 128 samples per ray. The tech report is explicit that the 40-channel triplane was chosen specifically to keep inference memory down — that choice is the direct reason this fits on a 6GB card.

Two years on, single-image-to-3D is crowded: TripoSG 1.5B, TRELLIS 1.2B and Hunyuan3D 2.1 are all bigger, slower and sharper, and TripoSR does not win on geometric detail. What it still owns is two things nobody has taken from it. Latency: half-second feed-forward inference is still unmatched for live preview, bulk draft meshes, and seeding a refinement model with an initial mesh. And licensing: source, pretrained weights and the interactive demo are all MIT, while Stability's own successor Stable Fast 3D moved to the Stability Community License, where organisations above $1M annual revenue need a separate enterprise agreement. If you want a 3D reconstruction model you can ship, modify and sell, TripoSR is still line one on the list.

01 —

What TripoSR ships, and what to pair it with in 2026

There is exactly one official checkpoint — the thing to get straight is the VRAM ladder around it.

Version	Parameters	VRAM	Context	Notes
stabilityai/TripoSR (official weights)	model.ckpt 1.68GB fp32 (~420M parameters)	~6GB fp32 at run.py defaults	512×512 single image in, mc-resolution 256	The only officially released checkpoint. Source and weights are both MIT. Default output is .obj with vertex colours and no UVs.
TripoSR with --bake-texture	Same weights, different output path	VRAM unchanged; xatlas UV unwrap and 2048² baking hit CPU and system RAM	--texture-resolution defaults to 2048, exports .glb	Required if the asset is going into Blender, Unity or a 3D-print slicer — vertex-coloured meshes render as grey blobs in most DCC tools.
Stable Fast 3D (SF3D)	Stability AI's separate successor, tech report August 2024	Not published; comfortable on a 24GB card in practice	Single image to UV-unwrapped mesh with PBR material, under a second	Adds delighting, per-object roughness/metallic and low polygon counts — but the licence is the Stability Community License, with an enterprise licence required above $1M annual revenue.
TripoSG 1.5B	1.5B rectified flow transformer plus an SDF VAE at 2048 latent tokens	At least 8GB per the project's own requirement	Released March 2025; a 512-token CFG-distilled scribble variant followed in April	VAST's own quality line, also MIT. Clearly better geometry than TripoSR, at the cost of leaving the half-second regime behind.
TRELLIS-image-large	1.2B (the text line adds 342M / 1.1B / 2.0B)	At least 16GB, tested on A100 and A6000	Released December 2024, built on the SLAT structured latent representation	One latent exports to 3D Gaussians, radiance fields or meshes. MIT, with a couple of submodules under other terms.
Hunyuan3D 2.1	3.3B shape model plus a 2B texture model	10GB shape only, 21GB texture only, 29GB for the full pipeline	Released 13 June 2025, needs Python 3.10 and PyTorch 2.5.1+	The best open PBR texturing available, and the steepest memory bill — 29GB rules out every 24GB consumer card.

02 —

Which GPU actually makes sense for TripoSR

A 6GB requirement means you should not overpay for VRAM. Spend on throughput and on whatever refines the mesh afterwards.

First runs, a long-lived Gradio demo, bulk draft meshes at defaults
RTX 3090 24GB$0.193/GPU-hour
For a 6GB workload this is the cheapest 24GB card on the list — about 35% below the 16GB Tesla T4 at $0.298/GPU-hour, with 8GB more memory.
Production batches: mc-resolution 512 combined with --bake-texture at 2048²
RTX 4090 24GB$0.540/GPU-hour
Marching cubes and xatlas unwrapping are single-card throughput problems; the 4090 gives the shortest end-to-end time per image, which under per-second billing is often the cheaper total.
Reproducing the reported sub-0.5s A100 number, or running a fair benchmark
A100 PCIE 80GB$0.824/GPU-hour
The paper's baseline is an A100, so same-card comparison is the only comparison worth publishing — and 80GB leaves room to keep TripoSG or TRELLIS resident for A/B runs.
TripoSR for the draft, Hunyuan3D 2.1 for the refinement, on one card
RTX A6000 48GB$0.817/GPU-hour
Hunyuan3D 2.1 needs 29GB for shape plus texture; 48GB holds the entire pipeline so you never pay the I/O of swapping models in and out.

03 —

Boot to first .obj in four steps

Every real pitfall lives in step two, in torchmcubes. Line up your CUDA versions and the rest is uneventful.

01
Start an instance with CUDA
Pick an RTX 3090 24GB in the NexGPU console and a prebuilt PyTorch image. Before anything else, confirm nvcc and the CUDA that PyTorch was built against are the same major version — if they are not, the torchmcubes build in step two will fail.
```
nvidia-smi && nvcc --version && python -c "import torch; print(torch.__version__, torch.version.cuda)"
```
02
Clone and install
requirements.txt pins transformers to 4.35.0, trimesh 4.0.5, xatlas 0.0.9, moderngl 5.10.0 and omegaconf 2.3.0, and installs torchmcubes as a CUDA extension compiled from tatsy's repository. "Failed building wheel for torchmcubes" remains the single most reported issue on the project, and the cause is almost always an nvcc/torch CUDA mismatch — align them and reinstall. setuptools must be 49.6.0 or newer.
```
git clone https://github.com/VAST-AI-Research/TripoSR && cd TripoSR && pip install -U "setuptools>=49.6.0" && pip install -r requirements.txt
```
03
Run your first image
run.py first strips the background with rembg (--foreground-ratio defaults to 0.85; --no-remove-bg skips it), runs a single forward pass to get the triplane, then extracts the surface with marching cubes. The first run pulls the 1.68GB model.ckpt from stabilityai/TripoSR plus the rembg u2net weights. If memory is tight, lower --chunk-size from 8192 — it sets the evaluation chunk for surface extraction and rendering, and 0 disables chunking entirely.
```
python run.py examples/chair.png --output-dir output/ --mc-resolution 256 --chunk-size 8192
```
04
Bake a texture if the asset is going into a DCC tool
The default .obj carries vertex colours only, which most tools render as an untextured grey mesh. --bake-texture runs xatlas to unwrap UVs and bakes a texture; pair it with --model-save-format glb for a single distributable file. Note that raising mc-resolution from 256 to 512 takes the density grid from 256³ (~16.8M sample points) to 512³ (~134M) — exactly 8× — so budget time and memory accordingly.
```
python run.py input.png --bake-texture --texture-resolution 2048 --mc-resolution 512 --model-save-format glb --output-dir output/
```

What this actually costs

TripoSR's cost shape is nothing like an LLM's: there is no service process holding weights resident, the checkpoint is 1.68GB, and what you are really renting is the window in which a batch finishes. On an RTX 3090 24GB at $0.193/GPU-hour: environment setup including the torchmcubes build, call it 20 minutes, is 0.193 × 0.33 ≈ $0.064. An hour of the card fully occupied by a batch job is $0.193. A full eight-hour working day without stopping is 0.193 × 8 = $1.54. If you want the absolute floor, a Tesla V100 32GB is $0.188/GPU-hour with 8GB more memory — the tradeoff is Volta having no bf16, which barely matters when TripoSR runs fp32 anyway. To match the paper's baseline, an A100 PCIE 80GB at $0.824/GPU-hour costs 0.824 × 0.5 = $0.41 for a half-hour benchmark. The output side is just as cheap: 1000 .glb files at roughly 3MB each is 3GB, and at the $0.0081/GB median egress rate that is 3 × 0.0081 ≈ $0.024. Keeping 10GB of weights and outputs on disk at the $0.414/GB-month median is $4.14 a month. Compute billing stops the moment the instance stops; storage keeps billing until you destroy the volume. Everything is metered per second and priced per hour, with no minimum, no setup fee and no quota request.

04 —

Frequently asked questions

How much VRAM does TripoSR need? Will it run on an 8GB card?

The published figure is about 6GB for a single image at default options, so an 8GB card is fine. The setting that actually drives memory up is --mc-resolution: 256 is safe, and 512 makes the density grid 8× larger. If you are tight, lower --chunk-size from 8192 — it controls the evaluation chunk for surface extraction and rendering, smaller means less VRAM and more time, and 0 disables chunking. On NexGPU an RTX 3090 24GB is $0.193/GPU-hour, which is enough headroom to test every one of those settings without ever hitting OOM.

Is TripoSR still worth using in 2026, or has TripoSG or Hunyuan3D replaced it?

On geometric detail, TripoSG 1.5B, TRELLIS 1.2B and Hunyuan3D 2.1 (3.3B shape plus 2B texture) all beat it, and there is no argument to be had there. But their memory floors are 8GB, 16GB and 29GB respectively, and none of them is anywhere near half a second. TripoSR's role is precise: live preview, bulk drafts, seeding a refinement model with an initial mesh — and the only fully MIT commercial licence in the group. The common production pattern is running both pipelines side by side, and on NexGPU a single RTX A6000 48GB at $0.817/GPU-hour holds TripoSR and the complete Hunyuan3D 2.1 pipeline at once.

How do I fix "Failed building wheel for torchmcubes"?

It is the most frequently filed issue on the TripoSR repository. requirements.txt installs torchmcubes as a CUDA extension built from tatsy's source, so nvcc's CUDA version has to match the CUDA your PyTorch build was compiled against. Compare nvcc --version against torch.version.cuda, then either swap the PyTorch wheel or the CUDA toolkit and reinstall torchmcubes. When they are mismatched it silently falls back to a CPU path, slow enough that people blame the model. NexGPU's library of 2,000+ prebuilt images includes PyTorch images where nvcc and torch already line up, which removes this step entirely.

Does TripoSR output textured models? Can I import them into Blender or Unity?

The default .obj has vertex colours and no UVs, so Blender and Unity will usually show a grey mesh. Add --bake-texture and xatlas unwraps UVs and bakes a texture at --texture-resolution, which defaults to 2048; add --model-save-format glb and you get one distributable file. That stage leans on CPU and RAM more than VRAM, so your card choice does not change — but wall-clock time grows noticeably. On NexGPU an RTX 4090 24GB at $0.540/GPU-hour gives the shortest total time for batch baking.

Can I use TripoSR commercially? What is the licence exactly?

MIT, and it covers the source, the pretrained weights and the interactive demo — the least restrictive terms in this category. For contrast, Stability's own successor Stable Fast 3D moved to the Stability Community License, where organisations above $1M in annual revenue must buy an enterprise licence. TripoSR was trained on a curated CC-BY subset of Objaverse. If you are evaluating it for a product, rent by the second on NexGPU, validate the output, and stop the instance — compute billing ends there, with no annual contract to negotiate first.

Can TripoSR run on CPU if I have no GPU?

run.py exposes --device, which defaults to cuda:0, and setting it to cpu does work — but the half-second forward pass stretches into minutes and marching cubes is slow too. Fine for verifying a code path, unrealistic for any real volume. Worth knowing: a mismatched torchmcubes build also silently drops to CPU, which is the actual explanation behind a lot of "TripoSR is so slow" reports. Rather than buying a card for it, open a Tesla V100 32GB on NexGPU at $0.188/GPU-hour, billed per second, and stop it when the batch is done.

Start building on NexGPU

Enterprise R&D team or solo developer — either way, your first job can be running in minutes.