Gemini 4 Argon Game From One Prompt: We Tested the Controls

The clip of a one-prompt Gemini 4 Argon game looks the same whether or not the jump key works. Video shows rendering. It doesn’t show what happens when a player taps Space faster than one frame, or switches tabs mid-run, or presses R after dying. Those are the parts that make something a game rather than an animation.

This post reads the 48 game posts in SandBase Lab’s launch-week collection, then runs our own test: one prompt to google/gemini-4-argon on SandBase for a single-file canvas game, 19 automated keyboard checks in headless Chrome, one fix prompt, and the real bill. It’s for developers who want a playable prototype from a prompt and need to know what to check before sharing the link.

Key takeaway

• Our one-prompt game, a 23 KB single HTML file, loaded with zero console errors and passed 18 of 19 input and state checks: movement, pause, delta-time clamp, score, lives, game over, restart, saved best score.
• The one failure was input timing. A Space tap shorter than one frame was dropped (0 of 10 instant taps hopped), because the jump was polled from a held-keys set. A one-paragraph fix prompt produced a 10-line diff that passed 19 of 19.
• Both calls together took about 2 minutes and cost $0.390808 on SandBase ($4 / $20 per 1M tokens). The same tokens at Google’s $2 / $10 intro rate would be about $0.195.
• Of 48 game posts in the Lab collection, 20 are side-by-side model comparisons. Creator-reported costs run from $1.16 to $54.41, mostly driven by agent harnesses resending context. We haven’t verified any of them.

What 48 Gemini 4 Argon game posts show

SandBase Lab collected 264 public X videos of Gemini 4 Argon work posted October 13 and 14, 2026 (gallery, synced 2026-10-14T16:29:53Z). Forty-eight are tagged game: 5,054 likes and about 512K views in total, a median of 20 likes and about 36 seconds. Only 10 shared a prompt. Everything below is the creators’ own description; we haven’t run their games or checked their numbers.

What they built, by what the game asks of the code:

Genre	Examples (credited)	What it needs from the code
Racing and flight	desk-photo racer by @genevieve__h, posted by @googledevs, drone racer Heatsink by @aniketjart, kart racer by @chasen_liao, WWII fighter by @exploraX_	continuous steering input, camera follow, collision
Arcade and casual	3D Flappy Bird by @ivanainai, jellybean bounce by @doe_naps, Jelly Jet Takeoff by @nex_ify	tap timing, score, restart loop
Physics sandboxes	rollercoaster builder by @burhansebin, chain-reaction machine by @procesor_x	mouse drag, simulation step
Board, card and strategy	WebGL mahjong by @soumyadesign, roguelike deck-builder by @realbrucemartin, civilization sim by @remoteugur	turn state, rules, many UI states
Voxel and open world	voxel world with weather by @jerrod_lew, “first to the Nether” race by @fawnunwrap	world state, block placement
Unusual inputs	multiplayer capture-the-flag by @chongdashu, SNES assembly level edit by @venturetwins, meditation-headband control by @0xVibeDino	networking, ROM tooling, Bluetooth

At least 27 of the 48 mention 3D, Three.js, WebGL or voxels. Controls are another matter: only a handful of posts mention input at all (drag, click, a phone swipe, a headband). The collection shows what a game looks like, not whether its input handling holds up.

The comparison clips

Twenty of the 48 put Argon next to another model on the same prompt: Claude Opus 5.5 in 10, Muse Wonder in 8, GPT-6 Astra in 3, GPT-6.1 Sol in 2, SWE-2 Max in 1 (some name several). The most-liked game post is one of them, @universalmodhq’s Argon vs Muse Wonder clip with 2,089 likes. Comparison posts had a median of 28.5 likes against 19 for solo posts, but with 20 and 28 posts that gap isn’t clear evidence (permutation test on the median, p ≈ 0.10).

