Sana

Generates high-resolution images (up to 4K) from text prompts using SanaTransformer2DModel, a Linear DiT architecture that implements O(N) complexity attention instead of standard quadratic attention. The pipeline encodes text via Gemma-2-2B, processes latents through linear transformer blocks, and decodes via DC-AE (32× compression). This linear attention mechanism enables efficient processing of high-resolution spatial latents without the memory quadratic scaling of standard transformers.

Generates images in a single neural network forward pass using SANA-Sprint, a distilled variant of the base SANA model trained via knowledge distillation and reinforcement learning. The model compresses multi-step diffusion sampling into one step by learning to directly predict high-quality outputs from noise, eliminating iterative denoising loops. This is implemented through specialized training objectives that match the output distribution of multi-step teachers.

Integrates SANA models into ComfyUI's node-based workflow system, enabling visual composition of generation pipelines without code. Custom nodes wrap SANA inference, ControlNet, and sampling operations as draggable nodes that can be connected to build complex workflows. Integration handles model loading, VRAM management, and batch processing through ComfyUI's execution engine.

Provides Gradio-based web interfaces for interactive image and video generation with real-time parameter adjustment. Demos include sliders for guidance scale, seed, resolution, and other hyperparameters, with live preview of outputs. The framework includes pre-built demo scripts that can be deployed as standalone web apps or embedded in larger applications.

Implements quantization strategies (INT8, FP8, NVFp4) to reduce model size and inference latency for deployment. The framework supports post-training quantization via PyTorch quantization APIs and custom quantization kernels optimized for SANA's linear attention. Quantized models maintain quality while reducing VRAM by 50-75% and accelerating inference by 1.5-3×.

Integrates with HuggingFace Model Hub for centralized model distribution, versioning, and checkpoint management. Models are published as HuggingFace repositories with automatic configuration, tokenizer, and checkpoint handling. The framework supports model card generation, version control, and seamless loading via HuggingFace transformers/diffusers APIs.

Provides Docker configurations for containerized SANA deployment with pre-installed dependencies, model checkpoints, and inference servers. Dockerfiles include CUDA runtime, PyTorch, and optimized inference configurations. Containers can be deployed to cloud platforms (AWS, GCP, Azure) or on-premises infrastructure with consistent behavior across environments.

Implements a hierarchical YAML configuration system for managing training, inference, and model hyperparameters. Configurations support inheritance, variable substitution, and environment-specific overrides. The framework validates configurations against schemas and provides clear error messages for invalid settings. Configs control model architecture, training objectives, sampling strategies, and deployment settings.

Generates videos from text or images using SanaVideoTransformer3DModel, which extends the 2D linear transformer with block-causal linear attention for temporal dimension. The architecture processes video frames as 3D latent sequences where attention is causal along the time axis (each frame only attends to past frames) while maintaining linear complexity. This enables efficient multi-frame generation with temporal consistency without quadratic memory scaling across frame sequences.

Encodes images into highly compressed latent representations using AutoencoderDC, achieving 32× spatial compression (vs 8× in Stable Diffusion's VAE). The DC-AE architecture is optimized for reconstruction quality at extreme compression ratios, enabling diffusion to operate on much smaller latent spaces. The framework supports both DC-AE-Full (higher quality) and DC-AE-Lite (faster decoding) variants, with external checkpoint management via HuggingFace Hub integration.

Implements flexible diffusion sampling via Flow Matching schedulers that control the noise-to-signal trajectory during generation. The framework supports multiple scheduler types (linear, exponential, custom) configured via YAML, allowing fine-tuning of generation quality vs speed tradeoffs. Schedulers control timestep sequences, noise schedules, and guidance scaling, enabling both standard multi-step sampling and optimized paths for one-step models.

Generates images at arbitrary resolutions up to 4K (4096×4096) by leveraging linear attention's O(N) complexity and DC-AE's 32× compression. The framework supports dynamic resolution handling through latent padding/cropping and aspect ratio preservation, enabling generation at native target resolutions rather than fixed sizes. Multi-scale training enables the same model to generate across resolution ranges without separate model variants.

Integrates ControlNet modules to guide image generation using spatial constraints (edge maps, depth, pose, segmentation). The framework loads ControlNet checkpoints compatible with HuggingFace Diffusers format and applies control conditioning during the diffusion process. Control signals are encoded and injected into transformer blocks, enabling precise spatial control while maintaining text-prompt guidance through classifier-free guidance.

Implements distributed training via PyTorch Distributed Data Parallel (DDP) and Fully Sharded Data Parallel (FSDP) for scaling across multiple GPUs and nodes. The framework handles gradient synchronization, model sharding, and checkpoint management automatically. FSDP enables training of larger models by sharding parameters, gradients, and optimizer states across devices, while DDP provides simpler data parallelism for smaller models.

Enables efficient model adaptation through Low-Rank Adaptation (LoRA) that trains only small rank-decomposed matrices instead of full model parameters. LoRA modules are inserted into transformer blocks and can be trained on custom datasets with minimal memory overhead. The framework supports LoRA merging into base model weights and composition of multiple LoRA adapters for different styles or domains.

Provides complete training pipeline for SANA-Video models with specialized loss functions enforcing temporal consistency across frames. Training uses block-causal attention masking to ensure causality, and includes optical flow or perceptual losses to maintain smooth motion and appearance consistency. The framework supports both text-to-video and image-to-video training with configurable frame counts and temporal sampling strategies.