Trellis 2 ComfyUI workflow download: reading the JSON, repairing a graph, and the four common variants

A TRELLIS 2 workflow downloaded from a node pack's examples folder, a model repository or a community hub arrives as one .json file. Inside there are no weights, no code and no textures, only a description of a graph: which node types sit on the canvas, how their sockets are wired, and what value every widget holds. Dropping it on the canvas rebuilds that graph, which is why it is worth reading first.

Most download problems are mismatch problems. A graph expects node classes from one custom node pack, weight files with exact names in exact folders, and a frontend new enough to recognise the widgets it is handed. When one of those is off, you get red boxes, a loader that refuses a filename, or a run that finishes with silently wrong settings.

What a ComfyUI workflow JSON actually contains

ComfyUI saves two shapes of JSON. File → Save writes the save format, which carries layout: a nodes array where each entry has an id, a type such as LoadImage or SaveGLB, inputs and outputs arrays for the sockets, and a widgets_values array. Beside it sit links, pairing an output slot with an input slot, and groups, the frames that keep a large graph readable. File → Export Workflow (API) drops all of that and keeps only class_type and inputs per node, keyed by node id, which is what /prompt accepts.

• Frontend version: a current frontend stores widget metadata differently from a 2023-era file, and very old files can load with nodes stacked in one corner.
• Custom node classes: type strings are Python class names, so a missing wrapper turns each node into a red placeholder.
• Widget values: widgets_values is positional rather than named, so a pack that adds a widget shifts every later value by one slot.
• Weight filenames: loader widgets store a filename, not a path, so the graph expects one exact name in one exact folder.

Loading a downloaded graph in the right repair order

1. Drag the .json onto the canvas. A rendered PNG works too: SaveImage embeds the workflow in the image metadata.
2. Read the Missing Node Types dialog first: it lists the class names the file needs. ComfyUI Manager resolves most by package name, but check the repository it offers.
3. Restart the ComfyUI server after installing a pack that registers node classes or ships CUDA extensions; a browser refresh is not enough.
4. Repair widgets from left to right: re-select the checkbox that flipped, re-enter the step count, and re-point every loader at a weight file that exists.
5. Queue one job at low resolution and few steps, then watch for the first failing node; the console lines above it name the cause.

Widget drift earns its own paragraph because it is the one failure in that table that stays silent: nothing is red, the graph runs, the mesh is simply worse. A wrapper that gains a checkbox ahead of its step count pushes every later value one slot to the right, so a seed of 12345 can land in a dropout field. Compare widget counts against a fresh copy of the node, and hover every widget on an unfamiliar graph.

Four TRELLIS 2 variants and what each one changes

Image-to-3D: the baseline chain, group by group

The image-to-3D graph has five node groups. Load and preprocess holds an image loader and usually a background removal step, because TRELLIS 2 is conditioned on that image and a busy background becomes geometry that does not belong to the subject. Conditioning encodes it into the features the flow models read. Sampling holds the two flow-matching stages: one places sparse structure, one fills shape and appearance latents inside it, and both take the resolution, seed and step count. Decoding hands the sparse 3D VAE output to the mesh stage: colour or PBR channels, a simplification target, an optional remesh, a GLB write, then Preview3D.

Text-to-3D: an image model wired in front

TRELLIS 2 is image-conditioned, so a text-to-3D workflow is the same chain with a renderer attached: a checkpoint loader, CLIP text encode, an empty-latent node and a sampler produce one image, which feeds the conditioning node. Two things matter here. The graph is only as good as the 2D model, and a vague prompt gives a flat, symmetric subject that TRELLIS 2 reconstructs faithfully. The stages also compete for one card, so many people render a shortlist first, then mute the text branch before the 3D run.

Multiview: two to four views of one object

A multiview graph adds a view dimension to conditioning: each image is paired with a view index or camera parameters, and the sampler attends across all of them. That extra condition is what fills in the back of an object. It also adds failure modes: the views must agree on scale, orientation and lighting, and must not be four subtly different objects, because the model averages that disagreement into a lumpy silhouette. Two frames from opposite angles usually beat four near-duplicates from one side.

Low-VRAM GGUF: lighter weights, same graph

The GGUF variant does not change the shape of the graph, only what sits in the sampling group. Quantised copies of the large flow transformer are stored as GGUF files, with Q4_K_M and Q5_K_M as the usual trade-offs and Q8_0 when there is headroom, and a GGUF loader reads them in place of the full-precision checkpoint. Expect a smaller footprint and slower sampling, since dequantisation happens on the way to the GPU. Memory also pools: the sparse 3D VAE, the image encoder and the text encoder stay resident, and ComfyUI caches models across runs.

Where these graphs come from, and what to check first

• Built-in templates: the Templates browser ships a curated set that matches the core node version you installed.
• The model repository: the TRELLIS 2 project publishes example graphs beside the weights, close to a reference implementation.
• Node pack repositories: a wrapper's examples folder is the safest source, because the author tests against the version they ship.
• Community hubs: check the licence on the weights, whether the graph downloads anything on first run, and whether its pack is maintained.

When the node graph is not the point

A node graph earns its setup cost when you need reproducibility, one specific checkpoint, or a sweep over dozens of seeds. When the goal is narrower, one photo in and one textured mesh out in an engine- or slicer-ready format, the graph is plumbing maintained for no return. Open3DAI aims at that gap: the same prompt or image can go to the available engines and be compared side by side before export to GLB, glTF, OBJ, STL, PLY or 3MF, with 48 format converters, 12 browser tools and a REST API. It does not run TRELLIS 2 for you, does not train or host third-party models, and does not retopologise, unwrap UVs or rig. Keep ComfyUI for the exact checkpoint; take the hosted path when the file is needed today.

Frequently Asked Questions

Run it yourself in Open3DAI

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.