Stories

One game of Kubb, written once

Kubb: Throwing Wood began on the Playdate on November 13, 2026. Four days later its rules and physics came out as the Kubb Engine, which a browser and an iPhone carry byte for byte, so the two compute the same throw. Every match is written down in Planet Kubb Notation, which Jamie began in 2012.

2012 to now · 5 things

In order

  1. Kubb: Throwing Wood Active

    A game of Kubb for the Playdate, thrown with the crank. Jamie began it in November 2026, and its core became the Kubb Engine, which the web and iPhone games run too. The Playdate version is not released; a test build is out for friends to sideload.

    – now 2025-12: 02026-01: 02026-02: 02026-03: 02026-04: 02026-05: 02026-06: 02026-07: 02026-08: 02026-09: 02026-10: 02026-11: 0
  2. Kubb: Throwing Wood on the web Active Gadget

    The Playdate game Kubb: Throwing Wood in a web browser: a match on a link with friends, a match against the computer, or the practice pitch, thrown with a dial or a linear meter in place of the crank. Anyone can watch an open game and move the camera round the pitch. It runs the Kubb Engine, and a phone running the iPhone game can join its pitches.

    – now 2025-12: 02026-01: 02026-02: 02026-03: 02026-04: 02026-05: 02026-06: 02026-07: 02026-08: 02026-09: 02026-10: 02026-11: 0
  3. Kubb Engine Active

    The rules, physics, notation and session of Kubb: Throwing Wood, as pure Lua. It was taken out of the Playdate game on November 17, 2026, and each release is a tag that the Playdate, web and iPhone games carry byte for byte.

    – now 2025-12: 02026-01: 02026-02: 02026-03: 02026-04: 02026-05: 02026-06: 02026-07: 02026-08: 02026-09: 02026-10: 02026-11: 0
  4. Kubb: Throwing Wood for iPhone Active

    Kubb: Throwing Wood as a native iPhone app, begun on November 17, 2026. It runs the Kubb Engine in Lua with musl’s math built in, so its throws match the web game’s hash for hash, and it plays on the same pitches. Since November 19 it plays on an iPad too, the same game on a bigger screen. It is in TestFlight, and since November 20 anyone can join its testers from a public link. Since November 21 they have version 0.4, with Day, Night and Neon scenes.

    – now 2025-12: 02026-01: 02026-02: 02026-03: 02026-04: 02026-05: 02026-06: 02026-07: 02026-08: 02026-09: 02026-10: 02026-11: 0
  5. Planet Kubb Score Active Gadget

    Jamie’s notation and scoring system for recording Kubb games, begun on Planet Kubb in 2012. He is rebuilding it, and it is not published yet.

    – now Latest commit Aug 17, 2014 2025-12: 02026-01: 02026-02: 02026-03: 02026-04: 02026-05: 02026-06: 02026-07: 02026-08: 02026-09: 02026-10: 02026-11: 0

Kubb: Throwing Wood started on the Playdate on November 13, 2026. The crank is the throwing arm, read as a clock: pulled back it sets the power, and where it stops on the way forward sets the arc. Claude writes the code, in Lua, and Jamie plays each build on his Playdate and says what is wrong with it. The first match on a real Playdate was played that first day. It ran six turns in seven minutes, ended when Team B resigned, and was saved as a game file in Planet Kubb Notation.

Two days later, on November 15, Claude built the same game for a web browser in one day. The Playdate game’s own Lua runs in it unchanged, compiled to WebAssembly, with a dial in place of the crank. Friends open a link, pick a side and play one match, each on their own screen. The browser of whoever throws decides the throw and sends it, and every other browser replays it on its own copy of the pitch and checks a hash of the match.

On November 17 the core came out of the Playdate game, history and all, as the Kubb Engine. It is pure Lua that draws nothing and reads no buttons; a game brings those. Each release is a tag. A game copies a tagged release byte for byte and never edits its copy, and a manifest gives a sha256 for every file, so a copy that drifts fails its own tests.

The iPhone game was begun the same day. It is written in Swift, but the game in it is the engine. For a phone and a browser to share a match, every throw has to land in the same place on both, to the last bit. The physics calls sine, cosine and square root thousands of times a throw, and math libraries can differ in the last digit, which grows into a different landing within a few throws. Stock Lua on a Mac, measured on November 17, parted from the browser at the fourth throw of the first golden match. So the reference is the browser’s, Lua in WebAssembly with musl’s math, and the app compiles musl’s math into its own Lua. Its tests play the engine’s twelve golden matches and check every hash. The Playdate’s 32-bit floats never agree with either, so it plays alone.

The iPhone game went into TestFlight with a small group of testers on November 18. On November 19 it became an iPad app as well. Jamie: “The idea of an iPad version would just be to give us a little bit bigger screen” (the app’s notes). So the engine’s core plays on a Playdate, and all of it in a browser, on an iPhone and on an iPad.

Every one of them keeps score the same way. The engine’s notation writer saves each match as a game file in Planet Kubb Notation, and its tests read each one back with the notation’s own grammar. The same notation holds the 150 tournament games the computer’s throwing is tuned against. They are the mark for its Pro level. Jamie: “there is no professional kubb. So that is essentially the best kubb there is” (the engine’s notes).

The notation is fourteen years older than the game. Jamie began it on Planet Kubb in 2012 with Garrick van Buren, who drew up the first scoresheet. In the interview he remembered that “we brainstormed a lot around things like the Planet Kubb notation system and score sheets”. By July 2012 the wiki’s Notation page set out a notation that could be sent over Twitter “turn by turn, tweet by tweet.” In August 2014 Jamie wrote a grammar for it. He is rebuilding the notation, grammar and scoresheets as a new site, and it is not published yet.

