Hi3D V1.0 · 几何精修

Here's the split nobody explains before you install a 3D pack: generating a mesh and refining one are different jobs, and Hi3D only does the second. You bring a reference image and a rough mesh of the same object; Hi3D Refine (Hi3D V1.0 · 几何精修, class Hi3DRefine) re-samples the geometry against the image and hands back a denser, more faithful surface.

That's useful, because generation is where the field is weak. Our 3D generation guide opens with the fact that image-to-3D returns an impressive silhouette over triangle-soup topology, and that hard-surface props reconstruct far better than organics. Hi3D is the second pass you run when the silhouette is right and the surface isn't.

What happens when you hit queue

The coarse mesh gets voxelised - adaptively, targeting ~80,000 occupied voxels at the first rung - and a flow-matching transformer samples sparse structure conditioned on the reference image, encoded by DINOv2 Large and CLIP ViT-L/14. A sparse VAE decodes it, then the mesh is simplified to a face budget and scrubbed of floating debris (components under 0.5% of the face count get dropped). Geometry only: no UVs, no materials, no texture. What comes back is a normalised, re-topologised shape.

The clever bit is that resolution isn't just a quality slider, it's a ladder: 512 output means one refinement rung, 1024 means two, 1536 means three - and each rung runs your full step count. So the cost isn't linear, it's multiplicative. T8star's own validation runs on a desktop 5090 back this up: 512 at 25 steps lands around three to four minutes, 1024 comes in near 16 minutes, and 1536 takes roughly 40. Same seed, same image, three times the passes.

Which sets your working loop: 512 / 25 steps / cpu_offload on / sdpa - exactly what the author recommends and exactly what ships in the example canvas. Run a few seeds at 512, pick the shape you like, then escalate that seed. Burning 40 minutes on a 1536 pass before you know whether the coarse mesh was any good is the classic way to waste an evening.

The inputs and outputs

Required: model (the HI3D_MODEL handle from Hi3D Model Loader), image (an IMAGE - the reference), mesh (a MESH, from Hi3D Load Mesh), resolution (512 / 1024 / 1536), steps (1–100, default 25, applied per rung) and seed. The optional one is mask - a MASK that becomes the reference's alpha channel, with a convention the node docs state plainly and everyone misses: 1 means transparent. If your mask came out of a background-removal node with the subject at 1, invert it (InvertMask) or Hi3D will refine everything except your subject. An existing RGBA alpha on the image is preserved and intersected with the mask.

Two outputs. refined_mesh is a MESH - wire it to native SaveGLB and it lands in ComfyUI's output directory; Preview3D lets you orbit it first, which you should. report_json is a STRING holding the run's receipt: requested and actual resolution, steps, seed, offload and attention backend, wall-clock seconds, Torch version, vertex and face counts, and peak PyTorch allocator memory. That last number is a tensor peak, not your card's usage - don't read it as a VRAM minimum.

Also by design: one image, one object. Multi-object batches are rejected outright.

Install

The pack, once, from the README:

cd ComfyUI/custom_nodes
git clone https://github.com/T8mars/Comfyui-Hi3d-T8
cd Comfyui-Hi3d-T8
../../../python_embeded/python.exe -m pip install -r requirements.txt

Or install Hi3D T8 from ComfyUI-Manager (node ID hi3d-t8). Then the core weights, which both the loader and this node need:

hf download t8star/Hi3d-Comfy --local-dir ComfyUI/models/Hi3D \
  --include "manifest.json" "hi3d/*" "dino/*" "clip/*" "licenses/*"

You need hi3d/transformer_512 for the 512 rung and transformer_1024 for anything above it; the same VAE serves all three resolutions, and there's no separate 1536 checkpoint. Note the pack's requirements.txt pins spconv-cu126==2.3.8 and pulls Triton - that's the compiled part of the stack, and it's where a mismatched CUDA build turns an install into an afternoon.

Where it bites

It is not watertight, and it is not printable by default. T8star's own validation counts, at 512: nine connected components, boundary edges, non-manifold edges. At 1536 those multiply - 73 components, 276 boundary edges, and two million faces. Higher resolution buys detail and also buys mess. Inspect before you send anything to a slicer.

Your texture step lives outside ComfyUI. The workbench has PBR engines (TRELLIS.2 PBR, Hunyuan3D-Paint, UltraTex); the three ComfyUI nodes don't. What comes back is geometry, so plan on Blender or a texture-projection tool afterwards.

Faces stay generic. Refinement sharpens what the mesh and image suggest; it doesn't invent identity. The complaint that surfaces whenever these models meet recognisable human figurines - mesh fine, face isn't the person - applies here too.

VRAM scales with the ladder, not just time. The author's 1536 run allocated ~15.5GB of tensors on a 24GB card, and lower-VRAM GPUs are explicitly unvalidated. On 12GB, treat 512 as your resolution and be pleasantly surprised by 1024.

Two operational notes: only one refine runs at a time (global lock), and each run calls unload_all_models() first, so your resident image models get evicted. Interrupts are checked at every sampling update and stage boundary, and a cancelled run cleans the pipeline up instead of leaking it - the difference between a bad session and a restart.