Kunlun Tech Opens Matrix-Game 3.5, but Its Real-Time Claim Still Needs a Public Test

Kunlun Tech released Matrix-Game 3.5 with an unusually specific promise: interactive 720p world generation at about 20 frames per second on one GPU. The Kunlun Tech Matrix-Game 3.5 open-source world model also adds geometric memory designed to preserve locations across minute-long video sequences. However, the public package does not yet include the distilled models behind its headline speed.

That gap makes this more than another model launch. Kunlun Tech has published code, base weights, and an inspectable memory architecture. Developers can examine how the system recalls scenes and controls cameras. They cannot yet reproduce the complete real-time configuration using the available checkpoints.

The immediate contest is therefore not Kunlun Tech against every world-model developer. It is open technical access against closed, integrated systems such as Google DeepMind’s Genie 3. Google offers a polished navigable experience, while Kunlun Tech is betting that outside developers will accept more setup work in exchange for architectural control.

Kunlun Tech Released an Open World Model, but Not the Full Real-Time Stack

Matrix-Game 3.5 turns persistent visual memory into the central feature of an interactive video model.

Kunlun Tech introduced the model during its July 19 event at the 2026 World Artificial Intelligence Conference in Shanghai. Skywork chief scientist Cheng Yu presented the system as the latest version of the Matrix-Game series.

The company’s official launch post describes a five-billion-parameter model that generates camera-controlled video in first-person and third-person modes. Kunlun Tech says it can maintain useful memory across roughly one minute of generation.

The release arrives as video generators are moving beyond isolated clips. A conventional video model creates a sequence that looks plausible from one frame to the next. An interactive world model must also respond to actions while preserving locations, subjects, and prior events.

That difference becomes obvious when a virtual camera turns around. A video generator can produce a convincing turn while quietly replacing the street behind the viewer. An interactive environment must remember the original street and reconstruct it from the new viewpoint.

Matrix-Game 3.5 addresses this problem through Patch Memory. A patch is a small region extracted from a previous frame. The model associates that region with estimated depth and camera position, giving the memory a location in three-dimensional space.

When the camera returns, the system retrieves patches expected to be visible from the current position. It then reprojects them into the new view and supplies the resulting mosaic to the video generator.

Kunlun Tech pairs that memory system with Warped PRoPE. Positional encoding tells a transformer how visual tokens relate across time and space. Warped PRoPE adds camera projection information, including changes in viewpoint and perspective, to those relationships.

The release also separates static scenery from moving subjects. Terrain, buildings, and fixed objects can enter long-term geometric memory. Characters and vehicles receive separate reference tokens intended to preserve their appearance without freezing an outdated position.

That separation matters because indiscriminate memory creates its own errors. If the system remembers a car as part of a street, the car can reappear after moving elsewhere. The result might be a duplicate, a visual trail, or a stationary ghost.

The public repository includes first-person and third-person base checkpoints under an Apache 2.0 license. It also includes memory reprojection components, example inputs, configuration files, and inference code.

The available models build on Wan2.2-TI2V-5B, a text-and-image-to-video foundation. Users must separately download its text encoder, video autoencoder, transformer components, and tokenizer. The pipeline also depends on Depth Anything 3 for metric depth estimates.

This is a meaningful release. Developers can inspect the implementation, modify memory behavior, and generate their own sequences. They can also study the system’s failures instead of relying entirely on selected demonstration videos.

However, Kunlun Tech has not released every component tied to its main performance claim. The repository says that distilled real-time autoregressive models will arrive later. The currently available base models use a slower bidirectional generation process.

That distinction changes how the launch should be read. Matrix-Game 3.5 is open enough for architectural evaluation, but not complete enough for independent verification of the announced 20-frames-per-second mode.

Why Patch Memory Is the Main Matrix-Game 3.5 Bet

Kunlun Tech is treating long-term consistency as a retrieval problem rather than asking one video context window to remember an entire world.

