Things I'm building.

OS 27 introduces more capable on-device models with text and image understanding, alongside access to larger server-based models through Private Cloud Compute. This project provides a quick way to explore how those models perform for a specific product idea before building the complete feature.

Choose a model, provide text or an image, define the desired JSON structure, and run the same prompt multiple times. The workbench groups matching responses and shows their level of agreement alongside latency, making it easier to refine instructions and understand how consistently a model behaves.

A shared core supports a local HTTP server, a native macOS app, and an iOS app.

The project began as an experiment using outdoor security-camera images. Rather than treating each camera event as a simple motion trigger, I wanted to add meaningful context about what was happening—producing structured information that another system could use for better notifications and automation.

A working 6502 microcomputer simulator on a path toward a teaching tool. CPU, RAM, ROM, VIC video chip, and a 6522 VIA peripheral wired to a memory-mapped bus with hardware-realistic chip-select decoding — demos written here are intended to transfer to real silicon unmodified.

Built in Go on top of foxpro-go (a from-scratch homage to FoxPro for DOS) and 6502-netsim-go (a transistor-level Visual6502 port). Same source compiles as a TUI and as a WebAssembly app.

Nothing here re-creates Merlin's six games. The 1978 program is executed one instruction at a time, and the light-show, the tones, and all six games emerge from running the real chip's code.

The same pure-Go core runs three ways — a browser build (Go → WebAssembly, audio via an AudioWorklet), a CLI for tracing and debugging, and a dependency-free package anywhere Go runs. The interpreter is verified bit-for-bit against a C++ reference across 200,000 instructions.

A target-port of the Merlin emulator idea: instead of rewriting Merlin's six games for the C64, the 6502 program emulates the TMS1100 well enough for the original ROM to run.

The port is tested in lockstep against the trusted Go core by assembling the C64 program, running it in a neutral 6502 emulator, and comparing every TMS1100 instruction boundary. The result is intentionally honest about the tradeoff: real engine, real ROM, slower than the original toy on stock C64 speed.

Reconstructs the C64's display from device memory about once a second — text (hi-res, extended-background, and multicolor character modes), bitmap modes, hardware sprites, and the border — and composites it into a live Screen window, alongside a Text Screen, a Sprite Inspector, and a command window (RESET, TYPE, RUN, POKE, PEEK…).

Built on foxpro-go over the u64ctl core. The same Go source runs as a terminal TUI (Unicode half-blocks) and as a WebAssembly app drawing real pixels on an HTML canvas; a small broker serializes device access across tools and proxies the calls, so the browser build has no CORS problem.

A direct-manipulation editor for ASCII animation that emphasizes immediacy: edit, scrub, share. Frame buffer, timeline, and export pipeline all designed to keep the loop between idea and result as short as possible.

A typographic word clock — letters arranged in a fixed grid, lit selectively to spell out the current time as a phrase ("IT IS HALF PAST THREE"). The gallery shows physical builds and color schemes; the repo has the firmware and a browser-based simulator.

Pairs a tiny local script with a TRMNL private plugin to surface live Claude Code usage on an e-ink panel. The "ambient awareness without checking a tab" pattern, applied to AI-coding budget tracking.