Skip to content

Wan2.2 14B Text-to-Video: Dual-Expert Model Produces Blockbuster Footage ​

The 5B from the previous lesson solved "being able to run it," while the 14B in this lesson solves "running it well." Wan2.2-T2V-A14B is Alibaba Tongyi Wanxiang's text-to-video model: an MoE dual-expert architecture supporting 480P and 720P videos of 5 seconds, commercially usable under the Apache 2.0 license. Officially, it outperforms leading commercial models on most key dimensions on their own Wan-Bench 2.0.

This page walks through the complete 14B workflow for Wan2.2 text-to-video: downloading the four-part dual-expert set, generating output in 20 steps, enabling Turbo mode for 4-step acceleration, and changing resolution and duration yourself. The VRAM requirements are also made clear: the official Python script calls for 80GB, while ComfyUI with fp8 weights and automatic offloading has a tested template note of running 640×640 on a 24GB card (RTX 4090D).

What You'll Be Able to Do After This Lesson ​

  • Load the official template and run Wan2.2 14B text-to-video: 20-step sampling, outputting a 640×640, 81-frame, roughly 5-second video
  • Explain how the MoE dual experts divide the work: the high-noise expert handles composition, the low-noise expert handles detail, and only 14B of the 27B parameters are activated per step
  • Enable Turbo mode with one click: attach the lightx2v 4-step LoRA, get output in 4 steps, and test prompts several times faster than with 20 steps
  • Change parameters according to the rules: width and height as multiples of 16, frame count as 4n+1, and adjust 480P/720P and duration yourself without errors
  • Distinguish this lesson's EmptyHunyuanLatentVideo from the previous lesson's Wan22ImageToVideoLatent, and know when it's worth upgrading from the 5B to the 14B

Your Current Pain Points ​

  • 5B runs, but the formal production output always feels like something's missing: complex motion turns blurry, and it falls short of a "cinematic feel"
  • You want to move up to the 14B, but then you see you need to download two 13GB diffusion files and the official script says 80GB of VRAM — an instant turnoff
  • Online 14B tutorials don't match the templates: old tutorials have a pile of loose nodes, while the official template has now wrapped everything into one subgraph node, plus an extra Turbo switch

When to Use This Technique ​

When you need:

  • Quality-first formal production output: cinematic aesthetic control, large-scale complex motion, multi-subject scenes
  • 480P / 720P, roughly 5-second short clips — officially suited for content creation, artistic creation, education and training, and similar scenarios
  • Commercial projects: Apache 2.0 license, commercially usable as long as the copyright notice is retained

And you don't want to:

  • Run inference with Wan-AI's official Python scripts: the command-line barrier is high, and the official requirement is at least 80GB of VRAM
  • Wait for the full 20-step sampling for every clip: first pick the composition with Turbo's 4 steps, then do a refined run for the final version

