A generated 16:9 title card reading 'Qwen4-Max Builds Playable Games', subtitled 'Unity, Unreal Engine and Godot - three demos and the harness behind them', with four rounded chips reading '3 game engines', '1,000,000-token context', '$1.50 in / $4.50 out per 1M' and 'Live Delivery, Apache-2.0'. OrcaRouter logo bottom-right.
Guides & Insights

Qwen4-Max Builds Playable Games in Unreal, Unity and Godot: Three Demos and the Harness Behind Them

Author

jinhao.song

Date Published

Latest models · 20View all models →
Benchmarks: Artificial Analysis · updated daily
Back to all posts

The most interesting line in Alibaba's launch post for Qwen4-Max is not a benchmark score. It is a list of game engines. Qwen4-Max, released on 16 November 2026, is documented by its own team as working "fluently" with Unity, Unreal Engine and Godot, and the post ships three videos of games it says the model built end to end: a cat-mage wave defence in Unreal Engine, a sword-flight adventure in Unreal Engine, and a West Lake racer in Unity 6, delivered as an installable Android build.

That is a different kind of claim from "scores 48.5% on Terminal-Bench 4.0". A benchmark number is a measurement somebody can re-run. A game demo is a deliverable, and the deliverable is the evidence: if the build installs and plays, the model did something real, and if it does not, no amount of prose fixes it. The awkward part is that the three builds are not in front of you. What is in front of you is roughly two minutes of edited video, so the honest work here is separating what the vendor showed from what a reader can verify, and then looking at the mechanism — because that part is documented, and it is the part that will decide whether this generalises past three showcase levels.

A generated single-column scoreboard titled 'Qwen4-Max - the scoreboard' with six rows reading AA Intelligence Index 42.89, Terminal-Bench 4.0 48.5%, FrontierCode-AA 2.0 26.5%, Terminal-Bench-Science 23.3%, price per 1M tokens $1.50 in and $4.50 out, and cost per AA task $3.27, with a footer reading 'All figures per Artificial Analysis v5.0.1 at maximum reasoning effort.' OrcaRouter logo bottom-right.

Three demos, three engines, one shared loop

The three demos are named and timed in the announcement, which is more than most launch posts offer. "Meow of Magic" runs 52 seconds: an Unreal Engine cat-mage adventure with spell casting, upgrade choices and waves of enemies and bosses. "Yun Guan Xing" runs 39 seconds: a fantasy flight sequence on a sword through clouds and rings, ending on a boss. "Flying Racer" runs 20 seconds: a Unity 6 mobile racer around West Lake, with drifting, nitro boosts and deployable wings, shipped as an installable Android game rather than a video-only prototype.

Those are three different engine APIs and three different build targets, and the vendor's description of the workflow is identical across all three. From a single natural-language brief, Qwen4-Max handles scene construction, gameplay logic, integration of external assets, material setup, HUD design and visual effects, then runs the game and uses the visual and interaction feedback to revise camera tracking, character animation, hit feedback, lighting and pacing. Read that list again, because the ordering is the claim: the model is not asked to write a game and hope. It is asked to produce a build, play it, and correct what it sees.

Nobody outside Alibaba has reproduced any of this yet, and there is no public repository of the three projects to inspect. What can be said without hedging is narrower and still worth something: the model is documented as operating inside three real engines rather than emitting an engine-agnostic scene description, and one of the three targets is an installable Android package, which is a build step that fails loudly and often.

A screenshot of Alibaba's Qwen4-Max announcement showing the section headed 'GameDev: Create Games with Real Engines', its paragraph naming Unity, Unreal Engine and Godot and describing scene construction, gameplay logic, asset integration, material setup, HUD design and visual effects from a single natural-language brief, and below it a dark still from the demo video captioned 'Meow of Magic - Qwen4-Max built a cat-mage adventure in Unreal Engine.'

The part that is genuinely new is the feedback loop, not the code

A frontier model writing a Unity script is not news. Models have been writing engine code for two years, and the failure mode has been stable the whole time: the code compiles, the scene loads, and the result is unplayable in a way only a human notices — a camera that clips through walls, a hit that produces no visible response, a jump arc that feels like a lift. The interesting question about Qwen4-Max's game development claim is therefore not "can it write C# or GDScript" but "can it close that loop itself".

The announcement says it does, and the mechanism it describes is a harness rather than a model capability: the agent runs the build, reads back visual and interaction feedback, and iterates on camera, animation, hit feedback, lighting and pacing. If that loop is real, the constraint on what it can build shifts from the model's coding ability to the quality of the feedback signal it is given — a rendered frame and an input log are a much thinner description of "this feels wrong" than a human playtester, and the demos are all short, self-contained scenes that a feedback loop can plausibly converge on within a session.

