Yes, you can run Matrix-Game 4.0 locally, but the documented inference setup is specific: use Linux, Python 3.12, a compatible NVIDIA GPU, and the matching runtime preset. The most straightforward consumer configuration is an RTX 5090 with the explicit rtx5090 preset. Download one supplied scene and its model files, verify the SHA256 manifests, render an offline clip, and only then bring up the WebRTC browser demo.
Matrix-Game is not a conventional game engine that generates gameplay by itself. The game engine owns gameplay state, physics, and input; a causal video model turns the engine’s low-poly RGB stream into the final visual output. HUD and sound are presentation layers outside the model. The release includes Medieval Castle, Ancient Egypt, and City Racing scenes.
As an Amazon Associate I earn from qualifying purchases.
What Matrix-Game 4.0 actually runs
Matrix-Game 4.0 is Kunlun Tech and Skywork AI’s open-source playable-game system. Its architecture separates simulation from visual synthesis:
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →- Game engine: maintains world state, collision and physics, and accepts player input.
- Low-poly stream: supplies a compact RGB representation of the current game state.
- Causal video model: renders the stream into the final frames you see.
- HUD and audio: remain outside the generative model as presentation systems.
That division matters when you troubleshoot. A visual artifact does not necessarily mean the game simulation is wrong, and a missed input can originate in the engine, capture pipeline, WebRTC transport, or browser rather than in the video model. The published setup is a demonstration of the three included worlds, not a general-purpose tool for training arbitrary new game environments. Training code and training data are not included.
#1 Best Overall
- First-Ever Matrix Deck Building Game: Experience the groundbreaking deck building game set in the iconic Matrix movie franchise
- Legendary Encounters Series: Follow the white rabbit into the world of The Matrix with this exciting addition to the Legendary Encounters Deck Building Game System
- Recruit Iconic Heroes: Play as legendary characters including Morpheus, Trinity, Niobe and even Neo, known as The One
- Battle Notorious Adversaries: Fight against formidable enemies like Agent Smith, the Merovingian, the Twins, the Sentinels and more as you work to free humankind from The Matrix
- Cooperative Multiplayer Experience: Play cooperatively with up to 5 players simultaneously with the included playmat to guide your journey
Supported operating systems, Python and GPU requirements
The documented inference path targets Linux, Python 3.12, and an NVIDIA GPU. The reference deployment uses PyTorch 2.12.0 with CUDA 13.2 on an NVIDIA A100. A separate runtime preset is provided for the RTX 5090. Hardware selection is not automatic, so choosing the correct preset is part of the launch command.
| Use case | Documented baseline | Important qualification |
|---|---|---|
| Inference and offline rendering | Linux, Python 3.12, NVIDIA GPU | Install a driver compatible with the selected CUDA and PyTorch stack. |
| Reference A100 path | PyTorch 2.12.0, CUDA 13.2 | The published frame-rate figures are server-side measurements on one A100-SXM4-80GB. |
| RTX 5090 path | Use the explicit rtx5090 preset |
The plain preset uses PyTorch SDPA; it does not auto-detect your card. |
| Optimized RTX 5090 path | rtx5090-sage |
Requires a separately built, patched SageAttention implementation. |
| Browser demo | Linux host running the game and GStreamer pipeline | Safari and Chrome are the documented desktop clients. |
| Standalone game or recording | macOS or Linux, CMake, C++20, SDL2 and FFmpeg | The legacy Windows entry remains in the project but has not been validated for feature parity. |
Before creating the environment, confirm that your NVIDIA driver supports the CUDA 13.2 wheels and that the driver, PyTorch and Triton versions are mutually compatible. If you are using a different GPU generation, do not assume the RTX 5090 preset is appropriate; use the runtime configuration intended for your hardware or expect to troubleshoot unsupported kernels yourself.
Prepare the Linux environment
Run the following commands from a terminal. They clone the repository, enter the version-4 directory, create an isolated Python 3.12 environment, install the reference CUDA-enabled PyTorch build, and install Matrix-Game’s inference, server, download and test extras.
Recommended Free Tools
git clone https://github.com/SkyworkAI/Matrix-Game.git
cd Matrix-Game/Matrix-Game-4
python3.12 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
python -m pip install torch==2.12.0 torchvision==0.27.0 --index-url https://download.pytorch.org/whl/cu132
python -m pip install -e '.[inference,server,download,test]'The repository is the authoritative place to check any release-specific changes: Matrix-Game on GitHub. Keep the virtual environment active whenever you invoke the matrix-game command. If your shell cannot find that command, run source .venv/bin/activate again and confirm that the prompt points at the v4 directory.
Choose one scene and keep downloaded files outside Git
Matrix-Game ships three scenes: castle (Medieval Castle), ancient-egypt (Ancient Egypt), and racing (City Racing). Start with one scene rather than downloading everything. The project’s documented layout places large files in a separate resources/ directory, so your repository remains manageable and you can delete or replace assets without recloning the source tree.
Each scene needs more than model weights. The asset set includes the game files, fast codec, sink images and related resources. Shared tokenizer and Wan VAE files come from a pinned base-model revision. The downloader checks the expected file sizes and SHA256 hashes against the manifests, while the explicit verify commands let you detect an incomplete or corrupted transfer before loading a model.
Rank #2
- MULTIPLICATION WITH A STRATEGIC TWIST – Roll the dice, build equations, multiply and pop matching numbers on your Matrix pad. Addition and subtraction can be used within equations, creating more possibilities with every roll.
- EASY TO LEARN, DIFFERENT EVERY GAME – Simple rules get play started quickly, while changing dice rolls challenge players to find new combinations and make smart choices. Play competitively with family and friends or practice on your own.
- SATISFYING BUBBLE-POP GAMEPLAY – Skip pencil-and-paper scorekeeping. Reusable silicone bubble mats let players press their answers as they play, adding a colorful, tactile element to multiplication practice.
- MADE FOR KIDS, ADULTS & SENIORS – Designed for ages 8+, Matrix combines arithmetic, strategy and hands-on play in a game families can enjoy together. Also well suited for classrooms, homeschool, tutoring and independent practice.
- EVERYTHING NEEDED FOR UP TO 4 PLAYERS – Includes 4 reusable double-sided Matrix bubble mats, 4 blue number dice, 1 red wild die, 1 multiplier die, dice bag and instructions. Complete one side, flip the mat over and play again.
The examples below use Ancient Egypt. Replace ancient-egypt with castle, racing, or all where the command accepts a scene selector.
Free tools Windows power users keep installed
One-click scans. No signup required.
matrix-game download --manifest releases/game-assets.json
--repo-id Skywork/Matrix-Game-4.0 --repo-type model
--revision 4419accdb7bb7881234c5914de8cd915266e0325
--scene ancient-egypt --resources resources
matrix-game download --manifest releases/models.json
--repo-id Skywork/Matrix-Game-4.0 --repo-type model
--revision 4419accdb7bb7881234c5914de8cd915266e0325
--scene ancient-egypt --resources resources
matrix-game verify --manifest releases/game-assets.json
--scene ancient-egypt --resources resources
matrix-game verify --manifest releases/models.json
--scene ancient-egypt --resources resourcesWhy the revision is pinned
The long revision value fixes the exact base-model files used by the commands. Keeping it unchanged makes a reinstall reproducible and prevents a later repository update from silently replacing shared tokenizer or VAE files. Change it only when the project documentation specifies a newer compatible revision.
Plan storage twice
You need space for the installed copy in resources/ and for the Hugging Face cache created during download. A download can therefore require substantially more free disk space than the final model directory appears to use. A high-capacity NVMe SSD is useful for reducing load and cache delays, but storage does not substitute for GPU memory.
Run an offline render before starting a live session
An offline render is the safest first test because it removes browser, WebRTC and input-transport variables. Supply a low-poly input movie and let the model produce the final clip:
matrix-game render --scene ancient-egypt --input lowpoly.mp4
--resources resources --preset realtime --prompt-mode fixed
--output outputs/egyptOn an RTX 5090, use --preset rtx5090 instead of --preset realtime:
matrix-game render --scene ancient-egypt --input lowpoly.mp4
--resources resources --preset rtx5090 --prompt-mode fixed
--output outputs/egyptThe command writes rendered.mp4 and a configuration report in the output directory. The documented pipeline preserves the input frame rate and frame count. Internally, only a final incomplete four-frame block is padded; those frames are trimmed from the result, so the output does not gain extra tail frames.
Rank #3
- Cooperative Game: DCeased: Gotham City Outbreak is a strategy game where players control the last uninfected superheroes of DC Comics facing off against zombie heroes & hordes; over 12,000 fans pledged on Kickstarter to bring this project to life
- Enter The World Of Zombicide: Based on the core mechanics of the smash hit Zombicide series, DCeased brings the zombie action to the DC Universe; combine this DC variant with Marvel Zombies to expand the story & gameplay even further
- How To Play: Complete mission objectives, defeat your enemies, & rescue endangered bystanders with mini figures of your favorite DC characters including Batman, Harley Quinn, Robin, Poison Ivy, Bane, & Batgirl
- Family Game Night: Keep the fun going with more Spin Master Games to add to your family’s board game shelf: Hedbanz, Beat the Parents, Family Feud, Jumanji, Wicked: The Game, Mind the Gap & more
- Spin Master Games & Toys: Looking for kids games, yard games & card games for adults, kids or teens? Find family favorite puzzles & games for family game night, travel games, kids puzzles & more
What a successful first run proves
- The selected scene files and model manifests are complete.
- Your CUDA, PyTorch and Triton combination can initialize the chosen preset.
- The video codec and output path work before a real-time server is introduced.
- The low-poly input is in a format the scene pipeline can consume.
If this step fails, fix it before attempting the browser demo. A browser launch cannot repair a missing model shard, incompatible kernel or invalid input movie.
Launch the WebRTC browser demo
The browser mode uses a MediaMTX-backed WebRTC service. The Linux host must build and run the native game, provide the media dependencies, and have the scene resources available. Once the offline path works, start the server with:
CUDA_VISIBLE_DEVICES=0 bash scripts/serve.sh
--scene ancient-egypt --resources resources
--preset rtx5090 --prompt-mode fixed --fps 40Set CUDA_VISIBLE_DEVICES to the GPU you intend to use. Because the project does not automatically choose hardware, pair the visible device with the corresponding preset. For an A100 deployment, use the preset documented for that installation rather than copying the RTX 5090 option blindly.
Expect a long first startup
The server warms up kernels and captures CUDA graphs before accepting a session. Startup can therefore be noticeably longer than steady-state rendering. Do not interpret a quiet terminal during warm-up as a hung server unless it exits or reports an error; wait for the service to announce that it is ready.
Connect with a documented desktop client
Safari and Chrome are the documented desktop clients. Open the demo endpoint exposed by your MediaMTX configuration after the server reports readiness. Browser playback rate is not the same measurement as the model pipeline’s rendering rate: the --fps 40 option controls the game-capture cadence requested by the server, not a guarantee of 40 rendered frames per second or of a particular action-to-photon latency.
Understand the published performance numbers
The README reports measurements from one NVIDIA A100-SXM4-80GB at 864×480 with one denoising step, TAEHV encoding and decoding, SDPA, a fused DiT implementation and CUDA graphs. With fixed prompts, Castle and Ancient Egypt run at approximately 38–39 frames per second, while Racing runs at approximately 38.5 FPS. Racing with dynamic prompts is slower at approximately 28.9 FPS.
Rank #4
- GAMEPLAY OVERVIEW: Immersive sci-fi board game where players lead alien research teams to explore an uncharted planet, gather specimens, and advance their civilization's knowledge
- PLAYER COUNT: Supports 1-4 players, making it perfect for both solo adventures and group gaming sessions with strategic depth and replayability
- AGE RATING: Designed for players aged 14 and above, offering complex decision-making and sophisticated gameplay mechanics
- MISSION OBJECTIVES: Players must carefully deploy away teams, collect vital specimens, and maintain stealth while competing to earn recognition from the Elders
- STRATEGIC DEPTH: Each decision impacts your quest for enlightenment, requiring careful planning and resource management to succeed in your extraterrestrial expedition
| Scene and prompt mode | Reported server-side rate | Conditions |
|---|---|---|
| Castle, fixed prompt | Approximately 38–39 FPS | One A100-SXM4-80GB, 864×480, one denoising step, optimized pipeline. |
| Ancient Egypt, fixed prompt | Approximately 38–39 FPS | Same conditions. |
| Racing, fixed prompt | Approximately 38.5 FPS | Same conditions. |
| Racing, dynamic prompt | Approximately 28.9 FPS | Dynamic prompting adds pipeline work. |
These are server-side pipeline measurements, not browser presentation FPS and not action-to-photon latency. Network transport, browser decoding, display refresh and input handling can all change what a user experiences.
Launch coverage from Kunlun Tech presents a consumer target of 480p at 60 FPS on one RTX 5090 and input-to-response latency below 150 ms. Those figures are vendor claims, not an independently reproduced guarantee. Treat them as a target for the RTX 5090 configuration rather than as a promise that every scene, prompt mode, driver or browser will reach those numbers.
Fixed prompts versus dynamic prompts
Fixed prompts
--prompt-mode fixed is the sensible baseline for installation testing and repeatable comparisons. It matches the mode used for the higher A100 rates above and reduces one source of variability while you verify GPU utilization, frame pacing and browser playback.
Dynamic prompts
Dynamic prompting changes conditioning during runtime and can reduce throughput, as the Racing measurement demonstrates. Use it only after the fixed-prompt path is stable and you specifically need changing scene descriptions. A lower rate in this mode is expected rather than proof of a broken installation.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Choosing between the RTX 5090 and A100 paths
RTX 5090
The explicit rtx5090 preset is the easiest documented consumer route. The standard preset uses PyTorch SDPA. The optional rtx5090-sage configuration requires a separately patched SageAttention build, so it adds another compilation and compatibility dependency. Start with plain rtx5090; move to the SageAttention variant only when you have a specific reason and a matching build.
A100
The A100 path is the reference used for the published measurements and is appropriate for a Linux server with sufficient memory and a validated CUDA stack. Its frame rates should not be read as a direct prediction for a different GPU or for a browser client.
Best Value
- Shifting Maze Adventure: Immerse yourself in the thrilling, ever-changing Labyrinth. This captivating family board game offers a unique strategic experience as you navigate dynamic pathways to discover hidden treasures. Challenging fun for everyone.
- Strategic Gameplay & Treasure Hunt: Navigate the shifting labyrinth to find treasures and block your opponents. Plan your route carefully and build critical thinking, cause and effect, planning, and recognition skills to outsmart your rivals.
- Easy To Learn, Tactical Family Fun: Simple rules ensure everyone can join the fun. Strategic gameplay fosters critical thinking skills for boys, girls, and adults in this captivating labyrinth board game that encourages friendly competition.
- Endless Replayability: The ever-changing labyrinth provides hours of engaging fun as the maze is rearranged with every turn. A fresh and exciting challenge every time you play makes this a great addition to your collection of Ravensburger games.
- Great for 2-4 Players: Includes Game Board, 34 Maze Cards, 24 Treasure Cards, and 4 Playing Pieces for hours of engaging fun and strategic competition. Playing times run between 20-30 minutes while each game round presents new challenges.
Other NVIDIA cards
The documentation establishes Linux and NVIDIA as the inference baseline but does not promise that every NVIDIA model is supported. Confirm that your card can run the selected PyTorch, Triton and attention kernels before investing time in a live setup. If the project does not provide a matching preset, you may need to adapt configuration files and will be outside the documented path.
Can you run Matrix-Game on macOS or Windows?
macOS
macOS or Linux is documented for standalone game and recording work when CMake, C++20, SDL2 and FFmpeg are available. That is distinct from the GPU-accelerated model-inference path, which is documented for Linux with an NVIDIA GPU. A Mac can therefore be useful for building or recording the native game component, but the supplied inference instructions do not establish a supported Apple-GPU video-model deployment.
Windows
A legacy Windows entry remains in the project, but it has not been validated for feature parity. Do not assume that the Linux inference commands, WebRTC server or all scenes behave identically on Windows. For the least uncertain route, use a Linux host locally or a Linux NVIDIA machine remotely.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Troubleshooting by symptom
The matrix-game command is missing
- Activate the environment with
source .venv/bin/activate. - Confirm that you are inside
Matrix-Game/Matrix-Game-4. - Re-run
python -m pip install -e '.[inference,server,download,test]'if the editable install was interrupted.
PyTorch cannot access CUDA
- Check that the NVIDIA driver is installed and visible to the operating system.
- Confirm that you installed the CUDA 13.2 wheel command shown above rather than a CPU-only PyTorch build.
- Use a preset that matches the visible GPU; the project does not select one automatically.
A download completes but verification fails
- Run the corresponding
matrix-game verifycommand again to identify the manifest that fails. - Check free space for both
resources/and the Hugging Face cache. - Delete only the damaged or incomplete cached file and repeat the same pinned-revision download.
- Do not mix scene directories or revisions while diagnosing a hash mismatch.
The render starts and then crashes
- Try the documented reference preset for your hardware instead of an RTX 5090-specific option.
- Check driver, PyTorch and Triton compatibility.
- Run the smallest test with one scene and fixed prompts before changing resolution or prompt mode.
- Inspect the generated configuration report and terminal error for the failing component.
The browser page is blank or never connects
- Verify that offline rendering succeeds first.
- Wait for kernel warm-up and CUDA-graph capture to finish.
- Confirm that the native game and GStreamer dependencies are installed on the Linux host.
- Use Safari or Chrome, the documented desktop clients, and check that the MediaMTX endpoint is reachable from the browser machine.
Playback is below the requested FPS
The --fps 40 argument sets capture cadence, not measured throughput. Compare server logs and pipeline measurements separately from browser playback. Dynamic prompts, network transport, browser decoding and display refresh can each lower the visible rate.
What is included—and what is not
- Included: three playable scenes, offline rendering, and a single-user WebRTC browser demo.
- Included: model, codec, sink-image and game-asset downloads with manifest and SHA256 verification.
- Not included: training code and training data for creating arbitrary new worlds.
- Not guaranteed: a universal Windows feature set, automatic GPU selection, browser FPS equal to server FPS, or vendor launch targets on every system.
That scope makes Matrix-Game best suited to experimenting with the supplied environments and studying the engine-plus-video-model pipeline. It is not yet a documented workflow for importing any game, fine-tuning a new world, or deploying a multi-user service.
A reliable first-day checklist
- Use a Linux NVIDIA machine and install a driver compatible with CUDA 13.2.
- Create the Python 3.12 virtual environment in the v4 directory.
- Install PyTorch 2.12.0 and torchvision 0.27.0 from the CUDA 13.2 index, then install the project extras.
- Choose one scene, create the external
resources/layout, and keep enough space for the cache. - Download both manifests at revision
4419accdb7bb7881234c5914de8cd915266e0325. - Run both verification commands and resolve every hash or size error.
- Render a low-poly clip offline with fixed prompts.
- Use the matching hardware preset; choose
rtx5090explicitly on an RTX 5090. - Start
scripts/serve.shonly after offline rendering works, then wait for warm-up. - Connect from Safari or Chrome and distinguish capture cadence, server throughput and browser playback when evaluating performance.
Bottom line for local users
Matrix-Game 4.0 is locally runnable today if you have the documented Linux/NVIDIA environment and are content to use its three supplied scenes. The least complicated route is one Linux host with an RTX 5090, Python 3.12, the plain rtx5090 preset, a verified single-scene download and an offline render before WebRTC. A100 measurements provide useful server-side context, while the 5090’s 480p/60-FPS and sub-150-ms figures remain vendor targets rather than guarantees. MacOS and Windows are not equivalent substitutes for the supported inference path, and creating new trained worlds is outside this release’s documented scope.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Scan for outdated or missing drivers - takes under a minute3Clear out junk files and repair common Windows errors