🎒 Preparation Before Starting ​

  • Completedthe previous lesson's Wan2.2 5B workflow: know how to load a video template, change positive and negative prompts, and run with Ctrl+Enter
  • Know the model directory rules: put files into the matching subdirectory under models/ (see where models go)
  • ComfyUI 0.16.4 or later (the minimum version the official template library marks for this template; for template library usage see template library tutorial, and for version changes see changelog)
  • Leave about 33GB of free disk space: the four files 13.31 + 13.31 + 6.27 + 0.24 GB; add two more 1.14 GB LoRAs if you want Turbo
  • 24GB-class VRAM (per the template's tested note: RTX 4090D running 640×640 uses 84%; for smaller cards see the GGUF option in the advanced tips)

Core Idea ​

First remember the four key designs of Wan2.2 14B—every step that follows verifies them:

  1. Dual MoE experts = splitting the denoising process in half. Wan2.2 introduces a Mixture-of-Experts architecture to video diffusion models: the high-noise expert handles the early denoising stage, focusing on overall layout; the low-noise expert handles the late denoising stage, refining video details. Each expert has about 14B parameters, totaling 27B, but only one expert (14B) is activated per step—so inference compute and VRAM barely increase. Official statement: the switching point between the two experts is determined by the signal-to-noise ratio (SNR).
  2. In the template this is simply "two loaders + two samplers". Two Load Diffusion Model nodes load the high-noise and low-noise weights respectively; two KSamplerAdvanced nodes sample in relay—under standard mode the high-noise sampler runs steps 0→10, then the low-noise sampler runs steps 10→20. Both ModelSamplingSD3 nodes use a shift of 5.
  3. The latent node is swapped to EmptyHunyuanLatentVideo. 14B goes back to wan_2.1_vae (officially noted as compatible with Wan2.2); the latent has 16 channels with 8× spatial compression—not interchangeable with the 5B new VAE latent with 48 channels from the previous lesson, so the node changed too.
  4. Turbo mode is a single switch. The template has built-in automatic switching for the lightx2v 4-step LoRA: once enable_turbo_mode is turned on, the model path automatically switches to the LoRA-attached version, with steps 20→4 and cfg 3.5→1.

How to choose between 5B and 14B:

Wan2.2 TI2V 5B (previous lesson)Wan2.2 T2V 14B (this lesson)
diffusion weights1 file (9.31 GB)high-noise + low-noise, two files (13.31 GB each)
Parameters5B dense single modelMoE dual experts: 27B total, 14B activated per step
Tasksone model for text-to-video + image-to-videotext-to-video only (image-to-video and first/last frame have separate weights)
VAEwan2.2_vae.safetensors (16×16×4)wan_2.1_vae.safetensors (officially noted as compatible with 2.2)
latent nodeWan22ImageToVideoLatent (48 channels, width/height step 32)EmptyHunyuanLatentVideo (16 channels, width/height step 16)
Resolution720P (1280×704) @ 24fps480P / 720P (template default 640×640 @ 16fps)
VRAMofficial figure 8GBtemplate note 24GB tested 84% (640×640)
Best forquick prototyping, low VRAM, everyday creativityquality-first formal production

Both are under the Apache 2.0 license—no separate agreement needed for commercial use.

Follow Along ​

Step 1: Load the Wan2.2 14B Text-to-Video Template ​

Why: the official template packages the dual-expert loading, two samplers, and the Turbo switch into a single Text to Video(Wan2.2) subgraph node, with common parameters laid out on the node surface so you can't wire it wrong.

  1. Open the template library (Browse Templates), search for "Wan2.2 14B T2V", and find the template Wan Wanxiang 2.2 14B Text to Video (called Wan 2.2 14B Text to Video in the English interface)
  2. Click to load

You should see: on the canvas, a large Text to Video(Wan2.2) subgraph node plus a SaveVideo, with two explanatory sticky notes beside it—Model Links (download links for all models) and VRAM Usage (officially measured VRAM/time records). The surface of the subgraph node exposes parameters such as the prompt, width / height, duration, high-noise/low-noise models, high-noise/low-noise Lightning LoRA, text encoder, VAE, and enable_turbo_mode, with no red nodes anywhere.

  • Template loaded, no red nodes on the canvas
What's inside the subgraph? (Read this when it doesn't match older tutorials online)

Inside the template JSON, the subgraph Text to Video(Wan2.2) contains: two Load Diffusion Model nodes (high-noise/low-noise), two LoraLoaderModelOnly nodes (the 4-step LoRA used by Turbo), Load CLIP (with type set to wan), Load VAE, two ModelSamplingSD3 (shift 5), one positive and one negative CLIP Text Encode, EmptyHunyuanLatentVideo, two KSamplerAdvanced (relay sampling), VAEDecode, and CreateVideo (fps 16). In older tutorials these were loose nodes; now the official version has packed them into a single subgraph, leaving only the commonly used parameters exposed.

Step 2: Download the four-model set and put them in place ​

Why: 14B uses a dual-expert architecture, so the diffusion weights come in two files; together with the text encoder and VAE, that makes four items. Each must go in its proper place, otherwise they won't show up in the dropdown lists on the subgraph node.

Filegoes intoSize
wan2.2_t2v_high_noise_14B_fp8_scaled.safetensorsmodels/diffusion_models/13.31 GB
wan2.2_t2v_low_noise_14B_fp8_scaled.safetensorsmodels/diffusion_models/13.31 GB
umt5_xxl_fp8_e4m3fn_scaled.safetensorsmodels/text_encoders/6.27 GB
wan_2.1_vae.safetensorsmodels/vae/242.1 MB

Note two "counterintuitive" points: the text encoder reuses the umt5 fp8 version from the Wan2.1 repo; the VAE is also from 2.1 (the official notes state it is compatible with Wan2.2)—the wan2.2_vae used by 5B in the previous lesson does not apply in this lesson.