Treat these as one person’s single run. Prompts are often missing, harnesses differ (Antigravity, Cursor, Devin, JetBrains, AI Studio, the Gemini app), and nobody plays both games under the same test. @xueyu1125 re-ran a shared boss-fight prompt in Devin, said the result came nowhere near the comparison video, and questioned whether that clip was genuine. We can’t settle that. A clip is not a reproducible result.

The cost claims are the most useful numbers in the set, because they vary so much:

Creator claim (unverified)	Harness	Reported cost and time
@wikiwayne: 7 one-shot games, “7/7 on the first try. Zero edits.”	not stated	$1.34, about 6 minutes, 132K output tokens
@nex_ify: Jelly Jet Takeoff from a one-line prompt	not stated	$1.16, 11m6s
@realbrucemartin: roguelike deck-builder, one HTML file	Devin	~$1.75 at a 75% Devin discount, 56 minutes, 6.5M in / 109K out
@universalmodhq: Argon vs Muse Wonder	not stated	Argon $29.71, Muse Wonder $3.45
@jetbrains: web-swinging delivery game, two agents	JetBrains	Argon $54.41, 23 min; Opus 5.5 $56.97, 2h 20m

The Lab detail page for @wikiwayne’s seven-game gauntlet shows the claim word for word, and notes that the author did not share the exact prompt (captured 2026-10-14 UTC).

Look at the realbrucemartin row: 6.5M input tokens against 109K output. An agent that resends its context every turn pays for input many times over. The wikiwayne figure is roughly what 132K tokens cost at Google’s $10 per million intro output rate. These are different games, but a 40x spread for one model mostly tracks the harness, not the price list. Our test sits at the cheap end on purpose: one request, one file, no agent loop.

Our run: one prompt, one HTML file

The prompt asked for “Lantern Drift”: steer a paper lantern along a night river, catch fireflies for 10 points, dodge falling embers, 3 lives, rising difficulty. I picked 2D canvas because the questions here are loop and input, not rendering (our Three.js scene test covers that). The prompt spelled out what a game needs and a demo doesn’t:

• four states: title, playing, paused, gameover
• arrows or A/D to move, Space to hop, Enter or Space to start, P to pause, R to restart
• requestAnimationFrame with delta time, clamped so a background tab doesn’t teleport objects
• a key set on keydown/keyup, with preventDefault on arrows and Space so the page doesn’t scroll
• one second of blinking invulnerability after a hit, best score in localStorage
• a read-only test hook, window.__game.getState(), returning state, score, lives, best, player position, entities and a frame counter

The test only reads the hook; every action goes through real keyboard events.

The request, sent 2026-10-14 at 18:58:29 UTC:

{
  "model": "google/gemini-4-argon",
  "max_tokens": 32000,
  "messages": [{"role": "user", "content": "Build a complete, playable browser game called \"Lantern Drift\" in ONE self-contained HTML file ... Return only the HTML file in a single ```html code block."}]
}

The full prompt is 22 lines, about 290 words. Reasoning effort, temperature and seed stayed at the route’s defaults; the endpoint is POST https://api.sandbase.ai/v1/chat/completions (guide). Trimmed response:

{"id": "25144395-ad80-48e6-9119-8efe4096de23",
 "choices": [{"finish_reason": "stop", "message": {"content": "```html\n<!DOCTYPE html>\n<html lang=\"en\"> ..."}}],
 "usage": {"prompt_tokens": 438, "completion_tokens": 8762,
           "completion_tokens_details": {"reasoning_tokens": 0}, "total_tokens": 9200}}

The call returned in 63.0 seconds: one 848-line, 23,077-character HTML file and nothing outside the code block. GET /v1/tasks/<id>/cost billed $0.176992, exactly 438 × $4/M + 8,762 × $20/M. Usage reported zero reasoning tokens; from outside we can’t tell whether the model reasoned without reporting it.

How we tested it: 19 checks with real key events

The harness is a Node script on playwright-core driving local headless Chrome at 1280×800. It records every console message and page error and walks the game:

