Anny: a differentiable human body model in PyTorch

A body model you can differentiate

Anny is a differentiable human body mesh model written in PyTorch. Differentiability is the point: because the model is expressed in tensor operations, its outputs carry gradients, so body shape and pose can be optimised rather than posed by hand. The project models a large variety of human body shapes, from infants to elders, using a common topology and parameter space.

That combination of properties is what makes it useful rather than merely convenient. A common topology and parameter space mean one model instance covers a wide range of bodies, and the fact that it is a PyTorch module means it fits inside an existing training or rendering pipeline, with `torch.compile` support called out in the recent release notes.

The lineage is the MakeHuman community, and the project says so plainly: Anny is based on the tremendous work of the MakeHuman community, which offers plenty of opportunities for extensions. Beyond the full body, there are part-specific models for hands and faces. The project also states that Anny is open-source and free.

There is a demo you can try in a browser at the Naver Labs demo site, an arXiv paper with identifier 2511.03589, and a blog post from Naver Labs Europe describing it as a free to use 3D human parametric model for all ages. The package is on PyPI as `anny`, and the implementation lives under `src` in a repository with a `docs` directory, a `tutorials` directory, a `test` directory and a `uv.lock` file.

Three install flavours, and what the free one may download

The install section offers three variants plus a source install:

pip install anny[smpl,examples] # Full install (non-free dependencies).
pip install anny[examples] # Free install.
pip install anny # Minimal install.
# Note that the free install may download non-commercial only assets when needed.

The names of the extras tell you what you are agreeing to. The `smpl` extra pulls in `smplx` and `chumpy`, and the `examples` extra brings the interactive tooling: gradio, jsonargparse, matplotlib, notebook tooling, scipy, jupytext and a pinned `py-soma-x` release, the last one marked as needing to stay in sync with the SOMA assets revision inside the package.

The comment on the free install is the detail to notice. A minimal install can still end up fetching non-commercial only assets when the model needs them, so the licensing position depends on what you ask for at runtime, not only on what you installed. That matters for anyone building a product rather than a research prototype.

There is also a source install, given as `pip install anny[examples]@git+https://github.com/naver/anny.git` for the latest sources, and the package requires Python 3.10 or newer. The build backend is setuptools with setuptools-scm for the version, and the runtime dependencies are `torch`, `roma`, `numpy`, `pyyaml`, `pillow`, `requests`, `safetensors`, `trimesh` and `warp-lang`.

Pose, phenotype, local changes and facial actions

The quickstart in the readme shows the whole parameter surface, and the shape of it is worth understanding because the model takes four different kinds of input:

import torch, anny, trimesh
model = anny.Anny(local_changes="default", facial_actions="all").to(dtype=torch.float32)
# The model accept both dictionnary and stacked tensor inputs.
# Skeletal rig pose parameters (see model.bone_labels).
pose_parameters = torch.eye(4)[None, None].repeat(1, model.bone_count, 1, 1)
# High-level shape parameters (within [0,1], see model.phenotype_labels):
phenotype_kwargs = {key : 0.5 for key in model.phenotype_labels}
# Local shape changes (within [-1,1], see model.local_change_labels):
local_changes = {'stomach-pregnant-incr': 1.}
# Facial expression changes (within [0,1], see model.facial_action_labels):
facial_actions = {"jawOpen": 0.8, "mouthSmileLeft": 0.4}

Pose parameters are per bone transforms, sized by `model.bone_count`, and the model accepts either a dictionary or a stacked tensor. Phenotype parameters are high level shape values in the range zero to one, driven by `model.phenotype_labels`. Local changes are the fine-grained deviations, in the range minus one to one, and the example names a specific one, `stomach-pregnant-incr`. Facial actions are expression values in the range zero to one, such as `jawOpen`.

The call then exports geometry:

output = model(
      pose_parameters=pose_parameters,
      phenotype_kwargs=phenotype_kwargs,
      local_changes_kwargs=local_changes,
      facial_actions=facial_actions
      )
trimesh.Trimesh(vertices = output["vertices"].squeeze(dim=0).numpy(), faces=model.faces).export("anny_output.ply")

The output dictionary carries vertices, and the faces come from the model, so the result is a plain mesh you can hand to trimesh and export as a PLY file. An interactive Gradio demo is also provided and starts with:

python -m anny.examples.interactive_demo

The 104-bone rig and the 163-bone MakeHuman alternative

By default `anny.Anny()` uses the compact `anny` rig with 104 bones, and the documentation calls it the recommended default for most full-body use cases.

The reason it is smaller is pruning. The default rig keeps the main body, hand and head articulation while removing facial expression, eye, tongue and other zero-weight or pruned bones that exist in the full MakeHuman rig. The guidance is to choose `rig="anny"` for a smaller, stable default skeleton, and to choose `rig="makehuman"` if you need exact compatibility with old models or direct access to the removed face, tongue and eye bones.

The MakeHuman rig exposes the full 163 bones with the old blender and root-identity orientation, which is the other half of the trade: a rig that matches existing assets exactly, at the cost of bones that contribute nothing to the pose.