text
📂 ComfyUI/
└── 📂 models/
    ├── 📂 diffusion_models/
    │   ├─── wan2.2_t2v_high_noise_14B_fp8_scaled.safetensors
    │   └─── wan2.2_t2v_low_noise_14B_fp8_scaled.safetensors
    ├── 📂 text_encoders/
    │   └─── umt5_xxl_fp8_e4m3fn_scaled.safetensors
    └── 📂 vae/
        └─── wan_2.1_vae.safetensors

Download links (the Model Links sticky note in the template also carries these two sets):

(Optional) To enable Turbo mode, also download two acceleration LoRAs and put them into models/loras/:

FileSize
wan2.2_t2v_lightx2v_4steps_lora_v1.1_high_noise.safetensors1.14 GB
wan2.2_t2v_lightx2v_4steps_lora_v1.1_low_noise.safetensors1.14 GB

You should see: the corresponding files can be selected in all four dropdown lists—high_noise_model / low_noise_model / clip_name / vae_name—on the subgraph node.

  • The four-model set (+ the two optional LoRAs) appears in the correct directories and can be selected in the dropdowns

💡 Users in China should use ModelScope first

Both repos have official mirrors on ModelScope with fast direct-connection speeds; the file names are identical to those on HF, so just place them according to the table above.

Step 3: Write a prompt and get Wan2.2 text-to-video running (a video in 20 steps) ​

Why: first validate the whole pipeline with the template's default parameters. The defaults are standard mode: 20 steps, cfg 3.5, euler + simple, with the high-noise expert running the first 10 steps and the low-noise expert the last 10—this default set is the balance point officially tuned for you, so don't rush to change it before everything runs through.

  1. In the positive prompt (text) on the subgraph node, write a complete scene description. Template example:
text
Beautiful young European woman with honey blonde hair gracefully turning
her head back over shoulder, gentle smile, bright eyes looking at camera.
Hair flowing in slow motion as she turns. Soft natural lighting, clean
background, cinematic slow-motion portrait.
  1. The negative prompt is a Chinese paragraph bundled with the template; keep it as-is for now:
text
Vivid colors, overexposed, static, details blurry and unclear, subtitles, style, works, paintings, picture, still,
overall grayish, worst quality, low quality, JPEG compression artifacts, ugly, incomplete, extra fingers,
poorly drawn hands, poorly drawn faces, deformed, disfigured, limbs with malformed shapes, fused fingers,
motionless frames, cluttered background, three legs, many people in the background, walking backwards, nudity, NSFW
  1. Confirm that enable_turbo_mode is off (off by default)
  2. Run with Ctrl+Enter

You should see: the progress bar completes 20 steps, and the video is saved by the SaveVideo node into the video/ subdirectory of the output directory (file name starts with ComfyUI, format defaults to auto), at resolution 640×640, 81 frames, 16fps, about 5 seconds long. The template's measured sticky note (RTX 4090D, 640×640): standard mode (fp8_scaled) takes about 536 seconds for the first run and about 513 seconds for the second.

  • Your first Wan2.2 14B video appears in the output directory

Step 4: Enable Turbo mode for a quick video in 4 steps ​

Why: 20 steps means waiting eight or nine minutes—far too slow for iterating on prompts. The template has a built-in automatic switch for the lightx2v 4-step LoRA—one toggle simultaneously changes the model paths, step count, and cfg, so you don't have to edit them manually in three places.

  1. Confirm that the two 4steps LoRAs have been downloaded and put in place (the optional items in step 2)
  2. Turn on enable_turbo_mode on the subgraph node
  3. Run

You should see: this time only 4 steps run—high-noise expert 0→2, low-noise expert 2→4, cfg drops to 1; per the template's measured sticky note: about 108 seconds for the first run and about 71 seconds for the second.

  • Turbo mode runs through, with video generation time noticeably shortened

What happens behind the toggle:

ParameterStandard modeTurbo mode
Total steps204
High-noise/low-noise boundaryStep 10Step 2
cfg3.51
Lightning LoRAnot attachedone attached each for high-noise and low-noise (strength 1.0)
Suited forfinal video outputquickly testing prompts, picking compositions

⚠️ Turbo for Picking Compositions, Standard Mode for the Final Cut

4 steps is an acceleration scheme that trades steps for speed. Recommended workflow: keep Turbo on to batch-test prompts and compositions, then after making your pick, turn the switch off and rerun for the final version in standard mode with 20 steps.

Step 5: Change resolution, duration, and frame count ​

Why: the template defaults of 640×640 and 5 seconds are not set in stone; but width, height, and frame count each have their own step-size rules, and filling them in carelessly will cause problems.

