lingbot-world-v2 ships four model variants, and the 1.3B package holds DiT weights only

Four variants are downloadable, and the 1.3B package is not self-contained

The model table lists four releases: `lingbot-world-v2-14b-causal-fast`, `lingbot-world-v2-14b-causal-pretrain`, `lingbot-world-v2-14b-bid` and `lingbot-world-v2-1.3b-causal-fast`, with sizes of 14B, 14B, 14B and 1.3B. Two of those are described as causal-fast, one as causal-pretrain and one as bidirectional.

The smallest one has a condition attached that the others do not. The 1.3B package on Hugging Face currently contains the DiT weights only, while the T5, the VAE and the tokenizer are shared with the 14B release and have to be passed in with `--assets_dir`, or as the third argument of `run_fast.sh`. So the 1.3B variant cannot be started from its own download directory without something else on disk.

The two download paths also differ in coverage. The causal-fast 14B model has both a Hugging Face and a ModelScope link, and there is a ModelScope collection for the family, but the causal-pretrain, bidirectional and 1.3B models each carry only a Hugging Face link. Both command forms are given:

pip install "huggingface_hub[cli]"
huggingface-cli download robbyant/lingbot-world-v2-14b-causal-fast --local-dir ./lingbot-world-v2-14b-causal-fast

Two dependency files disagree, and only one of them mentions torchaudio

The repository declares its dependencies twice, and the two declarations are not the same. `requirements.txt` is what the installation step installs. `pyproject.toml` declares the package metadata, and its dependency list differs in three places.

The clearest difference is transformers. The manifest requires `transformers>=4.49.0` with no ceiling, while the requirements file requires `transformers>=4.49.0,<=4.51.3`. A user who installs with `pip install -r requirements.txt` and a user who installs the package get different ceilings on the same library. The image dependency differs too, `imageio[ffmpeg]` in the requirements file against plain `imageio` in the manifest, and the manifest omits `torchaudio` entirely while the requirements file includes it.

Everything else lines up between them, including `torch>=2.4.0` and a numpy floor with an upper bound below 2. `flash_attn` appears in both, and the installation section adds a separate line for it with `--no-build-isolation`, which is the documented way to install that package.

The package metadata is otherwise plain: version `1.0.0`, Python from 3.10 up to but not including 4.0, a setuptools build backend, and a single package named `wan` with every Python file under it declared as package data.

make format runs a formatter the project does not declare

The build surface of this repository is one target, and it does not agree with the tooling configuration. The whole `Makefile` is:

.PHONY: format

format:
	isort generate.py wan
	yapf -i -r *.py generate.py wan

The configuration files describe a different setup. Black is configured with a line length of 88, isort is set to the black profile, and mypy is set to strict. The development extras list pytest, black, flake8, isort, mypy and the Hugging Face hub CLI. Yapf appears in the Makefile and nowhere else, not in the extras and not in any configuration.

So running `make format` sorts imports with isort and then reformats with a tool that is not installed by the project's own dependency list, overriding whatever black would have produced. If you inherit this repository, that target is the first thing to reconcile, and the choice between black and yapf is a decision rather than a cleanup.

The rest of the tree is small and flat: `generate.py` at the root, a `wan/` package, a `run_fast.sh` launcher, an `assets/` directory, numbered `examples/` directories from `00` to `05`, and `paper.pdf` committed alongside them.

The eight GPU path is constrained by forty attention heads

The fast variant's documented run is a `torchrun` invocation across eight GPUs at 480P, and one constraint is stated in the same line: `ulysses_size` must divide 40 heads. That number is the model's head count, and it turns an innocuous-looking flag into a hardware requirement. A sequence parallel degree that divides forty is one of a small set of values, so an odd GPU count or a six or seven GPU machine is not usable with this path as written.

The inference entry point is `generate.py`, and the change from the previous version is in how it consumes frames. Causal inference runs with KV caching and processes frames chunk by chunk rather than all at once, which is what makes an interactive model possible at all: the alternative is to regenerate the sequence for every step.

The task and size arguments are given in the same invocation, `--task i2v-A14B` with `--size 480*832`, and the model is described as distilled from the base model specifically to hit a response time sufficient for 720p video at 60 frames per second. The interactive claim is also attached to a causal pretraining paradigm for an unbounded interaction horizon with consistent output quality, and both of those are claims from the announcement rather than numbers the repository lets you reproduce.

The inference mode table is commented out, and one variant has no command

