Trellis.2 & Pixal3D: Native Image-to-3D Generation Inside ComfyUI

1. Introduction to Native Trellis.2 & Pixal3D in ComfyUI

Trellis.2 and Pixal3D are now built directly into ComfyUI core. What used to require third-party custom nodes, hand-matched CUDA extensions, and a separate Python environment now runs out of the box on whatever ComfyUI install you already have. In this tutorial, you'll learn how to update ComfyUI, download the required model files, and run both the Trellis.2 and Pixal3D image-to-3D workflows to generate clean geometry, PBR-textured meshes, and production-ready 3D assets — all from a single input image, entirely on local hardware.

This native integration also brings a rebuilt 3D pipeline with it: refreshed Load/Preview/Save 3D nodes, a new set of mesh post-processing nodes, and an extended PBR texturing stage that adds normal and ambient occlusion maps on top of the base color, roughness, and metallic maps the models already generate.

2. Requirements & Setup for Trellis.2 & Pixal3D (ComfyUI)

Getting Trellis.2 and Pixal3D up and running in ComfyUI starts with a handful of setup steps. Taking care of these first means both models are properly supported and the workflow runs without issues.

We're testing Trellis.2 and Pixal3D in this tutorial on an NVIDIA RTX 5090. Other GPUs will work too, but keep in mind that available VRAM plays a big role in the mesh resolution and overall speed you can achieve.

Requirement 1: ComfyUI

You'll need ComfyUI running either locally or on a cloud GPU.

Local (Windows): 👉 How to Install ComfyUI Locally on Windows

Cloud GPU (RunPod): 👉 How to Run ComfyUI on RunPod with Network Volume

Requirement 2: Update ComfyUI

Trellis.2 and Pixal3D require a recent version of ComfyUI with native support for both models. For this tutorial, make sure you are running the latest ComfyUI release.

Keeping ComfyUI updated is important to ensure that the required Trellis.2 and Pixal3D nodes and model support are available.

Windows Portable Users: Navigate to: ...\ComfyUI_windows_portable\update Double-click: update_comfyui.bat

RunPod / Linux Users:

1 cd /workspace/ComfyUI && git pull origin master && pip install -r requirements.txt && cd /workspace

1 cd /workspace/ComfyUI && git pull origin master && pip install -r requirements.txt && cd /workspace

Alternatively, you can update ComfyUI directly through the ComfyUI Manager. After updating, restart ComfyUI and verify that the Trellis.2 and Pixal3D nodes appear in the node search.

⚠️ Note: If you launch ComfyUI with the --use-ck-attention flag (Comfy-Kitchen attention), it silently corrupts Trellis.2's shape generation stage — it won't throw an error, the output will just be broken. If your shape generation results look wrong, check your startup flags first

⚠️ Note: If you launch ComfyUI with the --use-ck-attention flag (Comfy-Kitchen attention), it silently corrupts Trellis.2's shape generation stage — it won't throw an error, the output will just be broken. If your shape generation results look wrong, check your startup flags first

Requirement 3: Download the Required Trellis.2 & Pixal3D Models

Next, you'll need to download the Trellis.2 and Pixal3D model files required for the image-to-3D workflow.

Below is a table showing the required files, their download pages, and where they should be placed inside your ComfyUI installation:

Requirement 4: Verify Your Folder Structure

Once all of the model files have finished downloading, verify that your ComfyUI folder structure matches the following:

1📂 ComfyUI/
2├── 📂 models/
3│   ├── 📂 vae/
4│   │   ├── trellis_2_texture_vae_bf16.safetensors
5│   │   └── trellis_2_shape_vae_bf16.safetensors
6│   ├── 📂 clip_vision/
7│   │   └── dino_v3_L_naf_fp32.safetensors
8│   ├── 📂 geometry_estimation/
9│   │   └── moge_2_vitl_normal_fp16.safetensors
10│   ├── 📂 background_removal/
11│   │   └── birefnet.safetensors
12│   └── 📂 diffusion_models/
13│       ├── trellis_2_int8_convrot.safetensors
14│       └── pixal3d_int8_convrot.safetensors

1📂 ComfyUI/
2├── 📂 models/
3│   ├── 📂 vae/
4│   │   ├── trellis_2_texture_vae_bf16.safetensors
5│   │   └── trellis_2_shape_vae_bf16.safetensors
6│   ├── 📂 clip_vision/
7│   │   └── dino_v3_L_naf_fp32.safetensors
8│   ├── 📂 geometry_estimation/
9│   │   └── moge_2_vitl_normal_fp16.safetensors
10│   ├── 📂 background_removal/
11│   │   └── birefnet.safetensors
12│   └── 📂 diffusion_models/
13│       ├── trellis_2_int8_convrot.safetensors
14│       └── pixal3d_int8_convrot.safetensors

