A real pub/sub message broker I wrote in Rust, with genuine zero-copy delivery
and a cross-process shared-memory transport. The most serious engineering I've done.
live: ring buffer, head and tail pointers advancing
in flight: 0routed: 0
I built a proper Vyukov MPMC ring buffer over a memory-mapped file for
real cross-process IPC, and reasoned through why heap pointers can never live in shared memory and why
polling beats OS sleep timers below a millisecond (I leaned on LMAX Disruptor / Aeron precedent for
that). 48 passing tests, CI configured, a Python SDK, and a Svelte companion app.
Correction to my own README: I advertise "lock-free skip lists" for topic routing.
The actual router is a DashMap-backed trie. The skip list's in there somewhere else, just not
doing what I said it does.
Rustasynczero-copyshared memoryIPC
A 12-LED ring transmits data as light; a webcam decodes it. I started with one
bit per LED, ended at a 33-bit protocol that survived several failures I had to measure my way out of.
live: the actual fix, two alternating phases
phase: Aadjacent LEDs lit together: 0
Brightness thresholding gave way to nearest-color classification once I
added a diffuser and introduced real optical crosstalk between LEDs. The fix wasn't better tuning. It
was splitting transmission into two alternating phases so no two adjacent LEDs are ever lit at once,
eliminating the crosstalk instead of compensating for it. Ends with me sending a text message
through light and watching it type itself out.
PythonOpenCVcomputer visionembeddedoptical comms
A runtime I built that separates an agent's fast reflex path from its slow
reasoning path, so a safety-critical reaction never waits on an LLM to finish thinking.
live: reflex path vs. reasoning path, racing
reflex: ~4msreasoning (LLM): ~600ms+
A real modular architecture (tool registry, scheduler, world model, permission
manager, health monitor, plugin loader) with a live dashboard for sensors, actuators, and the reflex
event log. I tried to be honest in the README about where the idea comes from: Brooks' subsumption
architecture, industrial e-stops. I didn't invent the concept, I just gave it a runtime.
PythonasyncWebSocketagent architecture
A passive WiFi analysis suite I wrote (no transmitting, just listening) that
fingerprints devices, classifies hidden networks, and scores security posture in real time.
Under my own loud ASCII-art branding is a real device-category model, a
WPA-tier security scale, and a relationship graph linking access points, clients, and mesh nodes via
OUI vendor lookup. 975KB of Python across an actual package structure. For once, the branding
undersells it.
Pythonnetworkingpassive reconsignal analysis
A single-file WebGL particle system with a genuinely sensible scheduler
underneath (event-loop-lag-driven throttling, a binary heap, a circuit breaker) wrapped in the loudest
marketing copy I've ever written.
live: real shader, 60,000 of the full 16.7M nodes
I call this the Aizawa attractor. A handful of equations
that never repeat and never sit still, but never blow up either. Run every particle's ID through it
and you get this jellyfish shape for free. Chaotic math is doing the animating, not me hand-keying
anything. Full repo scales to 16.7M points. I capped this card at 60,000 so it doesn't melt your
laptop.
Scales live from 1,024 to 16.7 million particles via a slider on the real
page. The standout part isn't the particle count. It's the Nexus Controller, which measures
actual frame delta-time and throttles motion when the frame budget blows, so it degrades gracefully
instead of just getting choppy.
WebGL2GLSLchaotic systemsgenerative
The project I probably talk about the least, and I'm not sure why: a fully
local, fully offline stage that gives any script of mine a face and a voice, one HTTP call at a time.
live: amplitude-driven, not a canned loop
speaking
A three-tier local TTS fallback chain I built (Kokoro-82M, then Piper, then the
browser's own TTS if both are unavailable), optional RVC voice cloning through Applio, and real
amplitude-driven lip sync, the mouth actually moves with the audio. I built a drag-to-calibrate
tool so I could map eye/mouth hotspots onto a real photo instead of hand-coding coordinates.
PythonTTSWebAudiolocal-first