Home › Video Models › Stable Virtual Camera

Stable Virtual Camera - AI Video Models Tool

Overview

Stable Virtual Camera is a diffusion-based model from Stability AI for novel view synthesis and image-to-video generation. The 1.3B-parameter model is conditioned on multiple input images and a freely specified target camera trajectory to produce temporally and geometrically consistent novel views and short videos. It is distributed on Hugging Face as an image-to-video pipeline and is intended for research and creative non-commercial use (see the model page for license and usage restrictions). The model is designed for workflows that need plausible multi-view synthesis from sparse captures: examples include rapid prototyping of camera flythroughs from a handful of reference photos, generating consistent novel views for product photography, and creative previsualization for cinematography or AR/VR concepts. Because it accepts explicit camera trajectory inputs, artists and researchers can control viewpoint paths (e.g., linear dolly, orbit, complex spline) and obtain temporally coherent frames that respect the specified motion. For the latest details, example notebooks, and release notes, consult the model card on Hugging Face (stabilityai/stable-virtual-camera).

Model Statistics

Downloads: 13,166
Likes: 222
Pipeline: image-to-video

License: other

Model Details

Stable Virtual Camera is described on Hugging Face as a 1.3B-parameter diffusion model trained for novel view synthesis and image-to-video generation. The model takes as input multiple images of a scene (multi-view conditioning) plus an explicit target camera trajectory and produces sequences of frames that aim to be 3D consistent across time. On Hugging Face the model is provided as an image-to-video pipeline (pipeline type: image-to-video). Key technical points documented on the model page include: parameter scale (1.3B), multi-image conditioning, and camera-pose or trajectory conditioning to control output viewpoints. The model card lists the license as "other" (see the model page for precise terms). Stability AI provides the model for research and creative non-commercial use; a provided model card and examples on the Hugging Face page show typical input formats and usage notes. Specific training recipes, exact architecture variants (e.g., latent vs. pixel diffusion), and low-level hyperparameters are not published in detail on the model card; consult the model repository for any linked training or inference notebooks.

Key Features

Generates 3D-consistent novel views and short videos from multiple input images.
Accepts freely specified target camera trajectories to control viewpoint motion.
1.3B-parameter diffusion model balanced for research-oriented performance and cost.
Provided as an image-to-video pipeline on Hugging Face for quick experimentation.
Intended for research and creative non-commercial use; check model card license.

Example Usage

Example (python):

from PIL import Image
import torch
from diffusers import DiffusionPipeline
import imageio

# Replace with the model ID on Hugging Face
MODEL_ID = "stabilityai/stable-virtual-camera"

# Load pipeline (requires diffusers and appropriate backend)
pipe = DiffusionPipeline.from_pretrained(MODEL_ID, torch_dtype=torch.float16)
pipe = pipe.to("cuda")

# Prepare multiple input images (example: list of PIL images)
input_images = [Image.open("view1.jpg"), Image.open("view2.jpg"), Image.open("view3.jpg")]

# Example camera trajectory: a list of camera poses or waypoints.
# The exact format depends on the model's expected conditioning format.
# Here we use a placeholder structure; consult the model card for exact keys.
camera_trajectory = [
    {"position": [0.0, 0.0, 0.0], "rotation": [0.0, 0.0, 0.0]},
    {"position": [0.1, 0.0, -0.2], "rotation": [0.0, 5.0, 0.0]},
    {"position": [0.2, 0.0, -0.4], "rotation": [0.0, 10.0, 0.0]}
]

# Inference: call the pipeline. Parameter names vary per implementation.
# Below is a generic example; check the model card for exact kwargs.
output = pipe(
    images=input_images,
    camera_trajectory=camera_trajectory,
    guidance_scale=7.5,
    num_inference_steps=50
)

# `output` should include a list/array of frames. Save as MP4.
frames = output.frames if hasattr(output, "frames") else output[0]
frames = [frame.convert("RGB") if isinstance(frame, Image.Image) else Image.fromarray(frame) for frame in frames]

imageio.mimwrite("novel_view_video.mp4", [frame for frame in frames], fps=24)

# Note: adjust arguments and input formatting to match the model card examples.