Wan 2.7 Open Source: What Is Actually Open, Where to Get It, and How to Run It Locally

You search "wan 2.7 open source."

One page says yes. Another says unconfirmed. A Reddit thread says "open weights, not open source." A platform page dodges the question entirely and just shows you a pricing table.

Meanwhile, you are sitting there trying to answer one practical question:

Can I run this thing on my own machine, or do I have to pay someone else?

That is the question this page actually answers.

The Short Answer

Yes, Wan 2.7 is open-weight. The model parameters are publicly available. You can download them, run them locally, and use them in ComfyUI today. The video model, the image model, and the image-to-video pipeline all have downloadable checkpoints on HuggingFace and ModelScope.

The longer answer is that "open-weight" is not the same as "open source" in the traditional OSI sense. Training code, dataset details, and the full training pipeline are not published. What IS published is enough to self-host, fine-tune, and build on top of.

For most people asking this question, that is already the answer they need.

What "Open Source" Actually Means Here — And What Is Still Closed

The Wan model series has been released as open weights since Wan 2.2. That tradition continues with Wan 2.7, but the picture has more pieces now.

Here is what is publicly available as of May 2026:

If your goal is inference, fine-tuning, or building a workflow around the model, the open-weight release gives you what you need.

If your goal is to reproduce the training run from scratch, that is not possible with what is currently published.

Apache 2.0: What the License Actually Lets You Do

Knowing what is published is step one. Step two is knowing what you are actually allowed to do with it.

The Wan 2.7 model weights are released under the Apache 2.0 license, the same license that covered Wan 2.2.

This matters for three reasons.

First, commercial use is allowed. You can use Wan 2.7 outputs in commercial projects without a separate licensing fee.

Second, modification and redistribution are permitted. You can fine-tune the model, create LoRA adapters, and distribute your modifications.

Third, there is no share-alike requirement. Unlike GPL-style licenses, Apache 2.0 does not force you to open-source your own modifications or the outputs you produce.

The practical takeaway: if you are building a product, a service, or a creative pipeline around Wan 2.7, the license does not get in your way.

Where to Get the Weights: HuggingFace, GitHub, and ModelScope

There are three primary channels for getting the model weights.

HuggingFace: Wan-AI

The official HuggingFace organization hosts all the Wan 2.7 model variants. This is the most accessible path for most users.

Key repositories:

• Wan-AI/Wan2.7-T2V-14B — Text-to-Video, the main 14B video generation model
• Wan-AI/Wan2.7-I2V-14B — Image-to-Video
• Wan-AI/Wan2.7-Image — Text-to-Image and Image Editing

You can download these with the huggingface_hub Python library or through the HuggingFace website directly.

GitHub: Wan-Video

The GitHub organization at github.com/Wan-Video hosts the inference code, example scripts, and documentation. As of May 2026, it contains four repositories covering video generation, image generation, and related tooling.

This is where you go for the code that runs the model, not the model weights themselves.

ModelScope

Alibaba's ModelScope platform also carries the official Wan 2.7 model weights. This is often the fastest download path for users in Asia, and it is the channel Alibaba uses for many of its first-party model releases.

What Hardware You Actually Need — Check This Before You Download 30GB

This is the part most people need before they start downloading.

Wan 2.7 is a 14-billion-parameter model. It is not a lightweight model you can run on an entry-level GPU.

The practical minimum for a usable video workflow is 24GB VRAM.

If you have 16GB or less, GGUF quantized versions exist and can produce shorter clips, but expect longer generation times and lower quality.

If you are on a Mac, the MLX conversion path exists but is not yet a first-class experience. Expect it to be slower and less polished than the CUDA path.

Disk Space

The full set of Wan 2.7 checkpoints takes roughly 30-40GB per variant. If you download T2V, I2V, and Image models, budget at least 100GB of free disk space.

Two Paths to Run Wan 2.7 Locally: ComfyUI or Python

There are two practical paths. Choose based on whether you need a full workflow UI or just want to run inference.

Path A: ComfyUI (Recommended for Most Users)

ComfyUI is the fastest path to a working Wan 2.7 setup. Partner nodes from Kijai, ComfyUI-WanVideoWrapper, and others handle the model loading, prompting, and output.

The high-level steps:

1. Install ComfyUI if you have not already. The portable Windows version or the manual install both work.
2. Install ComfyUI Manager to simplify custom node installation.
3. Install the Wan 2.7 custom nodes through ComfyUI Manager. Search for "WanVideo" or "Wan 2.7."
4. Download the model weights from HuggingFace and place them in ComfyUI/models/wan/ (or the path your chosen node expects).
5. Load a workflow JSON — the node authors typically provide example workflows you can drag and drop into ComfyUI.
6. Generate.

