Hugging Face Image to Video: Models, Spaces, and Local Inference

Hugging Face image to video refers to using models hosted on huggingface.co under the image-to-video pipeline tag to turn a still image into a short animated clip. You interact with them in three ways: click-through Spaces demos in the browser, the Inference API/Inference Endpoints, or by downloading the weights and running them locally with the diffusers Python library. Below is what actually works, per model, per platform.

What the image-to-video tag actually covers

The pipeline tag filters the Hub to models whose intended input is one image (optionally plus a text prompt) and whose output is a short video, typically 2–6 seconds at 16–24 fps. As of writing, the most active open-weight families are:

Model	Author	Typical output	Weights license
Wan 2.2 I2V-A14B	Alibaba (Wan-AI)	720p, 5s, 24 fps	Apache 2.0
Wan 2.1 I2V-14B / I2V-1.3B	Alibaba (Wan-AI)	480p–720p, ~5s	Apache 2.0
Stable Video Diffusion (SVD)	Stability AI	576×1024, 14 frames	SVD non-commercial / commercial via Stability
SVD-XT	Stability AI	576×1024, 25 frames	Same as SVD
LTX-Video	Lightricks	768×512, ~5s at 24 fps	OpenRAIL-M variant
CogVideoX-5B-I2V	THUDM	720×480, 6s at 8 fps	Apache 2.0 (code), custom (weights)
image-to-video	Bantikumar (community)	Small demo checkpoint	See model card

Always confirm resolution, frame count and license on the model card itself — authors update these. The Wan 2.2 card is at huggingface.co/Wan-AI/Wan2.2-I2V-A14B, SVD-XT at huggingface.co/stabilityai/stable-video-diffusion-img2vid-xt, and LTX-Video at huggingface.co/Lightricks/LTX-Video.

Three ways to run Hugging Face image to video

1. Spaces (no install, browser only)

Every major I2V model has one or more community Spaces. Go to huggingface.co/spaces, search for the model name (e.g. “Wan 2.2 I2V” or “LTX-Video”), upload an image, type an optional prompt, click Generate. Free Spaces run on shared ZeroGPU (H200 slices) with a per-user daily quota; if the Space is busy you’ll queue. For production, duplicate the Space and attach paid hardware from the Space settings.

2. Inference API and Inference Endpoints

The serverless Inference API supports some I2V models directly; for others you deploy a dedicated Inference Endpoint on an A10G, L4, L40S, A100 or H100. Endpoints are billed per hour of GPU uptime, so leaving one running for a month is expensive; a 24/7 A100-80GB endpoint typically runs into thousands of dollars per month. Use the self-hosting vs API calculator to compare against per-second video APIs.

3. Local inference with diffusers

The reference client is the Hugging Face diffusers library. Install:

pip install --upgrade diffusers transformers accelerate torch imageio imageio-ffmpeg

Minimal SVD-XT example (from the model card):

import torch
from diffusers import StableVideoDiffusionPipeline
from diffusers.utils import load_image, export_to_video

pipe = StableVideoDiffusionPipeline.from_pretrained(
    "stabilityai/stable-video-diffusion-img2vid-xt",
    torch_dtype=torch.float16, variant="fp16"
)
pipe.enable_model_cpu_offload()

image = load_image("input.png").resize((1024, 576))
frames = pipe(image, decode_chunk_size=8, num_frames=25).frames[0]
export_to_video(frames, "out.mp4", fps=7)

For Wan 2.2 use WanImageToVideoPipeline; for LTX-Video use LTXImageToVideoPipeline. Check the model card for the exact class name — diffusers adds new pipelines each release.

VRAM and hardware, honestly

I2V is heavier than image generation because you’re denoising many frames of a temporal latent at once. Model cards and the diffusers repo report roughly:

Model	Native VRAM (fp16)	With CPU offload / quantization
SVD / SVD-XT (576×1024)	~16–20 GB	~8–10 GB with enable_model_cpu_offload()
LTX-Video	~12–24 GB depending on length	Runs on 12 GB cards with offload
Wan 2.1 I2V-1.3B	~8–12 GB	Runs on a 3060 12 GB
Wan 2.2 I2V-A14B (720p)	~24 GB+	Fits on 16 GB with fp8/GGUF community forks
CogVideoX-5B-I2V	~18–24 GB	~5 GB with full offload (per THUDM card)

