FramePack: Generate 60-Second AI Videos on a 6GB GPU

FramePack generates 60-second, 30fps AI videos (1,800 frames) on a 6GB Nvidia GPU — free, local, and open source. The official README is blunt about it: "the minimal required GPU memory is 6GB. (Yes 6 GB, not a typo. Laptop GPUs are okay.)" On an RTX 4090 it renders at 1.5-2.5 seconds per frame; a laptop RTX 3060 runs 4-8x slower but works. Install is a one-click package on Windows or five commands on Linux, plus a ~30GB model download on first run.

That 6GB floor is the reason this page exists. Every other serious local video model asks for 12, 16, 24GB before it will even load. FramePack turned the budget GPU — the card most of our readers actually own — into a video generation machine, and it did it with an architectural trick rather than brutal quantization. Here is exactly what it is, what the numbers really mean for your hardware, and every step of the install.

---

What FramePack Is (and Why 6GB Works)

FramePack is a 13B image-to-video model from lllyasviel — the developer behind ControlNet and Fooocus — that generates video as next-frame-section prediction with a fixed memory cost, no matter how long the video gets. The repo sits at 17.2k GitHub stars as of August 2026.

Normal video diffusion models attend over every frame at once, so VRAM scales with video length — which is why most tools cap out at a few seconds. FramePack instead predicts the video one section at a time, compressing everything it has already generated into a constant-size "frame context." The research behind it, Frame Context Packing and Drift Prevention in Next-Frame-Prediction Video Diffusion Models (Lvmin Zhang, Shengqu Cai, Muyang Li, Gordon Wetzstein, Maneesh Agrawala), is on arXiv as 2504.12626. The practical consequence, straight from the README: generating a 1-minute, 30fps, 1,800-frame video with the 13B model needs only 6GB of GPU memory.

Two more things worth knowing before you install:

• It is built on HunyuanVideo. The underlying 13B transformer is a HunyuanVideo derivative (the weights ship as FramePackI2V_HY on Hugging Face), so if you have read our HunyuanVideo local guide, this is that model made drastically cheaper to run for long clips.
• The author's track record matters here. lllyasviel's tools — ControlNet, Fooocus, Forge — share a house style: research-grade ideas wrapped in installers that normal people can actually run. FramePack keeps that tradition, down to the one-click Windows package.

---

Hardware: The Real Numbers

Minimum: any RTX 30XX/40XX/50XX Nvidia GPU with 6GB VRAM and roughly 40GB of free disk. Realistic: the more compute you have, the shorter the wait — memory is the floor, speed is the tax.

Everything in this table comes from the official README (lllyasviel/FramePack, fetched August 2026):

Now the arithmetic nobody prints — derived from those official per-frame speeds, so treat it as estimates, not measurements:

So yes: a 6GB laptop genuinely renders a one-minute video — as an overnight job. That is still remarkable. Before FramePack, the answer on that hardware was simply "no." If you are on an RTX 3060, our RTX 3060 local AI guide covers what else the card handles well, and if you are deciding what a 6GB card is good for beyond video, see the best models for 6GB VRAM.

One honest gap in the support matrix: RTX 20XX cards (2060, 2070, 2080) fall in the "not tested" bucket alongside the GTX 10XX series. Some may work; you are in unsupported territory. AMD and Apple Silicon are not mentioned at all — this is a CUDA project.

---

Windows: One-Click Install

Download the official one-click package, run update.bat once, then run.bat — that is the entire install. No Python environment, no CUDA wrangling.

The package bundles CUDA 12.6 and PyTorch 2.6, so the usual dependency minefield is pre-cleared. Step by step:

1. Download the one-click package from the lllyasviel/FramePack GitHub README — the link labeled "One-Click Package (CUDA 12.6 + Pytorch 2.6)". Download it from the GitHub repo only: the README warns that fake "framepack" domains exist and calls the repo page "the only official FramePack website." It is a compressed archive — extract it anywhere with enough disk space.
2. Run update.bat first. The README is explicit about this: update before first launch so you get the latest bug fixes rather than the version frozen into the archive.
3. Run run.bat. On first launch the app downloads the models automatically — more than 30GB from Hugging Face, per the README — then opens the Gradio interface in your browser.