Most generative video systems work with limited recent context. They preserve enough preceding frames to keep motion reasonably smooth. Details outside that window become vulnerable to replacement or distortion.

Extending the context window does not automatically solve the problem. Every added frame consumes computation and contains information that may be irrelevant to the current view. Old frames also capture the environment from outdated camera positions.

Patch Memory uses selective recall instead. The system stores localized observations and retrieves only those associated with the camera’s present viewing area. This gives the generator targeted evidence about what should appear.

The process starts by estimating depth for earlier frames. Depth indicates how far each visible point sits from the camera. The system combines that estimate with camera pose, which records the camera’s position and orientation.

Those inputs let Matrix-Game 3.5 lift image patches into a shared spatial coordinate system. When the camera changes position, the model can identify which remembered patches should remain visible.

The system then reprojects those patches into the current camera view. This produces a partial mosaic rather than a complete rendered scene. Empty or uncertain regions still require generation.

That division is important. The memory does not rigidly dictate every output pixel. It gives the diffusion transformer relevant historical evidence while leaving the underlying video model room to generate motion and new content.

Warped PRoPE supplies a second part of the mechanism. Standard rotary positional encoding helps attention layers represent relative token positions. The camera-aware version incorporates projection matrices into that encoding.

In practical terms, Patch Memory answers, “What did this region look like before?” Warped PRoPE helps answer, “How should that observation relate to the current viewpoint?”

Kunlun Tech says this design does not require additional backbone parameters. That matters because a larger memory mechanism can easily undermine an efficiency claim. A parameter-free geometric layer can add structure without expanding the main model.

The model’s static and dynamic branches address another tension. Geometry is useful for permanent objects, but harmful when applied carelessly to moving subjects.

Matrix-Game 3.5 uses motion detection and segmentation to filter dynamic objects from geometric memory. Multi-view reference tokens then carry a subject’s identity and appearance across frames.

This approach supports both first-person worlds and third-person scenes. The third-person checkpoint can accept up to four cropped reference images for a protagonist. Those references help the model preserve clothing, shape, and other identity cues.

The design resembles retrieval in a searchable knowledge base. An AI system rarely needs every historical item loaded at once. It needs relevant evidence retrieved for the current task.

Visual memory adds a harder constraint, however. Retrieved information must be geometrically aligned. A correct building patch is still harmful when projected onto the wrong side of a road.

Depth errors can therefore spread into memory errors. An inaccurate estimate places a patch at the wrong distance. Camera-pose drift can rotate or translate it incorrectly.

Occlusion creates another challenge. A building remembered behind a vehicle should not appear through that vehicle. The system needs visibility logic that distinguishes useful history from content currently hidden.

Dynamic-object filtering can also fail. Subtle movement, shadows, reflections, vegetation, and camera motion can complicate segmentation. A mistaken classification might erase useful scenery or preserve an outdated subject position.

The model’s technical report frames these components as a unified solution for scene recall, camera control, and identity consistency. The architecture directly targets common failures in long-running generated video.

Still, geometric consistency is not physical understanding. A system can remember the position of a door while generating impossible collisions around it. It can preserve a character’s jacket while ignoring the consequences of that character’s actions.

Patch Memory is therefore a credible mechanism, not proof of a complete simulation engine. Its value depends on measurable improvements during difficult returns, reversals, occlusions, and environmental changes.

The Single-GPU Claim Pressures Closed World Models

Matrix-Game 3.5 matters strategically because Kunlun Tech is pairing inspectable architecture with a claimed professional single-GPU deployment target.

Google DeepMind established a visible comparison point with Genie 3. According to Google’s Genie 3 details, that system generates navigable 720p environments at 24 frames per second.

Google also says Genie 3 can preserve consistency for several minutes. It creates environments from text prompts and supports real-time navigation through the resulting scenes.

Those figures should not become a simplistic leaderboard. Google has not disclosed Genie 3’s model size, complete architecture, training data, or hardware requirements. The systems also use different controls, pipelines, and evaluation conditions.