With ComfyUI updated, all required Trellis.2 and Pixal3D model files downloaded, and the folder structure verified, you're ready to load the workflow and start generating 3D assets with Trellis.2 and Pixal3D.

3. Running Trellis.2 & Pixal3D Image-to-3D Workflows in ComfyUI

Now that ComfyUI has been updated and all the required Trellis.2 and Pixal3D model files are in place, it's time to download and load the Trellis.2 / Pixal3D workflow into ComfyUI. The workflow includes the necessary nodes and settings to generate a 3D asset from a single image.

Step 1: Download the Workflow

First, download the Trellis.2 / Pixal3D image-to-3D workflow JSON file. This file contains the complete workflow configuration and will allow you to quickly set up the generation process without having to build the workflow manually.

👉 Download Trellis.2 / Pixal3D Image-to-3D Workflow JSON

Step 2: Load the Workflow

Once you have downloaded the workflow JSON file, open ComfyUI.

To load the workflow, simply drag and drop the JSON file into the ComfyUI interface. ComfyUI will automatically import the workflow and display all of the nodes and connections, including the image loader, background removal, and both the Trellis.2 and Pixal3D diffusion nodes.

### Step 3: Input Your Image

Upload a single image as input. Background removal is handled automatically through the native BiRefNet node, so there's no need to pre-mask your subject. A clear, well-lit subject with a front-facing or three-quarter view will generally give the cleanest mesh.

Step 4: Choose Trellis.2 or Pixal3D

The workflow includes both models wired into a single graph, with a Boolean (Switch to Trellis2) node controlling which one runs.

• Leave it set to False to generate with Pixal3D (the default) — geometry that's pixel-aligned with the input image, built on the Trellis.2 backbone but tracking the source photo more closely.
• Set it to True to switch to Trellis.2 — a strong general-purpose choice for high-fidelity geometry and materials, effective at resolutions up to 1536³ and capable of handling open surfaces, non-manifold geometry, and fully enclosed volumes.

Leave it set to False to generate with Pixal3D (the default) — geometry that's pixel-aligned with the input image, built on the Trellis.2 backbone but tracking the source photo more closely.

Set it to True to switch to Trellis.2 — a strong general-purpose choice for high-fidelity geometry and materials, effective at resolutions up to 1536³ and capable of handling open surfaces, non-manifold geometry, and fully enclosed volumes.

Step 5: Run the Workflow

Hit Run. The model will generate the mesh, followed by the PBR texturing stage, which produces base color, roughness, and metallic maps. If your workflow includes the UV unwrapping and baking nodes, normal and ambient occlusion maps are generated as well, giving you a complete material set straight out of the graph.

Runpod Special Offer

Load $10, get up to $500 in bonus credits randomly!

4. Inside the Workflow: What Each Stage Does

The graph is organized into labeled groups that map directly to the image-to-3D pipeline, from the raw input image to a fully textured, exportable mesh. Understanding what each group does makes it much easier to tune settings for your own hardware or output needs.

Upload & Image Pre-Processing

