Pippo generates 1K turnaround video of a person from one photo, with no weights published

What Pippo produces and what it deliberately avoids

Pippo is a generative model capable of producing 1K resolution dense turnaround videos of a person from a single casually clicked photo. The framing is worth pausing on, because dense turnaround means the model generates a full orbit of views rather than a novel view from one angle.

The second sentence of the description is the technical claim that matters: Pippo is a multi-view diffusion transformer and does not require any additional inputs, for example a fitted parametric model or camera parameters of the input image.

That is the whole design bet. Most single-image human reconstruction work asks for extra information: a SMPL or SMPL-X body fit, or the camera intrinsics, or a segmentation. Asking a user for a fitted body model of a person from a casual photo is asking for the hard part to be done elsewhere first. Pippo takes the photo and nothing else, and has to infer the body shape and the viewpoint from the image itself.

The project came out of Meta Reality Labs with collaborators from the University of Toronto, the Vector Institute and UC Berkeley, and the README marks it as a CVPR 2025 Highlight with a short animated summary. The project page, the paper PDF, a visuals page and a Drive folder of more results are all linked from the README header.

The target audience is therefore research. Nobody is going to run this to make a video of themselves; the audience is people building on multi-view human generation, and the repository is a starting point rather than a product.

Code only: no weights, no inference script, and a todo list that says so

The most important line in the README is a parenthetical, and it changes what this repository is:

This is a code-only release without pre-trained weights. We provide models, configs, inference, and sample training code on Ava-256.

So the contents are the model definitions, the configuration files, the inference components, and a sample training setup, trained on Ava-256. What is not there is a checkpoint you can download and point a script at.

The todo list confirms it. The README lists the plans to add and update in the future, and the first two entries are cleaning up fluff in pippo.py and dit.py, and an inference script for pretrained models. That second item is the one that defines the current state: you can train, and you can look at the inference code, but the packaged path from a photo to a video for someone else's trained model does not exist yet.

This is a normal pattern for a research release from a large lab, where the trained models may be hosted separately or released later, and it is worth being clear-eyed about the cost. To get output you either train the model yourself, which means the GPU budget described later in this article, or you wait. There are no GitHub releases in the repository to pin against either.

The last push was on 2026-07-02, the repository is not archived, and the licence is a custom one that GitHub cannot classify, so the LICENSE file is where you have to look.

Setting up the environment and the dependency list

The setup is a clone, a path export, and a conda environment. The clone command the README gives is:

git clone [email protected]:facebookresearch/pippo.git
cd pippo
export PATH=$PATH:$PWD

Note that this is the SSH form of the URL, and that the export puts the repository root on the path so the scripts are callable.

The environment section pins a specific Python and a specific PyTorch stack:

conda create -n pippo python=3.10.1 -c conda-forge
conda activate pippo

# can adjust as required (we tested on below configuration)
conda install pytorch==2.4.0 torchvision==0.19.0 torchaudio==2.4.0 pytorch-cuda=12.0 -c pytorch -c nvidia

pip install -r requirements.txt

The requirements file is fully pinned, and it is a long one. It includes torch 2.4.0 with matching torchvision and torchaudio, diffusers 0.32.2 and transformers 4.48.2 for the generative stack, accelerate 1.3.0, safetensors, huggingface-hub, einops, omegaconf and easydict for configuration, opencv-python and imageio for image handling, tokenizers, triton 3.0.0, kornia 0.8.0, and a set of smaller utilities including ftfy, regex, psutil, tqdm, scipy and wcwidth.

The pytorch-cuda=12.0 pin tells you the CUDA generation expected, and the comment in the README says the configuration was tested on exactly that setup and that you can adjust as required. A pinned requirements file for a diffusion model is a reasonable choice by the authors, and it also means you inherit those versions unless you resolve conflicts yourself.

Training configs at three resolutions and what they cost

The training story is the concrete part of the release, and the README gives you the configs and the hardware they were tested on.

Exact model configs are provided to train Pippo models at different resolutions of 128, 512 and 1024, placed in the config/full/ directory. The launch command for the full sized model is:

# launch training (tested on single A100 GPU 80GB): full sized model
 python train.py config/full/128_4v.yml

