February (15)
Anatomy of a Retro BIOS
Designing firmware for emulated retro computers—reset vectors, service calls, UART I/O, toolchains, and the boot theatre that makes it feel real.
Deep Dive: Audio Bus Architecture
Centralising modem, line, backend, and peripheral audio in a single bus system, and why fewer hops beat fancy decoupling.
Deep Dive: Audio Sonification for Code Visualization
I mapped code history onto a small audio graph and treated volume as a data contract, not a vibe.
Deep Dive: Balancing a Goose Game
The iteration that turned a text adventure into something playable—balance tuning, achievement scaffolding, and the 1081-line manual that made it legible.
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 a migration ending instead of game over.
Deep Dive: Custom Canvas Charts for 30fps Animation
Chart.js redraws the full scene every frame—correct for dashboards, wrong for playback. The fix was to treat the chart as a video surface.
Deep Dive: Simulating DATAPAC, Canada's Forgotten Internet
Rebuilding the DATAPAC PAD experience in code — the command loop, X.25 NUAs, and five period-authentic hosts behind a 300-baud prompt.
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 Heartbeats and Job Recovery
A database-first ownership model for long-running jobs, with heartbeats, stale detection, and deterministic recovery.
Inside Five CPU Emulators
Building five classic CPU cores in Rust for WebAssembly: 8008, 8080, 8088, Z80, and 6502, with shared state formats, cycle timing, and the edge cases that keep emulation honest.
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.
Deep Dive: The Microservices Migration
How a BBS emulator grew into a distributed system with gRPC services, NATS messaging, gateway routing, and real backends instead of localStorage.
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.
January (20)
Identity, SEO, and a Lot of Polish
Identity got real: guest sessions, passkeys, and a server‑backed auth surface, plus gopher content routing, Z‑Machine version wiring, and a formatting sweep.
Building a Code Evolution Analyzer in a Weekend
What started as a quick script turned into two days of yak-shaving through chart performance, audio bugs, and that moment when you realize cloc is just too slow.
Deep Dive: Passkey Authentication for a Retro BBS
Passkeys in a 300‑baud world: the smallest WebAuthn flow, the server state it requires, and how I kept it in tune with emulator.ca's identity model.
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.
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.
Storage Peripherals and Audio Realism
Floppy, hard drive, and cassette peripherals with Kansas City Standard encoding, plus a peripheral audio bus that makes the machine feel physical.
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 (Sort Of)
Building BASIC, Forth, and Scheme interpreters in Rust, running them in browser workers, and what that architecture taught me about language shape.
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 shovel bytes through a virtual modem—RTS/CTS backpressure, buffer gates, and the timing budget that makes dial-up feel real.
Deep Dive: The Z-Machine Interpreter
Building a Z-Machine transpiler in Rust—opcode decoding, Z-strings, branch offsets, and the constraints that make Infocom's bytecode tick.
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.
The Dungeon Gets Real
Transforming a dungeon crawler demo into a persistent roguelike with progression, daily challenges, and meta-unlocks—all in one session.
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 PETSCII screen memory into ANSI terminal output—character maps, colour translation, and the minimal contract a terminal-based VIC‑II can keep.
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.
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.
Deep Dive: Bell 212A and V.32bis Handshakes
When 300 baud isn't enough—simulating faster modem handshakes with phase modulation, training sweeps, and the controlled chaos of negotiation audio.
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 two-band trick that keeps full‑duplex honest.
A Small Day That Mattered
Fixing CRT modem and BBS bugs—the quiet foundation work that keeps a larger project from getting weird later.