The first generation will be slower as the model compiles. Subsequent generations reuse the loaded model.

If you want a detailed step-by-step walkthrough with screenshots, read the Wan 2.7 ComfyUI Local Guide.

Path B: Direct Python Inference

If you prefer working directly with Python and do not need a node-based UI, the Wan-Video GitHub repository provides inference scripts.

The basic flow:

git clone https://github.com/Wan-Video/Wan2.7
cd Wan2.7
pip install -r requirements.txt
python generate.py --prompt "your prompt" --model_path /path/to/weights

This path gives you more control over the pipeline but requires comfort with Python environments, CUDA setup, and command-line workflows.

Quick Sanity Check Before You Commit

Before downloading 30GB+ of model weights, run this quick test:

1. Check your VRAM: nvidia-smi on Linux/WSL, or Task Manager on Windows
2. Make sure CUDA is installed and visible to Python: python -c "import torch; print(torch.cuda.is_available())"
3. Try downloading a smaller Wan model (like Wan 2.2) first to verify your download pipeline works
4. Join the ComfyUI Discord or relevant Reddit threads — the community often spots issues before the documentation catches up

If any of these steps fail, fix the environment first before spending time on the full download.

Open Source vs API: Which One Should You Use?

This is the real decision most people face.

Start with the API if you want to test Wan 2.7's output quality before committing to local setup. The per-generation cost is low enough that testing 10-20 prompts will tell you whether the model fits your use case.

Move to local if you are generating more than 50 videos per month, you need privacy guarantees, or you plan to fine-tune.

Use both if you prototype on the API and move production workloads to local. Many teams do exactly this.

If you want to try the hosted path first, start on wan27.org and compare the output against your quality bar. If the model works for your use case, then invest the time in local setup.

What About Wan 2.7 Image Pro?

Separate from the main open-weight release, there is a product called Wan 2.7 Image Pro that Alibaba offers through its cloud platform.

This is a hosted, higher-capability variant that is not available as an open-weight download. It supports higher resolutions, more complex editing workflows, and additional control modes that are gated behind the cloud API.

If you see references to "Image Pro" in documentation or search results, know that this is the closed, hosted tier. The open-weight image model is the standard Wan2.7-Image checkpoint, which still supports text-to-image generation and image editing, just without the Pro-tier enhancements.

FAQ

Is Wan 2.7 fully open source?

It is open-weight under Apache 2.0. The model parameters, inference code, and documentation are public. The training code, training dataset, and full technical report are not. For most practical purposes — running, fine-tuning, building on top — the answer is yes.

Can I use Wan 2.7 commercially?

Yes. The Apache 2.0 license permits commercial use, modification, and redistribution. You can build a product or service on top of Wan 2.7 without additional licensing.

Is Wan 2.7 image generation open source?

Yes. The Wan 2.7 Image model (Wan2.7-Image) is available as open weights on HuggingFace and ModelScope, under the same Apache 2.0 license. The "Image Pro" variant is a separate, hosted-only product.

What is the difference between Wan 2.7 open source and Wan 2.2 open source?

Wan 2.2 was released under Apache 2.0 as a single video generation model. Wan 2.7 extends the open-weight release to cover video, image, image-to-video, image editing, and video editing — all under the same license. Wan 2.7 also added first-frame and last-frame control, reference-to-video, and native 1080p output.

Can I run Wan 2.7 without a GPU?

Technically yes, using CPU-only inference or Apple Silicon MLX, but it will be extremely slow. A 5-second video on CPU can take hours. For any practical workflow, a GPU with at least 16GB VRAM (ideally 24GB) is the realistic minimum.

Is Wan 2.7 on HuggingFace the same as the API version?

The base model is the same. API providers may apply additional optimizations, quantization, or serving infrastructure that makes generation faster, but they are running the same underlying weights that you can download.

Where can I find Wan 2.7 GGUF versions?

GGUF-quantized versions of Wan 2.7 are available on HuggingFace from community contributors. Search for "Wan2.7-GGUF" on HuggingFace. These quantized versions reduce VRAM requirements at the cost of some output quality.

Bottom Line

Wan 2.7 is open enough to run on your own hardware, for free, with a commercially permissive license.

The weights are on HuggingFace. The code is on GitHub. The community has already built ComfyUI nodes that make local deployment straightforward.

What is not open — the training pipeline and dataset — matters for researchers. But for creators, builders, and teams who just need a capable AI video model they can control, the open-weight release already delivers.

If you want to test the model before committing to local setup, start with the hosted workflow on wan27.org. If you want to go deeper into local deployment, read the Wan 2.7 ComfyUI Local Guide for the step-by-step walkthrough.