Napkin Arcade

Draw a game on a napkin. An AI studio of NVIDIA Nemotron agents builds it in 3D, playtests it with vision, fixes what isn't fun, and ships a link you can race your friends on.

Comment

Inspiration

Everyone has a game idea — usually scribbled on a napkin and forgotten, because turning it into a real game takes a whole studio: designers, 3D artists, programmers, QA and playtesters. We wanted to give everyone that studio, made of AI agents, and hold it to the standard real studios use: you don't ship until it's tested and fun.

What it does

You snap a drawing or type one sentence. A studio of NVIDIA Nemotron agents running on Nebius Token Factory then:

  • designs the game (Nemotron 3 Ultra): template, world, controls, three stages, a twist, win and lose rules;
  • builds the 3D art (Ultra) from primitives with physically based materials — and the art director (Nemotron 3.5 Super VL) reviews a render of every model with vision, sending back concrete problems ("parts are floating") until it reads right;
  • writes the game code (Ultra) as a JavaScript module for our 3D engine;
  • tests it: a static linter and 15 headless bot players at three skill levels run the real code in a sandbox; crashes and gameplay bugs go straight back to the developer with the exact failing line;
  • playtests it with vision: AI personas (a 7-year-old, a grandpa) look at real frames of the running game, choose every move with Super VL, and write their notes with Nemotron Nano;
  • fixes what isn't fun: the studio lead (Ultra) proposes three fixes, a built-in auto-tuner adds a fourth, the bots measure every one, and only a measurable improvement ships.

In the demo video's live run, the studio took "NEON FARE" from fun score 82 → 90 → 96 and shipped it for $0.09 of AI.

Every game ships with a link and QR code, 3D worlds with real-time lighting, power-ups and combos, a global leaderboard, keyboard and touch controls, and multiplayer rooms: share a link, everyone lands in the lobby, and you race in the same world with live rivals. There's also a free arcade of six polished games — no sign-in needed.

New since the first submission

  • Agentic gates: every game must pass a lint check, 15 bot players, vision playtesters and a 2-player race test before it ships; any failure goes back to the developer agent with the exact error.
  • It keeps improving: a workshop per game with memory. Players' bug reports and ideas arrive for the creator's approval, the agents build them as a draft, and the creator publishes.
  • Community: multiplayer from one link (everyone in their own lane), leaderboards by week, month, all time and country, groups with join links, and tournaments with prizes in any currency.
  • Publish everywhere: offline HTML5, playable ads (AppLovin, Unity, ironSource, Mintegral, Meta, Google), iOS, Android, Android TV, Fire TV, Samsung and LG TVs, desktop — with game controllers and TV remotes — plus an App Store / Google Play connector with cloud builds.

How we built it

  • Nemotron on Nebius Token Factory through the OpenAI-compatible chat completions API: Ultra for design, 3D modeling, code and leadership; Super VL for drawing reading, art review and playing; Nano for playtester summaries. Over development: 397 model calls, $1.34 total.
  • A purpose-built 3D engine on three.js: 12 world presets (neon city, space, underwater, volcano, synthwave…), procedural textures and instanced scenery, ACES tone mapping, soft shadows, reflections, bloom, particles, procedural sound, and a JSON model format the AI can write.
  • Agent tooling: an acorn-based linter that quotes failing lines, telemetry-driven bots (lane planning and sampled safe moves), a fun score with partial credit, and an auto-tuner.
  • Safety: AI-written code only ever runs in sandboxed, opaque-origin iframes in the browser — never on the server. Spending caps per game, per hour, per user and in total.
  • Platform: email one-time-code sign-in, WebSocket multiplayer rooms, global leaderboards, deployed on AWS (EC2 + Caddy HTTPS, Route 53, SES, CloudFormation, Systems Manager).
  • The demo video is generated from the real app: Playwright records it, Amazon Polly narrates it, ffmpeg edits it.

Challenges we ran into

  • Thinking models spending the whole budget on reasoning. Ultra and Super VL sometimes returned no content because reasoning used every token; chat_template_kwargs: { enable_thinking: false } fixed it (the /no_think tag didn't work for the VL model).
  • AI code with subtle bugs. Without reasoning, Ultra sometimes used variables it never declared. A line-quoting linter plus crash and gameplay checks turned this into a self-healing loop.
  • "Everything scores zero." Our first fun score bottomed out at 0 for games that were too hard, so no fix could prove progress. Partial credit for how far players get, plus an auto-tuner, let the studio climb out.
  • Bots that play like people. Early bots lost as often as experts; lane planning and predictive dodging gave real skill differences, so difficulty targets mean something.
  • Making 3D look good from text. We moved from 2D tiles to a full 3D engine and gave the artist hand-made reference models and a vision review loop.

Accomplishments that we're proud of

  • An agent loop that doesn't just generate code — it runs, tests, playtests and measurably improves it.
  • Vision in the loop twice: the same Super VL model reviews 3D art and plays the finished game.
  • Real games, real multiplayer, real leaderboards — live today, at about ten cents per game.

What we learned

Agents get dramatically better when they're held accountable by measurements: a linter, bots and a fun score turn "generate and hope" into "generate, test, keep what's better". Fast, cheap open models on Token Factory make that loop affordable — Super VL makes a playtest decision in about a second.

What's next

More genres (racing physics, puzzles, platformers), drawings becoming the actual textures of characters, longer games with saved progress, and letting players remix any game with a sentence.

How to test (sign-in required to build games)

Judge login — no email needed:

Then try:

  1. Build a game: in the Studio, type an idea (e.g. "a penguin delivering pizza across melting icebergs") and press Build my game. Keep the tab open; a build takes 2–4 minutes while the Nemotron agents design, model, code and test it live.
  2. Play it: press Play — touch, keyboard and game controllers work. Open 🏆 Leaderboard for week / month / all time and by country.
  3. Multiplayer: press 👥 Play with friends, open the share link in a second browser window, then Start race.
  4. Keep improving it: open the game's workshop (My games → the game) and ask the studio for a change in the chat — it's built as a draft and tested before you Publish.
  5. Publish everywhere: in the workshop, download the HTML5 game, the playable ads or the iOS / Android / TV projects.
  6. Community: create a Group (share its join link) or host a Tournament with a prize from the Studio.

No sign-in: play the free arcade at https://napkinarcade.revenuerush.in/arcade, or the AI-made game NEON FARE at https://napkinarcade.revenuerush.in/play/d91b2502.

Built With

Share this project:

Updates

Submission history