In February 2025, Alibaba released the Wan 2.1 weights under the Apache 2.0 license and published data that shifted the minimum requirements for generative video: its 1.3 billion parameter version generates clips with about 8 GB of VRAM, according to the company’s own release data. Just a few months prior, producing an AI clip meant paying for credits in a cloud service and waiting in a third-party server queue. Since then, three names have dominated the local conversation: Genmo’s Mochi, Lightricks’ LTX-Video, and Alibaba’s Wan. In this article, we will look at what each offers, how much VRAM they actually require, and how to use GGUF to fit weights of dozens of gigabytes into home GPUs using ComfyUI.
Three Open-Weight Bets
Genmo broke the ice in October 2024 with Mochi 1, a 10 billion parameter diffusion transformer published under Apache 2.0. According to its technical sheet, it generates clips of up to about 5 seconds at 480p, and from the start, it excelled in something rare in the open ecosystem at the time: strict instruction following and remarkably coherent motion representation. The barrier was the hardware; full-precision weights pointed toward GPUs with dozens of gigabytes, until the community brought them to consumer cards through quantization and RAM block offloading.
Lightricks took the opposite path with LTX-Video, released in November 2024. The initial model weighed only 2 billion parameters, and the company presented it as a diffusion transformer capable of generating video faster than it takes to play back on high-end hardware. The philosophy is clear: accept a smaller footprint to gain massive iteration speed. The line continued to grow in 2025 with a quality-oriented 13 billion parameter variant, and LTX-2, the next generation, has already been announced.
Wan entered the scene in February 2025 with two sizes available from day one: 1.3 billion parameters for 480p and 14 billion for 720p, both featuring text-to-video and image-to-video at 16 fps. Alibaba highlighted the RTX 4090 as the target for the small version and noted its strong performance with on-screen text in Chinese and English. Later came Wan 2.2, featuring a mixture-of-experts architecture and a smaller size variant designed for home equipment, all again under Apache 2.0.
If you come from local language models, the script will feel familiar: public weights, a permissive license, and a community that produces quantizations, wrappers, and distilled LoRAs within weeks. It is the same dynamic that led DeepSeek-R1, with its 671 billion parameters and MIT license, to run outside of major data centers. With video, the limiting variable changes: almost the entire ecosystem advances on its own, except for VRAM.
The choice between the three models is not about taste: LTX for fast iteration on modest cards, Wan for quality with the most active ecosystem of wrappers and LoRAs, and Mochi as a veteran alternative that continues to respond well to demanding prompts. Look at how many gigabytes your card has, and the list of candidates will narrow itself down.
VRAM Decides: Which Card Do You Actually Need?
In local execution, there are three memory consumers: the diffusion model weights, the text encoder, and the VAE along with the latents. The first block dominates in size. A 14 billion parameter model in BF16 occupies about 28 GB for weights alone, meaning it won’t fit on a 24 GB card no matter how much you optimize the rest of the pipeline.
The other two also add to the bill. Wan uses umt5-xxl as a text encoder, while Mochi and LTX-Video work with T5-XXL; in its original version, it occupies several GB, which is why loading fp8 versions is common. Latents grow with resolution and the number of frames: moving from 480p to 720p, or from 5 to more seconds per clip, spikes the memory peak.
Based on size references, the map looks like this: an RTX 3060 with 12 GB can start with Wan 1.3B or LTX-Video at low resolutions. With 16 GB (a 4080 or a 16 GB 4060 Ti), a quantized Wan 14B fits with some help from RAM block offloading. The 24 GB of a 3090 or 4090 is the sweet spot for 14B in fp8 or GGUF, and the 32 GB of a 5090 removes almost any limit in the current open catalog. In the buying path, the 3090 remains the typical route to get 24 GB without paying this year’s high-end prices.
On Mac with Apple Silicon, ComfyUI runs these models but with notable wait times, and on AMD, support via ROCm works with more tinkering. NVIDIA remains the frictionless route for local generative video. Every block sent to RAM is paid for in time, not quality: the goal is for the weights to fit entirely in the GPU.
Before downloading anything, note how many GB your card has and choose the largest model that fits in VRAM. If none fit in their original precision, the solution has a name: GGUF.
GGUF: llama.cpp Quantization Comes to Video
GGUF is the file format popularized by llama.cpp to run compressed language models on modest hardware. The idea is to store each weight with fewer bits than the usual 16: 8, 6, 5, or fewer per parameter. Fewer bits mean fewer GBs on disk, less VRAM occupied, and large models fitting on small cards.
The bridge to video was built by the community. Developer city96 adapted the format to diffusion transformers, and his custom node ComfyUI-GGUF loads these files within ComfyUI; he had previously done the same with GGUF for FLUX. Today, there are GGUF quantizations for Mochi, LTX-Video, and Wan. The nomenclature comes intact from llama.cpp: from Q2_K to Q8_0—the lower the number, the less precision and less memory.
The numbers are telling. A 14 billion parameter model in Q4 is around 7 GB of weights, compared to 28 GB for the BF16 version; that difference is what brings Wan 14B down to the territory of 12 or 16 GB cards. The trade-off is quality: in Q6 and Q8, the loss is barely perceptible to the naked eye; in Q4, there is a visible drop in detail and motion coherence; and below Q3, the degradation usually invalidates the result.
The workflow will feel familiar if you already generate images locally, as we described in the article on FLUX.1 dev and ComfyUI for professionals: download the .gguf file, place it in its model folder, and select the specialized loader in the workflow. As an alternative to quantization, Kijai’s wrapper for Wan keeps the model in fp8 and moves blocks between GPU and RAM during generation—another way to stretch available memory at the cost of time.
If your hardware is at its limit, start with a Q5_K_M of the model you are interested in: it usually marks the reasonable balance between weight and fidelity. Go up to Q6 if your card has room to spare and down to Q4 only if the former doesn’t fit.
From Zero to Your First Clip with ComfyUI
ComfyUI provides native support for all three models, and its library includes official templates for each. Start by updating to the latest version: video releases have been arriving with their own support within hours or days.
Next, it’s time to download weights. The diffusion model, in fp8 or GGUF, goes into the diffusion models folder; the text encoder (umt5-xxl in Wan’s case) and the VAE go into their respective folders. The Hugging Face repositories for each project and the pages of city96 and Kijai list the exact files and their locations, so there is no guessing involved.
With the files in place, open the model template, check that the loaders point to your files, and launch the first generation: 480p, a clip of about 5 seconds (in Wan, 81 frames at 16 fps), and a moderate number of steps. This minimum configuration is the test bench; it confirms that the pipeline works from end to end, from text to the video file on your disk.
Once the flow is working, add a distilled LoRA like LightX2V, which reduces Wan generation to about 4 steps per clip and multiplies iteration speed at the cost of some detail. On a 24 GB card, this cycle allows you to test dozens of variations in an afternoon; on a 12 GB card, times still dominate, and it’s advisable to start with the 1.3B or LTX-Video.
Save the working template as a versioned starting point and only then increase resolution or duration. Jumps from 480p to 720p multiply memory and time instantly: first a stable pipeline, then larger sizes.
Where it Fits in Professional Work
For a technical profile, the current viable uses are for previewing: b-roll for presentations, storyboard animatics, backgrounds for motion graphics, or pitch material before committing to a shoot or a 3D render. Generative video on your GPU can already communicate ideas competently; it does not yet deliver a final piece without retouching.
The limitations are specific: clips last seconds, so long pieces are assembled in chunks; hands and legible text within the frame frequently fail; temporal flickers appear that force regenerations; and wait times depend directly on your card. None of this is abstract opinion: it defines which tasks you can delegate to the model today and which still require classic tools.
Before billing results generated with these models, review the licenses. Mochi 1 and Wan are published under Apache 2.0, which simplifies commercial use; for LTX-Video, it is advisable to read the license as it stands in its Hugging Face repository before using outputs in client projects. It is wise to apply the same discipline as with any open-source dependency.
A practical starting point: choose a repeatable task in your work, such as b-roll for every presentation, and run it through the model every quarter. If the result passes your quality control without retouching, that task has changed owners; if not, you’ve lost little and you know where the limit lies.
A Concrete Plan for This Weekend
With 8-12 GB of VRAM, start with Wan 2.1 1.3B or LTX-Video; with 16-24 GB, set up Wan 14B in Q4 or Q5 with the GGUF loader and compare it directly with the 1.3B. Use the same prompt and the same seed across the three families: direct comparison teaches more than any specification table.
The advantage of running this on your GPU is not the price per clip, which is just electricity; it is being able to iterate without counting credits, without uploading drafts to a third party, and with the entire process recorded in a workflow that can be versioned and reused. Run the three models with your prompt, save the best result, and leave the template ready for the next project. The frontier of what fits on a home card is moving quarter by quarter right now, and the only reliable way to know where yours stands is to measure it.