Budget for that download: on a 100Mbit connection it is the better part of an hour before your first frame renders. After the first run, launches are fast because everything is cached locally.

---

Linux: Five Commands

Python 3.10, two pip installs, one launch command. From the official README:

git clone https://github.com/lllyasviel/FramePack
cd FramePack
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu126
pip install -r requirements.txt
python demo_gradio.py

The README specifies Python 3.10 — use a fresh venv or conda environment at that version rather than fighting your system Python. The Gradio app supports --share (public tunnel link), --port, and --server flags if you are running it on a headless box and browsing from another machine.

Same first-run behavior as Windows: the 30GB+ of model weights pull automatically from Hugging Face on launch.

Optional speedups: FramePack runs on plain PyTorch attention out of the box, and additionally supports xformers, flash-attn, and sage-attention if you install them (pip install sageattention==1.0.6 for the last one). One caveat straight from the README: "you are highly recommended to first try without sage-attention since it will influence results, though the influence is minimal." So get a clean baseline render first, then bolt on the speed.

---

Your First Video: Settings That Matter

Upload a starting image, write a short motion-focused prompt, generate. FramePack is image-to-video — the image is your composition, the prompt is your choreography.

Three things determine whether your first result looks good:

1. Prompt like the README tells you to. The official guidance is concise, motion-first prompting — structure it as subject, then motion, then details. The repo's own example: "The girl dances gracefully, with clear movements, full of charm." This is the opposite of Stable Diffusion habit. Long scene-description prompts waste tokens describing what the input image already shows; the model needs to know what should move and how.

2. Understand the section-by-section stream. FramePack is a next-frame-section prediction model, and the README describes exactly what you will see: "videos will be generated longer and longer. You will see the progress bar for each section and the latent preview for the next section." Practical upside: if the motion is going wrong, you see it within the first section and can kill the job instead of discovering the problem 1,700 frames later.

3. Use teacache for drafts, turn it off for finals. Teacache is the toggle behind the README's 2.5 → 1.5 s/frame speedup on a 4090, and the project's own advice matches intuition: "We recommend using teacache to try ideas and then using the full diffusion process to get high-quality results." It is an approximation, so keeper renders get the full process.

One more piece of official advice worth obeying: the README "highly recommend[s] going through the sanity check" — the repo's known-good image and prompt — before trying your own inputs, so a bad first result tells you something about your setup rather than your prompt. And start with a 3-5 second clip to validate motion before committing an hour (or a night) to 60 seconds. The per-frame cost is the same; the regret is not.

---

FramePack in ComfyUI

The standalone Gradio app is the easier path — use the ComfyUI wrapper only if FramePack needs to live inside a larger node workflow. There is no built-in ComfyUI support in the official repo; the community standard is kijai's wrapper.

