diff --git a/Makefile b/Makefile
index 76ea6b8c..9e75e73f 100644
--- a/Makefile
+++ b/Makefile
@@ -57,9 +57,17 @@ distro: buildtsc
 	rm -r $(TMP)/doc $(TMP)/scripts $(TMP)/test* $(TMP)/tools $(TMP)/.[a-z]* $(TMP)/ts*.json # $(TMP)/meta
 	rm -f $(TMP)/javatari && mkdir -p $(TMP)/javatari && cp -p javatari.js/release/javatari/* $(TMP)/javatari/
 
-tsweb: submodules node_modules
+getip:
+	@if command -v ip > /dev/null; then \
+		ip addr | grep -w inet; \
+	elif command -v ifconfig > /dev/null; then \
+		ifconfig | grep -w inet; \
+	else \
+		ipconfig | grep IPv4; \
+	fi
+
+tsweb: submodules node_modules getip
 	npm run esbuild-clean
-	(ip addr || ifconfig) | grep inet
 	trap 'kill 0' EXIT; \
 	make buildgrammars; \
 	$(TSC) -w --preserveWatchOutput & \
diff --git a/README.md b/README.md
index 267b65e3..fafb9340 100644
--- a/README.md
+++ b/README.md
@@ -20,6 +20,8 @@ git clone -b master --single-branch git@github.com:sehugg/8bitworkshop.git
 To build the 8bitworkshop IDE:
 
 ```sh
+# On Windows, use the `UCRT64` shell from https://msys2.org/
+# On Linux/macOS, just type:
 make
 ```
 
@@ -51,7 +53,7 @@ Copyright © 2016-2026 [Steven E. Hugg](https://github.com/sehugg).
 This project, unless specifically noted, is multi-licensed.
 You may choose to adhere to the terms of either the [GPL-3.0](https://github.com/sehugg/8bitworkshop/blob/master/LICENSE) License for the entire project or respect the individual licenses of its dependencies and included code samples, as applicable.
 
-This project includes various dependencies, modules, and components that retain their original licenses. 
+This project includes various dependencies, modules, and components that retain their original licenses.
 For detailed licensing information for each dependency, please refer to the respective files and documentation.
 
 All included code samples located in the `presets/` directory are licensed under
diff --git a/index.html b/index.html
index b72f7c1c..1f76dd51 100644
--- a/index.html
+++ b/index.html
@@ -60,7 +60,7 @@ body {
       <li class="dropdown dropdown-submenu">
         <a tabindex="-1" href="javascript:void(0)">Sync</a>
         <ul class="dropdown-menu">
-          <li><a class="dropdown-item" href="javascript:void(0)" id="item_github_login">Sign in to Github...</a></li>
+          <li><a class="dropdown-item" href="javascript:void(0)" id="item_github_login">Sign in to GitHub...</a></li>
           <li><a class="dropdown-item" href="javascript:void(0)" id="item_github_logout">Log out</a></li>
           <hr>
           <li><a class="dropdown-item" href="javascript:void(0)" id="item_github_import">Import Project from GitHub...</a></li>
diff --git a/presets/c64/cartheader.xa b/presets/c64/cartheader.xa
new file mode 100644
index 00000000..9ad0b667
--- /dev/null
+++ b/presets/c64/cartheader.xa
@@ -0,0 +1,30 @@
+
+* = $7ffe
+; 2-byte load address for ROM image
+	.word $8000
+; http://swut.net/c64cart-howto.html
+; https://codebase64.org/doku.php?id=base:assembling_your_own_cart_rom_image
+	.word CartKReset	; cold start vector
+	.word CartWStart	; warm start vector
+	.byt $c3, $c2, $cd, $38, $30 ; "CBM80"
+CartKReset
+	STX $D016	; Turn on VIC for PAL / NTSC check
+	JSR $FDA3	; IOINIT - Init CIA chips
+	JSR $FD50	; RANTAM - Clear/test system RAM
+	JSR $FD15	; RESTOR - Init KERNAL RAM vectors
+	JSR $FF5B	; CINT   - Init VIC and screen editor
+	CLI		; Re-enable IRQ interrupts
+CartBReset
+; init BASIC?
+#ifdef CART_INIT_BASIC
+	JSR $E453	; Init BASIC RAM vectors
+	JSR $E3BF	; Main BASIC RAM Init routine
+	JSR $E422	; Power-up message / NEW command
+	LDX #$FB
+	TXS		; Reduce stack pointer for BASIC
+; don't init BASIC, just NOP
+#else
+	.dsb 12, $ea	; nop
+#endif
+CartWStart
+; should be * = $x025
diff --git a/presets/c64/hello.xa b/presets/c64/hello.xa
new file mode 100644
index 00000000..bbf98367
--- /dev/null
+++ b/presets/c64/hello.xa
@@ -0,0 +1,41 @@
+
+#include "cartheader.xa"
+
+Temp = $02
+
+Start
+	sei		; turn off interrupts
+	ldy #0
+Loop
+	lda Message,y	; load message byte
+	beq EOM		; 0 = end of string
+	clc
+	adc #$c0	; convert PETSCII to screen code
+	sta $400+41,y	; store to screen
+	iny
+	bne Loop	; next character
+EOM
+
+Wait1
+	lda $d011
+	bmi Wait1	; wait for line < 256
+Wait2
+	lda $d012	; get current scanline
+Wait3
+	cmp $d012
+	beq Wait3	; wait for scanline to change
+	lsr		; divide by 2
+	lsr		; divide by 2
+	clc
+	adc Temp	; add to frame counter
+	sta $d020	; set border color
+	lda $d011	; get status bits
+	bpl Wait2	; repeat until line >= 256
+	sty $d020	; reset border color
+	dec Temp	; change frame counter
+	jmp Wait1	; endless loop
+
+Message
+	; PETSCII - http://sta.c64.org/cbm64pet.html
+	.asc "HELLO WORLD"
+	.byt 0
diff --git a/presets/gb/chase.c b/presets/gb/chase.c
new file mode 100644
index 00000000..29267de9
--- /dev/null
+++ b/presets/gb/chase.c
@@ -0,0 +1,1430 @@
+/*
+ * Chase for Game Boy — port of Shiru's NES Chase (presets/nes/chase).
+ *
+ * Level maps match the NES nametables exactly (cropped to content).
+ * Camera scrolls only when a level exceeds the 160×136 playfield.
+ * Title bounce matches NES title_screen() physics.
+ * Music/SFX from Coleco (NES FamiTone transcription).
+ * Graphics from presets/nes/chase/tileset.chr
+ * (regenerate with: python3 scripts/gen_chase_nes_gfx.py).
+ *
+ * Controls: D-pad move, Start = pause, A = start / continue.
+ */
+
+//#link "gb/sfr.sgb"
+//#link "gb/crt0.sgb"
+//#resource "gb/global.sgb"
+#include <stdint.h>
+#include <string.h>
+#include "gb/types.h"
+#include "gb/hardware.h"
+#include "gb/gb.h"
+
+typedef uint8_t byte;
+typedef uint16_t word;
+
+#define MAP_W_MAX    16
+#define MAP_H_MAX    13
+#define LEVELS_FIXED 5   /* hand-authored NES layouts */
+#define ACTORS_MAX   4
+
+#define TILE_PX      16
+#define FP_BITS      4
+#define TILE_TO_POS(t)  ((word)(t) << (4 + FP_BITS))
+#define POS_TO_TILE(p)  ((byte)((p) >> (4 + FP_BITS)))
+#define POS_SNAP_MASK   0xff00
+
+/* Visible playfield above bottom HUD (window at WY=136) */
+#define VIEW_W       160
+#define VIEW_H       136
+#define VIEW_TILES_W 20
+#define VIEW_TILES_H 17
+#define HUD_WY       136
+
+#define T_FLOOR  0
+#define T_WALL   1
+#define T_ITEM   2
+#define T_VOID   3  /* outside irregular NES silhouette — blank, solid */
+
+#define DIR_NONE  0
+#define DIR_LEFT  1
+#define DIR_RIGHT 2
+#define DIR_UP    4
+#define DIR_DOWN  8
+
+#define BKG_BASE     32
+#define TILE_WTL     (BKG_BASE + 0)
+#define TILE_WTR     (BKG_BASE + 1)
+#define TILE_WBL     (BKG_BASE + 2)
+#define TILE_WBR     (BKG_BASE + 3)
+#define TILE_FLOOR   (BKG_BASE + 4)
+#define TILE_GTL     (BKG_BASE + 5)
+#define TILE_GTR     (BKG_BASE + 6)
+#define TILE_GBL     (BKG_BASE + 7)
+#define TILE_GBR     (BKG_BASE + 8)
+#define TILE_GTL2    (BKG_BASE + 9)
+#define TILE_GTR2    (BKG_BASE + 10)
+#define TILE_GBL2    (BKG_BASE + 11)
+#define TILE_GBR2    (BKG_BASE + 12)
+
+#define SPR_TILE_PL   16
+#define SPR_TILE_PL2  20
+#define SPR_TILE_EN   24
+
+#define ENV_MAX 13
+#define ENV_SUSTAIN 7
+#define MUSIC_VOICES 2
+
+typedef struct {
+  word x, y;
+  word cnt;
+  word speed;
+  byte dir;
+  byte wait;
+  byte kind;
+} Actor;
+
+byte joy_left, joy_right, joy_up, joy_down, joy_fire, joy_start;
+byte fire_prev, start_prev;
+byte start_level; /* chosen on title screen (0-based) */
+
+byte map[MAP_W_MAX * MAP_H_MAX];
+Actor actors[ACTORS_MAX];
+byte actor_n;
+byte game_level;
+byte game_lives;
+byte items_count;
+byte items_collected;
+byte game_clear;
+byte game_done;
+byte game_paused;
+byte spawn_wait;
+word rnd = 0xCACE;
+byte frame_cnt;
+byte cam_x, cam_y;
+byte cam_max_x, cam_max_y;
+byte map_w, map_h;       /* current level size (cells) */
+byte map_tx0, map_ty0;   /* BG tile origin — inset when level fits */
+byte map_ox, map_oy;     /* pixel origin (= map_t*8) */
+
+byte voice_vol[3];
+byte voice_note[3];
+word voice_per[3];
+byte cur_duration;
+byte music_speed;
+byte music_release;
+byte music_enable;
+byte music_paused;
+const uint8_t* music_ptr;
+const uint8_t* music_loop;
+byte chord[4];
+byte chord_n;
+const uint8_t* sfx_ptr;
+byte sfx_timer;
+byte sfx_vol;
+byte sfx_busy; /* ch1 claimed by SFX */
+byte hw_note[3]; /* last note pushed to hardware (avoid retrigger clicks) */
+
+
+/*
+ * Level maps — exact NES Chase layouts (from levelN_nam.h metatiles).
+ *   # wall   * gem   P player   1/2/3 enemies   (space) void outside shape
+ * After these five, generate_level() builds endless mazes (no dead ends,
+ * corner pillars so diagonals stay walls, orthogonal exits only).
+ */
+typedef struct {
+  byte w, h;
+  const char* const* rows;
+} Level;
+
+const char* const level_1[] = {
+  "########",
+  "#P*****#",
+  "#*####*#",
+  "#******#",
+  "#*####*#",
+  "#*****1#",
+  "########",
+};
+
+const char* const level_2[] = {
+  "##########",
+  "#P***#**1#",
+  "#*##*#*#*#",
+  "#********#",
+  "###*#*#*##",
+  "#********#",
+  "#*#*#*##*#",
+  "#2*******#",
+  "##########",
+};
+
+const char* const level_3[] = {
+  "  ##########  ",
+  "  #P***#**1#  ",
+  "###*##*#*#*###",
+  "#********#***#",
+  "#*#*#*##*#*#*#",
+  "#***#********#",
+  "###*#*#*##*###",
+  "  #***#***2#  ",
+  "  ##########  ",
+};
+
+const char* const level_4[] = {
+  "  ######      ",
+  "  #P***#######",
+  "  #*##*#****1#",
+  "###*##*#*#*#*#",
+  "#**********#*#",
+  "#*#*#*##*#*#*#",
+  "#*#**********#",
+  "#*#*#*#*##*###",
+  "#2****#*##*#  ",
+  "#######***3#  ",
+  "      ######  ",
+};
+
+const char* const level_5[] = {
+  "  ############  ",
+  "  #P********1#  ",
+  "###*##*##*##*###",
+  "#**************#",
+  "##*#*###*#*#*#*#",
+  "#*****#********#",
+  "#*###*#*#*###*##",
+  "#*******#******#",
+  "##*#*#*###*#*#*#",
+  "#**************#",
+  "###*##*##*##*###",
+  "  #2********3#  ",
+  "  ############  ",
+};
+
+const Level levels[LEVELS_FIXED] = {
+  {  8,  7, level_1 },
+  { 10,  9, level_2 },
+  { 14,  9, level_3 },
+  { 14, 11, level_4 },
+  { 16, 13, level_5 },
+};
+
+/* Filled by generate_level() for endless mazes after the fixed set */
+char gen_row[MAP_H_MAX][MAP_W_MAX + 1];
+byte gen_w, gen_h;
+/* Compact CHASE wordmark (wall tiles), fits GB 20-tile width */
+const uint8_t title_logo[6][20] = {
+  {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
+  {0,35,34,0,34,0,34,0,0,35,0,0,0,35,34,0,34,35,34,0},
+  {32,0,0,0,32,0,32,0,32,0,32,0,32,0,0,0,32,0,0,0},
+  {34,0,0,0,34,35,34,0,34,35,34,0,0,35,0,0,34,35,0,0},
+  {32,0,0,0,32,0,32,0,32,0,32,0,0,0,32,0,32,0,0,0},
+  {0,35,34,0,34,0,34,0,34,0,34,0,34,35,0,0,34,35,34,0},
+};
+
+
+/* GB pulse periods; index 0x28 ~= C4 (matches Coleco/SFX note indices) */
+const word gb_note_per[64] = {
+  0x000,0x000,0x000,0x000,0x000,0x000,0x000,0x000,
+  0x000,0x000,0x000,0x000,0x000,0x000,0x000,0x000,
+  0x02c,0x09d,0x107,0x16b,0x1c9,0x223,0x277,0x2c7,
+  0x312,0x358,0x39b,0x3da,0x416,0x44e,0x483,0x4b5,
+  0x4e5,0x511,0x53b,0x563,0x589,0x5ac,0x5ce,0x5ed,
+  0x60b,0x627,0x642,0x65b,0x672,0x689,0x69e,0x6b2,
+  0x6c4,0x6d6,0x6e7,0x6f7,0x706,0x714,0x721,0x72d,
+  0x739,0x744,0x74f,0x759,0x762,0x76b,0x773,0x77b,
+};
+
+const uint8_t mus_level[] = {
+0x1c,0x28,0x82, 0x1c,0x28,0x82, 0x1e,0x2a,0x8c,
+  0xff
+};
+
+const uint8_t mus_game[] = {
+0x17,0x23,0x81,0x00,0x00,0x83,0x17,0x23,0x81,0x00,0x00,0x81,0x16,0x22,0x82,
+  0x1c,0x28,0x81,0x00,0x00,0x87,0x15,0x21,0x81,0x00,0x00,0x83,0x15,0x21,0x82,
+  0x14,0x20,0x82,0x1c,0x28,0x81,0x00,0x00,0x87,0x17,0x23,0x81,0x00,0x00,0x83,
+  0x17,0x23,0x81,0x00,0x00,0x81,0x16,0x22,0x82,0x1c,0x28,0x81,0x00,0x00,0x83,
+  0x16,0x22,0x81,0x00,0x00,0x83,0x15,0x21,0x81,0x00,0x00,0x83,0x15,0x21,0x82,
+  0x1c,0x28,0x81,0x14,0x20,0x83,0x00,0x00,0x86,0x17,0x23,0x81,0x00,0x00,0x83,
+  0x17,0x23,0x81,0x00,0x00,0x81,0x16,0x22,0x82,0x1c,0x28,0x81,0x00,0x00,0x83,
+  0x16,0x22,0x81,0x00,0x00,0x83,0x15,0x21,0x81,0x00,0x00,0x83,0x15,0x21,0x82,
+  0x14,0x20,0x82,0x1c,0x28,0x81,0x00,0x00,0x87,0x12,0x1e,0x81,0x00,0x00,0x83,
+  0x12,0x1e,0x81,0x00,0x00,0x81,0x14,0x20,0x82,0x1c,0x28,0x81,0x00,0x00,0x83,
+  0x15,0x21,0x82,0x1c,0x28,0x81,0x17,0x23,0x85,0x00,0x00,0x8c,
+  0xff
+};
+
+const uint8_t mus_clear[] = {
+0x21,0x2d,0x81,0x00,0x00,0x81,0x21,0x2d,0x81,0x00,0x00,0x81,0x21,0x2d,0x81,
+  0x00,0x00,0x83,0x21,0x2d,0x81,0x00,0x00,0x81,0x21,0x2d,0x81,0x00,0x00,0x81,
+  0x23,0x2f,0x89,0x00,0x00,0x8b,
+  0xff
+};
+
+const uint8_t mus_lose[] = {
+0x1c,0x28,0x88, 0x19,0x25,0x84, 0x17,0x23,0x94,
+  0xff
+};
+
+const uint8_t mus_gameover[] = {
+0x15,0x21,0x81,0x15,0x21,0x83,0x14,0x20,0x81,0x14,0x20,0x83,0x13,0x1f,0x81,
+  0x13,0x1f,0x83,0x12,0x1e,0x82,0x10,0x1c,0x86,0x1c,0x28,0x8c,
+  0xff
+};
+
+const uint8_t mus_welldone[] = {
+0x17,0x23,0x88,0x23,0x2f,0x86,0x23,0x2f,0x86,0x23,0x2f,0x88,0x17,0x23,0x84,
+  0x15,0x21,0x88,0x21,0x2d,0x86,0x21,0x2d,0x86,0x21,0x2d,0x88,0x15,0x21,0x84,
+  0x17,0x23,0x88,0x23,0x2f,0x86,0x23,0x2f,0x86,0x23,0x2f,0x88,0x17,0x23,0x84,
+  0x10,0x1c,0x88,0x1c,0x28,0x86,0x1e,0x2a,0x86,0x1e,0x2a,0x8c,
+  0xff
+};
+
+const uint8_t sfx_start[] = {
+/* C4 F4 G4 C5 F5 G5 ×3, volume steps like NES $7f/$74/$71 */
+  0x28,15,4, 0x2d,14,4, 0x2f,14,4, 0x34,13,4, 0x39,12,4, 0x3b,12,4,
+  0x28,12,4, 0x2d,11,4, 0x2f,11,4, 0x34,10,4, 0x39,10,4, 0x3b,9,4,
+  0x28,9,4,  0x2d,8,4,  0x2f,8,4,  0x34,7,4,  0x39,7,4,  0x3b,6,4,
+  0xff
+};
+
+const uint8_t sfx_item[] = {
+/* short high blip: C4→F4→E4→G4 then softer repeat */
+  0x28,12,1, 0x2d,11,1, 0x2c,10,1, 0x2f,9,1,
+  0x28,8,1,  0x2d,7,1,  0x2c,6,1,  0x2f,5,1,
+  0xff
+};
+
+const uint8_t sfx_respawn_p[] = {
+/* NES pulse arpeggio — bright rising chirp */
+  0x3c,10,1, 0x3e,11,1, 0x3f,12,1, 0x3c,13,1, 0x3e,14,1,
+  0x3f,14,1, 0x3c,13,1, 0x3e,12,1, 0x3f,11,1,
+  0x3c,9,1,  0x3e,8,1,  0x3f,7,1,  0x3c,6,1,  0x3e,5,1,
+  0x3f,4,1,  0x3c,3,1,  0x3e,2,1,  0x3f,2,1,
+  0xff
+};
+
+const uint8_t sfx_respawn_e[] = {
+/* slightly lower / darker than player respawn */
+  0x38,9,1, 0x3a,10,1, 0x3c,11,1, 0x38,12,1, 0x3a,13,1,
+  0x3c,13,1, 0x38,12,1, 0x3a,11,1, 0x3c,10,1,
+  0x38,8,1,  0x3a,7,1,  0x3c,6,1,  0x38,5,1,  0x3a,4,1,
+  0x3c,3,1,  0x38,3,1,  0x3a,2,1,  0x3c,2,1,
+  0xff
+};
+
+const uint8_t font_1bpp[] = {
+  /* 0 space */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  /* 1 '0' */ 0x3C,0x66,0x6E,0x76,0x66,0x66,0x3C,0x00,
+  /* 2 '1' */ 0x18,0x38,0x18,0x18,0x18,0x18,0x7E,0x00,
+  /* 3 '2' */ 0x3C,0x66,0x06,0x0C,0x18,0x30,0x7E,0x00,
+  /* 4 '3' */ 0x3C,0x66,0x06,0x1C,0x06,0x66,0x3C,0x00,
+  /* 5 '4' */ 0x0C,0x1C,0x3C,0x6C,0x7E,0x0C,0x0C,0x00,
+  /* 6 '5' */ 0x7E,0x60,0x7C,0x06,0x06,0x66,0x3C,0x00,
+  /* 7 '6' */ 0x1C,0x30,0x60,0x7C,0x66,0x66,0x3C,0x00,
+  /* 8 '7' */ 0x7E,0x06,0x0C,0x18,0x30,0x30,0x30,0x00,
+  /* 9 '8' */ 0x3C,0x66,0x66,0x3C,0x66,0x66,0x3C,0x00,
+  /*10 '9' */ 0x3C,0x66,0x66,0x3E,0x06,0x0C,0x38,0x00,
+  /*11 'A' */ 0x3C,0x66,0x66,0x7E,0x66,0x66,0x66,0x00,
+  /*12 'C' */ 0x3C,0x66,0x60,0x60,0x60,0x66,0x3C,0x00,
+  /*13 'D' */ 0x78,0x6C,0x66,0x66,0x66,0x6C,0x78,0x00,
+  /*14 'E' */ 0x7E,0x60,0x60,0x7C,0x60,0x60,0x7E,0x00,
+  /*15 'G' */ 0x3C,0x66,0x60,0x6E,0x66,0x66,0x3C,0x00,
+  /*16 'H' */ 0x66,0x66,0x66,0x7E,0x66,0x66,0x66,0x00,
+  /*17 'I' */ 0x3C,0x18,0x18,0x18,0x18,0x18,0x3C,0x00,
+  /*18 'L' */ 0x60,0x60,0x60,0x60,0x60,0x60,0x7E,0x00,
+  /*19 'M' */ 0x63,0x77,0x7F,0x6B,0x63,0x63,0x63,0x00,
+  /*20 'N' */ 0x66,0x76,0x7E,0x7E,0x6E,0x66,0x66,0x00,
+  /*21 'O' */ 0x3C,0x66,0x66,0x66,0x66,0x66,0x3C,0x00,
+  /*22 'P' */ 0x7C,0x66,0x66,0x7C,0x60,0x60,0x60,0x00,
+  /*23 'R' */ 0x7C,0x66,0x66,0x7C,0x6C,0x66,0x66,0x00,
+  /*24 'S' */ 0x3C,0x66,0x60,0x3C,0x06,0x66,0x3C,0x00,
+  /*25 'T' */ 0x7E,0x18,0x18,0x18,0x18,0x18,0x18,0x00,
+  /*26 'U' */ 0x66,0x66,0x66,0x66,0x66,0x66,0x3C,0x00,
+  /*27 'V' */ 0x66,0x66,0x66,0x66,0x66,0x3C,0x18,0x00,
+  /*28 'W' */ 0x63,0x63,0x63,0x6B,0x7F,0x77,0x63,0x00,
+  /*29 'Y' */ 0x66,0x66,0x66,0x3C,0x18,0x18,0x18,0x00,
+  /*30 '/' */ 0x06,0x06,0x0C,0x18,0x30,0x60,0x60,0x00,
+  /*31 ':' */ 0x00,0x18,0x18,0x00,0x18,0x18,0x00,0x00,
+};
+
+const uint8_t bkg_tiles[] = {
+/* From presets/nes/chase/tileset.chr (walls/floor/gems);
+ * BG pens 1:1 — NES bright → GB dark ink under BGP 0xE4. */
+/*{w:8,h:8,bpp:1,count:13,brev:1,np:2,pofs:1,sl:2}*/
+  0xff,0x00,0xff,0x7f,0xff,0x7f,0xe0,0x7f,
+  0xef,0x7f,0xe8,0x7f,0xe8,0x7f,0xe8,0x7f,
+  0xfe,0x00,0xfc,0xfe,0xfa,0xfc,0x06,0xf8,
+  0xf6,0xf8,0x16,0xe8,0x16,0xe8,0x16,0xe8,
+  0xe8,0x7f,0xe8,0x7f,0xe8,0x7f,0xef,0x78,
+  0xe0,0x7f,0xdf,0x60,0xbf,0x40,0x00,0x00,
+  0x16,0xe8,0x16,0xe8,0x16,0xe8,0xf6,0x08,
+  0x06,0xf8,0xfe,0x00,0xfe,0x00,0x00,0x00,
+  0xea,0x00,0xe5,0x00,0xea,0x00,0x05,0x00,
+  0xae,0x00,0x5e,0x00,0xae,0x00,0x50,0x00,
+  0xea,0x00,0xe5,0x00,0xea,0x00,0x05,0x00,
+  0xac,0x00,0x58,0x03,0xa3,0x07,0x53,0x07,
+  0xea,0x00,0xe5,0x00,0xea,0x00,0x05,0x00,
+  0x2e,0x00,0x1e,0xc0,0x8e,0xe0,0x40,0xa0,
+  0xe2,0x07,0xe1,0x06,0xe0,0x03,0x00,0x00,
+  0xae,0x00,0x5e,0x00,0xae,0x00,0x50,0x00,
+  0x8a,0x20,0x05,0x20,0x0a,0xc0,0x05,0x00,
+  0xae,0x00,0x5e,0x00,0xae,0x00,0x50,0x00,
+  0xea,0x00,0xe5,0x00,0xea,0x00,0x04,0x00,
+  0xa8,0x03,0x53,0x07,0xa3,0x07,0x52,0x07,
+  0xea,0x00,0xe5,0x00,0xea,0x00,0x05,0x00,
+  0x0e,0xc0,0x8e,0xe0,0x4e,0xa0,0x80,0x20,
+  0xe1,0x06,0xe0,0x03,0xe8,0x00,0x05,0x00,
+  0xae,0x00,0x5e,0x00,0xae,0x00,0x50,0x00,
+  0x0a,0x20,0x05,0xc0,0x2a,0x00,0x05,0x00,
+  0xae,0x00,0x5e,0x00,0xae,0x00,0x50,0x00,
+};
+
+const uint8_t sprite_tiles[] = {
+/* From NES metasprites; 8x16 L/R pairs (player, player2, enemy);
+ * pen0 clear; pen1 black→3, pen2 body→2, pen3 white→1. */
+/*{w:8,h:8,bpp:1,count:12,brev:1,np:2,pofs:1,sl:2}*/
+  0x00,0x00,0x3f,0x3f,0x60,0x7f,0x5f,0x60,
+  0x5f,0x6e,0x5f,0x72,0x5f,0x76,0x5f,0x76,
+  0x5f,0x7e,0x5f,0x60,0x5f,0x60,0x47,0x7f,
+  0x67,0x7c,0x7f,0x7e,0x3f,0x3f,0x00,0x00,
+  0x00,0x00,0xfc,0xfc,0x06,0xfe,0xf2,0x0e,
+  0xf2,0x7e,0xfa,0x4e,0xfa,0x6e,0xfa,0x6e,
+  0xfa,0x7e,0xf2,0x0e,0xf2,0x0e,0xe2,0xfe,
+  0xe6,0x3e,0xfe,0x7e,0xfc,0xfc,0x00,0x00,
+  0x3f,0x3f,0x60,0x7f,0x5f,0x60,0x5f,0x6e,
+  0x5f,0x72,0x5f,0x76,0x5f,0x76,0x5f,0x7e,
+  0x5f,0x60,0x5f,0x60,0x47,0x7f,0x67,0x7c,
+  0x7f,0x7e,0x3f,0x3f,0x00,0x00,0x00,0x00,
+  0xfc,0xfc,0x06,0xfe,0xf2,0x0e,0xf2,0x7e,
+  0xfa,0x4e,0xfa,0x6e,0xfa,0x6e,0xfa,0x7e,
+  0xf2,0x0e,0xf2,0x0e,0xe2,0xfe,0xe6,0x3e,
+  0xfe,0x7e,0xfc,0xfc,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x7f,0x7f,0x40,0x7f,0x5f,0x60,
+  0x7f,0x7f,0x5f,0x7f,0x5e,0x77,0x5f,0x76,
+  0x5f,0x72,0x5f,0x6e,0x5f,0x60,0x4b,0x77,
+  0x67,0x7e,0x3f,0x3c,0x1f,0x1f,0x00,0x00,
+  0x00,0x00,0xfe,0xfe,0x02,0xfe,0xf2,0x0e,
+  0xfe,0xfe,0xfa,0xfe,0x7a,0xee,0xfa,0x6e,
+  0xfa,0x4e,0xf2,0x7e,0xf2,0x0e,0xd2,0xee,
+  0xe6,0x7e,0xfc,0x3c,0xf8,0xf8,0x00,0x00,
+};
+
+
+byte rand8(void) {
+  rnd = rnd * 17 + 53;
+  return (byte)(rnd >> 8);
+}
+
+void read_controls(void) {
+  byte j = joypad();
+  joy_left  = (j & J_LEFT) != 0;
+  joy_right = (j & J_RIGHT) != 0;
+  joy_up    = (j & J_UP) != 0;
+  joy_down  = (j & J_DOWN) != 0;
+  joy_fire  = (j & J_A) != 0;
+  joy_start = (j & J_START) != 0;
+}
+
+void psg_init(void) {
+  NR52_REG = 0x80;
+  NR51_REG = 0xFF;
+  NR50_REG = 0x77;
+  NR10_REG = 0x00;
+}
+
+void gb_ch_off(byte ch) {
+  if (ch == 0) { NR12_REG = 0x00; NR14_REG = 0x80; hw_note[0] = 0; }
+  else { NR22_REG = 0x00; NR24_REG = 0x80; hw_note[1] = 0; }
+}
+
+void gb_ch_on(byte ch, byte note, word per, byte vol) {
+  byte lo = (byte)(per & 0xFF);
+  byte hi = (byte)((per >> 8) & 0x07);
+  byte v = vol > 15 ? 15 : vol;
+  byte retrig = (hw_note[ch] != note);
+  hw_note[ch] = note;
+  if (ch == 0) {
+    NR10_REG = 0x00;
+    NR11_REG = 0x80; /* 50% duty */
+    if (retrig) NR12_REG = (byte)((v << 4) | 0x00);
+    NR13_REG = lo;
+    NR14_REG = (byte)((retrig ? 0x80 : 0x00) | hi);
+  } else {
+    NR21_REG = 0x80;
+    if (retrig) NR22_REG = (byte)((v << 4) | 0x00);
+    NR23_REG = lo;
+    NR24_REG = (byte)((retrig ? 0x80 : 0x00) | hi);
+  }
+}
+
+void set_voice(byte ch, byte note, byte vol) {
+  if (note < 0x10) {
+    voice_note[ch] = 0;
+    voice_vol[ch] = 0;
+    return;
+  }
+  voice_per[ch] = gb_note_per[note & 63];
+  voice_note[ch] = note;
+  voice_vol[ch] = vol;
+}
+
+void mute_voice(byte ch) {
+  voice_note[ch] = 0;
+  voice_vol[ch] = 0;
+}
+
+void sn_update_hw(void) {
+  /* bass = ch2 (NR2), lead = ch1 (NR1) unless SFX owns ch1 */
+  if (voice_vol[0] && voice_note[0])
+    gb_ch_on(1, voice_note[0], voice_per[0], voice_vol[0]);
+  else
+    gb_ch_off(1);
+
+  if (sfx_busy) {
+    if (sfx_vol)
+      gb_ch_on(0, voice_note[2], voice_per[2], sfx_vol);
+    else
+      gb_ch_off(0);
+  } else if (voice_vol[1] && voice_note[1]) {
+    gb_ch_on(0, voice_note[1], voice_per[1], voice_vol[1]);
+  } else {
+    gb_ch_off(0);
+  }
+}
+
+byte next_music_byte(void) {
+  if (!music_ptr) return 0xff;
+  return *music_ptr++;
+}
+
+void sfx_stop(void) {
+  sfx_ptr = 0;
+  sfx_timer = 0;
+  sfx_vol = 0;
+  sfx_busy = 0;
+  mute_voice(2);
+  hw_note[0] = 0; /* allow lead to retrigger after SFX */
+}
+
+void sfx_play(const uint8_t* seq) {
+  sfx_ptr = seq;
+  sfx_timer = 0;
+  sfx_vol = 0;
+  sfx_busy = 1;
+  hw_note[0] = 0; /* force retrigger on first SFX note */
+}
+
+void sfx_update(void) {
+  byte note, frames;
+  if (!sfx_ptr) return;
+  if (sfx_timer) {
+    sfx_timer--;
+    if (sfx_timer) return;
+  }
+  note = *sfx_ptr++;
+  if (note == 0xff) {
+    sfx_stop();
+    return;
+  }
+  sfx_vol = *sfx_ptr++;
+  frames = *sfx_ptr++;
+  if (!frames) frames = 1;
+  sfx_timer = frames;
+  if (note & 0x80) {
+    mute_voice(2);
+    sfx_vol = 0;
+  } else {
+    set_voice(2, note & 63, sfx_vol);
+  }
+}
+
+void music_stop(void) {
+  byte i;
+  music_enable = 0;
+  music_ptr = 0;
+  music_loop = 0;
+  chord_n = 0;
+  music_release = 0;
+  for (i = 0; i < MUSIC_VOICES; i++) mute_voice(i);
+  hw_note[0] = hw_note[1] = hw_note[2] = 0;
+}
+
+void music_play(const uint8_t* music, byte loop) {
+  byte i;
+  music_enable = 0;
+  music_paused = 0;
+  music_ptr = music;
+  music_loop = loop ? music : 0;
+  cur_duration = 0;
+  chord_n = 0;
+  music_release = 0;
+  if (music == mus_game || music == mus_welldone) music_speed = 4;
+  else if (music == mus_gameover) music_speed = 6;
+  else music_speed = 3;
+  for (i = 0; i < MUSIC_VOICES; i++) mute_voice(i);
+  music_enable = 1;
+}
+
+void flush_chord(void) {
+  byte bass = (chord_n >= 1) ? chord[0] : 0;
+  byte lead = (chord_n >= 2) ? chord[1] : 0;
+  chord_n = 0;
+  if (bass) { set_voice(0, bass & 63, ENV_MAX); music_release = 0; }
+  else if (voice_note[0]) music_release = 1;
+  else mute_voice(0);
+  if (lead) { set_voice(1, lead & 63, ENV_MAX); music_release = 0; }
+  else if (voice_note[1]) music_release = 1;
+  else mute_voice(1);
+}
+
+void music_seq(void) {
+  byte ch, floor, note;
+  if (!music_enable || music_paused) return;
+  floor = music_release ? 0 : ENV_SUSTAIN;
+  for (ch = 0; ch < MUSIC_VOICES; ch++) {
+    if (voice_vol[ch] > floor) {
+      voice_vol[ch] -= music_release ? 2 : 1;
+      if (voice_vol[ch] < floor || (music_release && voice_vol[ch] > 200))
+        voice_vol[ch] = floor;
+    } else if (music_release && voice_vol[ch] == 0 && voice_note[ch]) {
+      mute_voice(ch);
+    }
+  }
+  if (!music_ptr) {
+    if (music_loop) music_ptr = music_loop;
+    else return;
+  }
+  if (cur_duration) { cur_duration--; return; }
+  while (1) {
+    note = next_music_byte();
+    if (note == 0xff) {
+      music_ptr = music_loop;
+      if (!music_ptr) { music_enable = 0; return; }
+      continue;
+    }
+    if (note & 0x80) {
+      flush_chord();
+      cur_duration = (note & 63) * music_speed;
+      if (!cur_duration) cur_duration = music_speed;
+      cur_duration--;
+      return;
+    }
+    if (chord_n < 4) chord[chord_n++] = note;
+  }
+}
+
+void music_update(void) {
+  sfx_update();
+  music_seq();
+  sn_update_hw();
+}
+
+void wait_vblank(void) {
+  wait_vbl_done();
+  music_update();
+}
+
+void wait_frames(byte n) {
+  while (n--) wait_vblank();
+}
+
+byte map_at(byte x, byte y) {
+  if (x >= map_w || y >= map_h) return T_WALL;
+  return map[y * MAP_W_MAX + x];
+}
+
+void map_set(byte x, byte y, byte t) {
+  map[y * MAP_W_MAX + x] = t;
+}
+
+byte can_enter(byte tx, byte ty) {
+  byte t = map_at(tx, ty);
+  return t == T_FLOOR || t == T_ITEM;
+}
+
+byte glyph(char c) {
+  if (c == ' ') return 0;
+  if (c >= '0' && c <= '9') return (byte)(1 + (c - '0'));
+  if (c == '/') return 30;
+  if (c == ':') return 31;
+  switch (c) {
+    case 'A': return 11; case 'C': return 12; case 'D': return 13;
+    case 'E': return 14; case 'G': return 15; case 'H': return 16;
+    case 'I': return 17; case 'L': return 18; case 'M': return 19;
+    case 'N': return 20; case 'O': return 21; case 'P': return 22;
+    case 'R': return 23; case 'S': return 24; case 'T': return 25;
+    case 'U': return 26; case 'V': return 27; case 'W': return 28;
+    case 'Y': return 29;
+    default: return 0;
+  }
+}
+
+void put_str(byte x, byte y, const char* s) {
+  while (*s) set_bkg_tile_xy(x++, y, glyph(*s++));
+}
+
+void put_digit(byte x, byte y, byte d) {
+  set_bkg_tile_xy(x, y, (byte)(1 + (d % 10)));
+}
+
+void put_str_win(byte x, byte y, const char* s) {
+  while (*s) set_win_tile_xy(x++, y, glyph(*s++));
+}
+
+void put_digit_win(byte x, byte y, byte d) {
+  set_win_tile_xy(x, y, (byte)(1 + (d % 10)));
+}
+
+void clrscr(void) {
+  byte x, y;
+  for (y = 0; y < 32; y++)
+    for (x = 0; x < 32; x++)
+      set_bkg_tile_xy(x, y, 0);
+}
+
+void hide_actor_sprites(byte i) {
+  byte s = (byte)(i << 1);
+  move_sprite(s, 0, 0);
+  move_sprite((byte)(s + 1), 0, 0);
+}
+
+void hide_all_sprites(void) {
+  byte i;
+  for (i = 0; i < 40; i++) move_sprite(i, 0, 0);
+}
+
+void update_camera(void) {
+  word px = actors[0].x >> FP_BITS;
+  word py = actors[0].y >> FP_BITS;
+  word tx, ty;
+  /* Free axes follow the player; locked axes keep load_level placement. */
+  if (cam_max_x == 0) {
+    tx = cam_x;
+  } else {
+    if (px > (VIEW_W / 2)) tx = px - (VIEW_W / 2); else tx = 0;
+    if (tx > cam_max_x) tx = cam_max_x;
+  }
+  if (cam_max_y == 0) {
+    ty = cam_y;
+  } else {
+    if (py > (VIEW_H / 2)) ty = py - (VIEW_H / 2); else ty = 0;
+    if (ty > cam_max_y) ty = cam_max_y;
+  }
+  cam_x = (byte)tx;
+  cam_y = (byte)ty;
+  move_bkg(cam_x, cam_y);
+}
+
+void draw_actors(void) {
+  byte i;
+  for (i = 0; i < actor_n; i++) {
+    Actor* a = &actors[i];
+    int16_t sx, sy;
+    byte base, prop, s;
+    s = (byte)(i << 1);
+    if (a->wait) {
+      if (a->wait >= 16 || (a->wait & 2)) { hide_actor_sprites(i); continue; }
+    }
+    sx = (int16_t)(a->x >> FP_BITS) + (int16_t)map_ox - (int16_t)cam_x;
+    sy = (int16_t)(a->y >> FP_BITS) + (int16_t)map_oy - (int16_t)cam_y;
+    /* hide if fully outside playfield */
+    /* hide if off playfield or X would wrap through OAM (byte) cast */
+    if (sx < -8 || sx >= VIEW_W || sy < -16 || sy >= VIEW_H) {
+      hide_actor_sprites(i);
+      continue;
+    }
+    if (a->kind == 0)
+      base = (frame_cnt & 8) ? SPR_TILE_PL2 : SPR_TILE_PL;
+    else
+      base = SPR_TILE_EN;
+    prop = (a->kind >= 2) ? S_PALETTE : 0;
+    set_sprite_tile(s, base);
+    set_sprite_tile((byte)(s + 1), (byte)(base + 2));
+    set_sprite_prop(s, prop);
+    set_sprite_prop((byte)(s + 1), prop);
+    move_sprite(s, (byte)(sx + 8), (byte)(sy + 16));
+    move_sprite((byte)(s + 1), (byte)(sx + 16), (byte)(sy + 16));
+  }
+}
+
+void draw_cell(byte x, byte y) {
+  byte t = map_at(x, y);
+  byte sx = (byte)(map_tx0 + (x << 1));
+  byte sy = (byte)(map_ty0 + (y << 1));
+  byte spark = (frame_cnt & 16) != 0;
+  if (t == T_VOID) {
+    set_bkg_tile_xy(sx, sy, 0);
+    set_bkg_tile_xy(sx + 1, sy, 0);
+    set_bkg_tile_xy(sx, sy + 1, 0);
+    set_bkg_tile_xy(sx + 1, sy + 1, 0);
+  } else if (t == T_WALL) {
+    set_bkg_tile_xy(sx, sy, TILE_WTL);
+    set_bkg_tile_xy(sx + 1, sy, TILE_WTR);
+    set_bkg_tile_xy(sx, sy + 1, TILE_WBL);
+    set_bkg_tile_xy(sx + 1, sy + 1, TILE_WBR);
+  } else if (t == T_ITEM) {
+    if (spark) {
+      set_bkg_tile_xy(sx, sy, TILE_GTL2);
+      set_bkg_tile_xy(sx + 1, sy, TILE_GTR2);
+      set_bkg_tile_xy(sx, sy + 1, TILE_GBL2);
+      set_bkg_tile_xy(sx + 1, sy + 1, TILE_GBR2);
+    } else {
+      set_bkg_tile_xy(sx, sy, TILE_GTL);
+      set_bkg_tile_xy(sx + 1, sy, TILE_GTR);
+      set_bkg_tile_xy(sx, sy + 1, TILE_GBL);
+      set_bkg_tile_xy(sx + 1, sy + 1, TILE_GBR);
+    }
+  } else {
+    set_bkg_tile_xy(sx, sy, TILE_FLOOR);
+    set_bkg_tile_xy(sx + 1, sy, TILE_FLOOR);
+    set_bkg_tile_xy(sx, sy + 1, TILE_FLOOR);
+    set_bkg_tile_xy(sx + 1, sy + 1, TILE_FLOOR);
+  }
+}
+
+void draw_hud(void) {
+  byte lv = (byte)(game_level + 1);
+  put_str_win(0, 0, "L");
+  put_digit_win(1, 0, lv / 10);
+  put_digit_win(2, 0, lv % 10);
+  put_str_win(4, 0, "G");
+  put_digit_win(5, 0, items_collected / 10);
+  put_digit_win(6, 0, items_collected % 10);
+  put_str_win(7, 0, "/");
+  put_digit_win(8, 0, items_count / 10);
+  put_digit_win(9, 0, items_count % 10);
+  put_str_win(11, 0, "H");
+  put_digit_win(12, 0, game_lives > 0 ? (byte)(game_lives - 1) : 0);
+  if (game_paused) put_str_win(14, 0, "PAUSE");
+  else put_str_win(14, 0, "     ");
+}
+
+void show_menu_screen(void) {
+  HIDE_WIN;
+  hide_all_sprites();
+  move_bkg(0, 0);
+  cam_x = cam_y = 0;
+  clrscr();
+}
+
+void actor_try_dir(byte id, byte dir) {
+  Actor* a = &actors[id];
+  byte tx = POS_TO_TILE(a->x);
+  byte ty = POS_TO_TILE(a->y);
+  if (dir == DIR_LEFT) tx--;
+  else if (dir == DIR_RIGHT) tx++;
+  else if (dir == DIR_UP) ty--;
+  else if (dir == DIR_DOWN) ty++;
+  else return;
+  if (!can_enter(tx, ty)) return;
+  a->dir = dir;
+  a->cnt = (word)TILE_PX << FP_BITS;
+}
+
+void try_collect(byte id) {
+  byte tx, ty;
+  Actor* a = &actors[id];
+  if (id != 0 || a->wait) return;
+  tx = POS_TO_TILE(a->x);
+  ty = POS_TO_TILE(a->y);
+  if (map_at(tx, ty) != T_ITEM) return;
+  map_set(tx, ty, T_FLOOR);
+  draw_cell(tx, ty);
+  items_collected++;
+  sfx_play(sfx_item);
+  draw_hud();
+}
+
+byte gen_is_open(char c) {
+  return c == '*' || c == 'P' || c == '1' || c == '2' || c == '3';
+}
+
+/* Corner pillars (even,even) stay walls — diagonals of every floor stay solid. */
+byte gen_is_pillar(byte x, byte y) {
+  return !(x & 1) && !(y & 1);
+}
+
+byte gen_ortho_degree(byte x, byte y) {
+  byte n = 0;
+  if (gen_is_open(gen_row[y - 1][x])) n++;
+  if (gen_is_open(gen_row[y + 1][x])) n++;
+  if (gen_is_open(gen_row[y][x - 1])) n++;
+  if (gen_is_open(gen_row[y][x + 1])) n++;
+  return n;
+}
+
+/* May open (x,y) only if it is not a pillar and does not form a 2×2 floor block. */
+byte gen_can_open(byte x, byte y) {
+  if (x < 1 || y < 1 || x >= gen_w - 1 || y >= gen_h - 1) return 0;
+  if (gen_is_pillar(x, y)) return 0;
+  if (gen_is_open(gen_row[y][x])) return 0;
+  /* Four possible 2×2 blocks that would include this cell */
+  if (gen_is_open(gen_row[y - 1][x - 1]) && gen_is_open(gen_row[y - 1][x]) &&
+      gen_is_open(gen_row[y][x - 1]))
+    return 0;
+  if (gen_is_open(gen_row[y - 1][x]) && gen_is_open(gen_row[y - 1][x + 1]) &&
+      gen_is_open(gen_row[y][x + 1]))
+    return 0;
+  if (gen_is_open(gen_row[y][x - 1]) && gen_is_open(gen_row[y + 1][x - 1]) &&
+      gen_is_open(gen_row[y + 1][x]))
+    return 0;
+  if (gen_is_open(gen_row[y][x + 1]) && gen_is_open(gen_row[y + 1][x]) &&
+      gen_is_open(gen_row[y + 1][x + 1]))
+    return 0;
+  return 1;
+}
+
+byte gen_try_open(byte x, byte y) {
+  if (!gen_can_open(x, y)) return 0;
+  gen_row[y][x] = '*';
+  return 1;
+}
+
+/* Keep every even,even cell as a wall (border + interior pillars). */
+void gen_force_pillars(void) {
+  byte x, y;
+  for (y = 0; y < gen_h; y++) {
+    for (x = 0; x < gen_w; x++) {
+      if (gen_is_pillar(x, y)) gen_row[y][x] = '#';
+    }
+  }
+}
+
+/*
+ * Remove cul-de-sacs: prefer opening an orthogonal wall (never a pillar / 2×2),
+ * otherwise fill the dead-end floor as wall. Exits are U/D/L/R only.
+ */
+void braid_dead_ends(void) {
+  byte x, y, n, guard, changed;
+
+  for (guard = 0; guard < 64; guard++) {
+    changed = 0;
+    for (y = 1; y < gen_h - 1; y++) {
+      for (x = 1; x < gen_w - 1; x++) {
+        if (!gen_is_open(gen_row[y][x])) continue;
+        n = gen_ortho_degree(x, y);
+        if (n >= 2) continue;
+        /* Prefer opening opposite the single exit. */
+        if (n == 1) {
+          if (gen_is_open(gen_row[y - 1][x]) && gen_try_open(x, (byte)(y + 1))) {
+            changed = 1;
+            continue;
+          }
+          if (gen_is_open(gen_row[y + 1][x]) && gen_try_open(x, (byte)(y - 1))) {
+            changed = 1;
+            continue;
+          }
+          if (gen_is_open(gen_row[y][x - 1]) && gen_try_open((byte)(x + 1), y)) {
+            changed = 1;
+            continue;
+          }
+          if (gen_is_open(gen_row[y][x + 1]) && gen_try_open((byte)(x - 1), y)) {
+            changed = 1;
+            continue;
+          }
+        }
+        if (gen_try_open(x, (byte)(y - 1)) || gen_try_open(x, (byte)(y + 1)) ||
+            gen_try_open((byte)(x - 1), y) || gen_try_open((byte)(x + 1), y)) {
+          changed = 1;
+          continue;
+        }
+        /* Cannot add a legal exit — shrink the cul-de-sac away. */
+        gen_row[y][x] = '#';
+        changed = 1;
+      }
+    }
+    if (!changed) break;
+  }
+}
+
+/*
+ * Binary-tree on odd cells (corner pillars stay walls), extra orthogonal
+ * openings, then braid. No dead ends; no 2×2 floors; exits are U/D/L/R only.
+ */
+void generate_level(byte diff) {
+  byte x, y, i, n_en, placed;
+  byte w, h;
+
+  /* Size grows with progress; stay odd for the carve grid. */
+  w = (byte)(9 + (diff % 4) * 2); /* 9,11,13,15 */
+  if (w > MAP_W_MAX) w = MAP_W_MAX;
+  if (!(w & 1)) w--;
+  h = (byte)(9 + ((diff / 2) % 3) * 2); /* 9,11,13 */
+  if (h > MAP_H_MAX) h = MAP_H_MAX;
+  if (!(h & 1)) h--;
+  gen_w = w;
+  gen_h = h;
+
+  for (y = 0; y < h; y++) {
+    for (x = 0; x < w; x++) gen_row[y][x] = '#';
+    gen_row[y][w] = 0;
+  }
+
+  for (y = 1; y < h - 1; y += 2) {
+    for (x = 1; x < w - 1; x += 2) {
+      gen_row[y][x] = '*';
+      if (x + 2 <= w - 2 && y + 2 <= h - 2) {
+        if (rand8() & 1) gen_row[y][x + 1] = '*';
+        else gen_row[y + 1][x] = '*';
+      } else if (x + 2 <= w - 2) {
+        gen_row[y][x + 1] = '*';
+      } else if (y + 2 <= h - 2) {
+        gen_row[y + 1][x] = '*';
+      }
+    }
+  }
+
+  /* Extra orthogonal openings between floors (never pillars / 2×2). */
+  for (i = 0; i < (byte)(10 + diff * 2); i++) {
+    x = (byte)(1 + (rand8() % (w - 2)));
+    y = (byte)(1 + (rand8() % (h - 2)));
+    if (!gen_can_open(x, y)) continue;
+    if (gen_is_open(gen_row[y - 1][x]) || gen_is_open(gen_row[y + 1][x]) ||
+        gen_is_open(gen_row[y][x - 1]) || gen_is_open(gen_row[y][x + 1]))
+      gen_row[y][x] = '*';
+  }
+
+  braid_dead_ends();
+  gen_force_pillars();
+  braid_dead_ends(); /* pillars may recreate a cul-de-sac — clean again */
+
+  /* Player near top-left floor */
+  gen_row[1][1] = 'P';
+
+  /* 1–3 enemies toward the bottom / right */
+  n_en = 1;
+  if (diff >= 2) n_en = 2;
+  if (diff >= 5) n_en = 3;
+  placed = 0;
+  y = (byte)(h - 2);
+  while (1) {
+    x = (byte)(w - 2);
+    while (1) {
+      if (gen_row[y][x] == '*' && !(x <= 2 && y <= 2)) {
+        gen_row[y][x] = (char)('1' + placed);
+        placed++;
+        if (placed >= n_en) break;
+      }
+      if (x <= 1) break;
+      x--;
+    }
+    if (placed >= n_en || y <= 1) break;
+    y--;
+  }
+  /* Fallback if we somehow placed none (h/w odd ⇒ bottom-right interior is a room). */
+  if (!placed) gen_row[h - 2][w - 2] = '1';
+}
+
+void load_level_cells(const char* const* rows, byte w, byte h) {
+  byte x, y;
+  const char* row;
+  map_w = w;
+  map_h = h;
+  actor_n = 0;
+  items_count = 0;
+  items_collected = 0;
+  for (y = 0; y < h; y++) {
+    row = rows[y];
+    for (x = 0; x < w; x++) {
+      char c = row[x];
+      byte t = T_FLOOR;
+      if (c == ' ') t = T_VOID;
+      else if (c == '#') t = T_WALL;
+      else if (c == '*') { t = T_ITEM; items_count++; }
+      else if (c == 'P' || c == '1' || c == '2' || c == '3') {
+        Actor* a = &actors[actor_n];
+        a->x = TILE_TO_POS(x);
+        a->y = TILE_TO_POS(y);
+        a->cnt = 0;
+        a->dir = DIR_NONE;
+        if (c == 'P') { a->kind = 0; a->speed = 32; a->wait = 16; }
+        else {
+          a->kind = (byte)(c - '0');
+          a->speed = (word)(10 + ((a->kind - 1) << 1) + (game_level >> 2));
+          if (a->speed > 20) a->speed = 20;
+          a->wait = (byte)(16 + (a->kind << 4));
+        }
+        actor_n++;
+        t = T_FLOOR;
+      }
+      map[y * MAP_W_MAX + x] = t;
+    }
+  }
+}
+
+void load_level(byte li) {
+  byte x, y, i;
+  word map_px, map_py;
+  const char* rowptrs[MAP_H_MAX];
+
+  if (li < LEVELS_FIXED) {
+    load_level_cells(levels[li].rows, levels[li].w, levels[li].h);
+  } else {
+    generate_level((byte)(li - LEVELS_FIXED));
+    for (y = 0; y < gen_h; y++) rowptrs[y] = gen_row[y];
+    load_level_cells(rowptrs, gen_w, gen_h);
+  }
+
+  /*
+   * Place maze in the BG map. Prefer a 1-cell (2-tile) inset from the top
+   * when leftover room allows; keep tile origin even so 16×16 metas align.
+   * Outside the maze stays blank — do not invent border walls.
+   */
+  {
+    byte tw = (byte)(map_w << 1);
+    byte th = (byte)(map_h << 1);
+    byte left;
+    if (tw < VIEW_TILES_W) {
+      left = (byte)(VIEW_TILES_W - tw);
+      map_tx0 = (byte)((left >> 1) & ~1);
+    } else {
+      map_tx0 = 0;
+    }
+    if (th < VIEW_TILES_H) {
+      left = (byte)(VIEW_TILES_H - th);
+      if (left >= 4)
+        map_ty0 = 2;
+      else
+        map_ty0 = (byte)(left & ~1);
+    } else {
+      map_ty0 = 0;
+    }
+    map_ox = (byte)(map_tx0 << 3);
+    map_oy = (byte)(map_ty0 << 3);
+  }
+  clrscr();
+  for (y = 0; y < map_h; y++)
+    for (x = 0; x < map_w; x++)
+      draw_cell(x, y);
+  for (i = actor_n; i < ACTORS_MAX; i++) hide_actor_sprites(i);
+  spawn_wait = (byte)(actor_n << 4);
+  map_px = (word)map_w * TILE_PX;
+  map_py = (word)map_h * TILE_PX;
+  cam_max_x = (map_px > VIEW_W) ? (byte)(map_px - VIEW_W) : 0;
+  cam_max_y = (map_py > VIEW_H) ? (byte)(map_py - VIEW_H) : 0;
+  cam_x = 0;
+  cam_y = 0;
+  move_bkg(cam_x, cam_y);
+  move_win(7, HUD_WY);
+  SHOW_WIN;
+}
+
+byte hit_player(void) {
+  byte i;
+  word px = actors[0].x >> FP_BITS;
+  word py = actors[0].y >> FP_BITS;
+  if (actors[0].wait) return 0;
+  for (i = 1; i < actor_n; i++) {
+    word ex, ey;
+    if (actors[i].wait) continue;
+    ex = actors[i].x >> FP_BITS;
+    ey = actors[i].y >> FP_BITS;
+    if (!((px + 4) >= (ex + 12) || (ex + 4) >= (px + 12) ||
+          (py + 4) >= (ey + 12) || (ey + 4) >= (py + 12)))
+      return 1;
+  }
+  return 0;
+}
+
+void animate_gems(void) {
+  byte x, y;
+  if ((frame_cnt & 15) != 0) return;
+  for (y = 0; y < map_h; y++)
+    for (x = 0; x < map_w; x++)
+      if (map_at(x, y) == T_ITEM) draw_cell(x, y);
+}
+
+void enemy_ai(byte id) {
+  Actor* a = &actors[id];
+  byte tx = POS_TO_TILE(a->x);
+  byte ty = POS_TO_TILE(a->y);
+  byte dirs[4];
+  byte n = 0;
+  byte prev = a->dir;
+  byte pick;
+  if (prev != DIR_RIGHT && can_enter((byte)(tx - 1), ty)) dirs[n++] = DIR_LEFT;
+  if (prev != DIR_LEFT  && can_enter((byte)(tx + 1), ty)) dirs[n++] = DIR_RIGHT;
+  if (prev != DIR_DOWN  && can_enter(tx, (byte)(ty - 1))) dirs[n++] = DIR_UP;
+  if (prev != DIR_UP    && can_enter(tx, (byte)(ty + 1))) dirs[n++] = DIR_DOWN;
+  if (!n) return;
+  pick = dirs[rand8() % n];
+  actor_try_dir(id, pick);
+  if (n > 1) {
+    Actor* p = &actors[0];
+    if (prev != DIR_DOWN && p->y < a->y) actor_try_dir(id, DIR_UP);
+    if (prev != DIR_UP   && p->y > a->y) actor_try_dir(id, DIR_DOWN);
+    if (prev != DIR_RIGHT && p->x < a->x) actor_try_dir(id, DIR_LEFT);
+    if (prev != DIR_LEFT  && p->x > a->x) actor_try_dir(id, DIR_RIGHT);
+  }
+}
+
+void player_controls(void) {
+  byte j = 0;
+  Actor* a = &actors[0];
+  if (joy_left) j |= DIR_LEFT;
+  if (joy_right) j |= DIR_RIGHT;
+  if (joy_up) j |= DIR_UP;
+  if (joy_down) j |= DIR_DOWN;
+  if (j & a->dir) {
+    j = (byte)(j & ~a->dir);
+    actor_try_dir(0, a->dir);
+  }
+  if (j & DIR_LEFT) actor_try_dir(0, DIR_LEFT);
+  if (j & DIR_RIGHT) actor_try_dir(0, DIR_RIGHT);
+  if (j & DIR_UP) actor_try_dir(0, DIR_UP);
+  if (j & DIR_DOWN) actor_try_dir(0, DIR_DOWN);
+}
+
+void advance_actor(byte id) {
+  Actor* a = &actors[id];
+  word step;
+  if (!a->cnt) return;
+  step = a->speed;
+  if (step > a->cnt) step = a->cnt;
+  if (a->dir == DIR_LEFT) a->x -= step;
+  else if (a->dir == DIR_RIGHT) a->x += step;
+  else if (a->dir == DIR_UP) a->y -= step;
+  else if (a->dir == DIR_DOWN) a->y += step;
+  a->cnt -= step;
+  if (!a->cnt) {
+    a->x &= POS_SNAP_MASK;
+    a->y &= POS_SNAP_MASK;
+    try_collect(id);
+  }
+}
+
+void wait_for_button(void) {
+  read_controls();
+  while (!joy_fire && !joy_start) { wait_vblank(); read_controls(); }
+  while (joy_fire || joy_start) { wait_vblank(); read_controls(); }
+}
+
+void draw_title_logo(byte y0) {
+  byte y, x;
+  for (y = 0; y < 6; y++)
+    for (x = 0; x < 20; x++)
+      set_bkg_tile_xy(x, (byte)(y0 + y), title_logo[y][x]);
+}
+
+void title_screen(void) {
+  /*
+   * NES starts at scroll Y=240 over a blank second nametable, then falls to 0.
+   * GB has one 256px BG map that wraps, so Y=240 still shows the title.
+   * Mirror the effect: keep the title in the top 112px, leave 112..255 blank,
+   * and start at SCY=112 (a full screen of blank) before falling to 0.
+   */
+  int16_t iy, dy;
+  byte wait, i;
+  byte left_prev, right_prev;
+  byte lv;
+  show_menu_screen();
+  HIDE_BKG;
+  draw_title_logo(2);
+  put_str(2, 8, "COLLECT ALL GEMS");
+  put_str(3, 9, "AVOID ENEMIES");
+  put_str(3, 13, "PD SHIRU 2012");
+  iy = (int16_t)112 << FP_BITS;
+  dy = (int16_t)(-8) << FP_BITS;
+  move_bkg(0, (byte)(iy >> FP_BITS));
+  SHOW_BKG;
+  wait_frames(20);
+  wait = 160;
+  frame_cnt = 0;
+  read_controls();
+  while (1) {
+    wait_vblank();
+    move_bkg(0, (byte)(iy >> FP_BITS));
+    read_controls();
+    if (joy_start || joy_fire) break;
+    iy += dy;
+    if (iy < 0) {
+      iy = 0;
+      dy = (int16_t)((-dy) >> 1);
+    }
+    if (dy > ((int16_t)(-8) << FP_BITS)) dy -= 2;
+    if (wait) {
+      --wait;
+    } else {
+      if (frame_cnt & 32) put_str(4, 11, "PRESS START");
+      else put_str(4, 11, "           ");
+      ++frame_cnt;
+    }
+  }
+  move_bkg(0, 0);
+  put_str(4, 11, "PRESS START");
+  sfx_play(sfx_start);
+  for (i = 0; i < 16; ++i) {
+    if (i & 1) put_str(4, 11, "           ");
+    else put_str(4, 11, "PRESS START");
+    wait_frames(4);
+  }
+  while (joy_fire || joy_start) { wait_vblank(); read_controls(); }
+
+  /* Level select — L/R change start, Start/A to play */
+  put_str(4, 11, "           ");
+  put_str(3, 11, "LEVEL");
+  put_str(1, 14, "L R TO PICK");
+  put_str(4, 15, "START");
+  left_prev = right_prev = 1;
+  while (1) {
+    lv = (byte)(start_level + 1);
+    put_digit(9, 11, lv / 10);
+    put_digit(10, 11, lv % 10);
+    wait_vblank();
+    read_controls();
+    if (joy_left && !left_prev) {
+      if (start_level) start_level--;
+    }
+    if (joy_right && !right_prev) {
+      if (start_level < 29) start_level++; /* L30 = deep into procedural */
+    }
+    left_prev = joy_left;
+    right_prev = joy_right;
+    if (joy_start || joy_fire) break;
+  }
+  while (joy_fire || joy_start) { wait_vblank(); read_controls(); }
+}
+
+void show_level_banner(void) {
+  byte lv = (byte)(game_level + 1);
+  show_menu_screen();
+  put_str(5, 8, "LEVEL");
+  put_digit(11, 8, lv / 10);
+  put_digit(12, 8, lv % 10);
+  music_play(mus_level, 0);
+  wait_frames(50);
+  music_stop();
+  sfx_stop();
+}
+
+void show_game_over(void) {
+  show_menu_screen();
+  put_str(5, 8, "GAME OVER");
+  music_play(mus_gameover, 0);
+  wait_for_button();
+  music_stop();
+}
+
+void show_well_done(void) {
+  show_menu_screen();
+  put_str(5, 7, "WELL DONE");
+  put_str(1, 10, "ALL GEMS COLLECTED");
+  music_play(mus_welldone, 0);
+  wait_for_button();
+  music_stop();
+}
+
+void game_loop(void) {
+  byte i;
+  hide_all_sprites();
+  load_level(game_level);
+  draw_hud();
+  update_camera();
+  game_done = 0;
+  game_clear = 0;
+  game_paused = 0;
+  music_paused = 0;
+  frame_cnt = 0;
+  start_prev = 1;
+  music_stop();
+  BGP_REG = 0xE4;
+  while (!game_done) {
+    wait_vblank();
+    frame_cnt++;
+    read_controls();
+    if (joy_start && !start_prev) {
+      game_paused = !game_paused;
+      music_paused = game_paused;
+      BGP_REG = game_paused ? 0xF9 : 0xE4;
+      draw_hud();
+    }
+    start_prev = joy_start;
+    if (game_paused) { draw_actors(); continue; }
+    animate_gems();
+
+    if (items_collected >= items_count && !game_clear) {
+      game_clear = 1;
+      game_done = 1;
+      sfx_stop();
+      music_play(mus_clear, 0);
+    }
+
+    if (spawn_wait) {
+      --spawn_wait;
+      if (!spawn_wait && !music_enable)
+        music_play(mus_game, 1);
+    }
+
+    for (i = 0; i < actor_n; i++) {
+      if (actors[i].wait) {
+        if (actors[i].wait == 16)
+          sfx_play(i ? sfx_respawn_e : sfx_respawn_p);
+        actors[i].wait--;
+        continue;
+      }
+      if (spawn_wait) continue;
+      advance_actor(i);
+      if (!actors[i].cnt) {
+        if (i == 0) player_controls();
+        else enemy_ai(i);
+      }
+    }
+    update_camera();
+    draw_actors();
+    if (!game_clear && hit_player()) {
+      sfx_stop();
+      music_play(mus_lose, 0);
+      game_done = 1;
+      wait_frames(100);
+    }
+  }
+  if (game_clear) wait_frames(100);
+  music_stop();
+  sfx_stop();
+  hide_all_sprites();
+  HIDE_WIN;
+  BGP_REG = 0xE4;
+}
+
+void setup_graphics(void) {
+  byte x;
+  DISPLAY_OFF;
+  set_bkg_1bpp_data(0, 32, font_1bpp);
+  set_bkg_data(BKG_BASE, 13, bkg_tiles);
+  set_sprite_data(16, 12, sprite_tiles);
+  /* same font tiles for window HUD */
+  for (x = 0; x < 20; x++) set_win_tile_xy(x, 0, 0);
+  SPRITES_8x16;
+  BGP_REG = 0xE4;
+  OBP0_REG = 0xE4;
+  OBP1_REG = 0xD2; /* slightly different for enemy kinds 2+ */
+  psg_init();
+  move_win(7, HUD_WY);
+  HIDE_WIN;
+  SHOW_BKG;
+  SHOW_SPRITES;
+  DISPLAY_ON;
+}
+
+void main(void) {
+  setup_graphics();
+  while (1) {
+    title_screen();
+    game_level = start_level;
+    game_lives = 4;
+    rnd ^= (word)frame_cnt << 8; /* fresh maze seed each run */
+    /* Levels 1–5 fixed; then endless procedural until lives run out. */
+    while (game_lives) {
+      show_level_banner();
+      game_loop();
+      if (game_clear) {
+        if (game_level != 255) game_level++;
+      } else {
+        game_lives--;
+      }
+    }
+    show_game_over();
+  }
+}
diff --git a/presets/gb/gb/bcd.h b/presets/gb/gb/bcd.h
index 4f3f0049..76f503cf 100644
--- a/presets/gb/gb/bcd.h
+++ b/presets/gb/gb/bcd.h
@@ -1,7 +1,7 @@
 #ifndef __BCD_H_INCLUDE
 #define __BCD_H_INCLUDE
 
-#include <types.h>
+#include "types.h"
 #include <stdint.h>
 
 /** @file bcd.h
diff --git a/presets/gb/gb/cgb.h b/presets/gb/gb/cgb.h
index 7cbded42..f2ec280e 100644
--- a/presets/gb/gb/cgb.h
+++ b/presets/gb/gb/cgb.h
@@ -17,7 +17,7 @@
 #ifndef _CGB_H
 #define _CGB_H
 
-#include <types.h>
+#include "types.h"
 #include <stdint.h>
 
 /** Macro to create a CGB palette color entry out of 5-bit color components.
diff --git a/presets/gb/gb/drawing.h b/presets/gb/gb/drawing.h
index bc53d042..e4129b93 100644
--- a/presets/gb/gb/drawing.h
+++ b/presets/gb/gb/drawing.h
@@ -30,7 +30,7 @@
 #ifndef __DRAWING_H
 #define __DRAWING_H
 
-#include <types.h>
+#include "types.h"
 #include <stdint.h>
 
 /** Size of the screen in pixels */
@@ -56,7 +56,7 @@
 #define SIGNED   1
 #define UNSIGNED 0
 
-#include <types.h>
+#include "types.h"
 
 /** Print the string 'str' with no interpretation
     @see gotogxy()
diff --git a/presets/gb/gb/emu_debug.h b/presets/gb/gb/emu_debug.h
index b74bec1e..51ab5c54 100644
--- a/presets/gb/gb/emu_debug.h
+++ b/presets/gb/gb/emu_debug.h
@@ -12,7 +12,7 @@
 #ifndef __EMU_DEBUG_INCLUDE
 #define __EMU_DEBUG_INCLUDE
 
-#include <types.h>
+#include "types.h"
 
 /** Macro to display a message in the emulator debug message window
 
diff --git a/presets/gb/gb/gbdecompress.h b/presets/gb/gb/gbdecompress.h
index 79a6c985..d645bd50 100644
--- a/presets/gb/gb/gbdecompress.h
+++ b/presets/gb/gb/gbdecompress.h
@@ -8,7 +8,7 @@
 #ifndef __GBDECOMPRESS_H_INCLUDE
 #define __GBDECOMPRESS_H_INCLUDE
 
-#include <types.h>
+#include "types.h"
 #include <stdint.h>
 
 /** gb-decompress data from sour into dest
diff --git a/presets/gb/gb/isr.h b/presets/gb/gb/isr.h
index 59b2165f..01f321a7 100644
--- a/presets/gb/gb/isr.h
+++ b/presets/gb/gb/isr.h
@@ -10,7 +10,7 @@
 #define _ISR_H_INCLUDE_
 
 #include <stdint.h>
-#include <types.h>
+#include "types.h"
 
 // #define VECTOR_VBL     0x40 // you can not define raw vector for VBlank interrupt
 #define VECTOR_STAT    0x48  /**< Address for the STAT interrupt vector */
diff --git a/presets/gb/gb/metasprites.h b/presets/gb/gb/metasprites.h
index 5bb27974..af9d077e 100644
--- a/presets/gb/gb/metasprites.h
+++ b/presets/gb/gb/metasprites.h
@@ -68,7 +68,7 @@
 #define _METASPRITES_H_INCLUDE
 
 #include <gb/hardware.h>
-#include <types.h>
+#include "types.h"
 #include <stdint.h>
 
 /** Metasprite sub-item structure
diff --git a/presets/gb/gb/sgb.h b/presets/gb/gb/sgb.h
index ab37a04f..8cd17c4f 100644
--- a/presets/gb/gb/sgb.h
+++ b/presets/gb/gb/sgb.h
@@ -6,7 +6,7 @@
 #ifndef _SGB_H
 #define _SGB_H
 
-#include <types.h>
+#include "types.h"
 #include <stdint.h>
 
 #define SGB_PAL_01 0x00U    /**< SGB Command: Set SGB Palettes 0 & 1 */
diff --git a/presets/gb/hello.sgb b/presets/gb/hello.sgb
index 78a605f3..2ccb6d43 100644
--- a/presets/gb/hello.sgb
+++ b/presets/gb/hello.sgb
@@ -1,5 +1,5 @@
 
-.include "gingerbread.sgb"
+.include "gb/gingerbread.sgb"
 
 ; Set the size of the ROM file here. 0 means 32 kB, 1 means 64 kB, 2 means 128 kB and so on.
 ROM_SIZE = 1
diff --git a/presets/gb/pakupaku.c b/presets/gb/pakupaku.c
new file mode 100644
index 00000000..a359cdaf
--- /dev/null
+++ b/presets/gb/pakupaku.c
@@ -0,0 +1,631 @@
+/*
+ * Paku Paku for Game Boy — port of presets/pacman/pakupaku.c
+ *
+ * One-lane chase inspired by crisp-game-lib "PAKU PAKU":
+ *   A / Start = reverse    Left / Right = face that way
+ * Collect dots; power pellet makes the ghost edible.
+ * Movement/AI match the Pac-Man hardware port; graphics from pacman.5e/5f
+ * (regenerate with: python3 scripts/gen_gb_pakupaku_gfx.py).
+ */
+
+//#link "gb/sfr.sgb"
+//#link "gb/crt0.sgb"
+//#resource "gb/global.sgb"
+#include <stdint.h>
+#include "gb/types.h"
+#include "gb/hardware.h"
+#include "gb/gb.h"
+
+typedef uint8_t byte;
+typedef uint16_t word;
+typedef int8_t sbyte;
+
+#define FIELD_MAX    152   /* arcade 208 scaled to GB width */
+#define PLAYER_SPD   2
+#define NUM_DOTS     18
+#define HIT_DIST     12
+
+#define ROW_ABOVE    8
+#define DOT_TILE_Y   9
+#define ROW_BELOW    10
+#define CORRIDOR_Y   68
+
+/* BG tiles from pacman.5e (after font 0..34) */
+#define BKG_BASE     40
+#define T_WALL_ABOVE (BKG_BASE + 0)
+#define T_WALL_BELOW (BKG_BASE + 1)
+#define T_DOT        (BKG_BASE + 2)
+#define T_POWER      (BKG_BASE + 3)
+
+/*
+ * Arcade pacman.5f sprites → GB 16×16 (two 8×16 OAM each).
+ * Each frame is 4 tiles at SPR_BASE: L-top, L-bot, R-top, R-bot.
+ * Regenerate: python3 scripts/gen_gb_pakupaku_gfx.py
+ */
+#define SPR_BASE     48
+#define SPR_FRAME(i) ((byte)(SPR_BASE + (i) * 4))
+#define SP_OPEN      SPR_FRAME(0)
+#define SP_MID       SPR_FRAME(1)
+#define SP_CLOSED    SPR_FRAME(2)
+#define SP_DEATH0    SPR_FRAME(3)  /* 11 frames: 3..13 */
+#define SP_DEATH_N   11
+#define SP_GHOST0    SPR_FRAME(14)
+#define SP_GHOST1    SPR_FRAME(15)
+#define SP_SCARED0   SPR_FRAME(16)
+#define SP_SCARED1   SPR_FRAME(17)
+#define SP_EYES      SPR_FRAME(18)
+#define SPR_TILE_COUNT 76
+
+typedef struct {
+  byte tx;
+  byte active;
+  byte is_power;
+} Dot;
+
+word rnd = 0xCACE;
+word score;
+byte multiplier;
+byte player_x;
+sbyte player_vx;
+byte enemy_x;
+sbyte enemy_eye_vx;
+word power_ticks;
+word anim_ticks;
+byte btn_prev;
+byte game_over;
+byte waka;
+Dot dots[NUM_DOTS];
+
+byte joy_left, joy_right, joy_fire, joy_start;
+byte sfx_timer;
+byte sfx_kind; /* 0=off 1/2=waka 3=eat 4=death 6=power */
+byte death_phase;
+
+const uint8_t font_1bpp[] = {
+  /* 0 space */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  /* 1 '0' */ 0x3C,0x66,0x6E,0x76,0x66,0x66,0x3C,0x00,
+  /* 2 '1' */ 0x18,0x38,0x18,0x18,0x18,0x18,0x7E,0x00,
+  /* 3 '2' */ 0x3C,0x66,0x06,0x0C,0x18,0x30,0x7E,0x00,
+  /* 4 '3' */ 0x3C,0x66,0x06,0x1C,0x06,0x66,0x3C,0x00,
+  /* 5 '4' */ 0x0C,0x1C,0x3C,0x6C,0x7E,0x0C,0x0C,0x00,
+  /* 6 '5' */ 0x7E,0x60,0x7C,0x06,0x06,0x66,0x3C,0x00,
+  /* 7 '6' */ 0x1C,0x30,0x60,0x7C,0x66,0x66,0x3C,0x00,
+  /* 8 '7' */ 0x7E,0x06,0x0C,0x18,0x30,0x30,0x30,0x00,
+  /* 9 '8' */ 0x3C,0x66,0x66,0x3C,0x66,0x66,0x3C,0x00,
+  /*10 '9' */ 0x3C,0x66,0x66,0x3E,0x06,0x0C,0x38,0x00,
+  /*11 'A' */ 0x3C,0x66,0x66,0x7E,0x66,0x66,0x66,0x00,
+  /*12 'C' */ 0x3C,0x66,0x60,0x60,0x60,0x66,0x3C,0x00,
+  /*13 'E' */ 0x7E,0x60,0x60,0x7C,0x60,0x60,0x7E,0x00,
+  /*14 'F' */ 0x7E,0x60,0x60,0x7C,0x60,0x60,0x60,0x00,
+  /*15 'G' */ 0x3C,0x66,0x60,0x6E,0x66,0x66,0x3C,0x00,
+  /*16 'H' */ 0x66,0x66,0x66,0x7E,0x66,0x66,0x66,0x00,
+  /*17 'I' */ 0x3C,0x18,0x18,0x18,0x18,0x18,0x3C,0x00,
+  /*18 'K' */ 0x66,0x6C,0x78,0x70,0x78,0x6C,0x66,0x00,
+  /*19 'L' */ 0x60,0x60,0x60,0x60,0x60,0x60,0x7E,0x00,
+  /*20 'M' */ 0x63,0x77,0x7F,0x6B,0x63,0x63,0x63,0x00,
+  /*21 'N' */ 0x66,0x76,0x7E,0x7E,0x6E,0x66,0x66,0x00,
+  /*22 'O' */ 0x3C,0x66,0x66,0x66,0x66,0x66,0x3C,0x00,
+  /*23 'P' */ 0x7C,0x66,0x66,0x7C,0x60,0x60,0x60,0x00,
+  /*24 'R' */ 0x7C,0x66,0x66,0x7C,0x6C,0x66,0x66,0x00,
+  /*25 'S' */ 0x3C,0x66,0x60,0x3C,0x06,0x66,0x3C,0x00,
+  /*26 'T' */ 0x7E,0x18,0x18,0x18,0x18,0x18,0x18,0x00,
+  /*27 'U' */ 0x66,0x66,0x66,0x66,0x66,0x66,0x3C,0x00,
+  /*28 'V' */ 0x66,0x66,0x66,0x66,0x66,0x3C,0x18,0x00,
+  /*29 'W' */ 0x63,0x63,0x63,0x6B,0x7F,0x77,0x63,0x00,
+  /*30 'X' */ 0x66,0x66,0x3C,0x18,0x3C,0x66,0x66,0x00,
+  /*31 'D' */ 0x78,0x6C,0x66,0x66,0x66,0x6C,0x78,0x00,
+  /*32 '-' */ 0x00,0x00,0x00,0x7E,0x00,0x00,0x00,0x00,
+  /*33 '!' */ 0x18,0x18,0x18,0x18,0x18,0x00,0x18,0x00,
+  /*34 '/' */ 0x06,0x06,0x0C,0x18,0x30,0x60,0x60,0x00,
+};
+
+const uint8_t bkg_tiles[] = {
+/*{w:8,h:8,bpp:1,count:4,brev:1,np:2,pofs:1,sl:2}*/
+  0xff,0xff,0x00,0xff,0x00,0xff,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x00,0xff,0x00,0xff,0xff,0xff,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x00,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x3c,0x00,0x7e,0x00,0xff,0x00,0xff,0x00,0xff,0x00,0xff,0x00,0x7e,0x00,0x3c,0x00,
+};
+
+const uint8_t sprite_tiles[] = {
+/*{w:8,h:8,bpp:1,count:76,brev:1,np:2,pofs:1,sl:2}*/
+  0x00,0x00,0x07,0x07,0x1f,0x1f,0x3f,0x3f,0x3f,0x3f,0x7e,0x7e,0x7c,0x7c,0x78,0x78,
+  0x7c,0x7c,0x7e,0x7e,0x3f,0x3f,0x3f,0x3f,0x1f,0x1f,0x07,0x07,0x00,0x00,0x00,0x00,
+  0x00,0x00,0xc0,0xc0,0xc0,0xc0,0x80,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x80,0xc0,0xc0,0xc0,0xc0,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x07,0x07,0x1f,0x1f,0x3f,0x3f,0x3f,0x3f,0x7f,0x7f,0x7f,0x7f,0x78,0x78,
+  0x7f,0x7f,0x7f,0x7f,0x3f,0x3f,0x3f,0x3f,0x1f,0x1f,0x07,0x07,0x00,0x00,0x00,0x00,
+  0x00,0x00,0xc0,0xc0,0xf0,0xf0,0xf8,0xf8,0xf8,0xf8,0xe0,0xe0,0x00,0x00,0x00,0x00,
+  0x00,0x00,0xe0,0xe0,0xf8,0xf8,0xf8,0xf8,0xf0,0xf0,0xc0,0xc0,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x07,0x07,0x1f,0x1f,0x3f,0x3f,0x3f,0x3f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,
+  0x7f,0x7f,0x7f,0x7f,0x3f,0x3f,0x3f,0x3f,0x1f,0x1f,0x07,0x07,0x00,0x00,0x00,0x00,
+  0x00,0x00,0xc0,0xc0,0xf0,0xf0,0xf8,0xf8,0xf8,0xf8,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,
+  0xfc,0xfc,0xfc,0xfc,0xf8,0xf8,0xf8,0xf8,0xf0,0xf0,0xc0,0xc0,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x60,0x70,0x70,0x78,0x78,0x7c,0x7c,0x7e,0x7e,
+  0x3f,0x3f,0x3f,0x3f,0x1f,0x1f,0x07,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x0c,0x0c,0x1c,0x1c,0x3c,0x3c,0x7c,0x7c,0xfc,0xfc,
+  0xf8,0xf8,0xf8,0xf8,0xf0,0xf0,0xc0,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x40,0xf0,0xf0,0xf8,0xf8,0xfe,0xfe,
+  0x7f,0x7f,0x7f,0x7f,0x3f,0x3f,0x0e,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x04,0x1e,0x1e,0x3e,0x3e,0xfe,0xfe,
+  0xfc,0xfc,0xfc,0xfc,0xf8,0xf8,0xe0,0xe0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,0xe0,0xfc,0xfc,
+  0xff,0xff,0x7f,0x7f,0x3f,0x3f,0x0e,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0e,0x0e,0x7e,0x7e,
+  0xfe,0xfe,0xfc,0xfc,0xf8,0xf8,0xe0,0xe0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0xf0,
+  0xff,0xff,0xff,0xff,0x7f,0x7f,0x1e,0x1e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1e,0x1e,
+  0xfe,0xfe,0xfe,0xfe,0xfc,0xfc,0xf0,0xf0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x0f,0x0f,0xff,0xff,0xff,0xff,0x7f,0x7f,0x1e,0x1e,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0xe0,0xe0,0xfe,0xfe,0xfe,0xfe,0xfc,0xfc,0xf0,0xf0,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x03,0x03,0x0f,0x0f,0x7f,0x7f,0xff,0xff,0x7e,0x7e,0x1c,0x1c,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x80,0x80,0xe0,0xe0,0xfc,0xfc,0xfe,0xfe,0xfc,0xfc,0x70,0x70,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x01,0x01,0x03,0x03,0x0f,0x0f,0x1f,0x1f,0x7f,0x7f,0x7e,0x7e,0x3c,0x3c,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x80,0x80,0xe0,0xe0,0xf0,0xf0,0xfc,0xfc,0xfc,0xfc,0x78,0x78,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x01,0x01,0x03,0x03,0x07,0x07,0x07,0x07,0x0f,0x0f,0x1f,0x1f,0x0e,0x0e,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x80,0x80,0xc0,0xc0,0xc0,0xc0,0xe0,0xe0,0xf0,0xf0,0xe0,0xe0,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x01,0x01,0x01,0x01,0x03,0x03,0x03,0x03,0x03,0x03,0x07,0x07,0x02,0x02,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x80,0x80,0x80,0x80,0x80,0x80,0xc0,0xc0,0x80,0x80,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x04,0x12,0x12,
+  0x08,0x08,0x00,0x00,0x30,0x30,0x00,0x00,0x08,0x08,0x10,0x10,0x02,0x02,0x04,0x04,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x40,0x80,0x80,
+  0x10,0x10,0x20,0x20,0x00,0x00,0x18,0x18,0x00,0x00,0x20,0x20,0x90,0x90,0x40,0x40,
+  0x00,0x00,0x03,0x03,0x0f,0x0f,0x1f,0x1f,0x3f,0x39,0x3f,0x30,0x3c,0x33,0x7c,0x73,
+  0x7f,0x79,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x6e,0x6e,0x46,0x46,0x00,0x00,
+  0x00,0x00,0xc0,0xc0,0xf0,0xf0,0xf8,0xf8,0xfc,0xe4,0xfc,0xc0,0xf0,0xcc,0xf2,0xce,
+  0xfe,0xe6,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0x76,0x76,0x62,0x62,0x00,0x00,
+  0x00,0x00,0x03,0x03,0x0f,0x0f,0x1f,0x1f,0x3f,0x39,0x3f,0x30,0x3c,0x33,0x7c,0x73,
+  0x7f,0x79,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7b,0x7b,0x31,0x31,0x00,0x00,
+  0x00,0x00,0xc0,0xc0,0xf0,0xf0,0xf8,0xf8,0xfc,0xe4,0xfc,0xc0,0xf0,0xcc,0xf2,0xce,
+  0xfe,0xe6,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xde,0xde,0x8c,0x8c,0x00,0x00,
+  0x00,0x00,0x03,0x03,0x0f,0x0f,0x1f,0x1f,0x3f,0x3f,0x3f,0x3f,0x3f,0x39,0x7f,0x79,
+  0x7f,0x7f,0x7f,0x7f,0x7f,0x66,0x7f,0x59,0x7f,0x7f,0x6e,0x6e,0x46,0x46,0x00,0x00,
+  0x00,0x00,0xc0,0xc0,0xf0,0xf0,0xf8,0xf8,0xfc,0xfc,0xfc,0xfc,0xfc,0x9c,0xfe,0x9e,
+  0xfe,0xfe,0xfe,0xfe,0xfe,0x66,0xfe,0x9a,0xfe,0xfe,0x76,0x76,0x62,0x62,0x00,0x00,
+  0x00,0x00,0x03,0x03,0x0f,0x0f,0x1f,0x1f,0x3f,0x3f,0x3f,0x3f,0x3f,0x39,0x7f,0x79,
+  0x7f,0x7f,0x7f,0x7f,0x7f,0x66,0x7f,0x59,0x7f,0x7f,0x7b,0x7b,0x31,0x31,0x00,0x00,
+  0x00,0x00,0xc0,0xc0,0xf0,0xf0,0xf8,0xf8,0xfc,0xfc,0xfc,0xfc,0xfc,0x9c,0xfe,0x9e,
+  0xfe,0xfe,0xfe,0xfe,0xfe,0x66,0xfe,0x9a,0xfe,0xfe,0xde,0xde,0x8c,0x8c,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x0f,0x00,0x0c,0x00,0x0c,0x00,
+  0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x00,0x3c,0x00,0x30,0x00,0x30,0x00,
+  0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+};
+
+byte rand8(void) {
+  rnd = rnd * 17 + 53;
+  return (byte)(rnd >> 8);
+}
+
+byte abs_diff(byte a, byte b) {
+  return (a > b) ? (byte)(a - b) : (byte)(b - a);
+}
+
+byte glyph(char c) {
+  if (c == ' ') return 0;
+  if (c >= '0' && c <= '9') return (byte)(1 + (c - '0'));
+  switch (c) {
+    case 'A': return 11; case 'C': return 12; case 'E': return 13;
+    case 'F': return 14; case 'G': return 15; case 'H': return 16;
+    case 'I': return 17; case 'K': return 18; case 'L': return 19;
+    case 'M': return 20; case 'N': return 21; case 'O': return 22;
+    case 'P': return 23; case 'R': return 24; case 'S': return 25;
+    case 'T': return 26; case 'U': return 27; case 'V': return 28;
+    case 'W': return 29; case 'X': return 30; case 'D': return 31;
+    case '-': return 32; case '!': return 33; case '/': return 34;
+    default: return 0;
+  }
+}
+
+void put_str(byte x, byte y, const char* s) {
+  while (*s) set_bkg_tile_xy(x++, y, glyph(*s++));
+}
+
+void put_digit(byte x, byte y, byte d) {
+  set_bkg_tile_xy(x, y, (byte)(1 + (d % 10)));
+}
+
+void clrscr(void) {
+  byte x, y;
+  for (y = 0; y < 32; y++)
+    for (x = 0; x < 32; x++)
+      set_bkg_tile_xy(x, y, 0);
+}
+
+void hide_all_sprites(void) {
+  byte i;
+  for (i = 0; i < 40; i++) move_sprite(i, 0, 0);
+}
+
+void read_controls(void) {
+  byte j = joypad();
+  joy_left = (j & J_LEFT) != 0;
+  joy_right = (j & J_RIGHT) != 0;
+  joy_fire = (j & J_A) != 0;
+  joy_start = (j & J_START) != 0;
+}
+
+void psg_init(void) {
+  NR52_REG = 0x80;
+  NR50_REG = 0x77;
+  NR51_REG = 0xFF;
+  NR10_REG = 0x00;
+}
+
+void sfx_off(void) {
+  sfx_timer = 0;
+  sfx_kind = 0;
+  NR12_REG = 0x00;
+  NR14_REG = 0x80;
+  NR22_REG = 0x00;
+  NR24_REG = 0x80;
+}
+
+void beep(word per, byte vol, byte len) {
+  /* ch1 one-shot */
+  NR10_REG = 0x00;
+  NR11_REG = 0x80;
+  NR12_REG = (byte)((vol << 4) | 0x01);
+  NR13_REG = (byte)(per & 0xff);
+  NR14_REG = (byte)(0x80 | ((per >> 8) & 0x07));
+  sfx_timer = len;
+}
+
+void play_sfx(byte id) {
+  sfx_kind = id;
+  if (id == 4) death_phase = 0;
+  switch (id) {
+  case 1: beep(0x6C0, 10, 3); break;   /* waka hi */
+  case 2: beep(0x650, 9, 3); break;    /* waka lo */
+  case 3: beep(0x700, 12, 12); break;  /* eat ghost */
+  case 4: beep(0x480, 12, 40); break;  /* death */
+  case 6: beep(0x720, 11, 8); break;   /* power */
+  default: sfx_off(); break;
+  }
+}
+
+void tick_sfx(void) {
+  if (!sfx_timer) return;
+  --sfx_timer;
+  if (!sfx_timer && sfx_kind == 4) {
+    death_phase++;
+    if (death_phase < 4) {
+      beep((word)(0x480 - death_phase * 0x40), 10, 10);
+      sfx_kind = 4;
+    } else {
+      death_phase = 0;
+      sfx_kind = 0;
+    }
+  }
+}
+
+void wait_vblank(void) {
+  wait_vbl_done();
+  tick_sfx();
+}
+
+void wait_frames(byte n) {
+  while (n--) wait_vblank();
+}
+
+void wait_for_button(void) {
+  read_controls();
+  while (!joy_fire && !joy_start) { wait_vblank(); read_controls(); }
+  while (joy_fire || joy_start) { wait_vblank(); read_controls(); }
+}
+
+void draw_hud(void) {
+  put_str(0, 0, "PAKU PAKU");
+  put_str(0, 1, "SCORE");
+  put_digit(6, 1, (byte)((score / 1000) % 10));
+  put_digit(7, 1, (byte)((score / 100) % 10));
+  put_digit(8, 1, (byte)((score / 10) % 10));
+  put_digit(9, 1, (byte)(score % 10));
+  put_str(12, 1, "X");
+  put_digit(13, 1, multiplier > 9 ? 9 : multiplier);
+  put_str(0, 17, "A=TURN");
+}
+
+void draw_corridor(void) {
+  byte x;
+  for (x = 0; x < 20; x++) {
+    set_bkg_tile_xy(x, ROW_ABOVE, T_WALL_ABOVE);
+    set_bkg_tile_xy(x, DOT_TILE_Y, 0);
+    set_bkg_tile_xy(x, ROW_BELOW, T_WALL_BELOW);
+  }
+}
+
+void add_dots(void) {
+  byte i, pi;
+  pi = (player_x > 80) ? (byte)(1 + (rand8() % 7)) : (byte)(10 + (rand8() % 7));
+  for (i = 0; i < NUM_DOTS; i++) {
+    dots[i].tx = (byte)(i + 1);
+    dots[i].active = 1;
+    dots[i].is_power = (i == pi);
+  }
+  if (multiplier < 99) multiplier++;
+}
+
+void draw_dots(void) {
+  byte i;
+  for (i = 0; i < NUM_DOTS; i++) {
+    if (!dots[i].active) {
+      set_bkg_tile_xy(dots[i].tx, DOT_TILE_Y, 0);
+      continue;
+    }
+    if (dots[i].is_power) {
+      if ((anim_ticks >> 3) & 1)
+        set_bkg_tile_xy(dots[i].tx, DOT_TILE_Y, T_POWER);
+      else
+        set_bkg_tile_xy(dots[i].tx, DOT_TILE_Y, 0);
+    } else {
+      set_bkg_tile_xy(dots[i].tx, DOT_TILE_Y, T_DOT);
+    }
+  }
+}
+
+void collect_dots(void) {
+  byte i, ptx;
+  ptx = (byte)((player_x + 8) >> 3);
+  if (ptx < 1) ptx = 1;
+  if (ptx > NUM_DOTS) ptx = NUM_DOTS;
+  for (i = 0; i < NUM_DOTS; i++) {
+    if (!dots[i].active) continue;
+    if (dots[i].tx != ptx) continue;
+    dots[i].active = 0;
+    set_bkg_tile_xy(dots[i].tx, DOT_TILE_Y, 0);
+    if (dots[i].is_power) {
+      play_sfx(6);
+      if (!enemy_eye_vx) power_ticks = 200;
+    } else {
+      waka ^= 1;
+      play_sfx(waka ? 1 : 2);
+    }
+    score += multiplier;
+  }
+}
+
+byte dots_left(void) {
+  byte i, n = 0;
+  for (i = 0; i < NUM_DOTS; i++)
+    if (dots[i].active) n++;
+  return n;
+}
+
+byte pac_frame(void) {
+  byte ai = (byte)(anim_ticks & 3);
+  if (ai == 0) return SP_OPEN;
+  if (ai == 1) return SP_MID;
+  if (ai == 2) return SP_CLOSED;
+  return SP_MID;
+}
+
+void put_actor16(byte i0, byte frame, byte flip, byte prop, byte x, byte y) {
+  /* Two 8×16 sprites = one 16×16 arcade sprite; swap halves when flipped. */
+  byte i1 = (byte)(i0 + 1);
+  byte p = prop;
+  byte oam0, oam1;
+  if (flip) p |= S_FLIPX;
+  set_sprite_tile(i0, frame);
+  set_sprite_tile(i1, (byte)(frame + 2));
+  set_sprite_prop(i0, p);
+  set_sprite_prop(i1, p);
+  if (flip) {
+    oam0 = (byte)(x + 16);
+    oam1 = (byte)(x + 8);
+  } else {
+    oam0 = (byte)(x + 8);
+    oam1 = (byte)(x + 16);
+  }
+  /* Hide if past the right edge (OAM X wraps). */
+  if (x > 152) {
+    move_sprite(i0, 0, 0);
+    move_sprite(i1, 0, 0);
+    return;
+  }
+  move_sprite(i0, oam0, (byte)(y + 16));
+  move_sprite(i1, oam1, (byte)(y + 16));
+}
+
+void draw_actors(void) {
+  byte ghost, gprop, pflip, gflip;
+  sbyte evx;
+
+  pflip = (player_vx < 0) ? 1 : 0;
+  put_actor16(0, pac_frame(), pflip, 0, player_x, CORRIDOR_Y);
+
+  if (enemy_eye_vx) {
+    ghost = SP_EYES;
+    gflip = (enemy_eye_vx < 0) ? 1 : 0;
+    gprop = 0;
+  } else if (power_ticks) {
+    ghost = ((anim_ticks >> 1) & 1) ? SP_SCARED1 : SP_SCARED0;
+    gflip = 0;
+    gprop = 0;
+    /* blink near end of power */
+    if (power_ticks < 60 && (anim_ticks & 0x08)) {
+      move_sprite(2, 0, 0);
+      move_sprite(3, 0, 0);
+      return;
+    }
+  } else {
+    ghost = ((anim_ticks >> 1) & 1) ? SP_GHOST1 : SP_GHOST0;
+    evx = (player_x > enemy_x) ? 1 : -1;
+    gflip = (evx < 0) ? 1 : 0;
+    gprop = 0;
+  }
+  put_actor16(2, ghost, gflip, gprop, enemy_x, CORRIDOR_Y);
+}
+
+void title_screen(void) {
+  byte x;
+  clrscr();
+  hide_all_sprites();
+  move_bkg(0, 0);
+  /* corridor stripe behind the demo sprites */
+  for (x = 0; x < 20; x++) {
+    set_bkg_tile_xy(x, 6, T_WALL_ABOVE);
+    set_bkg_tile_xy(x, 7, 0);
+    set_bkg_tile_xy(x, 8, T_WALL_BELOW);
+  }
+  put_str(5, 2, "PAKU PAKU");
+  put_actor16(0, SP_OPEN, 0, 0, 52, 48);
+  put_actor16(2, SP_GHOST0, 0, 0, 92, 48);
+  put_str(4, 11, "A TO TURN");
+  put_str(2, 13, "EAT DOTS  EAT GHOST");
+  put_str(4, 16, "PRESS START");
+  wait_for_button();
+  sfx_off();
+}
+
+void show_game_over(void) {
+  byte frame_i, t, frame;
+  hide_all_sprites();
+  put_actor16(0, SP_OPEN, 0, 0, player_x, CORRIDOR_Y);
+  play_sfx(4);
+  /* Arcade: 11 frames × 8 vblanks */
+  for (frame_i = 0; frame_i < SP_DEATH_N; frame_i++) {
+    frame = (byte)(SP_DEATH0 + (byte)(frame_i * 4));
+    for (t = 0; t < 8; t++) {
+      put_actor16(0, frame, 0, 0, player_x, CORRIDOR_Y);
+      wait_vblank();
+      read_controls();
+      if (joy_fire || joy_start) goto death_done;
+    }
+  }
+death_done:
+  hide_all_sprites();
+  put_str(5, 7, "GAME OVER");
+  put_str(4, 10, "PRESS START");
+  wait_for_button();
+  sfx_off();
+}
+
+void reset_round(void) {
+  player_x = 48;
+  player_vx = 1;
+  enemy_x = 128;
+  enemy_eye_vx = 0;
+  power_ticks = 0;
+  anim_ticks = 0;
+  btn_prev = 1;
+  game_over = 0;
+  waka = 0;
+  sfx_off();
+  draw_corridor();
+  add_dots();
+}
+
+void game_loop(void) {
+  byte btn;
+  sbyte evx;
+  byte espd;
+
+  clrscr();
+  hide_all_sprites();
+  move_bkg(0, 0);
+  draw_corridor();
+  draw_hud();
+  reset_round();
+
+  while (!game_over) {
+    wait_vblank();
+    anim_ticks++;
+    read_controls();
+
+    btn = (joy_fire || joy_start) ? 1 : 0;
+    if (btn && !btn_prev) player_vx = (sbyte)-player_vx;
+    btn_prev = btn;
+    if (joy_left) player_vx = -1;
+    if (joy_right) player_vx = 1;
+
+    /* Same wrap as pacman pakupaku.c */
+    player_x = (byte)(player_x + player_vx * PLAYER_SPD);
+    if (player_x < 4) player_x = FIELD_MAX;
+    else if (player_x > FIELD_MAX) player_x = 4;
+
+    collect_dots();
+    if (!dots_left()) add_dots();
+
+    /* Ghost AI — identical rules to presets/pacman/pakupaku.c */
+    if (enemy_eye_vx) {
+      evx = enemy_eye_vx;
+      espd = 3;
+    } else if (power_ticks) {
+      evx = (player_x > enemy_x) ? (sbyte)-1 : 1;
+      espd = 1;
+    } else {
+      evx = (player_x > enemy_x) ? 1 : -1;
+      espd = 2;
+    }
+    if (evx > 0) {
+      if (enemy_x < FIELD_MAX - 2) enemy_x = (byte)(enemy_x + espd);
+      else if (enemy_eye_vx) enemy_eye_vx = 0;
+    } else {
+      if (enemy_x > 6) enemy_x = (byte)(enemy_x - espd);
+      else if (enemy_eye_vx) enemy_eye_vx = 0;
+    }
+
+    if (!enemy_eye_vx && abs_diff(player_x, enemy_x) < HIT_DIST) {
+      if (power_ticks) {
+        play_sfx(3);
+        score += (word)(10 * (multiplier ? multiplier : 1));
+        enemy_eye_vx = (player_x > 80) ? (sbyte)-1 : 1;
+        power_ticks = 0;
+        if (multiplier < 99) multiplier++;
+      } else {
+        game_over = 1;
+      }
+    }
+
+    if (power_ticks) power_ticks--;
+
+    draw_dots();
+    draw_hud();
+    draw_actors();
+  }
+}
+
+void setup_graphics(void) {
+  DISPLAY_OFF;
+  set_bkg_1bpp_data(0, 35, font_1bpp);
+  set_bkg_data(BKG_BASE, 4, bkg_tiles);
+  set_sprite_data(SPR_BASE, SPR_TILE_COUNT, sprite_tiles);
+  SPRITES_8x16;
+  BGP_REG = 0xE4;
+  OBP0_REG = 0xE4;
+  OBP1_REG = 0xE4;
+  psg_init();
+  HIDE_WIN;
+  SHOW_BKG;
+  SHOW_SPRITES;
+  DISPLAY_ON;
+}
+
+void main(void) {
+  setup_graphics();
+  score = 0;
+  multiplier = 0;
+  while (1) {
+    title_screen();
+    score = 0;
+    multiplier = 0;
+    game_loop();
+    show_game_over();
+  }
+}
diff --git a/presets/markdown/hello.md b/presets/markdown/hello.md
index 6a39a8c6..8a1589bd 100644
--- a/presets/markdown/hello.md
+++ b/presets/markdown/hello.md
@@ -79,7 +79,7 @@ of text
 If you DO want to add soft line breaks (which translate to `<br>` in HTML) to a paragraph, 
 you can do so by adding 3 space characters to the end of the line (`  `).
 
-You can also force every line break in paragraphs to translate to `<br>` (as Github does) by
+You can also force every line break in paragraphs to translate to `<br>` (as GitHub does) by
 enabling the option **`simpleLineBreaks`**.
 
 ## Headings
diff --git a/presets/vcs/skeleton.remote:llvm-mos b/presets/vcs/skeleton.llvm-mos
similarity index 100%
rename from presets/vcs/skeleton.remote:llvm-mos
rename to presets/vcs/skeleton.llvm-mos
diff --git a/presets/zmachine/cloak.dg b/presets/zmachine/cloak.dg
new file mode 100644
index 00000000..a73867b0
--- /dev/null
+++ b/presets/zmachine/cloak.dg
@@ -0,0 +1,195 @@
+(story title)  Cloak of Darkness
+(story author)  Linus Åkesson
+(story noun)  A port of Roger Firth's reference game
+
+(story ifid)
+    %% This is the IFID for the Dialog port of Cloak of Darkness:
+    A5AA4F02-8F50-4649-A4BD-B1B5C5408B67
+
+(story release 3)
+
+(scoring enabled)
+(maximum score 2)
+
+(library links enabled)
+(default actions enabled)
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+(intro)
+
+    Hurrying through the rainswept November night, you're glad to
+    see the bright lights of the Opera House. It's surprising that
+    there aren't more people about but, hey, what do you expect in
+    a cheap demo game...?
+
+    (banner)
+    (enter #foyer)
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+#foyer
+
+(room *)
+(singleton *)
+(name *)  foyer of the Opera House
+
+(look *)
+
+    (link [me]) {You} are standing in a spacious hall, splendidly
+    decorated in red and gold, with glittering chandeliers
+    overhead. The entrance from the street is to the (#north), and
+    there are doorways (#south) and (#west).
+
+(prevent [leave * #north])
+
+    You've only just arrived, and besides, the weather outside
+    seems to be getting worse.
+
+(from * go #west to #cloakroom)
+(from * go #south to #bar)
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+#cloakroom
+
+(room *)
+(singleton *)
+(name *)  cloakroom
+
+(look *)
+
+    The walls of this small room were clearly once lined with
+    hooks, though now (#hook { only one }) remains. The exit is a
+    door to the (#east).
+
+    (notice #hook)
+
+(from * go #east to #foyer)
+
+#hook
+
+(supporter *)
+(name *)  small brass hook
+(dict *)  peg
+(* is #in #cloakroom)
+
+(descr *)
+
+    It's just a small brass hook,
+    (collect $Obj) ($Obj is #on *) (into $List)
+    (if) (nonempty $List) (then)
+      with (a $List) hanging on it.
+    (else)
+      screwed to the wall.
+    (endif)
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+#bar
+
+(room *)
+(singleton *)
+(name *)  Foyer Bar
+(look *)
+
+    The bar, much rougher than you'd have guessed after the
+    opulence of the foyer to the north, is completely empty. There
+    seems to be some sort of (#message {message}) scrawled in the
+    sawdust on the floor.
+
+    (notice #message)
+
+(from * go #north to #foyer)
+
+(inherently dark *)
+    (#cloak is in room *)
+
+(instead of [look #down])
+    (current room *)
+    (try [examine #message])
+
+#message
+
+(name *)  scrawled message
+(dict *)  floor sawdust
+(* is #in #bar)
+
+(descr *)
+    (if) (message has been trampled) (then)
+      The message has been carelessly trampled, making it
+      difficult to read. You can just distinguish the
+      words...
+      (par)
+      (game over { You have lost })
+    (else)
+      (increase score by 1)
+      The message, neatly marked in the sawdust, reads...
+      (par)
+      (game over { You have won })
+    (endif)
+
+~(warned the player about darkness)
+
+(prevent $Action)
+    (current room #bar)
+    ~(player can see)
+    ~(command $Action)
+    ($Action = [$Verb | $])
+    ~($Verb is one of [go leave enter look])
+    (if) (warned the player about darkness) (then)
+      Blundering around in the dark isn't a good idea!
+      (now) (message has been trampled)
+    (else)
+      In the dark? You could easily disturb something.
+      (now) (warned the player about darkness)
+    (endif)
+
+(instead of [read *])
+    (try [examine *])
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+#player
+
+(current player *)
+(* is #in #foyer)
+
+(instead of [examine *])
+  (try [inventory])
+
+#cloak
+
+(name *)  velvet cloak
+(dict *)  dark black satin
+(wearable *)
+(* is #wornby #player)
+
+(descr *)
+
+    A handsome cloak, of velvet trimmed with satin, and slightly
+    splattered with raindrops. Its blackness is so deep that it
+    almost seems to suck light from the room.
+
+(prevent [drop *])
+    (when dropping outside cloakroom)
+
+(prevent [put * $ $])
+    (when dropping outside cloakroom)
+
+(when dropping outside cloakroom)
+    ~(current room #cloakroom)
+    This isn't the best place to leave a smart cloak lying around.
+
+(perform [put * #on #hook])
+    ~(hook point awarded)
+    (increase score by 1)
+    (now) (hook point awarded)
+    (fail) %% Fall back on default behaviour now.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+(understand [hang | $Words] as [put $Obj #on $Dest])
+    *(split $Words by [on] into $Left and $Right)
+    *(understand $Left as object $Obj preferably held)
+    *(understand $Right as single object $Dest)
diff --git a/presets/zmachine/hello.dg b/presets/zmachine/hello.dg
new file mode 100644
index 00000000..7f027451
--- /dev/null
+++ b/presets/zmachine/hello.dg
@@ -0,0 +1,48 @@
+%% Hello World, in the Dialog interactive fiction language.
+%% https://linusakesson.net/dialog/docs/
+
+%% Story metadata
+(story title)	Hello World
+(story author)	8bitworkshop
+(story noun)	A one-room Dialog demo
+
+%% (intro) runs when the game starts.
+(intro)
+  Welcome to Dialog! Try LOOK, EXAMINE ME, or TURN ON LAMP.
+  (par)
+  (banner)
+  (enter #room)
+
+%% Define an object: the player character.
+%% The * token refers to the last object
+%% labelled on the left margin (the current "topic")
+#player
+(current player *)
+(descr *)	You look marvelous.
+
+%% The only room (for now).
+#room
+(room *)
+(name *)	small room
+(look *)
+  This is a small, featureless room.
+
+%% An object the player can pick up.
+#lamp
+(item *)
+(name *)	brass lamp
+(dict *)	lantern
+(initial appearance *)
+  A brass lamp sits on the floor.
+(descr *)
+  (* is on)
+  It is a battered brass lamp, switched on.
+(descr *)
+  It is a battered brass lamp, currently off.
+
+(* is #in #room)
+(switchable *)
+
+%% A rule: The lamp provides light when it is turned on.
+(* provides light)
+  (* is on)
diff --git a/src/common/baseplatform.ts b/src/common/baseplatform.ts
index 52d19178..37cbc5dc 100644
--- a/src/common/baseplatform.ts
+++ b/src/common/baseplatform.ts
@@ -441,6 +441,7 @@ export function getToolForFilename_6502(fn: string): string {
   if (fn.endsWith(".ca65")) return "ca65";
   if (fn.endsWith(".dasm")) return "dasm";
   if (fn.endsWith(".acme")) return "acme";
+  if (fn.endsWith(".xa")) return "xa";
   if (fn.endsWith(".wiz")) return "wiz";
   if (fn.endsWith(".ecs")) return "ecs";
   if (fn.endsWith(".cpp")) return "oscar64";
@@ -480,7 +481,7 @@ export abstract class Base6502Platform extends BaseDebugPlatform {
     return disassemble6502(pc, read(pc), read(pc + 1), read(pc + 2));
   }
   getToolForFilename = getToolForFilename_6502;
-  getDefaultExtensions() { return [".c", ".cpp", ".acme", ".ca65", ".dasm", ".ecs", ".wiz"]; };
+  getDefaultExtensions() { return [".c", ".cpp", ".acme", ".xa", ".ca65", ".dasm", ".ecs", ".wiz"]; };
 
   getDebugCategories() {
     return ['CPU', 'ZPRAM', 'Stack'];
@@ -984,7 +985,7 @@ export abstract class Base6502MachinePlatform<T extends Machine> extends BaseMac
 
   getOpcodeMetadata = getOpcodeMetadata_6502;
   getToolForFilename(fn) { return getToolForFilename_6502(fn); }
-  getDefaultExtensions() { return [".c", ".cpp", ".acme", ".ca65", ".dasm", ".ecs", ".wiz"]; }
+  getDefaultExtensions() { return [".c", ".cpp", ".acme", ".xa", ".ca65", ".dasm", ".ecs", ".wiz"]; }
 
   disassemble(pc: number, read: (addr: number) => number): DisasmLine {
     return disassemble6502(pc, read(pc), read(pc + 1), read(pc + 2));
diff --git a/src/common/gbpalette.ts b/src/common/gbpalette.ts
new file mode 100644
index 00000000..88fa3814
--- /dev/null
+++ b/src/common/gbpalette.ts
@@ -0,0 +1,43 @@
+/**
+ * Shared Game Boy DMG (olive LCD) palette.
+ *
+ * Shade 0 = lightest (LCD pixel off / "white"), shade 3 = darkest (pixel on).
+ * Values are packed for Canvas ImageData as Uint32 little-endian RGBA (= 0xAABBGGRR).
+ */
+
+export function rgbToPixel(r: number, g: number, b: number): number {
+  return 0xFF000000 | ((b & 0xff) << 16) | ((g & 0xff) << 8) | (r & 0xff);
+}
+
+/** Four DMG shades, lightest → darkest (matches BGP/OBP shade indices). */
+export const DMG_PALETTE: number[] = [
+  rgbToPixel(0xd0, 0xd8, 0x84), // Lightest (warm mint)
+  rgbToPixel(0x87, 0xa8, 0x4c), // Light mid
+  rgbToPixel(0x52, 0x6b, 0x34), // Dark mid
+  rgbToPixel(0x2d, 0x31, 0x22), // Darkest (deep olive)
+];
+
+/** RGB888 triples matching DMG_PALETTE (for boytacean remap / tooling). */
+export const DMG_PALETTE_RGB: [number, number, number][] = [
+  [0xd0, 0xd8, 0x84],
+  [0x87, 0xa8, 0x4c],
+  [0x52, 0x6b, 0x34],
+  [0x2d, 0x31, 0x22],
+];
+
+/** Asset-editor / PREDEF_PALETTES entries (RGB without alpha; callers OR 0xff000000). */
+export const DMG_PALETTE_RGB24: number[] = [
+  0xd0d884,
+  0x87a84c,
+  0x526b34,
+  0x2d3122,
+];
+
+/** Map a greyscale / near-grey RGB888 pixel to a DMG shade (0=light … 3=dark). */
+export function dmgShadeFromRgb(r: number, g: number, b: number): number {
+  var y = (r + g + b) / 3;
+  if (y >= 192) return 0;
+  if (y >= 128) return 1;
+  if (y >= 64) return 2;
+  return 3;
+}
diff --git a/src/common/wasi/wasishim.ts b/src/common/wasi/wasishim.ts
index 8d61b9c2..df59a5bc 100644
--- a/src/common/wasi/wasishim.ts
+++ b/src/common/wasi/wasishim.ts
@@ -624,6 +624,17 @@ export class WASIRunner {
         const fd = this.fs.getFile(path);
         console.log("path_filestat_get", dir+"", filename, path, filestat_ptr, '->', fd+"");
         if (!fd) return WASIErrors.NOENT;
+        this.poke_filestat(filestat_ptr, fd);
+        return WASIErrors.SUCCESS;
+    }
+    fd_filestat_get(fd: number, filestat_ptr: number) {
+        const file = this.fds[fd];
+        debug("fd_filestat_get", fd, filestat_ptr, file + "");
+        if (file == null) return WASIErrors.BADF;
+        this.poke_filestat(filestat_ptr, file);
+        return WASIErrors.SUCCESS;
+    }
+    poke_filestat(filestat_ptr: number, fd: WASIFileDescriptor) {
         this.poke64(filestat_ptr, fd.fdindex); // dev
         this.poke64(filestat_ptr + 8, 0); // ino
         this.poke8(filestat_ptr + 16, fd.type); // filetype
@@ -686,6 +697,7 @@ export class WASIRunner {
             fd_seek: this.fd_seek.bind(this),
             fd_close: this.fd_close.bind(this),
             path_filestat_get: this.path_filestat_get.bind(this),
+            fd_filestat_get: this.fd_filestat_get.bind(this),
             random_get: this.random_get.bind(this),
             path_readlink: this.path_readlink.bind(this),
             path_unlink_file: this.path_unlink_file.bind(this),
diff --git a/src/ide/pixeleditor.ts b/src/ide/pixeleditor.ts
index 11085a10..4c1a600d 100644
--- a/src/ide/pixeleditor.ts
+++ b/src/ide/pixeleditor.ts
@@ -18,7 +18,7 @@ export interface EditorContext {
 }
 
 export type SelectablePalette = {
-  node: PixNode
+  node: PixNode | null
   name: string
   palette: Uint32Array
 }
@@ -238,7 +238,11 @@ export function validateAssetData(datastr: string, fmt): string | null {
         maxOffset = Math.max(maxOffset, offset);
       }
     }
-    var required = maxOffset + (nplanes > 1 ? (nplanes - 1) * pofs : 0) + 1 + skip;
+    // Planar formats (e.g. NES pofs>=wpimg) store extra planes past each image block.
+    // Interleaved formats (GB/SMS pofs < wpimg) already include plane bytes in maxOffset.
+    var planeExtent = (nplanes > 1) ? (nplanes - 1) * pofs : 0;
+    if (planeExtent < wpimg) planeExtent = 0;
+    var required = maxOffset + planeExtent + 1 + skip;
 
     if (words.length != required) {
       return `Expected ${required} value(s), found ${words.length}`;
@@ -358,6 +362,10 @@ export function convertPaletteFormat(palbytes: UintArray, palfmt: PixelEditorPal
 
 // TODO: illegal colors?
 const PREDEF_PALETTES = {
+  // LCD polarity: index 0 = lightest (pixel off), 3 = darkest (pixel on)
+  'gb': [
+    0xd0d884, 0x87a84c, 0x526b34, 0x2d3122,
+  ],
   'nes': [
     0x525252, 0xB40000, 0xA00000, 0xB1003D, 0x740069, 0x00005B, 0x00005F, 0x001840, 0x002F10, 0x084A08, 0x006700, 0x124200, 0x6D2800, 0x000000, 0x000000, 0x000000,
     0xC4D5E7, 0xFF4000, 0xDC0E22, 0xFF476B, 0xD7009F, 0x680AD7, 0x0019BC, 0x0054B1, 0x006A5B, 0x008C03, 0x00AB00, 0x2C8800, 0xA47200, 0x000000, 0x000000, 0x000000,
diff --git a/src/ide/project.ts b/src/ide/project.ts
index c40c1376..8ad874b6 100644
--- a/src/ide/project.ts
+++ b/src/ide/project.ts
@@ -42,7 +42,7 @@ export class NullFilesystem implements ProjectFilesystem {
     this.sets.push(path);
     return;
   }
-  
+
 }
 
 export class OverlayFilesystem implements ProjectFilesystem {
@@ -222,6 +222,13 @@ export class CodeProject {
       while (m = re7.exec(text)) {
         this.pushAllFiles(files, m[1]);
       }
+      // for dialog -- %% #include "file" (dialog has no include directive,
+      // so the compiler is handed every file listed in a comment instead)
+      let re8 = /^\s*%%\s*#include\s+"(.+?)"/gm;
+      while (m = re8.exec(text)) {
+        this.pushAllFiles(files, m[1]);
+      }
+      // TODO: for xa assembler
     }
     return files;
   }
@@ -240,7 +247,7 @@ export class CodeProject {
     }
     return files;
   }
-  
+
   loadFileDependencies(text:string) : Promise<Dependency[]> {
     let includes = this.parseIncludeDependencies(text);
     let linkfiles = this.parseLinkDependencies(text);
@@ -442,7 +449,7 @@ export class CodeProject {
       }
     }
   }
-  
+
   stripLocalPath(path : string) : string {
     if (this.mainPath) {
       var folder = getFolderForPath(this.mainPath);
diff --git a/src/ide/services.ts b/src/ide/services.ts
index 236bada8..e4d48330 100644
--- a/src/ide/services.ts
+++ b/src/ide/services.ts
@@ -200,39 +200,39 @@ export class GithubService {
       // load README
       return sess.repo.contents('README.md').read();
     })
-    .catch( (e) => {
-      console.log(e);
-      console.log('no README.md found')
-      // make user repo exists
-      return sess.repo.fetch().then( (_repo) => {
-        return ''; // empty README
+      .catch((e) => {
+        console.log(e);
+        console.log('no README.md found')
+        // make user repo exists
+        return sess.repo.fetch().then((_repo) => {
+          return ''; // empty README
+        })
       })
-    })
-    .then( (readme) => {
-      var m;
-      // check README for main file
-      const re8main = /8bitworkshop.com[^)]+file=([^)&]+)/;
-      m = re8main.exec(readme);
-      if (m && m[1]) {
-        console.log("main path: '" + m[1] + "'");
-        sess.mainPath = m[1];
-      }
-      // check README for proper platform
-      // unless we use githubURL=
-      // TODO: cannot handle multiple URLs in README
-      const re8plat = /8bitworkshop.com[^)]+platform=([A-Za-z0-9._\-]+)/;
-      m = re8plat.exec(readme);
-      if (m) {
-        console.log("platform id: '" + m[1] + "'");
-        if (sess.platform_id && !sess.platform_id.startsWith(m[1]))
-          throw Error("Platform mismatch: Repository is " + m[1] + ", you have " + sess.platform_id + " selected.");
-        sess.platform_id = m[1];
-      }
-      // bind to repository
-      this.bind(sess, true);
-      // get head commit
-      return sess;
-    });
+      .then((readme) => {
+        var m;
+        // check README for main file
+        const re8main = /8bitworkshop.com[^)]+file=([^)&]+)/;
+        m = re8main.exec(readme);
+        if (m && m[1]) {
+          console.log("main path: '" + m[1] + "'");
+          sess.mainPath = m[1];
+        }
+        // check README for proper platform
+        // unless we use githubURL=
+        // TODO: cannot handle multiple URLs in README
+        const re8plat = /8bitworkshop.com[^)]+platform=([A-Za-z0-9._\-]+)/;
+        m = re8plat.exec(readme);
+        if (m) {
+          console.log("platform id: '" + m[1] + "'");
+          if (sess.platform_id && !sess.platform_id.startsWith(m[1]))
+            throw Error("Platform mismatch: Repository is '" + m[1] + "', you have '" + sess.platform_id + "' selected.");
+          sess.platform_id = m[1];
+        }
+        // bind to repository
+        this.bind(sess, true);
+        // get head commit
+        return sess;
+      });
   }
   
   pull(ghurl:string, deststore?) : Promise<GHSession> {
diff --git a/src/ide/sync.ts b/src/ide/sync.ts
index 136467c6..39905440 100644
--- a/src/ide/sync.ts
+++ b/src/ide/sync.ts
@@ -43,7 +43,7 @@ export async function importProjectFromGithub(githuburl: string, replaceURL: boo
     var sess: GHSession;
     var urlparse = parseGithubURL(githuburl);
     if (!urlparse) {
-        alertError('Could not parse Github URL.');
+        alertError('Could not parse GitHub URL.');
         return;
     }
     // redirect to repo if exists
@@ -70,14 +70,14 @@ export async function importProjectFromGithub(githuburl: string, replaceURL: boo
     }).catch((e) => {
         setWaitDialog(false);
         console.log(e);
-        alertError("Could not import " + githuburl + "." + e);
+        alertError("Could not import " + githuburl + ". " + e);
     });
 }
 
 export async function _loginToGithub(e) {
     var gh = await getGithubService();
     gh.login().then(() => {
-        alertInfo("You are signed in to Github.");
+        alertInfo("You are signed in to GitHub.");
     }).catch((e) => {
         alertError("Could not sign in." + e);
     });
@@ -86,7 +86,7 @@ export async function _loginToGithub(e) {
 export async function _logoutOfGithub(e) {
     var gh = await getGithubService();
     gh.logout().then(() => {
-        alertInfo("You are logged out of Github.");
+        alertInfo("You are logged out of GitHub.");
     });
 }
 
@@ -94,6 +94,10 @@ export function _importProjectFromGithub(e) {
     var modal = $("#importGithubModal");
     var btn = $("#importGithubButton");
     modal.modal('show');
+    modal.off('shown.bs.modal').on('shown.bs.modal', () => $("#importGithubURL").trigger('focus'));
+    $("#importGithubURL").off('keydown').on('keydown', (e) => {
+        if (e.key === 'Enter') { e.preventDefault(); btn.trigger('click'); }
+    });
     btn.off('click').on('click', () => {
         var githuburl = $("#importGithubURL").val() + "";
         modal.modal('hide');
@@ -103,7 +107,7 @@ export function _importProjectFromGithub(e) {
 
 export function _publishProjectToGithub(e) {
     if (repo_id) {
-        if (!confirm("This project (" + getCurrentProject().mainPath + ") is already bound to a Github repository. Do you want to re-publish to a new repository? (You can instead choose 'Push Changes' to update files in the existing repository.)"))
+        if (!confirm("This project (" + getCurrentProject().mainPath + ") is already bound to a GitHub repository. Do you want to re-publish to a new repository? (You can instead choose 'Push Changes' to update files in the existing repository.)"))
             return;
     }
     var modal = $("#publishGithubModal");
diff --git a/src/ide/ui.ts b/src/ide/ui.ts
index 86180954..aa51a131 100644
--- a/src/ide/ui.ts
+++ b/src/ide/ui.ts
@@ -113,6 +113,7 @@ export function getWorkerParams() {
 const TOOL_TO_SOURCE_STYLE = {
   'dasm': '6502',
   'acme': '6502',
+  'xa': '6502',
   'cc65': 'text/x-csrc',
   'ca65': '6502',
   'nesasm': '6502',
@@ -131,6 +132,7 @@ const TOOL_TO_SOURCE_STYLE = {
   'yasm': 'gas',
   'smlrc': 'text/x-csrc',
   'inform6': 'inform6',
+  'dialog': 'dialog',
   'fastbasic': 'fastbasic',
   'basic': 'basic',
   'silice': 'verilog',
@@ -160,6 +162,8 @@ const TOOL_TO_HELPURL = {
   'cmoc': "http://perso.b2b2c.ca/~sarrazip/dev/cmoc.html",
   'remote:llvm-mos': 'https://llvm-mos.org/wiki/Welcome',
   'acme': 'https://raw.githubusercontent.com/sehugg/acme/main/docs/QuickRef.txt',
+  'xa': 'https://www.floodgap.com/retrotech/xa/',
+  'dialog': 'https://linusakesson.net/dialog/docs/',
 }
 
 function newWorker(): Worker {
@@ -489,7 +493,7 @@ function reloadProject(id: string) {
 }
 
 async function getSkeletonFile(fileid: string): Promise<string> {
-  var ext = platform.getToolForFilename(fileid);
+  var ext = platform.getToolForFilename(fileid).replace(/^remote:/, "");
   try {
     return await $.get("presets/" + getBasePlatform(platform_id) + "/skeleton." + ext, 'text');
   } catch (e) {
@@ -1414,6 +1418,10 @@ function _addIncludeFile() {
     addFileToProject("Include", ".ecs", (s) => { return 'import "' + s + '"' });
   else if (tool == 'acme')
     addFileToProject("Include", ".acme", (s) => { return '!src "' + s + '"' });
+  else if (tool == 'xa')
+    addFileToProject("Include", ".xa", (s) => { return '#include "' + s + '"' });
+  else if (tool == 'dialog')
+    addFileToProject("Include", ".dg", (s) => { return '%% #include "' + s + '"' });
   else
     alertError("Can't add include file to this project type (" + tool + ")");
 }
diff --git a/src/ide/views/asseteditor.ts b/src/ide/views/asseteditor.ts
index 54d2f104..6ec659da 100644
--- a/src/ide/views/asseteditor.ts
+++ b/src/ide/views/asseteditor.ts
@@ -1,4 +1,5 @@
 
+import { DMG_PALETTE } from "../../common/gbpalette";
 import { hex, rgb2bgr, safeident } from "../../common/util";
 import { FileData } from "../../common/workertypes";
 import * as pixed from "../pixeleditor";
@@ -80,6 +81,18 @@ export class AssetEditorView implements ProjectView, pixed.EditorContext {
         node = node.right;
       }
     });
+    // Game Boy: default to LCD green scale (0=light … 3=dark) when no project palette
+    if (result.length == 0 && platform_id && platform_id.startsWith('gb')) {
+      if (matchlen == 4) {
+        result.push({ node: null, name: "DMG Green", palette: new Uint32Array(DMG_PALETTE) });
+      } else if (matchlen == 2) {
+        result.push({
+          node: null,
+          name: "DMG Green",
+          palette: new Uint32Array([DMG_PALETTE[0], DMG_PALETTE[3]]),
+        });
+      }
+    }
     return result;
   }
 
diff --git a/src/ide/views/editors.ts b/src/ide/views/editors.ts
index e08a9d33..73662178 100644
--- a/src/ide/views/editors.ts
+++ b/src/ide/views/editors.ts
@@ -11,6 +11,7 @@ import { SourceFile, SourceLocation, WorkerError } from "../../common/workertype
 import { asm6502 } from "../../parser/lang-6502";
 import { basic } from "../../parser/lang-basic";
 import { batariBasic } from "../../parser/lang-bataribasic";
+import { dialog } from "../../parser/lang-dialog";
 import { fastBasic } from "../../parser/lang-fastbasic";
 import { inform6 } from "../../parser/lang-inform6";
 import { verilog } from "../../parser/lang-verilog";
@@ -74,9 +75,10 @@ const MODEDEFS = {
   gas: { isAsm: true },
   vasm: { isAsm: true },
   inform6: { theme: cobalt },
+  dialog: { theme: cobalt, lineWrap: true },
   markdown: { lineWrap: true },
   fastbasic: { noGutters: true },
-  basic: { noLineNumbers: true, noGutters: true },
+  basic: { noGutters: true },
   ecs: { theme: mbo }, // TODO: is actually mixed-mode, as is verilog
 }
 
@@ -129,7 +131,7 @@ export class SourceEditor implements ProjectView {
     var isAsm = isAsmOverride || modedef.isAsm;
     var lineWrap = !!modedef.lineWrap;
     var theme = modedef.theme || MODEDEFS.default.theme;
-    var lineNums = !isAsm && !modedef.noLineNumbers && !isMobileDevice;
+    var lineNums = modedef.useLineNumbers && !isMobileDevice;
     if (qs['embed']) {
       lineNums = false; // no line numbers while embedded
       isAsm = false; // no opcode bytes either
@@ -150,6 +152,9 @@ export class SourceEditor implements ProjectView {
       case 'fastbasic':
         parser = fastBasic();
         break;
+      case 'dialog':
+        parser = dialog();
+        break;
       case 'inform6':
         parser = inform6();
         break;
@@ -546,8 +551,8 @@ export class SourceEditor implements ProjectView {
         effects: [
           currentPcMarker.set.of(line.line),
           currentPc.effect.of(line.line),
-          // Optional: follow the execution point
-          EditorView.scrollIntoView(this.editor.state.doc.line(line.line).from, { y: "center" }),
+          // Follow the execution point when stepping/hitting breakpoints.
+          ...(moveCursor ? [EditorView.scrollIntoView(this.editor.state.doc.line(line.line).from, { y: "center" })] : []),
         ]
       });
     }
diff --git a/src/machine/gb.ts b/src/machine/gb.ts
index 230055b1..7ade561c 100644
--- a/src/machine/gb.ts
+++ b/src/machine/gb.ts
@@ -2,16 +2,9 @@
 import { SM83, SM83State } from "../common/cpu/SM83";
 import { BasicScanlineMachine, Bus } from "../common/devices";
 import { newAddressDecoder, padBytes, Keys, makeKeycodeMap, newKeyboardHandler, EmuHalt } from "../common/emu";
+import { DMG_PALETTE } from "../common/gbpalette";
 import { hex } from "../common/util";
 
-// Game Boy DMG palette: 4 shades of green (darkest to lightest)
-const DMG_PALETTE: number[] = [
-  0xFFd0d884, // Lightest (Warm Mint)
-  0xFF87a84c, // Light Mid
-  0xFF526b34, // Dark Mid
-  0xFF2d3122, // Darkest (Deep Olive)
-];
-
 // Convert GBC 15-bit RGB (xBBBBBGGGGGRRRRR) to 32-bit ARGB
 function cgbColorToARGB(lo: number, hi: number): number {
   var r5 = lo & 0x1F;
diff --git a/src/parser/lang-dialog.ts b/src/parser/lang-dialog.ts
new file mode 100644
index 00000000..4188009e
--- /dev/null
+++ b/src/parser/lang-dialog.ts
@@ -0,0 +1,92 @@
+// CodeMirror 6 language support for Dialog
+// https://linusakesson.net/dialog/docs/
+
+import { StreamLanguage, StreamParser } from "@codemirror/language";
+import { LanguageSupport } from "@codemirror/language";
+
+interface DialogState {
+    // parens are only nested inside a rule head/query; column 0 starts a rule
+    depth: number;
+}
+
+// TODO: Migrate to CodeMirror 6 Lezer parser.
+function createDialogParser(): StreamParser<DialogState> {
+    // control keywords appear as the first word inside a parenthesis
+    const keywords = new Set([
+        "if", "then", "elseif", "else", "endif", "or", "select", "stopping",
+        "at random", "purely at random", "then purely at random", "cycling",
+        "collect", "into", "collect words", "determine object", "from words",
+        "matching all of", "stoppable", "stop", "just", "exhaust", "repeat forever",
+        "now", "global variable", "generate", "interface", "fail",
+    ]);
+
+    function token(stream: any, state: DialogState): string | null {
+        if (stream.eatSpace()) return null;
+        const ch = stream.peek();
+        // %% comment to end of line
+        if (stream.match("%%")) {
+            stream.skipToEnd();
+            return "comment";
+        }
+        // \( and \) are escaped literals inside text
+        if (stream.match(/\\./)) {
+            return "escape";
+        }
+        if (ch == "(" || ch == ")") {
+            stream.next();
+            state.depth += ch == "(" ? 1 : -1;
+            if (state.depth < 0) state.depth = 0;
+            return "bracket";
+        }
+        if (ch == "[" || ch == "]" || ch == "{" || ch == "}") {
+            stream.next();
+            return "bracket";
+        }
+        // $Variable, or $ for an anonymous variable
+        if (stream.match(/\$[a-zA-Z0-9_]*/)) {
+            return "variableName";
+        }
+        // #object name
+        if (stream.match(/#[a-zA-Z0-9_+-]+/)) {
+            return "atom";
+        }
+        // @style class
+        if (stream.match(/@[a-zA-Z0-9_-]+/)) {
+            return "className";
+        }
+        if (stream.match(/-?\d+\b/)) {
+            return "number";
+        }
+        // ~ negation, * multi-query, | list tail
+        if (stream.match(/[~*|]/)) {
+            return "operator";
+        }
+        // words: keywords only count at the start of a predicate
+        if (stream.match(/[^\s()\[\]{}$#@~*|\\%]+/)) {
+            if (state.depth > 0 && keywords.has(stream.current().toLowerCase())) {
+                return "keyword";
+            }
+            // text outside of parentheses is printed verbatim by the story
+            return state.depth > 0 ? null : "string";
+        }
+        stream.next();
+        return null;
+    }
+
+    return {
+        startState(): DialogState {
+            return { depth: 0 };
+        },
+        token,
+        languageData: {
+            commentTokens: { line: "%%" }
+        }
+    };
+}
+
+/**
+ * Language support for Dialog
+ */
+export function dialog(): LanguageSupport {
+    return new LanguageSupport(StreamLanguage.define(createDialogParser()));
+}
diff --git a/src/platform/apple2.ts b/src/platform/apple2.ts
index 0d79ff72..d57ac36a 100644
--- a/src/platform/apple2.ts
+++ b/src/platform/apple2.ts
@@ -49,7 +49,7 @@ class Apple2MAMEPlatform extends BaseMAME6502Platform implements Platform {
   }
 
   getOpcodeMetadata = getOpcodeMetadata_6502;
-  getDefaultExtensions() { return [".c", ".cpp", ".acme", ".ca65", ".dasm", ".ecs", ".wiz"]; }
+  getDefaultExtensions() { return [".c", ".cpp", ".acme", ".xa", ".ca65", ".dasm", ".ecs", ".wiz"]; }
   getToolForFilename = getToolForFilename_6502;
 
   getPresets() { return APPLE2_PRESETS; }
diff --git a/src/platform/atari8.ts b/src/platform/atari8.ts
index 516862e9..67274013 100644
--- a/src/platform/atari8.ts
+++ b/src/platform/atari8.ts
@@ -83,7 +83,7 @@ abstract class Atari8MAMEPlatform extends BaseMAME6502Platform {
   getPresets() { return Atari8_PRESETS; }
   getToolForFilename = getToolForFilename_Atari8;
   getOpcodeMetadata = getOpcodeMetadata_6502;
-  getDefaultExtensions() { return [".c", ".bas", ".cpp", ".acme", ".ca65", ".dasm", ".ecs", ".wiz"]; }
+  getDefaultExtensions() { return [".c", ".bas", ".cpp", ".acme", ".xa", ".ca65", ".dasm", ".ecs", ".wiz"]; }
   showHelp = atari8_showHelp;
 }
 
diff --git a/src/platform/c64.ts b/src/platform/c64.ts
index d72ceefe..ce206859 100644
--- a/src/platform/c64.ts
+++ b/src/platform/c64.ts
@@ -86,7 +86,7 @@ abstract class C64MAMEPlatform extends BaseMAME6502Platform {
   getPresets() { return C64_PRESETS; }
   getToolForFilename = getToolForFilename_6502;
   getOpcodeMetadata = getOpcodeMetadata_6502;
-  getDefaultExtensions() { return [".c", ".cpp", ".acme", ".ca65", ".dasm", ".ecs", ".wiz"]; }
+  getDefaultExtensions() { return [".c", ".cpp", ".acme", ".xa", ".ca65", ".dasm", ".ecs", ".wiz"]; }
   loadROM(title, data) {
     if (!this.started) {
       this.startModule(this.mainElement, {
diff --git a/src/platform/gb.ts b/src/platform/gb.ts
index b94f9657..1e06cf5b 100644
--- a/src/platform/gb.ts
+++ b/src/platform/gb.ts
@@ -7,6 +7,8 @@ const GB_PRESETS: Preset[] = [
   { id: 'hello.c', name: 'Hello World (C)' },
   { id: 'testdrawing.c', name: 'Drawing Routines (C)' },
   { id: 'testphys.c', name: 'Sprite Test (C)' },
+  { id: 'chase.c', name: "Shiru's Chase Game" },
+  { id: 'pakupaku.c', name: 'Paku Paku' },
   { id: 'hello.sgb', name: 'Hello World (ASM)' },
   { id: 'main.wiz', name: 'Snake Game (Wiz)' },
 ];
diff --git a/src/platform/nes.ts b/src/platform/nes.ts
index e66a491c..79557b77 100644
--- a/src/platform/nes.ts
+++ b/src/platform/nes.ts
@@ -561,7 +561,7 @@ class NESMAMEPlatform extends BaseMAME6502Platform implements Platform {
   getPresets() { return JSNES_PRESETS; }
   getToolForFilename = getToolForFilename_6502;
   getOpcodeMetadata = getOpcodeMetadata_6502;
-  getDefaultExtensions() { return [".c", ".cpp", ".acme", ".ca65", ".dasm", ".ecs", ".wiz"]; }
+  getDefaultExtensions() { return [".c", ".cpp", ".acme", ".xa", ".ca65", ".dasm", ".ecs", ".wiz"]; }
 
 }
 
diff --git a/src/platform/pce.ts b/src/platform/pce.ts
index 5286a0eb..6a45268e 100644
--- a/src/platform/pce.ts
+++ b/src/platform/pce.ts
@@ -49,7 +49,7 @@ class PCEnginePlatform implements Platform {
         return getToolForFilename_6502(fn);
     }
     getDefaultExtensions() {
-        return [".c", ".cpp", ".acme", ".ca65", ".dasm", ".ecs", ".wiz"];
+        return [".c", ".cpp", ".acme", ".xa", ".ca65", ".dasm", ".ecs", ".wiz"];
     }
     readAddress(addr: number): number {
         return this.pce.Get(addr);
diff --git a/src/platform/vcs.ts b/src/platform/vcs.ts
index 787519cd..20fba1e5 100644
--- a/src/platform/vcs.ts
+++ b/src/platform/vcs.ts
@@ -303,7 +303,7 @@ class VCSPlatform extends BasePlatform {
     return "\n" + dumpRAM(ram, 0x80, 0x80);
   }
   getToolForFilename = getToolForFilename_vcs;
-  getDefaultExtensions() { return [".dasm", ".a", ".bb", ".acme", ".ca65", ".cc2600", ".ecs", ".wiz", ".c"]; }
+  getDefaultExtensions() { return [".dasm", ".a", ".bb", ".acme", ".xa", ".ca65", ".cc2600", ".ecs", ".wiz", ".c"]; }
   getROMExtension() { return ".a26"; }
 
   getDebugCategories() {
@@ -480,7 +480,7 @@ class VCSMAMEPlatform extends BaseMAME6502Platform implements Platform {
   getPresets = function() { return VCS_PRESETS; }
 
   getToolForFilename = getToolForFilename_vcs;
-  getDefaultExtensions() { return [".c", ".bb", ".acme", ".ca65", ".dasm", ".cc2600", ".ecs", ".wiz"]; }
+  getDefaultExtensions() { return [".c", ".bb", ".acme", ".xa", ".ca65", ".dasm", ".cc2600", ".ecs", ".wiz"]; }
   getROMExtension() { return ".a26"; }
 
   getOriginPC = function() {
@@ -538,7 +538,7 @@ class VCSStellaPlatform implements Platform {
     return this.running;
   }
   getToolForFilename = getToolForFilename_vcs;
-  getDefaultExtensions() { return [".c", ".bb", ".acme", ".ca65", ".dasm", ".cc2600", ".ecs", ".wiz"]; }
+  getDefaultExtensions() { return [".c", ".bb", ".acme", ".xa", ".ca65", ".dasm", ".cc2600", ".ecs", ".wiz"]; }
   getROMExtension() { return ".a26"; }
   getPresets() { return VCS_PRESETS }
 }
diff --git a/src/platform/vic20.ts b/src/platform/vic20.ts
index 8531beae..45e566d9 100644
--- a/src/platform/vic20.ts
+++ b/src/platform/vic20.ts
@@ -51,7 +51,7 @@ abstract class VIC20MAMEPlatform extends BaseMAME6502Platform {
   getPresets() { return VIC20_PRESETS; }
   getToolForFilename = getToolForFilename_6502;
   getOpcodeMetadata = getOpcodeMetadata_6502;
-  getDefaultExtensions() { return [".c", ".cpp", ".acme", ".ca65", ".dasm", ".ecs", ".wiz"]; }
+  getDefaultExtensions() { return [".c", ".cpp", ".acme", ".xa", ".ca65", ".dasm", ".ecs", ".wiz"]; }
   loadROM(title, data) {
     if (!this.started) {
       this.startModule(this.mainElement, {
diff --git a/src/platform/zmachine.ts b/src/platform/zmachine.ts
index e9a1cd21..bd553d54 100644
--- a/src/platform/zmachine.ts
+++ b/src/platform/zmachine.ts
@@ -6,7 +6,7 @@ import { InputResponse } from "../common/basic/runtime";
 import { loadScript } from "../common/util";
 
 const ZMACHINE_PRESETS = [
-    { id: 'hello.inf', name: 'Hello World' },
+    { id: 'hello.inf', name: 'Hello World', category: 'Inform 6' },
     { id: 'house01.inf', name: 'House Tutorial #1' },
     { id: 'house02.inf', name: 'House Tutorial #2' },
     { id: 'house03.inf', name: 'House Tutorial #3' },
@@ -25,6 +25,8 @@ const ZMACHINE_PRESETS = [
     { id: 'museum.inf', name: 'Museum of Inform' },
     { id: 'advent.inf', name: 'Colossal Cave Adventure' },
     { id: 'ztrek.inf', name: 'Super Z Trek' },
+    { id: 'hello.dg', name: 'Hello Dialog', category: 'Dialog' },
+    { id: 'cottage.dg', name: 'Cloak of Darkness' },
 ];
 
 declare var ZVM;
@@ -704,10 +706,10 @@ class ZmachinePlatform implements Platform {
     }
 
     getToolForFilename(s: string): string {
-        return "inform6";
+        return s.endsWith(".dg") ? "dialog" : "inform6";
     }
     getDefaultExtensions() {
-        return [".inf"];
+        return [".inf", ".dg"];
     }
     showHelp() {
         return "https://www.inform-fiction.org/manual/html/contents.html";
diff --git a/src/worker/builder.ts b/src/worker/builder.ts
index 99787948..8215ddf5 100644
--- a/src/worker/builder.ts
+++ b/src/worker/builder.ts
@@ -49,6 +49,14 @@ export interface BuildStep extends WorkerBuildStep {
 
 ///
 
+export function fixLineEndings(data: any): any {
+  if (typeof data === 'string') {
+    // C build tools require LF line endings.
+    return data.replace(/\r\n/g, '\n');
+  }
+  return data;
+}
+
 export class FileWorkingStore implements WorkingStore {
   workfs: { [path: string]: FileEntry } = {};
   workerseq: number = 0;
@@ -89,7 +97,7 @@ export class FileWorkingStore implements WorkingStore {
     let data = this.getFileData(path);
     if (data != null && typeof data !== 'string')
       throw new Error(`${path}: expected string`)
-    return data as string; // TODO
+    return fixLineEndings(data) as string; // TODO
   }
   getFileEntry(path: string): FileEntry {
     return this.workfs[path];
@@ -256,6 +264,7 @@ export function populateEntry(fs, path: string, entry: FileEntry, options: Build
   if (options && options.processFn) {
     data = options.processFn(path, data);
   }
+  data = fixLineEndings(data);
   // create subfolders
   var toks = path.split('/');
   if (toks.length > 1) {
diff --git a/src/worker/fs/dialog-fs.zip b/src/worker/fs/dialog-fs.zip
new file mode 100644
index 00000000..8b8c6479
Binary files /dev/null and b/src/worker/fs/dialog-fs.zip differ
diff --git a/src/worker/tools/dialog.ts b/src/worker/tools/dialog.ts
new file mode 100644
index 00000000..f5f695bf
--- /dev/null
+++ b/src/worker/tools/dialog.ts
@@ -0,0 +1,71 @@
+import { WorkerError } from "../../common/workertypes";
+import { WASIFilesystem, WASIRunner } from "../../common/wasi/wasishim";
+import { BuildStep, BuildStepResult, gatherFiles, staleFiles, store, putWorkFile } from "../builder";
+import { loadWASIFilesystemZip } from "../wasiutils";
+import { loadWASMBinary } from "../wasmutils";
+
+// the Dialog standard library ships in the preload filesystem, but a project
+// can override it by including its own copy
+const STDLIB = "stdlib.dg";
+
+let dialog_fs: WASIFilesystem | null = null;
+let wasiModule: WebAssembly.Module | null = null;
+
+// Error: story.dg, line 6: Unexpected token at beginning of line.
+// Error: No library (such as stdlib.dg) was specified on the commandline.
+const re_error = /^Error:\s+(?:(\S+?), line (\d+):\s+)?(.+)/;
+
+export async function compileDialog(step: BuildStep): Promise<BuildStepResult> {
+    const errors: WorkerError[] = [];
+    gatherFiles(step, { mainFilePath: "main.dg" });
+    const destpath = step.prefix + ".z8";
+    if (staleFiles(step, [destpath])) {
+        if (!dialog_fs) {
+            dialog_fs = await loadWASIFilesystemZip("dialog-fs.zip");
+        }
+        if (!wasiModule) {
+            wasiModule = new WebAssembly.Module(loadWASMBinary("dialogc"));
+        }
+        const wasi = new WASIRunner();
+        wasi.initSync(wasiModule);
+        wasi.fs.setParent(dialog_fs);
+        for (let file of step.files) {
+            wasi.fs.putFile("./" + file, store.getFileData(file));
+        }
+        wasi.addPreopenDirectory(".");
+        // sources are matched in command-line order, so the story comes first
+        // and the library last -- a project's own stdlib.dg shadows the
+        // preloaded one, since putFile() writes to the child filesystem
+        const sources = step.files.filter(fn => fn.endsWith(".dg") && fn != STDLIB);
+        sources.push(STDLIB);
+        wasi.setArgs(["dialogc", "-t", "z8", "-o", destpath, ...sources]);
+        try {
+            wasi.run();
+        } catch (e) {
+            errors.push({ line: 0, msg: e + "" });
+        }
+        const stderr = wasi.fds[2].getBytesAsString();
+        for (let line of stderr.split("\n")) {
+            const matches = re_error.exec(line);
+            if (matches) {
+                errors.push({
+                    path: matches[1] || step.path,
+                    line: parseInt(matches[2]) || 0,
+                    msg: matches[3]
+                });
+            } else if (line) {
+                console.log(line); // warnings, progress messages
+            }
+        }
+        if (errors.length) {
+            return { errors };
+        }
+        const outfile = wasi.fs.getFile("./" + destpath);
+        if (!outfile) {
+            return { errors: [{ line: 0, msg: "dialogc did not produce " + destpath }] };
+        }
+        const output = outfile.getBytes();
+        putWorkFile(destpath, output);
+        return { output, errors };
+    }
+}
diff --git a/src/worker/tools/xa.ts b/src/worker/tools/xa.ts
new file mode 100644
index 00000000..2db9bc74
--- /dev/null
+++ b/src/worker/tools/xa.ts
@@ -0,0 +1,147 @@
+import { WASIRunner } from "../../common/wasi/wasishim";
+import { CodeListing, CodeListingMap } from "../../common/workertypes";
+import { BuildStep, BuildStepResult, gatherFiles, putWorkFile, staleFiles, store } from "../builder";
+import { re_crlf } from "../listingutils";
+import { loadWASMBinary } from "../wasmutils";
+
+// xa listing lines look like this:
+//     5 A:c000  a9 05                    start     lda #$05      ; comment
+// (line number, segment:address, then fixed-width byte / label / source columns)
+const re_listing = /^\s*(\d+) (\w):([0-9a-f]+)  (.*)$/i;
+const LABEL_COL = 25;   // width of the byte column
+const SOURCE_COL = 35;  // width of the byte + label columns
+
+// xa writes errors to stderr, e.g.:
+// main.xa:line 7: c00c:Overflow error
+const re_error = /^(\S.*?):line (\d+): (?:[0-9a-f]+:)?\s*(.+)$/;
+
+// the label file (-l) has one comma-separated entry per line:
+// start, 0xc000, 0, 0x0000
+const re_label = /^(\S+),\s*0x([0-9a-f]+)/i;
+
+function parseXALabels(text: string) {
+    const symbolmap = {};
+    for (const line of text.split(re_crlf)) {
+        const m = re_label.exec(line);
+        if (m) {
+            symbolmap[m[1]] = parseInt(m[2], 16);
+        }
+    }
+    return symbolmap;
+}
+
+function parseXAListing(lsttext: string, listings: CodeListingMap) {
+    // xa prints the file name on its own line whenever it enters or resumes a file
+    let path: string | null = null;
+    let listing: CodeListing | null = null;
+    let lastline = 0;
+    const lastlines: { [path: string]: number } = {};
+    for (const line of lsttext.split(re_crlf)) {
+        const m = re_listing.exec(line);
+        if (!m) {
+            // a file name switches us to another listing
+            const newpath = line.trim();
+            if (listings[newpath]) {
+                if (path) lastlines[path] = lastline;
+                path = newpath;
+                listing = listings[path];
+                lastline = lastlines[path] || 0;
+            }
+            continue;
+        }
+        const linenum = parseInt(m[1]);
+        const offset = parseInt(m[3], 16);
+        const rest = m[4];
+        const insns = rest.substring(0, LABEL_COL).replace('...', '').trim();
+        const source = rest.substring(SOURCE_COL).trim();
+        // when xa resumes a file after an include it repeats its line counter
+        // for one line, so only accept line numbers that move forward
+        if (insns && listing && linenum > lastline) {
+            listing.lines.push({
+                line: linenum,
+                offset: offset,
+                insns: insns,
+                iscode: !source.startsWith('.'),
+            });
+        }
+        if (linenum > lastline) lastline = linenum;
+    }
+}
+
+// the origin is the address of the first byte written to the output file
+function getListingOrigin(listings: CodeListingMap): number | undefined {
+    let origin: number | undefined;
+    for (const key in listings) {
+        for (const line of listings[key].lines) {
+            if (origin === undefined || line.offset < origin) origin = line.offset;
+        }
+    }
+    return origin;
+}
+
+let wasiModule: WebAssembly.Module | null = null;
+
+export function assembleXA(step: BuildStep): BuildStepResult {
+    const errors = [];
+    gatherFiles(step, { mainFilePath: "main.xa" });
+    const binpath = step.prefix + ".bin";
+    const lstpath = step.prefix + ".lst";
+    const sympath = step.prefix + ".lbl";
+    if (staleFiles(step, [binpath])) {
+        if (!wasiModule) {
+            wasiModule = new WebAssembly.Module(loadWASMBinary("xa"));
+        }
+        const wasi = new WASIRunner();
+        wasi.initSync(wasiModule);
+        for (const file of step.files) {
+            wasi.fs.putFile("./" + file, store.getFileData(file));
+        }
+        wasi.addPreopenDirectory(".");
+        const args = ['xa', '-E', '-o', binpath, '-l', sympath, '-P', lstpath];
+        if (step.params?.xaargs) {
+            args.push.apply(args, step.params.xaargs);
+        }
+        args.push("-D__8BITWORKSHOP__=1");
+        if (step.mainfile) {
+            args.push("-D__MAIN__=1");
+        }
+        args.push(step.path);
+        wasi.setArgs(args);
+        try {
+            wasi.run();
+        } catch (e) {
+            errors.push({ line: 0, msg: e + "" });
+        }
+        const stderr = wasi.fds[2].getBytesAsString();
+        for (const line of stderr.split(re_crlf)) {
+            const m = re_error.exec(line);
+            if (m) {
+                errors.push({ path: m[1], line: parseInt(m[2]), msg: m[3] });
+            }
+        }
+        if (errors.length) {
+            return { errors };
+        }
+        const lstout = wasi.fs.getFile("./" + lstpath)?.getBytesAsString() || "";
+        const symout = wasi.fs.getFile("./" + sympath)?.getBytesAsString() || "";
+        const output = wasi.fs.getFile("./" + binpath)?.getBytes();
+        if (!output) {
+            return { errors: [{ line: 0, msg: "xa did not produce an output file" }] };
+        }
+        const listings: CodeListingMap = {};
+        for (const path of step.files) {
+            listings[path] = { lines: [] };
+        }
+        parseXAListing(lstout, listings);
+        putWorkFile(binpath, output);
+        putWorkFile(lstpath, lstout);
+        putWorkFile(sympath, symout);
+        return {
+            output,
+            errors,
+            listings,
+            symbolmap: parseXALabels(symout),
+            origin: getListingOrigin(listings),
+        };
+    }
+}
diff --git a/src/worker/wasm/dialogc.wasm b/src/worker/wasm/dialogc.wasm
new file mode 100755
index 00000000..b81e2ba6
Binary files /dev/null and b/src/worker/wasm/dialogc.wasm differ
diff --git a/src/worker/wasm/xa.wasm b/src/worker/wasm/xa.wasm
new file mode 100755
index 00000000..3706386c
Binary files /dev/null and b/src/worker/wasm/xa.wasm differ
diff --git a/src/worker/workertools.ts b/src/worker/workertools.ts
index 2080bcb7..abe67498 100644
--- a/src/worker/workertools.ts
+++ b/src/worker/workertools.ts
@@ -16,6 +16,8 @@ import * as cc7800 from './tools/cc7800'
 import * as cc2600 from './tools/cc2600'
 import * as bataribasic from './tools/bataribasic'
 import * as oscar64 from './tools/oscar64'
+import * as xa from './tools/xa'
+import * as dialog from './tools/dialog'
 
 import { PLATFORM_PARAMS } from "./platforms";
 
@@ -60,6 +62,8 @@ export const TOOLS = {
   'armtcc': arm.compileARMTCC,
   'armtcclink': arm.linkARMTCC,
   'oscar64': oscar64.compileOscar64,
+  'xa': xa.assembleXA,
+  'dialog': dialog.compileDialog,
 }
 
 export const TOOL_PRELOADFS = {
diff --git a/test/services/testgithub.js b/test/services/testgithub.js
index aec44db3..c59d907d 100644
--- a/test/services/testgithub.js
+++ b/test/services/testgithub.js
@@ -34,7 +34,7 @@ const t0 = new Date().getTime();
 
 describe('Github', function() {
 
-  it('Should import from Github (check README)', function(done) {
+  it('Should import from GitHub (check README)', function(done) {
     var store = createNewPersistentStore('vcs', function(store) {
       var gh = newGH(store, 'vcs');
       gh.importAndPull('https://github.com/pzpinfo/test123123/').then( (sess) => {
@@ -52,7 +52,7 @@ describe('Github', function() {
     });
   });
 
-  it('Should import from Github (default branch)', function(done) {
+  it('Should import from GitHub (default branch)', function(done) {
     var store = createNewPersistentStore('nes', function(store) {
       var gh = newGH(store, 'nes');
       gh.importAndPull('https://github.com/sehugg/mdf2020-nes').then( (sess) => {
@@ -62,7 +62,7 @@ describe('Github', function() {
     });
   });
 
-  it('Should import from Github (explicit branch)', function(done) {
+  it('Should import from GitHub (explicit branch)', function(done) {
     var store = createNewPersistentStore('nes', function(store) {
       var gh = newGH(store, 'nes');
       gh.importAndPull('https://github.com/sehugg/mdf2020-nes/tree/main').then( (sess) => {
@@ -72,7 +72,7 @@ describe('Github', function() {
     });
   });
 
-  it('Should import from Github (binary files)', function(done) {
+  it('Should import from GitHub (binary files)', function(done) {
     var store = createNewPersistentStore('vcs', function(store) {
       var gh = newGH(store, 'vcs');
       gh.importAndPull('https://github.com/pzpinfo/testrepo3').then( (sess) => {
@@ -88,7 +88,7 @@ describe('Github', function() {
     });
   });
 
-  it('Should import from Github (wrong platform)', function(done) {
+  it('Should import from GitHub (wrong platform)', function(done) {
     var store = createNewPersistentStore('_FOO', function(store) {
       var gh = newGH(store, '_FOO');
       gh.importAndPull('https://github.com/pzpinfo/testrepo1557326056720').catch( (e) => {
@@ -98,7 +98,7 @@ describe('Github', function() {
     });
   });
 
-  it('Should import from Github (invalid URL)', function(done) {
+  it('Should import from GitHub (invalid URL)', function(done) {
     var store = createNewPersistentStore('_FOO', function(store) {
       var gh = newGH(store, '_FOO');
       gh.importAndPull('https://github.com/pzpinfo/NOEXISTSREPO').catch( (e) => {
@@ -109,7 +109,7 @@ describe('Github', function() {
     });
   });
 
-  it('Should import from Github (subdirectory tree)', function(done) {
+  it('Should import from GitHub (subdirectory tree)', function(done) {
     var store = createNewPersistentStore('nes', function(store) {
       var gh = newGH(store, 'nes');
       gh.importAndPull('https://github.com/brovador/NESnake/tree/master/src').then( (sess) => {
@@ -120,7 +120,7 @@ describe('Github', function() {
     });
   });
 
-  it('Should publish (fail) on Github', function(done) {
+  it('Should publish (fail) on GitHub', function(done) {
     var store = createNewPersistentStore(test_platform_id, function(store) {
       var gh = newGH(store);
       // should fail
@@ -130,7 +130,7 @@ describe('Github', function() {
     });
   });
 
-  it('Should publish new repository on Github', function(done) {
+  it('Should publish new repository on GitHub', function(done) {
     var store = createNewPersistentStore(test_platform_id, function(store) {
       var gh = newGH(store);
       var reponame = 'testrepo'+t0;
@@ -144,7 +144,7 @@ describe('Github', function() {
     });
   });
 
-  it('Should commit/push to Github', function(done) {
+  it('Should commit/push to GitHub', function(done) {
     var store = createNewPersistentStore(test_platform_id, function(store) {
       var gh = newGH(store);
       var binfile = new Uint8Array(256);
@@ -164,7 +164,7 @@ describe('Github', function() {
     });
   });
 
-  it('Should commit/push to Github (subdirectory tree)', function(done) {
+  it('Should commit/push to GitHub (subdirectory tree)', function(done) {
     var store = createNewPersistentStore(test_platform_id, function(store) {
       var gh = newGH(store);
       var files = [
@@ -182,7 +182,7 @@ describe('Github', function() {
     });
   });
 
-  it('Should bind paths to Github', function(done) {
+  it('Should bind paths to GitHub', function(done) {
     var store = createNewPersistentStore(test_platform_id, function(store) {
       var gh = newGH(store);
       var sess = {repopath:'foo/bar', url:'_', platform_id:'vcs',mainPath:'test.c'};
diff --git a/test/unit/testwasishim.ts b/test/unit/testwasishim.ts
index 088cbcad..2f96e393 100644
--- a/test/unit/testwasishim.ts
+++ b/test/unit/testwasishim.ts
@@ -82,6 +82,45 @@ describe('test WASI cc7800', function () {
     });
 });
 
+describe('test WASI dialogc', function () {
+    async function loadDialogc() {
+        let shim = await loadWASM('dialogc');
+        const zipdata = fs.readFileSync(`./src/worker/fs/dialog-fs.zip`);
+        shim.fs.setParent(await unzipWASIFilesystem(zipdata as any, "./"));
+        shim.addPreopenDirectory(".");
+        return shim;
+    }
+    it('dialogc compile', async function () {
+        let shim = await loadDialogc();
+        const src = fs.readFileSync('./presets/zmachine/hello.dg', 'utf8');
+        shim.fs.putFile("./hello.dg", src);
+        shim.setArgs(["dialogc", "-t", "z8", "-o", "hello.z8", "hello.dg", "stdlib.dg"]);
+        let errno = shim.run();
+        assert.strictEqual(shim.fds[2].getBytesAsString(), "");
+        assert.strictEqual(errno, 0);
+        const zfile = shim.fs.getFile("./hello.z8").getBytes();
+        assert.ok(zfile.length > 1000);
+        assert.strictEqual(zfile[0], 8); // z-machine version 8
+    });
+    it('dialogc syntax error', async function () {
+        let shim = await loadDialogc();
+        shim.fs.putFile("./bad.dg", "(room #room)\n(current player #player\n");
+        shim.setArgs(["dialogc", "-t", "z8", "-o", "bad.z8", "bad.dg", "stdlib.dg"]);
+        let errno = shim.run();
+        assert.strictEqual(errno, 1);
+        const stderr = shim.fds[2].getBytesAsString();
+        assert.ok(stderr.indexOf('Error: bad.dg, line ') >= 0, stderr);
+    });
+    it('dialogc missing source file', async function () {
+        let shim = await loadDialogc();
+        shim.setArgs(["dialogc", "-t", "z8", "-o", "x.z8", "nosuch.dg", "stdlib.dg"]);
+        let errno = shim.run();
+        assert.strictEqual(errno, 1);
+        const stderr = shim.fds[2].getBytesAsString();
+        assert.ok(stderr.indexOf('Error: Failed to open "nosuch.dg"') >= 0, stderr);
+    });
+});
+
 /*
 describe('test WASI oscar64', function () {
     it('oscar64 compile', async function () {
diff --git a/test/web/testimport.js b/test/web/testimport.js
index 0da05602..dd91a7bd 100644
--- a/test/web/testimport.js
+++ b/test/web/testimport.js
@@ -22,7 +22,7 @@ try {
     console.log('warning: need ./github.json with {token:"..."}')
 }
 
-exports['test import Github'] = async function (browser) {
+exports['test import GitHub'] = async function (browser) {
 
     await browser.url(`${IDEURL}?${QS_GITHUBURL}`)
         .waitForElementNotPresent('#step-0')