Live stream set for 2025-10-23 at 14:00:00 Eastern

Ask questions in the live chat about any programming or lifestyle topic.

This livestream will be on YouTube or you can watch below.

ComfyUI + Wan 2.2 T2V 14B: Beginner’s Guide to Text-to-Video on Linux (AMD Instinct Mi60 Setup)

Hello, creative minds and tech enthusiasts! Ever wanted to turn your text prompts into amazing, high-quality videos right on your own Linux machine? Today, we’re diving into the exciting world of **ComfyUI** and the powerful **Wan 2.2 T2V 14B** Text-to-Video model. This guide is tailored for beginners running **Linux** with an **AMD Instinct Mi60 32GB HBM2 GPU**-a powerful setup that can truly make this model shine.

ComfyUI is a node-based interface that makes advanced Stable Diffusion and video generation workflows more visual and manageable. Wan 2.2 T2V 14B is a cutting-edge AI model that excels at generating high-fidelity videos from text. Let’s get started!

System Requirements and Model Details

Before we jump into the fun part, let’s make sure your system’s ready to handle this robust model. The Wan 2.2 T2V 14B model is a significant undertaking, and running it on a single GPU often requires specialized optimization.

Is Wan 2.2 T2V 14B Open Source?

Yes, Wan 2.2 T2V 14B is an open-source model!

• License: The model is released under the **Apache 2.0 License**.
• Restrictions: The Apache 2.0 license is highly permissive. It generally allows you to **use, modify, and distribute** the software and models, even for **commercial purposes**, without royalties. However, it requires you to include the original **copyright and license notices** in your work and note any significant changes you make. **Always check the latest official repository documentation** for any specific usage limitations or ethical guidelines (e.g., concerning harmful or illegal content generation) that the creators may have imposed.

Step-by-Step: Configuring Wan 2.2 T2V 14B in ComfyUI

Since you’re using Linux with an AMD GPU, you must rely on **ROCm** for GPU acceleration.

1. Prerequisites (For AMD Linux Users)

Ensure you have your **ROCm** drivers and a PyTorch version compiled with ROCm support installed. This is the foundation for using your Mi60 for AI tasks.

2. Install ComfyUI

1. Clone the Repository: Open your Linux terminal and clone the ComfyUI repository.

   git clone https://github.com/comfyanonymous/ComfyUI.git
   cd ComfyUI

2. Install Dependencies: Use the ROCm-compatible requirement installation.

   pip install -r requirements.txt

   Note: If you have issues, search for guides on installing PyTorch with ROCm for your specific ROCm version.

3. Install the Wan2.2 Custom Node

Wan 2.2 integration often requires a custom ComfyUI node to load and manage the MoE (Mixture-of-Experts) architecture. You can often find these via the **ComfyUI Manager** (a recommended custom node for managing others), or by manually cloning a dedicated Wan2.2 workflow/node repository into your ComfyUI/custom_nodes folder.

4. Download the Model Checkpoint

1. Locate the official **Wan 2.2 T2V 14B checkpoint** (or a recommended GGUF/quantized version for lower VRAM) on platforms like Hugging Face.
2. Place the model file (e.g., a .ckpt or .safetensors file) into your ComfyUI/models/unet directory. For GGUF files, the location may vary (e.g., ComfyUI/models/llm or a specific folder designated by the custom node).

5. Run ComfyUI and Load the Workflow

1. Start ComfyUI from your terminal:

   python main.py

