Skip to content

Projects — William J.P. Armstrong

Built for myself

Projects

Software I built because I wanted it to exist. Three of these you can download and run today. One is unfinished, and says so on its own front page — which is the more useful thing to read, because it is where the reasoning shows.

Cinder — a wipe tool that says what wiping cannot do

Overwrites deleted files, free space and spare memory on an Android phone. The unusual part is the documentation: flash storage quietly moves blocks around underneath you, so the app states which of its three modes guarantees anything and which cannot, and keeps its own audit of what has never been tested on a real device.

  • 19tests pass
  • 4CPU architectures
  • 0internet permissions
Read the case study →

ThunderCrab — a mail client that shares what it learns, never what it reads

It works out how you sort your inbox and can pass those rules to other people's copies. A shared rule cannot carry your mail, and not because the code is careful: the type that describes one has eight shapes and none of them can refer to a message body.

  • 138tests pass
  • 8shareable rule shapes
  • 0of them touch a body
Read the case study →

Two of these six exist mainly to record a claim I had to withdraw after measuring it. That is the useful half of building things nobody asked for.

Tempered Studio — teaching Rust by refusing to give the answer

Seventy-eight lessons and ninety-one deliberately broken programs. Every exercise declares the exact compiler error it is built to teach, and a script compiles all ninety-one against the real rustc to check that error still appears — so a well-meaning fix that quietly destroys a lesson fails the build.

  • 78lessons
  • 91broken programs
  • 0answers on the server
Read the case study →
The Tempered Studio practice screen: a deliberately broken Rust program, a prompt asking the learner to predict whether it will compile, and a list of later exercises still locked

Ermine — a Monero wallet, and a claim I had to take back

Every account takes its own route through Tor so a node cannot tie them together. I built the measurement to prove it, went below the Tor client library to read the actual circuit identities, and found the result did not support the sentence on the website. The sentence changed.

  • 439tests pass
  • 1Tor circuit per account
  • 0releases yet
Read the case study →
$ rm -rf static/ && forge build --root .
  strict findings:     0
  duration:            1161ms
forge build OK
# # 62 phases; output byte-identical to what the server was serving

Forge, Loom and Crawler — the tools this page is made of

A compiler that turns typed documents into a website and refuses to ship one that fails its own audit: contrast, landmarks, security headers, page weight, buttons that go nowhere. Delete this page's built output, run the build again, and the bytes come back identical.

  • 220klines of Rust
  • 5,018tests pass
  • 62checks per build
Read the case study →

Sacred Vote — a receipt you can check without being watched

Online voting where the voter can confirm their own ballot is on the record. The browser fetches a published root and an inclusion proof, both public data identical for every caller, and folds them itself — so the server is never asked to look up who voted for what.

  • 237test files
  • 2live clients
  • 1proof you can recompute
Read the case study →

Why these sit apart from the client work

Client work is judged on whether it runs and keeps running, and the four sites under Work do. These are judged differently. Nobody commissioned them, so each one exists to settle a question I could not settle by reading: whether a wipe tool can honestly promise anything on a phone, whether a sorting rule can be shared without carrying mail with it, whether a beginner learns faster when the program refuses to tell them the answer.

It is also where the working out is visible. Three of them ship a document arguing against their own strongest claim, and I would rather a prospective client read one of those than a page on which everything went right the first time.

The rest of it

Seventy-six public repositories

These six are the ones worth an hour of reading. The index has the rest, grouped and honestly labelled — including the ones that went nowhere.

Code