Simple Pixal3D Image to GLB + Mesh

Pixal3D (Tencent, May 2026) is one of the strongest image-to-3D models around right now. The community's early read was "a step up from Trellis.2 raw," and the architecture backs it up: instead of loosely injecting image features via attention like the older generators, Pixal3D back-projects pixels directly into 3D, which is why its geometry and PBR textures stay so close to the source photo. The problem is that running it natively is a war of CUDA wheels and pinned dependency stacks - the kind of install fight the 3D corner of ComfyUI is famous for.

Simple Pixal3D Image to GLB + Mesh is the "make it just work" wrapper. One main node, the Pixal3D Python package vendored inside the custom node folder, and an install.py that installs the exact wheels you need.

Before you get excited, the honest image-to-3D caveat applies here like everywhere: you get a textured mesh, and like every model in this class, the topology underneath is triangle soup. Static prop, 3D print, background filler, a render you'll never rig - genuinely great. Anything that has to deform in a game engine? Budget for a retopology and re-UV pass, because no open model saves you from that yet.

How it works

Feed it one image and it runs the whole pipeline in one shot: background is removed with RMBG-2.0 and the subject cropped, the camera is estimated, Pixal3D's three-stage sampler (sparse structure, shape, texture) does its thing, and the result is exported as a GLB into ComfyUI's output/ folder. The resolution you pick maps directly to the cascade it runs - 1024 or 1536 - and naf_mode picks how the high-res image-condition network is used (duplicate_lr is the default because it needs no extra weights; strict_naf demands the real NAF model).

The inputs that actually matter

• image - your source shot. A clean, single-subject image on a plain background gives dramatically better results than a busy scene.
• resolution - 1024 default; bump to 1536 if your card has the room.
• low_vram - leave on unless you're on a big GPU; it's what lets 6GB cards run this at all.
• camera_mode / manual_fov_degrees - manual_fov (49.13°) is right for ordinary photos. Switch to auto_moge and it runs Microsoft's MoGe-2 point-map model to estimate the camera, only if models/pixal3d/moge-2-vitl-normal.pt is present.
• sampling_steps plus the three guidance sliders (ss_guidance, shape_guidance, tex_guidance) - 12 steps is fast but coarse; 20–30 cleans things up at a time cost. The defaults are a fine starting point.
• texture_size (512–8192) and decimation_target (the target triangle count) - the two knobs that set output fidelity vs. file size.
• keep_model_loaded - on by default and worth keeping: the first generation in a session is slow because the pipeline and helpers have to load, and later ones are much faster because they stay resident.

Outputs

Three, and they're not interchangeable:

• glb_path (STRING) - where Pixal3D's own exporter wrote the file. It keeps the full PBR material bake, so use this when materials matter.
• preprocessed_image (IMAGE) - the background-removed, cropped image it actually ran inference on.
• mesh (MESH) - the ComfyUI-native path. Wire it into the official Save 3D Model / SaveGLB node, but know it stores geometry plus vertex colors/texture, not Pixal3D's richer PBR output.

The node also posts a 3D preview entry, so the GLB shows up in the frontend if your ComfyUI build has 3D preview support.

Install

Clone it in, then run the installer with the Python your ComfyUI uses:

cd /path/to/ComfyUI/custom_nodes
git clone https://github.com/starsFriday/ComfyUI-SimplePixal3D.git
cd /path/to/ComfyUI
python custom_nodes/ComfyUI-SimplePixal3D/install.py

This is not a pip install -r requirements.txt pack - install.py is the real install path. It pulls the pure-Python deps, a pinned MoGe build, and five prebuilt CUDA wheels (flex_gemm, cumesh, nvdiffrast, nvdiffrec_render, o_voxel) plus natten and flash-attn. Those wheels are pinned hard: Linux x86_64 + Python 3.12 + torch 2.8.0 + CUDA 12.8. Anything else and the installer skips them, so --check shows you exactly what's missing and you're installing matching builds by hand. The installer won't touch torch - have a CUDA-enabled build in your ComfyUI venv first.

Then the models - roughly 24 GB before the helpers. Point model_path (default models/pixal3d) at the folder, then:

cd /path/to/ComfyUI
mkdir -p models/pixal3d
huggingface-cli download TencentARC/Pixal3D --local-dir models/pixal3d
huggingface-cli download camenduru/dinov3-vitl16-pretrain-lvd1689m --local-dir models/pixal3d/camenduru_dinov3-vitl16-pretrain-lvd1689m
huggingface-cli download briaai/RMBG-2.0 --local-dir models/pixal3d/briaai_RMBG-2.0

Plus MoGe, renamed to models/pixal3d/moge-2-vitl-normal.pt (the HF file is called model.pt).

Common issues

• First generation is slow - expected, not a hang. Pipeline load plus CUDA kernel init. Later runs are quick if keep_model_loaded stays on.
• Blank 3D preview but the saved GLB opens fine - flip use_webp_texture off; some browser-side viewers choke on GLBs using WebP texture extensions.
• RMBG-2.0 download fails - the BRIA repo has been gated; accept the license on the HuggingFace page before retrying.
• CUDA is mandatory - the node raises if torch.cuda.is_available() is false. There's no CPU path.