Vi3W
Skip to content

Guides

TRELLIS 2 on 16 GB of VRAM: official limits, community workarounds and alternatives

Can TRELLIS 2 run on 16 GB of VRAM? Officially it needs 24 GB. Here are the ComfyUI, int8 and GGUF workarounds, and the models built for 16 GB.

5 min read

Three graphics cards lined up side by side, each with a small figurine standing on top of it
Illustration. TRELLIS.2 is officially a 24 GB model. On 16 GB, you're choosing a workaround.

Quick answer

Can TRELLIS 2 run on a 16 GB graphics card?

Not officially. Microsoft lists an NVIDIA GPU with at least 24 GB. In practice, community guides report it running at lower resolutions on 16 GB through ComfyUI's native nodes and GGUF builds, with results that vary. If you want a supported setup on 16 GB, TRELLIS v1 is the MIT model built for that much memory.

At a glance

Ways to run TRELLIS.2 or a close alternative on a 16 GB card, from each project's own pages, checked November 21, 2026.
RouteOfficialVRAM basisOutputWatch out for
TRELLIS.2 official repoYes24 GB+ NVIDIA, Linux testedPBR GLB16 GB isn't a supported setup
ComfyUI v0.34+ native nodesYes (ComfyUI core)int8 diffusion model offered; no VRAM figure publishedGLB, with UV and baking nodesResults on 16 GB vary; start at low resolution
GGUF builds (ilintar/trellis2-ggufAero-Ex/Trellis2-GGUF)No, communityAimed at smaller cards; claims unverifiedDepends on the runtimeSome C++ ports do geometry only
TRELLIS v1Yes16 GB+ NVIDIA in the README3D meshOlder model, still maintained
Hunyuan3D 2.0Yes16 GB for shape plus textureTextured meshLicence not valid in EU, UK, South Korea

The official answer

Microsoft's TRELLIS.2 README is clear: it's tested only on Linux, with an NVIDIA GPU with at least 24 GB of memory, verified on A100 and H100 cards. TRELLIS.2 is a 4B-parameter model that turns one image into a PBR GLB, and it's MIT-licensed.

So a 16 GB card, whether that's a desktop RTX card or a laptop GPU, is below the stated minimum. That doesn't mean it can't work. It means nobody at Microsoft promises it will, and you should expect to trade resolution or speed for it.

We haven't measured TRELLIS.2 on any particular card. Everything below comes from the official README, ComfyUI's announcement and community projects, and the community figures are marked as such.

What the community reports on 16 GB

Secondary guides say the heavier step of TRELLIS.2 needs about 16 GB at lower resolution, with 24 GB recommended for 1024 and up, and suggest starting at 512. These come from third-party write-ups, not Microsoft, so treat them as a starting point. The safe summary: community builds aim at 16 GB and below, and results vary.

Route 1: ComfyUI's native nodes, with the int8 model

Since ComfyUI v0.34 (August 2026), TRELLIS.2 is a core node. No custom nodes, no compiled CUDA extensions; the post-processing was rewritten in PyTorch and SciPy. Comfy-Org publishes repackaged weights at Comfy-Org/TRELLIS.2, in bf16 and as an int8 diffusion model. The smaller int8 model is the obvious thing to try on 16 GB. ComfyUI's blog doesn't give a VRAM figure, so you'll find your limit by testing.

A sensible order:

  1. Update ComfyUI to v0.34 or later.
  2. Load the int8 diffusion model from Comfy-Org/TRELLIS.2.
  3. Start at a resolution of 512.
  4. Close other apps using the GPU, then raise the resolution one step at a time until you hit an out-of-memory error.

Full setup: TRELLIS 2 in ComfyUI.

A potted plant model assembling itself from small glowing cubes above a graphics card on a desk
Illustration. Lower the resolution and the model has fewer cubes to fit in memory.

Route 2: GGUF and C++ builds

Quantised builds shrink the model further. They're all community projects:

  • ilintar/trellis2-gguf, the most downloaded (about 205,000 downloads on Hugging Face on November 21, 2026), for trellis.cpp, a C++/GGML runtime with CUDA and Vulkan. It's also usable from Lemonade.
  • Aero-Ex/Trellis2-GGUF (about 46,000 downloads), used by ComfyUI's GGUF nodes.
  • LocalAI-io/TRELLIS.2-4B-GGUF.
  • rms80/trellis2cpp (MIT), a C++/ggml port that does stage-1 geometry only, so no textures.

