TRELLIS.2 vs TRELLIS vs TripoSR (2026): What Microsoft Changed, and How to Run TRELLIS 2 Free

The whole difference between the two generations starts with representation. The original TRELLIS encodes an object as Structured Latents (SLAT): a sparse grid of latent features that one of several decoders turns into a mesh, 3D Gaussians, or a radiance field. That flexibility is its signature, but the mesh path goes through an iso-surface field, and iso-surface fields struggle with open surfaces such as cloth or leaves, non-manifold geometry, and anything hollow inside. TRELLIS.2 replaces SLAT with O-Voxel, a "field-free" sparse voxel structure that stores geometry (a flexible dual-grid that preserves sharp edges) and appearance (full PBR attributes) in the same voxels, then compresses it with a Sparse Compression VAE at 16 times spatial downsampling, so a 1024-cubed asset fits in about 9,600 latent tokens.

Microsoft's paper puts numbers on it. In its shape reconstruction table, at the same 9.6K-token budget on the Toys4K set, the original TRELLIS scores a mesh distance (MD, which the paper reports scaled by ten to the sixth) of 85.07 and an F1 of 0.074, while TRELLIS.2 at 1024 cubed scores 0.0042 and 0.971, with normal-map PSNR rising from about 30 to 43. Those are Microsoft's own benchmarks on its own data, so read them as the size of the architectural change rather than an independent verdict. The model card is also candid about the cost of topology freedom: raw TRELLIS.2 meshes may occasionally contain small holes or minor discontinuities, and a hole-filling step is provided for strictly watertight needs such as 3D printing. TripoSR sits well below both on fine detail: one feed-forward pass from one view, no way to reason about the unseen side, clean but simple. For geometry, TRELLIS.2 wins this round outright; the original's remaining strength is stylized assets, where its own project page says it excels.

This is the second structural change. The original TRELLIS gets its mesh appearance by baking from the Gaussian output, so the textured GLB it exports is plausible but not a physically based material set. TRELLIS.2 stores base color, roughness, metallic, and opacity in the O-Voxel itself, so every generation is a PBR-ready GLB that responds correctly to lighting, translucent surfaces such as glass or foliage are modeled through the alpha channel, and the reference export writes textures at up to 4096 pixels. There is also a shape-conditioned texturing mode that paints PBR materials onto a mesh you already have, which the original never offered. Two practical notes from the README: the exported GLB is opaque by default until you enable transparency in your DCC tool, and the texture pass is included in the published timings.

TripoSR is the honest weak link: vertex colors only, with an optional baked-texture UV on export and no material synthesis at all, which is why Stability itself points users toward its SF3D successor for faster, more game-ready assets. If lit-ready materials are the point, TRELLIS.2 wins this round and it is not close; the original TRELLIS is a usable middle; TripoSR is geometry first and appearance second.

Here the generational change cuts the other way, and it is the reason the original repo still matters. TRELLIS shipped four models: TRELLIS-image-large (1.2B) plus TRELLIS-text-base, text-large, and text-xlarge (342M, 1.1B, 2.0B), so it does text-to-3D natively, and any result decodes to a mesh, 3D Gaussians for splatting, or a radiance field. A tuning-free multi-image mode was added later with the README's own caveat that it may not give the best results, and the README also warns that the text models are less creative and detailed than the image model.

TRELLIS.2 ships one checkpoint, TRELLIS.2-4B, with one input, a single image, and one output, a PBR mesh as GLB. The roadmap in its README is fully checked off (paper, inference code, checkpoints, Space, texturing, training code) and contains no text-to-3D or multi-image item; the multi-image request in the issue tracker has no maintainer reply. TripoSR is single image in, OBJ or GLB out, nothing else. So if you need text input, splats, or a NeRF from an open Microsoft model, the original TRELLIS wins this round and is the only one of the three that does it.

TRELLIS.2 is one of the few models in this class that publishes real end-to-end numbers: about 3 seconds at 512 cubed (2 s shape, 1 s material), about 17 seconds at 1024 cubed, and about 60 seconds at 1536 cubed, measured on an H100 and including the texture pass. The original TRELLIS never published an end-to-end figure; the TRELLIS.2 paper does show decoder time on an A100 rising from 0.108 s for TRELLIS to 0.301 s for TRELLIS.2 at 1024 cubed, so the new model is doing more work per asset, not less, and buying its quality with compute.

