# Stand-In controls identity in video generation by training one percent of the weights

> Stand-In is a CVPR 2026 research framework that keeps a subject's identity stable in generated video by training a small adapter on top of a frozen text-to-video model. The weights and inference code are open, the training code is not, and the face swapping feature is explicitly labelled experimental.

**WeChatCV/Stand-In** — [CVPR2026 🎉] Stand-In is a lightweight, plug-and-play framework for identity-preserving video generation.

- Repository: https://github.com/WeChatCV/Stand-In
- Stars: 794 · Forks: 50
- Language: Python
- License: Apache-2.0
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/wechatcv-stand-in

## One percent of the parameters, on top of a frozen base model

Stand-In is described as a lightweight, plug-and-play framework for identity-preserving video generation, accepted at CVPR 2026. The technical claim is specific: by training only 1% additional parameters compared to the base video generation model, the authors report state-of-the-art results in both Face Similarity and Naturalness, outperforming various full-parameter training methods.

That framing explains the architecture. Rather than fine-tuning a text-to-video model, Stand-In adds a small set of trainable parameters, 153M in the v1.0 release, and leaves the base model alone. The base is Wan2.1-14B-T2V, the 14 billion parameter text-to-video model, and the open weights are published as Stand-In_Wan2.1-T2V-14B_153M_v1.0 on the Hugging Face Hub under BowenXue/Stand-In.

The paper is on arXiv as 2508.07901, the project page is stand-in.tech, and the licence is Apache-2.0.

The claim to scrutinise is the identity consistency one. The README reports it in terms of similarity and naturalness metrics against a reference image, and the results section shows reference image, prompt and generated video side by side. A gallery of examples is evidence that it works on some inputs, not a measurement of how often it holds.

## The repository is inference code, not a training recipe

The tree at the repository root is the clearest statement of what is and is not open. There are directories for models, pipelines, preprocessor, prompters, schedulers, lora, trainers, distributed, vram_management and utils, alongside the top level entry points app.py, infer.py, infer_face_swap.py, infer_with_lora.py, infer_with_vace.py and wan_loader.py, and a download_models.py script.

What is missing is as telling as what is there. The todo list has three checked boxes for the released inference script and the open weights for Wan2.1-14B-T2V and Wan2.2-T2V-A14B, and one unchecked box for the training dataset, the data preprocessing scripts and the training code. The trainers directory exists in the tree, but the checklist says the training recipe has not been released.

That splits the project in two. Inference from the published checkpoint is fully reproducible today, since the weights are open and the scripts are there. Reproducing the method, retraining it on your own data or on a different base model, is not, and that is the more interesting half of the research.

The inference scripts are also split by task rather than by being one general entry point: a plain identity-preserving script, a face swap script, a LoRA script and a VACE script, each covering one of the downstream tasks the framework is claimed to integrate with.

## Setting up a Conda environment and pulling the weights

The quick start is a short sequence of shell commands. You clone the repository, create a Conda environment on Python 3.11, install the requirements, and optionally add Flash Attention for faster inference:

```bash
git clone https://github.com/WeChatCV/Stand-In.git
cd Stand-In

# Create and activate Conda environment
conda create -n Stand-In python=3.11 -y
conda activate Stand-In

# Install dependencies
pip install -r requirements.txt
```

The optional Flash Attention install carries a warning that your GPU and CUDA version need to be compatible with it:

```bash
# (Optional) Install Flash Attention for faster inference
# Note: Make sure your GPU and CUDA version are compatible with Flash Attention
pip install flash-attn --no-build-isolation
```

The dependency list is pinned hard. The requirements file names torch 2.7.0, torchvision 0.22.0, transformers 4.46.2, insightface 0.7.3, onnxruntime-gpu 1.22.0, huggingface_hub 0.31.1, einops 0.8.1, safetensors 0.5.3, opencv_python 4.11.0.86, imageio 2.37.0, imageio-ffmpeg 0.6.0, scikit-image 0.25.2, ftfy 6.3.1, facexlib 0.3.0, numpy 2.2.6, Pillow 11.3.0 and tqdm 4.67.1.

The two pins that matter for a working install are torch 2.7.0 with its matching torchvision 0.22.0, and the onnxruntime-gpu build, since the face recognition path runs on the GPU through that runtime.

## download_models.py fetches three sets of weights

The model download step is a single script:

```bash
python download_models.py
```

The README says this fetches all required model weights into the checkpoints directory, and it names three of them. The base text-to-video model wan2.1-T2V-14B, the face recognition model antelopev2, and the Stand-In model itself.

The face recognition model is the part that surprises people. Identity preservation is not only a matter of the generator keeping a face consistent, it also needs a way of measuring whether the face in the output is still the face in the reference, and antelopev2 from the insightface package fills that role. The same insightface dependency appears in the requirements file, which is consistent with the model being used for the similarity side of the pipeline.

The size of that download is the practical entry cost. A 14 billion parameter video model is a large set of weights, and a user who only wants to look at the published examples is going to pay for the whole base model before generating anything.

