Deep Dive: Audio Bus Architecture
Taming audio chaos in a modem emulator—centralizing multiple sound sources through a bus-based routing system with Tone.js, and the journey from 8 event hops to 3.
Deep Dive: Audio Sonification for Code Visualization
Turning code evolution into sound—Web Audio API oscillators, harmonic frequency mapping, and the pursuit of a THX-like evolving chord.
Assemblers, Memory Maps, and Madness
Building cross-assemblers for retro CPUs in Rust, migrating to Pest parsers, and discovering why load addresses matter more than you think.
Deep Dive: Building a Canada Goose Simulator
How a deadpan text adventure about mild chaos became the BBS system's most extensively tested game—79 tests, procedural honk audio, and goose migration instead of game over.
Deep Dive: Custom Canvas Charts for 30fps Animation
Why Chart.js couldn't keep up with streaming data, and how a custom Canvas 2D renderer with data decimation achieved smooth 30fps playback.
Deep Dive: Balancing a Goose Game
The iteration that turned a text adventure into something playable—achievement systems, balance tuning, playtesting lessons, and why geese need a 1077-line manual.
Anatomy of a Retro BIOS
Designing firmware for emulated retro computers—RST vectors, UART I/O, C-to-binary toolchains, and why floppy drives need to make noise.
Deep Dive: Simulating DATAPAC, Canada's Forgotten Internet
Building a historically accurate X.25 packet-switching network simulator—PAD commands, NUA addressing, and the five virtual hosts that defined Canadian computing in the 1980s.
Deep Dive: Lazy Loading 42 Backends with Dynamic Imports
How I shrank the emulator's main bundle from 1MB to 104KB by lazy-loading backends during dial tones—and why users never notice the delay.
Deep Dive: Worker Heartbeat and Job Recovery
How to handle worker crashes in a distributed job queue—using database heartbeats, startup reconciliation, and distributed stale job detection.
Server-Backed Backends and Peripherals Go Physical
Migrating backends to server APIs with NATS pub/sub, adding microservices, and building the peripheral slot system with the Canada Goose game.
Video Chips and Serial Streams: Rendering C64 Graphics Over a Modem
How I emulated the VIC-II video chip and forwarded its framebuffer as ANSI escape sequences over a serial connection—turning a 40-year-old graphics architecture into something a BBS terminal can display.
Serving Gopherspace from a Rust Backend
Building a Gopher server that serves RFC 1436 content through a modern API layer—because sometimes you want to browse the internet like it's 1991.
Inside Five CPU Emulators
Building cycle-accurate emulators for the Intel 8008, 8080, 8086/8088, Zilog Z80, and MOS 6502 in Rust compiled to WebAssembly—instruction decoding, flag handling, and the quirks that made these chips legendary.
Deep Dive: The Microservices Migration
How a BBS emulator accidentally became a distributed system—gRPC services, NATS message bus, gateway routing, and the move from localStorage to real backends.