This is the same argument the vendor makes elsewhere in the post under a different heading, and the two claims should be read together. In the long-horizon agent section, Alibaba describes an approach it calls Live Delivery: the agent produces a usable first version early, then expands it through successive releases, updating its plan from execution results and user requirements, so that a person can step in at any point to correct direction or undo a mistake before the whole run is finished. For a game, that means the deliverable cadence is playable builds rather than one final archive. For anything else with a long tool-using trajectory, it means the same thing.

Blender, and the pipeline that starts past the viewport

The 3D modelling section is the quieter half of the same story. Qwen4-Max is documented using Blender for geometry modelling, scene assembly, material setup, lighting and rendering, across architecture, interiors, natural landscapes and science-fiction scenes — work that exercises spatial layout and object structure rather than image aesthetics. The vendor's framing is that these assets are "in practical used in games" and taken into physical objects through 3D printing, which is a claim about downstream compatibility: an asset that can be printed has consistent geometry, watertight meshes and a real scale, and an asset that drops into a game engine has sane pivots and material assignments.

Treat that as a statement of intent rather than a verified pipeline. There is no published asset pack, no polycount budget, no topology report, and no statement about what happens when a generated mesh has to survive a retopology pass or a UV unwrap by a human artist. What the section does establish is that the workflow is file-level and tool-level: the model is driving a real DCC application and producing something a game engine imports, not generating a picture of a 3D object. That distinction is the one that matters for anyone hoping to put this in a production art pipeline, and it is also the one that is hardest to fake in a video.

Live Delivery has a repository, which makes it the checkable part

Two days before the model's general availability, Alibaba open-sourced the harness it built for this. The Qwen Live Delivery plugin sits on GitHub under Apache-2.0, was created on 14 November 2026 and last pushed the day before launch. It exposes four MCP tools — ld_begin, ld_publish, ld_status and ld_done — plus lifecycle hooks, and installs into a workspace with a shell script. At launch it is Codex CLI only, runs on Linux and macOS, and needs Node.js 22 or newer. There is an opt-in environment variable to give the sandbox full filesystem access, and a browser workbench for reviewing releases.

This is the most useful artefact in the whole release for anyone evaluating the game-development claim, because it is the part you can actually run. A framework that publishes successive releases of a long-running job is exactly the shape a game-development agent needs: each playable build is a checkpoint a human can inspect, and a wrong turn in level design costs one release rather than one run. It also means the interesting comparison is not "which model writes better Unreal code" but "which model's harness lets you supervise the work", which is a much more practical question and one that will be settled by using it, not by reading a scoreboard.

What the independent numbers can and cannot tell you

Artificial Analysis lists Qwen4-Max with an Intelligence Index of 42.89 on v5.0.1 at maximum reasoning effort, against 33.65 for Qwen3.8-Max on the same vintage — a gain of roughly nine points, which is a real generational step rather than a rounding difference. The sub-scores are more mixed than the headline: Terminal-Bench 4.0 at 48.5% versus 38.9%, FrontierCode-AA 2.0 at 26.5% versus 23.4%, Terminal-Bench-Science at 23.3% versus 11.9%, and HLE-Diamond at 44.9%. On agentic work the pattern holds — APEX-Agents 59.1%, AutomationBench 72.6% partial, EnterpriseOps-Gym 48.5%, AnalystAgent 46.3%.

None of that measures game development. No public leaderboard runs an Unreal build, checks whether a Unity scene loads, or scores a Godot project on whether the jump feels right. The closest proxies are the agentic and terminal benchmarks, which measure whether a model can hold a multi-step tool-using trajectory together without losing the plot — and those are the scores where Qwen4-Max gains most. So the correct reading of the independent data is indirect: it makes the harness story plausible without confirming a single frame of the demos. Artificial Analysis also records no open weights for the model, which matches the vendor documentation marking fine-tuning and model deployment as unsupported.

A screenshot of the Artificial Analysis page for Qwen4-Max, showing the summary line that Qwen4 Max is above average in intelligence and reasonably priced, an Intelligence Index of 43, pricing of $1.50 per 1M input tokens and $4.50 per 1M output tokens, a cost of $3.27 per task, a context window of 984k and a comparison class of 243 models.

The spec sheet, as published

Alibaba's own documentation and the launch post, for the numbers a buyer needs before committing a project:

• Backbone — 2.4 trillion parameters with 71 billion activated per token, plus 328 billion N-gram embedding parameters, in a sparse mixture-of-experts design with Gated DeltaNet hybrid attention and an N-gram embedding layer

