TRELLIS 2 is a 4B-parameter image-to-3D model, and its ComfyUI wrapper depends on compiled CUDA extensions that must match your Python, torch and CUDA versions. This hub covers what it produces, what a machine needs, and how both workflow builds are assembled.
TRELLIS 2 is the second generation of Microsoft Research's TRELLIS line, published with a tech report in December 2025: a 4B-parameter image-to-3D model that returns fully textured assets from 512³ up to 1536³. It works in O-Voxel, a sparse voxel structure that carries geometry and appearance together.
Running it inside ComfyUI is a different problem from reading the paper. The node pack wraps a research repository with compiled CUDA extensions, so the install is version-sensitive, and a Windows machine with an RTX 50 card meets every edge case at once. This page is the hub: what the model is, what a realistic machine needs, and how both builds fit together.
Microsoft Research describes TRELLIS 2 as an open-source 4B-parameter image-to-3D system that returns fully textured assets from 512³ up to 1536³. Its tech report appeared in December 2025, and the pipeline keeps three beats: an image conditions a sparse structure, the structure is filled with shape, and materials are generated from both.
O-Voxel is the part worth understanding. It stores geometry and appearance together in a field-free sparse voxel structure, including base color, metallic, roughness and alpha, so open surfaces, non-manifold geometry and enclosed cavities stay representable instead of being rounded into a solid. A sparse compression VAE downsamples that data 16×, and Microsoft quotes conversion in both directions: mesh to O-Voxel in under 10 seconds on one CPU, back again in under 100 ms with CUDA. Those are vendor numbers on vendor hardware.
| Component | Realistic baseline | Why this number |
|---|---|---|
| GPU memory | 16 GB comfortable, 24 GB for 1536³; 8-12 GB only with FP8 and offloading | A 4B model in bf16 is about 8 GB of weights, and offloading leans on system RAM |
| Disk | Tens of gigabytes in the ComfyUI tree | Checkpoint, DINOv3 extractor and compiled wheels live there |
| Python and torch | Python 3.11 or 3.12 with a CUDA torch build; wheels ship per version | Each compiled extension is built against one torch ABI |
| Source image | One subject, 1024 px long edge, plain background | Everything the camera never saw is inferred |
Microsoft's published timings are H100 numbers: about 3 seconds at 512³, 17 seconds at 1024³ and 60 seconds at 1536³, shape and material combined. They exclude queueing and export, and do not transfer to consumer cards. On a 16-24 GB desktop GPU the same three tiers typically land in the tens of seconds, a couple of minutes and several minutes, which is why FP8 checkpoints exist.
Most 3D node packs are Python that calls PyTorch; TRELLIS 2 needs sparse convolution kernels, a rasterizer and a voxel encoder, each compiled for one GPU architecture. The wrapper ships prebuilt Windows wheels for cumesh, nvdiffrast, nvdiffrec_render, flex_gemm and o_voxel, sorted by torch version, with Torch270, Torch280 and later Python 3.13 builds for CUDA 13.1. RTX 50 cards are Blackwell, compute capability sm_120, and binaries built without that target usually fail at the first kernel launch with a no-kernel-image error.
| Compiled piece | Role in the graph | Mismatch symptom |
|---|---|---|
| flex_gemm | Sparse convolution and GEMM kernels for structure and shape | Import error at startup, or no-kernel-image at the first sampling step |
| o_voxel | Converts between O-Voxel data and mesh data | Decode finishes but returns an empty voxel set |
| cumesh | Welding, hole filling, remeshing and simplification | Post-processing nodes report a missing module or undefined symbol |
| nvdiffrast, nvdiffrec_render | Rasterization behind texturing and multiview rendering | Shape completes, then texturing crashes at the rasterize step |
| Attention backend | Chooses sdpa or flash_attn_3; natten only for the Pixal3D-T path | Falls back to sdpa and runs slower, or the model will not load |
Run the smoke test in a terminal, not in the UI. From the same interpreter ComfyUI uses, print torch.__version__, torch.version.cuda and torch.cuda.get_device_capability(); an RTX 50 card should report (12, 0) and an RTX 40 card (8, 9). Wheels built without that capability cannot be fixed by rewiring nodes. The dedicated walkthrough covers the commands, the error strings and building cumesh and flex_gemm from source.
The wrapper exposes Heun, RK4 and RK5 samplers, and warns in its changelog that higher-order ones are much slower, so step counts should come down. Structure resolution above 64 is experimental and mainly for cascade pipelines. Texturing resolution is the largest cost lever: 1024 is the default, and 1536 buys finer detail at a large cost in time. Cleanup nodes matter more than they look: open surfaces are allowed here, which is not the same as a printable solid.
TRELLIS 2 is image-conditioned and has no text encoder, so a text-to-3D workflow pairs a text-to-image model such as Flux or an SDXL-family checkpoint with the TRELLIS 2 chain. That split helps when deliberate: a reference image costs seconds to redraw, so fixes are cheaper than a new shape and texture pass. It hurts when invisible, since a prompt that reads well as an illustration often reads badly as a 3D reference.
| Criterion | TRELLIS 2 in ComfyUI | Hosted AI 3D service |
|---|---|---|
| Setup | Hours on Windows aligning wheels; far less on supported Linux and torch builds | An account and a browser tab |
| Control | Samplers, resolutions and cleanup nodes are yours | Only the controls the product exposes |
| Cost | Electricity and time on your own card, no per-generation credits | Metered per generation; compare tiers first |
| Output | GLB with PBR maps, plus cleanup node output | Usually GLB or FBX, sometimes with converters |
| Still manual | Decimation targets, hole filling and print preparation | The same, unless the service sells cleanup |
Standing caveat: TRELLIS 2 is a research release; Microsoft's project page states that the materials are for research rather than commercial use, so read the repository licence before shipping anything built with it. Engine availability, node-pack versions and credit pricing change, so verify on the vendor page before committing a budget. The install walkthrough and the workflow download page carry the hands-on detail. Open3DAI, this site's own generator, runs the same prompt or image through the engines you connect, compares the results side by side, and exports GLB, glTF, OBJ, STL, PLY or 3MF, with 48 format converters, 12 browser tools and a REST API. It does not retopologise, unwrap UVs or rig, and it does not guarantee a watertight mesh, so a Blender pass stays part of the job.
It can, with limits. The 4B checkpoint in bf16 is about 8 GB of weights before the image encoder, VAE and decoder are loaded, so 8-12 GB cards depend on the FP8 checkpoints and offloading options in the wrapper. The 512³ tier is the realistic target there; 1536³ texturing is where 24 GB earns its keep.
No. TRELLIS 2 is image-conditioned and has no text encoder, so a text-to-3D workflow pairs it with a text-to-image model such as Flux or an SDXL-family checkpoint that produces the reference image first.
Almost always a compiled extension built for a different Python, torch, CUDA or GPU architecture. Install the wheel folder that matches your interpreter exactly, and check the startup log for the torch version and detected compute capability before editing any workflow.
No. TRELLIS 2 support arrives through community node packs; the core 3D nodes in ComfyUI cover Hunyuan3D 2.x and the GLB export path. A graph can mix both, and a common pattern is to generate a shape with one family and texture it with another, but neither is a prerequisite for the other.
Usually not on the first try. The representation deliberately supports open surfaces, so the mesh may not be watertight. Fill holes, remesh or simplify with the pack's cleanup nodes, check the result in Blender, then verify wall thickness and overhangs in the slicer as you would for any imported model.
Not automatically. Microsoft's project page describes TRELLIS 2 as a research project and states that the materials are for academic and research purposes and are not intended for commercial exploitation. Read the repository licence and, if the asset matters commercially, take advice rather than trusting a tutorial.
Send the same prompt or image to several engines, compare the meshes side by side, then export GLB, glTF, OBJ, STL, PLY or 3MF. Creating an account grants free credits and needs no card.
TRELLIS 2 arrives as a node package plus three CUDA extensions that compile on your own machine, and an RTX 50-series card changes which toolkit and which PyTorch wheel will work. This is the install order, the environment variables, and the fixes for the errors you will actually hit.
A downloaded TRELLIS 2 workflow is one JSON file describing node types, links and widget values. Most first-load failures come down to four things: a missing node pack, a weight filename that no longer matches, widget values that shifted between pack versions, and a VRAM budget only the GGUF variant fits.
ComfyUI can run Hunyuan3D, TRELLIS and the lighter 3D models behind one node graph, but the weights, the VRAM budget and the trip from a voxel grid to a printable mesh are three separate problems.