load file ──> title? ──Enter──> playing ──> frames advancing?
   │                                  ├─ hold Right / A ──> x changes, stays inside canvas
   │                                  ├─ Space held 100 ms, then 10 instant taps ──> hops?
   │                                  ├─ freeze main thread 2 s with Right held ──> no teleport?
   │                                  ├─ P ──> frames and entities frozen, input ignored ──> P resumes
   │                                  └─ play on until lives = 0 ──> gameover, best saved
   └─ R ──> score 0, lives 3 ──> reload page ──> best still there ──> zero console errors?

Two checks catch what screenshots never do. The instant tap sends keydown and keyup with no wait, so both land between two frames, like a fast tap during a frame drop. The stall check blocks the page for 2 seconds with Right held: unclamped, the lantern would move about 640 pixels at 320 px/s.

The core of the tap check, simplified from the harness:

// Read-only probe: count how many of 10 instant Space taps make the lantern leave the water.
async function countHops(page, taps = 10) {
  const y = () => page.evaluate(() => window.__game.getState().player.y);
  let hits = 0;
  for (let i = 0; i < taps; i++) {
    const y0 = await y();
    await page.keyboard.down('Space');
    await page.keyboard.up('Space');            // released before the next frame
    let minY = y0;
    for (let k = 0; k < 8; k++) {               // sample ~240 ms of flight
      await new Promise((r) => setTimeout(r, 30));
      minY = Math.min(minY, await y());
    }
    if (minY < y0 - 10) hits++;
    await new Promise((r) => setTimeout(r, 1100)); // wait to land
  }
  return hits;
}

Lantern Drift after the fix, 230 ms after a Space tap: hop, splash and live HUD all come from Argon’s unedited file (2026-10-14, 2× capture).

What broke on the first try

Eighteen checks passed. The loop ran at 60 fps, the lantern stopped at x 20 and 780 on an 800-pixel canvas, pause froze the frame counter and every entity, and the 2-second stall moved the lantern 21 pixels instead of 640. Lives went 3, 2, 1, 0, and the best score landed in localStorage and survived a reload. No console errors or warnings.

The failure: a held Space (100 ms) hopped every time, but instant taps hopped 0 of 10. A probe with different hold times made the cause plain: 0 ms gave 1 hop in 10, 5 ms gave 3, 30 ms and 100 ms gave 10. The code only checked keys.has('Space') inside update(). If the key went down and up between two frames, the update never saw it.

Most human taps last longer than 16 ms, so at a steady 60 fps you’d rarely notice. At 30 fps a frame is 33 ms, quick taps start slipping through, and a jump that sometimes ignores you is what players remember.

While writing the fix prompt we added two constraints we hadn’t tested. A later probe showed v1 broke both: the Space press that starts the game also hopped on the first frame, and holding Space auto-repeated hops (3 in 2.4 seconds).

One fix prompt

The fix prompt was a bug report, not a patch: what passed, the repro (instant taps, 0 of 10), the cause (polling the held-keys set), and the expected behavior. Every Space keydown during play hops if the lantern is on the water, holding doesn’t auto-repeat, Space on the title only starts the game, “change nothing else”. We sent the original prompt, the first file as the assistant turn, and the bug report.

The second call (2026-10-14 19:05:11 UTC) took 57.3 seconds, used 9,429 input and 8,805 output tokens, and cost $0.213816. Argon rewrote the whole file, as asked, but a diff against v1 shows only about 10 changed lines: a jumpQueued flag set on a fresh keydown (ignoring e.repeat), consumed in update(), cleared on start. The rest of the file was untouched.

Our harness output as a table: v1 and v2 differ only on the instant-tap check; times and costs come from the two calls and their /v1/tasks/<id>/cost records.

v2 passed 19 of 19, with 10 of 10 instant taps. The extra probe confirmed the two quirks were gone too: Space on the title screen started the game without hopping, and holding Space for 2.4 seconds produced zero extra hops.

