# LightX2V: Unified Inference Framework for AI Video Generation > LightX2V is an Apache-licensed Python framework from ModelTC that handles inference for text-to-video, image-to-video, text-to-image, and image-editing tasks across many state-of-the-art models including Wan 2.2, MiniMax H3, and SwiftVR. Version 0.5.0, released in September 2026, adds support for NVFP4 quantization, disaggregated deployment, and a Robotic Operating System integration for action-generating world models. **ModelTC/LightX2V** — Project brief: Lightweight Image Video Action Generation Inference Framework. February 27, 2026: We now support FP8 and NVFP4 quantization for autoregressive video generation models (Self Forcing)! - Repository: https://github.com/ModelTC/LightX2V - Website: https://x2v.light-ai.top/generate - Stars: 2,867 · Forks: 276 - Language: Python - License: Apache-2.0 - Published: 2026-08-04 · Updated: 2026-08-18 · Language: en - Canonical page: https://hysenlabs.com/projects/modeltc-lightx2v ## What LightX2V Is and Who It Targets LightX2V stands for the transformation of different input modalities into visual output. The README explicitly defines this: X represents the input (text or image) and V represents the vision output. The framework is not a model: it is an inference layer that sits in front of multiple independently developed generative models and provides a common interface, quantization pipeline, and deployment infrastructure. The primary target is engineers who want to run video generation in production rather than experimenting with individual model scripts. LightX2V covers text-to-video (T2V), image-to-video (I2V), text-to-image (T2I), and image editing (I2I). Its model support extends to MiniMax H3, which adds native synchronized stereo audio, covering T2AV, I2AV, L2AV, FL2AV, and Ref2AV workflows. The README links to an online demo at the LightX2V Studio and to HuggingFace model repositories under the `lightx2v` namespace. ## Model Support and Recent Additions The README provides a running news section that tracks model additions. As of September 22, 2026, SwiftVR support and optimization were added. On September 20, 2026, day-0 support for Qwen-Image-2.1 was added. MoGe-3-level geometric detail is unrelated; LightX2V focuses on generative video, not geometry estimation. The MiniMax H3 integration is the most feature-complete in the current codebase. It covers five audio-video workflows (T2AV, I2AV, L2AV, FL2AV, Ref2AV), model-level and block-level offloading, tensor and sequence parallelism, quantized DiT inference, and feature caching. The README also describes a MiniMax-H3 T2VA Prompt Rewriter LoRA, fine-tuned from Qwen3.6-27B to transform concise prompts into structured H3-oriented multimodal descriptions. For Wan 2.2, LightX2V provides an NVFP4 quantization-aware step distillation variant with sparse attention designed for the Blackwell architecture. On a single RTX 5090 GPU, the README states this achieves over 50x speedup. The pyproject.toml shows the current version as 0.5.0, and a release on 2026-09-10 confirms the tag. ## Installing LightX2V and Running the First Inference The project requires Python 3.10 or newer. The README includes a code style check as part of setup: ```bash pip install ruff pre-commit pre-commit run --all-files ``` The main installation uses the requirements.txt file, which is the single source of truth according to the file header: ```bash git clone https://github.com/ModelTC/LightX2V.git cd LightX2V ``` The requirements.txt covers diffusers, transformers, torch, torchvision, torchaudio, accelerate, safetensors, peft, and many others. After installation, scripts for specific models are under the scripts/ directory. Beginner examples are in `examples/BeginnerGuide/` and per-model examples include paths like `examples/minimax_h3/`, `examples/wan/`, `examples/seedvr/`, and others listed in the repository structure. The project also provides Docker images. The README links to a Docker Hub repository at `lightx2v/lightx2v`. A Dockerfile is not included in the top-level entries, but the repository has a dockerfiles/ directory for this purpose. ## Quantization Options: FP8, NVFP4, W8A8, and LoRA Distillation LightX2V offers several quantization strategies, documented across the README and blog posts linked from it. For autoregressive video generation models using the Self Forcing approach, the README highlights FP8 and NVFP4 support added in February 2026. These target NVIDIA Blackwell hardware primarily. For Wan 2.2 on a single RTX 5090, the NVFP4 quantization-aware step distillation with sparse attention achieves over 50x speedup according to the README. This is the most aggressive optimization in the current lineup and is hardware-specific. For Apple Silicon users, the Cider SDK within Mano-P (a separate project) handles MLX-based quantization; LightX2V does not target Apple Silicon. The LoRA distillation approach reduces inference steps. The LightLingBot-Video 4-step distilled LoRA, released on 2026-07-28 and described in the README, enables T2V, T2I, and I2V generation in four inference steps without classifier-free guidance. The MiniMax-H3 Turbo 8-step and 4-step LoRAs, released in August 2026, follow the same pattern for H3. These are available on HuggingFace under the `lightx2v` namespace. ## Disaggregated Deployment and ROS Integration Two architectural features distinguish LightX2V from simpler inference wrappers. First, disaggregated deployment separates the prefill and decode stages of diffusion model inference across different GPU nodes, addressing memory and throughput bottlenecks that appear at scale. The README references a blog post from April 10, 2026, covering this. Second, the LightX2V ROS (Robotic Operating System) integration, described in a July 23, 2026 blog post, closes the loop for action-generating world models. This connects video generation with robotic action planning, which is a direction the README explicitly names as a focus area. These capabilities place LightX2V in a category beyond personal workstation video generation. The disaggregated deployment and ROS integration are production and robotics features. Engineers who only need to generate a few clips locally will not benefit from this complexity, but teams building video generation into production pipelines at scale will find them relevant. ## Limitations and Dependency Weight The requirements.txt and pyproject.toml paint a picture of a framework with broad ambitions and a correspondingly heavy dependency footprint. The default dependencies include not just deep learning packages but also RabbitMQ bindings (aio-pika), Redis (redis==6.4.0), PostgreSQL (asyncpg), a JWT library, Alibaba Cloud authentication (alibabacloud_dypnsapi20170525), and Alibaba Object Storage (tos). These are service dependencies for the production deployment path, not for basic inference. Installing LightX2V in a constrained environment requires either careful selective installation or accepting a large dependency set. The pyproject.toml marks the development status as Beta (4). Some dependencies are pinned to exact versions (redis==6.4.0), which may create conflicts with other packages in an existing environment. Model support also evolves quickly. The news section in the README lists changes week by week, and what is available in the scripts/ directory may differ from what the latest commit mentions. The safe verification step before using any specific model is to check whether its scripts directory exists and contains working configuration files. ## LightX2V Compared to Running Model Scripts Directly The main alternative to LightX2V is running the official inference scripts for each model independently. Wan 2.2, MiniMax H3, and other models each have their own repositories with their own inference code, quantization instructions, and dependency sets. Using them directly gives the most direct path to a single model with no intermediary. LightX2V trades that simplicity for breadth. A team that uses three different video models no longer maintains three separate environments and inference scripts; they maintain one. The framework also adds features that individual model repositories do not provide by default: disaggregated deployment, LoRA distillation, feature caching, and the block-level offloading needed to run large models on single GPUs. Whether the trade-off is worth it depends on how many models a team needs and whether they are building for production or experimentation. ## Conclusion LightX2V is the right choice for engineers who need a single inference stack that covers multiple video generation models, quantization formats, and deployment targets including Docker, disaggregated GPU setups, and specialized hardware like T-head PPU and iluvatar. It is not the right choice for teams who want a simple wrapper around one model: the dependency list is extensive and includes CUDA-specific packages, a RabbitMQ connector, and Redis, so the setup overhead is real. Before committing, verify that the specific model you need is supported in the current release by checking the scripts/ directory and the changelog, since model support evolves rapidly and some entries in the news section may not yet be in a tagged release. ## FAQ ### What is LightX2V? LightX2V is an open-source Python inference framework for video and image generation. It provides a unified interface for running multiple state-of-the-art video models including Wan 2.2, MiniMax H3, and SwiftVR, with support for quantization, LoRA distillation, disaggregated deployment, and Docker. ### How do I use LightX2V? Clone the repository, install dependencies from requirements.txt, then run the model-specific script from the scripts/ directory. The examples/BeginnerGuide/ folder provides a developer quick start guide, and per-model examples are in subdirectories like examples/wan/ and examples/minimax_h3/. ### What is a LightX2V LoRA and what does it do? LightX2V LoRAs are step-distillation adapters that reduce the number of inference steps needed to generate video. For example, the LightLingBot-Video LoRA and the MiniMax-H3 Turbo LoRA allow generation in four or eight steps instead of the full number, with no classifier-free guidance, reducing latency significantly. ### What does LightX2V do compared to running a single model's inference script? LightX2V provides a unified inference framework that covers multiple video generation models with a common interface, quantization pipeline, and deployment infrastructure. Running a single model's script gives a simpler setup but requires separate environments and code for each model; LightX2V trades that simplicity for breadth, adding features like disaggregated deployment, LoRA distillation, and block-level offloading. ## Sources - [Official documentation](https://x2v.light-ai.top/generate) - [Official README](https://github.com/ModelTC/LightX2V#readme) - [Project repository](https://github.com/ModelTC/LightX2V) - [Release notes](https://github.com/ModelTC/LightX2V/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/modeltc-lightx2v