Note that the file name encodes the resolution and the number of views, 128_4v, and that the same directory holds the other resolutions. So the architecture is configured per resolution and per view count, and the number of views is part of the experiment design rather than something fixed in the code.

For people without an 80GB A100, there is a tiny config:

# launch training (tested on single T4 GPU 16GB): tiny model
python train.py config/tiny/128_4v_tiny.yml

The gap between the two is the number that matters for planning. A single A100 with 80GB of memory for the full model, a single T4 with 16GB for the tiny one. The tiny config is the realistic entry point for a group that wants to understand the system rather than reproduce the paper, and the README's own wording distinguishes a full sized model from a tiny model.

The training data path is Ava-256, the dataset from the same organisation, and pre-packaged samples for that training are stored as npy files on Hugging Face. The download command is:

# download packaged Ava-256 samples
python scripts/pippo/download_samples.py

And the README notes you need to be authenticated to Hugging Face with a login token to download the samples, which is a small but real step in getting started.

Training on your own data: the Plucker Rays and Spatial Anchor images

The README is direct that the difficult bits of custom data preparation are creating the Plucker Rays and the Spatial Anchor images, and it points at a gist with the implementations of those methods, built using the Ava-256 and Goliath data.

This is the part of the release that tells you the most about how the model works. A multi-view diffusion transformer that generates an orbit around a person has to know, for each camera position it renders, where that camera is relative to the subject, and it has to know something about the subject's spatial extent. The Plucker Rays encode a camera ray in a way that can be fed to a transformer, and the Spatial Anchor images are the representation of the subject's position in space that the model conditions on.

So the model does take extra inputs at training time, even though it does not require the user to supply them at inference. The distinction is between what a user has to provide and what the training pipeline computes. At inference, a photo is enough; during training, you have to build the geometric conditioning for every frame of every view, which is exactly the part the README calls difficult and provides code for.

The README points at an issue in the repository, issue 9, for the custom dataset procedure, and says you will have to prepare your dataset similar to the provided Ava-256 samples stored in numpy files. The npy format is worth noting, since it means your data pipeline ends up as numpy arrays rather than as an image directory, which is a different shape of work from most image model setups.

For a team with no multi-view capture rig, this is the real cost of using the codebase beyond the sample data.

The re-projection error metric and the parts worth borrowing

The repository includes a metric and a short list of things the authors think are reusable, and that list is the most practically useful part of the README for a reader who is not going to train a 1K model.

The metric is re-projection error between generated images and ground truth images, computed by running:

python scripts/pippo/reprojection_error.py

The README's Useful Pointers section lists three things to borrow from the codebase. ControlMLP to inject spatial control in Diffusion Transformers, pointing at latent_diffusion/models/control_mlp.py. Attention Biasing to run inference on 5x longer sequences, pointing at latent_diffusion/models/dit.py. And the re-projection error metric itself, pointing at scripts/pippo/reprojection_error.py.

Attention biasing for longer sequences is the one that generalises furthest. A diffusion transformer over multi-view sequences runs into an attention cost that grows with the sequence length, and a mechanism that makes 5x longer sequences tractable at inference time is useful well beyond human generation. The same is true of spatial control injection.

The repository layout matches the pointer list, with the model code in a latent_diffusion directory, a top-level train.py, common.py and add_headers.py, a config directory, a scripts directory, and an assets directory. The naming suggests the model is built on a latent diffusion foundation with a diffusion transformer on top, and the TODO list refers to cleaning up pippo.py and dit.py, which are the entry and model files.

Editorial conclusion

Adopt Pippo if you are doing research on multi-view human generation and want to train the model yourself on your own data, since the repository gives you the model, the configs at three resolutions, the training loop and the data preparation tools. Do not adopt it if you need to generate video today, because this is a code-only release with no pretrained weights and the inference script for pretrained models is still on the todo list. Verify first that you can absorb the training cost, with the README citing a single A100 80GB for the full model and a single T4 16GB for the tiny config, that you can build the Plucker Rays and Spatial Anchor images for your own dataset since the README calls those the difficult bits, and that the licence file permits your use, because the repository is published under a custom licence rather than a standard one.

Frequently asked questions

Official sources

1. facebookresearch/pippo on GitHub
2. Issues
3. README