The v2 game-over state reached by play, not by a shortcut: lives ran out during the harness’s left-right wiggle loop, and R then reset score to 0 and lives to 3 (2026-10-14).

What it cost

Call	Time	Input / output tokens	SandBase charge	Same tokens at Google’s $2 / $10 intro
v1, one prompt	63.0 s	438 / 8,762	$0.176992	$0.0885
v2, fix prompt	57.3 s	9,429 / 8,805	$0.213816	$0.1069
Total	120.3 s	9,867 / 17,567	$0.390808	$0.1954

SandBase lists Argon at $4 / $20 per million tokens: Google’s standard rate after the intro period ends on November 30, 2026, and twice Google’s direct intro price today. Output was about 99% of the v1 bill. The fix turn costs more because it resends the first file as input. The pricing guide works through caching and the December 1 change.

The Gemini 4 Argon model page on SandBase shows the $4 / $20 rate behind our bill and a 65.5K max output, far above the 8.8K tokens one game file needed (captured 2026-10-14 UTC).

At this size each extra fix round adds about $0.21, because the model rewrites the full file. If your game is 5x larger, expect roughly 5x the output cost per call, and remember that a single SandBase response stops at 65.5K output tokens. Asking for a diff instead of the whole file should cut output; we didn’t test that.

A prompt pattern for playable games

What made this run easy to check was the prompt:

1. Name the states. title, playing, paused, gameover gets you a state machine instead of a loop that only knows “running”.
2. Spell out every key per state. Input bugs live in the gaps, like Space meaning “start” on one screen and “hop” on the next.
3. Ask for edge-triggered actions. Write “every keydown produces exactly one jump, even if released before the next frame”. We didn’t, and that’s the bug we got.
4. Require a delta-time clamp and preventDefault. Argon followed both on the first try; without them, tab switches and page scroll are the usual first complaints.
5. Ask for a read-only test hook. One getter turns “looks right in a video” into a check that fails loudly.
6. Fix with a bug report. Repro, observed, expected, “change nothing else”. Here that gave a 10-line diff, not a redesign.

For a longer prompt guide built from the prompts creators shared, see Gemini 4 Argon prompts for creative coding. For a 3D puzzle where progression and collision were the hard parts, our earlier GPT-6 Astra vs Claude Fable 5.1 game test used a similar test-hook approach.

FAQ

Can Gemini 4 Argon make a playable game from one prompt?

In our run, yes, with one caveat: the first file passed 18 of 19 checks and missed fast Space taps; one fix prompt brought it to 19 of 19. One prompt, one genre, one run: an example, not a success rate.

How much does a one-prompt Gemini 4 Argon game cost?

Our 23 KB canvas game cost $0.177 plus $0.214 for the fix on SandBase, $0.39 total. Creators report $1.16 to $54.41, mostly in agent harnesses that resend context; those are their numbers.

Why did the first version miss some jumps?

It checked whether Space was held during each frame, so a tap that starts and ends between frames was never seen. The fix queues each keydown and consumes it in the next update.

Do the comparison videos show which model makes better games?

No. Each is one creator’s single run, usually without the prompt, in different tools, with nobody playing both games under the same checks.

How do I test a generated game automatically?

Ask for a read-only state getter, load the file in headless Chrome with Playwright, send real key events, and assert on state. Include an instant tap and a main-thread stall; they catch timing bugs a screenshot can’t.

Limitations

One prompt, one 2D canvas genre, one run per version, default settings, 2026-10-14 UTC. Headless Chrome on a Mac at 60 fps only: no Firefox or Safari, touch, gamepad, other refresh rates, audio or accessibility review. “Playable” means the specified controls and states work, not that the game is fun. Creator posts are self-reported and unreproduced. For where Argon ranks on independent benchmarks, see the Gemini 4 Argon leaderboard post; for the most-liked builds across all categories, see the best Gemini 4 Argon examples.