The essentials in 60 seconds / tl;dr
- All five models produced a complete, playable Three.js game and passed every automated functional check.
- Sol, Fable and Opus scored 100; Luna scored 97 and the locally executed DeepSeek V4 Flash scored 94.
- The largest differences were not basic functionality, but art direction, visual density, code structure and time spent.
- DeepSeek remained behind the strongest visual entries, but passed every browser and mobile check and produced a modular application.
- All five builds were archived unchanged and are hosted on separate subdomains without analytics inside the games.
01
How a local model test became a frontier comparison
This did not start as a model competition. I wanted to find out whether DeepSeek V4 Flash 0731 could be used meaningfully as a coding agent inside the Codex harness on my MacBook. After downloading, creating a custom quant, testing long contexts and trying several speed optimizations, I needed a task that measured more than tokens per second.
A browser game is unusually useful for that purpose: it has to compile, respond to input, maintain a stable game loop, work on smartphones and still develop a recognizable visual idea. Once DeepSeek produced a genuinely playable result, the obvious question was how the same task would look with current frontier models.
Luna, Sol, Fable and Opus were therefore tested with the same frozen starting point. The assignment was not adapted for individual models between runs.
What deliberately stayed unchanged
- the same Vite and Three.js starting point
- the same frozen prompt
- no external images, fonts, audio sources or runtime APIs
- no post-run repairs to model output
- the same independent functional and browser review
02
The local model: technically demanding, noteworthy in this result
DeepSeek V4 Flash 0731 ran entirely as a local model provider on a MacBook Pro with an M5 Max and 128 GB of unified memory. The setup used a heavily compressed mixed Q2 quant with roughly 81 GiB of Metal mappings and a 393,216-token context window.
Local setup
Hardware
MacBook Pro · Apple M5 Max · 128 GB unified memory
Model
DeepSeek V4 Flash 0731 · mixed Q2 quantization
Context
393,216 tokens (384 Ki)
Harness
Codex through a local OpenAI-compatible DS4 endpoint
Reasoning
Maximum official reasoning setting without an artificial thinking cap
Acceleration
No DSpark in the final run: the fast path changed output, while exact replay was slower
What the run actually achieved
- 45 out of 45 points in automated functional checks
- 15 out of 15 for browser robustness, smartphone layout, input and restart
- 25 out of 30 for visual craft
- 9 out of 10 for code quality
- 15 modules, a successful production build and a fully playable online version
03
One prompt, one starting point and a deliberately mixed evaluation
The product requirements were short enough to leave creative room, but concrete enough for reproducible functional checks.
Core requirements
- Three.js as the primary full-screen scene
- 2D or 2.5D presentation with procedural assets
- gravity, flap impulse, obstacles, collision, scoring and restart
- keyboard, mouse and touch support
- deliberate smartphone playability
- frame-rate-independent motion and robust resize behavior
- visible ready, playing and game-over states
Scoring
Automated · 45 points
Build, Three.js, physics, obstacles, collision, score, restart, input, resize and local best score.
Browser robustness · 15 points
Direct desktop and phone review, touch input, game over, restart and repeated resize.
Visual craft · 30 points
Art direction, character, world depth, motion, UI, effects and mobile composition.
Code quality · 10 points
State model, delta time, resource lifecycle and understandable module structure.
Maximum reasoning was the comparable setting for each run. The harnesses were not identical, however: Codex for Luna, Sol and DeepSeek; Claude Code for Fable and Opus. That difference remains part of the methodology and prevents a perfectly clean ranking.
04
More than screenshots: all five results are playable
Every game runs unchanged on its own subdomain and opens in a new tab. This keeps assets, high scores and browser state isolated from one another.
The games contain no analytics. At runtime, the builds load no external images, fonts, audio sources or APIs.
GPT-5.6 Sol · Max
Codex harness · maximum reasoning
The most balanced result overall, with a clear postal theme, strong 2.5D depth and cleanly separated modules.
Play Sol Max
GPT-5.6 Luna · Max
Codex harness · maximum reasoning
A particularly strong night-flight presentation and the best start screen, although nearly all logic lives in one very large module.
Play Luna Max
DeepSeek V4 Flash 0731 · Max
Local · 384 Ki context · M5 Max
Less strongly art-directed, but fully playable, touch-safe and organized into understandable modules.
Play DeepSeek
Claude Fable 5 · Max
Claude Code harness · maximum reasoning
A polished low-poly world and the most extensive self-initiated quality assurance in the comparison.
Play Fable 5
Claude Opus 5 · Max
Claude Code harness · maximum reasoning
Strong atmosphere, spatial depth and a responsive glass HUD; the run timed out while continuing to refine mobile presentation.
Play Opus 5
05
The result: functionally close, visually very different
All five models passed every automated check. Score differences only appeared in direct browser, design and code review.
| Model | Automated | Browser | Visual | Code | Total | Runtime |
|---|---|---|---|---|---|---|
| GPT-5.6 Sol · Max | 45/45 | 15/15 | 30/30 | 10/10 | 100/100 | 16:50 |
| Claude Fable 5 · Max | 45/45 | 15/15 | 30/30 | 10/10 | 100/100 | 50:05 |
| Claude Opus 5 · Max | 45/45 | 15/15 | 30/30 | 10/10 | 100/100 | 60:02 · timeout |
| GPT-5.6 Luna · Max | 45/45 | 15/15 | 30/30 | 7/10 | 97/100 | 11:43 |
| DeepSeek V4 Flash 0731 | 45/45 | 15/15 | 25/30 | 9/10 | 94/100 | 1:45:41 |
Runtime was documented but not scored. DeepSeek had a 120-minute ceiling because of slower local inference; hosted runs had 60 minutes. Opus reached the cutoff, but its preserved state still passed the full review.
06
What the score alone does not show
The games solve the same task, but feel like five different product decisions.
Sol: the most balanced overall winner
Visual concept, responsive UI, depth and technical structure work together most cohesively.
Fable: strong self-review
Alongside the polished low-poly world, the model independently checked desktop, phone, landscape, touch and performance in unusual depth.
Opus: refinement to the final minute
The preserved state was already complete, yet the model kept working on mobile details until the cutoff.
Luna: maximum impact, compact architecture
The presentation belongs near the top. Keeping almost everything in a 1,069-line module costs maintainability points.
DeepSeek: function before presentation
The world is less distinctive, but the model prioritized robust input, physics, resize behavior, mobile use and clear code responsibilities.
07
Why this is not a universal ranking
One prompt cannot represent the full coding ability or day-to-day usefulness of a model. A different product, an existing codebase or several feedback rounds could change the order.
Token figures are not fully comparable across harnesses either. Cached input, tool protocols and how an agent repeatedly processes context differ. Runtime also depends on hosting, local hardware and the amount of self-directed QA.
Visual scoring follows a documented rubric, but remains partly subjective. That is why all five games are public: readers can form their own judgement independently of my scores.
Important limitations
- different agent harnesses between Codex and Claude Code
- one quality-focused product prompt
- API cost was not scored
- runtime documented but not scored
- subjective elements in art direction and visual quality
- high-end specialist hardware for the local DeepSeek run
08
My conclusion: the gap is not equally large everywhere
Sol is the most rounded result in my view. Fable and Opus show similarly high product quality, while Luna creates a strong visual identity unusually quickly. DeepSeek does not reach that level of visual confidence.
I still personally find the local result noteworthy: not because 94 points prove local models are generally equal, but because nearly all missing points are in visual craft. Function, smartphone input and technical structure were already dependable.
For real development work, the crucial question is what happens after the first impressive output: can the agent understand unfamiliar code, make targeted changes, reproduce bugs and remain consistent across several iterations? This benchmark cannot answer that completely. It does show how high the starting level has become.
09
Frequently asked questions
Was the same prompt really used?
Yes. All five runs began with the same frozen task and fixture. No additional design hints were added between models.
Did DeepSeek run entirely locally?
Model inference ran through a local DS4 provider on the M5 Max MacBook. The coding agent used the Codex harness and local tools for files, builds and checks.
Why did DeepSeek receive more time?
An earlier local run had reached the 60-minute ceiling. The local limit was therefore set to 120 minutes before the frozen comparison. Runtime did not affect scoring.
Are scores of 94 and 100 objectively comparable?
Automated and functional checks are directly comparable. Design and code review follow a fixed rubric but deliberately include human and therefore subjective judgement.
Were the games improved afterwards?
No. The published builds match the archived model output. Only hosting, subdomains and TLS were added.
Do the games collect analytics?
No. None of the five games contains analytics. High scores, where implemented, are only stored locally in the browser.