ExAvatar is a PyTorch reimplementation of a whole-body 3D Gaussian avatar

Two source models do the work: SMPL-X and 3DGS

ExAvatar is described as a combination of two things: the whole-body drivability of SMPL-X, covering body, hands and face, and the appearance modelling capability of 3DGS, or 3D Gaussian Splatting. That pairing is the project's central design idea and it explains why the code is split the way it is. SMPL-X supplies a parametric human body with hands and a face that can be fitted to motion and then posed, and 3DGS supplies the rendering side, where a scene is represented as a set of anisotropic Gaussians rather than a mesh. A result of the paper is "Expressive Whole-Body 3D Gaussian Avatar", presented at ECCV 2024, and the project links the paper, a project page and a video. The author also states that the repository is a reimplementation of that work after leaving Meta, that all the code uses public assets without Meta internal-only modules, and that the results shown in the camera-ready paper version and the demo videos come from this reimplemented code. For a reader, that last point matters: the code here is the code that produced the published figures.

The pipeline has two directories and a strict order

The README gives a two step path for creating an avatar from your own scan, and the two steps live in separate top level directories. The first step is fitting SMPL-X to a video that contains a single person, and that work is under `fitting/`. The second step, under `avatar/`, creates and animates the avatar from the result of that fit. The ordering is not optional: the avatar stage consumes the output of the fitting stage, so a user who starts in `avatar/` without a fit has nothing to work with. The video has to show one person, which is a constraint worth checking before recording anything, since the fitting stage is described as taking a video with a single person in it. The repository root holds only LICENSE, README.md, an assets directory, the two pipeline directories and environment.yml, so the whole project is small and the structure does not hide much.

Installation is a conda environment and nothing else

There is no pip install path, no package index entry and no build step documented. The entire install section is two lines that create a conda environment from the checked-in file and activate it:

conda env create -f environment.yml
conda activate exavatar

The environment name in the activate command is `exavatar`, so the file itself defines that name and any pinned dependencies. Because the environment is committed as a file rather than described in prose, the reliable way to know what you will be installing is to read environment.yml before creating it, especially on a machine where a large CUDA or PyTorch stack would be unwelcome. The README does not describe a separate step for fetching model assets or datasets, which means the environment file is not the whole setup story. It also does not state which GPU or how much memory the pipeline needs, so there is no documented way to check that your machine is suitable before you start a fit.

The X-Humans branch avoids recording your own video

For anyone who does not want to capture and fit their own footage, the project points at a second path. The README has a section on creating and animating avatars from the X-Humans dataset and links to a dedicated branch in the repository, at the path `X-Humans` under `mks0601/ExAvatar_RELEASE`. The distinction between the two routes is structural rather than cosmetic: the phone scan route asks you to supply a video of one person and fit SMPL-X to it, while the dataset route starts from data that already exists and is already annotated. That makes the branch the faster entry point for a reader who wants to see the avatar stage working before investing in capture and fitting. It also introduces a dependency on an external dataset, so the workflow now has an input that must be obtained separately rather than recorded locally. The X-Humans project is credited in the README as the source of the dataset, and the dataset itself lives outside this repository.

What the repository does not tell you

The documentation is a project page with a short README, and it leaves several questions open. There is no statement of the hardware requirements, no training or fitting time, no guidance on how long a capture session should be, and no troubleshooting section for a failed fit. There is also no description of where the SMPL-X model assets come from, even though fitting SMPL-X is the first step of the pipeline and SMPL-X itself is distributed under its own terms from its own project rather than bundled here. The README is explicit that the code uses public assets, but it does not enumerate them. The practical consequence for an adopter is that the pipeline has a first stage whose inputs live outside the repository and are not documented inside it. If you intend to run this end to end, expect to read `fitting/` and `avatar/` directly for the argument names and expected file layout, because the README does not provide a parameter reference.

MIT licensing and a paper to cite

The licence is MIT, which is permissive and means the code can be read, modified and redistributed under its terms, a reasonable starting point for academic work that may become product work later. The README also carries a BibTeX entry that any write-up of results should use:

@inproceedings{moon2024exavatar,
  title={Expressive Whole-Body 3D Gaussian Avatar},
  author = {Moon, Gyeongsik and Shiratori, Takaaki and Saito, Shunsuke},  
  booktitle={ECCV},
  year={2024}
}

The entry names Gyeongsik Moon, Takaaki Shiratori and Shunsuke Saito. Note the tension between the permissive code licence and the models the pipeline depends on: SMPL-X is a separate model distribution with its own terms, and the datasets used by the second path carry their own conditions, so an MIT file at the repository root does not make the whole pipeline free of restrictions. This is not legal advice, but it is the reason to read the terms of the upstream assets rather than assume the root licence covers them.

Code arrives through commits, not through releases

The repository has no GitHub releases, so there is no tagged artefact to download and no versioned install path. The last push to the repository was on 2026-10-14, which tells you the working tree is being worked on rather than left as a finished snapshot. What that means in practice is that reproducibility rests on the commit you check out rather than on a release version, and the environment.yml at that commit is the thing to keep with your results. The project is not archived, so it is not a dead branch, but there is no published changelog and no release note describing what changed between snapshots. Anyone planning to build on this code should pin a commit hash and record the matching environment file, because a later push can change dependencies in the conda file without any version marker announcing it.

Editorial conclusion

Researchers reproducing the ExAvatar paper, or anyone building a phone-scanned avatar that needs hand and face articulation rather than a head-only rig, will find this the reference implementation to read, since it is the paper author's own reimplementation rather than a third-party summary. It is the wrong tool for production use: the repository publishes no GitHub releases, documents no hardware requirements or run times, and expects the SMPL-X model assets to be arranged outside the code. Before starting, read environment.yml, confirm you can obtain the SMPL-X assets and the X-Humans data, and plan on following the two stage path in fitting/ before avatar/.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. mks0601/ExAvatar_RELEASE on GitHub
4. README