GPT 6.2, Fable 5.2, Gemini 4 Tested: Which Builds the Best Game UI from a Single Image?

LGUI framework test: three top models recreate game UI from one image—functionality converges, but fidelity and stability diverge sharply.
Bilibili creator "Lumian" used his self-built LGUI Agent framework to test GPT 6.2, Fable 5.2, and Gemini 4 on recreating a runnable game UI from a single original image, with the Agent autonomously handling requirements, asset generation, coding, and testing in the browser. Functionality no longer separates the models; the real divide is design fidelity, interaction quality, and engineering stability. Fable 5.2 looked best but once wrote an infinite loop that crashed the computer; GPT 6.2 was balanced but deviated from the prototype; Gemini 4 was complete but looked cheap. He recommends Opus 5.5 and GPT 6.2 for daily use, and LGUI can export to Unity in one click, with future plans for pure-code JSON 3D models with semantics.
When large models start taking over game UI development, how far can a single screenshot go? Bilibili creator "Lumian" (路面) ran a head-to-head test using an Agent framework called LGUI: feeding the same original game screenshot to GPT 6.2, Fable 5.2 (a Claude-family model), and Gemini 4 to see which could recreate a runnable game interface from scratch. The results were more divided than expected—all of them could get functionality working, but "looking right" and "being usable" are two different things.
Test Method: How a Single Image Becomes a Runnable UI
LGUI is an Agent-oriented game UI framework that plugs into coding Agents like Claude Code and Codex as a plugin. All editing, slicing, and coding happen in the browser—no game engine needs to be launched, and no MCP connection is required. The Agent can self-loop within the web page to complete design reasoning, asset generation, code writing, and self-testing/acceptance.
The workflow starts from a single original image: the model first infers the interface structure, icon semantics, and interaction states, outputting a detailed requirements sheet; then it generates an art asset table, design specifications (accent colors, text styles, image-generation prompts), and assembly specs; finally it writes code with accompanying test cases covering each functional point. The entire process is completed autonomously by the Agent, with humans only needing to accept the results.

The creator specifically mentioned one surprise: Fable 5.2 wrote an infinite loop during generation, causing his computer to crash twice. He felt this shouldn't be how a top-tier model behaves, so he docked points from Fable 5.2 in his subjective scoring.
MCP (Model Context Protocol) is an open protocol proposed by Anthropic for connecting large models to external tools and data sources in a standardized way. Simply put, it defines a unified interface for "how a model discovers, calls, and returns tool results," so Agents don't need to write adapter code for each tool individually. The article emphasizes that LGUI "doesn't need to connect to any MCP," meaning the framework builds slicing, asset generation, and code writing entirely into its browser-side plugin. The Agent operates on the framework's own APIs rather than external services mounted via MCP. The benefit is a shorter chain and greater controllability, avoiding the extra latency and permission-configuration costs of MCP calls—but the trade-off is that extensibility is limited to the interface range the framework itself provides.
How Each Performed: Functionality All Works, Expressiveness Gaps Are Obvious
Fable 5.2: Overall the Most "Like the Real Thing"
From slicing quality to interface details to animations, Fable 5.2 was the set the creator was personally most satisfied with. It had the highest fidelity for the Thousand Dao interface, with item-flying-into-currency-bar animations, click feedback, and map and battle popups all fairly complete. He said outright that "only Fable 5.2 made it look like the real thing," while the other models' results were "also okay."
GPT 6.2: Details Are Criticizable, but Overall Satisfying
GPT 6.2 (including both the 6.2 hand and 6.2 hand-insert versions) performed relatively evenly—basic functionality was fine, and slicing had no major issues. The problem was that character icons became especially cartoonish; the model didn't seem to strictly reproduce the prototype but instead "made its own version." The creator speculated this might relate to certain measures during training. Within the GPT family, he felt 6.2 hand was much stronger than S2.

Gemini 4: Functionally Complete, but Looks Cheap
Gemini 4's performance was rated as "rather lackluster." Although functionality was complete and slicing normal, the assets were simple, buttons weak, animations and interactions poor, and the overall look "very cheap." Even as the latest release, it still hasn't reached a usable standard for front-end UI.
Comparison with Older Versions: GPT 6.1's Font Adaptation Pitfall
The creator also reviewed an earlier attempt using GPT 6.1 to go directly from web page to Unity packaging. The biggest problem was severely abnormal display of outlined fonts, rooted in poor TMP (TextMeshPro) adaptation. Functionality and slicing themselves were fine, but font outline handling needed extra optimization.
TMP (TextMeshPro) is Unity's official text rendering solution, designed to replace the traditional UI Text component. Its core advantage is vector rendering, which keeps text edges sharper at high resolutions. Effects like outlines, shadows, and gradients are achieved through materials and shaders rather than pixel-by-pixel drawing. TMP font assets must be pre-baked into SDF (Signed Distance Field) atlases containing distance information for glyph contours, so runtime scaling doesn't blur. The problem is that if the font atlas resolution, sampling parameters, or material channel configuration are improper, outlines get clipped or overflow—showing up as overly thick, broken, or completely invisible outlines. UI generated on the web typically uses CSS or Canvas native text rendering, and after importing into Unity it must be remapped to TMP font assets. This cross-engine text pipeline adaptation is one of the most error-prone steps in automated workflows.
Speed and Quota: Who's Better for Daily Development
Based on personal experience, the creator's top recommendation is Opus 5.5, which he says is "absolutely top-tier" for game front-end UI development; second is GPT 6.2, because the Pro tier's Ultra Fast speed is extremely quick. For image generation, since Opus has no image-generation model, he switches to GPT's image-generation capability. Although Gemini and another latest model have the strongest parameters, their experience in front-end UI scenarios lags behind.

