LongCat FP8 ComfyUI Workflow: 12GB VRAM Long Video Guide

Introduction to LongCat FP8 Workflow

The LongCat Video model represents a breakthrough in efficient AI video generation, but the original BF16 version demands premium hardware. The FP8 quantized variant changes everything—delivering the same cinematic quality while cutting VRAM requirements in half. This complete workflow guide teaches you how to leverage quantization techniques, intelligent block swapping, and distilled LoRA models to generate unlimited-duration videos on modest consumer GPUs.

Unlike earlier long-video models that sacrifice quality for memory efficiency, LongCat FP8 maintains temporal consistency over entire minutes of footage while tracking objects, maintaining character identity, and preserving camera movements. The key innovation is using lower-precision floating-point numbers (8-bit) without perceptible quality loss, combined with strategic memory management.

Why FP8 Changes the Game

What is FP8 Quantization?

FP8 reduces model precision from 16-bit (BF16) to 8-bit floating-point numbers:

• BF16 Model Size: ~27GB
• FP8 Model Size: ~13.5GB
• VRAM Overhead: Roughly 40-50% less during generation
• Quality Loss: Negligible on practical videos

Most users see zero perceptible difference in output quality while gaining massive memory headroom.

Hardware Compatibility

The FP8 version unlocks 12GB GPUs entirely, making professional AI video creation affordable for more creators.

Advantages Over BF16

Memory Efficiency

• FP8: 12-16GB VRAM sufficient
• BF16: 20GB+ required for comfortable operation
• Difference: ~40% less VRAM demand

Speed Optimization

• FP8 operations execute faster on modern hardware
• 8-bit calculations = fewer clock cycles
• Typical speedup: 5-15% depending on GPU

Accessibility

• More creators can participate
• Lower barrier to entry
• Community-driven model improvements

Cost Reduction

• No need for RTX 4090 ($1,600+)
• RTX 3060/4070 ($300-500) is sufficient
• Or use cloud GPUs at fraction of cost

System Requirements for FP8

Minimum Configuration

• GPU: NVIDIA RTX 3060 (12GB VRAM)
• System RAM: 16GB DDR4
• Storage: 20GB SSD (model + cache)
• OS: Windows 10/11, Linux, macOS
• CUDA Compute: 8.6+ (for optimal 8-bit performance)

Recommended Setup

• GPU: NVIDIA RTX 4070 Ti or RTX 4080 (16GB+)
• System RAM: 32GB DDR5
• Storage: NVMe SSD with 50GB+ free space
• Internet: 500Mbps+ (for model downloads)
• Cooling: Active GPU cooling recommended

Cloud GPU Alternative

If you lack local hardware:

• RunPod: RTX 4090 with 24GB for ~$0.44/hour
• Lambda Labs: A100 GPU from ~$1.10/hour
• Vast.ai: Competitive bidding, sometimes under $0.30/hour

Installation Guide

Step 1: Update ComfyUI and Dependencies

Ensure your ComfyUI installation is current:

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

Check Python version (3.10+ recommended):

python --version

Step 2: Install WAN Video Wrapper (Latest)

The LongCat support is in the main WAN Video Wrapper branch:

cd ComfyUI/custom_nodes
git clone https://github.com/kijai/ComfyUI-WanVideoWrapper.git
cd ComfyUI-WanVideoWrapper
pip install -r requirements.txt

If you already have the repo cloned:

cd ComfyUI/custom_nodes/ComfyUI-WanVideoWrapper
git pull origin main
pip install -r requirements.txt

Step 3: Download FP8 Model

Download the quantized model from Hugging Face:

Model File: LongCat-Video_fp8.safetensors Source: https://huggingface.co/Kijai/LongCat-Video_comfy/tree/main Destination: ComfyUI/models/diffusion_models/ Size: ~13.5GB

Command-line download (using huggingface_hub):

pip install huggingface_hub
huggingface-cli download Kijai/LongCat-Video_comfy --include "LongCat-Video_fp8.safetensors" --local-dir ./models/diffusion_models/

Step 4: Install Distill LoRA (Optional but Recommended)

The Distill LoRA cuts sampling steps from 12-16 down to 8-10:

Model File: LongCat-Video_distill_lora.safetensors Destination: ComfyUI/models/loras/ Speedup: ~30% faster generation

Step 5: Download VAE and Text Encoder

If not already installed:

Text Encoder (required):

• File: t5xxl-clip-bf16.safetensors
• Source: https://huggingface.co/Kijai/LongCat-Video_comfy
• Destination: ComfyUI/models/text_encoders/

VAE (required):

• File: wan-2.1-vae.safetensors
• Destination: ComfyUI/models/vae/

Step 6: Verify Installation

Launch ComfyUI and confirm:

1. No red errors on startup
2. LongCat Video nodes appear in node menu
3. FP8 model loads without warnings

FP8 Workflow Configuration

Model Loader Settings

Loading the FP8 Model:

1. In Model Loader node, select LongCat-Video_fp8.safetensors
2. Set Precision: 8-bit (FP8)
3. Don't force BF16 casting—defeats the purpose

Block Swap Configuration (Critical for VRAM):

Block swap = 40 is the default for 12GB systems. This moves inactive model blocks to system RAM, reducing GPU memory pressure.

Attention Mode:

• Try sdpa first (built-in, no setup)
• If installed: Use sage_attention (faster)
• Don't use flash_attention with FP8 (incompatible)

Torch Compile:

• Requires: Visual Studio C++ build tools
• Benefit: ~15-20% speedup when working
• Skip if causes issues

Video Generation Settings

Resolution (Recommended):

• 480p: 832x480 (faster, good for testing)
• 720p: 1280x720 (production quality)
• 1080p: 1920x1080 (slow, requires 16GB+ VRAM)

Frames Per Window:

• 81 frames = ~5 seconds at 16 FPS (default)
• 61 frames = ~3.8 seconds (for ultra-low VRAM)
• 93 frames = ~5.8 seconds (if VRAM allows)

Sampling Steps (With Distill LoRA):

• 8-10 steps (recommended)
• 12-14 steps (higher quality if VRAM allows)
• Never below 8 (quality degrades noticeably)

Shift Parameter:

• 8-10: Subtle camera motion
• 12: Dynamic cinematic movement
• 15+: Extreme motion (can cause jitter)

CFG Scale:

• 7.5: Standard for most content
• 5-6: More creative, less prompt-adherent
• 10-12: Strict adherence to prompt (slower)

Workflow Structure for FP8

Single Sampling Group (for short videos):

Image Input → VAE Encode → Model Loader (FP8) → Sampler → Decode → Output
         ↓                                         ↓
    Clip Text Encoder                      Latent (to next group)

Chained Sampling Groups (for long videos):

Group 1: Image Latent + Audio Segment 1 → 5s Video
Group 2: Video Latent (from Group 1) + Audio Segment 2 → 5s Video
Group 3: Video Latent (from Group 2) + Audio Segment 3 → 5s Video

The key: Use pink latent connections between groups to maintain consistency.

Distill LoRA: Acceleration Secret

How Distill LoRA Works

Distill LoRA is a lightweight adapter (50MB) that "teaches" FP8 to generate quality results with fewer steps:

Without LoRA:

• Steps needed: 12-16
• Time per 5s segment: ~3-4 minutes

With Distill LoRA:

• Steps needed: 8-10
• Time per 5s segment: ~2-2.5 minutes
• Quality: Comparable to 12-step non-LoRA

Stacking Multiple LoRAs

You can combine Distill LoRA with refinement LoRAs:

Load LoRA (Distill) - Slot 1 → Strength: 1.0
Load LoRA (Refinement) - Slot 2 → Strength: 0.5

This combines acceleration (Distill) with quality enhancement (Refinement).

Prompt Engineering for FP8

Text Prompt Structure

Element Breakdown:

1. Subject: "A young woman in business attire"
2. Setting: "Standing in a modern glass office"
3. Action: "Speaking with hand gestures"
4. Camera: "Camera slowly zooms in from wide to close-up"
5. Lighting: "Soft window light from left side"

Complete Prompt Example:

A young woman in professional business attire stands in a modern
glass-walled office overlooking a city. She speaks confidently with
natural hand gestures, her expression engaged. The camera slowly
zooms in from a wide shot to a close-up. Soft morning light streams
through the window on her left, creating subtle shadows. Professional,
contemporary aesthetic.

