MIRA Open Source: Real-Time Rocket League for 4 Players on a Single B200

An Open-Source World Model That 4 People Can Play Simultaneously

Yesterday, General Intuition, Kyutai, and Epic Games jointly released MIRA — a 5B-parameter latent diffusion world model. What it does sounds almost absurd: it stuffs the entire 2v2 rocket-powered soccer game Rocket League into a neural network, allowing 4 real players to control it simultaneously with gamepads, each receiving a real-time 20 FPS video stream generated frame by frame entirely by the model. The hardware requirement: just a single B200.

No physics engine, no collision detection, no rendering pipeline. Whether the ball flies, the cars flip, or goals are scored is all something the model "imagines" on its own.

This is not the first interactive world model — Google’s Genie 3 and GameNGen have done similar things before — but MIRA is the first open-source project to truly make "real-time multiplayer" work. Genie 3 is still a closed demo to this day, GameNGen was single-player DOOM, while MIRA directly dumped the code, a 1,000-hour dataset, and the technical report onto GitHub.

Three Key Technical Choices

After reading through the technical report, MIRA’s architecture is actually quite pragmatic, with nothing mystical about it. The core comes down to three decisions:

First, using a Representation Autoencoder instead of a traditional VAE. This is where the "RA" in the paper title comes from. The latent space of traditional world-model VAEs contains weak semantic information, forcing the model to spend a lot of capacity learning basic representations like "this is a car, that is a ball." MIRA replaces the encoder with an RA that includes semantic priors, so the latent variables themselves already contain structure. The diffusion backbone can then focus on learning dynamics, resulting in significantly better parameter efficiency. The autoencoder deserves a lot of credit for achieving these results with only 5B parameters.

Second, frame-by-frame generation with extremely few denoising steps. 20 FPS means each frame has only a 50ms budget, while simultaneously handling the viewpoints of 4 players. MIRA uses distilled low-step diffusion (the technical report mentions near single-step/few-step generation), combined with the B200’s FP8 compute performance, to push latency into a playable range. The engineering effort here is arguably more hardcore than the model architecture itself.

Third, fully synthetic data. Training used 10,000 hours of synthetic Rocket League data, which actually isn’t that large in scale — tiny compared to internet-video-scale datasets like Genie. But because it’s synthetic data, every frame precisely corresponds to keyboard inputs and game state (ball, cars, score), making the supervision signal extremely clean. The open-source 1,000-hour subset is called kyutai/rocket-science and is already available on HuggingFace.

from mira.data import RocketScienceDataset

ds = RocketScienceDataset.from_hub(
    \"kyutai/rocket-science\",
    split=\"test\",
    shards=1
)
# Each clip contains 16 frames sampled at 20 FPS
clip = ds[0]
print(clip.frames.shape)      # (16, H, W, 3)
print(clip.actions.shape)     # (16, action_dim)
print(clip.game_state)        # ball / cars / score

Why "Multiplayer" Is Such a Big Deal

Single-player world models have already become heavily optimized over the past two years — from GameNGen to Oasis, people have recreated DOOM, Minecraft, racing games, and more. But the moment multiplayer enters the picture, progress stalls collectively, for very straightforward reasons:

• Action space explosion. With 4 players, each with independent keyboard inputs, the model must reason over a high-dimensional joint action space at every step. Errors cascade across all players’ viewpoints.
• View consistency. If Player A knocks the ball away, the ball must fly identically in Player B’s screen as well, otherwise the entire match collapses. This is a nontrivial consistency problem for diffusion models.
• Latency cannot accumulate. Single-player systems can tolerate occasional stutters. In multiplayer, if even one viewpoint lags by 100ms, the experience falls apart.

MIRA’s solution is to treat all 4 viewpoints as a joint generation task, sharing a single hidden state before decoding into each individual player’s view. The technical report calls this a "shared world latent." In essence, the model internally maintains a kind of "god’s-eye-view" world state, which is then projected into each player’s camera perspective. The idea is somewhat similar to the authoritative server architecture used in traditional game engines — except the server is now a single B200.

What It Feels Like in Practice

I spent half an hour playing the demo (there’s an online version at generalintuition.com/mira — there’s a queue, but you can get in). A few immediate impressions:

• The visual quality is a tier below Genie 3, especially with noticeable motion blur and edge artifacts, but for real-time generation at 20 FPS it still exceeds expectations.
• The physics "feel right." The ball bounces, car acceleration, and double-jump hover timing are all model hallucinations, yet they align with the muscle memory of veteran Rocket League players. This suggests the distribution of the synthetic data was genuinely learned.
• It still breaks occasionally. Balls suddenly disappearing, cars clipping through walls, scores jumping randomly — all the classic world-model problems are still there. After more than two minutes of play, obvious drift usually appears.
• Multiplayer synchronization is surprisingly stable. Four people really can play soccer inside the same "dream," and that impressed me more than what the technical report described.

Why This Matters

In the short term, MIRA is a very polished technical demo, but it won’t replace any real game engine anytime soon — latency, stability, and controllability are still far from sufficient. With Epic Games involved, I see this more as a long-term bet on the direction of "neural rendering + neural physics."

Over the medium to long term, the value of this work exists on three levels:

1. Low-cost synthesis of multi-agent interactive environments. RL training requires huge numbers of environments. Models like MIRA could eventually serve as "neural simulators," especially for multi-agent interaction scenarios, scaling more easily than traditional engines.
2. World models are beginning to gain "social properties." Previously, all interactive world models were single-player experiences. MIRA proves that the same set of neural weights can support multiple users simultaneously, which is a critical prerequisite for future AI-native games and virtual social systems.
3. The compute advantages of the B200 are finally being realized. Running 5B parameters + 4 viewpoints + 20 FPS is not feasible on an H100, while the B200’s FP8 performance and memory bandwidth make this demo possible. Over the next year, there will likely be more and more real-time generation applications that "require the newest GPUs to run."

Comparison with Domestic Projects

China has recently seen similar open-source efforts, such as AutoNavi’s DreamX-World 1.0, which is also a 5B-parameter general interactive world model emphasizing single-GPU operation and long-duration interaction. The tradeoffs between the two are somewhat different: DreamX focuses more on general scenarios and long-term consistency, while MIRA is obsessed with multiplayer real-time interaction and action precision. Interestingly, both projects converged on the same parameter scale — 5B seems to be emerging as a sweet spot for "single-GPU real-time world models."

Looking further back, there are also Microsoft’s Muse and Google’s Genie series. As of now, MIRA is the only one that is truly open-source, runnable locally, and supports multiplayer.

Getting Started

The repository already includes complete training and inference code:

# One-time environment setup (requires NVIDIA GPU)
git clone https://github.com/mira-wm/mira
cd mira && bash setup.sh

# Run tests
pytest tests/

# Start local inference
python -m mira.serve --checkpoint <ckpt> --players 4

For inference, the official recommendation is a B200. An H100 can also run it, but requires lowering the frame rate or reducing the player count. If you want to reproduce training, a 1,000-hour subset of the 10,000-hour synthetic dataset is currently open-source, while the remainder must be generated yourself — the Rocket League bot match scripts are also included in the repository.

At ICML (booth 111), they set up a live demo using PlayStation controllers. If you’re attending the conference, it’s worth checking out — reportedly the queue already stretches to the neighboring booth.

A Final Take

MIRA is not the kind of model that will immediately transform the industry, but it is an extremely solid milestone on the path toward "neural game engines." It proves three things: real-time multiplayer interactive world models are feasible, 5B parameters are sufficient, and training world models with synthetic data is a viable path.

For developers, what matters isn’t "can I use this to make games," but rather the open-sourced combination of Representation Autoencoder + low-step diffusion + shared latent state. Swap in a different application scenario — robotics simulation, autonomous-driving closed-loop testing, multi-agent RL environments — and the same toolkit becomes useful there too.

True world models are still far away, but MIRA shortens the meaning of "far" a little.

References

• MIRA GitHub Repository — Complete training/inference code and documentation
• MIRA Release Discussion (r/MachineLearning) — Original author post and community discussion
• Introducing MIRA (r/accelerate) — Project introduction and online demo link
• DreamX-World 1.0 Analysis (Zhihu) — Comparison reference for a contemporary domestic 5B world model