Loading
Where Classic Games Hub is heading next.
A living plan of what we're building next. Everything here is an idea or an intention - not a promise. Plans shift, features ship early or get dropped, and your feedback genuinely changes what comes next. For everything already shipped, see the update log. Have a suggestion? Tell us on Discord.
Every game on the site is being rebuilt, so every game is locked to staff while it waits its turn. This first release reopens none of them: it builds the machinery all twenty-six rebuilds run on. A stage that fills your whole screen instead of a small square in the middle of a page, an effects library so animation stops being something eight games happen to have, skins and arenas, sound that the volume slider actually controls, and input that does not throw your presses away.
The complaint underneath all the others: games play in a small box in the middle of a page, and even fullscreen letterboxes them.
Pressing play hands the game your entire display. Not a 528-pixel-wide box on a page, and not today's fullscreen either - that deliberately letterboxes the canvas, so Snake uses about 56% of a laptop screen and Tetris about 35%. The frame around the game goes away and the game itself grows to fill what is left.
Right now an engine is told how big it is exactly once, when it starts, and eighteen of the twenty-six bake their board size and position into constants at that moment - so making the window wider leaves the board glued to the old top-left with dead space beside it. Engines gain the ability to be resized while running, and re-lay themselves out when they are. Every game then has to answer a question it has never been asked: what do you do with a screen that is a different shape?
Twenty-one of the twenty-six games hardcode their text sizes in pixels, which is fine in a 480-pixel box and unreadable across a 4K display. One scale factor, derived from the stage, applied to every score, timer, label and button the games draw.
Eight games have genuinely good feedback and eight have essentially none, because every effect in the arcade is hand-rolled inside one game and cannot be used by any other.
The shared helper file is 139 lines and contains no easing, no tweening, no particles, no screen shake and no colour blending - so a game either invents its own or does without. The best existing work gets promoted into something every game can use: Target Rush's particle bursts and expanding rings, Simon's screen shake and bloom, 15 Puzzle's frame-rate-correct easing, Reversi's staggered flip cascade.
Reversi is the only game that keeps its animation in a layer of its own, separate from the board state - which is exactly why it can flip a disc by swapping colour at the midpoint while it pinches through zero, and why 2048 and Gem Cascade cannot animate at all. Giving every engine that separation is the single change that makes animating everything possible rather than aspirational.
Every game gets a set of looks. Some free, some earned, some bought, some booster-only, some handed out for events.
A skin changes the thing you control and the pieces you move; an arena changes the world they sit in. Every game gets several of each, and because they are described in code rather than downloaded as pictures they cost almost nothing, recolour instantly and stay perfectly sharp on any screen. Three to six of each are free on day one, so the overhaul is visible to everyone without spending anything.
The rest come from playing: per-game mastery goals, achievements, the credits you already earn, booster exclusives, seasonal sets, and one-off grants for events and prizes. Kept deliberately separate from profile cosmetics - these belong to a game, and you should be able to have a different look set on all twenty-six at once.
Lives, combos, multipliers, power-ups, medals, timers and every piece of on-screen furniture drawn as one family rather than twenty-six dialects. It is what will make a rebuilt arcade look like one place.
Settings has a sound slider. It saves what you set. Nothing reads it. Every game makes noise through one shared square-wave beep at a fixed volume, which is why everything in the arcade sounds like the same two pips. A proper mixer fixes the slider, adds a mute, and lets each game have a real set of sounds.
The site already composes its own background music in code. Games get the same treatment - optional per-game tracks that react to what is happening, duck under sound effects, and stay off until you ask for them.
Most engines remember exactly one input. Take a corner in Snake quickly - up then left inside a single step - and the first press is simply discarded. Buffered input with forgiveness windows across every game, so what you meant is what happens.
Four games respond to the difficulty picker. The other twenty-two are hidden from it, because showing a control that does nothing is worse than showing none. Finishing the job deletes that exception - and corrects the note underneath which still claims easy and hard are unranked, when each has had its own leaderboard since v1.5.1.
Six games return a pause that does nothing at all. Gem Cascade keeps draining its ninety-second clock behind the overlay; Simon and Memory Match keep running queued events and can move on without you. Since the site pauses automatically when you switch tabs, those six have been quietly losing people their runs.
A game reopens when it meets the standard above and the definition of done below - not when its rewrite compiles. They come back grouped by category, so the library refills steadily instead of everything landing at the end.
This is what the staff-only lock is for. Each rebuild is played on production, on a real phone and a real desktop, before it is opened up - because the faults being fixed here are exactly the kind that only show up on a real device.
No leaderboard is cleared, no favourite dropped, no rating lost. A rebuilt game keeps its whole history - which is also the honest test of whether a rebuild moved its difficulty more than intended.
Every part of it is built. None of it is running, and that is a configuration job rather than a coding one.
`bot_all_config()` returns an empty object and the worker has never once checked in, so nothing is broken - nothing has ever been configured. Slash commands, buttons and modals run on Vercel and need credentials plus an interactions URL; the green Online dot, chat XP, automod, the live feed, the counter channels and the server logs need the gateway worker in `bot/` running somewhere always-on, because a Vercel function cannot hold a WebSocket open. The full ordered checklist, and what has already been verified about the current state, is in `docs/discord-bot.md` under *Where this deployment actually stands*. Worth doing early rather than late: it is the largest piece of already-built retention machinery on the site, and it is the only thing here that can reach a player who has closed the tab.
A phone that is already struggling before the game starts does not get faster because the game got prettier.
116 components are marked `"use client"`, which is most of the interface. Every one of them ships its code to the browser and is re-executed there on load, so on a mid-range phone the cost of starting the site up dominates anything the games themselves do - and it is paid on every page, before a single frame is drawn. The work is to find the ones that are client components by habit rather than need (anything with no state, no effect and no event handler is a server component wearing the wrong label), and to push the rest down the tree so an interactive control does not drag its whole page into the browser with it. Measured against the number, not the feeling: the count is the target.
The first eight games come back, rebuilt on the new platform. Every one of them gets the same four things: a new look with skins and arenas, animation on essentially everything that moves or changes, a pass over how it feels and how it handles on a phone, and a real answer to what it does with your whole screen.
The oldest engine on the site and the most played. It gets the most work.
Six arenas instead of one flat grid: a circuit board that lights along the traces you have already covered, a garden that grows behind you, a deep trench with drifting motes, a frozen lake that cracks, a night city seen from above, and a clean minimal board for people who want none of it. Six snakes with actual bodies - segments that bank into corners, a head that turns to face where it is going with eyes that track the food, a tail that tapers. Food becomes a handful of things worth telling apart, each with its own shape, glow and sound.
Nothing in Snake animates today except position, one cell at a time. Now: the snake glides between cells and leans through turns; the head squashes on impact; food breathes and bobs and bursts into segment-coloured particles when eaten; a ripple travels the length of the body each time you grow; the tail leaves a fading trail; arena lights react as you pass them; near-misses with your own body flash a warning; a combo for eating without turning stacks a visible multiplier; speeding up pulls a subtle motion streak across the board; and death is a slow-motion pinch, a screen shake, the colour draining out, and the last few seconds played back.
The eleven puzzle games, which between them contain both the best-built engine on the site and the thinnest. Four of them currently do not animate their core state change at all - tiles and cards simply teleport - so this wave is where the new animation layer earns its keep.
Five arenas that react to how you are doing - a calm studio, a neon shaft, a machine room with working parts, a storm and a clean competitive board. Piece skins from flat classic colours through to glass, metal and light. The well gets real framing, the next and hold queues become part of the furniture rather than absent, and danger is shown by the arena itself darkening as the stack climbs.
Pieces drop with weight and settle with a bounce. Hard drops leave a streak and thump the well. Rotations sweep rather than snap; a kick off a wall shows the nudge. Lines flash, compress and collapse with the stack falling to meet them, and a tetris runs a bigger effect than a single. Combos and back-to-back stack visible multipliers. The ghost piece breathes. Levelling up washes the arena in a new colour. A near-topout pulses red at the edges, and a game over freezes the board and drains it downward.
The last seven - three shooters and four strategy games - and the arcade is whole again. The strategy games are the ones hiding the most: three of them have opponents far better than anything the interface admits to, and none of them exposes a difficulty setting at all.
Five regions of space with their own hazards and backdrops - a debris field, a nebula, a ring system, a derelict fleet and clean vector black. Six ships with distinct silhouettes, engine glows and weapon looks. Rocks get real surfaces and break along believable lines rather than into smaller circles.
The engine flares under thrust and the ship banks as it turns. Rocks tumble on their own axes and split with a burst of debris and dust. Every shot has muzzle flash, travel and impact. Destroying a rock shakes the screen in proportion to its size. The shield flickers and cracks. Hyperspace tears in and out. The saucer arrives with a warning and a sound that circles. Waves announce themselves; the ship exploding is a slow-motion break-up; and clearing a wave pulls the remaining debris into the void.
Waves that genuinely escalate rather than rocks respawning at the same difficulty forever. A saucer, hyperspace and weapon pickups. Three difficulties. Its own touch input - at the moment the on-screen buttons are pretending to be a keyboard, which makes fine rotation impossible - with analogue turning and thrust. Collision that scales, rather than checking everything against everything.
The arcade whole again, and the things that only become possible once every game runs on the same platform. It takes the next free number in the 1.x line rather than 2.0.0: a major version is something an arcade earns by being finished and steady, not something a plan awards itself in advance. 2.0.0 stays unclaimed until there is a reason to reach for it.
One place per game to see everything it can look like, what you have, what you are close to, and what it takes to get the rest - previewed live rather than described.
Per-game goals that teach the game - survive a minute, clear without losing a life, finish on hard, hit a combo you have to plan for - rather than one global number that treats every game as interchangeable. The main source of the skins and arenas that are not for sale.
Record the inputs rather than video - a few kilobytes - and a run can be replayed from a leaderboard entry, raced against as a ghost, or re-simulated on the server to check the score it claims is one those inputs could actually produce.
The arcade has twenty-six games and no good way to play one against another person. This is what happens once the rebuild has finished: give people something to do with each other, and finally tell them when it is happening. Deliberately behind the rebuild rather than beside it - multiplayer written against engines that are still being replaced would only have to be written twice.
Both were asked for as categories, but a game holds exactly one category, so adding them as categories would force Labyrinth and Cube out of Puzzle and Noughts and Crosses out of Strategy just to gain the label. They are properties, not genres - a game can be a 3D puzzle. A tags column alongside the category, with filter chips that combine, and room for `quick`, `endless` or `touch-friendly` later without another schema change each time.
Twenty-six games is past the point where scrolling is browsing. Search across titles, tags and how a game plays, plus a shelf of "like this one" on every game page - the cheapest way to make the back half of the library visible at all.
Every game here was made by the people who run the place. This is the release where that stops being true: you build a game in the browser, play it yourself until it is worth showing, submit it, and once a real person has sat down and played it, it goes into the arcade beside the other twenty-six. The obstacle is worth naming rather than glossing over - every engine on this site is a TypeScript file listed in an import map, and nothing written by a player can ever join that list. Games made by players need a second way of running entirely, walled off from the rest of the site. It comes after the rebuild because a game somebody made deserves the same stage, the same effects and the same controls as everything else, and a runtime written against the shell that is currently being replaced would only have to be written twice.
In the browser, on the site, with nothing to install and no account anywhere else.
Code down one side, the game running down the other, and a button between them that starts it. Templates to open rather than an empty file - a blank one, something top-down, something that jumps and a board game - because the hardest part of a first game is the first twenty lines, not the last two hundred. It saves as you go and it never leaves the browser.
Written down so they are not lost, and deliberately not scheduled. Nothing here is a commitment - some of it will be built, some will turn out to be a bad idea once it is looked at properly, and some is here to be argued with.
Nothing on the site measures return visits. There is a count of registered players and a count of plays, and no way at all to answer the only question retention work is judged on - of the people who signed up on a given day, how many came back the next day, the next week, the next month. Everything needed is already recorded (`profiles.created_at`, `play_sessions.created_at`), so this is a cohort view and a panel rather than new tracking, and it deliberately collects no more about a player than the site already has. Worth building before there is an audience rather than after: a cohort you did not measure at the time cannot be reconstructed later, and every retention feature already built - streaks, challenges, seasons, achievements - is currently being shipped blind.
Colourblind-safe palettes per game, full keyboard remapping, a reduced-motion mode that goes further than the CSS one, proper focus order and screen-reader labelling in menus, and a difficulty floor that makes every game finishable. Much of this is being pulled into the rebuild, but it is worth doing on its own terms afterwards rather than assuming the rebuild caught everything.
Every feature that lands has to clear the same bar before it's considered done:
This roadmap is a plan, not a guarantee. Want to shape it? Play, earn, and let us know what you'd love to see.
Real handling for the things phones actually do: a URL bar that collapses mid-run and changes the height, notches and gesture bars on all four edges rather than only the bottom, rotating the device, and the fixed tab bar that currently sits over the bottom of the screen. Where a browser will not give a page true fullscreen - which includes every iPhone - the game takes over the screen anyway, and you should not be able to tell which one you got.
Party matches currently build their games through a separate, older copy of the player with no pause, no fullscreen, no difficulty and no on-screen controls at all - so playing in a party on a phone means playing with no controls. Both become one shell, or every improvement here has to be made twice and one of them will be forgotten.
Every glow in the arcade is drawn with shadow blur, which is the slowest thing a canvas can do. It is fine in a small box and it is the first thing that will collapse at full screen with heavy effects. A proper additive glow pass replaces it, which both looks better and costs less.
Three of the twenty-six games currently honour reduced motion, despite it being a setting people have deliberately switched on. Every effect answers to it. And a frame-time budget quietly steps effects down on a weaker device rather than letting the game stutter.
The on-screen buttons currently work by pretending to be a keyboard, which is why Neon Runner can only ever jump - there is no second fake key for ducking, so its overhead obstacles are impossible on a phone. Real held and analogue input, gestures, vibration, and controls for the three games that have none at all.
Seven games accept no keyboard input whatsoever. Controls painted onto the canvas - Hangman's alphabet, Mastermind's colour palette, the two-player toggle in Noughts and Crosses - cannot be reached by a keyboard or announced by a screen reader, because as far as the browser is concerned they are just paint.
A real input queue, so a fast corner keeps both presses instead of throwing the first away. Walls as a choice rather than always wrapping. Swipes read from the whole gesture rather than the first 24 pixels, and a phone layout that puts the board above your thumb rather than under it. Three difficulties that change the board as well as the speed. It also fixes a quiet old bug: every Snake run ever recorded reported the length of the snake where the number of seconds played belongs.
Snake currently works out its grid shape from the shape of the canvas, so a wide screen would hand it about eight rows and a snake in a letterbox slit. Instead the play field is designed and centred, and the arena art fills the room around it - so a widescreen game looks composed rather than stretched.
Five arenas with their own physics personality and backdrop - a neon workshop, a sunken temple, an orbital station with the planet turning below, a storm, and a clean classic board. Bricks stop being flat rectangles: they have material, damage states you can read at a glance, and light that spills from the ones about to break. Paddle and ball get skins, and the ball leaves a trail coloured by how fast it is travelling.
Bricks crack in stages, shed chips, and burst into debris that bounces before fading. The paddle squashes on impact and tilts with your movement. The ball trails, streaks at speed, and leaves a brief scorch where it hits. Power-ups tumble down with a glow and a promise of what they are, and the paddle flashes as it collects them. Clearing a row runs a chain reaction along it. Multi-ball splits with a burst; losing a life cracks the screen; clearing a level pulls the whole board apart and assembles the next one in front of you.
The physics are rebuilt around elapsed time rather than frames, so the ball is not faster on a faster screen. Collisions resolve against the face actually struck - at the moment the ball only ever flips vertically on first contact, which is why a hit on the side or corner of a brick sends it somewhere obviously wrong. Ball angle responds to where on the paddle you hit and how you were moving. Power-ups, multi-ball, and a paddle that follows your thumb precisely on a phone.
A wider screen means a wider brick field and more room to recover, not a stretched one - the layout is generated to fit the space it is given, with the arena art carrying the edges. Vertical phone play keeps a taller, narrower field with the same rules.
The simplest game here gets the most dramatic transformation, because there is so little on screen that everything counts. Arenas from a CRT cabinet with scanlines and phosphor bleed through to a neon court, a zero-gravity chamber and a rain-soaked rooftop. Paddle and ball skins, a centre line that reacts to play, and a scoreboard that feels like part of the world rather than text laid on top.
The ball trails and stretches with speed. Paddles squash on contact and recoil from a hard hit. Each bounce throws a ring of sparks and briefly lights the wall it struck. Rallies build heat: the longer one runs, the more the arena reacts, until a long rally has the whole court pulsing. Scoring shatters the ball, shakes the screen and animates the number over. Serves have a wind-up, match point changes the lighting, and the winning point ends in slow motion.
The opponent is rebuilt completely. Today it tracks the ball perfectly at one fixed speed, so it can only be out-reached, never outplayed. Now it has reaction time, misreads, recovery, and a preferred position it drifts back to - and three difficulties that change those rather than its raw speed. Spin off a moving paddle. Two players on one keyboard, and two thumbs on one phone. It also fixes the score shown during play disagreeing with the score submitted at the end.
Pong is the game that benefits most from a full screen and the one most obviously wasted in a small box. A wide court with real distance between paddles, so the ball genuinely travels and there is time to read it.
Named as one of the three worst to play, and currently missing the point of the game entirely.
Five worlds, each with its own hazards and rhythm: a rain-slicked city street, a rushing river, a motorway at night, a lava field, and a snowbound crossing. Traffic becomes actual vehicles with lights, wheels and personality rather than coloured blocks. Six characters to cross with, each animated in their own way, and homes at the top that visibly fill up as you reach them.
Hops arc rather than snap between squares, with a squash on landing and a turn to face the way you are going. Water ripples around logs and turtles; turtles submerge with a warning; logs bob under your weight. Vehicles have headlights that sweep, brake lights, spray in the rain and a horn when they nearly get you. Reaching a home plants a flag with a burst of confetti and the row lights up. Near-misses slow time for a fraction of a second. Losing a life is a proper animation rather than a beep, and completing a level floods the board with celebration before the next one slides in.
The actual game arrives: five homes to fill before the level ends, a timer creating real pressure, turtles that dive, and logs that will carry you off the edge if you let them. Hit boxes that forgive the pixel you were not looking at. Input buffered so a queued hop lands the moment the last one finishes. Swipe and D-pad both properly supported, and difficulty that changes traffic patterns rather than only speed.
A wider road means more lanes visible and more to plan around, with the world extending past the play field rather than a stretched grid. On a phone it stays tall and readable, with the homes always in view so you can see what is left.
Currently impossible to play properly on a phone: the touch button only ever jumps.
A runner should be about the world going past, and this one has almost none. Five routes with deep parallax - a neon skyline, a rain-soaked underpass, a sunrise desert, a data tunnel and a storm - each with foreground, midground and far layers moving at their own speeds. Six runners with real silhouettes and running animations, trails that intensify with speed, and obstacles you can read at a glance.
The runner has a full animation set: run cycle, wind-up, jump, peak, fall, land with a squash, roll, slide, stumble and wipeout. Speed pulls the background faster, stretches the trail, tightens the field of view and shifts the colour. Obstacles telegraph before they arrive. Coins arc toward you as they are collected and click up a counter. A near miss triggers a brief slow-motion and a flash. Milestones flash across the screen; the ground reacts to each landing; and a crash is a tumbling, shaking, slow-motion end with the score counting up over it.
The fix that matters most: a second touch control, so ducking exists at all on a phone - right now the button only ever sends a jump while the game still spawns obstacles you must duck under. Coyote time so a jump at the edge still counts, a jump buffer so an early press is not eaten, variable jump height, and hit boxes that match what feels fair rather than what is drawn. A speed curve that ramps rather than steps, and three difficulties.
A wide screen gives more warning of what is coming, which changes the game from reaction to planning - so the difficulty curve is tuned against how much road you can actually see. The parallax layers extend to fill whatever shape the screen is.
Already one of the better-looking games, so this builds on it rather than replacing it. Five instrument sets, each with its own colours, tones and pad shapes - the classic four, a synth board, a drum machine, a set of chimes and a neon ring. The core in the middle becomes a living thing that reacts to the sequence, and the arena behind reacts to the round you are on.
Pads bloom, ripple outward and press inward when touched, all of which exist today and all of which get more. Added: the core pulses in time with the sequence and spins faster as rounds climb; each correct entry sends a wave through the ring; a completed sequence runs a full lap of light; the round number counts up with a flourish; the tempo rising is visible as well as audible; a mistake shakes, desaturates and replays the step you got wrong; and a new best score breaks the ring apart and reassembles it.
A strict mode where one mistake ends it, an input timeout so you cannot stall indefinitely, and difficulties that change sequence growth and speed together. A best score that survives pressing restart, rather than being wiped by it. Vibration on each pad, and a layout sized for thumbs rather than a mouse.
The ring scales to the shortest edge and centres, with the arena filling the rest - so on a wide screen it becomes a stage with the ring at its centre rather than a small circle floating in a big empty box.
Five settings with their own inhabitants: a garden, a workshop, a haunted graveyard, an arcade cabinet and a laboratory. The things you hit stop being circles - each has a face, a body, an expression and a reaction. Gold targets, bombs and decoys are instantly distinguishable by shape rather than only colour, and the mallet is a real object that swings.
The single biggest change: things rise and duck rather than appearing and vanishing, so there is something to read and time. Added on top: a wind-up look before one emerges, a flinch on a near miss, a squash and a puff of dirt on a hit, a stunned wobble, a taunt for one that escapes, and a bomb that visibly arms before it blows. The mallet swings and recoils. Combos stack a visible multiplier with rising pitch; the score counter rolls rather than jumping; the last ten seconds change the lighting; and time running out ends in a freeze frame.
Waves with patterns worth learning rather than uniform randomness, a combo for consecutive hits, and a real penalty for hitting the wrong thing. Three difficulties changing spawn rate, how long targets stay up, and the mix of decoys. Keyboard support, which it has never had, and vibration on a hit.
The grid grows with the space - more holes on a bigger screen at higher difficulties, rather than the same nine stretched out - and the scene around it fills the rest.
A genuine pseudo-3D racer, currently rendered into a tall narrow box because it was never given a screen size.
Five routes with distinct times of day and weather - a sunset coast, a neon night city, a desert dawn, a mountain pass in rain, and a storm. Roadside detail that actually passes: signs, pylons, barriers, crowds and scenery with real depth. Six cars with their own silhouettes, lights and paint, and traffic that looks like vehicles rather than obstacles.
The car leans into corners, squats under braking, lifts under acceleration and bounces over crests. Wheels turn. Brake lights and indicators work. Speed brings motion blur at the edges, a tightening field of view, wind noise and a shaking frame. The sky moves through its own cycle and weather rolls in. Overtaking throws a wash of air and sound. Drifting leaves marks. Checkpoints explode into light with time added counting up. A crash is a full spin-out with debris, slow motion and a recovery.
A throttle and a brake, so there is something to drive rather than only steering. Checkpoints and a clock to beat, laps, and traffic you can read far enough ahead to plan around. Three difficulties changing traffic density, speed and how forgiving the road is. Touch controls, which it has never had at all, including analogue steering and vibration under braking.
The one with the most to gain. Its projection currently divides by a hardcoded reference width, so widening the canvas both widens the road and squashes it vertically. A proper field-of-view and aspect model replaces it, and a widescreen display finally shows a widescreen road - which is the entire point of this kind of game.
Everything modern that is currently missing: a next-piece preview, a hold slot, lock delay so a piece can be slid home, delayed auto-shift and repeat rates so moving across the board is not hammering a key at whatever rate the operating system happens to repeat, and a proper rotation system with wall kicks rather than the naive coordinate flip it uses now. A seven-bag randomiser. Its own touch controls rather than a swipe approximation, and three difficulties.
The well stays a fixed, fair shape - this is a competitive game and the field cannot grow - so the extra space becomes what a real Tetris screen has: hold and next queues, statistics, level and combo readouts, and arena art, arranged to fit whatever shape the display is.
Named as one of the three worst, and the reason is a single unused value.
Five tile sets - the classic warm numbers, neon, glass, wooden blocks and a set that swaps numbers for symbols entirely - and five boards behind them. Higher tiles stop being darker rectangles and become genuinely special: light, texture and presence, so reaching one is visibly an event.
The whole reason it feels bad: the game works out exactly how far each tile should slide, then throws that away and redraws them in their new places. So nothing slides and nothing merges. Now tiles slide with easing, merges collide and pop with a burst, new tiles scale in, and the board shifts slightly in the direction you swiped. Big merges shake the screen and ripple outward. The score counts up rather than jumping, with the gain floating off the merge that earned it. A new best tile takes over the screen briefly. Running out of moves closes the board down deliberately rather than just stopping.
Undo. A running best tile. The option to keep playing past 2048 instead of the game ending at its own title. Board sizes as difficulty, from an easy five-by-five to a punishing three-by-three. A pause that pauses, which it currently does not. Swipes read from the whole gesture, with a nudge animation when a swipe cannot move anything.
The board stays square and centred - stretching it would be wrong - and the space around it holds the score, the best tile, the history of what you have made, and board art that reacts as the numbers climb.
Five gem sets and five settings - a mine, a temple, a reef, a vault and a clean board. Gems get facets, internal light and weight rather than being flat coloured shapes, and special gems are unmistakable at a glance by shape, not just colour.
Currently the grid is rewritten behind a timer, so gems become different gems with nothing in between. Now: gems fall with gravity and bounce as they land, matches flare and shatter into shards, and cascades chain visibly with each step louder and brighter than the last. Swapping tilts both gems; an invalid swap bounces back. Special gems charge up as they form and detonate with their own effects. The combo counter climbs with rising pitch. The last ten seconds tint the board and quicken everything. Running out of moves shuffles the board in front of you rather than silently.
The timer moves out of the drawing code, so pausing actually pauses it - at the moment the clock keeps draining behind the pause overlay. Swipe to swap, which the controls have always promised and the game has never implemented. Cascade scoring that genuinely rewards chains, special gems for larger matches, an automatic shuffle when no move exists, a hint when you are stuck, and three difficulties.
A larger board on a larger screen at higher difficulties, rather than the same grid blown up, with the setting art framing it and the score and combo readouts given room of their own.
Already one of the better engines. What it lacks is pressure.
Five worlds with their own bubble materials - soap, glass, plasma, ice and a clean classic set. The glossy shading is already good and gets better: real refraction, light that passes through clusters, and a launcher that looks like a machine rather than a triangle.
The aim guide already reflects off walls; now it pulses and brightens as it nears a valid landing. Bubbles squash on impact and settle into the grid. Clusters pop in sequence rather than at once, shedding shards. Detached clusters fall with real weight and splash at the bottom. The launcher recoils and reloads visibly with the next bubble shown. The ceiling descending is a physical, threatening movement with the whole grid shifting. Danger pulses at the line. Clearing the board runs a full cascade, and a lost game has the grid press down over you.
The missing half of the game: a ceiling that descends over time, a shot counter, and levels with objectives, so a careful player can no longer sit there indefinitely. Swap to the next bubble. Fine aiming on a phone with a drag-to-aim control that does not put your thumb over the target. Three difficulties changing descent rate, colour count and starting layout.
Bubble size currently scales with the width of the canvas, so a wider screen makes the bubbles bigger rather than showing more of the field. That is inverted: bubbles keep a sensible size and a bigger screen shows a wider field with more room to aim.
Five board styles - the classic grey, a circuit board, an archaeological dig, a frozen field and a clean modern set. The emoji currently used for mines and flags go, replaced by drawn icons that look the same on every device rather than depending on the phone's font. Numbers get real typography and colour coding that survives colour blindness.
Tiles lift and fall rather than switching state. A cascade of empty squares opens outward as a wave from where you clicked, which is the most satisfying thing this game does and is currently instant. Flags plant with a small flourish. The cursor highlights its square and, when chording, the neighbours it would open. A wrong flag is corrected visibly at the end. Hitting a mine detonates it, then reveals the rest in a chain with the board shaking. Winning flags every remaining mine in sequence and lights the board.
The furniture the game is actually played with: a timer, a counter of mines remaining, and chording - clicking a satisfied number to open its neighbours - which is how the game is played at speed and is entirely absent. First-click safety and long-press flagging already work and stay. A clearer flag mode toggle for phones, and more difficulty steps including a custom board.
A bigger screen means a bigger board at higher difficulties rather than bigger squares, with the timer, counter and controls arranged around it. On a phone the board stays thumb-sized and scrollable if the difficulty is high.
The thinnest engine in the library at 121 lines. Effectively a new game.
Card backs and faces as real sets rather than emoji on a rectangle - animals, constellations, machine parts, playing cards and symbols - across five table settings. Cards get thickness, edges and a back design worth looking at, since you spend most of the game looking at the backs.
Cards currently flip instantly, which removes the one moment the game has. Now they rotate in 3D with a highlight sweeping across the face as it turns. A match pulses, lifts, glows and settles together; a miss shakes both and flips them back with a slower, more deliberate turn so you have time to commit them to memory. Dealing the board is an animation. The timer and move counter tick visibly. A streak of matches stacks a multiplier. The last pair is a slow reveal, and clearing the board sweeps every card up in a cascade.
Board sizes as difficulty rather than one fixed four-by-four, a timer, and scoring that rewards remembering rather than surviving. A pause that pauses - currently it is a no-op whose queued flip-backs keep firing behind the overlay. Keyboard play, which it has never had. Themed sets tied to unlocks.
Bigger boards on bigger screens, with the grid laid out to suit the shape of the display rather than a fixed number of columns, and the table setting filling the surround.
Quietly one of the best-built games here. It is simply too small.
Five tile materials - numbered classic, brushed metal, wood, glass and neon - plus an image mode that slices a picture instead of numbering tiles. The solved-state rainbow cascade it already runs is kept and extended.
Tiles already ease into their slots, which is the right foundation. Added: tiles that cannot move nudge and spring back; a whole row or column pushed at once slides together; correctly placed tiles settle with a click and a glow; the empty slot has a subtle presence of its own; the move counter rolls; a hint traces the path a tile should take; and solving runs the existing cascade with the board lifting and reassembling into the finished picture.
Board sizes from three-by-three to six-by-six as difficulty, undo, a hint, and an optional solver that shows the way rather than doing it for you. It already guarantees the shuffle is solvable, which many versions do not, and that stays. Push a whole row with one swipe rather than one tile at a time.
The board stays square and centred with the material and setting art filling the room, and the move counter, timer and best time given proper space rather than being squeezed above the grid.
Five themes that change the whole framing - the classic gallows, a lock being picked, a ship sinking, ice cracking underfoot and a rocket losing parts - so the losing state is drawn rather than only counted. Letters get real typography, and the keyboard becomes proper on-screen keys rather than paint on a canvas.
Correct letters fly from the keyboard into their slots and land with a flourish; wrong ones shatter and grey out the key. The theme advances a stage per mistake, with each stage animated rather than appearing. Slots pulse when a letter would fit them. The last life changes the lighting and adds a heartbeat. Winning reveals the remaining letters in sequence and celebrates; losing completes the theme animation, then shows the word letter by letter.
Real word lists across categories rather than twenty arcade words hardcoded in the file, so a session stops repeating almost immediately. A hint worth spending something on, and the definition shown once the word is out. Difficulty by word length and rarity as well as the number of guesses. The alphabet becomes real, focusable, screen-reader-announceable buttons - at the moment it is drawn onto the canvas and clicked by coordinate, so no keyboard can reach it and no assistive technology can see it, even though typing already works.
The theme art gets the room to be a scene rather than a small line drawing, with the word and keyboard laid out to suit the shape of the screen - side by side when wide, stacked when tall.
Five fixtures - filament bulbs, neon tubes, a circuit board, candles and a clean modern panel - each with their own warmth, falloff and off-state. The existing eased brightness and warm bloom are the best grid lighting on the site and are the starting point rather than being replaced.
Toggling sends a cross-shaped ripple through the affected cells, which exists and gets stronger. Added: bulbs flicker as they warm; the whole board reacts subtly to each press; a wrong move dims briefly; the move counter and par indicator animate; getting close to a solution brightens the surround; and solving runs the diagonal wave it already has, then lifts the panel and assembles the next puzzle in front of you.
Keyboard play, which it accepts none of today. Board sizes as difficulty rather than one fixed five-by-five. Generated puzzles with a known minimum solution and a par to beat, instead of a random scramble that makes one board trivial and the next brutal. A hint, an undo, and a solver you can ask.
The grid scales to the shortest edge and centres, with the light spilling out into the surround - which on a large screen is the whole point, since the glow is the game's identity.
The strongest engine in the library: exact integer turns that cannot drift, and queued moves so fast input is never dropped.
Five cube finishes - classic stickers, glossy tiles, brushed metal, glass with light passing through, and neon edges - in five settings, from a competition table to a void with drifting light. Real materials, edge bevels and reflections, rather than flat coloured quads.
Layer turns already animate and queue properly. Added: the cube settles with a slight overshoot at the end of each turn; grabbing a face highlights the layer that would rotate; the whole cube breathes while idle and tilts toward the pointer; the scramble is a rapid, dramatic sequence rather than an instant reshuffle; solved faces glow as they complete; the timer and move counter animate; and solving runs a full celebration with the cube spinning, coming apart and reassembling.
A proper speedcubing clock with an inspection period, undo, standard notation shown as you turn, scramble depth by difficulty, and two-by-two and four-by-four cubes. Touch controls, which it currently has none of, with drag-to-turn and drag-to-orbit properly separated.
It currently has no screen size registered at all, so it renders into a default portrait box. Given a real stage, the cube fills it, with the timer and move list arranged around and the setting providing depth behind - the game that most obviously benefits from being big.
The only true 3D game on the site, and the closest to already being full-screen ready.
Five mazes with genuinely different architecture and light - catacombs, an overgrown ruin, a facility with emergency lighting, an ice cavern and a shifting digital space. Real texture on the walls, lighting that falls off with distance, and a map that looks like a drawn map rather than a debug overlay.
Head bob and sway while walking, already present and extended, plus lean into turns. Torchlight flickers and casts moving shadows. The map fills in with a sweep as you explore. Doors open, walls shift, dust drifts in the light. Finding something plays a full pickup animation. Getting close to the exit changes the lighting and the sound. Dead ends are marked with a subtle animation as you turn away, and reaching the exit pulls the camera up and out to show the maze you just solved.
Generated mazes at chosen sizes instead of three hand-carved ones you learn once and never need to solve again. Something to find rather than only somewhere to reach - collectables, keys and locked routes - and a reason to hurry. Mouse look with pointer lock on desktop, which it lacks entirely. The dual-thumb touch controls are already the best on the site and get analogue refinement rather than replacement.
Its renderer is already fully resolution-independent and derives its focal length correctly, so a wider screen genuinely shows more to the sides rather than stretching - the correct behaviour, and rare here. It needs the screen-size entry it never got, plus a map and heads-up display that scale properly.
A wraparound field that genuinely fills the display, so a wide screen gives more room to run and changes how the game plays, with the region art providing depth behind the action.
Its own description on this site promises playing from behind your barricades. There are no barricades.
Five invasions with their own aliens, colours and skies - the classic silhouettes, an organic swarm, a machine fleet, a spectral wave and a neon set. Aliens get tiers you can tell apart at a glance and worth different points. Barriers, finally, that erode visibly as they take fire. Six player cannons with their own looks.
The formation gets its famous two-frame shuffle, and it is currently static rounded rectangles. Aliens lurch as the formation steps, and the step quickens as their numbers thin. Hits pop them in a burst of their own colour. Barriers chip away shot by shot, leaving real holes. The cannon recoils and flashes. The saucer crosses the top with its own sound and a payout that flies to the score. The last alien moves visibly faster and more erratically. Losing a life shakes the screen and rebuilds the cannon; the formation reaching the bottom takes the whole screen.
The barricades it already claims to have, alien tiers, a saucer, and a formation that tightens rather than only speeding up. Three difficulties changing fire rate, descent speed and barrier strength. Its own touch input with analogue movement, rather than fake key presses, and a fire control you can hold.
A wider formation and a wider battlefield on a wide screen rather than a stretched one, with the sky art extending behind and the score and lives given proper space at the edges.
The best-feeling game on the site already. It counts your accuracy and never tells you.
Five ranges - a shooting gallery, a neon grid, deep space, a forest and a clean test range - with targets that have real construction: rings, materials, and gold and hazard variants that read instantly. A crosshair, which it does not currently have.
The particle bursts, expanding rings and spawn pops it already has are the model the rest of the arcade is being built from, and they stay. Added: targets drift, rotate and shrink with visible urgency as they age; the crosshair reacts to proximity; a hit sends a shockwave and a floating score; a miss cracks the screen where you clicked; combos stack a growing visual and audible ladder; a perfect streak sets the range alight; the time bar pulses in the last seconds; and the run ends on a freeze frame with accuracy counting up.
Accuracy shown during play and recorded on the leaderboard - it already counts every hit and every shot and simply never surfaces either, which for this kind of game is the number that matters most. Three difficulties changing target size, lifetime and spawn rate. A real miss penalty. Keyboard aiming as an alternative, and vibration on hits.
A larger range means targets can be further apart and genuinely test aim rather than sitting within a small box, with spawn logic tuned to the actual size of the stage rather than assuming a fixed one.
Five boards - chalk on slate, neon, carved wood, a sci-fi grid and paper - with marks drawn in the material of the board rather than as generic shapes. Six mark sets beyond X and O. The two-player toggle becomes a real control rather than a pill painted onto the canvas.
Marks already stroke themselves on, which is the right idea and gets extended to every set. Added: the board draws itself at the start; hovering previews your mark faintly; the opponent visibly considers before moving; a winning line is struck through with a sweep and the three marks lift; a draw settles the board with a shrug; the streak counter rolls; and the board wipes and redraws between games rather than resetting instantly.
Three real opponents. Today there is exactly one - perfect play with a deliberate twelve per cent random slip, which is not a difficulty, it is a coin flip that occasionally hands you a game you did not earn. Easy makes plausible human mistakes, medium plays well but misses deeper traps, hard is unbeatable and says so. Keyboard play, which it accepts none of, and a proper accessible two-player toggle.
A small board on a big screen needs a room around it, not a stretched grid: the board stays square and centred with the setting art, the score, the streak and the move history filling the space deliberately.
Five sets - the classic plastic frame, glass, wood, neon and an industrial machine - with discs that have real material and a frame you can see through. Column hover indicators that read clearly, and a drop that looks like something falling into a slot rather than appearing in it.
Discs already drop with gravity; now they bounce, settle and rock. The ghost disc above the column follows your pointer and tilts. Columns highlight as you consider them. A winning line pulses through its four discs in sequence and the frame lights up. A threat you are about to walk into flashes a warning. A full column shakes and refuses. The board empties by opening the bottom and letting everything fall out, which is how the real toy resets.
Difficulty, by search depth - the opponent currently thinks to one hardcoded depth, so there is exactly one strength forever. Keyboard play: its own controls row on this site advertises the number keys one to seven, and the engine has never had a keyboard handler at all. Undo, threat highlighting, and a move list.
The grid stays a fixed seven by six and centres, with the frame becoming a real object in a real setting and the space around it holding the move list, the score and the opponent's thinking.
A far better opponent than anything the interface admits to - and no way to make it easier.
Five boards - green felt, marble, neon, wood and a clean tournament set - with discs that have thickness and edges so a flip is a real object turning over. Valid-move dots become part of the board's design rather than plain circles.
The staggered flip cascade is the best animation on the site and is the model the whole arcade's animation layer is being built from. It stays and grows: discs land with a press, the cascade ripples out from the placed disc in order, and each flip pinches through its edge. Added: the score bar slides continuously as the balance shifts, corners flash when taken, the opponent's considered moves are hinted, a pass is announced rather than silently skipped, and the endgame fills the remaining squares in sequence.
Its strength exposed as three difficulties. Underneath it already weights corners, penalises the squares beside them, counts mobility and searches deeper once the endgame can be solved outright - all of which is invisible and unadjustable. Keyboard play, undo, a move list, and a clearer read on why a square is worth taking.
The board stays square and centred with the setting filling the surround, and the score bar, move list and captured counts arranged around it rather than crammed against the edge.
Five sets - classic pegs, gemstones, a code panel, runes and a clean modern board - with pegs that have material and light. Feedback markers become clear at a glance and carry shapes as well as colours, so the game is playable without relying on colour vision.
Pegs drop into their slots and settle. Picking a colour lifts it from the palette. Submitting a row locks it with a press and the feedback markers resolve one at a time rather than appearing at once, which is the tense moment the game is built around. Deduced information highlights the earlier rows it came from. The remaining-guesses indicator visibly shortens. Cracking the code opens the hidden row with a flourish; running out reveals it slowly.
An explicit submit. It currently commits your guess the instant a fourth peg lands, so a row cannot be reconsidered, and the only way to take a peg back is tapping empty space above the palette - which nothing anywhere tells you. Difficulty by slot count, colour count and whether repeats are allowed. Colour-blind-safe marking, a pause that pauses, and notes you can keep on earlier rows.
The history of your guesses is the game, so a taller screen shows more of it at once and a wider one puts the palette and your notes alongside rather than squeezed underneath.
One game, one seed, the same for everyone, resetting at midnight - so scores are directly comparable in a way a free-play leaderboard never is. A streak for playing every day, and a shareable spoiler-free result card.
The point of doing the platform first: a shared look, a shared sound, shared controls and shared expectations, so moving between games stops feeling like moving between websites.
Every game carrying the multiplayer tag should offer all three, so the tag means one predictable thing rather than whichever mode that game happened to get.
An opponent that is always there, at difficulties that mean something - easy makes real mistakes rather than moving at random, hard plays the best line it can find. Also the honest fallback when nobody is online, and the way to practise before facing a person. The per-game difficulty work in the rebuild is most of this already.
Two players, one screen, sharing a keyboard or passing a phone. The simplest multiplayer to build, often the most fun, and it needs no network code at all.
A short code you send a friend, built on the party system that already carries real-time state. Reconnect if a tab closes, a clear forfeit rather than a match that hangs when someone leaves, and a rematch button that does not make you swap codes again.
A join code needs someone to send it to. Quick play pairs you with whoever else pressed it, roughly matched on that game's rating, and remembers who you keep meeting - a running head-to-head record with the people you play most, which is the part that makes anyone come back for one more.
Anyone else in the party can spectate rather than sit through it, on a short delay so a spectator cannot feed information back. The same view a tournament final would be shown through.
A party mode that runs several games in sequence and crowns an overall champion. By default the five most played at regular difficulty; the host can swap any of them, change the difficulty and set the length. Points per round rather than sudden death, so one bad game does not end it, a running scoreboard between rounds, and a final standing worth screenshotting.
Single elimination with seeding for anything bigger than a party - sign-ups, byes for odd numbers, and a bracket that fills in live as rounds resolve. The five-game run is the casual mode; this is the one an actual event would use.
Winners recorded on the profile, announced to Discord as they happen, and the champion given a role that passes to the next winner rather than accumulating forever. A tournament nobody outside the party hears about is a private game with extra steps.
For the things worth interrupting someone about - a friend request, a party invite, your record being beaten, a tournament starting - built on the notifications table that already exists, so there is no second source of truth. Granular enough to take the tournament alerts and refuse everything else.
Genuine double opt-in, categories rather than one list (product news, a weekly recap of your scores, tournament reminders), one-click unsubscribe in the header, and a hard rule that transactional and marketing email never share a list. Needs an email provider chosen and a sending domain verified before any of it can even be tested.
The twenty-six are handed a bare canvas and left to it, which is right for code that ships with the site and wrong for code that does not. A game made by a player draws through a shorter set of instructions - shapes, text, sprites, sound - and reads input by asking what is currently held rather than by listening for keys. That indirection is the whole point: it is what lets the rebuilt stage, the scaling HUD, the effects library and the touch controls arrive underneath a game that was published months earlier without breaking it, and what makes the same game playable on a phone without its author thinking about phones.
A draft runs in exactly the runtime a published game runs in, so what you test is what everyone else will get. It earns nothing, records nothing and appears on no leaderboard, and there is no separate preview mode that behaves slightly differently and hides the bug until launch day.
Images and short audio, with limits on how many and how large, kept with the game rather than hotlinked from somewhere that can change underneath it. The reviewer sees every single one before it goes live, which is only possible because the game cannot reach out and fetch a twenty-seventh once it is running.
Modelled on how Roblox does it, with one deliberate difference: there is no automatic route to the front page.
Every submission waits in a queue for a person. No trusted-author fast lane, no automatic approval for a small change, no scanner deciding on its own that something looks fine. It is slower and it does not scale forever, and it is the right trade for an arcade this size - the alternative is finding out what got published by reading a complaint.
One place in the admin area holding everything waiting, oldest first, with the code, the assets, who wrote it and what they have submitted before. The part that matters is that the exact build under review is playable right there, because approving a game you have only read is not reviewing it.
The score ceiling, how much score converts into credits and the hard cap on a single run are staff values, filled in at approval and never taken from the person who wrote the game. Otherwise the first thing anybody publishes is a button that pays ten thousand credits a press, and they will not even have to be dishonest about it - the numbers are just the wrong person's to choose.
A published game keeps a live version and a draft version, so improving it means editing the draft and submitting that. What is already out there carries on being played, with its ratings and its leaderboards, right up until the new one is approved. Nobody should have to choose between fixing a bug and staying open.
Turning something down leaves a written reason that reaches its author, and stays on the game so they can read it again while they fix it. A queue that silently swallows work teaches people to stop submitting.
Same page, same card, same favourite button, same ratings and reviews, same leaderboards split by difficulty, same achievements. Not a roped-off section of lesser things with a different layout - it appears in search, in the command palette, in recently played and on the library shelf, because underneath it is the same kind of row as Snake.
A filter for them and a shelf on the games page, the author's name on the card and a link to their profile, and a games tab on every profile listing what that person has published. Somebody making things here should be findable for it.
Playing one earns credits and XP like anything else, at a lower rate and with a minimum length to the run, because a game whose author decides the payout is a very different object to a game whose author does not. The existing hourly limit already stops the obvious version of this; the rest is making sure a published game cannot be quietly rewritten into a slot machine.
They do not, to begin with, and that is a decision rather than something forgotten. Paying creators per play invents a problem the site does not have yet - alternate accounts, rings of people playing each other's games, and caps that have to be argued about - and it is far easier to add later than to take away. Worth revisiting once there are enough games for it to be a question.
The site is about to start running code it did not write, in your browser, while you are signed in.
A game made by a player runs sealed off from the page around it, with no way to reach your account, your session, your saved things or the network. It cannot see the site it is running on and it cannot talk to anything outside itself. That wall is the protection - not a check that reads the code looking for suspicious words, which is a useful hint for a reviewer and would be a terrible thing to rely on.
Nothing stops somebody writing a loop that never ends, by accident far more often than on purpose. A game that stops answering is shut down and says so, rather than freezing the tab and taking the rest of the site with it.
The report button the site already has, pointed at games as well as people and messages, so reports arrive in the queue moderators already read. Taking something down removes it from the arcade, tells its author why, and leaves a record of who decided - the same for every decision made about somebody else's work.
A level requirement to make a game and a limit on how many can be submitted a day. Not to keep anybody out, but because a queue reviewed by hand only works while a person can keep up with it, and the first thing an open submission form attracts is somebody testing how open it is.
The single-player games are self-contained canvas engines with no server dependency mid-run, so a service worker could make the arcade work on a train, syncing scores when the connection returns.
Short themed events with their own cosmetics and a limited-time game variant - the seasons system already built gives these somewhere to live, and the per-game skins give them something to hand out.
The turn-based games map cleanly onto message components - Noughts and Crosses, Connect 4 and Hangman are a grid of buttons and a state machine. Same rules and same engine as the site, so a game started in Discord could be finished in the browser.
`/challenge @user game:` mints a join code for an online match on the site and DMs it to both of you - the shortest path from talking about a game to playing it.
Post the daily challenge automatically each morning and the standings each evening, and announce tournaments as they start, run and finish.
Closed tickets currently end in Discord. Writing the transcript back to the admin panel would put support history in the same place as reports and the audit log.
Rules, then verify, then a role picker for which games you care about - so a new member leaves the door with the channels they want already visible, instead of every channel at once.
Colours, pronouns, and notification opt-ins for tournaments and events, as button menus that need no staff involvement.
The live feed exists; a starboard alongside it would keep the genuinely remarkable runs rather than every high score, and per-game threads would stop one popular title burying the rest.
A small reward for taking part, and a light barrier that raid accounts have to actually earn their way past.