Numbers vary with resolution and frame count. For a general view of GPU memory scaling see the VRAM calculator and best GPUs for local models — the same cards (RTX 3090, 4090, 5090, A6000) are the sweet spot for video too.

Windows

Install Python 3.10 or 3.11 from python.org, then the CUDA build of PyTorch from pytorch.org/get-started/locally matching your NVIDIA driver. Create a venv, pip install diffusers transformers accelerate, and set HF_HOME to a drive with 50+ GB free — Wan and CogVideoX weights are large. Windows has no ROCm support; AMD users should use WSL2 or Linux. For a friendlier UI, ComfyUI has native workflows for SVD, Wan and LTX-Video.

macOS

Apple Silicon (M1–M4) runs diffusers via MPS. Install PyTorch with MPS support, then pass torch_dtype=torch.float16 and .to("mps"). Realistically, SVD produces a 25-frame clip on an M2 Max in several minutes; Wan 2.2 A14B is impractical on anything below 64 GB unified memory. LTX-Video is currently the most usable I2V model on Mac because of its lower step count. Intel Macs have no working GPU path — use a hosted API instead.

Linux

Linux is the primary target. Install the NVIDIA driver, CUDA 12.x runtime (bundled in PyTorch wheels), then pip install diffusers transformers accelerate. For multi-GPU or long clips use accelerate config and pipe.enable_sequential_cpu_offload(). xformers and torch.compile() give large speedups for SVD and Wan on Ampere/Ada/Hopper cards.

When to skip Hugging Face and use a hosted video API

If you need one short clip a day, a Space or a local RTX card is fine. If you need reliable throughput, per-second hosted APIs are usually cheaper than paying for an idle A100/H100 endpoint:

• Wan 2.5 — from $0.05/sec (same lineage as the open Wan weights on the Hub)
• Sora 2 — from $0.05/sec; Sora 2 Pro from $0.15/sec
• Veo 3.1 — from $0.05/sec
• Kling 2.5 Turbo Pro — from $0.07/sec

At $0.05 per second, 1,000 five-second clips cost $250; renting an H100 at typical cloud rates for the same throughput usually costs more. Use the API cost calculator and browse the models database for current pricing.

Frequently asked questions

Is there a single “Hugging Face image to video” model I should default to?

No single default. For open weights and permissive licensing, Wan 2.2 I2V-A14B currently produces the best 720p output but wants 24 GB+ of VRAM. On 12 GB cards, LTX-Video or Wan 2.1 I2V-1.3B are the practical choices. SVD-XT is older but very well documented.

Can I use these models commercially?

Depends on the checkpoint. Wan 2.1/2.2, CogVideoX code and LTX-Video are permissive but each has its own terms; Stable Video Diffusion’s weights ship under a Stability community license with a separate commercial tier. Always read the model card’s License section before shipping anything.

Why does my output flicker or look like a slideshow?

Usually one of: too few inference steps (raise num_inference_steps), motion_bucket_id/guidance_scale set too low for SVD, or an input image whose aspect ratio doesn’t match the model’s training resolution. Match the model’s native resolution (e.g. 1024×576 for SVD-XT) before generating.

Can I run image-to-video on a laptop with 8 GB VRAM?

Only with the smallest models and aggressive offloading. Wan 2.1 I2V-1.3B and quantized LTX-Video builds can run, but expect minutes per clip. For anything larger a hosted API or a Space will be faster and cheaper than fighting OOM errors.

Does Ollama support image-to-video?

No. Ollama is focused on text and multimodal LLMs, not diffusion video pipelines. See the Ollama guide for what it does cover; for I2V, stick with diffusers or ComfyUI.

How long does a single clip take on a consumer GPU?

Order of magnitude: SVD-XT on an RTX 4090 produces a 25-frame clip in well under a minute at default settings; the same model with enable_model_cpu_offload() on a 12 GB card is several times slower. Wan 2.2 A14B at 720p is substantially heavier. Exact numbers depend on step count, resolution and PyTorch version, so treat any single benchmark you read as approximate.