Three parameters on the subgraph node:

ParameterTemplate defaultRuleNotes
width64016 multiplescorresponds to the latent node step size 16
height64016 multiplessame as above
duration5unit: secondsframe count is converted internally: length = duration × fps + 1
  1. To run 480P: set width to 848 and height to 480 (these are the EmptyHunyuanLatentVideo node's own defaults)
  2. To run 720P: set width to 1280 and height to 720 (this is the size used in the official command-line example)
  3. To change duration: just edit duration (in seconds). 5 seconds × 16fps + 1 = 81 frames; changing it to 3 seconds gives 49 frames
  4. The frame rate is on the CreateVideo node inside the subgraph (the template sets it to 16), and usually doesn't need touching—adjusting duration is enough to change the length

You should see: after changing the parameters and rerunning, the output video's resolution and duration change accordingly.

  • can change width / height / duration, and can explain why the frame count is 4n+1
Why is the frame count still 4n+1?

The latent generated by EmptyHunyuanLatentVideo is compressed by a factor of 4 in the time dimension: length frames get compressed into ((length−1)÷4)+1 time slices. So length can only take values like 1, 5, 9… 81 — values of the form 4n+1, and the node setting the step size to 4 is exactly what guarantees this. duration × fps + 1 (5×16+1=81) lands right on this sequence.

Checkpoints ✅ ​

  • Standard mode runs: a 20-step, 640×640, 81-frame, roughly 5-second video appears in the output directory
  • Turbo mode runs: video produced in 4 steps, with time cut to under 2 minutes (measured on a 24GB card)
  • can name the four files and their respective directories (diffusion_models ×2 / text_encoders / vae)
  • can explain the MoE dual-expert division of labor: the high-noise expert handles overall layout, the low-noise expert refines details, with 27B total parameters and 14B activated per step
  • knows that width and height must be multiples of 16 and length must be 4n+1, and can change 480P/720P and duration on their own

Pitfall reminders ​

❌ Only downloaded one diffusion file ​

14B is dual-expert: the two files high_noise and low_noise are both indispensable. If you only download one, no file can be selected in the other unet dropdown on the subgraph node, and the workflow won't run.

Correct approach: download the full set of four files per the table in step 2, placing the high-noise and low-noise models each in its place.

❌ Downloaded the wrong VAE again: this time you need the 2.1 one ​

Last lesson 5B used wan2.2_vae, but this lesson's 14B is the opposite, using wan_2.1_vae (officially noted as compatible with Wan2.2). The two model families have different latent channel counts (5B has 48 channels, 14B has 16 channels), so their VAEs cannot be mixed.

Correct approach: for this lesson, only wan_2.1_vae.safetensors will do—don't casually reuse the previous lesson's VAE.

❌ Turbo is on but the LoRA files weren't downloaded ​

After enable_turbo_mode is turned on, the template switches both samplers' model inputs to the LoRA-attached path; if the LoRA files aren't in models/loras/, they can't be selected in the dropdown and things get stuck immediately.

Correct approach: download and place both wan2.2_t2v_lightx2v_4steps_lora_v1.1_*.safetensors files (1.14 GB each) first, then flip the switch.

❌ Less than 24GB of VRAM but insisting on 720P ​

The template default of 640×640 is for a reason: per the template's own test notes, running this size on a 24GB card already uses 84% of VRAM. Jumping straight to 1280×720 makes the latent larger, VRAM usage rises with it, and OOM is very likely.

Correct approach: first reduce the duration (duration 5→3), then shrink width and height within multiples of 16 (note that 848×480 and 640×640 have comparable pixel counts, so switching between them saves little VRAM). If VRAM is still tight, see the GGUF quantization option below.

Advanced tips (optional) ​

Prompt extension: short sentences into long ones ​

The official recommendation is to enable prompt extension to enrich video details: the official script uses the dashscope API's qwen-plus (text-to-video task) for extension, and you can also swap in a local Qwen model (e.g., Qwen2.5-14B-Instruct). The ComfyUI template doesn't include this step, but the idea ports over directly: feed a short sentence to any LLM to expand it into a full scene description, then paste it into the positive prompt.

The text-to-video example prompt on the official model card is just one short sentence:

text
Two anthropomorphic cats in comfy boxing gear and bright gloves fight
intensely on a spotlighted stage.

Not enough VRAM: GGUF quantized versions ​

The community has GGUF quantized versions of the T2V-A14B model (bullerwins/Wan2.2-T2V-A14B-GGUF, QuantStack's Wan2.2 GGUF collection), loaded with the city96/ComfyUI-GGUF custom nodes — the mainstream solution for running the 14B model on low VRAM; see GGUF quantized models for details.

Official Prompt Guide ​

Alibaba officially maintains a Wan2.2 prompt guide (a DingTalk document) that supports both Chinese and English prompts — the negative prompt included in this lesson's template is in Chinese by default.

Lesson Summary ​

✅ This lesson got the Wan2.2 text-to-video 14B dual-expert workflow running:

  • ✅ Standard mode: the four weight files + official template, 20 steps, cfg 3.5, euler + simple, 640×640 produces a video in about 5 seconds
  • ✅ MoE principle: the high-noise expert handles composition, the low-noise expert handles details, with 27B total parameters but only 14B activated per step, so compute cost doesn't increase
  • ✅ Turbo mode: enable_turbo_mode a single switch, 4-step LoRA + cfg 1, a big speedup for testing prompts
  • ✅ Parameter rules: width and height must be multiples of 16, length is 4n+1, and you can change 480P/720P and duration yourself

Review of key configuration fields:

FieldRecommended valueNotes
high_noise_modelwan2.2_t2v_high_noise_14B_fp8_scaled.safetensorsThe high-noise expert, covering the first half of denoising
low_noise_modelwan2.2_t2v_low_noise_14B_fp8_scaled.safetensorsThe low-noise expert, covering the second half of denoising
clip_nameumt5_xxl_fp8_e4m3fn_scaled.safetensorsSelect wan for type, reusing the 2.1 repository file
vae_namewan_2.1_vae.safetensorsOfficially noted as compatible with Wan2.2; don't use the 5B one
Sampling (standard mode)20 steps / cfg 3.5 / euler + simple / boundary at step 10Template default
Sampling (Turbo)4 steps / cfg 1 / boundary at step 2 + two 4steps LoRAsenable_turbo_mode Enabled
ModelSamplingSD3shift 5 (one each for high-noise and low-noise)Template default
width / height640×640 (multiples of 16)480P uses 848×480, 720P uses 1280×720
duration5 seconds (length = duration×fps+1 = 81 frames)fps 16 is set via CreateVideo inside the subgraph
SaveVideovideo/ComfyUI prefix, format autoOutput goes to a video/ subdirectory

Next Lesson Preview ​

Text-to-video creates from scratch; the next lesson makes an existing photo move: Wan2.2 14B image-to-video: bringing photos to life. You will learn:

  • What the dedicated 14B image-to-video weights look like (note: I2V is an fp16 file, different from this lesson's fp8)
  • Load Image uploads the first frame, so the video starts moving from your photo
  • When to use T2V to create from scratch and when to use I2V to transform existing material

Appendix: Source Code Reference ​

Click to expand and view source code locations

Last updated: 2026-11-05 (template library template video_wan2_2_14B_t2v, officially marked minimum ComfyUI version 0.16.4)

ContentLocation
Official tutorial (Wan2.2, including the 14B T2V section)https://docs.comfy.org/tutorials/video/wan/wan2_2
Workflow template JSONhttps://github.com/Comfy-Org/workflow_templates/blob/main/templates/video_wan2_2_14B_t2v.json
Weights repository (Hugging Face)https://huggingface.co/Comfy-Org/Wan_2.2_ComfyUI_Repackaged
Weights repository (ModelScope mirror)https://modelscope.cn/models/Comfy-Org/Wan_2.2_ComfyUI_Repackaged
Wan-AI model card (T2V-A14B: MoE 27B/14B, 480P/720P, 80GB figures)https://huggingface.co/Wan-AI/Wan2.2-T2V-A14B
EmptyHunyuanLatentVideo node source codecomfy_extras/nodes_hunyuan.py (L43–L64)

The parameters on this page (standard mode 20 steps / cfg 3.5 / boundary at step 10, Turbo 4 steps / cfg 1 / boundary at step 2, shift 5, 640×640 / 81 frames / fps 16, the four-piece set and LoRA file names and sizes, and measured notes of 536s / 108s) were all verified against the actual node values in template JSON video_wan2_2_14B_t2v.json; the MoE architecture, 480P/720P, and VRAM figures come from the Wan-AI model card and official tutorials.

gaodong.aiAboutPrivacyContact

Independent tutorials, not affiliated with any product mentioned. Product names and trademarks belong to their owners. Check official pages for prices and policies.