Vulkan support in trellis.cpp matters if your 16 GB card isn't NVIDIA. For AMD, there are also community ROCm builds such as WakeUpMorty/Trellis2-Rocm-Windows-Installer.

Low-VRAM claims of 6 to 8 GB circulate for GGUF builds. We couldn't verify them.

Route 3: use a model built for 16 GB

If you want a setup that's supported at 16 GB rather than squeezed into it:

  • TRELLIS v1 (MIT) lists an NVIDIA GPU with 16 GB or more. It's older than TRELLIS.2, but still maintained, with a commit on October 27, 2026. On the 3D Arena community leaderboard (November 21, 2026), TRELLIS v1 ranked 6th and TRELLIS.2-4B 18th, though newer entries have fewer votes. See TRELLIS 2 vs TRELLIS.
  • Hunyuan3D 2.0 needs about 16 GB for shape plus texture. Its licence isn't valid in the EU, the UK or South Korea.
  • Hunyuan3D 2.1 fits shape-only in 10 GB with --low_vram_mode, but texture needs 21 GB, so on 16 GB you'd get untextured meshes.

Route 4: don't run it locally

  • The TRELLIS.2 Hugging Face Space demo runs it on someone else's GPU. It's shared, so check its limits.
  • Krea hosts TRELLIS 2 in its 3D feature, with 100 free compute units a day.
  • Vi3W runs TRELLIS and TRELLIS 2 in the browser, alongside Hunyuan 3D, Meshy, Tripo and Rodin. TRELLIS is the free default; other models cost XP, shown before each run.

When it fails on 16 GB

The usual failure is an out-of-memory error partway through a run, often in the heavier stage. Before giving up:

  • Lower the resolution one step. It's the biggest lever you have.
  • Free the GPU. Browsers, games and other AI tools all hold VRAM. Check what's using it with your GPU vendor's monitoring tool.
  • Switch weights. Move from bf16 to the int8 model, or from the native nodes to a GGUF build.
  • Split the work. If you only need shape, a geometry-only build like rms80/trellis2cpp asks less of the card, and you can texture the mesh separately.
  • Check the driver. If generation slows to a crawl instead of failing, the driver may be spilling into system memory. That's a sign you're past what the card holds.

If none of that helps, the model and your card don't fit, and Route 3 or Route 4 is the honest answer.

How to tell whether 16 GB is good enough for you

Run the same image at 512 locally and through a hosted TRELLIS.2, then compare the two in Blender: the wireframe, the texture maps and the thin parts. If the local result is close enough for your use, keep it. If you need higher resolution every time, 16 GB will keep fighting you. More on cards: GPU for AI 3D generation.

Skip the VRAM maths

Run TRELLIS 2 or any of Vi3W's other image-to-3D models in the browser, then rig, retexture or retopologise the result and download it as GLB, FBX, OBJ, STL, PLY or glTF. Try Vi3W.

Frequently asked questions

trellis 2 on 16gb vram

It isn't supported, but community guides say the heavier step fits in about 16 GB at lower resolution, with 24 GB recommended for 1024 and up. Start at 512 in ComfyUI v0.34 or later, using the int8 model, and raise it until you run out of memory.

how much vram does trellis 2 need

The official README says an NVIDIA GPU with at least 24 GB, verified on A100 and H100, and tested only on Linux. Anything below that is a community workaround.

trellis 2 on 8gb vram

Claims of 6 to 8 GB exist for GGUF builds, but they're unverified. On 8 GB, a model built for that memory is a safer bet: TripoSG (MIT, 8 GB+) or TripoSR (MIT, about 6 GB).

trellis 2 gguf

The most downloaded is ilintar/trellis2-gguf, for trellis.cpp, a C++ and GGML runtime with CUDA and Vulkan. Aero-Ex/Trellis2-GGUF is used by ComfyUI's GGUF nodes. Both are community builds, not Microsoft's.

Last reviewed