Games, a voxel engine, local AI services, developer tools and a few experiments that taught me more by failing. Line counts are measured, not estimated: copies, generated files and bundled libraries are left out.
The hard problem first, then what I did about it.
A web page gets one thread, no file system and no processes — roughly everything an operating system needs, removed on purpose. Making windows that look like a desktop is the easy part. The real work is supplying what a kernel supplies inside a sandbox built to withhold it: applications that cannot tread on each other in one shared runtime, a file system with no disk underneath, and windows that stay coherent while several apps redraw at once. Then a real Python interpreter moves into the page, so applications can be written in Python — the part most people assume is a joke.
The window manager, virtual file system and app launcher are written from scratch in JavaScript, with Pyodide supplying genuine CPython in the browser. Each application loads as its own module with its own WebSocket channel to a Flask backend, so a text editor and a real-time multiplayer game can run side by side without noticing each other. Graphics quality follows the device — a rule written the day a regression made desktop machines render like phones.
Ask a single model to review its own work and it will tell you the work is fine. Self-correction is not a prompting trick — the capacity for disagreement has to exist structurally, or the loop just launders the first answer. Separating the roles and forcing structured handoffs between them is what makes a rejection possible, and a rejection is the only thing that makes correction real.
Planning, execution, criticism and repair are distinct stages with typed contracts between them — a supervisor decomposes the work, a critic evaluates the result against it, and a repair stage must act on that evaluation. Output is structured at every boundary, which is what makes automated judgement tractable.
Simulating competing airlines — route profitability, demand, fleet economics, rival carriers responding to your moves — is normally server work, because it is genuinely expensive to compute. Doing it entirely client-side means the backend can never become the bottleneck, the cost, or the outage.
Hand-built simulation with no game engine underneath it, behind a deliberately thin static server and a file-based save API, and held to a measured budget in CI.
Porting a game usually means rewriting it and hoping it feels the same. Racing is the worst case: the physics is chaotic, so a rounding difference on the first lap is a different winner by the third, and 'feels about right' is not a test anyone can run.
Anything that can be worked out ahead of time is baked in Python — the track in the game's own vertex format, textures, collision, 310 rule constants and the course's 412 sounds — and only the per-tick rules are rewritten in JavaScript on WebGL2. The JavaScript then races against recordings of the Python original, tick by tick, so a difference is a failing test instead of a vague feeling. The baking runs across a fleet of machines, and the result is playable at voxelblox-notes.pages.dev/play.
A game has about sixteen milliseconds to draw each frame. Python spends a good share of that before your code even starts, which is why nobody sensible writes a 3D engine in it. That is exactly the appeal: every design choice here exists to win those milliseconds back, and the screen keeps score — the frame either lands or you watch it stutter.
The hot loops are compiled with Numba, the terrain is raymarched per pixel on the GPU, lighting is baked into the colour map ahead of time, and everything that is not ground is an instanced draw. Then bombs carve real craters into the live terrain. Every performance change is measured A/B against the last commit, so a slowdown shows up as a number long before anyone feels it.
Producing a consistent, shareable technical document normally means someone doing layout by hand every time — which is where quality drifts, and why the tenth document never looks like the first. Automating it properly means handling the parts people quietly do manually: hierarchy, navigation, cross-references and self-contained output.
Markdown in, a polished self-contained HTML or PDF document out, with hierarchical heading structure and breadcrumb navigation generated automatically for long technical material.
Most AI code editing pastes a file into a prompt and hopes the answer is in there. When it is not, the model confidently invents something plausible — the software version of answering an exam question you did not read. The fix is not a cleverer prompt; it is letting the model go and look, and trusting it to decide where.
The model gets search, read and edit as real tools and runs the investigation itself: what to examine, what to fetch, then the change. Around it sits a transcription platform — meetings recorded until you stop them, speakers separated across a fleet of machines, eleven on-demand analyses — behind a default-deny login and a honeypot that hands automated scanners convincing fake credentials.
Model output is capped by the quality of its input, and assembling that input is usually done by hand — copying files into a prompt, differently every time. So results vary for reasons nobody can trace, and the natural response is to blame the model. Making context assembly deliberate and repeatable removes the variable.
Select the exact entities from a codebase that matter rather than dumping whole files, keep reusable libraries of system messages and prompt templates, and produce context of the same quality every time.
Anything that speaks normally calls a speech service while the user waits. That single decision brings latency, a per-use cost, and an outage whenever the provider has one — and it is a bad trade for software children use at home, where a failure is not an error message but a game that stopped working. The alternative is to do all the speech work once, ahead of time, which sounds obvious until every piece of content has to become addressable data first.
All content — quests, inventory, collection sets, shop items — lives in SQLite as structured records, and a generation pass walks it to produce audio for every line through a local TTS engine. The pass is idempotent, skipping what already exists, so adding content generates only the new lines rather than rebuilding the library. A shared type package sits between the FastAPI backend and the React front end so both sides agree on the same schema.
Counting your own code sounds easy until the count lies. One project here first measured 27.5 million lines against about 95,000 of real source — saved web pages, notebook outputs and backup folders all look like code if you squint. A number that wrong, stated with confidence, is worse than no number, and every resume or sales page built on it inherits the mistake.
Every folder is sorted into source, ingested data, generated output or duplicate, and only source counts. One pass over each project feeds the dependency graph, the hotspot scores and the unused-code scan, so they cannot disagree about which files exist. The same measurements run a nightly security sweep, answer AI agents in any project over MCP, and keep this portfolio honest: its figures are quoted from measurements, not typed from memory.
Local AI on one PC hits a wall fast: one graphics card, one model at a time, and every app wired to its own port. Meanwhile the house was full of capable machines doing nothing — mini PCs, handhelds, an old gaming laptop. A fleet only helps, though, if nobody has to remember which box does what.
One endpoint sits in front of everything. Requests go to whichever machine is fastest or already has the model loaded; a GPU arbiter says no before a card quietly spills into system memory and runs at a third of the speed; idle models are parked and woken on demand; and every machine reports its vitals every 30 seconds, so 'do we need more hardware?' is answered with data instead of a hunch.
A story game with spoken dialogue normally needs a server writing lines for every player, so each new player costs money and every outage sinks the ship. The alternative is to do all that work once, before release — which sounds obvious until you have to rebuild a whole game around never calling anything at runtime.
Every line of voice and text is generated ahead of time and shipped as static files, more than 41,000 voice clips streamed from storage at the edge. Saves live on the player's device with optional cloud sync, so the network is a bonus rather than a dependency. Pages come from Cloudflare's edge, audio from R2 and optional saves from D1 — and a weak phone still gets a smooth crossing.
Dictation is normally trapped inside whichever application implements it, so it is available exactly where you are not. Capturing input at the operating-system level makes it work everywhere — including in software that has never heard of it — but means dealing with global hotkeys, focus, and hardware that is frequently already in use by something else.
A background client captures a global hotkey regardless of which window has focus, retries microphone acquisition when the device is busy or mismatched, and returns the transcription straight to the clipboard from either a local or a remote model.
The moment two players act at the same instant, a naive system applies both and the rules quietly stop meaning anything. It is the bug that never shows up while you test alone and always shows up in front of an audience — and you cannot find it by clicking, because you cannot click twice at the same time.
Turn order, action limits and duplicate rejection live on the server, not in the browser. An automated suite plays entire battles in seconds to prove the rules hold when everyone acts at once. Underneath sit a versioned REST API with four middleware layers, a proper relational content model, and the writing-and-voice studio the game mode grew out of.
Almost all software can only demonstrate that it did not crash. Whether it produced the *correct answer* is usually unknowable, so bugs live for years. This one has a rare property: every source document states its own total, which makes the parser's output checkable against ground truth the document itself supplies. That turns correctness from an assumption into something you can run.
Every parsed line item is reconciled against the order's printed subtotal. The consumption maths is deterministic Python and the language model only reasons over numbers already computed — so suggestions stay explainable, and a backtest gate blocks any change that lowers accuracy before it can land.
New Brunswick has been laser-scanned from the air and the data is free — in the way a pallet of unlabelled hard drives is free. Tens of gigabytes of point clouds per corridor, in formats only mapping software opens, behind a download site that turns scripts away. Making it something a person can stroll through on a phone means solving storage, processing and delivery at once, with no server to pay for.
Every 1 km tile is a self-contained job on a fleet of machines: download from NRCan's public bucket, rasterise into 1 m columns, mesh, cut into 200 m web chunks, then delete the source. The browser draws 12-byte instanced quads — a quarter of the memory of an ordinary vertex format — streamed under a frame-rate governor from nine Cloudflare Pages sites that share one map. GeoNB's own site sits behind a bot challenge, so the build uses NRCan's official bulk copy of the same surveys instead of trying to sneak past it.
Filter by area or search for anything: a language, a library, a word.
A complete desktop operating system that runs inside a browser tab: windowing, a file system and real applications, with Python itself executing client-side through a Pyodide runtime.
A desktop orchestrator that splits one local language model into a team of specialists — planner, generator, critic, repairer, enhancer — which pass typed JSON between them and are structurally able to reject each other's work.
A full airline-management strategy game — route networks, fleet economics, demand and rival carriers that react to your moves — simulated entirely in the browser, behind a small server that only serves files and stores saves.
An open-world voxel sandbox in Python — dig, build, drive, fly to space — where every texture, model, sound and note of music comes from code, and whose racing game made the jump to the browser with its physics proven identical.
Land, air and sea combat over terrain you can actually blow holes in, written in Python and kept at frame rate by Numba-compiled kernels and a per-pixel GPU raymarch.
Turns a markdown file into a polished, self-contained HTML site or PDF in one command, generating hierarchy, table of contents, breadcrumbs, anchors and zoomable diagrams automatically.
A bulk transcription platform with speaker diarization that grew into an agentic code editor: the model is handed real search, read and edit tools and investigates a codebase itself instead of guessing from a pasted file.
A desktop workbench for assembling exactly the right context to hand a language model: select individual functions and classes out of a codebase rather than dumping whole files, and keep reusable libraries of system messages and prompt templates.
A React and FastAPI role-playing game that turns household responsibilities into quests, with every line of spoken dialogue generated ahead of time from a content database so the game never calls a speech service at runtime.
Keeps an inventory of a personal software estate across four drives and refreshes it every night behind its own test suite: a reuse index, measured dependency graphs, a security worklist, and a resume and portfolio whose every figure can show its working.
Started as a terminal for keeping an eye on dozens of AI coding agents and grew into the control plane for a home fleet of machines: one OpenAI-compatible endpoint for chat, vision, embeddings, speech and images, jobs farmed out to idle machines, graphics cards scheduled, and every machine's vitals recorded every 30 seconds.
Ports of Call, an Age-of-Exploration trading and naval RPG on Cloudflare's edge: no game server and no runtime AI, because every line of voice and text is generated at build time and shipped as static assets.
Speech-to-text that works in every application at once: a background client captures a global hotkey no matter which window has focus, and the transcription lands on the clipboard from either a local or a remote model.
A writing-and-voice studio: a versioned FastAPI service with real auth middleware, a SQLAlchemy content model, a TTS pipeline, and an LLM dungeon-master mode with turn-based combat.
Turns supermarket order pages — saved by hand or fetched from the household's own browser — into a household consumption model, then has a local LLM propose the next shop, grounded in arithmetic rather than guesswork.
Turns New Brunswick's open LiDAR surveys into a 1-metre block world you can orbit, fly over or walk through in a browser — built tile by tile across a fleet of machines and served from Cloudflare's edge, in English and French.
A marketing site for a business-automation consultancy: hand-written HTML, CSS and JavaScript with no framework and no build step, served locally by a small Python script.
A Flask research platform for TSX energy equities and beyond: a stacking ensemble and signal gates run overnight in an off-hours window, every pipeline stage is logged and alerted, and a daily research shortlist is tracked against a benchmark.
An Android keyboard, shipped as Ownword, built around speech: on-device dictation, swipe typing, word prediction, autocorrect and a sentence check, plus read-aloud and Ask Ownword from any app — reconstructed from its own APK after the original project was lost.
A local text-to-speech studio and OpenAI-compatible API for Qwen3-TTS, patched to run its CUDA-Graph serving engine on an RTX 3090 under WSL2 — nine voices, plus voices cloned from a recording or designed from a description.
A complete real-time strategy game in a single HTML file that links two players directly over WebRTC and runs the same battle on both machines in lockstep — no server of its own anywhere.
A FastAPI nutrition application built on the Open Food Facts dataset, with a logging model that tracks nutrients per entry, saved meals composed of items, and versioned schema migrations.
A desktop code editor and runner built around comparison: two panes, real-time diff highlighting between them, and a model that explains what actually changed rather than just marking the lines.
A FastAPI service and desktop front end for scripted, multi-clip voice generation, with saved voice templates and four separately-tuned API variants benchmarked against each other.
A desktop stock screener that collects market data with a real browser, stores it in a local database, ranks candidates, and records research experiments and detected events so a screen can be replayed later.
A poster catalogue of your films and shows, built to be driven from about three metres away — with an optional voice layer that can click anywhere on screen, drive VLC exactly, and learn the titles speech-to-text keeps mangling.
Point it at any repository and ask questions in plain language: retrieval over the source feeds a local model that answers, edits and runs an agent loop, with nothing leaving the machine.
Finds anything in a large folder tree, and — only if you ask — tidies one folder up under a safety suite that must pass before a single file is allowed to move.
A browser-based orchestration platform for document-processing workflows that replaced two legacy desktop applications with one interface, running pipelines with real-time progress instead of blocking dialogs.
A local retrieval-augmented chatbot that answers from a markdown knowledge base using hybrid search — keyword and vector results fused by reciprocal rank — with citations back to the source document.
A maths adventure for children — counting to fractions and early algebra, with voice coaching, music and RPG battles — in one self-contained HTML file that works offline, published at number-dragon.pages.dev with the file as a download.
Reads a codebase and writes its documentation: analyses functions, classes, imports and the call graph, then generates prose from the structure with enterprise authentication and token estimation built in.
Say "back", "new tab" or "read this" while browsing and it happens — recognised offline in about 50 ms, and listening only while a browser is in front and actually being used.
Walk through a space narrating it on video and get back a written verbal map; the same recordings can be turned into Gaussian-splat 3D scenes — all on local models and graphics cards.
A desktop-controlled local web server that streams music with matched artwork to any device on the network, started and stopped from a small control window rather than a terminal.
A FastAPI music service with a Svelte single-page front end, WebSocket updates, database migrations, and AI annotations stored against artists and tracks.
A workbench that treats context as a budget: it keeps engineered context under a model-aware cap with explicit headroom reserved, and ingests documents in overlapping batches that preserve salience instead of truncating.
Generates multi-part stories through a local model from named, reusable prompt templates, with batching, live logs and the ability to stop a run mid-flight.
Generates new project skeletons from templates, and converts an existing tree into a structured context bundle — with gitignore-aware scanning and typed parse results rather than string handling.
A single front door for a large collection of standalone scripts — registered, described, themed and launched from one window instead of remembered as file paths.
A C# application for printed-circuit-board work — the only .NET codebase in the estate, and the counterweight to a portfolio that would otherwise read as Python-only.
Extracts individual functions and classes out of source with the surrounding context they need to make sense, so a single entity can be moved between projects or handed to a model without dragging the whole file along.
A self-contained interactive flowchart renderer: open one HTML file and get a pannable, clickable node graph with no server, no build step and no install.
Push-to-talk speech-to-text that runs entirely inside one self-contained HTML file — the model, ONNX Runtime in WebAssembly and the interface all embedded, with no install, server or network.
An incremental game built around social and psychological pressure as mechanics: achievements, notifications and modelled social expectations, with detailed statistics tracked behind them.
Applies multiple code patches at once with class-targeted method insertion, strict validation before anything is written, and a side-by-side review pane listing every function and class the patch would replace or add.
A soundboard that analyses music structurally rather than just triggering clips: select a region of the waveform, find where that motif repeats across the track, and group the results into families.
A REST service wrapping a Qwen speech backend, supporting preset voices, zero-shot cloning from a short reference clip, and multi-format audio output behind a versioned API.
The same flowchart-rendering idea as Graph HTML, carried through fifteen versions, with d3 added alongside vis-network for layout control.
An experiment in building a desktop-style application interface that runs Python in the browser through Pyodide, iterated across several successive attempts kept side by side.
Writes conversations of any length — thirty seconds to four hours — with a local language model, then performs them in chosen voices through Qwen3-TTS Studio, from a browser page or one command.
A competitive block puzzle game with a server-side engine, socket play, accounts and purchasable skills — the rules live on the server rather than in the browser.
Steer how long a local reasoning model thinks while it is still thinking — with the mouse wheel — and a bandit that learns the right budget per kind of prompt instead of guessing it.
Control and telemetry tooling for an HS600 drone, built by capturing and decoding its packet protocol rather than from a published specification.
A compact FastAPI speech service exposing generation, voice listing and health behind a typed API, with custom voices and generation history persisted.
A personal database that captures screenshots with their metadata and stores entries for retrieval by similarity rather than by remembering what you filed them under.
Finds every quoted passage in a document and attributes it to a speaker, turning unlabelled dialogue into an attributed transcript.
Renders three-dimensional data visualisations in the browser, driven from Python-computed geometry.
A local OCR platform built on a 3B-parameter vision-language model specialised for long documents, with a job queue, evaluation harness, and a training-data pipeline that feeds corrections back into the model.
Scans a project and assembles a context file for an AI assistant from its structure and key files, with the output strategy — structured JSON or direct artifact — selectable rather than fixed.
A desktop tool that saves the video embedded in a web page as an MP4, trying yt-dlp, a real browser and, as a last resort, recording playback in parallel parts.
A desktop dictation window that monitors for speech, transcribes locally, keeps a searchable history of what was said, and stays on top so it works alongside whatever you are writing in.
A desktop CSV explorer with stacked filters and regex matching, reporting distinct counts and confirmed totals as the filters change.
Joins video files in a chosen order and combines them with audio tracks or generated speech, with natural-order sorting so files sequence the way a human expects.
A spoken-command grid interface with an offline recogniser, built so its core logic — grid parsing, recognition and the application state machine — can be tested without any of the heavy dependencies installed.
Serves a local transformer model behind an OpenAI-compatible chat completions endpoint, so existing clients can point at it without code changes, with model loading driven from a desktop window.
A focused desktop tool for analysing equities from downloaded market data, with manual row entry for figures that are not in the export.
A desktop control panel for Cloudflare infrastructure: scaffold and deploy Workers, create and redeploy Pages projects, and set up tunnels with their DNS records from one window.