[doc] standardize diffusion cookbook model pages (#34247)

Co-authored-by: Claude Opus 5 <noreply@anthropic.com>
2026-08-21 10:25:40 +08:00
parent 7e80e889a2
commit e0cf75d9bd
32 changed files with 2712 additions and 602 deletions
@@ -6,11 +6,13 @@ metatags:

 import { DiffusionModelTags } from '/src/snippets/diffusion/model-tags.jsx';

-<DiffusionModelTags tags={["image", "video", "sound/action", "world model", "policy"]} />
+<DiffusionModelTags tags={["omnimodal", "image + video", "sound + action", "world model", "robot policy"]} />

 ## 1. Model Introduction

-[NVIDIA Cosmos3](https://huggingface.co/collections/nvidia/cosmos3) is an omnimodal world-model family for image, video, sound, and action generation. SGLang Diffusion serves the public checkpoints with its native Cosmos3 pipeline.
+[NVIDIA Cosmos3](https://huggingface.co/collections/nvidia/cosmos3) is an omnimodal world-model family spanning text/image/video generation, optional synchronized sound, and robot action prediction. Its main advantage is breadth: the same native SGLang pipeline can serve media-generation checkpoints and the DROID policy checkpoint without routing through an LLM sampler.
+
+Choose Nano for the broadest modality coverage and lower deployment cost, Super for the larger 64B image/video model, and a specialized checkpoint when only T2I or I2V is needed. Sound and action are checkpoint-specific heads, so they are not available from every Cosmos3 repository.

 | Model | Status | Notes |
 | --- | --- | --- |
@@ -6,11 +6,13 @@ metatags:

 import { DiffusionModelTags } from '/src/snippets/diffusion/model-tags.jsx';

-<DiffusionModelTags tags={["image", "text-to-image", "turbo"]} />
+<DiffusionModelTags tags={["image", "text-to-image", "standard + Turbo", "single GPU"]} />

-## 1. Model introduction
+## 1. Model Introduction

-[ERNIE-Image](https://huggingface.co/baidu/ERNIE-Image) is Baidu's text-to-image diffusion model family. SGLang Diffusion supports both the regular and Turbo checkpoints with the native `ErnieImagePipeline`.
+[ERNIE-Image](https://huggingface.co/baidu/ERNIE-Image) is Baidu's text-to-image family with separate standard and Turbo checkpoints. The standard model is the quality-oriented path; Turbo is the lower-latency choice, and both load through SGLang's native `ErnieImagePipeline`.
+
+This integration currently targets text-only image generation rather than image editing or reference conditioning. Choose it for a straightforward single-GPU T2I deployment; use a dedicated editing model when preserving source-image structure is part of the task.

 | Model | Hugging Face model ID | Notes |
 | --- | --- | --- |
@@ -7,31 +7,18 @@ metatags:
 import { DiffusionModelTags } from '/src/snippets/diffusion/model-tags.jsx';
 import { FluxDeployment } from '/src/snippets/diffusion/flux-deployment.jsx';

-<DiffusionModelTags tags={["image", "text-to-image", "image editing", "multi-reference"]} />
+<DiffusionModelTags tags={["image", "text-to-image", "image editing", "multi-reference", "rectified flow"]} />

 ## 1. Model Introduction

-[FLUX](https://blackforestlabs.ai/) is a family of rectified flow transformer models developed by Black Forest Labs for high-quality image generation from text descriptions.
+[FLUX](https://blackforestlabs.ai/) is Black Forest Labs' rectified-flow image model family. [FLUX.1-dev](https://huggingface.co/black-forest-labs/FLUX.1-dev) is the smaller 12B text-to-image checkpoint; [FLUX.2-dev](https://huggingface.co/black-forest-labs/FLUX.2-dev) is a 32B model that adds instruction-based editing plus single- and multi-reference composition.

-[FLUX.1-dev](https://huggingface.co/black-forest-labs/FLUX.1-dev) is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions.
+FLUX is a strong default when prompt adherence, polished image quality, or reference consistency matters. The tradeoff is deployment weight: FLUX.2 needs substantially more memory than FLUX.1, and the dev checkpoints use the FLUX non-commercial license, so review the model license before production use.

-**Key Features:**
-
- **Cutting-edge Output Quality**: Second only to the state-of-the-art FLUX.1 [pro] model
- **Competitive Prompt Following**: Matches the performance of closed-source alternatives
- **Guidance Distillation**: Trained using guidance distillation for improved efficiency
- **Open Weights**: Available for personal, scientific, and commercial purposes under the FLUX [dev] Non-Commercial License
-
-[FLUX.2-dev](https://huggingface.co/black-forest-labs/FLUX.2-dev) is a 32 billion parameter rectified flow transformer capable of generating, editing, and combining images based on text instructions.
-
-**Key Features:**
-
- **State-of-the-art Performance**: Leading open model in text-to-image generation, single-reference editing, and multi-reference editing
- **No Finetuning Required**: Character, object, and style reference without additional training in one model
- **Guidance Distillation**: Trained using guidance distillation for improved efficiency
- **Open Weights**: Available for personal, scientific, and commercial purposes under the FLUX [dev] Non-Commercial License
-
-For more details, please refer to the [FLUX.1-dev HuggingFace page](https://huggingface.co/black-forest-labs/FLUX.1-dev), [FLUX.2-dev HuggingFace page](https://huggingface.co/black-forest-labs/FLUX.2-dev), and the [official blog post](https://blackforestlabs.ai/announcing-black-forest-labs/).
+| Checkpoint | Best fit | Main limitation |
+| --- | --- | --- |
+| `black-forest-labs/FLUX.1-dev` | High-quality text-to-image with the lighter FLUX deployment | No native multi-reference editing path |
+| `black-forest-labs/FLUX.2-dev` | Text-to-image, editing, and reference-guided composition in one model | 32B model with a larger memory footprint |

 ## 2. SGLang-diffusion Installation

@@ -6,13 +6,13 @@ metatags:

 import { DiffusionModelTags } from '/src/snippets/diffusion/model-tags.jsx';

-<DiffusionModelTags tags={["image", "text-to-image", "typography", "NF4/FP8/NVFP4"]} />
+<DiffusionModelTags tags={["image", "text-to-image", "typography", "8/20-step distilled", "NF4 / FP8 / NVFP4"]} />

-## 1. Model introduction
+## 1. Model Introduction

-[Ideogram 4](https://huggingface.co/ideogram-ai/ideogram-4-nf4) is Ideogram's text-to-image diffusion model. SGLang Diffusion supports the official NF4 and FP8 checkpoints, the Comfy-Org NVFP4 transformer checkpoint, and fal's single-branch Fast and Instant variants.
+[Ideogram 4](https://huggingface.co/ideogram-ai/ideogram-4-nf4) is a text-to-image family focused on polished composition and typography-aware generation. SGLang supports the official NF4 and FP8 checkpoints, Comfy-Org's NVFP4 transformer, and fal's distilled Fast and Instant variants.

-Compared with previous open-source image models, Ideogram 4 provides a significant aesthetic lift, with stronger composition, more polished visual style, and better typography-aware generation.
+Choose NF4 when memory is the primary constraint, FP8/NVFP4 for supported accelerator deployments, Fast for a 20-step balance, and Instant for the 8-step latency target. The public repositories are gated, and the available releases are already quantized or distilled rather than a single full-precision baseline.

 | Variant | Hugging Face model ID | Notes |
 | --- | --- | --- |
@@ -7,13 +7,15 @@ metatags:

 import { DiffusionModelTags } from '/src/snippets/diffusion/model-tags.jsx';

-<DiffusionModelTags tags={["video", "audio-video", "multi-shot", "memory bank"]} />
+<DiffusionModelTags tags={["video + audio", "multi-shot", "minute-scale", "memory bank", "8-step"]} />

 ## 1. Model Introduction

-[JoyAI-Echo](https://huggingface.co/jdopensource/JoyAI-Echo) (JoyEcho) is a long-form audio–video generation model built on the LTX-2 backbone. Its core idea is a **paired audio–video memory bank**: each shot commits decoded frames and audio latents into a rolling bank, and subsequent shots condition on that memory prefix. This enables **multi-shot, minute-scale generation** with visual and audio continuity across prompts.
+[JoyAI-Echo](https://huggingface.co/jdopensource/JoyAI-Echo) is an 8-step long-form audio-video model built on LTX-2. Its paired memory bank carries decoded visual context and audio latents across prompt changes, making it strongest for multi-shot, minute-scale sequences that need continuity in both picture and soundtrack.

-Use `jdopensource/JoyAI-Echo` as `--model-path`. SGLang loads the monolithic release through the built-in [JoyAI-Echo-overlay](https://huggingface.co/Niehen6174/JoyAI-Echo-overlay) materialization path, similar to LTX-2.3-overlay.
+Choose JoyEcho over a standard LTX pipeline when shots must share audiovisual memory. Its distilled 832×480 path prioritizes long-form continuity and throughput rather than the higher-resolution two-stage quality modes offered by LTX-2.3.
+
+Use `jdopensource/JoyAI-Echo` as `--model-path`; SGLang materializes the monolithic release through the built-in [JoyAI-Echo overlay](https://huggingface.co/Niehen6174/JoyAI-Echo-overlay).

 | Aspect | Standard LTX-2.3 | JoyEcho |
 | --- | --- | --- |
@@ -6,24 +6,18 @@ metatags:

 import { DiffusionModelTags } from '/src/snippets/diffusion/model-tags.jsx';

-<DiffusionModelTags tags={["image", "text-to-image", "turbo", "raw"]} />
+<DiffusionModelTags tags={["image", "text-to-image", "8-step Turbo", "high-fidelity Raw", "Qwen3-VL"]} />

 ## 1. Model Introduction

-[Krea-2](https://huggingface.co/krea/Krea-2-Turbo) is a high-quality text-to-image diffusion model from [Krea](https://www.krea.ai/). It ships in two variants that share the same backbone and differ only in their sampling recipe:
+[Krea-2](https://huggingface.co/krea/Krea-2-Turbo) is Krea's photorealistic text-to-image family, built as a single-stream MMDiT with a Qwen3-VL text encoder and Qwen-Image VAE. Both public variants use the same native SGLang pipeline and differ mainly in their sampling target.

- **[Krea-2-Turbo](https://huggingface.co/krea/Krea-2-Turbo)** - a distilled, few-step model that produces photorealistic images in only **8 inference steps** with no classifier-free guidance (`guidance_scale = 1.0`), ideal for fast and interactive generation.
- **[Krea-2-Raw](https://huggingface.co/krea/Krea-2-Raw)** - the base (non-distilled) model that trades speed for maximum fidelity, using a longer schedule (~52 steps) with classifier-free guidance (`guidance_scale ≈ 4.5`).
+Choose Turbo for interactive generation: it is distilled to 8 steps with `guidance_scale=1.0`. Choose Raw when maximum fidelity matters more than latency: it uses roughly 52 steps with classifier-free guidance. Neither checkpoint is an image-editing model; use the Qwen-Image-Edit or FLUX.2 path when an input image must be preserved or transformed.

-Both variants are built on a single-stream MMDiT with a Qwen3-VL text encoder and the Qwen-Image VAE, and are distributed in the standard diffusers layout (a `model_index.json` plus sharded `transformer/`, `text_encoder/`, `vae/`, `tokenizer/`, and `scheduler/` folders). SGLang loads them **natively** - just point `--model-path` at the repo, no conversion step required.
-
-**Key Features:**
-
- **Two variants, one pipeline**: switch between fast (Turbo) and high-fidelity (Raw) by changing only the model path and the sampling settings.
- **Photorealistic generation** at 1024x1024 and other resolutions.
- **Native diffusers loading**: components (DiT, text encoder, VAE, scheduler) are read straight from the repo's `model_index.json`.
-
-For more details, see the [Krea-2-Turbo](https://huggingface.co/krea/Krea-2-Turbo) and [Krea-2-Raw](https://huggingface.co/krea/Krea-2-Raw) HuggingFace pages.
+| Variant | Model ID | Sampling profile |
+| --- | --- | --- |
+| Turbo | `krea/Krea-2-Turbo` | 8 steps, no CFG; fastest path |
+| Raw | `krea/Krea-2-Raw` | About 52 steps with CFG; higher-fidelity path |

 ## 2. SGLang-diffusion Installation

@@ -8,13 +8,15 @@ metatags:
 import { DiffusionModelTags } from '/src/snippets/diffusion/model-tags.jsx';
 import { LTXDeployment } from '/src/snippets/diffusion/ltx-deployment.jsx';

-<DiffusionModelTags tags={["video", "text-to-video", "image-to-video", "two-stage"]} />
+<DiffusionModelTags tags={["video", "text-to-video", "image-to-video", "one/two-stage", "1088p HQ"]} />

 ## 1. Model Introduction

-[LTX-2](https://huggingface.co/Lightricks/LTX-2) and [LTX-2.3](https://huggingface.co/Lightricks/LTX-2.3) are video generation models from Lightricks. SGLang Diffusion supports the LTX series through native one-stage and two-stage pipelines for text-to-video and image-conditioned video generation.
+[LTX-2](https://huggingface.co/Lightricks/LTX-2) and [LTX-2.3](https://huggingface.co/Lightricks/LTX-2.3) are Lightricks video models for text-to-video and image-conditioned generation. Their defining deployment choice is the pipeline: one-stage minimizes latency, standard two-stage refines quality, and LTX-2.3 adds a 1920×1088 HQ path.

-Use `Lightricks/LTX-2` or `Lightricks/LTX-2.3` as `--model-path`. For two-stage generation, SGLang uses the spatial upsampler and distilled LoRA components from the model snapshot by default. LTX-2.3 also supports the HQ two-stage variant.
+Choose LTX when one model family must span fast generation, higher-quality refinement, and LoRA adaptation. Two-stage quality costs substantially more memory and startup work because both DiTs and the spatial upsampler participate; use the one-stage path when latency or capacity matters more than final detail.
+
+Use `Lightricks/LTX-2` or `Lightricks/LTX-2.3` as `--model-path`. SGLang loads the two-stage upsampler and distilled components from the selected snapshot.

 <Warning>
 **License notice:** LTX-2 and LTX-2.3 are released under the LTX-2 Community License Agreement, not Apache 2.0. The license includes commercial-use restrictions for some entities. Review the [official Lightricks license](https://huggingface.co/Lightricks/LTX-2.3/blob/main/LICENSE) before production or commercial use; SGLang support does not grant additional model usage rights.
@@ -8,7 +8,7 @@ metatags:
 import { DiffusionModelTags } from '/src/snippets/diffusion/model-tags.jsx';
 import { LTX25Deployment } from '/src/snippets/diffusion/ltx25-deployment.jsx';

-<DiffusionModelTags tags={["video", "audio", "text-to-video", "image-to-video", "two-stage", "auto-duration", "diffusion decoder"]} />
+<DiffusionModelTags tags={["video", "audio", "text-to-video", "image-to-video", "two-stage", "auto-duration"]} />

 ## 1. Model Introduction

@@ -7,13 +7,22 @@ metatags:

 import { DiffusionModelTags } from '/src/snippets/diffusion/model-tags.jsx';

-<DiffusionModelTags tags={["video", "text-to-video", "mixture-of-experts"]} />
+<DiffusionModelTags tags={["video", "text-to-video", "mixture-of-experts", "30B-A3B"]} />

-## 1. Model introduction
+## 1. Model Introduction

 [LingBot Video MoE 30B-A3B](https://huggingface.co/robbyant/lingbot-video-moe-30b-a3b)
-is a text-to-video mixture-of-experts model. SGLang Diffusion provides a native
-pipeline for the public checkpoint:
+is a text-to-video mixture-of-experts model served through a native SGLang
+Diffusion pipeline. Its main advantage is the MoE economics: 30B total
+parameters with 3B active per token, so a plain `sglang serve` invocation
+covers the released 480×480, 81-frame profile without parallelism flags.
+
+Prompting is the distinctive part of this checkpoint: it expects a structured
+JSON caption rather than an unexpanded natural-language prompt, passed as the
+request's `prompt` string. A compact 17-frame, 12-step smoke-test profile is
+available for quick validation next to the released 40-step profile.
+
+The public checkpoint served by the pipeline:

 | Model ID | Task | Default output |
 | --- | --- | --- |
@@ -7,13 +7,13 @@ tag: REALTIME

 import { DiffusionModelTags } from '/src/snippets/diffusion/model-tags.jsx';

-<DiffusionModelTags tags={["realtime", "world model", "causal DiT", "camera control"]} />
+<DiffusionModelTags tags={["realtime", "world model", "14B causal DiT", "camera control", "interactive KV window"]} />

 ## 1. Model Introduction

-lingbot-world-v2-14b-causal-fast-diffusers is a realtime camera-controlled video world model. In SGLang-diffusion, it belongs to the realtime causal path: the server keeps a live session, samples control signals per chunk, reuses causal DiT state, and decodes video frames incrementally.
+[LingBot World 2.0](https://huggingface.co/robbyant/lingbot-world-v2-14b-causal-fast-diffusers) is the 14B realtime camera-controlled world model in the LingBot family. It generates continuously from a live causal session, accepts control updates between chunks, and reuses DiT and VAE state for incremental frame delivery.

-This is different from offline diffusion video models such as Wan or LTX. Offline models denoise a bounded latent sequence for one request. Realtime world models generate a continuing stream, so the runtime must manage session state, control events, causal attention cache, and VAE decode cache.
+Choose 2.0 when the larger model and interactive KV-window path justify an 8-GPU deployment. Like the earlier LingBot release, it prioritizes responsive control and bounded causal state over the full-clip global context of offline video diffusion.

 ## 2. Deployment

@@ -7,13 +7,13 @@ tag: REALTIME

 import { DiffusionModelTags } from '/src/snippets/diffusion/model-tags.jsx';

-<DiffusionModelTags tags={["realtime", "world model", "causal DiT", "camera control"]} />
+<DiffusionModelTags tags={["realtime", "world model", "continuous video", "camera control", "causal KV cache"]} />

 ## 1. Model Introduction

-[LingBot World](https://huggingface.co/robbyant/lingbot-world-fast-diffusers) is a realtime camera-controlled video world model. In SGLang-diffusion, it belongs to the realtime causal path: the server keeps a live session, samples control signals per chunk, reuses causal DiT state, and decodes video frames incrementally.
+[LingBot World](https://huggingface.co/robbyant/lingbot-world-fast-diffusers) is a realtime camera-controlled video world model. It keeps a live causal session, applies prompt and camera events between chunks, reuses DiT/VAE state, and streams decoded frames instead of finishing a bounded clip before returning.

-This is different from offline diffusion video models such as Wan or LTX. Offline models denoise a bounded latent sequence for one request. Realtime world models generate a continuing stream, so the runtime must manage session state, control events, causal attention cache, and VAE decode cache.
+Choose it for interactive exploration and continuous control, not one-shot cinematic generation. The causal window makes long sessions practical but gives up the global bidirectional context available to offline Wan or LTX pipelines; session state and cache policy are therefore part of the serving contract.

 ## 2. Deployment

@@ -5,13 +5,15 @@ description: "Serve LongLive 2.0 distilled text-to-video and image-to-video mode

 import { DiffusionModelTags } from '/src/snippets/diffusion/model-tags.jsx';

-<DiffusionModelTags tags={["video", "text-to-video", "image-to-video", "few-step", "multi-shot"]} />
+<DiffusionModelTags tags={["video", "text/image-to-video", "4-step", "multi-shot", "Wan2.2 5B"]} />

 ## 1. Model Introduction

-[LongLive 2.0](https://nvlabs.github.io/LongLive/LongLive2/) is a distilled few-step text-to-video and image-to-video model from NVIDIA, built on Wan2.2-TI2V-5B. SGLang serves the Diffusers-format conversion for single-prompt and multi-shot video generation.
+[LongLive 2.0](https://nvlabs.github.io/LongLive/LongLive2/) is NVIDIA's 4-step text/image-to-video model distilled from Wan2.2-TI2V-5B. Its main strength is extending few-step causal generation across prompt changes, so a single request can produce multi-shot sequences without paying a full diffusion schedule for every shot.

-For more details, check the [LongLive 2.0 paper](https://arxiv.org/abs/2605.18739) and [LongLive 2.0 GitHub](https://github.com/NVlabs/LongLive). The model weights are released under the NVIDIA Open Model License.
+Choose it for low-step long or multi-shot generation rather than maximum one-shot fidelity. The SGLang path uses a Diffusers conversion of the official weights, and scene continuity still depends on prompt-block and sink settings; validate transitions on the target storyboard.
+
+The model weights use the NVIDIA Open Model License. See the [paper](https://arxiv.org/abs/2605.18739) and [GitHub repository](https://github.com/NVlabs/LongLive) for training details.

 ## 2. SGLang-diffusion Installation

@@ -6,22 +6,18 @@ metatags:

 import { DiffusionModelTags } from '/src/snippets/diffusion/model-tags.jsx';

-<DiffusionModelTags tags={["video", "audio-video", "lip-sync", "environment audio"]} />
+<DiffusionModelTags tags={["video + audio", "joint generation", "lip-sync", "environment sound", "up to 8 seconds"]} />

 ## 1. Model Introduction

-[MOVA](https://github.com/OpenMOSS/MOVA) (MOSS Video and Audio) is a foundation model developed by the SII-OpenMOSS Team, designed to break the "silent era" of open-source video generation. Unlike cascaded pipelines that generate sound as an afterthought, MOVA synthesizes video and audio simultaneously in a single inference pass for perfect alignment. It adopts an Asymmetric Dual-Tower Architecture, fusing pre-trained video and audio towers through a bidirectional cross-attention mechanism to maintain tight synchronization between video and audio during generation.
+[MOVA](https://github.com/OpenMOSS/MOVA) generates video and audio together with an asymmetric dual-tower model connected by bidirectional cross-attention. Its strongest use cases are speaking subjects, visible sound-producing events, and scenes where ambient audio must track the picture rather than be synthesized by a later cascade.

-[MOVA-360p](https://huggingface.co/OpenMOSS-Team/MOVA-360p) is suitable for fast inference and resource-constrained environments. [MOVA-720p](https://huggingface.co/OpenMOSS-Team/MOVA-720p) provides higher resolution video generation. Both versions support generating up to 8 seconds of video-audio content.
+The public 360p and 720p checkpoints both generate up to 8 seconds. Choose 360p for the lighter deployment and 720p for output resolution; MOVA is less suitable when the task needs long-form continuity or the richer image/video/audio reference conditioning provided by H3.

-**Key Features:**
-
- **Native Bimodal Generation**: Generates high-fidelity video and synchronized audio in a single inference pass, eliminating error accumulation from cascaded pipelines
- **Precise Lip-Sync**: Achieves state-of-the-art performance in multilingual lip-synchronization (LSE-D: 7.094, LSE-C: 7.452 with Dual CFG on Verse-Bench Set3)
- **Environment-Aware Sound Effects**: Generates corresponding environmental sound effects including physical interaction sounds, ambient sounds, and spatial/textural sound feedback
- **Fully Open-Source**: Model weights, inference code, training pipelines, and LoRA fine-tuning scripts are all open-sourced
-
-For more details, please refer to the [MOVA-360p HuggingFace page](https://huggingface.co/OpenMOSS-Team/MOVA-360p), the [MOVA-720p HuggingFace page](https://huggingface.co/OpenMOSS-Team/MOVA-720p), the [GitHub repository](https://github.com/OpenMOSS/MOVA), and the [technical report (arXiv)](https://arxiv.org/abs/2602.08794).
+| Checkpoint | Best fit | Output limit |
+| --- | --- | --- |
+| `OpenMOSS-Team/MOVA-360p` | Faster, lower-memory joint audiovisual generation | Up to 8 seconds at 360p |
+| `OpenMOSS-Team/MOVA-720p` | Higher-resolution lip-sync and environment audio | Up to 8 seconds at 720p |

 ## 2. SGLang-diffusion Installation

@@ -5,9 +5,43 @@ metatags:
    description: "Serve MiniMax-H3 with SGLang Diffusion for text-to-video-and-audio, first/last-frame conditioning, video-to-video, and multimodal reference conditioning."
 ---

-## 1. Model introduction
+import { DiffusionModelTags } from '/src/snippets/diffusion/model-tags.jsx';
+import { Deployment } from "/src/snippets/_deployment.jsx";
+import { config } from "/src/snippets/configs/MiniMaxAI/minimax-h3.jsx";

-[MiniMax-H3](https://huggingface.co/MiniMaxAI/MiniMax-H3) generates a video and a synchronized stereo audio track in one request. SGLang Diffusion provides a native pipeline for the three public task profiles, split across the released FL2VA (First-and-Last-Frame-to-Video-and-Audio) and Ref2VA (Reference-to-Video-and-Audio) checkpoint partitions:
+<DiffusionModelTags tags={["video + audio", "T2VA / FL2VA / Ref2VA", "multimodal references", "4–15 seconds", "768p"]} />
+
+## 1. Quick start
+
+Install with `uv pip install "sglang[diffusion]" --prerelease=allow`, then choose
+a verified recipe below. Setup changes the deployment; Server and Request expose
+orthogonal startup and sampling choices.
+
+<Deployment config={config} />
+
+<Note>
+The generated Server command already includes the recommended encoder policy.
+Change a Server option only for a deliberate trade-off; Request options do not
+reload the model.
+</Note>
+
+The Docker form installs the platform-specific diffusion extra from the source
+bundled in the image. For conditioned requests, set **Host media directory**
+under **Variables**; the builder mounts it read-only at `/data/minimax-h3`.
+AMD currently offers the Python form, while NVIDIA also offers Docker.
+
+To use ModelScope through the same normal `sglang serve` path, prefix the copied
+command with `SGLANG_USE_MODELSCOPE=true` and replace the model path with
+`MiniMax/MiniMax-H3`. Keep the selected variant and topology flags unchanged.
+
+For platform-specific installation details, see the
+[SGLang Diffusion installation guide](/docs/sglang-diffusion/installation).
+
+## 2. Model capabilities
+
+[MiniMax-H3](https://huggingface.co/MiniMaxAI/MiniMax-H3) is a native joint video-and-audio model for text-to-video-and-audio, first/last-frame control, and multimodal reference conditioning. Its main strength is producing the picture and stereo soundtrack together, so speech, music, ambient sound, and visible events can stay aligned without a separate audio-generation pass.
+
+Choose H3 when synchronized audiovisual output or reference-driven generation matters more than a lightweight deployment. The released recipe targets a 768-pixel short edge at 24 fps for 4–15 seconds, and its capabilities are split across two checkpoint partitions; serving every mode therefore requires separate FL2VA and Ref2VA deployments.

 | Task | `task` value | Conditioning |
 | --- | --- | --- |
@@ -29,64 +63,12 @@ mapping; do not point `--model-path` at a manually downloaded subdirectory.
 Review the license and usage terms in the MiniMax-H3 model card before production or commercial use. SGLang support does not grant additional model usage rights.
 </Warning>

-## 2. Installation
+## 3. Deployment details

-Install SGLang with the diffusion dependencies:
-
-```bash Command
-uv pip install "sglang[diffusion]" --prerelease=allow
-```
-
-For platform-specific setup, see the [SGLang Diffusion installation guide](/docs/sglang-diffusion/installation).
-
-## 3. Serve MiniMax-H3
-
-Use the interactive selector to choose a hardware platform, deployment profile,
-one of the two checkpoint partitions, a request mode, and deployment features.
-It generates Python and, where available, Docker launch forms. AMD selections
-use the Python form until an H3-capable ROCm image is validated. The **$ cURL**
-button follows the selected request mode and switches the payload across
-text-only, all three first/last-frame signatures, and the image/audio/video
-reference combinations listed below.
-Set **Outputs per prompt** in the picker’s **Env** panel to generate more than
-one output without mixing request sampling controls into the deployment
-matrix.
-
-The Docker form does not assume the base SGLang image contains optional
-diffusion dependencies. It installs the platform-specific diffusion extra from
-the source bundled in the image before starting the server. Set **Host media
-directory** in the **Env** panel for FL2VA, V2V, or Ref2VA; the picker mounts
-that directory read-only at `/data/minimax-h3` inside the container.
-
-Every hardware/topology cell in this picker has completed a real request on
-that exact GPU model. Approximate load-time features such as online
-quantization are called out separately in the generated command. Sampling
-behavior such as Cache-DiT is documented separately below.
-
-**Deployment Profile** exposes resident and FSDP placement on B200, B300,
-H200, and H100. Resident is the latency-oriented default; FSDP reduces DiT
-weight residency at the cost of per-block parameter collectives. On H200 it
-also selects the verified 2-node cross-node topology. **Online
-Quantization** appears only on B200 and B300. AMD keeps its resident AITER
-recipe, while RTX 5090 uses its dedicated layerwise-offload profile. A
-single 24 GB card (RTX 4090) uses the same offload knobs plus online
-`kitchen_int8`; that recipe is documented below rather than in the picker.
-
-import { Deployment } from "/src/snippets/_deployment.jsx";
-import { config } from "/src/snippets/configs/MiniMaxAI/minimax-h3.jsx";
-
-<Deployment config={config} />
-
-<Note>
-The ready-to-run request template lives behind the **$ cURL** button in the
-picker above. It regenerates as you change the selection, so the payload it
-shows always matches the serve command next to it.
-</Note>
-
-The selector uses the verified Hugging Face ID. To use ModelScope through the
-same normal `sglang serve` path, prefix the copied command with
-`SGLANG_USE_MODELSCOPE=true` and replace the model path with
-`MiniMax/MiniMax-H3`; keep its selected variant and topology flags unchanged.
+The builder accepts legal custom GPU counts and topologies, marking them
+**Unverified** until the exact recipe has completed end-to-end validation.
+Static H3 head or partition violations disable Copy before they reach
+`sglang serve`.

 For a four-card H200 host, keep the full BF16/FP32 model resident by default.
 The model fits without FSDP, so this path avoids the per-block parameter
@@ -98,6 +80,7 @@ sglang serve \
  --model-variant fl2va \
  --num-gpus 4 \
  --ulysses-degree 4 \
+  --encoder-parallel auto \
  --performance-mode speed \
  --port 30010
 ```
@@ -121,6 +104,7 @@ sglang serve \
  --num-gpus 4 \
  --tp-size 2 \
  --ulysses-degree 2 \
+  --encoder-parallel auto \
  --performance-mode speed \
  --port 30010
 ```
@@ -136,6 +120,7 @@ sglang serve \
  --model-variant fl2va \
  --num-gpus 4 \
  --ulysses-degree 4 \
+  --encoder-parallel auto \
  --performance-mode speed \
  --use-fsdp-inference true \
  --port 30010
@@ -153,6 +138,7 @@ sglang serve \
  --num-gpus 2 \
  --tp-size 2 \
  --ulysses-degree 1 \
+  --encoder-parallel auto \
  --performance-mode memory \
  --layerwise-offload-components dit,text_encoder,vae \
  --dit-offload-prefetch-size 1 \
@@ -680,6 +666,7 @@ sglang serve \
  --sp-degree 4 \
  --ulysses-degree 4 \
  --ring-degree 1 \
+  --encoder-parallel auto \
  --performance-mode speed \
  --use-fsdp-inference false \
  --enable-torch-compile false \
@@ -764,6 +751,7 @@ sglang serve \
  --model-variant ref2va \
  --num-gpus 8 \
  --ulysses-degree 8 \
+  --encoder-parallel auto \
  --performance-mode speed \
  --port 30010
 ```
@@ -777,7 +765,11 @@ task profile. A real B200 request has completed, but the `quality: "high"`
 path above remains fail-closed to the audited 4×H200 workload.
 </Warning>

-## 7. Runtime feature recipes
+## 7. Feature contracts and advanced recipes
+
+The generated command already contains the recommended topology and encoder
+setting. Use the detailed reference below only when applying an optional
+override or checking its installation, topology limits, and validation evidence.

 <Tabs>

@@ -791,7 +783,6 @@ listed hardware and topology; it is not inherited by a similar GPU family.
 | --- | --- | --- |
 | Ulysses sequence parallelism | Verified: 8× B200, 4× H200, 4× H100, and Ulysses1/2/4/8 on MI300X and MI355X | Use `--ulysses-degree`. Combine with Ring for cross-node scaling; see the next row. |
 | Ring sequence parallelism (cross-node) | Verified: 2 nodes of 8× H200 each (Ulysses8 × Ring2) | Use `--ring-degree` together with `--nnodes`/`--node-rank`/`--dist-init-addr`. Ring shards the sequence across nodes while Ulysses shards heads within a node; H3's packed multi-segment attention only supports Ring across the node boundary, not within a single node's Ulysses group. Requires `--encoder-parallel replicate` — `auto`'s fold decision is not node-boundary aware. See the benchmark section below. |
-| SageAttention | Supported | Use `--attention-backend sage_attn` to select the native packed varlen path; install the SageAttention dependency first. |
 | Tensor parallelism | Verified: B200 TP2 + Ulysses4; H100 TP2 + Ulysses2 and TP4 + Ulysses1 | `--tp-size` may be combined with Ulysses when the TP-local head count remains divisible by the Ulysses degree. On 4×H100, TP2 + Ulysses2 is the measured speed default. |
 | FSDP inference | Verified: 4× B200 and 4× H100 + Ulysses4 | Preserves H3's mixed BF16/FP32 parameter policy. B200 completed the exact eager comparison; H100 completed consecutive real requests at about 57 GB peak memory per GPU. |
 | Resident components | Verified: B200, H200, 4×H100 with TP, and 1/2/4/8× MI300X and MI355X | This is the recommended single-request latency path when the complete workload fits. |
@@ -814,6 +805,7 @@ sglang serve \
  --model-variant ref2va \
  --num-gpus 8 \
  --ulysses-degree 8 \
+  --encoder-parallel auto \
  --performance-mode speed \
  --enable-breakable-cuda-graph true \
  --warmup-resolutions 1344x768 \
@@ -827,6 +819,29 @@ different task profile, reference set, resolution, or prompt template.

 </Tab>

+<Tab title="Attention backends">
+
+Leave `--attention-backend` unset for the platform default. Use
+`--attention-backend fa` only for an explicit FlashAttention comparison.
+
+SageAttention uses quantized attention math and is not a consistency mode. To
+select H3's native packed-varlen Sage path, install the dependency and add
+`--attention-backend sage_attn`. On Hopper, install the upstream SM90 binding
+fix rather than the PyPI 2.2.0 build:
+
+```bash Command
+pip install --force-reinstall \
+  git+https://github.com/thu-ml/SageAttention.git@d9704247a5139ab4c03bf7fc6b35cc0e2cbb5ea4 \
+  --no-build-isolation
+```
+
+The backend is a server-wide default. Use
+`--component-attention-backends` only when a measured component needs a
+different kernel, and keep the platform default for every component not named
+in the override.
+
+</Tab>
+
 <Tab title="Online quantization">

 On the verified 8× B200 topology, quantize the BF16 transformer at server load:
@@ -837,6 +852,7 @@ sglang serve \
  --model-variant ref2va \
  --num-gpus 8 \
  --ulysses-degree 8 \
+  --encoder-parallel auto \
  --performance-mode speed \
  --quantization fp8 \
  --port 30010
@@ -852,6 +868,7 @@ sglang serve \
  --model-variant ref2va \
  --num-gpus 8 \
  --ulysses-degree 8 \
+  --encoder-parallel auto \
  --quantization fp8 \
  --quantization-ignored-layers blocks.0.attn token_refiner \
  --port 30010
@@ -861,8 +878,8 @@ sglang serve \
 Online FP8 is approximate and is not a consistency ground-truth mode. It can
 be combined with Cache-DiT, but the two approximations compound. Validate
 visual quality, audio quality, memory use, and latency on the target workload.
-The picker exposes this option only on the B200 and B300 topologies used for
-real H3 validation runs.
+This recipe is limited to the resident B200 and B300 topologies used for real
+H3 validation runs.
 </Warning>

 On a single 24 GB card, use `kitchen_int8` instead of FP8. It quantizes the
@@ -924,6 +941,33 @@ the strict `quality="high"` deployment contract.

 </Tab>

+<Tab title="Encoder scheduling">
+
+The picker explicitly writes `--encoder-parallel auto` in every single-node
+recipe. At the default request batch size of one, H100/H200/B200/B300 servers
+with peer-to-peer access fold the Qwen encoder across otherwise idle Ulysses
+ranks. A pure-TP recipe keeps the encoder inside its TP group, while a
+PCIe-only host can avoid an expensive world fold. Keep `auto` unless one of
+the cases below applies.
+
+Encoder DP is a throughput policy for compatible request batches. It requires
+TP1 and DiT DP1, replicates the encoder weights, and does not improve a batch
+of one:
+
+```bash Overlay
+--encoder-parallel dp \
+--batching-max-size 2
+```
+
+The cross-node picker recipe already uses replication because the automatic
+fold decision is not node-boundary aware:
+
+```bash Overlay
+--encoder-parallel replicate
+```
+
+</Tab>
+
 </Tabs>

 ## 8. Configuration notes
@@ -995,7 +1039,7 @@ The swept axes are `--model-variant` (`fl2va` / `ref2va`), `--quantization`

 This is a single-request latency sweep (`batching_max_size: 1`), so encoder DP
 is intentionally excluded: it cannot distribute a batch of one. Use the
-picker’s **DP (batched throughput)** option for a multi-request throughput
+**DP for a request batch** setting above for a compatible multi-request
 deployment; the table below does not claim a measured H3 DP speedup.

 **Driver.**
@@ -7,22 +7,13 @@ metatags:
 import { DiffusionModelTags } from '/src/snippets/diffusion/model-tags.jsx';
 import { QwenImageEditDeployment } from '/src/snippets/diffusion/qwen-image-edit-deployment.jsx';

-<DiffusionModelTags tags={["image", "image editing", "text rendering", "character consistency"]} />
+<DiffusionModelTags tags={["image editing", "text replacement", "character consistency", "multi-person", "20B"]} />

 ## 1. Model Introduction

-[Qwen-Image-Edit-2511](https://huggingface.co/Qwen/Qwen-Image-Edit-2511) is an enhanced version over Qwen-Image-Edit-2509, featuring multiple improvements—including notably better consistency. Built upon the 20B Qwen-Image model, Qwen-Image-Edit-2511 successfully extends Qwen-Image's unique text rendering capabilities to image editing tasks, enabling precise text editing.
+[Qwen-Image-Edit-2511](https://huggingface.co/Qwen/Qwen-Image-Edit-2511) is the 20B editing counterpart to Qwen-Image. It is strongest at changing text, materials, lighting, viewpoint, or composition while reducing drift in regions that were not requested to change.

-Key Enhancements in Qwen-Image-Edit-2511:
-
- **Mitigate Image Drift**: Reduces unwanted changes in non-edited regions of the image.
- **Improved Character Consistency**: The model can perform imaginative edits based on an input portrait while preserving the identity and visual characteristics of the subject.
- **Multi-Person Consistency**: Enhanced consistency in multi-person group photos, enabling high-fidelity fusion of two separate person images into a coherent group shot.
- **Integrated LoRA Capabilities**: Selected popular community-created LoRAs are integrated directly into the base model, unlocking their effects without extra tuning (e.g., lighting enhancement, viewpoint generation).
- **Enhanced Industrial Design Generation**: Special attention to practical engineering scenarios, including batch industrial product design and material replacement for industrial components.
- **Strengthened Geometric Reasoning**: Stronger geometric reasoning capability for generating auxiliary construction lines for design or annotation purposes.
-
-For more details, please refer to the [official Qwen-Image-Edit-2511 HuggingFace page](https://huggingface.co/Qwen/Qwen-Image-Edit-2511), the [Blog](https://qwenlm.github.io/blog/qwen-image-edit-2511/), and the [Tech Report](https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen-Image/Qwen_Image.pdf).
+Choose it for identity-sensitive portrait edits, multi-person composition, typography replacement, and geometry-aware design work. It is substantially heavier than small specialist editors, and consistency is improved rather than guaranteed; evaluate untouched-region drift on the actual editing workload.

 ## 2. SGLang-diffusion Installation

@@ -7,13 +7,13 @@ metatags:
 import { DiffusionModelTags } from '/src/snippets/diffusion/model-tags.jsx';
 import { QwenImageDeployment } from '/src/snippets/diffusion/qwen-image-deployment.jsx';

-<DiffusionModelTags tags={["image", "text-to-image", "text rendering", "NVFP4"]} />
+<DiffusionModelTags tags={["image", "text-to-image", "bilingual typography", "complex layouts", "NVFP4"]} />

 ## 1. Model Introduction

-[Qwen-Image](https://huggingface.co/Qwen/Qwen-Image) is a text-to-image diffusion model developed by the Qwen team.
+[Qwen-Image](https://huggingface.co/Qwen/Qwen-Image) is a 20B text-to-image model built for strong prompt following and precise rendering of English and Chinese text. It is especially useful for posters, signs, diagrams, and dense layouts where typography and spatial relationships matter as much as general image quality.

-For more details, please refer to the [official Qwen-Image HuggingFace page](https://huggingface.co/Qwen/Qwen-Image), the [Blog](https://qwenlm.github.io/blog/qwen-image/), and the [Tech Report](https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen-Image/Qwen_Image.pdf).
+This page covers generation rather than editing: use Qwen-Image-Edit when an existing image, subject identity, or untouched region must be preserved. The full checkpoint is memory-heavy, while the validated ModelOpt NVFP4 release provides a supported low-precision deployment option with an expected quality tradeoff.

 ## 2. SGLang-diffusion Installation

@@ -1,36 +1,44 @@
 ---
 title: "Diffusion Cookbook"
-description: "Cookbook recipes for running diffusion models with SGLang"
+description: "Author and review deployment-focused diffusion model recipes for SGLang."
 metatags:
-    description: "Explore SGLang diffusion cookbook structure, categories, and contribution guidance for image and video generation recipes."
+    description: "SGLang diffusion cookbook structure, model-page standards, and contribution guidance."
 ---

 # SGLang Diffusion Cookbook

-<div style={{display: 'flex', gap: '8px'}}>
-  <a href="https://opensource.org/licenses/Apache-2.0"><img src="https://img.shields.io/badge/License-Apache_2.0-blue.svg" alt="License" /></a>
-  <a href="https://github.com/sgl-project/sglang/pulls"><img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg" alt="PRs Welcome" /></a>
-</div>
+The diffusion cookbook is a set of model-specific, validated deployment guides. Each page
+should let a reader answer three questions quickly: what the model is good at, which
+checkpoint and base topology to choose, and which optional features change performance,
+memory, or quality.

-Create a comprehensive cookbook for diffusion models in SGLang, demonstrating SGLang's performance advantages for image and video generation workloads.
+## What every model page includes

-## 🎯 What You'll Find Here
+1. A compact capability tag row using the shared `DiffusionModelTags` component.
+2. A short introduction that states the model's capability range, strongest use case, and
+   an important limitation or deployment tradeoff.
+3. Verified base launch recipes for the hardware actually tested.
+4. Matching request examples for every public task or checkpoint partition.
+5. Optional attention, quantization, caching, compile, and offload recipes with explicit
+   quality contracts and validation scope.

-This cookbook aggregates battle-tested SGLang recipes covering:
+Tags describe the model, not every runtime flag. Prefer `video + audio`, `multi-reference`,
+or `4–15 seconds` over generic labels such as `native`, `fast`, or `high quality`.

- **Models**: Mainstream Image and Video generation  Models
- **Use Cases**: Inference serving, deployment strategies
- **Hardware**: GPU and CPU configurations, optimization for different accelerators
- **Best Practices**: Configuration templates, performance tuning, troubleshooting guides
+## Keep the command picker small

-Each recipe provides step-by-step instructions to help you quickly implement SGLang solutions for your specific requirements.
+The command picker selects a runnable base recipe: hardware topology, checkpoint partition,
+request mode, and a validated placement profile. Independent feature knobs do not need to
+become picker dimensions.

-## 🚀 Quick Start
+Document orthogonal controls as feature overlays instead:

-1. Browse the recipe index above to find your model
-2. Follow the step-by-step instructions in each guide
-3. Adapt configurations to your specific hardware and requirements
-4. Join our community to share feedback and improvements
+| Feature class | Where it belongs | Required context |
+| --- | --- | --- |
+| Attention backend | Optional feature overlays | Default backend, precision/approximation contract, installation, measured hardware |
+| Online or pre-quantized weights | Optional feature overlays | Weight source, protected precision-sensitive layers, quality and memory tradeoff |
+| Cache-DiT and sampling controls | Request/sampling recipes | Quality level, incompatible placement modes, task-specific validation |
+| TP, Ulysses, Ring, FSDP, residency | Base picker only for verified cells | Exact GPU count, topology, memory, and latency evidence |

 For memory placement, prefer the unified
 [`--component-residency`](/docs/sglang-diffusion/api/cli#component-residency)
@@ -40,62 +48,25 @@ selector. Each component resolves to exactly one of `resident`,
 `--image-encoder-cpu-offload`, and `--vae-cpu-offload` remain supported by all
 recipes that already use them.

-The sglang diffusion cookbook directory structure are shown below:
+## Contributing a model

-```text Example
-docs/cookbook/diffusion/
-├── README.mdx             # Main cookbook (this file)
-├── Qwen-Image/            # Qwen-Image series docs
-│   ├── Qwen-Image.mdx
-│   └── Qwen-Image-Edit.mdx
-├── Wan/                   # Wan series docs
-│   ├── Wan2.1.mdx
-│   └── Wan2.2.mdx
-├── Z-Image/               # Z-Image series docs
-│   └── Z-Image-Turbo.mdx
-├── Ernie-Image/           # ERNIE-Image series docs
-│   └── Ernie-Image.mdx
-└── ...
+Use the repo-local `cookbook-add-model` skill and its
+`templates/diffusion-page.mdx.tmpl` template. The full category contract lives in
+`.claude/skills/cookbook-add-model/references/diffusion-authoring.md`.
+
+Before opening a PR, run:
+
+```bash Command
+node docs/scripts/check_cookbook_configs.mjs
+cd docs
+mint validate
+mint broken-links --check-anchors --check-redirects
 ```

-## 🤝 Contributing
+The static cookbook check requires every diffusion model page to use the shared tag widget,
+the standard introduction heading, 4–6 tags, and a substantive two-paragraph lead. Mintlify
+validation then catches MDX, navigation, and internal-link problems.

-We believe the best documentation comes from practitioners. Whether you've optimized SGLang for a specific model, solved a tricky deployment challenge, or discovered performance improvements, we encourage you to contribute your recipes!
-
-**💪How to Contribute**
-
- Comment below if interested (mention which role)
- Join discussion on implementation details
- Fork repo and work on assigned section
- Submit PR following SGLang cookbook standards
- Iterate based on review feedback
-
-**To contribute:**
-
-```shell Command
-# Fork the repo and clone locally
-git clone https://github.com/YOUR_USERNAME/sglang.git
-cd sglang
-
-# Create a new branch
-git checkout -b add-my-recipe
-
-# Add your recipe under docs/cookbook/diffusion/
-# Submit a PR!
-```
-
-## 📖 Resources
-
- [SGLang GitHub](https://github.com/sgl-project/sglang)
- [SGLang Documentation](/)
- [SGLang Diffusion Documentation](/docs/sglang-diffusion/index)
- [SLACK Channel](https://sgl-fru7574.slack.com/archives/C07GLLLESNR)
- [Community Slack/Discord](https://discord.gg/MpEEuAeb)
-
-## 📄 License
-
-This project is licensed under the Apache License 2.0 - see the [LICENSE](https://github.com/sgl-project/sglang/blob/main/LICENSE) file for details.
-
---
-
-**Let's build this resource together!** 🚀 Star the repo and contribute your recipes to help the SGLang community grow.
+For runtime concepts and platform support, see the
+[SGLang Diffusion documentation](/docs/sglang-diffusion/index) and
+[compatibility matrix](/docs/sglang-diffusion/compatibility_matrix).
@@ -7,12 +7,20 @@ metatags:

 import { DiffusionModelTags } from '/src/snippets/diffusion/model-tags.jsx';

-<DiffusionModelTags tags={["video", "text-to-video"]} />
+<DiffusionModelTags tags={["video", "text-to-video", "480p", "2B lightweight"]} />

-## 1. Model introduction
+## 1. Model Introduction

 [SANA-Video 2B 480p](https://huggingface.co/Efficient-Large-Model/SANA-Video_2B_480p_diffusers)
-is a text-to-video model with a native SGLang Diffusion pipeline.
+is a lightweight text-to-video model served through a native SGLang Diffusion
+pipeline. Its main advantage is deployment cost: at 2B parameters it serves
+480p video from a single GPU with a plain `sglang serve` invocation, no
+parallelism flags required.
+
+The released generation profile produces 832×480 output at 81 frames and
+16 FPS over 50 inference steps; a compact 17-frame, 8-step profile is covered
+by server CI for quick validation. Motion strength can be steered directly
+from the prompt with an optional `motion score: N.` suffix.

 | Model ID | Task | Default output |
 | --- | --- | --- |
@@ -6,32 +6,19 @@ metatags:

 import { DiffusionModelTags } from '/src/snippets/diffusion/model-tags.jsx';

-<DiffusionModelTags tags={["video", "realtime", "world model", "camera control", "two-stage"]} />
+<DiffusionModelTags tags={["world model", "720p video", "minute-scale", "6-DoF camera control", "realtime"]} />

 ## 1. Model Introduction

-[SANA-WM](https://huggingface.co/Efficient-Large-Model/SANA-WM_bidirectional) is an efficient open-source **world model** from NVLabs, trained natively for one-minute video generation. It is a **2.6B-parameter text+image-to-video (TI2V) diffusion transformer** that synthesizes **720p, minute-scale videos with precise 6-DoF camera control**, paired with an **LTX-2 refiner** for high-fidelity decoding. It builds on the [SANA](https://github.com/NVlabs/Sana) family — efficient high-resolution synthesis with a linear diffusion transformer.
+[SANA-WM](https://huggingface.co/Efficient-Large-Model/SANA-WM_bidirectional) is NVLabs' 2.6B text-and-image-to-video world model for 720p, minute-scale generation with explicit per-frame 6-DoF camera control. Its hybrid recurrent/softmax attention keeps long causal histories bounded, while an LTX-2 refiner supplies the detail that the fast Stage-1 world model does not produce on its own.

-SANA-WM ships in two checkpoints: a **bidirectional** checkpoint (dense, one-shot) and a **streaming** checkpoint (chunk-causal, autoregressive — generated chunk-by-chunk, reusing causal DiT state across chunks for bounded memory → long, even endless, clips). From a single first frame, a text prompt, and a camera trajectory, this cookbook covers **all three serving modes** SGLang exposes:
+Choose the dense checkpoint for the best bounded-clip quality and the streaming checkpoint for long-running or interactive control. Streaming and realtime trade global bidirectional context for bounded state and lower response latency; the realtime WebSocket path is not bit-identical to offline batch streaming.

- **(A) Dense bidirectional** (§4) — the `SANA-WM_bidirectional` checkpoint generated in one shot (no chunking) via **`SanaWMTwoStagePipeline`** over the standard **`/v1/videos`** HTTP API. Highest single-clip quality (full bidirectional attention + dense LTX-2 refiner); matches the NVlabs dense reference.
- **(B) Batch streaming** (§5) — the `SANA-WM_streaming` checkpoint generated chunk-by-chunk in one request via the same **`SanaWMTwoStagePipeline`** + `--streaming` over **`/v1/videos`**. This is SGLang's offline chunk-causal streaming path: the whole clip is produced chunk-by-chunk internally, then returned.
- **(C) Live realtime** (§6–7) — the streaming pipeline exposed as **`SanaWMRealtimePipeline`** over a **WebSocket API** at `/v1/realtime_video/generate`, so a browser/client streams camera-action events frame-by-frame and receives video chunks back in real time. Realtime uses the same streaming checkpoint, but the incremental session path is not bit-identical to offline batch streaming.
-
-All three modes share the camera action DSL (§8) and the configuration knobs (§9). Modes (B) and (C) share the streaming checkpoint and the chunk-causal pipeline.
-
-**Key features** (per the official model):
-
- **Hybrid Linear Attention** — frame-wise Gated DeltaNet (GDN) recurrent blocks combined with softmax attention (every 4th layer, block indices {3,7,11,15,19}) for memory-efficient long-context modeling.
- **Dual-Branch Camera Control** — independent main and camera branches (UCPE + PRoPE) for precise per-frame 6-DoF trajectory adherence.
- **Two-Stage Pipeline** — an LTX-2 long-video refiner on top of Stage-1 latents for quality and temporal consistency.
-
-In the **streaming / realtime** configuration this becomes a low-latency, interactive pipeline:
-
- **Stage-1 chunk-causal DiT** — the streaming path carries a **per-block KV cache** (recurrent GDN state + a softmax K/V window) across chunks; bounded memory means it scales to long / endless sequences. Stage-1 is intentionally coarse.
- **LTX-2 streaming refiner** — refines each Stage-1 latent chunk block-by-block with a **sink + sliding-history KV cache** (required for sharp output).
- **Causal LTX-2 VAE** — decodes latents chunk-by-chunk with a carried conv-cache for seam-free frames.
- **Camera control** — drive the camera with a compact **WASD/IJKL** action DSL (move with WASD, look with IJKL; see §8) — supplied at request time on the `/v1/videos` paths, or pushed over the WebSocket at init / as live per-chunk events on the realtime path (see §7).
+| Serving mode | Checkpoint and API | Best fit | Tradeoff |
+| --- | --- | --- | --- |
+| Dense bidirectional | `SANA-WM_bidirectional` via `/v1/videos` | Highest single-clip quality | Bounded one-shot generation; full attention cost |
+| Batch streaming | `SANA-WM_streaming` via `/v1/videos` | Long clips returned as one job | Chunk-causal context rather than global bidirectional context |
+| Live realtime | `SANA-WM_streaming` via WebSocket | Interactive camera events and incremental output | Stateful session; not bit-identical to batch streaming |

 **Architecture & components**

@@ -44,7 +31,7 @@ In the **streaming / realtime** configuration this becomes a low-latency, intera
 | Refiner | LTX-2 Stage-2 distilled; ~41 GB |
 | Output | up to 720p (704×1280) @ 16 fps, minute-scale |

-For more details, see the [SANA-WM paper (arXiv)](https://arxiv.org/abs/2605.15178), the [SANA project page](https://nvlabs.github.io/Sana/), the [NVlabs/Sana GitHub](https://github.com/NVlabs/Sana), and the [SANA-WM_bidirectional model card](https://huggingface.co/Efficient-Large-Model/SANA-WM_bidirectional) (Apache-2.0).
+For architecture and training details, see the [SANA-WM paper](https://arxiv.org/abs/2605.15178) and [model card](https://huggingface.co/Efficient-Large-Model/SANA-WM_bidirectional) (Apache-2.0).

 ## 2. Installation

@@ -7,24 +7,13 @@ metatags:
 import { DiffusionModelTags } from '/src/snippets/diffusion/model-tags.jsx';
 import { Wan21Deployment } from '/src/snippets/diffusion/wan21-deployment.jsx';

-<DiffusionModelTags tags={["video", "text-to-video", "image-to-video", "LoRA", "text rendering"]} />
+<DiffusionModelTags tags={["video", "text-to-video", "image-to-video", "1.3B / 14B", "bilingual text"]} />

 ## 1. Model Introduction

-[Wan2.1 series](https://github.com/Wan-Video/Wan2.1) is an open and advanced suite of large-scale video generative models from Wan-AI.
+[Wan2.1](https://github.com/Wan-Video/Wan2.1) is a broad open video family covering text-to-video and image-to-video across 1.3B and 14B checkpoints. Its practical strengths are motion-rich generation, temporal consistency, and readable Chinese/English text, with 480p and 720p variants for different quality and memory targets.

-Key characteristics:
-
- **State-of-the-art video quality**: Consistently outperforms many open-source and commercial video models on internal and public benchmarks, especially for motion richness and temporal consistency.
- **Consumer GPU friendly**: The T2V-1.3B variant can generate 5-second 480P videos on consumer GPUs with modest VRAM requirements.
- **Multi-capability suite**: Supports Text-to-Video (T2V), Image-to-Video (I2V), video editing, text-to-image, and video-to-audio generation.
- **Robust text rendering**: First-generation Wan model capable of generating both Chinese and English text in videos with strong readability.
- **Powerful Wan-VAE**: A 3D causal VAE that encodes/decodes long 1080P videos while preserving temporal information, enabling efficient high-resolution video generation.
-
-For more details, refer to the official Wan2.1 resources:
-
- **GitHub**: [Wan-Video/Wan2.1](https://github.com/Wan-Video/Wan2.1)
- **Hugging Face collection**: [Wan-AI Wan2.1](https://huggingface.co/Wan-AI/Wan2.1-T2V-14B)
+Choose the 1.3B T2V model for consumer-GPU experiments and the 14B models when quality matters more than footprint. Wan2.1 is a dense DiT family; for timestep-specialized MoE capacity or the unified 5B TI2V path, use Wan2.2 instead.

 ## 2. SGLang-diffusion Installation

@@ -7,20 +7,13 @@ metatags:
 import { DiffusionModelTags } from '/src/snippets/diffusion/model-tags.jsx';
 import { Wan22Deployment } from '/src/snippets/diffusion/wan22-deployment.jsx';

-<DiffusionModelTags tags={["video", "text-to-video", "image-to-video", "TI2V", "MoE"]} />
+<DiffusionModelTags tags={["video", "T2V / I2V / TI2V", "MoE", "720p @ 24 fps", "cinematic motion"]} />

 ## 1. Model Introduction

-[Wan2.2 series](https://github.com/Wan-Video/Wan2.2) are the most popular and open and advanced large-scale video generative models.
+[Wan2.2](https://github.com/Wan-Video/Wan2.2) extends the Wan family with timestep-specialized Mixture-of-Experts models and a unified 5B TI2V checkpoint. It targets cinematic composition, lighting, and complex motion while supporting text-to-video, image-to-video, and hybrid text/image conditioning.

-This generation delivers comprehensive upgrades across the board:
-
- **Effective MoE Architecture**: Introduces a Mixture-of-Experts (MoE) architecture into video diffusion models. By separating the denoising process cross timesteps with specialized powerful expert models, this enlarges the overall model capacity while maintaining the same computational cost.
- **Cinematic-level Aesthetics**: Incorporates meticulously curated aesthetic data, complete with detailed labels for lighting, composition, contrast, color tone, and more. This allows for more precise and controllable cinematic style generation, facilitating the creation of videos with customizable aesthetic preferences.
- **Complex Motion Generation**: Trained on a significantly larger data, with +65.6% more images and +83.2% more videos. This expansion notably enhances the model's generalization across multiple dimensions such as motions, semantics, and aesthetics, achieving TOP performance among all open-sourced and closed-sourced models.
- **Efficient High-Definition Hybrid TI2V**: Open-sources a 5B model built with our advanced Wan2.2-VAE that achieves a compression ratio of 16×16×4. This model supports both text-to-video and image-to-video generation at 720P resolution with 24fps and can also run on consumer-grade graphics cards like 4090. It is one of the fastest 720P@24fps models currently available, capable of serving both the industrial and academic sectors simultaneously.
-
-For more details, please refer to the [official Wan2.2 GitHub Repository](https://github.com/Wan-Video/Wan2.2).
+Choose the A14B MoE checkpoints for maximum T2V or I2V capacity and the 5B TI2V model for a smaller unified 720p-at-24-fps path. MoE reduces active compute relative to total capacity but does not remove the memory cost of loading expert weights, so hardware selection still matters.

 ## 2. SGLang-diffusion Installation

@@ -7,23 +7,13 @@ metatags:
 import { DiffusionModelTags } from '/src/snippets/diffusion/model-tags.jsx';
 import { ZImageTurboDeployment } from '/src/snippets/diffusion/zimage-turbo-deployment.jsx';

-<DiffusionModelTags tags={["image", "text-to-image", "turbo", "8-step"]} />
+<DiffusionModelTags tags={["image", "text-to-image", "6B S3-DiT", "8-step", "bilingual text"]} />

 ## 1. Model Introduction

-[Z-Image](https://github.com/Tongyi-MAI/Z-Image) is a powerful and highly efficient image generation model family with 6B parameters, developed by Tongyi-MAI. It adopts a Scalable Single-Stream DiT (S3-DiT) architecture, where text, visual semantic tokens, and image VAE tokens are concatenated at the sequence level to serve as a unified input stream, maximizing parameter efficiency compared to dual-stream approaches.
+[Z-Image-Turbo](https://huggingface.co/Tongyi-MAI/Z-Image-Turbo) is a distilled 6B single-stream DiT for fast text-to-image generation. It reaches its intended operating point in 8 function evaluations and is particularly strong at photorealistic scenes, prompt adherence, and English/Chinese text rendering.

-[Z-Image-Turbo](https://huggingface.co/Tongyi-MAI/Z-Image-Turbo) is a distilled version of Z-Image that matches or exceeds leading competitors with only 8 NFEs (Number of Function Evaluations). It is powered by two core techniques: **Decoupled-DMD** (few-step distillation) and **DMDR** (fusing DMD with Reinforcement Learning).
-
-**Key Features:**
-
- **Sub-second Inference Latency**: Achieves sub-second inference on enterprise-grade H800 GPUs and fits comfortably within 16GB VRAM consumer devices
- **Photorealistic Image Generation**: Excels in high-quality photorealistic image generation with rich aesthetics
- **Bilingual Text Rendering**: Supports accurate bilingual text rendering in both English and Chinese
- **Robust Instruction Adherence**: Strong prompt following and instruction adherence capabilities
- **#1 Open-Source Model**: Ranked 8th overall and #1 among open-source models on the [Artificial Analysis Text-to-Image Leaderboard](https://artificialanalysis.ai/image/leaderboard/text-to-image)
-
-For more details, please refer to the [Z-Image-Turbo HuggingFace page](https://huggingface.co/Tongyi-MAI/Z-Image-Turbo), the [GitHub repository](https://github.com/Tongyi-MAI/Z-Image), and the [technical report (arXiv)](https://arxiv.org/abs/2511.22699).
+Choose it when latency and a relatively small deployment footprint matter more than the editability or maximum capacity of larger image models. It is a generation-only checkpoint; use Qwen-Image-Edit or FLUX.2 when the request includes source images or identity-preserving edits.

 ## 2. SGLang-diffusion Installation