STARFlow-V Sampler

This is the heart of the video half of the pack - the node that takes a STARFlow-V model and a conditioning and actually emits video latents. Everything else in the STARFlow-V suite exists to feed or un-feed this node. And like its T2I cousin, it is emphatically not a KSampler: no steps, no scheduler, no denoise slider. STARFlow-V runs a block-wise reverse - deep, fully causal text-conditioned blocks first, then shallow temporally-local blocks - using Jacobi iteration to converge faster than a straight sequential decode. That's the "normalizing flow inversion" people talk about when they discuss Apple's architecture, and it's all happening inside this one node.

The inputs that matter

• model and conditioning - from STARFlowVCheckpointLoader and STARFlowVTextEncode, respectively.
• width / height - 848×480 by default, the nearest 16-aligned 16:9 size to Apple's released profile. Both must be divisible by 16; the sampler asserts it.
• num_frames - default 81. This one will bite you: the count must follow 4n+1, because the Wan2.2 VAE does causal temporal compression in fours. Set it to 80 and you get a hard ValueError telling you exactly that.
• cfg - 3.5 default, matching the released inference profile. Like the T2I model, STARFlow-V isn't guidance-distilled, so keep it real. And remember: I2V (via first_frame_latent) requires cfg > 0.
• sampling_mode - jacobi (default) or ancestral. Jacobi is the fast, block-wise fixed-point solver; ancestral is the strictly sequential fallback for debugging or when Jacobi misbehaves. Most people never switch.
• jacobi_block_size (32), jacobi_max_iter (32), jacobi_th (0.001) - the solver knobs, shipped at Apple's recommended values.
• apply_learnable_denoiser - default true, and the released profile says leave it on. STARFlow-V ships a learnable self-denoiser that cleans up the sample after the reverse pass.
• first_frame_latent (optional) - the LATENT from STARFlowVImageEncode. Provide it and you're doing image-to-video; leave it empty and it's text-to-video.

Output is latent, a raw un-normalized ComfyUI video LATENT in (B, C, T, H, W) layout, ready for STARFlowVDecode (or core VAEDecode) with a Wan2.2-TI2V VAE.

Wiring it

STARFlowVCheckpointLoader ──model──▶ STARFlowVSampler ──latent──▶ STARFlowVDecode ──▶ video out
STARFlowVTextEncode ──conditioning──▶ STARFlowVSampler
STARFlowVImageEncode ──first_frame_latent──▶ STARFlowVSampler   (I2V only)

Install and models

Shared pack install:

cd ComfyUI/custom_nodes
git clone https://github.com/RyukoMatoiFan/ComfyUI-STARFlow
pip install -r ComfyUI-STARFlow/requirements.txt
# restart ComfyUI

Plus the 7B checkpoint in models/starflow_v/, a full local FLAN-T5-XL directory in models/text_encoders/flan-t5-xl/, and a Wan2.2 TI2V VAE for the core VAELoader - details in the checkpoint loader article. Checkpoints and checksums: huggingface.co/AkaneTendo25/starflow.

Gotchas

VRAM is the headline. At 480p the sampler's KV caches are enormous, and the code explicitly frees them on interruption because they can strand your GPU. If you're not on a 24 GB+ card, drop resolution before you drop frame count. The other classic: forgetting 4n+1. If the node throws about frame counts, that's the reason - 81, 85, 89, not 80, not 82. And be patient with the first run; the 7B transformer loads from scratch and it's a genuinely heavy single forward pass, which is normal and not a hang. When the quality underwhelms compared to a diffusion video model, remember the community verdict on STARFlow-V at release: the architecture is the thing worth seeing, and this node is how you see it.