Z-Image

How to Install and Configure LTX-2 GGUF Models in ComfyUI: Complete 2026 Guide

Jan 10, 2026

How to Install and Configure LTX-2 GGUF Models in ComfyUI: Complete 2026 Guide

Running professional AI video generation on consumer hardware just became possible. LTX-2 GGUF models bring Lightricks' powerful audio-video generation capabilities to GPUs with as little as 8GB VRAM, democratizing access to synchronized video and audio creation that was previously limited to high-end workstations.

Released in early 2026, LTX-2 is a 19-billion parameter diffusion transformer that generates video and audio simultaneously. While the full-precision model demands 32GB+ VRAM, GGUF (GPT-Generated Unified Format) quantized versions enable generation on mainstream consumer GPUs like the RTX 4060, RTX 4070, and even older cards with limited memory.

19

This guide provides step-by-step instructions for installing and configuring LTX-2 GGUF models in ComfyUI, based on community-verified methods from Reddit user HerrDehy and extensive testing. You'll learn how to set up the environment, download the right models, configure workflows, and optimize performance for your specific hardware.

What you'll learn:

  • Understanding GGUF quantization and its benefits for LTX-2
  • Installing ComfyUI with required custom nodes
  • Downloading and organizing LTX-2 GGUF model files
  • Configuring text-to-video and image-to-video workflows
  • Optimizing generation settings for different VRAM levels
  • Troubleshooting common installation issues

What is GGUF and Why Does It Matter for LTX-2?

GGUF (GPT-Generated Unified Format) is a quantization format that reduces model precision from 16-bit or 32-bit floating point to lower bit depths (3-bit, 4-bit, 6-bit, or 8-bit). This compression dramatically reduces memory requirements while preserving most of the model's generation capabilities.

The VRAM Challenge

LTX-2's full-precision model presents significant hardware requirements:

  • LTX-2 19B (BF16): ~32GB VRAM minimum
  • LTX-2 19B (FP8): ~16GB VRAM
  • LTX-2 19B (NVFP4): ~10GB VRAM (NVIDIA RTX 40-series only)

These requirements put professional video generation out of reach for most users. Consumer GPUs typically offer:

  • RTX 4060: 8GB VRAM
  • RTX 4070: 12GB VRAM
  • RTX 4080: 16GB VRAM
  • RTX 3080: 10-12GB VRAM

The GGUF Solution

GGUF quantization bridges this gap through intelligent compression. By reducing numerical precision in less critical model layers while maintaining higher precision in important areas, GGUF models achieve dramatic memory savings with minimal quality loss.

Key Benefits:

  • Accessibility: Run LTX-2 on 8-16GB VRAM GPUs
  • Speed: Faster inference due to reduced data movement
  • Flexibility: Multiple quantization levels for different hardware
  • Quality: Minimal perceptible quality loss at Q4-Q6 levels

LTX-2 GGUF Quantization Levels Explained

LTX-2 GGUF models come in multiple quantization levels, each offering different trade-offs between quality, speed, and memory usage. Understanding these options helps you choose the right model for your hardware.

Available Quantization Formats

Quantization File Size VRAM Requirement Quality Loss Speed Best For
Q3_K_S ~8GB 9-10GB Moderate Fastest Extreme VRAM constraints
Q3_K_M ~9GB 10-11GB Moderate Very Fast Budget GPUs (8GB)
Q4_0 ~10GB 11-12GB Low Fast RTX 4060, RTX 3060 Ti
Q4_K_S ~11GB 12-13GB Low Fast RTX 4070 (Recommended)
Q4_K_M ~12GB 13-14GB Very Low Balanced RTX 4070, RTX 3080
Q5_0 ~13GB 14-15GB Minimal Balanced RTX 4080
Q5_K_M ~14GB 15-16GB Minimal Slightly Slower RTX 4080
Q6_K ~16GB 17-18GB Near-Zero Slower RTX 4090
Q8_0 ~20GB 21-22GB Virtually None Slowest RTX 4090, Professional Cards

Choosing the Right Quantization Level

For 8GB VRAM (RTX 4060, RTX 3060 Ti):

  • Start with Q4_0 or Q3_K_M
  • Generate at 512×512 or 640×384 resolution
  • Use 16-24 frames for short clips
  • Expect 2-4 minute generation times

