Zing-0.5 - Loopit's open-source real-time interactive video world model

What is Zing-0.5

Zing-0.5 is an Loopit open-source real-time interactive video world model, 5B parameters, based on Wan2.2-TI2V-5B, under the Apache 2.0 license. Its core capability is "joint control": keyboard spatial operations and natural language semantic rewriting both feed into the Causal DiT. Users can control character movement while rewriting the unfolding world with text at any time, and new instructions enter the current world rather than resetting the scene. The model learns to "play while modifying" by switching prompts mid-training, and actively perturbs historical frames to resist error accumulation. A single RTX 5090 can generate in real time at over 24 FPS, with one minute of streaming inference costing about 6 cents. It ranked first among real-time world models in the WBench evaluation jointly conducted by Meituan LongCat and Fudan.

Zing-0.5's main features

• Joint control: keyboard spatial operations (W/A/S/D movement + I/J/K/L viewpoint) and natural language semantic rewriting work together, allowing you to control movement while changing the world with text; new instructions enter the current world rather than replacing the scene.
• Real-time streaming generation: over 24 FPS on a single RTX 5090, one minute of inference costing about 6 cents, supporting infinitely long continuous temporal generation.
• Mid-generation semantic rewriting: text instructions can be inserted at any time during generation (such as "blizzard" or "dragon breathes fire"); the model preserves visual and operation history, letting the rewrite take place in the current world.
• Simultaneous response from multiple objects: a single instruction can drive changes in multiple different objects at once (such as a character kneeling in prayer + multiple statues opening their eyes and glowing).
• Long-range consistency: character appearance, scene structure, and art style (such as pixel style) remain stable during continuous generation, without drifting or switching styles.
• Resistance to error accumulation: historical frames are actively perturbed during training, so the model learns to "catch its own mistakes" and does not drift further off course over long generation.
• Action control: 8-dimensional continuous action signals (values [0,1]), supporting forward/backward/left-right movement and four-direction viewpoint changes, encoded as per-frame action residual.
• Local deployment: 5B parameters can run on a single card, Linux + PyTorch environment, 80GB+ VRAM or sliding-window attention configuration (RTX 4090 level also works), outputs H.264 MP4.
• Open source and free: Apache 2.0 license, code and weights open on GitHub, ModelScope, and HuggingFace, trained based on Wan2.2-TI2V-5B.

Zing-0.5's technical principles

• Base model: trained based on Wan2.2-TI2V-5B, 5B parameter scale; the core generation network is Causal DiT (Causal Diffusion Transformer), with causal KV cache supporting infinitely long temporal autoregressive inference.
• Dual control chain architecture: two independent control channels that both feed into the Causal DiT—spatial operations go through the "action chain" and semantic rewriting goes through the "text chain"; together they determine what is generated next.
• Action chain (action residual): W/A/S/D movement + I/J/K/L viewpoint form 8-dimensional continuous action signals (values [0,1]), which are converted via sin/cos encoding and causal temporal convolution (under 10M parameters) into per-frame action residual, injected into generation after per-frame alignment with the corresponding video tokens.
• Text chain (cross-attention): Natural language instructions are encoded into language tokens by the language model and written into the current generation via cross-attention, enabling mid-generation semantic rewriting.
• Decoupled dual chains, continuously parallel: When the text condition changes, the action chain is not interrupted, so effects such as "a dragon breathing fire while flying in its original direction" can be achieved, allowing rewriting while operating.
• Learning "mid-generation rewriting" through training: During training, the Prompt is switched midway through autoregressive generation, preserving the already generated visual history and action history, and predicting the continuation under the new text condition. The rewriting capability is a native capability learned through training, not an add-on feature stitched together at inference time.
• Error-accumulation-resistant training: The "history" in autoregressive generation is the model's own output, and errors accumulate; during training, Zing-0.5 actively perturbs part of the historical frames (adding noise, slight blur, color shift, viewpoint changes) to simulate real errors, while the training target always remains clean, forcing the model to learn to discern the true state from imperfect history.
• Pure training solution, zero inference overhead: The anti-accumulation capability is fully internalized in the weights; online inference requires no additional error-correction model and adds no latency or compute.
• Four-step DMD distilled sampling: Compressing diffusion sampling to 4 steps is the key to single-GPU real-time performance (>24 FPS) and low cost (about 6 cents per minute).
• Sliding-window attention adapts to VRAM: For 80GB+ VRAM use --local-attn-size 97 --sink-size 9; for RTX 4090 level use --local-attn-size 33 --sink-size 5, maintaining long context within limited VRAM through local attention + sink tokens.
• Output pipeline: Video frames enter the Causal DiT as tokens via patch embedding, and the predicted frames are decoded and output as H.264-encoded 24 FPS MP4.

