v0.8.6

Patch Changes

• 890763f: Bump @8bitscript/* and the CI cli-version fallback to 0.23.0, and depend on @8bitscript/audio and @8bitscript/graphics for the four-pillar media.

v0.8.5

Patch Changes

• b6cd172: The game is dealt as the program starts. The header is the title — the copyright, the version, and on the C64 the raster wobble — and the board is the sixteen tiles. Measured against the previous build: the C64 5334 → 5076 bytes of program (99 → 97 of RAM), the 4K PET 2892 → 2826 (66 → 62), the German 4K PET 3072 → 3003, under the 3071-byte ceiling, and the unexpanded VIC-20 3431 → 3316 (84 → 81).
• 343cb62: The program owns its start-up and its frame. 2048.8bs is that loop; session.8bs is gone. A turn is still play.8bs, and what is on the screen is unchanged. Release sizes are unchanged (the C64, the PET 4032, and the VIC-20 checksummed identical).

v0.8.4

Patch Changes

• 6b6a877: Bump @8bitscript/* and the CI cli-version fallback to 0.22.0.

v0.8.3

Patch Changes

• deaa1cb: The program entry starts the session and runs a frame. session.8bs is start-up and that frame, play.8bs is a turn, and <Game /> returns the board or the title directly. Release sizes are unchanged.

v0.8.2

Patch Changes

• 197ad46: 8bitscript 0.20.0: the web's input.keyboard(), which the status row's SWIPE TO MOVE reads.
• 197ad46: The status row says SWIPE TO MOVE on a phone or a tablet in the hands, where there are no arrows to press, and SWIPE OR ARROWS everywhere both work — a desktop, a touchscreen laptop, a tablet from the first arrow a plugged-in keyboard sends. host.keyboard() in lib/host/ is the question: Input.KEYBOARD on the eight machines (a fact, folded — every 6502 build is byte-identical, the 4K PET still 2876), and the web's new input.keyboard() on the page. The fixed web replicas, which said nothing at all on a touchscreen because SWIPE OR ARROWS might have been a lie there, now say the same as the fluid grid. Needs the 8bitscript release that carries input.keyboard().

v0.8.1

Patch Changes

• c1b96ea: Bump @8bitscript/* from 0.15.0 to 0.19.1. The Atari 8-bit's textmode=gr1 (#71) is 0.16.0's, so CI's compile step had refused the option since that merge; it builds again, as 2048-atari8-gr1-ntsc.xex (4089 bytes of program). What 0.18.0 changes under the game, measured 2026-09-19 with 8bs build --release (0.19.1, 2026-09-20, is byte-identical to it on every build): the C64 takes @8bitscript/c64/text's native print/printNumber/fill (a nine-character HUD print 1,908 → 498 cycles) and the reworked, double-buffered raster list, 4500 → 5185 bytes of program (4771 → 5398 German); the MEGA65 3566 → 3581. Every other build is byte-identical — 2876 English / 3056 German on the 4K PET 2001, 2886 on the 4032, 3431 on the unexpanded VIC-20, 3599 on the C128, 4345 on the X16, and the five web builds. The two workflows' cli-version fallback moves to 0.19.1 with it.
• 58292d7: The Atari 8-bit build now uses 20-column ANTIC 6 (textmode=gr1) so board tiles get per-cell color instead of grey reverse video.
• c1b96ea: baseline: 'c64' in 8bitscript.config.ts: the game is designed on the C64 — the build every fact it tests is true on — and says so where the toolchain can read it. On 8BitScript 0.19.1, 8bs run alone runs the C64 build and 8bs build --release prints, after every artifact, which of the facts the game tests that build is short of (2048-pet.prg: short of the baseline (c64): video.palette 2 of 16, video.raster, input.joysticks 0 of 2, memory.ram 3071 of 51199). pnpm start is plain 8bs run now — the C64 (pnpm run start:vic20 for the VIC-20). README: the opening says the C64 is the baseline and the 4K PET the floor, the 22-columns bullet says the VIC-20 is the floor of width rather than "the machine checked first", and a new section carries the release report and the vocabulary — floor, baseline, build; not port, tier or edition. No build's bytes change.
• c1b96ea: The title's wobble reads raster.STRIDE — the bytes one raster-list entry takes, 4 on the C64 and 3 on the web, a fact that folds — instead of probing for it at start-up. <TitleWobble /> no longer writes a trial setValue at offset 3 and wobble.step() no longer reads the answer back from two bytes of RAM each frame; examples/fancy in 8bitscript, whose probe this was, made the same change in 0.18. C64: 5185 → 5122 bytes of program and 94 → 92 of RAM; the web's C64 skin 109 → 107 of RAM; the 4K PET and the VIC-20, which never link the wobble, byte-identical. Checked on screen: 8bs run c64 --screenshot --frames 1200 and 1203 show the band, the yellow border, and "2048" sheared at the two-scanline pitch in two different phases; the web's C64 skin at --frames 300 and 303 the same.

v0.8.0

Minor Changes

• d508d1c: German and English builds use @8bitscript/i18n/catalog: namespaced catalogs in src/i18n/en.8bs and src/i18n/de.8bs, with i18n.format for control labels and number.print for grouped scores (the unexpanded VIC-20 keeps a zero-padded field). One locale, one binary. Measured 2026-09-18: 2876 bytes English / 3056 German on the 4K PET 2001; 3431 on the unexpanded VIC-20 in both locales; 4500 / 4771 on the C64.

Patch Changes

• 40a5113: Bump @8bitscript/* dependencies from 0.14.0 to 0.15.0. That release is what actually lands the @lib/@ui import aliases, the @8bitscript/i18n/catalog and ./messages exports, and the Game.NAME.length-style chained member expression this project's code already assumed — 0.14.0 predated all three, which is why pnpm run check and CI's compile step were failing on both this branch and trunk.
• 40a5113: Use @lib and @ui import aliases from 8bitscript.config.ts instead of relative ../../lib paths in UI modules.

v0.7.0

Minor Changes

• 7455259: Structure under ui/ and lib/, and the PET prints through @8bitscript/text like every other machine.

  ui/Game.8bx is the root (was App.8bx), ui/board/ is the game (Board, Tiles, Tile, ScoreBar, GameOver) and ui/title/ the front door; lib/ is grouped by what it is — game/, layout/, draw/, text/, host/, raster/. Byte-identical on every target (checksummed on the PET and VIC-20).

  No element names a machine any more. Every #system() == System.PET arm — eight switches in eight files that wrote hand-baked screen codes into video RAM (lib/petscii.8bs, lib/codes.8bs, codes.de.8bs) — is gone; the PET prints lib/text/strings.8bs through @8bitscript/text, and what it keeps is its look, as two twins in lib/: layout/layout.pet.8bs (the 8×5 block-digit arrangement, both widths) and draw/tile.pet.8bs (the tile stamped into video RAM, because text.putChar's ASCII contract cannot carry two of the quadrant-block glyph codes). Measured: 2876 bytes on the 4K PET 2001 (2779 before; the arms bought 97 bytes; the German build is 2877), 2886 on the 4032, 2905 on the 8032 (2970 before), and every other target byte-identical. A 3032/4032 now exits to a lower-case ready., as @8bitscript/pet/text documents.

v0.6.0

Minor Changes

• 4a70539: One element, every machine that draws through @8bitscript/text. The
  eight *.web.8bx twins and the nine *.web.{c64,pet-2001,vic20}.8bx
  copies are gone: ui/Tile.8bx, ui/ScoreBar.8bx, ui/GameOver.8bx and
  the title's five are each one file, fixed grid or fluid — what differs is
  a fact (screen.RESIZABLE, #system(), Input.*) and the arm a build
  cannot take folds away. Underneath, lib/ exposes one surface from every
  skin: layout.8bs (the fixed grids and the fluid host in one file, the
  PET and the web's replicas as twins of it), the tables written once in
  palette.8bs and font.8bs instead of three to five times, the shared
  primitives in draw.8bs, and host.8bs for what only the web can ask.
  The 4K PET 2001 and the unexpanded VIC-20 are the size they were (2759 and
  3486); the C64, C128, Atari and MEGA65 are 26 to 34 bytes smaller. The
  web's C64 and VIC-20 replicas now print the score on the same row as the
  name, as the machines they replicate do.
• 45f96c4: Where the random numbers come from is the platform's decision now:
  @8bitscript/random/entropy (8bitscript 0.12.0) is one import that the
  compiler resolves to SID voice 3 on the C64, POKEY's counter on the Atari
  8-bit, and the seeded generator on the other seven. The game's own
  rng.8bs and its two machine twins go. Every build is byte-for-byte the
  size it was: 2687 on the 4K PET 2001, 3396 on the unexpanded VIC-20, and
  the C64 and Atari still link the register read and not the generator.
• 60552de: No element has a machine twin. The PET's eight *.pet.8bx files — the
  screen codes it writes straight into video RAM — are each an arm of the
  one element now, behind #system() == System.PET, over lib/petscii.8bs
  (its positions, its tables, its primitives; not a twin, so every machine
  can name it and the arm folds away on the eight that are not a PET).
  Measured one element at a time on the 4K PET 2001: every one at exactly
  the bytes its twin cost, 2759 before and after, and 6 bytes less RAM.
  src/ui/ is ten files, one per element; the twins left in src/lib/
  are the PET's font, the web's PET replica, the web's host, and the
  hardware random numbers.
• f5b3d8a: ui/Tile.8bx is a call: stampTile() in lib/petscii.8bs (screen codes
  into the PET's video RAM) and paintTile() in lib/draw.8bs (reverse-video
  fills, block digits or a printed number through @8bitscript/text) own the
  painting, and the element says which. A function with one caller is
  written into it on 0.12.0, so this costs nothing — the form that measured
  +56 / +84 bytes on 0.11.0 is byte-identical now. The PET's cells have names
  in lib/petscii.8bs. Every build is the size it was.
• a91e8cf: Every line the game prints is in lib/strings.8bs, and strings.de.8bs
  beside it is the German one: 8bs build --locale de (or the release's
  { locale: 'de' } entries, for the web and the 4K PET) builds a German
  game, and with no locale named no locale's file is read. The PET's lines
  are baked screen codes in lib/codes.8bs and codes.de.8bs. The elements
  read the strings and their .length, so the centring moves with the words.
  The score header is two prints instead of a template, which is 14 bytes
  smaller on every 6502 but the PET (unchanged at 2687); the VIC-20 is 3382.
  The version line is not yet a string here — it waits on 8bitscript 0.13.0's
  #package("version").
• d7bd0df: The source is now two directories under the program: src/ui/ holds the
  .8bx — what is on the screen, one element per file, starting with
  App.8bx (the root that was Screen.8bx) — and src/lib/ holds the
  .8bs underneath it: the rules (game.8bs), the skins (tile.8bs and
  its machine twins) and the random numbers (rng.8bs and its twins).
  src/2048.8bs stays the program. Nothing moved but files: every one of
  the thirteen release builds is the same size it was — 2763 bytes on the 4K
  PET 2001, 3490 on the unexpanded VIC-20.
• c8acf79: The score bar and the end of the game are elements: ui/ScoreBar.8bx is
  the name, the score and the status line; ui/GameOver.8bx is GAME OVER
  and how to try again, and the board composes it only when the game has
  ended — {over && <GameOver />}. drawHud() leaves every skin. The
  PET and the fluid web host keep their own of each. Every native build is
  the size it was — 2763 bytes on the 4K PET 2001, 3490 on the unexpanded
  VIC-20.
• d6ea161: A tile is an element: src/ui/Tile.8bx is the filled square and the
  value on it, and <Tile row={…} col={…} exponent={…} /> is how the board
  places sixteen of them. The element owns the painting; lib/tile.8bs and
  its twins own the layout and the tables it paints from. The PET and the
  fluid web host paint a tile differently enough to have their own
  (Tile.pet.8bx, Tile.web.8bx). Every native build is the size it was —
  2763 bytes on the 4K PET 2001, 3490 on the unexpanded VIC-20.
• 1739019: The title screen is composition: ui/TitleScreen.8bx is a <Logo />, a
  <StartMessage /> that names this machine's controls, the
  <Copyright />, the <Version /> and — on the real C64 and the web's C64
  skin — a <TitleWobble />, the raster band and wobble behind the name,
  whose sine table and per-frame step now live once in lib/wobble.8bs
  instead of twice. drawTitleScreen() and wobbleTitle() leave every
  skin. Every native build is four bytes smaller than before — 2759 bytes
  on the 4K PET 2001, 3486 on the unexpanded VIC-20 — because the
  one-line Title that used to forward to drawTitleScreen() is gone.
• f4f6713: The web's C64 and VIC-20 replicas read lib/layout.8bs — the machine's
  own layout, at the replica's columns — instead of a twin each of baked
  cell numbers. The C64's picture is named by its facts (40 columns, sixteen
  colours, a raster) rather than by #system(), which is what lets the web
  replica take the C64's arm; the title screen's raster band comes with it.
  Both replicas replay frame for frame. Nine native builds unchanged.

Patch Changes

• fb2a474: The title screen's version is package.json's, read at compile time by
  #package("version") — one number in one place, where it used to be
  three (the PET's baked table said V0.1.4, version.8bs said v0.2.0, and
  the package was at 0.5.0). The text machines print a v and the number;
  the PET stamps a baked V and copies the number's bytes straight into
  video RAM, since a digit and a . are the same code in ASCII and in both
  of its character sets. 4K PET 2001 2687 → 2779, VIC-20 3382 → 3415.

v0.5.0

Minor Changes

• dc70e1a: What goes on the screen is now composition: src/Screen.8bx — <Title />,
  or a <Board /> that is the HUD over sixteen <Tiles /> — written as 8BX
  elements over the drawing calls tile.8bs and its twins provide. The
  rules and the board move to src/game.8bs; src/2048.8bs is the program
  that drives both. The same functions at the same sizes on every target —
  2763 bytes on the 4K PET 2001 and 3490 on the unexpanded VIC-20, as before
  — and 60 bytes less on every build that animates. Needs @8bitscript/cli
  0.11.0.