For 12GB VRAM (RTX 4070, RTX 3080):

  • Q4_K_S or Q4_K_M offers the best balance
  • Generate at 768×512 or 640×480 resolution
  • Use 24-32 frames for 1-2 second clips
  • Expect 1-3 minute generation times

For 16GB+ VRAM (RTX 4080, RTX 4090):

  • Q5_K_M or Q6_K provides near-original quality
  • Generate at 1024×576 or higher resolutions
  • Use 32-48 frames for longer clips
  • Q8_0 available for maximum fidelity on RTX 4090

Quality vs. Performance Trade-offs:

  • Q3 quantization: Noticeable quality reduction, suitable for testing
  • Q4 quantization: Sweet spot for most users, minimal quality loss
  • Q5-Q6 quantization: Near-original quality, higher VRAM needed
  • Q8 quantization: Virtually identical to full precision

System Requirements

Before installing LTX-2 GGUF models, ensure your system meets these specifications.

Minimum Hardware Requirements

GPU: NVIDIA GPU with 8GB+ VRAM

  • RTX 4060 (8GB) - minimum for Q3/Q4 models
  • RTX 3060 Ti (8GB) - minimum for Q3/Q4 models
  • AMD GPUs not currently supported

RAM: 16GB system memory minimum

  • 32GB recommended for smoother operation
  • Models load into system RAM before GPU transfer

Storage: 50GB+ free disk space

  • GGUF models: 8-20GB depending on quantization
  • VAE and text encoders: ~10GB
  • ComfyUI and dependencies: ~5GB
  • Working space for outputs: ~10GB

Operating System:

  • Windows 10/11 (64-bit) - recommended
  • Linux (Ubuntu 20.04+ or equivalent)
  • macOS (limited support, CPU-only, very slow)

Software Prerequisites

Python: Version 3.10 or higher

  • Python 3.11 or 3.12 recommended
  • Virtual environment strongly recommended

CUDA: Version 11.8 or higher

  • CUDA 12.1+ recommended for best performance
  • Download from NVIDIA website

Git: For cloning repositories

  • Windows: Git for Windows
  • Linux/Mac: Pre-installed or via package manager

For the best experience with LTX-2 GGUF models:

  • GPU: RTX 4070 or better (12GB+ VRAM)
  • RAM: 32GB DDR4/DDR5
  • Storage: NVMe SSD with 100GB+ free space
  • CPU: Modern multi-core processor (6+ cores)

Step-by-Step Installation Guide

This section provides detailed instructions for installing LTX-2 GGUF models in ComfyUI, based on the community-verified method from Reddit user HerrDehy.

Step 1: Install or Update ComfyUI

If you don't have ComfyUI installed, follow these steps. If you already have ComfyUI, skip to updating.

Fresh Installation (Windows):

  1. Clone the ComfyUI repository:
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
  1. Create a Python virtual environment:
python -m venv venv
venv\Scripts\activate
  1. Install dependencies:
pip install -r requirements.txt
  1. Install PyTorch with CUDA support:
pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu121
  1. Launch ComfyUI to verify installation:
python main.py

Open your browser to http://localhost:8188 to confirm ComfyUI is running.

Fresh Installation (Linux):

git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu121
python main.py

Updating Existing ComfyUI:

If you already have ComfyUI installed, update to the latest version:

cd ComfyUI
git pull origin master
pip install -r requirements.txt --upgrade

Important: Ensure you're running the latest ComfyUI version for GGUF compatibility.

Step 2: Install Required Custom Nodes

LTX-2 GGUF requires two essential custom node packages: ComfyUI-GGUF and ComfyUI-KJNodes.

Method A: Install via ComfyUI Manager (Recommended)

  1. Launch ComfyUI:
python main.py

  1. Open ComfyUI Manager:

    • Access ComfyUI at http://localhost:8188
    • Click the "Manager" button in the interface
    • Select "Install Custom Nodes"

  2. Install ComfyUI-GGUF:

    • Search for "ComfyUI-GGUF"
    • Click "Install" next to the result
    • Wait for installation to complete

  3. Install ComfyUI-KJNodes:

    • Search for "ComfyUI-KJNodes"
    • Click "Install"
    • Wait for installation to complete

  4. Close ComfyUI (important for next step)