One game, written once: a crank on a Playdate, a link for friends, a phone in the hand, and a notation from 2012 keeping the score.

What happened when

  1. archive Kubb, notation, and a community on the web

    Open Loop’s Kubb Fever episode links Planet Kubb Notation and Scoresheet. This dates the public record, not the original launch. Source

  2. milestone A scoresheet with on-pitch stats

    A new Planet Kubb scoresheet records statistics during play. Source

  3. development Notation BNF grammar

    Jamie writes a BNF grammar for the notation. Source

  4. development Kubb: Throwing Wood gets its look

    A design session gives the Playdate game a look called Woodcut, three tones, hard shadows and a white pitch, with comic bursts reading TOK, KLAK and KING on a hit. Jamie approves it the same day, and building it into the game begins. Source

  5. milestone Kubb: Throwing Wood goes out to friends

    The day after it was begun, a first test build of the Playdate game goes up on playdate.thingelstad.xyz for friends to sideload. It is not a release. Source

  6. milestone Kubb: Throwing Wood’s release candidate

    Version 0.9.5 goes up for friends as the release candidate for 1.0.0, with a throw rebuilt that day to read the crank as a clock, and HOW TO PLAY and HOW TO THROW to teach a new player. Source

  7. launch Kubb: Throwing Wood on the web

    The Playdate game goes live in a web browser at kubb.thingelstad.xyz, built by Claude in one day, with its own Lua core in WebAssembly, a dial for the crank, and friends joining a match at a link. Source

  8. development The Kubb Engine is taken out of the Playdate game

    The rules, physics, throw, computer thrower and notation of Kubb: Throwing Wood leave the Playdate game with their history, joined by the web’s session and room, and become a Lua engine that every version carries from a tagged release. Source

  9. milestone Kubb: Throwing Wood 0.9.6

    The Playdate game’s physics release, with the night’s fixes measured against MuJoCo, real throws on video and a fuzzer, and a new bundle id at the game’s own domain. Source

  10. development Kubb: Throwing Wood for iPhone begun

    A native iPhone app starts, running the Kubb Engine in Lua with musl’s math built in, so its throws match the web game’s hash for hash. Source

  11. milestone Kubb: Throwing Wood gets its own domain

    The game on the web moves to throwingwood.com, its own home, and links to kubb.thingelstad.xyz carry on there. Source

  12. milestone Kubb: Throwing Wood 0.9.7

    A new test build of the Playdate game on engine 0.5.1, with batons that turn over less, a computer that adds spin to its drills, and fallen wood that slow impacts can move. Source

  13. milestone Kubb: Throwing Wood for iPhone in TestFlight

    The iPhone game goes into TestFlight with a small group of testers, a day after it was begun, playing practice, the computer and shared pitches. Source

  14. development Kubb: Throwing Wood’s controls, remade for a hand

    The web and iPhone games take the same new controls, a clock or a linear meter as the player’s choice, a hint shown on the meter, sliders, STAND, raising a kubb by touch, and a phone turned on its side. Source

  15. development Kubb: Throwing Wood’s crank can turn either way

    After one player found the crank backward, the Playdate game makes the crank’s direction a setting in the System Menu, and tells a player who seems to be cranking the wrong way how to flip it. Source

  16. development Kubb: Throwing Wood for iPhone plays on an iPad

    The iPhone game becomes universal, the same game on a bigger screen, laid out by the window’s size in all four of an iPad’s turns and in a resizable window, and goes to the testers in build 90 that evening. Source

  17. milestone Kubb Engine 0.9.0

    The day’s fifth tag: a kubb never rests on an edge, batons aim lower at a kubb’s body, the computer steps up to a kubb a step from the line, and its games against itself run 15.6 turns where they had run 24.1. The web game moves to it the same day, and the Playdate and iPhone games on their main branches. Source

  18. development The Kubb Gym

    A measuring tool in the engine’s repository plays hundreds of matches, thrown the way the computer throws and the way people throw, and scores an engine build on one page beside the 150 tournament games, so the throw can be tuned from numbers, not from play tests. No throw changed; the engine is still 0.9.0. Source

  19. development Kubb: Throwing Wood’s highlight reels

    The web and iPhone games can ask for a short video of a finished match’s best throws, made on the server from its replay with the engine’s own physics, and a match against the computer can be shared with a link of its own. Source

  20. milestone throwingwood.com becomes the home of Kubb: Throwing Wood

    The site becomes a front page for the whole game, with pages for the web game, the iPhone app, the Playdate game and the Kubb Engine, and the web game’s lobby moves to /web/. Source

  21. milestone Kubb: Throwing Wood for iPhone opens to outside testers

    Builds 113 and 121 pass Apple’s Beta App Review and go to the outside testers, with a public TestFlight link on the game’s iPhone page. Source

  22. development Kubb: Throwing Wood for iPhone gets scenes

    Version 0.4, build 144, goes to TestFlight: a match can be played in the Day, at Night under a full moon, or in Neon, a black world on a grid of light. A scene is a look only and never changes a throw. It passes Apple’s Beta App Review early the next morning, as does build 132, version 0.3, and both go to the outside testers. Source

  23. development Kubb: Throwing Wood on the web gets observer mode

    Version 0.8.0: anyone can watch an open game from the open games list, in step at once and never able to act, and anyone watching in the wide view can turn, tilt, move and zoom the camera round the pitch. Version 0.7.1, just before it, put the device’s settings in one place, with a name typed once. Source

  24. development Kubb: Throwing Wood on the web gets scenes

    Version 0.7.0: a match can be played in the Day, at Night under a full moon, or in Neon, a black world on a grid of light. A scene is a look only, the same engine and the same throws, and it skins the controls too. The player picks it on the Play the computer card or in practice, and on a shared pitch the host picks it for everyone. Source