Go (LittleJS Arcade)

Most of the classic-board-game conversions that turn up as candidates for this shelf get one thing right and one thing wrong: they get the rules correct and then treat touch as an afterthought, expecting a thumb to land on the exact pixel a mouse cursor would. Frank Force's Go — one entry in his larger LittleJS Arcade collection, built on his own open-source LittleJS engine — is the rarer case of a conversion where someone actually thought about what happens when the input device is a finger instead of a cursor.

A real Go, not a demo with stones on it

The board is 9x9 rather than the traditional 19x19, which is the standard "small board" size serious Go players actually use to teach beginners or play a quick game, not a simplification invented for this port. Everything that makes Go actually Go is here: placing a stone that leaves an opposing group with no liberties captures it, the win condition is calculated from territory surrounded plus stones remaining on the board with komi added for White to offset the advantage of playing second, and two consecutive passes end the game and trigger scoring. The in-game HELP screen states all of this outright, correctly, in plain language, rather than assuming the player already knows the rules or leaving them to find a wiki. There's a genuine AI opponent (labelled by difficulty), a player-vs-player mode for two people sharing a device, and an AI-vs-AI spectator mode that's a pleasant way to watch the engine play against itself.

The part that actually matters for this shelf: touch precision

A 9x9 board squeezed onto a 390-pixel phone screen is a real constraint, and it's worth being honest about the raw number: adjacent intersections measured out to roughly 37 CSS pixels apart in testing, computed directly from the game's own getIntersectionWorldPos and worldToScreen functions rather than eyeballed off a screenshot. That's short of the roughly 44-pixel target most mobile design guidelines recommend. What keeps that from becoming a real problem is that the game accounts for it: its own worldPosToIntersection function snaps a tap to the nearest intersection as long as it lands within half a cell of it, which in practice means every intersection has a full-cell-sized forgiving catchment zone, not a bare single point. This was confirmed directly rather than taken on faith — placing a stone with a tap deliberately offset 12 to 16 pixels from the true intersection still placed it exactly where intended, with the AI replying on the very next frame. That's the difference between a board game that happens to render on a phone and one that was actually built to be tapped on one.

Where it's thinner

There isn't much to complain about mechanically, so what's left is mostly about scope. This is a faithful, well-executed conversion of an existing game rather than an original idea, which limits how much credit it can claim next to something inventing its own systems — that's simply what a Go implementation is for, and it would be an odd thing to hold against it too heavily, but it's worth naming plainly. The bigger practical gap is that the board sits in a fixed square in the middle of the screen without growing to fill the generous black space above and below it on a phone held in portrait — not a functional problem, since the board itself is perfectly playable at the size it renders, but a missed opportunity to make the single most important element on screen larger than it needs to be. And, like most single-page browser board games, there's no save-and-resume: closing the tab mid-game loses it, and player-vs-player means two people at one screen rather than any kind of online matchmaking.

The verdict

Go doesn't try to reinvent anything, and it doesn't need to — it's a correct, well-explained, nicely presented 9x9 Go that happens to have had real thought put into how a thumb interacts with a board this dense, which is precisely the thing this shelf exists to reward. It won't be the flashiest thing here, but it's one of the more trustworthy ones.