Setting Up Image-to-Video Generation in ComfyUI: Nodes, Models, and First Working Render

The ComfyUI image-to-video node graph that produces a working MP4 render from a still image is: Load Image node → CLIP vision encoder → KSampler with temporal attention layers → VAE Decode → FFmpeg video combine node outputting MP4. This pipeline is the standard local-generation front-end for open-weights video models as of the dossier's entity descriptions. New models ship with ComfyUI workflows as their primary local deployment method, and the sequence below is what their Hugging Face example workflows specify.

Attach a Load Image node to import your JPEG or PNG source. That feeds a CLIP vision encoder which extracts visual features the model uses to condition the generation. The KSampler then runs the diffusion process, denoising from random latent noise across the specified number of frames. Temporal attention layers inside the model ensure that each frame is influenced by its neighbours, creating smooth motion. After the KSampler finishes, a VAE Decode node converts the latent representation back into pixel frames. Finally, the FFmpeg video combine node packages those frames into an MP4 file with your chosen frame rate.

For Stable Video Diffusion (SVD), the Hugging Face model card at stabilityai/stable-video-diffusion-img2vid specifies the ComfyUI node set: VideoLinearCFGGuidance, SVD_img2vid_Conditioning, and VAEDecodeTiled. The motion bucket ID range runs from 1 to 255, where lower values produce less motion. The augmentation level controls added noise; leave it at 0.0 unless you want a more chaotic output.

Frame Counts and Scheduler Defaults

Use the VideoLinearCFGGuidance node to set the frame count: 14 frames for the base SVD model, 25 for SVD-XT. The scheduler specified in the release documentation is the default DDIM scheduler in ComfyUI's KSampler. The native output resolution is 1024×576 at 7 fps for SVD and 6 fps for SVD-XT. You can set a higher frame rate, but the model was trained at these defaults.

The VRAM Bottleneck

The VAE Decode stage is the most VRAM-intensive step with SVD. The dossier identifies VRAM exhaustion crash during VAE decode, not during the main inference step, because the VAE decode stage has the highest peak memory demand.

The ComfyUI integration for the Lightricks model uses the ComfyUI-LTXVideo community node set. The Hugging Face model card for Lightricks/LTX-Video (version 2B-v0.9.5, released November 2024) specifies that the KSampler should use the Euler ancestral scheduler with a denoising strength of 0.95. The native output is 121 frames at 768×512 resolution and 24 fps. That is roughly 5 seconds of video. The model checkpoint is 4.1 GB, so it fits on most 8 GB VRAM cards if you run at the native resolution.

Architecture and Node Wiring

This model uses a Diffusion Transformer (DiT) architecture with a VAE, not a standard UNet. The node wiring is: Load Image node → CLIP vision encoder → LTX-Video conditioning wrapper → KSampler with Euler a scheduler → VAE Decode node → FFmpeg video combine node. The wrapper handles the temporal attention configuration automatically. If you hit a VRAM exhaustion crash, reduce the frame count to 97 or 73 frames, or enable tiled VAE decode where the model supports it. The Lightricks Community Licence, published with the model card, permits commercial use for individuals and companies with under $1M annual revenue.

Setting	Stable Video Diffusion	LTX-Video	Wan 2.1 I2V 14B
Model loader node	VideoLinearCFGGuidance (native)	ComfyUI-LTXVideo (community)	ComfyUI-WanVideoWrapper (community)
Scheduler	DDIM (default)	Euler ancestral	DDIM (default, per Hugging Face example)
Native frame count	14 (SVD) / 25 (SVD-XT)	121	81
Native resolution	1024×576	768×512	720×1280 (14B) / 480×832 (1.3B)
Native frame rate	7 fps (SVD) / 6 fps (SVD-XT)	24 fps	16 fps
Checkpoint size	2.1 GB	4.1 GB	27.3 GB (14B, fp16)
VRAM requirement at native res	~6 GB	~4 GB	~16 GB (14B, fp16 with tiled decode)
VAE Decode option	VAEDecodeTiled (included)	Standard VAE Decode	Standard VAE Decode (tiled option available)
Licence	Non-commercial research only	Apache 2.0 (commercial under $1M revenue)	Apache 2.0 (full commercial)

