HairDeck: Tsinghua Turns One Image Into Animation-Ready Hair Cards

HairDeck is a new open-source model that takes one image of a stylized character and returns the hair as separate, artist-style hair cards, plus the spring-bone chains that make them swing. The paper, from authors at Tsinghua University, Carnegie Mellon and the Chinese University of Hong Kong, reports that it runs about 33 times faster than the previous generator, CHARM, while cutting geometric error by 44% on CHARM's own test set. Code, checkpoints and a hosted demo are public, and the repository carries an Apache-2.0 licence.

This is a niche but genuinely usable release: if you build anime-style avatars, VTuber models or game characters, hair is one of the slowest parts to author by hand. Below is what HairDeck does, how it works in plain terms, the numbers the authors report, how to try it, and where the limits are.

HairDeck at a glance

What are hair cards, and why generate them?

In real-time 3D, a character's hair is rarely thousands of simulated strands. Stylized characters in games and VRM avatars usually wear hair cards: flat, curved ribbons placed by an artist, each textured to look like a lock of hair. The geometry of those ribbons is the visible hairstyle. To make them move, riggers attach chains of "spring bones," simple bones that swing and settle with the head so the hair reacts to motion.

The paper's framing is that existing image-based methods miss this representation. Realistic-hair methods output strands, other pipelines output a single fused mesh, and neither gives an artist the individual cards they would edit, re-texture or re-rig. According to the authors, CHARM was the only prior generator of stylized hair cards, and it decodes a hairstyle one control point at a time as a long autoregressive sequence.

HairDeck stylized hair cards generated from single input images, with spring-bone chains in orange Image: HairDeck authors

How HairDeck works: a hairstyle is a set, not a sequence

The central observation in the abstract is that a card hairstyle is an unordered set of artist-defined primitives. There is no natural "first card." Forcing the cards into a sequence, as an autoregressive decoder must, adds an ordering that means nothing and makes generation slow.

HairDeck instead treats the hairstyle as a set. The project page describes three steps:

1. One card, one token. A card VAE compresses each card's geometry, root position and orientation into a single compact token.
2. Generate the set together. A set diffusion transformer denoises all card tokens jointly, conditioned on an input image or a point cloud. If you want a refresher on the mechanism, our explainer on how diffusion image generation works covers the noise-to-structure idea; HairDeck applies it to a bag of tokens rather than pixels.
3. Make it move. A second transformer generates the spring-bone chains, and geometric skinning binds the cards to them.

The README adds that the output "preserves individual hair cards and provides per-card UV coordinates," so each ribbon remains something an artist can open in Blender and adjust.

The reported numbers

All figures below are the authors' own, from the project page and paper abstract, measured on the 100 test hairstyles of CHARM. They have not been independently reproduced as of this writing.

The authors note that timing measures card generation before meshing, so the end-to-end time on your machine will include preprocessing, chain generation and export. They also report that, from single images, HairDeck outperforms CHARM, image-to-3D pipelines and strand-based methods, though the project page shows that comparison as qualitative galleries and the abstract does not give a single headline number for it. Treat the 33x figure as a benchmark on point-cloud input, not a promise for every image.

What the output looks like

The results gallery shows the same character redrawn in several styles with a generated hairstyle under each input, and a head-turn comparison with and without spring bones. In the authors' clip, hair without the chains stays rigid relative to the head, and hair with them lags and settles.

Spring-bone chains moving generated hair cards through a head turn Image: HairDeck authors

A caveat from the project page: hair colours in the demo renders are sampled from the input images for display. Colour here is for visualisation, not a texture-painting pipeline.

What people will ask next

Does it replace a character artist? Not on the evidence given. The output is a set of editable cards, UVs and bones, which suggests a draft to refine. The authors do not claim production-ready quality for every style, and the project page only shows curated galleries.

Can I feed it a photo of a real person? The paper is about stylized characters drawn in different art styles, and the gallery pairs each input with a generated hairstyle across those styles. Photographs of real people are not what the released examples demonstrate, so results there are untested by the authors.

Can I use only the cards and skip the animation? Yes. The --no-chains flag generates cards only, and the chains file is simply omitted from the outputs.