• Upload Input Image Here — a single Load Image node; this is your only required input.
• Remove Background — runs the image through the native BiRefNet node. A Switch: Remove background toggle controls this and is set to True by default, so background removal runs automatically unless you turn it off (useful if you're feeding in an already-clean, pre-masked image).
• Get Camera FoV — a MoGe geometry estimation model (moge_2_vitl_normal_fp16.safetensors) analyzes the input image and estimates its camera field of view, which helps the model reason about the subject's real-world proportions before generating geometry.
• The cleaned, cropped image (via ImageCropToMask, padded and centered on your subject) then feeds into conditioning.

Upload Input Image Here — a single Load Image node; this is your only required input.

Remove Background — runs the image through the native BiRefNet node. A Switch: Remove background toggle controls this and is set to True by default, so background removal runs automatically unless you turn it off (useful if you're feeding in an already-clean, pre-masked image).

Get Camera FoV — a MoGe geometry estimation model (moge_2_vitl_normal_fp16.safetensors) analyzes the input image and estimates its camera field of view, which helps the model reason about the subject's real-world proportions before generating geometry.

The cleaned, cropped image (via ImageCropToMask, padded and centered on your subject) then feeds into conditioning.

Conditioning & the Model Switch

Both diffusion models are loaded side by side — trellis_2_int8_convrot.safetensors and pixal3d_int8_convrot.safetensors — along with a CLIP Vision loader and shared VAEs. The Boolean (Switch to Trellis2) node sits right next to a note confirming its behavior: false routes the graph through Pixal3D, true routes it through Trellis.2. Everything downstream automatically uses whichever model you've selected.

Sparse Structure Generation

The first sampling stage generates a coarse voxel structure from the conditioning — essentially a rough 3D blueprint of your subject. It runs through a dedicated KSampler (12 steps, CFG 7.5 by default) along with a CFG Override and RescaleCFG pair; a note directly in the graph explains these exist purely to match the original reference pipeline's sampling behavior. The result is decoded and converted from voxels into a rough mesh, with its own Preview 3D node so you can sanity-check the coarse shape early, before committing to the slower stages.

Shape Generation

The sparse structure is refined and upsampled into detailed geometry across two more KSampler passes (12–20 steps each), progressively adding resolution. This is where Pixal3D's pixel-aligned correspondence or Trellis.2's general-purpose shape modeling actually does its work.

Texture Generation

A separate KSampler pass generates the texture latent for the mesh, which is then decoded through a dedicated texture VAE ahead of the baking stage.

Mesh Post-Processing

Before texturing, the raw generated mesh is cleaned up:

• Remesh Mesh runs at a 768 resolution (UDF mode) to fix holes and topology issues from generation.
• Decimate Mesh then reduces the mesh down to a 700,000-face target using midpoint decimation — a reasonable budget for most uses, but worth lowering further if you're targeting real-time or game-engine assets.
• Smooth Mesh Normals cleans up shading artifacts left over from remeshing.

Remesh Mesh runs at a 768 resolution (UDF mode) to fix holes and topology issues from generation.

Decimate Mesh then reduces the mesh down to a 700,000-face target using midpoint decimation — a reasonable budget for most uses, but worth lowering further if you're targeting real-time or game-engine assets.

Smooth Mesh Normals cleans up shading artifacts left over from remeshing.

Texture Baking

This is where the full PBR material set comes together. The Texture Resolution primitive controls output size and defaults to 4096 (drop this to 2048 or 1024 if you're VRAM-limited or don't need full 4K textures). From here, the workflow:

• Unwraps the mesh's UVs.
• Bakes base color, roughness, and metallic maps from the generated voxel texture.
• Bakes a normal map and an ambient occlusion map directly from the high-poly mesh.
• Applies the finished textures back onto the mesh, with individual Preview Image nodes for each map (Base Color, Roughness, Metallic, Normal, Ambient Occlusion) so you can inspect them before export.

Unwraps the mesh's UVs.

Bakes base color, roughness, and metallic maps from the generated voxel texture.

Bakes a normal map and an ambient occlusion map directly from the high-poly mesh.

Applies the finished textures back onto the mesh, with individual Preview Image nodes for each map (Base Color, Roughness, Metallic, Normal, Ambient Occlusion) so you can inspect them before export.

Vertex Color Preview (Fast Alternative)

Alongside the full PBR pipeline, the workflow includes a Paint Mesh branch that vertex-paints the mesh directly instead of baking a full texture set. It's a much faster way to preview color and shape together without waiting on the UV unwrap and baking stages — useful for quickly checking a result before committing to a full-resolution texture bake.

Saving Your Output

The finished mesh is written out through Save 3D (Advanced), which saves to a 3d/ComfyUI output folder by default. Both the fully textured mesh and the faster vertex-color preview have their own Preview 3D nodes so you can compare results directly in ComfyUI before exporting.

5. New 3D Nodes & Mesh Post-Processing

This release also rebuilds ComfyUI's core 3D tooling, not just the two models:

• Load 3D (Advanced) / Preview 3D (Advanced) / Save 3D (Advanced) — rebuilt to support modern mesh workflows and the new model outputs.
• Remesh Mesh — fixes holes and general mesh imperfections.
• Decimate Mesh — reduces face and vertex count to a target budget, useful for game-ready assets.
• Smooth Mesh Normals — smooths the mesh volume.
• Fill Holes — patches gaps left over from generation.
• Additional nodes such as Merge Meshes, Paint Mesh, and Render Mesh round out the post-processing set.

Load 3D (Advanced) / Preview 3D (Advanced) / Save 3D (Advanced) — rebuilt to support modern mesh workflows and the new model outputs.

Remesh Mesh — fixes holes and general mesh imperfections.

Decimate Mesh — reduces face and vertex count to a target budget, useful for game-ready assets.

Smooth Mesh Normals — smooths the mesh volume.

Fill Holes — patches gaps left over from generation.

Additional nodes such as Merge Meshes, Paint Mesh, and Render Mesh round out the post-processing set.

6. Conclusion: A Fully Native Open 3D Pipeline

Trellis.2 and Pixal3D are now first-class citizens inside ComfyUI: no custom nodes, no compiled CUDA extensions, no PyTorch downgrades, and nothing standing in the way of commercial use. Combined with the rebuilt Load/Preview/Save 3D nodes and the new mesh post-processing suite, ComfyUI now offers a complete open-source, local image-to-3D pipeline at zero cost per asset.

It's worth being upfront: the top closed-source 3D generators still edge out Trellis.2 and Pixal3D on raw output quality. But for iteration, prototyping, stylized work, and anyone who wants full local control of their pipeline without spending an afternoon on installation, this native integration is the easiest way yet to turn a single image into a usable 3D asset inside ComfyUI.