Method B: Manual Installation

If ComfyUI Manager isn't available:

cd ComfyUI/custom_nodes

# Install ComfyUI-GGUF
git clone https://github.com/city96/ComfyUI-GGUF.git
cd ComfyUI-GGUF
pip install -r requirements.txt
cd ..

# Install ComfyUI-KJNodes
git clone https://github.com/kijai/ComfyUI-KJNodes.git
cd ComfyUI-KJNodes
pip install -r requirements.txt
cd ../..

Step 3: Update ComfyUI-GGUF with Critical Patch

CRITICAL STEP: The official ComfyUI-GGUF release doesn't yet support LTX-2 GGUF models. You must manually update two files with a non-merged commit.

This step is based on HerrDehy's Reddit guide and is essential for LTX-2 GGUF to work.

1. Backup existing files (optional but recommended):

cd ComfyUI/custom_nodes/ComfyUI-GGUF
copy loader.py loader.py.backup
copy nodes.py nodes.py.backup

2. Download the updated files:

Visit these URLs and download the files:

3. Replace the existing files:

  • Copy the downloaded loader.py to ComfyUI/custom_nodes/ComfyUI-GGUF/loader.py
  • Copy the downloaded nodes.py to ComfyUI/custom_nodes/ComfyUI-GGUF/nodes.py
  • Overwrite when prompted

Why this step is necessary: The specific commit (f083506) includes support for LTX-2's architecture that hasn't been merged into the main branch yet. Without this update, ComfyUI won't recognize LTX-2 GGUF models.

Note: This is a temporary workaround. Once the changes are merged into the official release, this manual update won't be necessary.

Step 4: Download LTX-2 GGUF Model Files

Now you'll download the required model files from Kijai's Hugging Face repository. This repository hosts community-optimized LTX-2 models specifically prepared for ComfyUI.

Model Repository: https://huggingface.co/Kijai/LTXV2_comfy/tree/main

Required Files:

1. VAE Models (Video and Audio Encoders)

Download both VAE files and place them in ComfyUI/models/vae/:

  • LTX2_audio_vae_bf16.safetensors (~1.5GB)
  • LTX2_video_vae_bf16.safetensors (~1.2GB)

2. Text Encoder (Embeddings Connector)

Download and place in ComfyUI/models/text_encoders/:

  • ltx-2-19b-embeddings_connector_bf16.safetensors (~2.8GB)

3. GGUF Diffusion Model (Choose One)

Download ONE quantization level from ComfyUI/models/diffusion_models/:

For 8GB VRAM:

  • ltx2-19b-Q3_K_M.gguf (~9GB)
  • ltx2-19b-Q4_0.gguf (~10GB)

For 12GB VRAM (Recommended):

  • ltx2-19b-Q4_K_S.gguf (~11GB)
  • ltx2-19b-Q4_K_M.gguf (~12GB)

For 16GB+ VRAM:

  • ltx2-19b-Q5_K_M.gguf (~14GB)
  • ltx2-19b-Q6_K.gguf (~16GB)

Optional but Recommended Files:

4. Spatial Upscaler (for higher resolution outputs)

Download from official LTX-2 repository and place in ComfyUI/models/latent_upscale_models/:

5. Distilled LoRA (for faster generation)

Download and place in ComfyUI/models/loras/:

6. Gemma FP8 Text Encoder (alternative, lower VRAM)

Download and place in ComfyUI/models/text_encoders/:

Step 5: Organize Your Model Files

After downloading, verify your directory structure matches this layout:

ComfyUI/
├── models/
│   ├── vae/
│   │   ├── LTX2_audio_vae_bf16.safetensors
│   │   └── LTX2_video_vae_bf16.safetensors
│   ├── text_encoders/
│   │   ├── ltx-2-19b-embeddings_connector_bf16.safetensors
│   │   └── gemma_3_12B_it_fp8_e4m3fn.safetensors (optional)
│   ├── diffusion_models/
│   │   └── ltx2-19b-Q4_K_M.gguf (or your chosen quantization)
│   ├── latent_upscale_models/
│   │   └── ltx-2-spatial-upscaler-x2-1.0.safetensors (optional)
│   └── loras/
│       └── ltx-2-19b-distilled-lora-384.safetensors (optional)