Can I train on my own characters? The README documents a training path starting from the CHARM dataset and the characters' VRM files, with launch scripts for the card VAE and the point-cloud, image and chain transformers.

How to try HairDeck

You have two routes. The hosted demo is linked from the project page and is the lowest-effort way to test a character image. For local use, the GitHub README lists these requirements: Linux x86-64, Python 3.12, one NVIDIA CUDA GPU, PyTorch 2.8 and CUDA 12.8, and ffmpeg on your PATH.

Weights live in the hyz317/HairDeck repository on Hugging Face. Two supporting models, SAM 3 and DINOv3, are gated, so you must accept their licences and log in before the downloader will fetch them.

git clone https://github.com/hyz317/HairDeck.git
cd HairDeck
python -m pip install -r requirements.txt
python -m pip install --no-deps pyrender==0.1.45
hf auth login
export HAIRDECK_ROOT=/path/to/workspace
python scripts/setup/download_weights.py

Then generate hair from an image and export a VRM:

python scripts/image_to_hair.py character.png --out results/my_character --n 4
python -m hairdeck.vrm.export results/my_character/character 0

The --n flag takes 1 to 4 variations, --seed sets the first seed, and --no-chains produces cards only. For a local web UI, install requirements-demo.txt and run python demo/app.py --port 7860.

What you get on disk

Per the README, a run writes the input and preprocessing masks, cards_seed0.json for card geometry, chains_seed0.json for spring-bone chains, hair_seed0.glb with a head proxy and per-card UVs, hair_seed0_nohead.glb without it, an info.json of settings, and, after the export commands, avatar_seed0.vrm and turn_seed0.mp4. The VRM route matters because VRM is a common avatar format, so the generated hair can drop straight onto a character in tools that read it.

Where HairDeck fits next to other image-to-3D work

HairDeck is narrower than the general image-to-3D models we have covered. A general model hands you one mesh and leaves rigging to you; our walkthrough of an AI image-to-3D rigged game character pipeline shows how a fused AI mesh needs cleanup before it will rig at all. HairDeck sidesteps that for one body part by generating the editable primitives and the bones together.

It also sits in a wider trend of open 3D and avatar generation: Tencent's HY-World and WorldClaw work on agentic 3D worlds, LingBot-Map's streaming 3D reconstruction, and the LongCat open-source talking avatar model. Each takes a different slice of the pipeline from flat input to something you can animate.

Limits and open questions

• Scope. The method targets stylized hair cards, the anime and game look. It is not a photoreal strand-hair generator, and the authors' strongest comparisons are against CHARM on CHARM's test set.
• Licences. HairDeck itself is Apache-2.0, but it depends on gated third-party weights and datasets that "retain their respective licences," per the README. Read them before commercial use.
• Training data. The README says the current image-training recipe uses synthetic appearance augmentation, and that the restyled-render pool behind the released image model is not included. You can retrain from the CHARM dataset and VRM files, but not bit-for-bit reproduce the released image checkpoint.
• Hardware. You need an NVIDIA GPU and Linux; there is no CPU or Mac path in the instructions.
• Verification. Numbers are self-reported on a benchmark the authors chose. No third-party reproductions were found at the time of writing.

What this means for builders

If you ship avatars or stylized characters, the practical gain is time: hair cards that used to be placed by hand, or generated in tens of seconds per hairstyle, now come out in about a second on the authors' benchmark, already attached to spring bones and exportable to VRM. Treat the output as a strong first draft that an artist still reviews, because the cards, UVs and chains are all editable files rather than a baked mesh.

For researchers, the lesson is the representation. Treating an unordered collection of primitives as a set, one token per primitive, removed the sequence ordering and the slow decoding that came with it. The same idea may apply wherever a 3D asset is naturally a bag of parts.

Related reading

• How diffusion image generation works
• AI image-to-3D rigged game character pipeline
• Tencent HY-World WorldClaw agentic 3D open world
• LingBot-Map streaming 3D reconstruction
• LongCat open-source talking avatar model
• Official: HairDeck project page, GitHub, paper

Details, numbers and repository state are as published on the project page and GitHub on November 1, 2026, and may change.