Save 4 hours! We auto-setup your workflow! Free!

Drop your workflow.json — we handle every dependency, custom node, and model. Just open the link and run.

Auto-Setup Workflow Json (Free) Now!
ComfyUI > Nodes > kandinsky-s2v > Kandinsky S2V Sampler

ComfyUI Node: Kandinsky S2V Sampler

Class Name

KandinskyS2VSampler

Category
Kandinsky S2V
Author
kandinskylab (Account age: 362days)
Extension
kandinsky-s2v
Latest Updated
2026-11-05
Github Stars
0.04K

How to Install kandinsky-s2v

Install this extension via the ComfyUI Manager by searching for kandinsky-s2v
  • 1. Click the Manager button in the main menu
  • 2. Select Custom Nodes Manager button
  • 3. Enter kandinsky-s2v in the search bar
After installation, click the Restart button to restart ComfyUI. Then, manually refresh your browser to clear the cache and access the updated list of nodes.

Visit ComfyUI Online for ready-to-use ComfyUI environment

  • Free trial available
  • 16GB VRAM to 80GB VRAM GPU machines
  • 400+ preloaded models/nodes
  • Freedom to upload custom models/nodes
  • 200+ ready-to-run workflows
  • 100% private workspace with up to 200GB storage
  • Dedicated Support

Run ComfyUI Online

Kandinsky S2V Sampler Description

Generates Kandinsky S2V videos from speech, text, and a reference frame in continuous chunks.

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 steps set to 16, the documented distillation setting. Treat this as a baseline rather than assuming the maximum of 100 will produce a better video.
  • For quick experiments, try fewer steps and compare the result against your 16-step baseline. The node performs chunks × steps sampling steps, so reducing steps reduces the model-call count across the entire clip.
  • Keep seed fixed 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 Image followed by VAE Encode. Use the VAE appropriate to your Kandinsky S2V workflow rather than assuming that any VAE will produce compatible reference latents.
  • Connect conditioning from Kandinsky 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 latent with the stock VAE Decode, then use Kandinsky S2V Trim To Audio if you need to remove the frames corresponding to silence padding at the end. The supplied trimming node returns a frame rate of 25 fps.
  • If GPU memory is limited, close other GPU-heavy applications and check the reference-image size supported by your workflow. Lowering steps reduces 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 MODEL type does not guarantee that its contents are compatible.
  • Solution: Load a supported Kandinsky S2V distilled checkpoint through Load Diffusion Model and connect that loader’s model output directly to model. 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 steps or 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 steps primarily 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 Image followed by VAE Encode with the appropriate VAE. Avoid substituting unrelated image latents or manually reshaping the data; first verify that the standard reference preparation path runs successfully.

Kandinsky S2V Sampler Related Nodes

Go back to the extension to check out more related nodes.
kandinsky-s2v
RunComfy
Copyright 2025 RunComfy. All Rights Reserved.

RunComfy is the premier ComfyUI platform, offering ComfyUI online environment and services, along with ComfyUI workflows featuring stunning visuals. RunComfy also provides AI Models, enabling artists to harness the latest AI tools to create incredible art.

Kandinsky S2V Sampler