• Context — 1,000,000 tokens advertised; the docs cap maximum input at 991,808 tokens in non-thinking mode and 983,616 in thinking mode

• Output — 131,072 tokens maximum in non-thinking mode; in thinking mode the reasoning trace and the answer share a combined 262,144

• Modality — text, image and video in, text out; no image or video generation

• Price — $1.50 input and $4.50 output per million tokens in Singapore, $1.413 and $4.24 in the other regions, against Qwen3.8-Max at $2.00 and $6.00

• Cache — $0.075 per million tokens on a cache read in Singapore, a 95% discount, with explicit and implicit caching at five-minute and one-hour TTLs

• Limits — batch inference, fine-tuning and model deployment are all listed as unsupported, so there is no cheap asynchronous path and no weight access

• Rate limits — 30,000 requests and 5,000,000 tokens per minute globally, with regional per-minute token ceilings between 5 and 20 million

The output ceiling is the line to read twice. A playable build is not one response; it is dozens of tool calls, each returning file contents and build logs, and every one of those turns is bounded by the same context. Long-horizon work at a million tokens of window is exactly the workload where a smaller output budget turns into more round trips.

What a long build loop actually costs

The vendor's own cost figures are stated per task rather than per token, which is the right unit for this kind of work. On Work360, Alibaba's internal benchmark of professional tasks across 26 first-level domains, Qwen4-Max scores 52.69 against 47.74 for Qwen3.8-Max, and the average cost per task falls from $4.43 to $1.67 — a 62% reduction, achieved partly through price cuts and partly through using fewer tokens: roughly 24% and 35% fewer on Work360 at extra-high and high reasoning effort, and 48% and 49% fewer on Terminal-Bench 4.0. Those are vendor-reported and unreproduced.

The independent estimate is less flattering and more useful as a budget input. Artificial Analysis puts the cost of running its own Intelligence Index at $3.27 per task for Qwen4-Max, down from $10.02 for Qwen3.8-Max on the same harness — a 67% reduction that is directionally consistent with Alibaba's claim while landing at a different absolute number, because the two measurements run different tasks at different reasoning effort. If you are planning a game-development loop, $3.27 per evaluated task is the number to multiply, not the $1.67, and the multiplier is the number of turns in your build-and-play cycle rather than the number of prompts you type.

There is one more cost note that matters more than the rate card for this workload. Cached input is $0.075 per million tokens, and a build loop is the ideal cache workload: the same engine documentation, the same project files, the same error log, read over and over. A loop that re-reads a 200,000-token project context twenty times pays $0.30 in cached input rather than $6.00 at the uncached rate, which is the difference between an experiment you leave running and one you stop after three tries.

Trying it without betting a pipeline on it

Qwen4-Max is available through Alibaba's own API across six regions and through a number of third-party platforms; it is not in OrcaRouter's catalogue today, whose 215 models include Qwen3.8-Max, Qwen3.7-Max and Qwen3-Max but not the Qwen4 generation. What that means practically is that the first month of evaluation happens on the vendor's own endpoint, on a key with a spend cap, and that a harness you build against one OpenAI-compatible endpoint will move without code changes if the model does appear.

Two things make that trial cheaper. The first is failover: a model this new, doing work this long-running, will hit rate limits and timeouts, and automatic failover to a second endpoint turns a dead build loop into a slower one. The second is the pass-through price rule — OrcaRouter bills at the provider's list price with no markup, so when a vendor cuts a rate the cut is live on our side the same day rather than at the next contract renewal. Neither of those claims depends on hosting the model in question, and neither is worth pretending otherwise.

A practical shape for the evaluation: give the model one small, finished thing — a single playable scene with one mechanic, a camera and a win condition — and watch what it does across three consecutive playable releases rather than one. The claim under test is not whether it can produce a game. It is whether the second and third releases are better than the first, because that is the only part of the loop that a benchmark cannot measure and a demo video cannot show.

The open question

Alibaba's framing of Qwen4-Max is a model that will keep working while you are not watching, and the game-development demos are the most legible proof of that idea it could have chosen: games are visual, they are interactive, and they fail in ways anyone can see. Three short scenes in three engines is a strong opening argument and a weak demonstration of durability — the levels are small, the runs are minutes long, and the acceptance criteria were set by the team that made them.

What would settle it is unglamorous. A project with an existing codebase, an art direction it did not choose, a physics bug that only shows up on a low-end device, and a human reviewer who rejects the build twice. If the loop survives that, the engine list stops being a marketing line and becomes a workflow. Until then, the honest position is that Qwen4-Max has shipped the first credible demonstration that a frontier model can drive a game engine and play back its own work — and that the Live Delivery plugin, released two days early under Apache-2.0, is the part of the story you can check for yourself today.