Every game on this site runs the same way: the television is the board, and everyone's phone is a private controller. The contract for building one is a single page, written to be read by a coding agent in one pass. Hand it the address, describe the game you want, read what comes back.
The whole contract
https://totallynotfun.com/llms.txt
Open it
That address serves the document itself, copied byte for byte from the file our own gates read — the copy you hand your agent is the copy we build against. What is not open yet — the npm package, the repository, a link you can send your friends — is listed in full further down, before you spend an evening on it.
A link. Everybody opens it on their own phone. Five people sitting on one sofa, each looking down at their own screen, playing something that would work exactly as well if they were in five different cities — which is the tell, because then why are they on the sofa.
A room. One screen everybody is watching, and a private screen in every hand. The television holds the board, the scores and the reveal; the phone holds your cards, your role, your secret bid. A game that needs both is a game you can only build on hardware everyone in the room already brought with them.
This is not a roadmap. It is what this site has been doing for a year: 80+ games on one authoritative server loop, the finished ones listed on the home page. A game built against the contract speaks the same wire protocol those do — the same message names, kept in step by the same conformance driver — and its phone and TV components are handed the same primitives the shipped games are built from.
One page. Not a tour, not a quickstart that stops halfway, not a video. It states the contract, the caps, the gates and the failure modes, in the order an agent needs them — and the half of it that lists the SDK is generated out of the SDK, so the reference cannot quietly go stale on you.
<the directory above>/
manifest.ts id, name, author, players, controls, how to play, tutorial
server.ts init / onInput / tick / isGameOver / getResults / getPlayerState (pure)
Controls.tsx the phone — a React component; props: state, send, player
Renderer.tsx the TV — a React component; props: state, players
Spectator.tsx optional — a late joiner's phone; props as Renderer
checks/ optional — the game's own harness (a template is provided)npx totallynotfun create <id> scaffold the game directory from the template
npx totallynotfun check the hard gates (§8), then the advisory warnings (§9)
npx totallynotfun play a room on this machine: TV URL + a QR for the phones
npx totallynotfun submit prove it is green, then print the steps to open the PRBuilt, and run against real rooms in our repository every day. Not published to npm yet — today those four run from a checkout, not from a clean machine. See what works today.
Prevents Two phones each convinced they won.
The server holds the only copy of the state that counts. A phone sends an input, never a fact. Your rules are a pure reducer — state in, state out, no clock of its own, no storage — and the room is the thing that runs it, at the same cadence every game here has always run at.
Prevents The card game everybody can read over your shoulder.
Declare that your game holds hidden information and the runtime stops sending anyone the raw state: the television gets one projection, each phone gets its own. A scan reads both and fails the build if a projection carries another player's private fields — which is the bug that would otherwise ship looking perfect.
Prevents The evening ending because somebody's battery did.
Four letters on the television and a camera. Nothing to install, and nothing for a guest to sign into. When a phone sleeps, drops or wanders out of range, the seat stays reserved — name, colour, score, place in the game — and the page reclaims it when the phone comes back.
Prevents One stranger's game taking down everybody else's night.
Your rules run inside a JavaScript engine compiled to WebAssembly, one instance per room, with its own memory ceiling and a deadline on every single call. Random numbers and the clock are handed in by the room, so two rooms fed the same inputs play the same game — which is how a reported game gets replayed and a stuck one gets stopped.
And two things we do not have. There is no rollback netcode and no client-side prediction anywhere in this platform. An input travels to the server and the result travels back — the right trade for a room staring at one shared screen, the wrong one for a twitch shooter. Build with that in mind, and the page you are reading will not have lied to your agent.
Open the room on the television. Four letters appear. Everyone points a camera at them and they are in — nothing to install, no guest signing in, nothing to wait for. It is the same thirty seconds for a game that shipped last year and a game your agent wrote this morning.
An illustration of a room, not a screenshot. Room codes really are four letters, drawn from an alphabet with no I and no O so nobody types a one or a zero.
npx totallynotfun does not resolve from a clean machine; the commands run from a checkout of the repository.That is the entire gap, written down because the alternative is you finding it yourself twenty minutes in. The document, the contract and the gates are the parts that take months; they are done. The rest is a switch.
Email support@totallynotfun.com with one sentence about the game you would build. When the repository opens, that list hears first — and if you want to start reading tonight, the contract is one page.