Stable Diffusion architecture images to video: ComfyUI image-to-video models, GPU cost and consistency

If you generate architecture images with Stable Diffusion or Flux in ComfyUI, you already have most of a video pipeline on your machine. The image models make stills only, but ComfyUI also runs open image-to-video models that animate a still into a few seconds of footage. Whether that's worth doing for a project film depends on your GPU, your patience and how consistent your six images are. This guide covers the open models documented as of October 2026, a basic ComfyUI image-to-video workflow, what the GPU time really costs, how to keep six images of one design, and when to hand the stills to a hosted service instead.

Key takeaways

• Stable Diffusion and Flux make still images; animation comes from separate image-to-video models such as Wan 2.2 or Stable Video Diffusion, which ComfyUI runs as their own workflows.
• ComfyUI's documentation says the Wan 2.2 5B model "should fit well on 8GB vram" with offloading, and that the Wan 2.2 models are Apache 2.0 licensed and "support commercial use."
• Wan's own model card says the 5B model makes a five-second 720P clip in under nine minutes on a single consumer-grade GPU, so six scenes with retries take hours, not minutes.
• Stable Video Diffusion XT makes 25 frames at 576 × 1024, about four seconds at most, and its model card warns that it may produce little motion and can't render legible text.
• Consistency across six images has to be built in the image stage: the same checkpoint, prompt, seed and sampler, with ControlNet guides from one 3D model.

Can Stable Diffusion turn architecture images into a video?

Not by itself. Stable Diffusion and Flux generate still images; to animate one, you load an image-to-video model such as Wan 2.2 or Stable Video Diffusion in ComfyUI and run a separate workflow that turns each still into a clip of roughly four to five seconds. A project film then means six clips, joined and scored in an editor. The alternative is to export six finished stills and give them to a hosted image-to-video service that returns the whole film.

Both routes start from the same place: six images that show one building. That part is covered below, after the models and the costs.

The open image-to-video models you can run in ComfyUI (as of October 2026)

Wan 2.2

ComfyUI's official Wan 2.2 workflow page covers three variants: a 5B hybrid model that does text-to-video and image-to-video, a 14B text-to-video model and a 14B image-to-video model (ComfyUI docs). It says "the Wan2.2 5B version should fit well on 8GB vram with the ComfyUI native offloading," and "the Wan2.2 series models are based on the Apache 2.0 open source license and support commercial use."

The Wan 2.2 image-to-video model card lists "480P & 720P" output at 24 FPS, and says the 5B model can "generate a 5-second 720P video in under 9 minutes on a single consumer-grade GPU" (Hugging Face, Wan-AI). For the 14B model, the reference code's single-GPU inference needs "at least 80GB VRAM"; ComfyUI's offloading lowers the bar, at the cost of speed.

Stable Video Diffusion

Stability AI's SVD XT model "generates 25 frames at resolution 576x1024," and its card is candid about limits: "The generated videos are rather short (<= 4sec), and the model does not achieve perfect photorealism," "the model may generate videos without motion, or very slow camera pans," "faces and people in general may not be generated properly," and "the model cannot render legible text" (Hugging Face, Stability AI). It can't be steered with a text prompt, and its stated inference time is about 180 seconds on an A100 80GB. The license is the Stable Video Diffusion community license, and the card points to Stability's license page for commercial terms.

For architecture, the 720P ceiling matters. A vertical Reel is delivered at 1080 × 1920, so a 720P clip will be upscaled on the way, and fine detail such as mullions and tile joints is the first thing to soften.

A basic image-to-video workflow in ComfyUI

ComfyUI ships Wan workflows as templates, so you don't have to wire the graph from scratch. Following the official page, the image-to-video run looks like this:

1. Load the models. The 14B workflow loads a high-noise and a low-noise diffusion model, plus the text encoder and the VAE named on the docs page.
2. Load your still. Put the architecture image into the LoadImage node.
3. Write a short motion prompt. Describe the camera, not the building: "slow push-in toward the entrance, steady camera, overcast light." The image already defines the building.
4. Set size and length. The docs note that the default size is small "to prevent low VRAM users from consuming too many resources," and suggest trying "a resolution around 720P" if you have enough VRAM. Match the aspect ratio to your still.
5. Run, review, repeat. Expect to regenerate. Change the seed or soften the camera move rather than rewriting the whole prompt.

Camera moves that keep buildings straight ranks the safe ones. In short: a slow push-in or a gentle lateral drift stays inside the frame; orbits and pull-backs force the model to invent what it can't see.

GPU time and cost: the honest numbers