FP8-Specific Prompt Tips

Work Well:

• Clear subjects (single person/object)
• Specific settings (office, park, room)
• Simple actions (walking, talking, gesturing)
• Distinct lighting (window light, studio lights)

Avoid:

• Multiple complex scenes in one prompt
• Vague descriptions ("a scene", "something happening")
• Conflicting instructions ("zoom in and zoom out")
• Extreme physics ("floating upside down forever")

Camera Movement Prompts

Push In:

Camera slowly pushes in from medium shot to extreme close-up...

Reveal Movement:

Camera pulls back, revealing the full environment...

Tracking Shot:

Camera tracks with subject as they walk...

Pan:

Camera pans slowly from left to right...

Static:

Fixed camera position, no movement...

Generation Workflow Step-by-Step

Preparing Your Image

Image Requirements:

• Minimum 512x512 pixels
• Clear, well-lit subject
• Minimal background distractions
• Front-facing or 3/4 angle
• Neutral to slightly engaging expression

Image Processing:

1. Load image into workflow
2. Resize to 832x480 (or your chosen resolution)
3. Encode through VAE (compress to latent space)
4. Connect to first sampling group as reference latent

Setting Up Audio (Optional)

Option 1: Generate with Text-to-Speech

Text Input → TTS Node → Audio Output → Feed to workflow

Option 2: Load Existing Audio

Load .wav or .mp3 → Optional: Vocal separator → Feed to workflow

Audio Frame Calculation:

• Audio processes at 32 FPS internally
• Video outputs at 16 FPS
• 10-second audio = 320 audio frames = 160 video frames

Running 5-Second Generation

Step 1: Load image and configure resolution (832x480) Step 2: Enter text prompt Step 3: Set frames per window to 81 Step 4: Verify block swap is set to 40 (for 12GB VRAM) Step 5: Set sampling steps to 8-10 (with Distill LoRA) Step 6: Queue generation

Typical Time (RTX 3060, FP8):

• First 5-second segment: ~3-4 minutes
• Each additional segment: ~2-3 minutes

Extending to Longer Videos

For 15-Second Video (3 segments):

Segment 1:
- Reference latent: From image
- Prompt: "Young woman walks down street"
- Output: 5 seconds

Segment 2:
- Reference latent: From Segment 1 output
- Prompt: "Woman continues walking, turns corner"
- Output: 5 seconds (5-10)

Segment 3:
- Reference latent: From Segment 2 output
- Prompt: "Woman stops at storefront, looks at display"
- Output: 5 seconds (10-15)

Final: Concatenate all 3 segments → 15-second video

Block Swap Deep Dive

What is Block Swap?

The Diffusion model contains multiple "blocks" (attention, feed-forward, etc.). Block swap moves inactive blocks from VRAM to system RAM:

• When activated: Block 5 moves to RAM while Block 1 runs on GPU
• When needed: Block 5 loads back to GPU, Block 1 moves to RAM
• Overhead: Minor (0.2-0.5 seconds per swap)

Recommended Settings

12GB VRAM (RTX 3060):

Block Swap = 40
GPU VRAM Usage: ~10.5GB (leaving 1.5GB buffer)
Swaps per 81-frame generation: ~180
Total overhead: ~30 seconds per 5-second clip

16GB VRAM (RTX 4070):

Block Swap = 20
GPU VRAM Usage: ~14GB
Swaps per generation: ~90
Total overhead: ~15 seconds per 5-second clip

24GB+ VRAM (RTX 4090):

Block Swap = 0
Full model in VRAM
Zero swapping overhead

Troubleshooting FP8

Problem: CUDA Out of Memory Error

Solution 1 - Increase Block Swap:

Current: block_swap = 30
Try: block_swap = 50

Solution 2 - Reduce Frames:

Current: frames_per_window = 81
Try: frames_per_window = 61

Solution 3 - Lower Resolution:

Current: 832x480
Try: 640x360

Solution 4 - Reduce Steps:

Current: 10 steps
Try: 8 steps (still acceptable quality)

