How to encode a won Minesweeper board in base64url

glassonion1 — Sun, 04 Oct 2026 09:48:52 +0000

I built a Minesweeper that runs in the browser, and thought it would be nice if you
could share your win screen as a URL and nothing else.

What I ended up with is compact enough to be worth writing down. Here is the algorithm,
with the implementation.

The format

https://9revolution9.com/games/minesweeper?b=0909&mf=kAAQogCAIAiAAHdg&t=125

That link is real. It opens a won 9×9 with eight flags on it, finished in 12.5 seconds.

b is the level, which in Minesweeper is just a board size. Two digits for the width
and two for the height. The three standard levels have been the same since the Windows
version.

level	board	mines	`b`
beginner	9×9	10	`0909`
intermediate	16×16	40	`1616`
expert	30×16	99	`3016`

The mine count is not in b. Counting the mine bits in mf gives it, and that also
leaves room for board sizes nobody has standardised.

t is the time in tenths of a second.

mf is the board, packed six bits to a base64url character.

[ width × height bits ]  is this square a mine?   row-major, left to right
[ N bits              ]  was this mine flagged?   same order, mines only

N is the number of mines. On expert that makes mf 97 characters, and 115 for the
whole query string.

Nothing else travels. 3BV, the usual measure of how hard a board was, is counted from
the mine layout, and 3BV/s is 3BV divided by the time. If the reader can work it out, it
does not go in the URL.

The code

Encoding is one pass over the bits.

export function encode(board: Board): Params {
  const mines = board.mines.flat()
  const flagged = board.flagged.flat()
  // The mines, then the flags of the mined squares in the same order.
  const bits = [...mines, ...flagged.filter((_, i) => mines[i])]

  let mf = ''
  for (let i = 0; i < bits.length; i += BITS_PER_CHAR) {
    let v = 0
    for (let j = 0; j < BITS_PER_CHAR; j++) v = (v << 1) | (bits[i + j] ? 1 : 0)
    mf += ALPHABET[v]
  }
  ...
}

On the last group bits[i + j] reads past the end and gives undefined, which packs as
a zero. That is the padding rule, so the tail needs no special case.

Decoding reverses it. The first width × height bits are the mines and the rest are the
flags. Counting the set bits in the first part gives N, so nothing has to carry it.
Lining the flag bits up with the mines is the only fiddly part.

export function decode(b: string, mf: string): Board | null {
  ...
  const flagBits = bits.slice(squares, squares + mineCount)
  let next = 0
  const flagged = mines.map((isMine) => (isMine ? flagBits[next++] : false))
  ...
}

next only moves when a mine turns up, so the two lists stay in step without either
side carrying an index.

Why the flags are one bit each

The flags take one bit per mine rather than one bit per square. That is where the whole
saving comes from.

[ width × height bits ]  is this square a mine?   row-major, left to right
[ N bits              ]  was this mine flagged?   same order, mines only

Storing two facts per square, a mine bit and a flag bit, costs 480 plus 480 bits on
expert. At six bits per character that is 160 characters, before the time is added. Only
99 of those squares hold a mine, so half the string describes empty ground.

Minesweeper has a rule that makes most of those flag bits unnecessary.

A won board has every non-mine square opened.

A flag stands on an unopened square. A flag on an empty square therefore means an
unopened empty square, and that board is not won. On a won board, every flag is on a
mine.

The mines are already in the string, so the flags never have to say where they are. They
answer yes or no for each mine in turn. That is 99 bits on expert instead of 480, and
the board drops from 960 bits to 579, with no compression and no lookup table.

The rule holds for a won board and nowhere else. A lost one can have flags on empty
squares and needs the full bitmap.

Has somebody done this already?

minesweeper.online, the best known Minesweeper site, puts boards in URLs too. Two things
are different.

It cannot put the flags back. It carries the mine layout and nothing else.

It also packs less tightly. The same expert board takes 96 characters there and 80 here,
or 97 once every flag is added.

It is on GitHub

I wrote the whole thing up as a spec, in case anybody else is building a Minesweeper and
wants boards that travel. The reference implementation has no dependencies and comes to
92 lines, counting the types, the comments and the validation.

glassonion1/minesweeper-board-format

You can play it

The Minesweeper is here. Win a game and it
hands you one of these links. Open somebody else's and you get their board, their flags
and their time, exactly as they left it.