ZacWalk

I take a lot of photos and videos. In 1998 I wrote my own PC photo management software, ArtMate, a tiny thumbnail browser. It was fast and minimal because life is too short for slow software. It grew into ImageWalker, shareware that turned out to be surprisingly popular, and ImageWalker grew into Diffractor.

Diffractor is free, local-only and fast, with Direct3D and SIMD doing the heavy lifting. It reads RAW, puts photos on a map from their GPS, spots duplicates even after they have been resized or re-encoded, and speaks 14 languages. It is open source too. Twenty-odd years in, I am still not sure it is finished.

I have also brought imagewalker back to modern 64-bit Windows, old versions and a new 3.0 alongside them. It shares libfiles with Diffractor: one C++20 library for media formats and metadata, so a format fix lands in both.

My first brush with machine learning came at a Microsoft hackathon around 2015, while I was working on Skype. The idea was a video call that worked over a 2G network, at about 10 kbit/s. At that speed all you can send is a blurry mess, so low-ban tracks the landmarks of your face and sends those along too: you can at least see whether someone is smiling. I demoed it to Skype's head of design, who wore all black and really looked the part. Nothing came of it, but I still poke at it; these days a learned autoencoder runs beside a classic codec on the same webcam frame.

Having been a compiler engineer for a while, I also wondered how far I could get running an LLM on an ordinary CPU. nncpu is where that led: a Rust library and command-line app, ported from my earlier C++ implementation. It runs GGUF models such as Gemma, Llama and Qwen with quantised weights and AVX2/FMA kernels. You can chat with it, use tool calls and embeddings, or put it in your own app. No graphics card, cloud account or Python, and nothing you type leaves your machine.

I have always found the financial world fascinating. In 2007 I worked at Merrill Lynch, the year it lost more than $20 billion on subprime mortgages. Not my fault. I invest in technology stocks myself and publish my research at Alpha Galactica. It is not financial advice. I also tinker with reinforcement learning and trading in trade-rl, an offline research bench written in Rust. An agent picks short, flat or long after each bar closes, and walk-forward experiments compare it with baselines and controls. The trading costs are part of the score, not a footnote.

Underneath it is trade-db, my embedded market-data database, also in Rust. Ticks, quotes and candles live in one crash-safe file, with zero-copy scans and readers that can keep going alongside a writer. It also has as-of lookups, so a backtest can ask what was known at the time rather than accidentally borrowing tomorrow's answer.

I learned to program on a Commodore 64. I think it is a machine simple enough for anyone to understand how computers work. 64Ready is my educational C64 emulator in the browser: type BASIC into a live machine, single-step 6502 assembly, or watch the bus traffic as it boots. lib8bit is my embeddable C++20 C64 emulator, with a small Windows host.

When Microsoft open-sourced MS-DOS 4.0, I wanted to build it myself, but that needs the original 16-bit tools, so I wrote libdos, a DOS emulator library with command-line and windowed hosts, and its own 16-bit C compiler. Its demu runner builds and boots dos4z, a version of DOS 4.0 with bug fixes and larger disk support. It allows my IBM 5150 to boot and work well with my CF hard drive adapter.

In 2022 I wrote the proposal for Microsoft to back a GNU toolchain for Windows on Arm. It was accepted, and I worked with Linaro's compiler team and other open-source contributors to add support for that backend.

In that role I did a lot of low-level training inside Microsoft. vector-experiments started life as that course: in its 64-byte distance benchmark, hand-written AVX2 beats the scalar MSVC build by about 34 times.

Later I moved to work on Rust at Microsoft, where Oxidizer is the framework behind some of its most critical services. One of my first Rust experiments was http-sys-rust, now an async server on the Windows kernel's HTTP stack, with a benchmark harness to compare it with axum. One of our Rust experts said the first version looked like a C++ developer trying to write Rust. Fair enough.

I grew up in the glory days of Win32, when an app was one small, fast .exe, and I have been writing them ever since. Around 2000 my employer still supported Windows 95, whose task manager really was basic, so I wrote my own improved version, sys-mate. It now shows live performance charts, processes, network connections and windows. Around that time I also wrote ergo-active with my London neighbour, a Swedish furniture designer. It reminds you to take a break if you have been using the computer too long.

Then I spent a few years on the other side of the fence, owning the native code in the Teams desktop app, which ran on Electron. I managed that team but did make a few Electron contributions: I swapped Electron's WTL file dialogs for plain Win32, extended its tracing so we could see where the memory went, and wrote electron-bench, which shows that the IPC path everyone argues about barely changes latency, but changes main-process CPU by more than 60 times. My longest-lasting contribution is a “temporary” fix to Chromium's build from 2018. It is still in Electron today, FIXME and all.

I have my own C++20 platform and UI layer for native apps, libdesktop, shared by the editor, browser and Diffractor. They build with dd, a PowerShell build and dependency tool that scaffolds projects and drives CMake. My editor, dde, renders with plain GDI and lets me edit, build, test and run dd projects from the keyboard, with the output beside the code. potato is the web browser I wrote to learn CSS: probably the worst in the world, but its HTML/CSS engine is now a reusable library, libwebvis. Still no JavaScript.

fast-draw is for vector diagrams and quick sketches, with its own anti-aliased software renderer. And a few games: zpilot began in 1995 as a Turbo C++ game for DOS; now it is a Windows cave flyer, hauling an orb on a swinging chain. My port of Stunt Car Racer, which I loved on my C64, draws the whole race with a software 3D renderer, without GPU acceleration.