The documentation contains a table of inference modes, and it is not live. The block sits inside an HTML comment, and it is the only place the sampling cost of each mode is written down: causal-fast is the default and runs four steps per chunk with no classifier-free guidance, while causal-pretrain is a pretrained causal model at 40 steps per chunk with CFG.

That is a tenfold difference in sampling per chunk, and it is the number that decides whether you can serve a frame budget. Having it inside a comment is the kind of thing that happens when a flag was renamed and the table was parked rather than deleted, and it means the flag it describes is not presented as a supported option on the page.

The visible command list then covers the causal-fast 14B model only. The causal-pretrained and bidirectional weights are both offered for download, and neither has a matching invocation in the visible instructions, while the 1.3B causal-fast model is handled through `run_fast.sh` and the shared assets described earlier. Four weights, one documented command shape, and a commented table explaining what the others would cost.

Installation instructions are delegated to another project's documentation

The quick start does not describe the environment. It states that the codebase is built upon Wan2.2 and directs you to that project's documentation for installation instructions, then gives three commands of its own:

git clone https://github.com/robbyant/lingbot-world-v2.git
cd lingbot-world-v2

# Ensure torch >= 2.4.0
pip install -r requirements.txt

pip install flash-attn --no-build-isolation

The version floor is stated twice, once as a comment above the requirements install and once in both dependency files, and flash-attention is given its own step because it needs to build against the installed torch rather than in an isolated environment. What is missing from this repository is everything about the runtime: no CUDA version, no driver version, no GPU memory requirement for the 14B models, no note about how many GPUs a 1.3B run needs, and no operating system guidance. A reader who has not already set up Wan2.2 has to go and read that project first.

The one hardware statement in the whole page is the eight GPU, forty head constraint on the fast variant.

The public demos are hosted by two third parties

There is no demo in the repository, only videos, and the interactive experience lives somewhere else. The real-time version is available on two platforms that the project thanks for their support: Reactor, described as the international web option, and LingGuang, described as the domestic mobile option.

The note attached to both is the important sentence. They provide a convenient way to try the model in real time, and in the project's own setup the model runs at full capability, with the official demo located at a conference rather than on a URL. So what a visitor sees on either platform may not be the configuration the weights are meant for, and the authoritative demonstration is a booth.

The video gallery is where the variants can be compared. The 14B causal-pretrained variant has two clips, the 14B causal-fast variant has six, and the 1.3B causal-fast variant has one. The gallery is also a naming lesson, since the headings use a different capitalisation from the download identifiers, with hyphens where the model directories use hyphens too, which is worth checking before typing a name from the video heading.

Weights arrived five weeks after the code, and there are no releases

The news log has two entries. On Jul. 9, 2026 the technical report, the inference code and the models for LingBot-World-Infinity were released. On Sep. 10, 2026 the remaining full model variants followed, which the entry names as the 14B causal-pretrained and bidirectional variants and the 1.3B causal-fast variant. So the code came five weeks before the weights that most of it needs, and the last push to the repository is the same day as that second entry, 2026-09-10.

The task list is complete. All four items are checked: the causal-fast inference code and model for 14B, the causal-pretrained model for 14B, the bidirectional model for 14B, and the causal-fast model for 1.3B. Nothing is outstanding, and the repository is not archived.

Two absences are worth noting next to that. There are no GitHub releases at all, so there is no tag to pin and the version `1.0.0` in the package metadata is the only version string anywhere, attached to the code rather than to the weights. And the tree contains no workflow directory, so there is no continuous integration configuration to run the type checker, the formatter or the tests that the development extras install. Licensing is handled by a single `LICENSE.txt` at the root, referenced from the package metadata, while the recorded licence field for the repository is unasserted, so check that file rather than the metadata before reusing anything.

Editorial conclusion

Use lingbot-world-v2 if you have the hardware the fast variant assumes, since the documented path is eight GPUs with a sequence parallel degree that has to divide forty attention heads, and that requirement is stated as a hard constraint rather than a suggestion. Three things to check first. Which of the four variants you actually want, because the causal-fast one has a documented command while the causal-pretrained and bidirectional weights are downloadable without a matching recipe in the visible instructions. Which dependency file you install from, since one of them caps transformers and mentions torchaudio and the other does neither. And where your assets come from, because the 1.3B package on Hugging Face contains the DiT weights only, with the T5, VAE and tokenizer shared with the 14B release and passed in separately. The weights are on Hugging Face and, for the causal-fast model only, on ModelScope. There are no GitHub releases, so pin a commit rather than a version.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. Robbyant/lingbot-world-v2 on GitHub