Matrix-Game 3.5 claims a slightly lower rate of about 20 frames per second. Its more distinctive claim concerns accessibility. Kunlun Tech says the five-billion-parameter system reaches that rate on one GPU.

The word “one” needs context. The repository requires an Nvidia GPU with at least 40GB of video memory. Kunlun Tech reports that generation at 704 by 1280 pixels peaks near that limit.

The recommended environment also includes Linux and at least 64GB of system memory. The team tested Nvidia A-series and H-series hardware. This is professional infrastructure, not an ordinary laptop or mainstream gaming card.

Even so, a one-card configuration would lower the barrier for research labs and development teams. It avoids the coordination, communication, and memory demands of a multi-GPU deployment.

Open access adds another advantage. Researchers can adjust memory retrieval, replace camera trajectories, inspect intermediate mosaics, and introduce adversarial tests. A closed interface limits such experimentation.

Google’s advantages remain substantial. Genie 3 provides broader demonstrated scene variety and a more integrated user experience. Google can combine proprietary data, dedicated infrastructure, and direct product distribution.

Kunlun Tech offers a different bargain. Developers receive more control and more responsibility. They must assemble dependencies, manage large checkpoints, prepare camera data, and interpret failure cases themselves.

Nvidia represents another branch of the world-model race. Its Cosmos platform focuses on synthetic data, robotics, autonomous vehicles, and physical AI workflows.

Cosmos is less directly comparable with Matrix-Game’s interactive game-like generation. However, it competes for the same developer attention and infrastructure budgets. Both companies present world models as reusable foundations rather than single-purpose video tools.

The differences reveal an increasingly divided market. Google emphasizes general-purpose navigable experiences. Nvidia centers physical AI training and simulation. Kunlun Tech is trying to connect interactive media with longer-term robotics ambitions.

Matrix-Game’s history supports that infrastructure narrative. The original model used extensive Minecraft footage and action annotations. Matrix-Game 2.0 expanded toward real-time, long-running interactive generation.

Matrix-Game 3.0 then emphasized high-resolution output and long-horizon memory. Its earlier technical paper reported up to 40 frames per second at 720p using a five-billion-parameter model.

That number appears higher than version 3.5’s reported 20 frames per second. It does not establish that the new model is slower under identical conditions.

The version 3.0 result used a different inference configuration, including multiple GPUs in its documented high-speed setup. Version 3.5 adds more explicit geometric memory, camera encoding, and subject handling.

Frame rate also captures only part of interactive performance. Depth estimation, patch retrieval, video decoding, input processing, and display all contribute to perceived latency.

A system can generate frames quickly yet respond slowly to a changed command. It can also maintain a high average rate while pausing between generated blocks.

The current Matrix-Game 3.5 base model produces blocks of 80 frames. Its default configuration uses 25 denoising steps, which is not the promised few-step real-time process.

The unreleased distilled model is supposed to reduce that workload. Distillation trains a faster generator to approximate the behavior of a slower teacher model. Kunlun Tech describes a staged process that gradually transfers guidance, camera control, and memory conditioning.

If outside developers reproduce the claimed performance, the release will pressure closed providers on efficiency and access. If the distilled checkpoint arrives late or performs inconsistently, the headline advantage will weaken.

Open Code Does Not Yet Prove a Deployable Interactive World

The main uncertainty is no longer whether Kunlun Tech published useful code, but whether the complete public system can sustain its claims outside a curated demonstration.

The available package supports serious inspection. It contains two base checkpoints, an inference entry point, camera examples, depth dependencies, and memory visualizations.

A first-person run begins with an anchor image, a text prompt, and a camera trajectory. The trajectory contains camera intrinsics and extrinsics, which describe lens geometry and camera movement.

Third-person generation can add protagonist reference crops. The output directory includes the generated video and a diagnostic visualization of the mosaic memory. That diagnostic view can help developers trace alignment failures.