Problem: Output Quality Degrading Mid-Video

Cause: Accumulated latent corruption across segments

Solutions:

• Increase sampling steps to 10-12
• Add color matching between segments
• Keep prompts consistent across groups
• Reduce video duration (test with 15 seconds)

Problem: Faces Changing Between Segments

Cause: Latent drift without reference

Solutions:

• Ensure previous-latent connections are properly pink-colored
• Keep character description identical in prompts
• Increase overlap frames to 15-20
• Test with shorter duration first (10 seconds)

Problem: Video Looks Too Different from Original Image

Cause: Reference latent not properly scaled

Solutions:

• Verify reference image is encoded correctly
• Use slightly more detailed prompt about character appearance
• Lower shift parameter (from 12 to 8)
• Verify image was loaded and processed

Problem: Generation Hangs or Very Slow

Cause 1 - Block Swap Too High:

Reduce from 50 to 35
(More swaps = more slowdown)

Cause 2 - Torch Compile Incompatibility:

Disable torch_compile if enabled
Can cause 2-3x slowdown if misconfigured

Cause 3 - Insufficient System RAM:

Close other applications
Ensure 16GB+ free system memory

Real-World Example: 30-Second Product Demo Video

Scenario: Create an AI video showing a product unboxing and review.

Setup:

• Image: Product photo on clean background (512x512)
• Duration: 30 seconds total
• Segments Needed: 6 × 5-second groups
• Resolution: 832x480
• GPU: RTX 3060 (12GB FP8)

Segment Prompts:

Segment 1: Close-up of sealed product box with minimalist white background, gentle light reflection on packaging

Segment 2: Camera pulls back, hands appear opening the product box, revealing contents, soft overhead lighting

Segment 3: Product is lifted from box, hands rotate it slowly showing all sides, white studio lighting, product appears pristine

Segment 4: Product is placed on white surface, camera zooms in on key features, soft shadows emphasizing design details

Segment 5: Product is held at arm's length, natural hand movements showing scale, professional product demonstration style

Segment 6: Final product shot stationary on white surface, lights create subtle highlights, minimalist product photography aesthetic

Configuration:

• Block swap: 40
• Steps: 8 (with Distill LoRA)
• Shift: 10 (moderate camera motion)
• CFG: 7.5

Timeline:

• Segment 1 generation: 4 minutes
• Segments 2-6: 2.5 minutes each
• Total generation time: ~19.5 minutes
• Final video: Seamless 30-second product demo

Post-Processing:

• Add background music at -20dB
• Apply subtle color correction
• Export at 16 FPS (matches generation)

Comparison: FP8 vs BF16 vs Original Model

Advanced Optimization Techniques

Memory Profiling

Monitor actual VRAM usage:

# In ComfyUI, enable verbose logging
python main.py --verbose

Watch the logs during generation to see peak VRAM at each sampling step.

Batch Processing Multiple Videos

Chain multiple generations:

1. Generate Segment A
2. Export Segment A
3. Load new reference image
4. Generate Segment B
5. Concatenate in post

Hybrid Approach: High-Quality Final Segments

Generate core content in FP8, then upscale final segments with higher precision:

1. Generate 90% of video in FP8 (fast, efficient)
2. Re-generate final 10% in BF16 for absolute quality
3. Blend carefully at seams

Conclusion

The LongCat FP8 workflow democratizes professional AI video generation. By leveraging quantization, intelligent memory management, and distilled models, you can create unlimited-duration videos on a $350 GPU instead of requiring a $1,600 RTX 4090.

The workflow is straightforward: load FP8 model, set block swap to 40 for 12GB systems, use Distill LoRA for speed, chain sampling groups for duration. The results match original-precision models while consuming half the VRAM.

Start small—generate a few 5-second test clips to understand the workflow. Then scale up gradually to minute-long videos as you master prompt engineering and latent management. The FP8 revolution makes AI video accessible to everyone.

Related Resources

1. LongCat Video Complete Guide - Master all aspects of LongCat video generation
2. ComfyUI LongCat Workflow for Low VRAM - Additional memory optimization techniques for budget GPUs
3. LongCat Video Extra Long Generation - Create extended videos with efficient memory management