Interestingly, these models all performed fairly well in overall image-generation quality; the gaps mainly came down to fidelity in "reproducing the prototype" and polish in interaction details.
From UI to Engine: LGUI's Ambitions Go Beyond Interfaces
All of LGUI's output can be exported to commercial engines with one click. Currently Unity is prioritized; other engines require community PRs for compatibility—the creator says the compatibility work itself is simple, mainly hooking up mouse clicks, screen touch, and other events and assets, and building some APIs. The project repository currently has 139 stars and 18 forks.

The creator also recently open-sourced a performance testing tool for Agents. The web-side profiling tool can autonomously instrument, locate problems, run tests, and fix them, further automating the programming development phase. Next, he wants to Agent-ify the art phase as well, exploring a web-based Blender-style approach: no FBX, no DCC software, using pure code (JSON format) to describe model structure so AI can understand the purpose of each component instead of being helpless in front of mesh nodes. He admits this is an exploratory path and very difficult, but if it works, AI's way of understanding 3D assets will be completely different.
FBX is a universal 3D model exchange format introduced by Autodesk, containing data such as meshes, skeletons, animations, and material references. It is the most common asset carrier between game engines and DCC (Digital Content Creation) software. Traditional 3D workflows rely on DCC tools like Blender, Maya, and 3ds Max to produce FBX files, which are then imported into Unity or Unreal. Such files are not AI-friendly: mesh nodes only have coordinate and topology information, lacking semantic labels like "this is a chair leg" or "this is a door handle," making it hard for models to understand the function and compositional relationships of each component. The pure-code JSON approach the creator envisions essentially turns 3D assets from "geometry containers" into "structured descriptions with semantics," enabling AI to reason about, edit, and generate by component purpose rather than just moving vertex data. If this path works, it would bypass DCC software and the FBX intermediate layer, letting AI participate directly in the creation and modification of 3D assets.
Conclusion
The takeaway from this test is straightforward: current top-tier models can no longer be separated on "functional implementation." The real dividing line is design fidelity, interaction quality, and engineering stability. Fable 5.2 wins on expressiveness but loses on engineering incidents like infinite loops; GPT 6.2 is balanced but "takes liberties"; Gemini 4 is still at the "good enough to run" stage. For scenarios like game UI that are highly visual and interaction-heavy, you can't choose a model based on leaderboards alone—you have to look at its actual output within a specific pipeline.
One-line Summary
LGUI framework test of three major models recreating game UI from original images: functionality converges, but fidelity and stability diverge sharply.
Paragraph Summary
Bilibili creator "Lumian" ran a head-to-head test with his self-built LGUI Agent framework: feeding the same original game screenshot to GPT 6.2, Fable 5.2, and Gemini 4, letting the Agent autonomously complete requirements reasoning, asset generation, code writing, and testing in the browser to recreate a runnable game UI from scratch. The results show that functional implementation no longer separates the models; the real dividing line is design fidelity, interaction quality, and engineering stability. Fable 5.2 had the best expressiveness but once wrote an infinite loop that crashed the computer; GPT 6.2 was balanced but deviated from the prototype on its own; Gemini 4 was functionally complete but looked cheap. The creator's daily top picks are Opus 5.5 and GPT 6.2, and he revealed that LGUI can export to Unity with one click, with future plans to describe 3D models in pure-code JSON so AI can understand asset semantics.
Related articles

Three Major Browsers Join Forces: Helping AI Write More Modern Web Code
Chrome, Firefox, and Edge jointly launch a free "modern web guidance" skills package to teach AI coding assistants to write more modern web code. One command integrates it into tools like Cursor, automatically scanning for safely upgradable code patterns—but human review is still required.

Fake Claude Code Extension Leaks Cursor Keys — Users Should Check Immediately
A fake Claude Code extension appeared in Cursor's marketplace and was removed within 11 hours, but leaked keys from a third-party vendor may have accessed chat histories of users without privacy mode enabled. Developers who used Cursor and pasted private keys between 2025 and 2026 should rotate credentials immediately and check privacy settings.

App Store Submission Pitfall Guide: Open-Source Tool Helps You Avoid 117 Rejection Patterns
GitHub open-source project mjmirza/app-store-compliance documents 117 App Store and Google Play rejection patterns with fixes, offering privacy manifest checks, 95 regulatory deadline tracking, and AI coding agent compliance automation.