🚀Compile Model

"🚀Compile Model" (class VelocatorCompileModel) is the same idea as the pack's Compile Model+ - JIT-compile the diffusion model's forward pass for fused, faster kernels - but routed through a completely different, third-party compiler called xelerate (the code calls it "velocator"). Same job, different engine, and a much rougher ride.

Here's the thing nobody tells you when you google this node: the pack's README doesn't document the Velocator nodes at all. They live in velocator_nodes.py under the wavespeed/velocator category, they're shipped, they're registered - and they're an experimental corner of an otherwise stable pack. Before you use any of them, know that you're on the frontier, not the beaten path.

How it works

The node takes your model, applies a memory format (channels_last by default - the layout that makes compiled attention kernels sing), and hands it to xelerate_compile, xelerate's own compile function. The default mode is cache-all:max-autotune:low-precision, which is xelerate's flavor of "compile everything, autotune hard, allow reduced precision."

Like the standard compile node, the first run compiles (slowly) and the result is cached for later runs. Unlike Compile Model+, there's no LoRA-see-through patching built into this node - that LoRA-compat work is specific to the torch.compile path in misc_nodes.py.

Inputs that matter

• model - any model; the output is the same type, so it feeds straight back into your sampler.
• mode - default cache-all:max-autotune:low-precision. This is the tuning knob for the whole thing.
• memory_format - channels_last (default), contiguous_format, or preserve_format.
• fullgraph / dynamic - as with torch.compile; dynamic helps when you change resolution and keep triggering recompiles.
• backend - defaults to velocator, which maps to xelerate internally.
• disable - bypass switch.

Install - the actual gotcha

The pack itself installs like everything else here:

cd ComfyUI/custom_nodes
git clone https://github.com/chengzeyi/Comfy-WaveSpeed.git

But the moment you run this node without xelerate installed, you'll hit a hard assert: velocator is not installed. That's because the pack does not install xelerate for you - its own pyproject.toml declares zero dependencies, and the README never mentions it. You need the xelerate Python package importable in ComfyUI's environment; the code imports from xelerate.compilers.xelerate_compiler and xelerate.ao.quant, so track down the xelerate project's own install instructions. As of writing, xelerate has essentially no community footprint in the usual ComfyUI circles, so there's no battle-tested install recipe to lean on.

Where people get burned

• It's a hard dependency, invisibly. Every Velocator node asserts xelerate exists at runtime. If you loaded a workflow with 🚀 nodes and it fails instantly with "velocator is not installed," that's this, and it's not a bug in your workflow.
• All the standard compile caveats still apply. If you're on Windows, torch.compile-family approaches are officially unsupported (the common fix is Triton wheels from woct0rdho's triton-windows repo, and it's an ordeal). Offloading fights compilation - launch with --gpu-only. And fp8 models don't compile on pre-Ada GPUs like the 3090.

If you just want a compiled Flux and you're not specifically chasing xelerate, use Compile Model+ instead. This node is for the curious who want to compare compilers - and for people whose workflows happened to come with 🚀 in the title.