The Hugging Face model card for Wan-AI/Wan2.1-I2V-14B specifies the ComfyUI-WanVideoWrapper community node set. Wan 2.1 is a Diffusion Transformer (DiT) with a 3D VAE, producing 81 frames at 720×1280 (14B variant) or 480×832 (1.3B variant), both at 16 fps. The model checkpoint for the 14B image-to-video variant is 27.3 GB in fp16 precision, requiring a GPU with at least 24 GB VRAM for full-resolution inference. The 1.3B variant requires roughly 6 GB.

Node Wiring and Scheduler

The node wiring for Wan 2.1 image-to-video: Load Image node → CLIP vision encoder (Wan uses its own vision encoder, included in the wrapper) → Wan conditioning node → KSampler with DDIM scheduler → VAE Decode → FFmpeg video combine node. The temporal attention layers are built into the DiT architecture and handled automatically by the wrapper. The scheduler default is DDIM, as specified in the Hugging Face example workflow. The Apache 2.0 licence permits full commercial use.

Avoiding the VAE Crash

The failure mode to watch for is VRAM exhaustion during the VAE decode stage. The workaround is reducing the frame count to 49 or enabling ComfyUI's tiled VAE decode, which processes the latent space in chunks.

The dossier identifies VRAM exhaustion crash as a failure mode that strikes during VAE decode, not during the main inference step. The VAE decode stage has the highest peak memory demand because it converts the full latent representation back into pixel frames for every frame simultaneously. On an 8 GB GPU, a 25-frame SVD generation at 1024×576 resolution can exceed 10 GB of VRAM during VAE decode, crashing the process with an out-of-memory error. The same generation runs fine through the KSampler, which only processes one latent at a time.

Workarounds by Model

Reduce frame count or enable tiled VAE decode where the model supports it. For SVD, use the VAEDecodeTiled node included in the native ComfyUI node set. For the Lightricks model, reduce frame count from 121 to 73 or 49. For Wan 2.1, use the tiled VAE decode option available in the wrapper, or reduce to 49 frames. If you still hit the limit, lower the output resolution by resizing the input image before loading it. The ComfyUI community node 'Image Resize' before the Load Image node lets you keep the aspect ratio while dropping pixel count.

The open-source tinkerer running models locally on a consumer GPU is the exact audience for this workflow. You already know how to install ComfyUI custom nodes and have at least 8 GB of VRAM. You are comfortable editing a JSON workflow file if a model ships one. You want to control every parameter from frame count to scheduler type and are willing to debug a VRAM crash with a tiled decode workaround.

Who Gains the Most

The solo filmmaker or video artist who needs b-roll and establishing shots should use this workflow if they want zero per-generation cost and full control. The social-media content creator producing high-volume short-form video should consider the commercial services instead. The open-weights models lack speed optimisations and have no queue bypass. The educator or researcher studying generative tools will find the node graph transparent and the failure modes reproducible.

Who Should Stay Away

The legal or compliance person clearing AI-generated video for broadcast or advertising should skip this and go to the jurisdiction-specific disclosure requirements section of the site. The open-weights models do not embed detectable watermarks in the metadata by default. Before animating a real person's likeness, secure explicit written consent. The models provide no built-in consent verification, and using someone's image without permission carries legal risk under personality-rights and privacy laws in multiple jurisdictions.

The One Thing That Goes Wrong

The VRAM exhaustion crash during VAE decode is the failure you will hit. Not because the model cannot run on your hardware, but because the documented VRAM requirement on the Hugging Face model card reflects ideal batch-size-1 inference and excludes the peak memory demand of the VAE decode stage. Reduce the frame count first, enable tiled VAE decode second, and only then consider buying a bigger GPU.