The README also notes that if you already have the base model, the script can reuse it, which is the route to take if you are working on a machine that already hosts Wan.

## One adapter, several downstream tasks

The claim that Stand-In integrates into other tasks is the second part of the pitch, and the news entries give it a timeline.

On 2025-08-18 a version compatible with VACE was released, which the README says means not only pose control but also other control methods such as depth maps, combined with Stand-In to maintain identity at the same time. The VACE example in the results section shows three columns, a reference pose, a first frame and the generated video, which is the shape of a control conditioned pipeline.

The other tasks are visible in the results tables. There is identity-preserving text-to-video generation with a reference image and a prompt, a non-human subject example with a chibi-style boy on a skateboard, an identity-preserving stylised generation table that pairs a reference image with a Ghibli LoRA, and a video face swapping table with a reference video, an identity image and the output.

The LoRA table is the one that shows the plug-and-play claim most directly, since it puts a community LoRA next to the identity reference in the same generation. The key features list names compatibility with community models such as LoRA as highly extensible.

A Wan2.2 based version went live on 2025-12-22, and the news entry dated 2026-08-10 says a Stand-In-V2 is coming soon.

## The ComfyUI story is a warning about forks

The most practically useful part of the news section is the ComfyUI situation, because it is a case where a popular integration outpaced the official one.

Special thanks go to kijai for integrating Stand-In into the custom ComfyUI node WanVideoWrapper. The README then says the implementation differs from the official version, which may affect Stand-In's performance, and that to address part of the issue an official Stand-In preprocessing ComfyUI node was urgently released, at the Stand-In_Preprocessor_ComfyUI repository. Users who want to experience Stand-In within ComfyUI are told to use the official preprocessing node to replace the one implemented by kijai, and for the best results to wait for the full official Stand-In ComfyUI release.

That is a candid admission that the community path and the official path are not equivalent right now. It is also a useful model for anyone integrating this into a pipeline of their own: the same identity control can behave differently depending on which preprocessing implementation produced the reference representation, and the difference is measurable.

The face swapping feature was updated separately on 2025-08-16 and is described as experimental, so the project itself marks that feature as less settled than the core identity control.

## What the framework does not give you

Two limits deserve naming before anyone builds on this.

The first is the training gap. The todo list is explicit that the training dataset, the data preprocessing scripts and the training code are not yet released, and the main claim of the paper, that one percent of the parameters is enough, is a claim you cannot verify from the released artefacts alone. You can run inference with the published adapter weights, which is a great deal of practical value, but you cannot retrain the adapter, you cannot try the method on a different base model, and you cannot ablate it.

The second is the base model dependency. Stand-In is a Wan adapter, and the weight download pulls a 14B text-to-video model into the checkpoints directory. Anyone using it inherits the licence terms and the hardware requirements of that base model, and the framework itself does not abstract over which Wan variant you run beyond the two named releases.

On maintenance, the repository is not archived and the last push was on 2026-08-10, with the V2 announcement on the same date. There are no GitHub releases, so the version history lives in the README news list rather than in tags, and the Hugging Face organisation is where the weights are actually versioned.

A final note on the nature of the work: identity preservation and face swapping are dual use capabilities, and a framework that makes a face consistent across generated video is also a framework for putting a real face into generated video. The project ships this openly for research, and the honest position is that the deployment decision belongs to whoever operates the model.

## Conclusion

Stand-In suits a research team that needs identity control on top of an existing text-to-video checkpoint and is willing to work with a Wan-derived stack, since the adapter approach keeps the base model frozen and the released weights cover Wan2.1 and Wan2.2. It is the wrong tool if you need to train the method yourself, because the training code, dataset and preprocessing scripts are still unchecked boxes in the todo list. Before using it, run the environment setup and download_models.py, confirm the base model licence allows your use, and read the note about the ComfyUI node implementation, since the community version differs from the official one and the project says it may affect performance.

## FAQ

### How do I set up the Stand-In environment?

Clone the repository, create a Conda environment on Python 3.11 with conda create -n Stand-In python=3.11 -y, activate it, and run pip install -r requirements.txt. Flash Attention is optional and needs a compatible GPU and CUDA version, and the weights are then fetched with python download_models.py.

### What does Stand-In need to download?

The download script fetches the required weights into the checkpoints directory, naming three of them, the base text-to-video model wan2.1-T2V-14B, the face recognition model antelopev2, and the Stand-In model itself.

### Is the Stand-In training code available?

Not yet. The todo list has the inference script and the open weights for Wan2.1-14B-T2V and Wan2.2-T2V-A14B marked as done, while the release of the training dataset, the data preprocessing scripts and the training code is still an open item.

## Sources

- [Issues](https://github.com/WeChatCV/Stand-In/issues)
- [License: Apache-2.0](https://github.com/WeChatCV/Stand-In/blob/main/LICENSE)
- [README](https://github.com/WeChatCV/Stand-In/blob/main/README.md)
- [WeChatCV/Stand-In on GitHub](https://github.com/WeChatCV/Stand-In)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/wechatcv-stand-in