ComfyUI-FramePackWrapper (1.7k stars, from ComfyUI's most prolific wrapper author) is explicitly labeled "WORK IN PROGRESS — Mostly working." Setup, per its README:

1. Clone the wrapper into ComfyUI/custom_nodes/ and install its requirements.
2. Get the transformer. Either let it auto-download the diffusers-format model from lllyasviel/FramePackI2V_HY on Hugging Face (lands in ComfyUI/models/diffusers/lllyasviel/FramePackI2V_HY), or grab a single-file version — FramePackI2V_HY_fp8_e4m3fn.safetensors or FramePackI2V_HY_bf16.safetensors from Kijai's HunyuanVideo_comfy Hugging Face repo — and drop it in ComfyUI/models/diffusion_models. The fp8 file is the one to take on low-VRAM cards.
3. Get the supporting models. The wrapper uses the standard Comfy-Org HunyuanVideo repackaged set — text encoders and VAE — plus the sigclip_vision_384 CLIP-vision model. If you already run HunyuanVideo natively in ComfyUI, you have these; they go in the usual text_encoders, vae, and clip_vision folders.

If you want the newer F1 model inside ComfyUI, kijai's original wrapper does not mention it — the community extension ComfyUI-FramePackWrapper_Plus builds on kijai's work and adds an F1 sampler plus LoRA support. It is a smaller project (113 stars), so expect rougher edges.

New to the node graph entirely? Start with our ComfyUI complete guide first — the wrapper assumes you already know your way around model folders and custom nodes.

---

Original vs F1: Which Model to Run

Run the original for stable, predictable motion; try F1 when clips feel too static. Both ship in the same repo — demo_gradio.py launches the original, demo_gradio_f1.py launches F1.

The timeline, from the repo's news section and the official F1 release notes:

• April 2025 — FramePack released (the paper hit arXiv on April 17, 2025). The original model is the stability-first option.
• May 3, 2025 — FramePack-F1 released. The official description: "a FramePack model that only predicts future frames from history frames" — strictly forward generation with "a new anti-drifting regulation", and, per the same release notes, "larger variances and more dynamics will be visible."
• June-July 2025 — FramePack-P1 research results posted, followed by "pure text2video anti-drifting stress-test results" (repo news, July 14, 2025). P1 is the research track, not an installable tool — but it shows where the project is heading: text-to-video.

On Windows, switching to F1 means editing run.bat to launch demo_gradio_f1.py instead of demo_gradio.py (the release notes spell out the exact line). Practical advice: the original's bias toward stability suits the classic FramePack use case — long, coherent shots from a single image. If your subject should dance rather than sway, render the same input through F1 and compare. Same hardware requirements either way.

---

Honest Limitations

FramePack is the best long-video option for 6-8GB cards, full stop — but it is not the best local video generator overall, and you should know the trade-offs before burning a night of GPU time.

• Image-to-video only, in practice. You need a decent starting frame. Pure text-to-video is the P1 research track, not the shipping tool. Generate your input still with a local image model first, or use a photo — and if text-to-video is the actual requirement, go Wan instead.
• Slow is the price of small. The 6GB floor does not repeal physics: on the very cards this tool targets, a 60-second video is measured in hours (see the math table above). Treat long renders like overnight batch jobs, not interactive work.
• Motion can be conservative. The original model prioritizes keeping 1,800 frames coherent over dramatic movement — the F1 release notes' promise of "larger variances and more dynamics" is an implicit admission of it. F1 helps; neither matches the raw dynamism of the best short-clip models.
• Nvidia-only, RTX 30-series or newer. GTX 10XX/20XX untested, AMD and Apple Silicon unsupported. This excludes a real chunk of budget hardware.
• It is a 2025-vintage wave. FramePack's core release energy was April-July 2025, and the open-video field moves fast. The 6GB/60-second combination remains unmatched as of August 2026, which is why we still recommend it — but survey the field in our local AI video generation overview and the low-VRAM text-to-video roundup before committing your workflow to any single tool.
• 30GB+ disk commitment. Automatic, unavoidable, and easy to forget when your SSD is nearly full.

None of these change the headline. If you own a 6-8GB Nvidia card and want to animate images into genuinely long videos without paying a cloud service, FramePack is the tool, and nothing else in the local stack currently comes close at that VRAM tier.

---

Sources

• lllyasviel/FramePack — official repo and README (VRAM floor, speeds, install commands, GPU support, F1/P1 timeline; fetched August 2026)
• FramePackI2V_HY on Hugging Face — official model weights
• kijai/ComfyUI-FramePackWrapper — ComfyUI wrapper README (model files, folder paths, WIP status)
• ShmuelRonen/ComfyUI-FramePackWrapper_Plus — F1 sampler + LoRA extension for ComfyUI
• Frame Context Packing and Drift Prevention in Next-Frame-Prediction Video Diffusion Models — Zhang, Cai, Li, Wetzstein, Agrawala (arXiv:2504.12626, cited in the FramePack README)

---

FAQ