GameCoder-27B: Web Game Code Generation

• GameCoder-27B is a 27-billion-parameter model specialized in end-to-end web game coding, particularly for Phaser engine projects.
• It employs a three-stage training pipeline: continual pre-training on Phaser-based game code, supervised fine-tuning with synthetic prompts, and execution-grounded reinforcement learning to enhance code consistency and playability.
• Performance metrics from the OpenGame-Bench highlight significant gains in Build Health and Intent Alignment, demonstrating its advantage over prior open-source code models.

GameCoder-27B is a 27-billion-parameter, decoder-only transformer model specialized for end-to-end web game coding, designed to serve as the core code-generation engine within the OpenGame agentic framework. Built atop the Qwen-3.5-27B backbone, it introduces a domain-adaptive training regimen targeting complete, playable web games, specifically those based on the Phaser engine ecosystem. GameCoder-27B couples large-scale transformer architecture with continual pre-training, supervised instruction fine-tuning, and execution-grounded reinforcement learning to address longstanding issues in code generation for interactive game projects, including cross-file inconsistencies and logical incoherence (Jiang et al., 20 Apr 2026).

1. Architectural Characteristics

GameCoder-27B utilizes the Qwen-3.5-27B foundation, maintaining its decoder-only transformer configuration with approximately 32 self-attention layers and a hidden dimension on the order of 8,000–10,000. Each self-attention layer comprises 32 attention heads, totaling approximately $27 \times 10^9$ trainable parameters. No architectural modifications (e.g., additional attention/memory modules) are introduced beyond the base design; gains stem from targeted data and training regimes. This architecture positions the model to capture the long-range dependencies inherent in multi-file game projects, accommodating patterns involving asset management, scene orchestration, and real-time control loops characteristic of modern web games.

2. Domain Specialization and Training Pipeline

The domain specialization of GameCoder-27B is achieved through a three-stage pipeline:

1. Continual Pre-Training (CPT): The model is further pre-trained on corpora consisting of open-source JavaScript/TypeScript web games (particularly those utilizing Phaser), official Phaser 3 API documentation, and community-created tutorials. The CPT objective is standard left-to-right causal code modeling:

$$L_{\text{CPT}}(\theta) = -\sum_{t=1}^T \log P_\theta(x_t|x_{<t})$$

This procedure anchors the model in engine- and domain-specific idioms, promoting internalization of asset imports, scene registration, and project layout conventions.

2. Supervised Fine-Tuning (SFT): To align with instruction-driven use, a synthetic dataset of multi-step game-coding prompts (drafted by an auxiliary LLM, gpt-codex5.1) is paired with high-quality reference solutions (via MiniMax-2.5). The supervised objective maximizes the conditional likelihood of the reference solution:

$$L_{\text{SFT}}(\theta) = -\mathbb{E}_{(x,y)\sim D_{\text{SFT}}} \left[ \sum_{t=1}^{|y|} \log P_\theta(y_t|y_{<t},x) \right]$$

Optionally, a KL regularization term

$\lambda \cdot KL[\pi_\theta||\pi_{ref}]$

is introduced to penalize over-drift from the pre-trained base, though early stopping and weight decay are typically sufficient.

3. Execution-Grounded Reinforcement Learning (RL): The model further refines code consistency by generating single-file components, executing them in a sandboxed Node and headless browser environment, and measuring unit-test pass rates across API interaction and minimal runtime behavior. The reinforcement signal is:

$$R = \sum_{i=1}^N w_i \cdot \mathbf{1}[\text{test}_i\,\text{passed}]$$

The expected return $J(\theta)$ is maximized using Proximal Policy Optimization (PPO), with hyperparameters $\epsilon\approx 0.2$, $\gamma=0.99$, $\lambda_{GAE}=0.95$, and minibatch sizes spanning several thousand tokens:

$$L_{\text{PPO}}(\theta) = \mathbb{E}_t \left[ \min(r_t(\theta)\,\hat{A}_t,\,\text{clip}(r_t(\theta),1-\epsilon,1+\epsilon)\,\hat{A}_t) \right]$$

Credit assignment operates at the file granularity, so that only the responsible tokens receive update gradients.

3. Agentic Integration and Behavioral Protocols

Within the OpenGame framework, GameCoder-27B powers automated workflows for real-world game generation. The system implements "Game Skill," a reusable, evolving programmatic capability structured around two sub-components:

• Template Skill: Accumulates a library of verified project skeletons, fostering scaffolding of stable architectures and promoting cross-file consistency such as asset key management and scene registration discovered during CPT.
• Debug Skill: Maintains a living protocol of repair routines, ensuring systematized correction of integration and execution errors as opposed to isolated syntax bug fixes.

The downstream agent imposes architectural patterns, notably a Template Method Pattern and a Three-Layer Reading Strategy, to focus generative attention, mitigate hallucination of undocumented engine patterns, and further stabilize multi-file code synthesis. These stratified protocols enforce the use of scene wiring via hook-based overrides, real-time loop invariants, and cross-module composition, ensuring alignment with Phaser engine best practices as reflected in the SFT and RL datasets.

4. Game-Engine Mastery and Emergent Behaviors

GameCoder-27B demonstrates robust specialization for web game construction by internalizing several critical patterns during its training stages:

• Cross-file Consistency: Reinforced by the proliferation of scaffolded project skeletons in CPT, GameCoder-27B maintains asset key consistency, coherent scene registration, and correct import paths across files.
• Real-time Loop Invariants: Execution-grounded RL, leveraging unit tests, instills correct update–render cycle handling and physics body management, essential for stable and performant games.
• Scene Wiring and Modular Composition: SFT ensures that code adheres to hook-based overrides, precluding hallucinated or undocumented wiring mechanisms.

These capabilities are achieved without novel architectural components, instead emerging from domain-centric data and skillful agentic workflow constraints.

5. Performance Evaluation: OpenGame-Bench

The OpenGame-Bench protocol provides quantitative evaluation of GameCoder-27B-driven agentic coding using headless browser execution and vision-LLM (VLM) assisted judging. Three continuous 0–100 metrics are reported:

Metric	Definition	OpenGame+GC27B Mean
Build Health (BH)	Compilation and runtime success	63.9
Visual Usability (VU)	Frame-entropy and VLM coherence/interactivity	57.0
Intent Alignment (IA)	Fraction of user requirements met (VLM-judged)	54.1

OpenGame employing GameCoder-27B as its code engine outperforms prior open-source LLM baselines on Build Health and Intent Alignment. Full agentic systems—incorporating Claude Sonnet 4.6 for strategy with GameCoder-27B for code—yield further improvements:

• BH=72.4, VU=67.2, IA=65.1; a 5–6 point gain over the next best agentic framework (Cursor with Claude Sonnet 4.6).

Ablation studies of the training regime under a consistent agentic workflow show:

• Addition of CPT: $$L_{\text{CPT}}(\theta) = -\sum_{t=1}^T \log P_\theta(x_t|x_{<t})$$0BH≈+0.4, $$L_{\text{CPT}}(\theta) = -\sum_{t=1}^T \log P_\theta(x_t|x_{<t})$$1VU≈+0.9, $$L_{\text{CPT}}(\theta) = -\sum_{t=1}^T \log P_\theta(x_t|x_{<t})$$2IA≈+0.8
• SFT: Largest alignment improvement, $$L_{\text{CPT}}(\theta) = -\sum_{t=1}^T \log P_\theta(x_t|x_{<t})$$3IA≈+1.9
• RL: $$L_{\text{CPT}}(\theta) = -\sum_{t=1}^T \log P_\theta(x_t|x_{<t})$$4VU≈+1.3, $$L_{\text{CPT}}(\theta) = -\sum_{t=1}^T \log P_\theta(x_t|x_{<t})$$5IA≈+1.6, yielding the finalized GameCoder-27B

6. Context and Comparative Significance

GameCoder-27B addresses a prominent challenge in code generation: achieving end-to-end, multi-file, playable game synthesis from abstract specifications. By leveraging domain-adaptive data and systematic evaluation, it demonstrates persistent gains in architectural coherence and gameplay reliability compared to generalist code models. The collaborative regimen of continual pre-training, synthetic instruction tuning, and RL inferential validation sets a methodological precedent for future domain-specific code LLMs, especially in environments where static analysis is insufficient for veracity assessment (Jiang et al., 20 Apr 2026).

A plausible implication is that targeted, modular training strategies may supersede architectural augmentation when domain grounding and executional fidelity are paramount. As OpenGame will be fully open-sourced, further analysis and extension of the GameCoder-27B approach will likely inform both the capabilities and limitations of code agents in creative, interactive software engineering.