TripoSR is a different kind of model and it is the fast one: a single feed-forward pass that the paper and repo put at under 0.5 seconds on an A100, with no sampling loop at all. The honest caveat is that this is raw inference on a top-tier GPU and end-to-end time grows with background removal and slower hardware. Still, at the low resolution TRELLIS.2 is only a few seconds behind while delivering a full PBR asset; at its top resolution it is a minute per object. TripoSR wins the round; TRELLIS.2 wins the transparency prize for actually publishing timings.

The reference TRELLIS.2 install is the most demanding of the three: Microsoft states an NVIDIA GPU with at least 24 GB, verified on A100 and H100, Linux only, CUDA toolkit 12.4 recommended, and a setup script that compiles flash-attention, nvdiffrast, nvdiffrec, cumesh, o-voxel, and flexgemm. That is up from the original TRELLIS's 16 GB minimum (A100, A6000, also Linux only, with a long-running community Windows thread). Two things soften the 24 GB number. The pipeline defaults to a low-VRAM mode, and since ComfyUI 0.34.0 in August 2026 the model runs natively in ComfyUI with official int8 weights from Comfy-Org and, in the ComfyUI blog's words, everything running on consumer hardware with no compiled CUDA extensions; ComfyUI publishes no VRAM figure, so we will not invent one. Community Windows wrappers exist for both generations, and the 71-comment Windows issue on the TRELLIS.2 repo has no maintainer reply.

TripoSR is the one most people can run on what they already own: about 6 GB of VRAM for a single image and a CPU fallback when there is no CUDA device. It is also the only one of the three with a hosted, in-browser version on this site, which is a paid product and not part of the open model; we say so plainly. If your GPU is the constraint, TripoSR wins this round; if you have a 24 GB Linux box or a recent ComfyUI, TRELLIS.2 is within reach.

There are three genuinely free routes to TRELLIS.2, and they suit different people. First, the official Hugging Face Space: it runs on ZeroGPU with a 120-second GPU reservation per job, offers 512, 1024, or 1536 resolution (default 1024), 100k to 500k face decimation, and 1024 to 4096 texture size, and is free, with the catch that ZeroGPU quotas are small: Hugging Face's documentation gives unauthenticated users 2 minutes of GPU per day and free accounts 5 minutes, and quota is charged by actual GPU time used, so a free account covers a handful of short 512-cubed jobs or only a couple of full-length 1536-cubed runs per day. Second, native ComfyUI: as of v0.34.0 (August 2026) TRELLIS.2 ships inside ComfyUI core with official weights from Comfy-Org, an official tutorial, and, in ComfyUI's words, no custom nodes, no compiled CUDA extensions, no PyTorch downgrades, and no non-commercial dependencies. This is the route for anyone with a decent consumer GPU, including on Windows. Third, the reference local install from the GitHub README, which is the full-fidelity path and wants a 24 GB Linux machine.

The original TRELLIS is weaker here than it used to be: its official Space was in a configuration error state when we checked, so the free routes are the local install and community ComfyUI nodes. TripoSR's free routes are its Hugging Face Space (running), a local install on about 6 GB, and community ComfyUI nodes; the hosted generator on this site is the paid, no-setup route. For breadth of free options, TRELLIS.2 wins this round; for the shortest free path to a first mesh, TripoSR's Space or a 6 GB local install is hard to beat. One honest note from the ComfyUI team's own announcement: the best closed hosted generators still produce better results than TRELLIS.2, so free does not mean best.

All three are MIT, and the differences are in the footnotes. TRELLIS.2 releases its model and code under MIT and its README flags two NVIDIA rendering dependencies, nvdiffrast and nvdiffrec, as governed by their own license terms. The original TRELLIS is MIT for the models and the majority of the code, with two submodules, diffoctreerast and a modified Flexicubes, under separate licenses. Neither is a problem for research, but a commercial deployment of either reference stack takes a quick dependency audit. Notably, ComfyUI's native TRELLIS.2 build was written specifically to avoid non-commercial dependencies, which removes that audit for ComfyUI users.

TripoSR is plain MIT with no submodule caveats, no user cap, no territory clause, and no restriction on what you train with the outputs. It carries no warranty or indemnity, like any MIT project, so responsibility for what you generate is yours. On license cleanliness TripoSR wins; both TRELLIS generations are close behind once you have checked their renderer dependencies.