Language-Driven Game Web Re-Architecture - Design Process
Language-Driven Game Web Re-Architecture - Design Process
This design project is a browser-based re-implementation of the original Language Game, rebuilt for WebAssembly deployment.
Rather than directly porting the Unity version of the game, the focus was on re-evaluating and redesigning gameplay systems under browser constraints, while preserving the core experience of exploration and language-based progression.
The goal was to understand how platform limitations reshape interaction design, responsiveness, and moment-to-moment gameplay clarity.
This project focuses on preserving the core experience of the original game while redesigning it for browser execution constraints.
The original version relied on systems and assumptions that were not suitable for web deployment. This redesign required identifying what was essential to the player experience and rebuilding everything else around performance, input, and rendering limitations.
Rather than treating browser limitations as technical restrictions, they were treated as design constraints that shaped system behavior.
Key constraints included:
Limited performance overhead compared to desktop builds
Increased sensitivity to load times and asset size
Dynamic window resizing and unpredictable aspect ratios
Keyboard-only input expectations (no gamepad support)
WebAssembly build size limitations
These constraints were not just worked around, they were used to guide redesign decisions across core systems.
Input systems were redesigned specifically for browser interaction.
The original game’s input assumptions (including gamepad-style interaction) were replaced with a simplified keyboard-driven model.
The redesign also focused on making interactions more deterministic, since browser environments introduce more variability in input timing and focus states.
The camera system was fully rebuilt to support unpredictable browser conditions.
Key improvements included:
Responsive scaling across window sizes
Stable framing across dynamic aspect ratios
Reduced visual drift during resizing or resolution changes
These improvements required rethinking how camera framing supported exploration, especially since the readability of the world is tightly coupled to navigation clarity in a language-driven game.
The UI was restructured to:
Remain legible across a wide range of browser resolutions and aspect ratios
Maintain clarity under resizing
Preserve interaction readability across scaling states
Adapt to keyboard-first input expectations
These changes ensured that language comprehension systems remained readable regardless of device or window configuration.
A major part of the project involved optimizing the original game for WebAssembly constraints.
The optimization included:
Reducing unnecessary asset overhead
Simplifying or removing non-essential systems
Reducing model and texture sizes
Removing or replacing complex shader usage
Optimizing scene and resource loading behavior
The guiding principle for optimization was to preserve anything directly tied to gameplay clarity and remove anything that did not meaningfully contribute to the core loop.
Development was highly iterative and conducted primarily within the browser environment to reflect real deployment conditions.
Testing focused on:
Responsiveness of movement and input handling
Consistency across browsers and operating systems
Visual clarity under multiple resolutions and scaling states
Load performance and runtime stability
Preservation of exploration pacing
Integrity of language interaction systems under latency
Adjustments were continuously made to preserve the feel of the original player experience while adapting to browser-specific constraints.
In addition to the re-architecture, the system was extended with small quality-of-life improvements based on playtester feedback.
A responsive mini-map system was added to improve spatial awareness without interfering with the language-based progression loop.
Several key tradeoffs were required to maintain the core player experience under the new browser limitations.
Fidelity vs. performance constraints
High-fidelity visual systems were not viable under WebAssembly limitations.
I decided to prioritize gameplay clarity over visual complexity while preserving the core visual identity.
Input richness vs. reliability
The original input system supported more expressive control schemes.
I decided to simplify interactions using keyboard-based input out of necessity and to improve responsiveness.
System complexity vs. load stability
Some visual systems introduced unnecessary runtime overhead in web environments.
I decided to remove or simplify systems that did not directly support exploration or language comprehension.
While the WebAssembly version successfully preserves the core gameplay loop, there are several areas for future improvement.
Implementing more advanced adaptive performance scaling could ensure future versions dynamically adjust visual and simulation complexity based on device performance to improve consistency across lower-end browsers.
Adding an improved input abstraction layer with a more generalized input system would allow easier expansion beyond keyboard-only interaction, potentially supporting touch and mouse controls for more flexibility.
Further improving UI resilience under extreme aspect ratios would strengthen consistency across unconventional browser window shapes, particularly on mobile devices.
This project successfully demonstrated how a fully functional gameplay system can be re-architected around platform constraints without losing its core design intent.
Rather than only serving as a direct port, this project became an exercise in constraint-driven redesign, where browser limitations directly shaped interaction, performance, and system architecture decisions.
The final result preserves the game's original exploration and language-comprehension loop while operating reliably within WebAssembly browser environments.