# InfinityStar: one autoregressive model for images and video > InfinityStar is a purely discrete autoregressive model that treats images and video in a single spacetime sequence, so the same architecture handles text to image, text to video, image to video and long interactive video synthesis. It was a NeurIPS 2025 oral, and the repository ships training code, inference scripts and checkpoints. **FoundationVision/InfinityStar** — [NeurIPS 2025 Oral]Infinity⭐️: Unified Spacetime AutoRegressive Modeling for Visual Generation - Repository: https://github.com/FoundationVision/InfinityStar - Stars: 792 · Forks: 29 - Language: Python - License: MIT - Published: 2026-10-20 · Updated: 2026-10-20 · Language: en - Canonical page: https://hysenlabs.com/projects/foundationvision-infinitystar ## A discrete autoregressive model for spacetime InfinityStar is introduced as a unified spacetime autoregressive framework for high resolution image and dynamic video synthesis, and the name expands to unified spacetime autoregressive modeling for visual generation. The core idea is stated as a single sentence: a purely discrete, autoregressive approach that jointly captures spatial and temporal dependencies within a single, elegant architecture. That is the part that differs from most video generation work. The dominant approach treats a video as a diffusion process in a latent space, with the temporal dimension handled by a video specific architecture such as a 3D VAE or a temporal attention block. Here, space and time are the same axis. A frame is a sequence of tokens and a video is a longer sequence of tokens, and the same model predicts the next token in either case. The consequences show up in the task list. Because there is no separate video pathway, the same design supports text to image, text to video, image to video, and long interactive video synthesis through straightforward temporal autoregression. Long video falls out of the formulation rather than needing a special mechanism. The paper was accepted as a NeurIPS 2025 oral, with the technical report on arXiv, and the weights are published on the Hugging Face hub under the FoundationVision organisation. ## The performance claims, and how to read them The README makes three performance claims, and they are worth taking apart. The first is a score of 83.74 on VBench, with the claim that this outperforms all autoregressive models by large margins and even surpasses diffusion competitors such as HunyuanVideo. VBench is a video generation benchmark, so the comparison is like for like on the benchmark, although a single aggregate score hides the per dimension behaviour, and the README shows the benchmark charts as images rather than tables. The second claim is speed, approximately ten times faster than leading diffusion based methods. That follows from the architecture rather than from engineering: an autoregressive model that predicts discrete tokens can often be run with a much smaller number of sampling steps than a diffusion model needs, because the tokens are predicted more directly. The third claim is about resolution and scale. The README states that to their knowledge InfinityStar is the first discrete autoregressive video generator capable of producing industrial level 720p videos. The phrase to your knowledge is doing real work in that sentence, since it is a claim about a first, and firsts in this area are contested often. The separate human evaluation chart in the repository is described as surpassing diffusion competitors such as HunyuanVideo, which is a different measurement from the automated benchmark and worth looking at separately. What you should take from all this is that the numbers are the authors' own, published alongside code and checkpoints so that they can be checked. ## What has been released The README has an open source plan with checkboxes, and every box is ticked, which is unusual and useful. The training code is released, along with the web demo, the InfinityStar inference code, the model checkpoints, the inference code for the interactive variant and its checkpoints. The release timeline in the updates section tells the story. The paper was accepted as a NeurIPS 2025 oral on 18 September 2025, and the paper, the training and inference code, the checkpoints and the demo website were released on 7 November 2025. So the publication came first and the weights followed about seven weeks later. There is one entry that needs context. The most recent update, dated 16 April 2026, announces GRN, a next-generation visual synthesis framework released in another repository by a related organisation. The README describes it as neither diffusion nor autoregressive, a third way, and describes it as refining globally like an artist and generating adaptively by complexity. So the direction of travel is away from this repository. If you are reading the project to see where the approach is heading, the interesting artefact now is the successor framework. If you want to reproduce the results in the paper, this repository is still where the code and weights are. ## The inference scripts and what each one gives you There are three inference scripts, and the differences between them are about resolution and length. The 720p script generates five second videos at 720p resolution, and the README explains why the length is fixed: because of the high computational cost of training, the released 720p model is trained for five second video generation. The same script also does image to video by specifying an image path. ```bash python3 tools/infer_video_720p.py ``` The 480p script uses an intermediate checkpoint at 480p resolution, capable of five and ten second videos. The README is candid that this model is not specifically optimised for text to video and recommends the experimental image to video and video to video modes for better results. The duration is set by editing a variable in the script to either five or ten, which is the kind of rough edge you expect from an intermediate checkpoint. ```bash python3 tools/infer_video_480p.py ``` The interactive script generates a long interactive video at 480p. You provide a reference video and multiple prompts, and the model generates the video interactively with your assistance, which is the extended application the README demonstrates separately from the standard generation modes. ```bash python3 tools/infer_interact_480p.py ``` The demo website is the other route in, and the README invites people to try it and generate videos there. ## Training setup and the dependency list The installation section is short and has one requirement that matters for anyone who wants to train rather than just run inference. The project uses FlexAttention to speed up training, and that requires a recent torch, with the README stating the version requirement of 2.5.1 or later. The other pip packages come from the requirements file. The other pip packages come from the requirements file, installed with the pip3 install of that file. The training workflow is described as comprehensive, covering data organisation, feature extraction and the training scripts, with the detailed instructions in the data readme in the data directory. So the pipeline is not just a single training script; there is a preparation stage that has to happen first, and the data directory is where that is documented. The requirements file is long and gives a good picture of the stack. It pins torch at 2.5.1 and the image model library at 0.9.6, and includes the usual generative model dependencies: transformers, a training tracker, the configuration library, an image processing library, a video decoding library, an augmentation library, einops for tensor manipulation, and imageio with its ffmpeg backend for video writing. There are also several entries that reveal where this code came from. An HTTP client pinned to an old version, a distributed storage client specific to one vendor, and a distributed training library are all telltale signs of a large lab environment, and they are worth checking for compatibility before you try to reproduce the pipeline elsewhere. The remaining dependencies are standard research tooling: a progress bar, a plotting library, a computer vision library, a type checking helper and a retry library. ## Repository layout and maintenance The repository is organised around the model, the tools and the data. The infinity directory holds the model implementation, the tools directory holds the inference scripts, the scripts directory holds the training scripts and the train file at the root is the training entry point, the data directory holds the dataset preparation material and its readme, the evaluation directory holds the benchmarking code, and the assets directory holds the images used in the readme. There is a cog configuration file at the root, which is the configuration format used by one of the hosted model deployment platforms, so the model can be served through it without extra work. The maintenance facts are modest. The repository has no GitHub releases, so there is no tagged version to pin, and the last push was on 2026-04-16, which is the same day as the GRN announcement. The licence is MIT, with the licence file at the root. What that means for an adopter is that the repository is a snapshot of a research release rather than a maintained package. The weights on the hub are the stable artefact, and the code here is what produced the results in the paper. If you need to run this in production, you should expect to own the environment, since the dependency set is tuned to one lab's machines rather than to a general environment. ## Conclusion InfinityStar suits a research team that wants an autoregressive alternative to diffusion for video and a single model covering several generation tasks, since the checkpoints, the inference scripts and the training pipeline are all published and the claimed VBench score and speed come with a reproducible script. It is the wrong choice if you need a stable, supported package, since the repository has no releases and the README now points at a newer framework for the next generation of work, and the wrong choice if your hardware cannot hold a 720p autoregressive video model. Verify first which checkpoint resolution and duration you can actually run, since the 720p model is limited to five second clips and the 480p one is described as intermediate, and read the data preparation notes before attempting to train. ## FAQ ### What is InfinityStar? It is a unified spacetime autoregressive framework for high resolution image and dynamic video synthesis, using a purely discrete autoregressive approach that captures spatial and temporal dependencies in a single architecture. ### Which generation tasks does InfinityStar support? Text to image, text to video, image to video and long interactive video synthesis, the last through straightforward temporal autoregression rather than a separate mechanism. ### How do I generate a video with the released code? The 720p script generates five second videos and also does image to video from an image path, while the 480p script handles five and ten second clips with a duration set in the script, and the interactive script produces long interactive video from a reference video and multiple prompts. ### What does the README say about requirements? The project uses FlexAttention to speed up training, which requires torch 2.5.1 or later, and the other pip packages are installed from the requirements file. ## Sources - [FoundationVision/InfinityStar on GitHub](https://github.com/FoundationVision/InfinityStar) - [Issues](https://github.com/FoundationVision/InfinityStar/issues) - [License: MIT](https://github.com/FoundationVision/InfinityStar/blob/main/LICENSE) - [README](https://github.com/FoundationVision/InfinityStar/blob/main/README.md) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/foundationvision-infinitystar