Kandinsky S2V Sampler:
KandinskyS2VSampler generates video clips with supported distilled Kandinsky S2V models, using speech and text guidance together with a reference frame. It uses the model’s π-Flow sampling method to build the video in successive chunks rather than generating the entire clip in one pass. Each chunk continues from the last frames of the preceding chunk, helping maintain visual continuity across the sequence. This makes the node the central generation stage in a Kandinsky S2V workflow, turning prepared guidance into a video representation that can subsequently be decoded into visible frames. It supports Kandinsky S2V 1.0 Lite distilled and Pro distilled checkpoints and requires a CUDA device.
Kandinsky S2V Sampler Input Parameters:
model
Required input of type MODEL. This supplies the Kandinsky S2V diffusion model that generates the video. Connect a compatible model from Load Diffusion Model; the node checks both that it is a Kandinsky S2V model and that its checkpoint supports distilled π-Flow sampling. Only Kandinsky S2V 1.0 Lite distilled and Pro distilled are explicitly supported by the supplied code. A standard image-generation model or a non-distilled Kandinsky S2V checkpoint cannot be substituted. The model must run on a CUDA device, and its memory requirements affect whether generation fits on your GPU. No default value, numeric range, or selectable options are defined for this connection.
conditioning
Required input of type KANDINSKY_S2V_CONDITIONING. This carries the prepared speech and prompt guidance used during generation, including text embeddings, a pooled text embedding, audio embeddings, and the number of chunks to generate. Embeddings are numerical representations that allow the model to work with your prompt and speech. Connect the compatible conditioning produced by Kandinsky S2V Encode (speech + prompt) rather than ordinary ComfyUI text conditioning. The chunk count directly affects the amount of sampling work: the node tracks a total of chunks × steps sampling steps. No default value, numeric range, or selectable options are defined for this connection.
reference_latent
Required input of type LATENT. This supplies the reference frame in the compressed representation used by the model, rather than as a directly viewable image. The documented preparation path is to process your image with Kandinsky S2V Reference Image and then encode that result with VAE Encode. The sampler uses this encoded reference to guide video generation. Correct preparation is important because the reference must have a format and dimensions compatible with the Kandinsky S2V workflow; the node also uses its spatial dimensions when estimating GPU memory requirements. No default value, numeric range, or selectable options are defined for this connection.
seed
Required integer input controlling the randomness passed to video sampling. Keeping the seed fixed is useful when comparing changes to the prompt, speech guidance, or reference image, because it holds the random starting conditions consistent; changing it lets you explore alternative results with otherwise identical settings. Exact reproducibility can still depend on your hardware and software environment. The minimum is 0, and the maximum is 18446744073709551615. The default is specified as contract.SEED, whose numerical value is not included in the supplied source. The parameter enables ComfyUI’s after-generation seed control, allowing you to choose how the seed is handled between runs.
steps
Required integer input setting the number of π-Flow sampling segments per chunk, with one model call for each segment. Increasing this value increases sampling work for every chunk, so its effect on generation time grows with the clip’s chunk count. The minimum is 1, and the maximum is 100. The default is specified as contract.PIFLOW_STEPS, whose numerical value is not shown in the supplied source. The tooltip states that the model was distilled at 16 steps, making 16 the documented reference setting to start with when evaluating results. Lower values reduce the number of model calls but may change the result; higher values should not be assumed to improve quality automatically, because this is a distilled sampler rather than a general-purpose sampling setup.
Kandinsky S2V Sampler Output Parameters:
latent
Output of type LATENT containing the generated video chunks in a compressed form suitable for decoding, not directly viewable images. The node packages the generated chunks into the standard latent samples structure and converts them to the model’s expected output latent format. Each batch entry represents a generated clip chunk; according to the source, the stock VAE Decode decodes these chunks separately and concatenates their frames in order. Connect this output to VAE Decode with the appropriate VAE to obtain the video frames. The sampler does not trim frames generated over final audio padding, so use Kandinsky S2V Trim To Audio after decoding when you need the frame sequence shortened to the original audio duration.
Kandinsky S2V Sampler Usage Tips:
- Start with
stepsset to16, the documented distillation setting. Treat this as a baseline rather than assuming the maximum of100will produce a better video. - For quick experiments, try fewer steps and compare the result against your 16-step baseline. The node performs
chunks × stepssampling steps, so reducing steps reduces the model-call count across the entire clip. - Keep
seedfixed while adjusting one creative setting at a time. Once you find a useful combination of reference image, speech, and prompt, vary the seed to explore alternative generations. - Prepare the reference through
Kandinsky S2V Reference Imagefollowed byVAE Encode. Use the VAE appropriate to your Kandinsky S2V workflow rather than assuming that any VAE will produce compatible reference latents. - Connect
conditioningfromKandinsky S2V Encode (speech + prompt). Standard text-conditioning connections do not provide this node’s required speech embeddings and chunk information. - Check your checkpoint before starting a long run: use Kandinsky S2V 1.0 Lite distilled or Pro distilled loaded through
Load Diffusion Model, and ensure ComfyUI has access to a CUDA GPU. - Decode
latentwith the stockVAE Decode, then useKandinsky S2V Trim To Audioif you need to remove the frames corresponding to silence padding at the end. The supplied trimming node returns a frame rate of25fps. - If GPU memory is limited, close other GPU-heavy applications and check the reference-image size supported by your workflow. Lowering
stepsreduces sampling work but should not be relied on to resolve a peak-memory problem.
Kandinsky S2V Sampler Common Errors and Solutions:
Kandinsky S2V Sampler needs a Kandinsky S2V model from Load Diffusion Model
- Explanation: This exact error is raised when the connected model is not recognized as a Kandinsky S2V model. A connection having the general
MODELtype does not guarantee that its contents are compatible. - Solution: Load a supported Kandinsky S2V distilled checkpoint through
Load Diffusion Modeland connect that loader’s model output directly tomodel. Check that you have not accidentally connected a different image or video model.
This checkpoint is not a π-Flow distilled one; only Kandinsky S2V 1.0 Lite distilled and Pro distilled are supported
- Explanation: This exact error means the model passed the Kandinsky S2V type check but failed the sampler’s π-Flow checkpoint check. This sampler is specifically implemented for the supported distilled models.
- Solution: Replace the checkpoint with Kandinsky S2V 1.0 Lite distilled or Pro distilled. Increasing
stepsor changing the seed cannot make a non-distilled checkpoint compatible.
Kandinsky S2V runs on a CUDA device
- Explanation: This exact error is raised when the model’s selected execution device is not CUDA. The supplied implementation does not provide a CPU or other non-CUDA sampling path.
- Solution: Run the workflow on a CUDA-capable NVIDIA GPU with a compatible PyTorch and ComfyUI installation. Verify that ComfyUI detects the GPU and is not configured to run the model on the CPU.
CUDA out of memory
- Explanation: This is a possible PyTorch runtime error rather than a custom message defined by the node. It means there is insufficient available GPU memory for the model and sampling workload; reference spatial dimensions contribute to the node’s memory estimate.
- Solution: Close other GPU-intensive applications, free unused GPU memory, and try a smaller reference size if your Kandinsky S2V reference workflow supports it. Consider the supported Lite distilled checkpoint if Pro exceeds your available memory. Reducing
stepsprimarily reduces computation and is not a dependable fix for insufficient peak memory.
KeyError: 'chunks', 'text_embeds', 'pooled_embed', or 'audio_embeds'
- Explanation: These are possible Python errors if the conditioning data is incomplete or malformed. The sampler reads each of these entries directly, so the required custom connection must contain more than ordinary prompt conditioning.
- Solution: Regenerate the conditioning with
Kandinsky S2V Encode (speech + prompt)and reconnect its output. If a saved workflow or custom intermediate node supplies the conditioning, check that it is compatible with your installed Kandinsky S2V extension.
Incompatible reference latent or tensor dimensions
- Explanation: Reference validation or later tensor operations can fail if the encoded reference has incompatible dimensions or format. The supplied class does not show the exact validation messages, so the wording may vary.
- Solution: Rebuild the reference path using
Kandinsky S2V Reference Imagefollowed byVAE Encodewith the appropriate VAE. Avoid substituting unrelated image latents or manually reshaping the data; first verify that the standard reference preparation path runs successfully.