Facial expression is not part of the rig in either case. Facial action blendshapes remain available separately, through `facial_actions="all"`, so expressions are a separate mechanism from skeletal articulation. That separation is a common design in body models, and it is why the readme lists facial actions as a separate input in the quickstart and the v0.6 news entry describes the facial action work as a new feature alongside the new rig.

The parameter names are also introspectable, since the labels for bones, phenotypes, local changes and facial actions are attributes on the model, which is what lets the example build a pose tensor without hard coding a bone count.

Topology choices, and what the default edits change

The default `anny.Anny()` topology is described as a MakeHuman-derived full-body mesh with Anny's minor nudity-related mesh edits, unattached vertices removed, and triangular faces. It is the recommended topology for new full-body models, because every output vertex is referenced by the mesh connectivity, and because the triangulated faces work directly with downstream tools such as anthropometry and most mesh processing libraries.

The alternatives are named and each has a clear reason. `topology="anny-quads"` gives back the original quad faces, `topology="anny-full"` keeps unattached vertices and disables the nudity-related mesh edits, and `topology="makehuman"` gives the unedited quad MakeHuman body mesh convention. When interoperability matters more than the native mesh, alternative retopologies such as `smplx`, `smpl` and `soma` are available.

Migration is documented as a table, because the defaults changed. `anny.Anny()` now defaults to the new model with `rig="anny"`, `topology="anny"` and `pose_parameterization="local-ref"`, while the deprecated `anny.create_fullbody_model(...)` factory preserves the legacy full-body defaults. The table maps the old argument values to the new ones, for example `rig="default"` becomes `rig="makehuman"` and the old default topology becomes `topology="anny-quads"`.

The nudity-related edits deserve a direct mention rather than a footnote, because they are a content decision baked into the geometry, and a project that needs the unedited mesh has an explicit option to get it.

Eleven months of releases and an interface that keeps moving

The news section is a useful guide to how fast this project is moving, and the dates are all in the last year.

Version 0.1 was the initial release on 2025-11-05, and 0.2 followed on 2025-11-21 with support for different mesh topologies. Version 0.3 on 2026-02-04 added the `smplx` topology for interoperability with SMPL-X, explicitly marked as non-commercial use only, and excluded nipple blend shapes from the default settings, with `local_changes="all"` offered for backward compatibility.

Version 0.5 on 2026-06-03 was a refactoring release: the `anny.Anny` syntax became available, support for the SOMA rig and topology arrived along with an SMPLX wrapper with an `anny` topology option, and the changelog was pointed at for detail.

Version 0.6 on 2026-08-06 brought the new `anny` rig, facial actions, improved SOMA compatibility, an API refactoring and better `torch.compile` support.

So in eleven months the model went from first release to a rewritten rig, a rewritten topology, new expression handling and a reshaped API. That is normal for a 0.x research library and it is also a warning for anyone planning to depend on it. There are no GitHub releases, so the CHANGELOG.md file and the news section are the version record, and the last push was on 2026-09-28.

Free software with assets that are not always free

The licence position needs two files. The package metadata lists `LICENSE` and `LICENSE_THINGS` as the licence files, and the repository carries both. The distinction is the important part: the code in `src` is open source and free, while some of the third party assets the model can load carry their own terms, which is what the separate file for things is for.

The clearest example is the SMPL-X topology, which the news entry describes as available for interoperability with SMPL-X for non-commercial use only. The `smpl` install extra pulls in `smplx` and `chumpy`, and the `chumpy` dependency is old enough that the build configuration has to give it special handling, with a pip source declared in the uv configuration.

The rest of the tooling is ordinary and modern. Ruff is pinned at 0.14.5 for linting and formatting with an 88 column target, and there is a `dev` extra with build and twine for publishing. The repository also has a `.devcontainer` directory, an AGENTS.md, a CLAUDE.md, a MANIFEST.in and a `build_doc.bash` script, and the tutorials directory links to documentation pages covering shape parameterization, pose parameterization, the portability of pose parameterizations across rigs, texture coordinates, and alternative models.

If you are evaluating this for a commercial product, read `LICENSE_THINGS` before anything else. The code being permissive does not make the assets it can pull in permissive.

Editorial conclusion

Anny suits a graphics or machine learning researcher who needs a body model that is differentiable and scriptable, who can live with the MakeHuman heritage of the mesh, and who is working on non-commercial or properly licensed data. It is a poor fit if you need a model whose assets are unambiguously free for commercial use, since the SMPL-X topology is documented as non-commercial use only and the free install may pull non-commercial assets, and it is a poor fit if you need a stable API, because the project has refactored its interface repeatedly in under a year. Before you adopt it, read `LICENSE` and `LICENSE_THINGS`, check the news timeline in the readme against the version you install, and confirm that the topology you need is one you are allowed to ship.

Frequently asked questions

Official sources

1. Issues
2. naver/anny on GitHub
3. Project website
4. README