PyramidFlow Sampler

Every node in Kijai's PyramidFlow wrapper is load-bearing, but this is the one that pays rent. PyramidFlow Sampler takes the loaded transformer, the encoded prompt, and turns them into actual video latents. Everything else in the pack exists to feed it or clean up after it.

The "pyramid" in PyramidFlow isn't decoration. The model generates in three stages at progressively finer resolutions - the first stage at a downsampled scale, then stages that halve the downsampling twice, each one predicting the detail the previous stage left out. Every stage gets its own step budget. That's why first_frame_steps and video_steps are strings like 10, 10, 10 instead of a single number: three comma-separated values, one per stage. The pack's example workflows use 20, 20, 20 for the first frame and 10, 10, 10 for the video units - a reasonable starting point if you don't want to think about it.

The inputs that actually matter

• temp - this is your video length knob. The tooltip says it plainly: temp=16 is a 5-second video, temp=31 is 10 seconds. It roughly corresponds to number of frames, and it's the single biggest lever on both runtime and VRAM.
• guidance_scale vs video_guidance_scale - two separate CFG values, and the split is the point. guidance_scale (default 9) steers the first frame like a still image; video_guidance_scale (default 5) steers the motion latents. The model was trained this way, so don't just slap one value on both and expect it to hold up.
• width / height - defaults of 640×384. 384p is where this model shines; the community consensus back in the day was that PyramidFlow's big virtue was fast generation at 384p, not crisp output at high res. Steps of 8, range up to 2048, but don't get greedy.
• input_latent - the optional input that flips the node from text-to-video into image-to-video. Wire in a latent from PyramidFlow VAE Encode and the node runs generate_i2v instead. Note the tooltip: first_frame_steps has no effect in this mode, because your input image is the first frame.
• keep_model_loaded - leave it false unless you're iterating and want to skip the offload/reload churn between runs.

The output

One output, samples (LATENT). It's a plain ComfyUI latent, so you can feed it to the standard preview or pass it to PyramidFlow VAE Decode to get frames, then into VHS Video Combine to write a file. Yes, the wrapper's own VAE Decode is the path of least resistance - it knows the weird shift-and-scale factors this model needs and applies them for you.

Installing it

This is Kijai's pack, so install is boring: ComfyUI Manager → search "PyramidFlow Wrapper", or:

cd ComfyUI/custom_nodes
git clone https://github.com/kijai/ComfyUI-PyramidFlowWrapper

Restart ComfyUI, let it pull the requirements (diffusers, accelerate, sentencepiece, timm, a pinned numpy<=1.26.4 - the usual suspects), then download the models from Kijai/pyramid-flow-comfy on HuggingFace into ComfyUI/models/diffusion_models and ComfyUI/models/vae. The examples tuck them in a pyramidflow subfolder. The fluxmini model runs in about 7GB of VRAM.

Common issues

The two gotchas people actually hit: the pack was refactored hard from its original SD3 form to Flux ("miniflux") in late 2024, so old tutorial workflows using the SD3 nodes need the legacy branch - the current main is Flux-only. And when the Flux version first dropped, everyone on an older ComfyUI hit a get_full_path_or_raise crash on the loaders; updating ComfyUI fixed it. Still the answer if a loader throws something inscrutable: update, then restart.

Be honest about what this model is. It's an early open video model, and even after the Flux move the community found it "less consistent than CogVideoX" with genuinely rough human anatomy. Where it wins is speed at low res and quick iteration on a modest card. If you need a 5-second test render before committing a real workflow, this is a perfectly fine tool for it.