Most video diffusion models get more expensive the longer the clip, because the whole sequence has to stay in memory. Doubling the length roughly doubles the VRAM, which is why open video models tend to cap out at a few seconds on hardware most people own.
FramePack removes that constraint. It compresses the input context to a fixed length, so the generation workload is the same whether you are making five seconds or a minute. The project's own headline figure is the striking one: a 13B model producing 60 seconds of video at 30fps, which is 1,800 frames, on a minimum of 6 GB of GPU memory.
Length stops being a memory problem and becomes a time problem. That changes how you should pick hardware and how you should budget a run.
What FramePack does differently
Conventional video diffusion holds the full sequence in VRAM. FramePack is a next-frame-section prediction structure: it generates progressively, predicting the next section from a compressed representation of what came before. Because that context representation is a constant size, memory use does not grow with clip length.
The project describes the result as video diffusion that feels like image diffusion, and the same property lets it train at batch sizes closer to image models.
What this means in practice:
- Long clips cost time, not memory. A longer video takes longer but does not need a bigger card.
- Modest hardware becomes viable for work that previously needed a data center GPU.
- You see output as it arrives. Generation runs section by section, so you get visual feedback well before the clip is finished. A progress bar that shows only one second of video early on is expected behavior, not a failure.
- Very long sequences can drift, because the model is working from compressed context rather than full history.
What do I need to run FramePack?
The requirements published by the project are specific, and two of them matter more than the VRAM figure everyone quotes.
- At least 6 GB of GPU memory. That is the floor for the 13B model at 60 seconds and 30fps.
- An NVIDIA GPU in the RTX 30XX, 40XX or 50XX series that supports fp16 and bf16. The project states GTX 10XX and 20XX are untested.
- Linux or Windows. On Linux the project recommends an independent Python 3.10 environment.
- More than 30 GB of model weights, downloaded automatically from Hugging Face on first run.
That second point is worth reading carefully before you pick a GPU. The project lists consumer RTX series specifically. Workstation and data center cards of the same generation, such as the RTX A5000 and RTX A6000, are Ampere silicon and support bf16, so they meet the stated architectural requirement, but they are not on the project's tested list. If you want to stay inside what the maintainers have verified, choose an RTX 3090, 4090 or 5090.
Time is the cost, not memory
Because VRAM stays flat, the only thing that scales with clip length is generation time. The project publishes its own benchmark on an RTX 4090 desktop: 2.5 seconds per frame unoptimized, or 1.5 seconds per frame with TeaCache enabled.
Run that against the 1,800 frames in a 60 second clip at 30fps and you get a usable planning number:
- About 45 minutes for a one minute clip with TeaCache on
- About 75 minutes for the same clip at full quality with TeaCache off
The project notes that laptop GPUs such as a 3070ti or 3060 run roughly 4x to 8x slower, so the same job on a laptop-class card is measured in hours rather than minutes.
Budget by the hour, not by the gigabyte. Since the card requirement does not move with clip length, cost is generation time multiplied by your hourly rate. A longer target clip means more hours, not a bigger GPU.
Choosing a GPU on Runpod
Every card below clears the 6 GB minimum many times over, which is exactly the point: on FramePack you are not buying VRAM, you are buying speed per dollar.
Start with the RTX 4090. It is on the supported list and it is the card the project benchmarks against, so the published 1.5 and 2.5 seconds per frame figures are the ones you should actually see. That makes it the only card where you can predict a run time before you start.
Check the rate card before assuming bigger costs more. Runpod's hourly rates do not track VRAM in the order you would expect, and the 48 GB RTX A6000 has at times been cheaper per hour than the 24 GB RTX 4090. Since FramePack needs neither card's full memory, that is a real consideration, with one caveat: a cheaper card that generates more slowly can still cost more for the same clip. Compare hourly rate and frames per second together, not separately.
When to use FramePack
Use FramePack for long single-shot video, animating a still image into extended motion, and any case where clip length is the constraint rather than resolution.
Use something else for short high-fidelity clips, where a model optimized for a few seconds will look better. See How to Use Wan 2.7 on Runpod for that.
The honest trade: FramePack buys length. If you want five seconds that look as good as possible, a model built for five seconds is the better choice.
Running FramePack on Runpod
- Deploy a pod. Open the Pods section, select an RTX 4090, and choose a PyTorch template.
- Set container disk to at least 60 GB. The weights alone are over 30 GB, and you need room for output on top of that.
- Attach a network volume. Strongly recommended. Re-downloading 30 GB of weights every session is a real cost in both time and money, and generated video is large.
- Clone the repository and install dependencies. The project recommends an independent Python 3.10, PyTorch built for CUDA 12.6, then the repository requirements file. Follow the project's current instructions rather than a snapshot in this article, since video tooling moves quickly.
- Launch the Gradio interface. The repository ships a demo script that starts a web UI where you upload an image, write a prompt, and watch sections generate.
- Run the sanity check first. The project provides a reference image, prompt and settings, along with the expected output. Confirming you match it catches hardware and software problems before you spend an hour on a long generation.
- Stop the pod when you are done. Billing is per second while it runs, and video work has long gaps where you are reviewing output rather than generating.
Getting quality results with FramePack
Understand what TeaCache costs you. It roughly cuts generation time from 2.5 to 1.5 seconds per frame, but the project is direct that it is not lossless and can change results noticeably. Their recommendation, and the right one, is to use TeaCache while you are trying ideas and switch to the full diffusion process for the take you intend to keep. The same applies to sage-attention and to quantized weights.
Start short, then extend. Confirm your prompt and input produce what you want over a few seconds before committing to a long generation.
Watch for drift. Because context is compressed, subjects can shift over long sequences. This is a known limitation the project is actively working on: FramePack-F1 was released in May 2025, and the in-development P1 version adds planned anti-drifting and history discretization specifically to address it. If a clip degrades past a certain point, generate in segments and join them rather than pushing a single run further.
Input image quality carries through. When animating from a still, the source image sets the ceiling for everything after it.
Write output to the network volume, not pod storage. Video files are large, and losing a completed long generation to a stopped pod is avoidable.
Queue long runs rather than babysitting them. A one hour generation is exactly the workload where a stopped-when-done pod beats leaving a machine running while you sleep.
Get it from the official place
FramePack has attracted an unusual number of imitation sites. The maintainers state plainly that the GitHub repository is the only official FramePack website, and that a long list of lookalike domains using the FramePack name are spam. Their instruction is direct: do not pay money to or download files from any of them.
The project is open source under Apache 2.0. If a site is asking you for a subscription to use FramePack, it is not the project.
Frequently asked questions
What is FramePack?
A video generation method that predicts frames section by section from a compressed, fixed-length context representation, which keeps memory use constant as clip length grows. It is released as an open source implementation and desktop application by the author of ControlNet.
What GPU do I need for FramePack?
The published minimum is 6 GB of GPU memory, on an NVIDIA RTX 30XX, 40XX or 50XX series card supporting fp16 and bf16. Memory does not increase with clip length, so a larger card buys speed rather than capability. On Runpod, an RTX 4090 is {{gpu:rtx-4090}}/hr on Secure Cloud and matches the hardware the project benchmarks against.
How long can FramePack videos be?
The project demonstrates 60 seconds at 30fps, which is 1,800 frames, on the 6 GB minimum. Memory is not the limit. The practical constraints are generation time and quality drift over very long sequences.
How long does it take to generate a one minute video with FramePack?
On the project's RTX 4090 benchmark, roughly 45 minutes with TeaCache enabled or about 75 minutes at full quality, based on their published 1.5 and 2.5 seconds per frame. Laptop-class GPUs run roughly 4x to 8x slower.
Is FramePack better than Wan or LTX?
Different jobs. FramePack is built for length on modest hardware. Models tuned for short clips will generally look better over a few seconds. Pick based on whether length or fidelity is your constraint.
How much does it cost to generate a long video?
Cost tracks generation time, since the card requirement does not change with length. Take your expected run time, roughly 45 to 75 minutes for a one minute clip on a 4090, and multiply by the hourly rate for the card you choose. Billing is per second, so stopping the pod between runs matters.
Should I use TeaCache?
Use it while iterating, then turn it off for final output. It is a meaningful speedup, roughly 2.5 to 1.5 seconds per frame on a 4090, but the project states it is not lossless and can visibly change results.