2. Open the web interface (usually http://127.0.0.1:8188).
3. Load a Workflow: Find a pre-built **Wan 2.2 T2V 14B ComfyUI workflow** online (they are often shared as .json files or directly through the node’s documentation). Load this workflow by dragging the .json file onto the ComfyUI canvas. This pre-configures all the necessary nodes for you.
4. Select the Model: In the **Checkpoint Loader** or specific Wan 2.2 loading node, select the Wan2.2-T2V-A14B model file you downloaded.

6. Configure and Generate!

1. Adjust Settings: Modify the text prompt (your desired video description) and other parameters like frame count, resolution (start with 480P or a smaller resolution like 832×480 to test performance), and number of steps.
2. Optimize for 32GB VRAM: Look for settings in your workflow that enable **model offloading** or use a **quantized (GGUF)** checkpoint. These are crucial for fitting the 14B model onto your 32GB VRAM.
3. Click “Queue Prompt”: ComfyUI will process your request, utilizing your powerful AMD Instinct Mi60! Video generation can take several minutes, depending on the complexity and settings.

Analysis of Model Loading Failure

The following table summarizes resource usage before and during the memory-intensive AI model loading process. The rapid consumption of resources led to an immediate Out-of-Memory (OOM) event.

Resource Usage During AI Model Loading

Summary of the Failure Event

The system experienced a critical failure because the AI model’s memory requirements, peaking with a 20.1 GB increase in RAM demand, exceeded the combined total of physical RAM and the compressed ZRAM swap.

Although the system attempted to manage the load by utilizing 4.4 GB of swap space, this was insufficient. The failure message—”Application Stooped Device memory is nearly full. An application was using a lot of memory and was forced to stop.”—confirms an Out-of-Memory (OOM) event was triggered. This resulted in the operating system forcibly terminating the application. The simultaneous spikes in CPU temperature (to 55°C) and dedicated GPU temperature (to 80°C) confirm that the hardware was stressed right up until the point of termination. Increasing the disk swap capacity, as outlined in the previous steps, is the correct measure to allow the system to handle these large memory demands by providing a large, disk-backed memory overflow.

Increasing Swap for AI Workloads (Adding Disk Swap)

I had an 8GB ZRAM partition (/dev/zram0), which is compressed swap space that lives in RAM. Since AI workloads demand high memory, we will add a 16GB disk-backed swap file on the dedicated AI partition (/mnt/AI on /dev/sdb1) to act as a high-capacity overflow.

Using the /mnt/AI partition is ideal because it isolates the heavy swap I/O from your root system drive (/dev/sda3) and utilizes the available 103GB on that dedicated drive.

Command Verification

$ swapon --show
NAME        TYPE      SIZE USED PRIO
/dev/zram0 partition   8G 3.5G  100
$ sudo fallocate -l 16G /mnt/AI/swapfile_ai
$ sudo chmod 600 /mnt/AI/swapfile_ai
$ sudo mkswap /mnt/AI/swapfile_ai
Setting up swapspace version 1, size = 16 GiB (17179865088 bytes)
no label, UUID=your-real-uuid-7a1c2e9b-5f3d-4b90-a021-1111aabbccdd
$ swapon --show
NAME        TYPE      SIZE USED PRIO
/dev/zram0 partition   8G 3.5G  100

Step 1: Activate the New Swap File

The disk swap file was created and initialized, but was not yet active. Use swapon to activate it immediately.

1. Activate the Swap File:

   sudo swapon /mnt/AI/swapfile_ai

2. Verify Total Swap Space (Expected 24GB Total):

   You should now see both the ZRAM and the new disk file active. The system automatically prioritizes the fast ZRAM (PRIO 100) over the slower disk swap (lower PRIO).

   swapon --show

   Expected Output will show both entries:

   NAME	TYPE	SIZE	PRIO
   /dev/zram0	partition	8G	100
   /mnt/AI/swapfile_ai	file	16G	-2 (or similar low value)

Step 2: Make the Disk Swap Permanent (/etc/fstab)

This is a crucial step to ensure the 16GB swap file is enabled automatically every time you reboot.

1. Open the /etc/fstab file:

   sudo nano /etc/fstab

2. Add the following line to the end of the file:

   /mnt/AI/swapfile_ai none swap sw 0 0

3. Save and close the file (in nano, press Ctrl+O then Enter, then Ctrl+X).

Step 3: Kernel Optimization (Swappiness)

Since you are running AI tasks, it’s best to configure the kernel to keep active data in the fast physical RAM as long as possible before resorting to disk swap.

1. Set swappiness to 10 (less aggressive swapping):

   sudo sysctl vm.swappiness=10
   sudo sh -c 'echo "vm.swappiness=10" >> /etc/sysctl.conf'

2. This setting is permanent and will take effect immediately and after reboots.

Model Precision and Quantization Comparison

To run large AI models like the 14B parameter model efficiently on systems with limited memory (like 32GB VRAM + 27GB RAM), it’s crucial to reduce the model’s footprint. This is achieved by moving from standard full-precision formats (FP32) to half-precision (FP16) and finally to advanced quantization (like FP8 and GGUF).

Comparison Table: Precision vs. Performance

Key Takeaways for Your Workflow

Given the hardware and the memory failure, switching to a lower precision model is the most effective solution:

• FP32: **Infeasible.** Requires 4x the memory and would instantly crash your system.
• FP16: **Too Large.** The current failure indicates the 14B model in FP16 is too big for your combined memory, forcing the slow disk swap.
• FP8 or Q4_K: **Recommended.** These formats reduce the memory requirement enough to keep the entire model structure within your **VRAM and fast RAM**, eliminating the need to constantly offload to the extremely slow disk swap. This will directly resolve the “long time” taken during the last step and prevent memory crashes.

Part 3: Download Recommendation Summary

For the specific hardware (32GB VRAM + 27GB RAM), the **Q5\_K\_M** level is the optimal choice for the 14B model, as it is the highest quality file likely to fit entirely within your fast memory, thus eliminating the severe slowdown caused by disk swapping.

Recommended GGUF File

Download the following two files for the I2V diffusion model:

• Wan2.2-I2V-A14B-HighNoise-Q5_K_M.gguf
• Wan2.2-I2V-A14B-LowNoise-Q5_K_M.gguf

Note: You must also download the separate VAE and Text Encoder files for the Wan 2.2 model and place them in their correct ComfyUI directories.

🚀 Workflow Structural Summary: GGUF Optimization Guide

The goal is to convert your memory-intensive workflow from **FP8 safetensors** to the highly efficient **GGUF Q5_K_M** format. This involves replacing the standard model loading nodes and removing incompatible components.

📄 Original vs. Optimized Structure

💾 Download Link and File Location

Download the required **High Noise** and **Low Noise** GGUF models from the repository below. Look under the “Files and versions” tab to find the specific Q5_K_M files.

🔴 Required Action Checklist

1. **INSTALL:** The ComfyUI-GGUF custom node via the ComfyUI Manager.
2. **DOWNLOAD & PLACE:** Get the two **Q5_K_M** GGUF files and put them in ComfyUI/models/unet.
3. **SWAP NODES:** In your workflow, replace the two existing Load Diffusion Model nodes with two new Unet Loader (GGUF) nodes, selecting the corresponding High and Low Noise files.
4. **BYPASS:** Remove or bypass any LoraLoader nodes.

Guide: Running GGUF Models (Wan 2.2) in ComfyUI

This guide explains how to install the custom nodes necessary to use highly efficient GGUF models (like the Wan 2.2 video models) and set up the required dual-model workflow.

1. Installation: ComfyUI-GGUF Custom Node

Step 1: Install via ComfyUI Manager

1. Click the Manager button in ComfyUI.
2. Select Install Custom Nodes.
3. Search for ComfyUI-GGUF (by city96).
4. Click Install, then Restart ComfyUI.

Step 2: Install Python Dependency (Crucial Fix)

The custom node often fails to load without its required Python library.

1. Close ComfyUI (browser and terminal).
2. Open your command line/terminal and navigate to your ComfyUI installation folder.
3. Execute the following command to install the gguf library:

   pip install --upgrade gguf

   (Use .\python_embeded\python.exe -s -m pip install --upgrade gguf if on a portable Windows install.)

4. Restart ComfyUI.

2. Workflow Setup: The Dual-Stage GGUF Flow

You will replace your standard Load Diffusion Model nodes with the GGUF components, using two separate models for the two-stage process (High Noise and Low Noise).

Step 1: Add the GGUF Loaders

• Delete/Bypass your old Load Diffusion Model nodes.
• Add Two instances of the node: Unet Loader (GGUF).
• Instance 1: Select the High Noise model (wan2.2_t2v_high_noise...).
• Instance 2: Select the Low Noise model (wan2.2_t2v_low_noise...).

Step 2: Add Model Sampling Nodes

The Wan 2.2 model requires the SD3-style sampling patch.

• Add Two instances of the node: ModelSamplingSD3.
• For both nodes, ensure the shift parameter is set to 5.0 (or your observed default).

Step 3: Connect the Final Flow to K-Samplers

The entire workflow uses two separate chains that lead to your two K-Sampler nodes.

This setup allows you to leverage the VRAM-saving benefits of the GGUF format for the Wan 2.2 model.

3. GGUF Conversion: Node Replacement Summary

The GGUF workflow is designed to replace the VRAM-heavy original model loading and sampling nodes while keeping the core logic of the Wan 2.2 dual-stage generation intact. The key changes are summarized below:

By following these steps, you successfully transition your powerful Wan 2.2 workflow to the VRAM-optimized GGUF format, making cinematic-quality video generation accessible on consumer-grade hardware.

Step 4: Adding the Free Memory (Latent) Node to the Workflow

Now that the node is installed, you need to correctly insert it between your two KSampler nodes. This step forces the VRAM clean-up to happen exactly when the Model from the first pass is no longer needed.

A. Disconnect the Latent Wire

First, remove the direct connection between your two KSampler nodes:

• **Disconnect** the wire from the **LATENT** output of your **KSampler (Pass 1)**.
• **Disconnect** the wire from the **latent_image** input of your **KSampler (Pass 2)**.

B. Insert and Connect the Node

Insert the **Free Memory (Latent)** node and use it as a bridge for the latent data.

1. Add the **Free Memory (Latent)** node to your canvas (Add Node → custom_nodes → ComfyUI-FreeMemory → Free Memory (Latent)).
2. Connect the **LATENT** output of the **KSampler (Pass 1)** to the **latent** input of the **Free Memory (Latent)** node.
3. Connect the **LATENT** output of the **Free Memory (Latent)** node to the **latent_image** input of the **KSampler (Pass 2)**.

C. Final Workflow Structure

Your finished multi-sampler chain will now look like this, ensuring optimal VRAM management:

Step 5: Reviewing the “Aggressive” Setting

The **Free Memory (Latent)** node includes an aggressive boolean input, which defaults to False. Understanding this setting is crucial for balancing performance and memory management.

Why the Free Memory Node is Essential for the Original Setup

You asked a critical question: Would the **ComfyUI-FreeMemory** node work on the original, default template? The answer is a definitive **Yes**, and in fact, its entire purpose is to be the **fix** for that exact scenario.

The Problem: VRAM Caching in the Default Chain

The standard ComfyUI architecture is designed for speed and automatically caches (keeps loaded) large models like the U-Net in VRAM after they run, assuming they will be needed again immediately. In the original, memory-inefficient setup:

• **Pass 1 (KSampler)** loads its Model. The workflow completes this step and holds the Model in VRAM.
• **Pass 2 (KSampler)** attempts to load its required components (or a second, large upscaling model).
• Since the VRAM from Pass 1 was never explicitly freed, the system runs out of space, resulting in the dreaded Out-of-Memory (OOM) error.

The Solution: Forcing a VRAM Checkpoint

The custom **ComfyUI-FreeMemory (Latent)** node acts as a mandatory checkpoint. By inserting it between KSampler 1 and KSampler 2, you are manually executing the critical cleanup command that ComfyUI’s default caching mechanism skips.

Therefore, inserting this node is not an optional optimization, but a **necessary functional step** to enable the two-KSampler latent upscale chain on systems that are VRAM-constrained.

Wan 2.2 T2V 14B File Information

📷 Screenshots

▶️ Screencast

Watch my real-time demo of Wan 2.2 T2V 14B on Linux:

Results:

Ready to Deepen Your Python Skills?

If this guide sparked your interest in the technical side of AI, you’re in luck! Python is the core language used in tools like ComfyUI and PyTorch.

• Check out my books, including **”Learning Python”** on Amazon: https://www.amazon.com/Learning-Python-Programming-eBook-Beginners-ebook/dp/B0D8BQ5X99
• Enroll in the companion online course, **”Learning Python”** to accelerate your knowledge: https://ojamboshop.com/product/learning-python
• **Need personalized guidance?** I am available for **one-on-one online Python tutorials**. Book your session here: https://ojambo.com/contact
• **Want expert setup?** If you need assistance with the complex setup process, I offer professional services to **install or migrate Wan 2.2 T2V 14B** or other AI models for you. Contact me for service inquiries: https://ojamboservices.com/contact