The game loop stays hidden
Drag-and-drop makers hide the render loop and timing, so custom scoring, round pacing, and animations mean fighting the tool instead of editing the loop.
Game Builder for playable browser prototypes
Turn a game idea into a browser build you can play and inspect
Describe the game, the rounds, and how players compete. E-Code turns that into an editable game loop, lobby interface, scoring rules, and multiplayer state model. Play the local flow in Preview, refine it through the Agent, and connect a real-time service before inviting remote players.
Start from the game you already have in mind. Source files, the running Preview, and publishing controls stay visible as the game evolves.
Round 3 of 5
Which capital sits on the Bosphorus strait?
A responsive quiz concept that presents a lobby, timed questions, and a shared-score interface in one clear round loop.
Live scoreboard
- NadiaLeading
- Marco
- Priya
This inline demonstration shows a live scoreboard, the current question panel, and an answer control in one responsive layout.
From engine lock-in to an inspectable game loop
Game makers look easy until multiplayer state and play-testing fight the tool
A live quiz game needs a tight loop: a lobby that fills, questions that fire in sync, and a scoreboard that updates for everyone at once. No-code game tools start fast, then hide the game loop and the networking, and the exported result rarely maps to code the team can keep evolving.
Multiplayer state drifts out of sync
When each client tracks its own score and timer, players see different boards, and there is no single source the team can inspect, version, and reason about.
You cannot really play-test it
Previewing one screen is not playing a match. Without a running game and real rounds, timing bugs and edge cases only show up once players are live.
E-Code starts from the game you describe and produces an editable browser loop, rules, and multiplayer state model in source files. You test the local flow in Preview, connect networking where the code exposes it, and request the next change without leaving the project.
One prompt starts the game
Describe the rounds, not the engine
The request below reads like a note from a game designer. The four items map its implementation scope in real source files, not a locked engine.
Example prompt
Build a multiplayer quiz game with real-time scoring and a leaderboard.
- 01
Canvas game loop
A real render-and-update loop drives rounds, timers, and animations across desktop, tablet, and mobile from editable components.
- 02
Multiplayer state model
Lobby, question, timer, and scoreboard states are modeled in editable code with explicit integration points for a real-time backend. Remote synchronization is not active until that service is connected.
- 03
Scoring and rounds
Answer handling, per-round scoring, and win conditions are modeled as working game rules rather than a static screen.
- 04
Preview and publishing
E-Code runs the local game flow in Preview across screen sizes. Supported static frontends can follow guided publishing; remote matches still require the real-time service you connect.
From plain-language instruction to a running Preview
See the IDE loop behind an E-Code build
The App Builder page shows a captured, real E-Code workspace — the prompt, the agent’s plan, the generated files, and the running Preview — for a booking application. The same build loop applies to an interactive game like this one.
The captured salon run places the user prompt, Agent plan, editable files, and running application on one screen—the same surfaces used to build and test a browser game.
Open the salon-run IDE capture at full resolution
This genuine follow-up shows an error described in plain language so the Agent can inspect the code, preserve the working routes, and verify the Preview again.
Open the salon-run IDE capture at full resolutionWhat you receive
A playable game foundation you can inspect and keep evolving
The project stays inspectable from the first generated file through Preview and export. Supported static builds add a live release through guided publishing without hiding the code.
Game code you can open and export
The render loop, round rules, interface components, state, and styles stay readable, versionable, and portable outside E-Code.
A match-state adapter, not a hidden server
Lobby, question, timer, and leaderboard state is explicit in the source. Connect that model to a real-time backend before expecting synchronized remote players.
A playable Preview at every target size
Run the local round flow in the active Preview and test its controls and scoreboard layouts on desktop, tablet, and mobile.
Guided publishing for the static frontend
Supported static game builds move through E-Code’s guided release path once the play-test is ready to share.
A live playtest link with a clear server boundary
A supported static frontend publishes to an E-Code live URL. Games that depend on a server remain exportable so you can deploy the frontend and connected runtime together.
Tune the next round by talking to the Agent
Ask for a new scoring rule, shorter timer, or another question type, then play the updated local flow without restarting the project.
Built for real browser games
The browser-game loop, rules, and screens in code you control
The Game Builder path keeps game logic, connection-ready state, and frontend publishing in one inspectable workflow.
Canvas and game loop
A real render-and-update loop for rounds, timers, and animations you can tune.
Connection-ready multiplayer
Lobby and match state with integration points for the service that synchronizes remote players.
Scoring and rounds
Answer handling, per-round scoring, and win conditions modeled as game rules.
Play-test in Preview
Run the local round flow in Preview across screen sizes before you publish.
Responsive by default
Game screens adapt from wide desktop to phone without a separate mobile build.
Keep the source accessible
Export the project or publish supported static frontends while retaining editable source files.
Who builds with it
Games teams ship with the Game Builder
From a live quiz night to a classroom challenge, the same loop produces a real, playable game.
Multiplayer quiz and trivia
Lobby, timed-question, and shared-score flows ready to connect to a real-time match service.
Classroom and training games
Interactive challenge interfaces with scoring rules and a scoreboard ready for synchronized data.
Event and campaign games
Branded browser-game frontends with lobbies and leaderboards you can wire to event infrastructure.
Casual arcade experiences
Canvas-based games with a game loop, input handling, and score tracking.
Common questions
Game Builder, answered honestly
What the Game Builder path produces, and where its boundaries are.
Do I get real code or a locked engine?+
You get editable source files — components, the game loop, state, and styles — that you can read, version, and export. There is no proprietary engine lock-in.
Is the multiplayer real?+
Not in the inline demonstration: it uses fictional match data and no connected backend. The generated source can model the lobby and match state, but remote players need a real-time service that you connect, secure, and test.
Can I play-test before publishing?+
Yes. E-Code runs the local round flow in Preview across desktop, tablet, and mobile. Testing a remote match starts after you connect its networking service.
Can I connect a real-time backend or database?+
The generated state model is code you can extend and wire to external services. The inline demonstration on this page uses fictional data and no connected backend.
How do I change the game later?+
Edit the files directly or ask the Agent for the next change and review the diff against the running Preview.
Game Builder for playable browser prototypes
Describe your game and play its first rounds
Turn the game you have in mind into an editable browser loop, lobby, and scoring system, play-test the local flow in Preview, then connect the service that powers remote matches.