I take things apart to find out how they work.

The interpreter loop and the timers run on separate clocks: 700 Hz for instructions, 60 Hz for the timers, both independent of the display refresh. Share one and instruction throughput fights frame timing: fast enough to feel responsive and the display tears; slowed to 60 Hz and the games crawl.

Profiling put the allocator above the matcher. Memory-mapping hands you the file as one borrowed slice, so a match becomes a pair of offsets into memory the kernel already paged in. Nothing is copied in order to be looked at.

The queue is unbounded on purpose. Workers both consume and produce, so a bounded queue deadlocks the moment every worker blocks on a full one. What bounds the crawl instead is the visited set and a page slot reserved atomically before each fetch. A pending counter covers queued plus in-flight work; when it reaches zero the queue closes and the workers exit.

Each block commits to the hash of the one before it, so validation is recomputation: index continuity, the previous hash, the block’s own hash, then the proof of work. Change one byte and that block’s hash moves, the next block is left pointing at a hash that no longer exists, and repairing it means mining every later block again. Difficulty is a count of leading hex zeros, so it moves in steps of sixteen. The nonce is an integer you increment; there is no cleverness in the search at all.

I built it to understand how market making actually works rather than to produce anything new, and the code was the easy half. The idea worth the attention is the reservation price: not the mid, but the price you are indifferent to holding your current inventory at. Quote around that instead and the skew that unloads a position falls out of the model rather than being bolted on. Everything the paper leaves out (an order book with depth, queue position, what happens when its assumptions do not hold) is where the rest of the work went.

A round trip needs no reference price, and that matters: Jupiter’s price is an index, not the mid of the pool you route through, and measuring against it put METAx at −4.4 bps, buying below mid. Both legs are quoted in raw units, so Token-2022’s scaled-UI multiplier cancels too; ignore it anywhere else and a holding is off by up to 57 bps.

State sits behind an Arc<RwLock<…>>: many readers evaluating, one writer applying each push. Channels were the alternative, but then every consumer keeps its own copy of the book and they drift under load. One shared truth, briefly locked.

Statements are chaos as text, so parsing anchors on the one thing every transaction has: a date and time. Lines are split into blocks at those anchors, then vendor, amount, UTR and direction are pulled out of each block. Extraction runs in a Web Worker so the page never freezes, and scanned pages with no text layer fall back to OCR.

A Rust engine compiled to WebAssembly streams the file through a worker in 10 MB chunks, so size is limited by time, not memory. Chunks rarely end on a record, so the unfinished tail is carried into the next one. Stats are single-pass (Welford), duplicates are 64-bit row fingerprints rather than rows, and medians come from a reservoir sample.