HiCache Accelerate (Hunyuan3D)

Hunyuan3D is genuinely good at turning one image into a textured mesh, and it's also a slow conversation. The shape DiT grinds through 30 flow-matching steps, and on a consumer card that's the part of an image-to-3D run that drags. HiCache Accelerate attacks exactly that: it skips most of the DiT forwards and predicts what the next few outputs would have been. Training-free, checkpoint-agnostic, measured at a 2.7x speedup on the sampling stage inside real ComfyUI. If you're already using kijai's Hunyuan3DWrapper and your mesh runs feel sluggish, this is the cheapest speedup you can bolt on.

One honest caveat up front: on the small 2-mini model the end-to-end win is modest - about 1.2 seconds out of a roughly 9-second run, because VAE decode and marching cubes dominate the tail. The bigger your shape DiT and the more steps you run, the larger the share of the run this node saves. Think of it as a free dial you get on a workflow you already run, not a magic 3x on the whole pipeline.

How it works

This is not distillation. A distilled model is a retrained, step-starved student; HiCache is a runtime patch that leaves the model untouched. The node sits between the wrapper's Hy3DModelLoader and its mesh sampler, and wraps pipeline.model (the shape DiT). On compute steps the DiT runs normally and its output is cached as a forecast anchor. On the next interval-1 steps, the DiT is never called - the flow-matching velocity is extrapolated from those anchors instead, using the hicache-pp library.

With interval = 3 you compute 1 step and forecast 2, so roughly two-thirds of DiT forwards disappear (the validated run logged 11 computed + 19 skipped out of 30). The math behind it is HiCache's dual-scaled Hermite polynomial (arXiv:2508.16984), with HiCache++'s DMD/Prony-exponential forecaster as an alternative basis.

The inputs that actually matter

Three required inputs, and you'll only touch two of them:

• pipeline - the HY3DMODEL out of the wrapper's Hy3DModelLoader. Wire it through this node and on to Hy3DGenerateMesh (or the multiview sampler).
• method - hermite (default), dmd, or auto. Use hermite. It's the best-measured setting inside ComfyUI, and the README is blunt that DMD's "lossless" upstream result does not transfer to this node's model-level patch - on mini it lands right at the different-seed noise floor. dmd is only worth an experiment on the big 2.1 DiT at large intervals.
• interval - default 3, and the measured sweet spot is 3. Set it to 1 and caching is disabled entirely, which is a handy "does this actually help me" A/B toggle.

The optional settings (max_order, sigma, dmd_history) are the forecaster's tuning knobs; the defaults are sane, leave them alone. enable=false cleanly unpatches and restores the original DiT. The single output is a patched pipeline you feed straight into the mesh sampler.

Installing it

Via ComfyUI Manager, search for ComfyUI-HiCache (or Install via Git URL), or manually:

cd ComfyUI/custom_nodes
git clone https://github.com/Archerkattri/ComfyUI-HiCache
pip install -r ComfyUI-HiCache/requirements.txt   # just hicache-pp

Restart ComfyUI. The dependency situation is refreshingly light: requirements.txt is a single line (hicache-pp), there are no model downloads, and the patch needs nothing from ComfyUI internals. What you do need is the actual subject: kijai/ComfyUI-Hunyuan3DWrapper to provide the HY3DMODEL pipeline. This node accelerates Hunyuan3D only - no wrapper, no node.

Gotchas worth knowing

• Measure on your own checkpoint before trusting dmd. The author's own validation found the model-level patch (caching the pre-CFG stacked output) behaves differently from the upstream pipeline wiring (caching the CFG-combined velocity). Hermite transfers exactly; DMD doesn't. That's why the default is hermite / interval=3 - a rare case where the defaults genuinely are the answer.
• The copy-on-patch detail is not cosmetic. ComfyUI caches node outputs keyed on inputs, and an in-place patch could silently serve you a stale accelerated pipeline from an earlier run. This node returns a shallow copy (weights shared, so zero extra VRAM) to avoid that. You won't notice it working - you'd only notice if it didn't.
• The validation is mini-only. The full-size 2.0/2.1 checkpoints and the multiview sampler path were measured in the upstream repos but not end-to-end inside ComfyUI. Mechanism is the same, but don't be surprised if exact speedups differ.
• Watch for the node in the HiCache category after install; if it's missing, the hicache-pp pip install failed or you skipped the restart.

For a tool this new, it's unusually well documented - the README ships a full measured table, run-boundary reset tests, and the exact numbers behind its claims, all MIT licensed and independent of Tencent and kijai. If you run Hunyuan3D in ComfyUI at all, this is a five-minute install for a free speedup on the slowest part of the pipeline.