Important Notes:

  • File names are case-sensitive
  • Ensure files are in the correct directories
  • Don't create extra subdirectories within these folders
  • The GGUF model must be in diffusion_models/, not checkpoints/

Step 6: Download and Load Workflows

HerrDehy has created pre-configured workflows that work with LTX-2 GGUF models. These workflows are essential for proper operation.

Download Workflows:

Text-to-Video Workflow:

Image-to-Video Workflow:

Loading Workflows in ComfyUI:

  1. Launch ComfyUI:
cd ComfyUI
python main.py

  1. Access the interface at http://localhost:8188

  2. Load the workflow:

    • Drag and drop the downloaded JSON file onto the ComfyUI canvas
    • Or click "Load" → "Load Workflow" and select the JSON file

  3. Verify node connections:

    • All nodes should appear without red error indicators
    • Check that model paths are correctly detected
    • Look for the "Text to Video" or "Image to Video" node

  4. Select your models:

    • In the GGUF loader node, select your downloaded GGUF model
    • In the VAE loader nodes, select the audio and video VAE files
    • In the text encoder node, select the embeddings connector

If you see missing nodes errors:

  • Ensure ComfyUI-GGUF and ComfyUI-KJNodes are installed
  • Verify you updated the GGUF node files (Step 3)
  • Restart ComfyUI completely
  • Check the console for specific error messages

Configuration and Optimization

Once your workflow is loaded, you'll need to configure generation parameters based on your hardware and quality requirements.

Understanding Key Parameters

Resolution Settings:

  • Must be divisible by 32
  • Common options for LTX-2 GGUF:
    • 512×512: Fast testing, low VRAM
    • 640×384: Widescreen, balanced
    • 768×512: HD quality, moderate VRAM
    • 1024×576: Full HD, high VRAM

Frame Count:

  • Must be divisible by 8, plus 1 (e.g., 9, 17, 25, 33)
  • More frames = longer videos but exponentially more VRAM
  • Recommended starting point: 17 or 25 frames

Sampling Steps:

  • Range: 20-50 steps
  • More steps = better quality but slower generation
  • Recommended: 25-30 steps for Q4 models

CFG Scale (Classifier-Free Guidance):

  • Range: 1.0-15.0
  • Lower values (3-5): More creative, less prompt adherence
  • Higher values (7-10): Stricter prompt following
  • Recommended: 5.0-7.0

Optimization for Different VRAM Levels

8GB VRAM Configuration:

Resolution: 512×512 or 640×384
Frames: 17 (about 0.7 seconds at 24fps)
Steps: 25
CFG Scale: 5.0
Quantization: Q3_K_M or Q4_0
Expected Generation Time: 3-5 minutes

12GB VRAM Configuration (Recommended):

Resolution: 768×512
Frames: 25 (about 1 second at 24fps)
Steps: 30
CFG Scale: 6.0
Quantization: Q4_K_M
Expected Generation Time: 2-3 minutes

16GB+ VRAM Configuration:

Resolution: 1024×576
Frames: 33 (about 1.4 seconds at 24fps)
Steps: 35
CFG Scale: 7.0
Quantization: Q5_K_M or Q6_K
Expected Generation Time: 3-4 minutes

Memory Management Tips

Reduce VRAM Usage:

  1. Lower resolution (biggest impact)
  2. Reduce frame count
  3. Use lower quantization (Q3 instead of Q4)
  4. Close other GPU-intensive applications
  5. Enable tiled VAE decoding if available

Improve Generation Speed:

  1. Use distilled LoRA (8-step generation)
  2. Reduce sampling steps to 20-25
  3. Lower CFG scale to 4-5
  4. Use Q4 instead of Q5/Q6 quantization

Your First Generation Test

Now that everything is configured, let's create your first video with LTX-2 GGUF.

Start with a simple, clear prompt to verify your setup works correctly:

A golden retriever puppy playing with a red ball in a sunny garden, wagging its tail happily. Soft ambient sounds of birds chirping. Camera slowly pans from left to right.

This prompt works well because:

  • Simple subject (puppy) that LTX-2 handles well
  • Clear action (playing with ball)
  • Defined setting (sunny garden)
  • Audio description (birds chirping)
  • Camera movement specified (pan left to right)

