WithAnyone: ID-consistent image generation without the copy-paste look
✨ [ICLR'26] WithAnyone is capable of generating high-quality, controllable, and ID consistent images
At a glance
- What is it?
- WithAnyone is an ICLR 2026 research release that generates images containing several given identities while trying to break the similarity against copy-paste trade-off that earlier face generation methods fell into, and the repository ships inference code, a Gradio demo, a training codebase and two datasets.
- Who is it for?
- WithAnyone is worth trying if you are building identity-consistent image generation and want to see how controllability over expression, hairstyle, accessories and pose is handled alongside similarity to a reference, and it is a useful reference implementation because the training code and the benchmark data are published alongside the inference code.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 24 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on October 23, 2026, and from our analysis. They are not legal advice.
Editorial analysis
The problem: similarity against copy-paste
WithAnyone is described in the project title as being towards controllable and ID-consistent image generation, and the introduction names the specific failure it is trying to fix.
Previous methods for face generation have a tendency to directly copy and paste the reference face onto the generated image. The result is that controllability suffers: expressions, hairstyles, accessories and even poses are all constrained by whatever the reference picture happened to contain. The project describes this as a clear trade-off between similarity and copy-paste, where the more similar the generated face is to the reference, the more copy-paste artifacts it has, and WithAnyone is presented as an attempt to break that trade-off.
That framing matters because it identifies the two things a user wants at once. You want the face in the output to be the person you supplied, and you also want the scene around it to be directed by your prompt. A method that simply pastes the reference wins on the first and loses on the second, and the value of a better method is measured by how much of the second you get without giving up the first.
The project is presented as an ICLR 2026 paper, with the arXiv entry, a project page, the model on Hugging Face, the benchmark and dataset repositories, and a hosted demo space all linked from the readme. The author list and affiliations, which include Fudan University and StepFun, are present in the readme but commented out.
So the audience is researchers and engineers working on identity preservation in generative models, not someone looking for a product with a support contract.
Multiple identities in one image, and the data behind it
The second headline capability is multi-ID generation, and it is the one that needs a dataset to exist at all.
WithAnyone can generate multiple given identities in a single image, and the stated goal is that all the generated faces fit together harmoniously in one group photo. That is a materially harder problem than single identity generation, because each face has to be a faithful reproduction of a different reference while the composition treats them as one scene.
Two datasets are published for this, both on Hugging Face. MultiID-Bench is the benchmark, and MultiID-2M is the training data, split into a part 1 and a part 2. The action item list in the readme shows MultiID-Bench and MultiID-2M part 1 as done, with part 2 still open, so the training data is incomplete relative to what the project describes.
The benchmark matters for a different reason. Identity consistency work is exactly the kind of area where a qualitative result is not enough, because a face that looks right in a cherry-picked example tells you nothing about the failure rate. A published benchmark that other work can be measured against is what turns a set of impressive pictures into a comparable result, and MultiID-Bench is that artefact.
The readme also notes a follow-on project, WithEveryone, released in September 2026, which extends identity-consistent generation from WithAnyone into more general multi-person scenarios. That is worth knowing about, because it tells you the direction of travel is away from the two-person group photo towards larger scenes.
Three checkpoints, and the two the authors warn you about
The model zoo lists three checkpoints, and the difference between them is the main decision a new user has to make.
WithAnyone 1.0 on FLUX.1 is the main model, and the readme says plainly that if you just want to try it out, this is the one to use. The other two are for specific use cases, and both are described as preliminary.
WithAnyone.K.preview is a preliminary version built on FLUX.1 Kontext, for text-to-image generation with multiple given identities. The documentation says its stability and quality are not as good as the base model and advises using it with caution, with work ongoing to improve it.
WithAnyone.Ke.preview is the face editing version on FLUX.1 Kontext, and it uses the editing capabilities of that model. It comes with a practical instruction: use gradio_edit.py rather than gradio_app.py. It is also described as preliminary.
The pattern is worth reading carefully. The base model is the one with quality behind it, and the two Kontext variants are early ports to a different backbone, aimed at editing workflows that the base model does not cover. Choosing a preview because its feature list matches your task means accepting the stability caveat, and the documentation is unusually direct about that.
All three are distributed on Hugging Face, and the same host carries the demo space, which is the fastest way to see the behaviour before committing to the environment setup.
Setting up the environment and the checkpoints
The installation is conventional for a diffusion research repository, and the readme gives both halves of it.
The Python dependencies come from the requirements file.
Use `pip install -r requirements.txt` to install the necessary packages.The list behind it is worth glancing at, because it tells you what the project depends on. PyTorch is pinned at 2.5.1 with torchvision at 0.20.1, transformers at 4.45.2 and accelerate at 1.6.0, and alongside those sit insightface, which is the face analysis library, onnxruntime with a GPU variant, optimum and optimum_quanto for model quantisation, gradio for the demo interface, safetensors, and the usual supporting stack of numpy, opencv, matplotlib, seaborn, scikit-image, Pillow, tqdm and sentencepiece.
The checkpoints are handled in two ways, and the readme recommends the second if you want to save time and disk.
- `huggingface-cli download black-forest-labs/FLUX.1-dev flux1-dev.safetensors`
- `huggingface-cli download black-forest-labs/FLUX.1-dev ae.safetensors` Either you run the inference scripts and let the hf_hub_download function pull the weights automatically into your $HF_HOME directory, which defaults to ~/.cache/huggingface, or you fetch them yourself with the huggingface-cli. The repositories listed are black-forest-labs/FLUX.1-dev, xlabs-ai/xflux_text_encoders, openai/clip-vit-large-patch14, google/siglip-base-patch16-256-i18n and withanyone/withanyone, and the readme notes that you can download only the checkpoints you need.
That last point is a real saving, since a user who only wants to try the face editing preview does not need the whole set.
What the repository actually contains
The top level of the repository is the inventory of what you can do with it.
Inference comes first, in infer_withanyone.py, with two Gradio front ends beside it, gradio_app.py and gradio_edit.py, where the latter is the one the Kontext editing variant is meant to be used with. A util.py sits alongside them for shared helpers.
Training is here too, with train.py, train.sh and a TRAIN.md document that was released in December 2025, and a config directory for the run configurations. The model code itself is in the withanyone directory, with a separate withanyone_kontext_e directory for the editing variant, and there is a .gitmodules file, so some components arrive as submodules.
The data directories are in the repository as well, MultiID-2M and MultiID-Bench, and the assets directory holds the teaser material used in the readme.
Two things stand out for an adopter. First, the training codebase is public, which is unusual for this class of project and is what makes it usable as a research reference rather than a black box. Second, there is a ComfyUI integration contributed by a community member, which puts the model into a node-based workflow for people who do not want to write Python at all, and the readme thanks that contributor by name.
What is finished, what is not, and what that means for adoption
The readme keeps an action item checklist, and it is unusually honest about the state of the project.
The completed items are the inference scripts, the base model on FLUX.1, the two Kontext previews, the MultiID-Bench benchmark, the first part of the MultiID-2M dataset and the training codebase. The open items are the non-preview Kontext model, the second part of the MultiID-2M dataset, and a model called WithAnyone.Z built on Z-image.
Reading that list tells you three things. The core contribution is out, since the main model, the inference code, the benchmark and the training code all exist. The training data is half published, which matters for anyone training from scratch. And there is a third variant planned on a different backbone entirely, which suggests the project is not settling on one architecture.
For an adopter, the practical consequences are concrete. Using the base model is the supported path. Training from scratch means working with an incomplete dataset, or waiting for part 2. And the Kontext models are previews, so any comparison you run should record which checkpoint produced it, because the quality gap between the base model and the previews is stated in the documentation rather than assumed.
The timeline in the updates section is also useful context. The codebase and project page appeared in October 2025, the checkpoints, benchmark and dataset followed in the same month, the training code came in December 2025, the paper was accepted by ICLR 2026 in January 2026, and the WithEveryone follow-on project was released in September 2026. That is a fast sequence for a research project, and it means the code you clone today is newer than the paper most readers have read.
Editorial conclusion
WithAnyone is worth trying if you are building identity-consistent image generation and want to see how controllability over expression, hairstyle, accessories and pose is handled alongside similarity to a reference, and it is a useful reference implementation because the training code and the benchmark data are published alongside the inference code. It is the wrong tool if you need a supported product, since there are no tagged releases, and the Kontext variants are described by their own authors as preliminary. Before building on it, download the base model rather than a preview, read TRAIN.md and the training scripts, and decide whether the MultiID-Bench numbers reflect the kind of identity fidelity your use case needs.
Frequently asked questions
What problem does WithAnyone solve?
It aims to mitigate the copy-paste artifacts in face generation, where earlier methods directly copy the reference face onto the generated image and lose controllability over expression, hairstyle, accessories and pose. The project presents this as a trade-off between similarity and copy-paste that it tries to break.
Which WithAnyone model should I use first?
The readme says that if you just want to try it out, use the base model WithAnyone on FLUX.1. The WithAnyone.K.preview and WithAnyone.Ke.preview variants are described as preliminary, with the K preview for text to image generation and the Ke preview for face editing, where you use gradio_edit.py rather than gradio_app.py.
How do I install WithAnyone and get the model weights?
Install the Python dependencies with pip install -r requirements.txt, which pins torch 2.5.1, transformers 4.45.2 and accelerate 1.6.0. The checkpoints are downloaded automatically into $HF_HOME by the inference scripts, or you can fetch them yourself with huggingface-cli download for the FLUX.1-dev, xflux text encoder, CLIP, SigLIP and withanyone repositories.
What datasets and benchmark does WithAnyone publish?
MultiID-Bench, the benchmark for evaluating the approach, and MultiID-2M, the training dataset, are both published on Hugging Face. The project's own action item list marks MultiID-Bench and part 1 of MultiID-2M as done, with part 2 of the training data still outstanding.
Is the training code for WithAnyone available?
Yes. The training codebase was released in December 2025 and the repository contains train.py, train.sh, a TRAIN.md guide, a config directory and the model code in the withanyone and withanyone_kontext_e directories, which makes the project usable as a research reference rather than only as a set of weights.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/doby-xu-withanyone)Was this useful?