February (15)
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.
January (20)
Building a Code Evolution Analyzer in a Weekend
What started as a 'quick script to visualize git history' became microservices, NATS message queues, and audio sonification. The anatomy of a one-day project that wasn't.
Identity, SEO, and a Lot of Polish
Building out the identity system—sessions, OAuth, passkeys—plus gopher content flow, Z-Machine expansion, and a huge formatting sweep.
Deep Dive: Passkey Authentication for a Retro BBS
WebAuthn meets 1980s aesthetics—implementing FIDO2 passkeys and biometric auth for a system that pretends to be a 300-baud bulletin board.
CC-40 Completion and IVR Launch
Shipping the TI CC-40 backend with authentic CALL commands and audio, plus a full IVR phone tree system.
Storage Peripherals and Audio Realism
Adding hard drive, floppy, and cassette peripherals with Kansas City Standard encoding, plus a peripheral audio bus for realistic sounds.
Deep Dive: Kansas City Standard Cassette Storage
Building a 1976-era cassette peripheral—FSK encoding at 2400/1200 Hz, tape transport simulation, and why saving 8KB took six minutes.
Deployment Prep and Backend Growth
Kubernetes/K3s deployment configs, CI/CD scaffolding, schema-driven API generation, and the Star Trek BASIC backend.
Three Languages, One Weekend: Building BASIC, Forth, and Scheme Interpreters in Rust
Implementing three classic programming language interpreters in Rust, compiled to WebAssembly. BASIC for nostalgia, Forth for stack machines, Scheme for elegance—and what I learned along the way.
The Big web/ Move and Parser Migrations
Moving the web app to a proper structure, migrating parsers to Pest/Pratt, and building the Z-Machine opcode engine.
Deep Dive: CTS Flow Control in the Serial/Modem System
Why you can't just shove bytes through a virtual modem—RTS/CTS hardware flow control, buffer management, and making dial-up feel authentic.
Z-Machine Foundations and Storage Sync
Pushing the Z-Machine interpreter forward with decoder work, text handling, and SAVE/RESTORE—plus content-addressable storage with S3 sync.
Deep Dive: The Z-Machine Interpreter
Building an Infocom Z-Machine interpreter in Rust—instruction decoding, Z-strings, call frames, and understanding what makes Zork tick at the bytecode level.
Feature Surge: Dungeon, Forth, and Core Polish
A big feature day across the dungeon backend, Forth interpreter, and CPU cores—plus the Intel 8008 calculator peripheral.
Emulation Milestones and TypeScript Migration
Intel 8088 demos, Zig-based 6502 experiments, and migrating the frontend to TypeScript for better type safety.
Deep Dive: PETSCII and the VIC-II Text Adapter
Translating Commodore's weird character encoding and VIC-II video memory into ANSI terminal output—box drawing, color mapping, and 40-column nostalgia.
Big Repo Restructure and Backend Migration
Splitting the repository into clear domains—cores, languages, assemblers, BIOS—and making future work less of a guessing game.
Deep Dive: Bell 212A and V.32bis Handshakes
When 300 baud isn't enough—simulating faster modem handshakes with phase modulation, QAM, and the beautiful screaming of USRobotics Sportsters.
Deep Dive: Bell 103 Audio Modem and FSK Implementation
Implementing the 1962 modem standard that made 300 baud dialup possible—FSK modulation, Goertzel demodulation, and the beautiful warble of two frequencies arguing over a phone line.
Build System Groundwork and Modem Plumbing
Tightening the build pipeline for modem-core WASM, dynamic backend loading, and making the modem behave like a real modem.
A Small Day That Mattered
Fixing CRT modem and BBS bugs—the quiet foundation work that keeps a larger project from getting weird later.