These features make Matrix-Game 3.5 more transparent than a demonstration-only system. Yet transparency does not automatically establish usability.

The first missing test concerns speed. The announced configuration needs a public checkpoint, exact hardware disclosure, and a complete latency methodology.

A reported 20 frames per second can mean several things. It might measure only neural generation after inputs are prepared. It might exclude depth processing, memory updates, decoding, or display.

A stronger test would measure the entire loop from user command to visible response. It would also report average latency, worst-case pauses, memory use, and performance across several minutes.

The second missing test concerns long-term consistency. A minute-long sequence is useful only if earlier scenes remain recognizable when revisited.

An independent evaluation should send the camera through a location, away from it, and back again. It should compare structural elements such as doors, windows, paths, signs, and object placement.

The test should include camera reversals, not only forward motion. Generated environments often look stable while the viewer continues moving into newly invented space. Turning back exposes whether the system retained a coherent world.

Moving subjects require separate tests. A character should preserve identity through turns and occlusion without remaining frozen in geometric memory. Vehicles should not duplicate after crossing the scene.

The third missing test concerns actions. A world model must respond reliably to controls, not merely produce attractive video around a camera path.

Evaluation should measure whether requested movement changes the output in the intended direction. Repeated commands should produce consistent effects under comparable conditions.

The fourth issue is physical behavior. Patch Memory can recall visual surfaces without maintaining an authoritative simulation state.

Traditional game engines track objects, collision volumes, inventories, scripted events, and deterministic rules. A generative video model predicts what the next frames should look like.

That prediction can support flexible visuals and rapid prototyping. It remains unsuitable for many mechanics that demand exact, repeatable outcomes.

Hybrid applications offer a more credible near-term path. A conventional engine can retain authoritative state, while a world model generates backgrounds, visual variations, or exploratory content.

Game studios could use Matrix-Game 3.5 to test scene concepts or produce interactive previsualization. Researchers could use it to study memory architectures and camera-aware generation.

Simulation teams might explore generated variations around a controlled state. Robotics researchers could investigate whether parts of its memory system transfer to sensor prediction or synthetic data production.

None of these uses requires believing that the model replaces Unreal Engine or another deterministic platform. They require a controllable generator that remains visually useful under interaction.

Hardware also narrows the immediate audience. A 40GB GPU requirement excludes most consumer systems. The single-GPU description remains accurate, but readers should not interpret it as universal local deployment.

Licensing requires review as well. The core project uses Apache 2.0, while bundled and downloaded components have their own terms. Teams must examine the Wan foundation, depth model, sample assets, and supporting libraries before commercial use.

The public release also lacks broad third-party benchmarks. Kunlun Tech’s demonstrations show intended behavior, but curated examples rarely cover difficult inputs or persistent failures.

None of these limitations proves that the company’s claims are false. They show that publication and verification are different milestones.

Kunlun Tech has reached the first milestone by releasing architecture and base weights. The second begins when independent teams can run the distilled model under disclosed conditions.

Matrix-Game 3.5 Moves the Competition From Video Quality to Infrastructure

The deeper shift is that world models are being judged as systems with memory, controls, data pipelines, and deployment constraints.

Video quality still matters. Blurred surfaces, unstable subjects, and repetitive motion can ruin an interactive experience. Yet visual quality alone no longer defines the category.

A credible world model must connect actions with future states. It must preserve relevant history without carrying every earlier frame. It must also generate quickly enough for users or agents to react.

Matrix-Game 3.5 packages those demands around a memory-centered architecture. Patch Memory handles localized scene recall. Warped PRoPE represents viewpoint changes. Reference tokens support recurring dynamic subjects.

Kunlun Tech also connects the model to a larger data strategy. The company says it has built three automated pipelines producing video, pose, action, and language data.

According to the company, those pipelines have accumulated more than five million video segments, over 10,000 effective training hours, and more than 1,200 game environments.