Open models are free to download, not free to run. Here's a worked estimate from the published figures, not a benchmark.

• On your own GPU. At Wan's stated "under 9 minutes" per five-second 720P clip with the 5B model, six scenes with three attempts each come to 18 runs, or up to about 2.7 hours of generation, plus the time to set up, review and edit. The 14B model is slower again on consumer cards.
• On rented GPUs. As of October 2026, RunPod's pricing page lists an RTX 4090 at $0.89 an hour and an H100 SXM at $3.99 an hour on demand (RunPod). The GPU rent for a six-scene film is small; the hours of your own time are the real cost, along with downloading large model files to a fresh machine.
• After generation. You still need to join six clips, upscale them for a 1080 × 1920 export, and add licensed music.

If you enjoy the pipeline and make many films, the local route pays off. If you need one project film by Friday, it rarely does.

Six consistent stills from Stable Diffusion or Flux

A video model animates each image separately, so a film is only as consistent as its six inputs. Text-only prompts give you six similar buildings, not one. What holds a design still:

• Guide every image from one 3D model. Export depth maps or line drawings of six camera views from SketchUp, Rhino or Revit and feed them to ControlNet. The model fixes the geometry; the diffusion model only decides surfaces and light.
• Lock the generation settings. The same checkpoint, LoRA, sampler, steps, CFG, prompt text and seed for all six. Save the workflow as a file, and change only the ControlNet image between runs.
• One aspect ratio. Portrait or square for a vertical film, the same for every image.
• Inpaint, don't reroll. When one image has a wrong window, mask and regenerate that area only.
• Cover six roles. Context, approach, main space, secondary space, detail and closing view; the six roles a project video needs explains each.
• Check before animating. Count openings, follow the roofline, compare materials between exterior and interior. The fidelity checks for AI renders apply here too.

Save the workflow file next to the six images. Exports and uploads often strip embedded metadata, so the image alone may not tell you later which settings made it.

Local pipeline or hosted six-image service

Neither route gives you a measured walkthrough. Both animate pixels, not a 3D model, so motion past the frame edge is invented and the film is a sequence of views, not a route through the plan.

Handing the six stills to a hosted service

If you'd rather stop at the image stage, export the six checked stills at full size and upload them to Arch2Video. Each image needs a long side of at least 512 pixels, and 1,500 pixels or more gives the sharpest scenes; JPG, PNG, HEIC, TIFF and WebP files up to 30 MB are accepted, so ComfyUI's PNG output works as it is. The AI director plans the order, which may differ from your upload order, and uses every image once. The result is a 1080 × 1920 vertical H.264 MP4 of about 30 seconds: six connected five-second scenes with an original soundtrack (Still Air by default, or Quiet Piano, Concrete or none) and your logo if you add one. There's no prompt box, timeline or API, and every film includes a small cast of original, fictional adults in at least one scene. It usually takes an hour or more, and the price is USD 15 per video, paid once.

Whichever route you take, review the result as you would any AI footage, using an AI video quality checklist, and present it as concept work.

Frequently asked questions

Which ComfyUI model is best for animating architecture images?

As of October 2026, Wan 2.2 is the practical choice among the open models documented here: it runs image-to-video at up to 720P and 24 FPS, ComfyUI ships official workflows for it, and its Apache 2.0 license supports commercial use. Stable Video Diffusion is older and, by its own model card, short, sometimes nearly static and not controllable by prompt. Whichever you use, a slow push-in keeps straight lines straighter than an orbit.

Can I run Wan 2.2 image-to-video on an 8 GB GPU?

The 5B model, yes: ComfyUI's documentation says it "should fit well on 8GB vram with the ComfyUI native offloading." Expect slow runs and keep the resolution modest. The 14B image-to-video model is much heavier; the reference code asks for at least 80 GB of VRAM on one GPU, and offloading in ComfyUI makes it possible on smaller cards only at a large cost in speed.

Can I use Wan or SVD videos in client work?

ComfyUI's docs say the Wan 2.2 models are Apache 2.0 licensed and support commercial use. Stable Video Diffusion uses Stability's community license, and its model card sends commercial users to Stability's license page, so read the terms that apply to your business. Also check the license of the checkpoint and any LoRA that made the still. This is general information, not legal advice.

Why do the buildings bend and wobble in my AI clips?

Because the video model reads pixels, not geometry, and fills in each new frame by guessing. Long or fast camera moves, wide-angle source images and fine repeating detail such as louvers make it worse. Use a slow push-in, start from an eye-level image with straight verticals, keep the clip short and regenerate with a new seed when lines drift, rather than trying to fix the warp afterwards.