Generation Process

  1. Enter your prompt in the text input node
  2. Set parameters based on your VRAM:
    • 8GB: 512×512, 17 frames, 25 steps
    • 12GB: 768×512, 25 frames, 30 steps
    • 16GB+: 1024×576, 33 frames, 35 steps
  3. Click "Queue Prompt" in the top right
  4. Monitor progress in the console window
  5. Wait for completion (2-5 minutes depending on hardware)

Evaluating Output Quality

When your first video generates, check these aspects:

Visual Quality:

  • Smooth motion without jittering
  • Consistent subject appearance
  • Proper lighting and shadows
  • No obvious artifacts or distortions

Audio Quality:

  • Synchronized with video action
  • Clear and appropriate sounds
  • No crackling or distortion

Prompt Adherence:

  • Subject matches description
  • Actions are correct
  • Setting is accurate
  • Camera movement follows instructions

If quality is poor, try:

  • Increasing quantization level (Q3 → Q4 → Q5)
  • Adding more sampling steps
  • Adjusting CFG scale
  • Refining your prompt with more details

Troubleshooting Common Issues

Here are solutions to the most common problems when installing and running LTX-2 GGUF models.

CUDA Out of Memory Errors

Symptoms: "RuntimeError: CUDA out of memory" during generation

Solutions:

  1. Lower resolution: Try 512×512 instead of 768×512
  2. Reduce frames: Use 17 frames instead of 25
  3. Use lower quantization: Switch from Q4 to Q3
  4. Close other applications: Free up GPU memory
  5. Restart ComfyUI: Clear cached models
  6. Check VRAM usage: Use nvidia-smi to monitor

Missing Nodes or Red Error Indicators

Symptoms: Workflow shows red nodes or "Node not found" errors

Solutions:

  1. Verify custom nodes installed:
    • Check ComfyUI/custom_nodes/ComfyUI-GGUF exists
    • Check ComfyUI/custom_nodes/ComfyUI-KJNodes exists
  2. Confirm GGUF node update: Verify you replaced loader.py and nodes.py
  3. Restart ComfyUI completely: Close terminal and relaunch
  4. Check Python version: Must be 3.10+
  5. Reinstall dependencies:
cd ComfyUI/custom_nodes/ComfyUI-GGUF
pip install -r requirements.txt --upgrade

Model Not Found or Loading Errors

Symptoms: "Model not found" or "Failed to load model" errors

Solutions:

  1. Verify file paths:
    • GGUF models must be in models/diffusion_models/
    • VAE files must be in models/vae/
    • Text encoders must be in models/text_encoders/
  2. Check file names: Ensure exact spelling and case
  3. Verify file integrity: Re-download if files are corrupted
  4. Check disk space: Ensure sufficient free space
  5. Try absolute paths: In node settings, use full file paths

Slow Generation Times

Symptoms: Generation takes 10+ minutes for short clips

Solutions:

  1. Verify GPU usage: Check nvidia-smi shows GPU activity
  2. Update NVIDIA drivers: Install latest drivers
  3. Use lower quantization: Q4 is faster than Q5/Q6
  4. Reduce steps: Try 20-25 steps instead of 35-50
  5. Check CPU bottleneck: Ensure GPU is being utilized
  6. Enable performance mode: In NVIDIA Control Panel

Poor Video Quality or Artifacts

Symptoms: Blurry output, visual artifacts, or inconsistent motion

Solutions:

  1. Increase quantization: Try Q5 instead of Q4
  2. Add more steps: Use 35-40 steps
  3. Adjust CFG scale: Test range 5.0-8.0
  4. Improve prompt: Be more specific and detailed
  5. Check model files: Verify downloads completed successfully
  6. Try different seed: Change random seed value

Performance Benchmarks

Understanding real-world performance helps you set realistic expectations and choose the right quantization level for your hardware.

Generation Time Comparison

Based on community testing with various GPUs and quantization levels:

GPU Model VRAM Quantization Resolution Frames Steps Time
RTX 4060 8GB Q3_K_M 512×512 17 25 4-5 min
RTX 4060 8GB Q4_0 512×512 17 25 3-4 min
RTX 4070 12GB Q4_K_M 768×512 25 30 2-3 min
RTX 4070 12GB Q5_K_M 768×512 25 30 3-4 min
RTX 4080 16GB Q5_K_M 1024×576 33 35 3-4 min
RTX 4090 24GB Q6_K 1024×576 33 35 2-3 min

Key Insights:

  • Q4 quantization offers the best speed/quality balance
  • Higher resolutions increase generation time exponentially
  • More frames have greater impact than more steps
  • GPU memory bandwidth matters more than raw compute

Quality vs. Speed Trade-offs

Q3 Quantization:

  • Pros: Fastest generation, lowest VRAM
  • Cons: Noticeable quality reduction, occasional artifacts
  • Best for: Rapid prototyping, testing prompts

Q4 Quantization (Recommended):

  • Pros: Excellent quality, good speed, moderate VRAM
  • Cons: Slight quality loss vs. higher quantizations
  • Best for: Most users, production work on consumer GPUs

Q5-Q6 Quantization:

  • Pros: Near-original quality, minimal artifacts
  • Cons: Slower generation, higher VRAM requirements
  • Best for: Final outputs, professional work

Try LTX-2 Online Without Installation

If you want to test LTX-2 before committing to a local setup, or need quick access without hardware constraints, you can try it online at Z-Image.

Z-Image provides a streamlined interface for LTX-2 and other state-of-the-art AI video models, with no installation required. This is particularly useful for:

Testing Prompts: Experiment with different prompts before running local generations
Quick Iterations: Generate videos when away from your workstation
Comparing Models: Test LTX-2 against other video generation models
Learning: Understand prompt engineering without setup overhead
Hardware Evaluation: Determine if local installation is worth the investment

The platform handles all technical complexity, letting you focus on creativity and prompt refinement. Once you're comfortable with LTX-2's capabilities, you can follow this guide to set up your local installation.

Conclusion

LTX-2 GGUF models represent a significant breakthrough in making professional AI video generation accessible on consumer hardware. By following this guide, you've learned how to:

  • Install ComfyUI with the required custom nodes for LTX-2 GGUF support
  • Download and organize model files from community repositories
  • Apply the critical GGUF node patch for LTX-2 compatibility
  • Configure workflows for text-to-video and image-to-video generation
  • Optimize settings for different VRAM levels
  • Troubleshoot common installation and generation issues

Key Takeaways

Start with Q4 Quantization: For most users with 8-16GB VRAM, Q4_K_M offers the best balance of quality, speed, and memory usage.

Follow the Manual Update Step: The critical step of manually updating ComfyUI-GGUF node files (Step 3) is essential. Without this, LTX-2 GGUF models won't load correctly.

Optimize for Your Hardware: Use the configuration recommendations based on your VRAM to avoid out-of-memory errors and achieve reasonable generation times.

Community Resources Matter: This guide is based on HerrDehy's Reddit post and community testing. The AI video generation community actively shares workflows, optimizations, and solutions.

Next Steps

Now that you have LTX-2 GGUF running:

  1. Experiment with Prompts: Test different subjects, settings, and camera movements
  2. Try Image-to-Video: Use the I2V workflow to animate still images
  3. Explore Quantization Levels: If you have VRAM headroom, try Q5 or Q6 for better quality
  4. Join the Community: Share your results and learn from others on Reddit and Discord
  5. Stay Updated: Watch for official GGUF node updates that will simplify installation

Community Resources

Original Reddit Guide: Using GGUF models for LTX2 in T2V by HerrDehy

Model Repository: Kijai's LTX-2 ComfyUI Models

Workflows: HerrDehy's SharePublic Repository

ComfyUI-GGUF: city96's GGUF Node Repository

Official LTX-2: Lightricks LTX-2 Repository

The future of AI video generation is increasingly accessible, and LTX-2 GGUF is at the forefront of this democratization. With consumer-grade hardware and community-driven optimizations, professional video creation capabilities are now within reach for creators, developers, and enthusiasts worldwide.

Last updated: January 10, 2026

This guide is based on community-verified methods and will be updated as official support for LTX-2 GGUF improves.

Sources

Z-Image Team

How to Install and Configure LTX-2 GGUF Models in ComfyUI: Complete 2026 Guide | Blog