How to use Zing-0.5

• Environment preparation: Prepare hardware and system: Linux system + NVIDIA GPU (80GB+ VRAM recommended, such as H100/A100; RTX 4090 level can use the sliding-window attention configuration), install the basic environment: Python 3.11, PyTorch 2.9, CUDA.
• Get the code and model
  • Clone the code repository:git clone https://github.com/seedleap/zing-world-model.git, enter the directory cd zing-world-model。
  • Install dependencies:pip install -r requirements.txt。
  • Download the model weights:pip install modelscope, then run modelscope download --model seedleap/Zing-0.5 --local_dir ./Zing-0.5。
  • Confirm the directory structure: the weights contain generator/model.pt(generator) and pretrained/（text_encoder、tokenizer、vae）。
• Run inference
  • Text-driven mode (Action T2V): run run.sh, specify --pretrained-dir、--checkpoint、--messages examples/case3_action_t2v.jsonl, the output directory, and the random seed.
  • Image initialization mode (Action TI2V): also use run.sh, switch to examples/case4_action_ti2v.jsonl and other image-to-video configurations.
  • Choose attention parameters by VRAM: for 80GB+ add --local-attn-size 97 --sink-size 9; for below 80GB add --local-attn-size 33 --sink-size 5; for full history attention use --local-attn-size -1 --sink-size 0。
• Interactive operation
  • Keyboard controls: W/A/S/D control forward/backward/left/right movement, I/J/K/L control viewpoint rotation (internally an 8-dimensional continuous vector with values in [0,1]).
  • Mid-generation semantic rewriting: input natural language instructions during generation (such as "blizzard" or "dragon mouth breathing fire"), and the world responds in real time without the scene being reset.
• View the output: The generated result is an H.264-encoded 24 FPS MP4 file, saved in the specified --output-dir directory.
• Zero-deployment experience (optional): If you don't want to deploy locally, you can wait for the official product: the corresponding feature is expected to launch on the overseas version of the Loopit APP within two weeks, letting you experience the real-time interactive world directly in the App.

Zing-0.5's core advantages

• Hard power as the No. 1 on the real-time leaderboard: WBench evaluation average score 81.0, ranking second on the overall leaderboard, behind only a non-real-time bidirectional model, and first on the real-time world model leaderboard.
• "Edit while playing" in a class of its own: Most real-time world models only support "exploring scenes," while Zing-0.5 is one of the few models that can rewrite the world with text midway while controlling movement; joint control is the core differentiator.
• Rewrite without swapping the world: New instructions are precisely written into the current world, changing only what should be changed (adding a blizzard, making a dragon breathe fire), while what should not be touched (characters, art style, distant scenes) remains completely unchanged; similar models often "conveniently swap out the entire world."
• Long sequences stay on track: During training, historical frames are actively perturbed so the model learns error correction, keeping character appearance and scene structure stable during long generation; moreover, this is a pure training-stage solution, requiring no additional error-correction model at inference time and adding no latency.
• Both cost and barrier to entry are low: 5B parameters, single-GPU deployment, over 24 FPS on a single RTX 5090, and one minute of streaming inference costs only about 6 cents; real-time interaction is possible on consumer-grade GPUs.
• Lightweight and elegant architecture: The action control path has less than 10M parameters (sin/cos encoding + causal convolution → frame-by-frame action residual), and the dual control paths jointly enter the Causal DiT, making the design simple and efficient.
• Truly open source: Under the Apache 2.0 license, the full set of code + weights + deployment documentation is open, with no barrier to commercial use; the base model Wan2.2-TI2V-5B is mature and reliable.

Zing-0.5's project addresses

• GitHub repository：https://github.com/seedleap/zing-world-model
• HuggingFace model repository：https://huggingface.co/seedleap/zing-0.5
• ModelScope：https://modelscope.cn/models/seedleap/Zing-0.5

Comparison of Zing-0.5 with similar competitors

Application scenarios of Zing-0.5

• AI interactive entertainment/AI games: Players use the keyboard to control characters exploring in generated worlds, and can rewrite the plot and environment at any time with language (such as making it snow or summoning monsters), realizing "generative games that everyone can play."
• "Playable TikTok"-style content consumption: Short videos change from "watching" to "playing"; each user plays out different directions within the same piece of content, reshaping the form of content platforms.
• UGC interactive content creation: Creators generate interactive video worlds for fans to experience; audiences are no longer bystanders but participants, spawning a brand-new content category.
• Rapid validation of game prototypes: Game teams do not need to build engine scenes; they can use the world model to quickly generate interactive demos and validate gameplay and level ideas at low cost.
• Virtual livestreaming/virtual streamers: Streamers drive the virtual world in real time, and viewers participate through bullet-screen text to rewrite scenes and events, enhancing livestream interactivity.