Those figures come from Kunlun Tech and have not been independently audited. They nevertheless clarify the company’s objective. Matrix-Game is positioned as a data and simulation layer, not only a media generator.

That positioning places the company between game generation and physical AI. Interactive game footage supplies abundant action-linked visual data. Robotics demands stronger causal and physical accuracy.

Moving from one domain to the other is not automatic. Game videos contain designed rules and visual effects that differ from the physical world. Camera motion does not equal robot action.

However, both domains need memory and prediction. A robot should remember an object after it leaves view. An interactive video model should remember a building after the camera turns away.

The shared technical problem explains why many companies use the same “world model” label for different products. The label can describe navigable video, synthetic training systems, predictive sensor models, or internal agent representations.

Matrix-Game 3.5 belongs most clearly to the interactive video branch. Its public inputs are an image, camera trajectory, text prompt, and optional subject references. Its output is generated video.

Calling it a complete simulator would overstate the evidence. Calling it an ordinary video generator would ignore its explicit memory and control mechanisms.

The release is best understood as open infrastructure for testing persistent interactive generation. Its importance comes from exposing a concrete design that other teams can inspect, challenge, and extend.

The architecture might influence competitors even if Matrix-Game never becomes a major product. Patch-level geometric retrieval offers a testable alternative to relying on larger context windows or permanent reconstructed scenes.

It also creates clearer evaluation questions. Researchers can measure whether retrieved patches improve scene recall. They can test whether camera encoding reduces geometric drift.

They can identify cases where static and dynamic separation fails. Open code lets those findings lead to patches, forks, and alternative checkpoints.

That feedback loop is the strongest argument for the release. Closed systems can deliver impressive experiences, but external researchers cannot easily isolate their mechanisms.

Kunlun Tech still needs adoption, documentation, and reliable checkpoints to benefit from openness. A repository without maintained integrations can quickly become an archival artifact.

The next phase will reveal whether Matrix-Game 3.5 becomes a foundation for outside work or remains primarily a conference-era reference implementation.

What to Watch After the Matrix-Game 3.5 Release

Three signals will determine whether the open release supports Kunlun Tech’s efficiency story or exposes a wider gap between its architecture and deployment claims.

The first signal is the distilled real-time checkpoint. Kunlun Tech needs to release the promised autoregressive weights with exact hardware and software configurations.

Independent teams should test the Kunlun Tech Matrix-Game 3.5 open-source world model at 720p with memory enabled. Results should include end-to-end latency, sustained frame rate, video-memory use, and control responsiveness.

Successful reproduction near 20 frames per second would strengthen Kunlun Tech’s challenge to closed systems. A delayed checkpoint or inconsistent results would weaken the launch’s main efficiency claim.

The second signal is independent long-horizon evaluation. Researchers should test repeated returns, camera reversals, occlusion, moving subjects, and structural changes.

Those tests must separate visual recall from physical prediction. Remembering a wall does not show that the model understands collision. Preserving a person’s face does not show that it tracks the person’s state.

Clear gains over Matrix-Game 3.0 would support the Patch Memory thesis. Small or inconsistent gains would suggest that geometric retrieval solves only part of persistent world generation.

The third signal is outside adoption. Useful evidence includes maintained integrations, published experiments, fine-tuned checkpoints, and applications created without Kunlun Tech’s direct involvement.

Repository stars measure attention, not infrastructure value. Repeated use in research, game prototypes, simulation workflows, or hybrid engine systems offers a stronger signal.

Developers evaluating Matrix-Game 3.5 should begin with narrow tests. Record camera paths, prompts, hardware, latency, and visible failures. Repeat those tests when the distilled model arrives.

The central question is now concrete: can an open five-billion-parameter system remember a generated world while responding at interactive speed on one professional GPU? The answer will determine whether Matrix-Game 3.5 becomes reusable infrastructure or remains an ambitious preview.