iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
Yes—you can run Kunlun Tech and Skywork AI’s Matrix-Game 4.0 locally, but the documented inference path is a Linux host with an NVIDIA GPU and Python 3.12. The most straightforward consumer setup is the explicit rtx5090 preset on an RTX 5090; an A100 path is documented for server-class hardware. Start with one supplied scene and an offline render, then move to the MediaMTX/WebRTC browser demo after the native game and media pipeline work.
Matrix-Game is not a conventional game engine replacement. The game engine owns gameplay state, physics and input, while a causal video model renders the low-poly RGB stream. The release includes Medieval Castle, Ancient Egypt and City Racing, with offline rendering and a single-user browser session. The steps below keep those responsibilities, hardware limits and performance claims explicit.
What Matrix-Game 4.0 actually runs
Matrix-Game 4.0 combines a conventional real-time game loop with a generative video renderer. The engine calculates the world, collisions, controls and other gameplay state. The causal video model turns that low-poly stream into the displayed RGB frames. The HUD and sound are presentation layers outside the model. This division matters when diagnosing a problem: a visual-generation issue is different from a game-input or physics issue.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →The public release supplies three ready-made scenes:
#1 Best Overall
- Powered by Radeon RX 9070 XT
- WINDFORCE Cooling System
- Hawk Fan
- Server-grade Thermal Conductive Gel
- RGB Lighting
- Medieval Castle
- Ancient Egypt
- City Racing
You can render a captured low-poly video to an output video without opening a browser, or run the native game and stream a single interactive session through WebRTC. Training code and training data are not published, so the documented installation is for running these supplied scenes—not for training an arbitrary new world.
Keep the project directory and downloaded resources separate. The repository contains code and manifests; model weights, codec files, sink images and game assets are downloaded into a resources/ tree. Shared tokenizer and Wan VAE files come from a pinned base-model revision. This layout lets you update code without placing large binary files inside Git.
Supported hardware, operating systems and software
Use the following matrix to choose a path before installing anything.
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| Use case | Documented host | Important requirements |
|---|---|---|
| Inference and browser server | Linux | NVIDIA GPU, Python 3.12, matching NVIDIA driver, compatible PyTorch and Triton |
| Reference high-end deployment | Linux with NVIDIA A100-SXM4-80GB | PyTorch 2.12.0 with CUDA 13.2 wheels |
| Consumer inference preset | Linux with RTX 5090 | Select rtx5090 explicitly; hardware selection is not automatic |
| Optional optimized RTX 5090 path | Linux with RTX 5090 | rtx5090-sage needs a separate patched SageAttention build |
| Standalone game or recording | macOS or Linux | CMake, a C++20 compiler, SDL2 and FFmpeg |
| Legacy Windows entry | Windows | Retained in the project, but feature parity has not been validated |
| WebRTC client | Desktop Safari or Chrome | The Linux host must build and run the game and GStreamer pipeline |
The A100 and RTX 5090 rows describe different presets, not interchangeable command names. A server with another GPU may be able to run parts of the stack, but the supplied documentation does not promise an automatic selector or a tested preset for every model. Treat the listed combinations as the reliable baseline.
Choose offline rendering or the browser demo
Offline render first
Offline rendering is the best validation step. It exercises the model, codec and scene assets without adding WebRTC, GStreamer or browser variables. You provide a low-poly input video and receive a rendered MP4. This is also the path to use for batch recordings.
Browser demo after the native stack works
The browser demo adds a native game process, capture cadence, GStreamer and a MediaMTX-backed WebRTC server. It is interactive, but startup is longer because the runtime warms kernels and captures CUDA graphs before accepting a session. A successful offline render gives you a known-good model and resource installation before you troubleshoot streaming.
Install Matrix-Game 4.0 on Linux
The commands below follow the project’s v4 directory layout. They create an isolated Python environment and install the CUDA 13.2 PyTorch wheels required by the documented reference setup.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
- Clone the repository and enter the v4 directory:
git clone https://github.com/SkyworkAI/Matrix-Game.git cd Matrix-Game/Matrix-Game-4 - Create and activate a Python 3.12 virtual environment:
python3.12 -m venv .venv source .venv/bin/activate - Update the packaging tools:
python -m pip install --upgrade pip - Install the pinned PyTorch and torchvision wheels from the CUDA 13.2 index:
python -m pip install torch==2.12.0 torchvision==0.27.0 --index-url https://download.pytorch.org/whl/cu132 - Install Matrix-Game in editable mode with the inference, server, download and test extras:
python -m pip install -e '.[inference,server,download,test]'
Check that the NVIDIA driver is new enough for the installed CUDA stack before launching a preset. The optimized path also depends on compatible PyTorch and Triton versions. The normal rtx5090 preset uses PyTorch SDPA. The separate rtx5090-sage preset is not a drop-in speed switch: it requires a patched SageAttention build installed independently.
If you are using an A100, keep the documented PyTorch 2.12.0/CUDA 13.2 combination unless the project’s own instructions for a newer release say otherwise. Mixing a wheel for a different CUDA series with the reference environment can produce import or kernel errors before a scene starts.
Download one scene and verify every file
Download a single scene first. The downloader reads manifests, retrieves the model and asset files, and checks both file sizes and SHA256 hashes. Keep the resources outside the Git checkout if you want a clean code update path. Also budget space for the Hugging Face cache: the cache can temporarily hold another copy while files are being placed in resources/.
From Matrix-Game/Matrix-Game-4, the Ancient Egypt example is:
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 resourcesVerify both manifests before rendering:
matrix-game verify --manifest releases/game-assets.json
--scene ancient-egypt --resources resources
matrix-game verify --manifest releases/models.json
--scene ancient-egypt --resources resourcesUse the exact scene identifiers castle, ancient-egypt or racing. To fetch every supplied scene, replace the scene value with all. Pinning revision 4419accdb7bb7881234c5914de8cd915266e0325 makes the download reproducible; changing it can select a different set of files. A verification failure means a file is missing or does not match the manifest, so fix the download rather than trying to bypass the check.
Rank #2
- NVIDIA Ampere Streaming Multiprocessors: The all-new Ampere SM brings 2X the FP32 throughput and improved power efficiency.
- 2nd Generation RT Cores: Experience 2X the throughput of 1st gen RT Cores, plus concurrent RT and shading for a whole new level of ray-tracing performance.
- 3rd Generation Tensor Cores: Get up to 2X the throughput with structural sparsity and advanced AI algorithms such as DLSS. These cores deliver a massive boost in game performance and all-new AI capabilities.
- Axial-tech fan design features a smaller fan hub that facilitates longer blades and a barrier ring that increases downward air pressure.
- OC Mode : 1500 MHz (Boost Clock)/Default Mode : 1470 MHz (Boost Clock)
Render a scene offline
Once both manifests verify, render a low-poly input video. The fast A100 example uses the realtime preset:
matrix-game render --scene ancient-egypt --input lowpoly.mp4
--resources resources --preset realtime --prompt-mode fixed
--output outputs/egyptFor an RTX 5090, use the dedicated preset instead:
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 under outputs/egypt. The documented renderer preserves the input frame rate and frame count. Internally, it pads only the final incomplete four-frame block and trims that padding from the result, so a short tail block should not change the delivered video length.
To render another supplied scene, change --scene and provide an input captured for that scene. Do not assume that an Ancient Egypt input can be paired with Castle or Racing assets; scene-specific resources and matching game capture are the safe pairing.
Launch the single-user WebRTC browser demo
After the native game and media dependencies are ready, launch the server from the v4 directory. This example uses the RTX 5090 preset and Ancient Egypt:
CUDA_VISIBLE_DEVICES=0 bash scripts/serve.sh
--scene ancient-egypt --resources resources
--preset rtx5090 --prompt-mode fixed --fps 40CUDA_VISIBLE_DEVICES=0 selects the first visible GPU. If your machine exposes a different device ordering, adjust that value rather than assuming the physical card is numbered zero. The scene and resources must correspond to the downloads you verified.
The --fps 40 option sets the game capture cadence. It is not a measured model-rendering rate and should not be read as a guarantee that the browser will display 40 frames per second. The server first warms kernels and captures CUDA graphs; expect a longer startup before a session is accepted, followed by steadier operation.
The release describes this as a single-user browser demo. Use a documented desktop Safari or Chrome client and follow the repository’s displayed WebRTC endpoint or connection instructions after the script starts. If the page cannot connect, first confirm that the native game starts and that the GStreamer pipeline is installed and functioning on the Linux host; browser troubleshooting cannot repair a failed capture pipeline.
What performance numbers mean
The project’s README reports server-side pipeline measurements from one NVIDIA A100-SXM4-80GB at 864×480, using one denoising step, TAEHV encoding and decoding, SDPA, a fused DiT and CUDA graphs:
| Scene and prompt mode | Reported throughput | Measurement qualification |
|---|---|---|
| Castle, fixed prompts | Approximately 38–39 FPS | One A100-SXM4-80GB; 864×480; one denoising step; stated optimizations enabled |
| Ancient Egypt, fixed prompts | Approximately 38–39 FPS | Same server-side pipeline conditions |
| City Racing, fixed prompts | Approximately 38.5 FPS | Same server-side pipeline conditions |
| City Racing, dynamic prompts | Approximately 28.9 FPS | Same hardware and resolution, with dynamic rather than fixed prompts |
These figures describe the server pipeline, not browser presentation FPS, network delivery or action-to-photon latency. A browser can show fewer frames because of capture, encoding, transport, decode or display scheduling. Dynamic prompts also cost more than fixed prompts in the reported Racing measurement.
Kunlun Tech’s launch coverage states a consumer target of 480p at 60 FPS on one RTX 5090 and input-to-response latency below 150 ms. Those are vendor launch claims, not an independently reproduced guarantee. Your result depends on the exact preset, driver, prompt mode, scene, host load and browser path, so record the configuration report with any benchmark.
macOS, Windows and non-NVIDIA options
macOS
macOS or Linux is documented for the standalone game and recording components when CMake, C++20, SDL2 and FFmpeg are available. The documented model-inference path, however, is Linux with an NVIDIA GPU. A Mac can therefore be relevant for building or recording the standalone game components, but the supplied instructions do not establish a supported Mac inference deployment.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Windows
A legacy Windows entry remains in the project, but it has not been validated for feature parity. Do not plan a Windows installation around the browser demo or assume that every Linux command and dependency has an equivalent Windows workflow. If Windows is your only machine, treat it as an experimental port rather than the supported route.
Rank #3
- Powered by the NVIDIA Blackwell architecture and DLSS 4. System Requirements: Minimum 850W PSU with 16-pin 12V-2x6 (12VHPWR) connector required. Verify before purchasing.
- Military-grade components deliver rock-solid power and longer lifespan for ultimate durability. Compatibility: 348mm (13.7") length, 3.6 slots, 4.3 lbs. Confirm case clearance and slot spacing. GPU bracket included.
- Protective PCB coating helps protect against short circuits caused by moisture, dust, or debris
- 3.6-slot design with massive fin array optimized for airflow from three Axial-tech fans
- Phase-change GPU thermal pad helps ensure optimal thermal performance and longevity, outlasting traditional thermal paste for graphics cards under heavy loads
Other GPUs
The repository documents an A100 reference path and an explicit RTX 5090 path. It does not promise automatic hardware selection. On another NVIDIA model, you may need to adapt the environment yourself, and the supplied presets may not fit its memory, driver or kernel capabilities. No documented CPU-only path is provided.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Troubleshoot the common failure points
The command selects the wrong preset
Presets are explicit. Use --preset realtime for the documented fast A100 route and --preset rtx5090 for an RTX 5090. Do not expect the launcher to detect the card and switch automatically. The optional rtx5090-sage path will fail or lose its intended optimization if its separate patched SageAttention dependency is absent.
PyTorch or CUDA imports fail
Confirm that the virtual environment is active, Python reports version 3.12, and the installed wheels are torch==2.12.0 and torchvision==0.27.0 from the CUDA 13.2 index. Then check the NVIDIA driver and Triton compatibility. Installing a second CUDA or PyTorch combination into the same environment can leave mismatched libraries; recreating .venv is safer than layering random versions on top.
Free tools Windows power users keep installed
One-click scans. No signup required.
Verification reports a hash or size mismatch
Re-run the corresponding matrix-game download command with the pinned revision and ensure the resource path is the same one passed to matrix-game verify and later to render or serve.sh. Check available disk space, including the Hugging Face cache. A partial cached file should be replaced by a clean download rather than ignored.
The browser starts slowly or never connects
Initial kernel warm-up and CUDA-graph capture are expected before the first session. Give the server time to finish that phase. If it still does not accept a connection, test the native game and GStreamer pipeline separately, confirm that the selected scene exists under resources, and verify that the Linux firewall or local network is not blocking the WebRTC endpoint. Use a documented desktop Safari or Chrome client.
The output FPS does not equal the command-line value
The --fps argument controls capture cadence. It does not report model throughput, browser display rate or latency. Compare like with like: the README’s A100 numbers were measured server-side at 864×480 with fixed or dynamic prompts under specified optimizations. A different resolution, prompt mode or transport path is a different measurement.
The final frames look unusual in an offline render
The renderer pads only a final incomplete four-frame block internally and trims it afterward. Inspect the output frame count and configuration report before treating a tail-frame artifact as a model failure.
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchStorage and operational planning
Plan for three kinds of storage: the Git checkout, the installed resource copy and the Hugging Face download cache. Downloading all three scenes and model files can require substantially more temporary space than the final resources/ directory because the cache may retain its own copies. An NVMe SSD is the practical choice for faster asset access and cache operations, but the project’s documentation does not state a single minimum capacity.
For repeatable runs, keep the revision, scene, preset, prompt mode, GPU identifier and configuration report with each output. This makes an A100 realtime render distinguishable from an RTX 5090 render and prevents a capture-cadence setting from being mistaken for measured inference speed.
What you can and cannot extend
You can run the three supplied worlds, render their low-poly captures, and expose a single interactive session through the browser demo. You can also build the standalone game and recording components on the documented macOS or Linux toolchain. The public release does not include training code or data, so creating a new world by training the video model is outside the documented local workflow. Likewise, the supplied performance figures should not be generalized to unsupported GPUs, operating systems or multi-user deployments.
Bottom line
For the least-surprising installation, use Linux, Python 3.12, an NVIDIA GPU and the pinned PyTorch 2.12.0/CUDA 13.2 environment. Download one scene into resources/, verify both manifests, complete an offline render, and only then start scripts/serve.sh for WebRTC. Choose realtime on the documented A100 path or rtx5090 on an RTX 5090; neither preset is selected automatically. The release is a runnable demonstration of three prepared scenes, not a turnkey platform for training arbitrary games.
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.
