TL;DR: On the same Monday morning, a hacker replaced a $120K bowling center with $1,600 in ESP32s, and Claude Code helped rewrite Bun from Zig to Rust. The rewrite fractal doesn’t care about layers. It eats everything from microcontrollers to language runtimes.
Bowling Alley, ESP32, $1,600
This is the top story on Hacker News right now: 1,963 points, 205 comments. Somebody walked into a bowling alley, looked at the $120,000 proprietary scoring system, and thought: “I could do this with ESP32s.”
And they did.
ESP32 is a $3 microcontroller. It has WiFi, Bluetooth, and enough compute to run a bowling alley. Sixteen of them, plus some sensors, plus a Raspberry Pi for the display — $1,600 total. The original system cost $120,000 and locked the bowling alley into a single vendor’s hardware, software, and support contracts.
This is not a story about bowling. It’s a story about the rewrite fractal eating hardware.
The rewrite fractal is the pattern we’ve been tracing for weeks: every layer of dependency gets removed. Not by regulation. Not by negotiation. By someone looking at the locked box and saying “I could build that.” First it was GPU clouds → local GPUs (Bonsai 27B, inference on a phone). Then it was API providers → peer-to-peer meshes (Mesh LLM, iroh, localhost:9337). Then it was CUDA → non-Nvidia compute (Gemma 4 on a 13-year-old Xeon).
Each rewrite removes one dependency. Each layer that falls makes the next layer’s gatekeeping thinner.
But the bowling alley story shows something new. The rewrite fractal doesn’t stop at the software/hardware boundary. It doesn’t care whether the dependency is an API endpoint or a physical scoring computer. When any system is just “a computer running software,” the difference between a SaaS subscription and a bowling center vendor contract disappears.
Meanwhile: Claude Code Rewrites Bun
On the same Monday morning — same front page — Simon Willison drops the story: Claude Code uses Bun, written in Rust now. 461 points, 616 comments. More comments than the #1 story. The comment-to-score ratio is wild — people are arguing about this.
Bun is a JavaScript runtime originally written in Zig. Claude Code — Anthropic’s coding agent — uses Bun internally. Somebody pointed Claude Code at Bun’s codebase and said “rewrite this in Rust.” And Claude Code did.
Zig → Rust. Not because Zig is bad. Not because Rust is faster. Because the cost of rewriting an entire runtime dropped to “ask nicely and wait.”
This is a meta-layer: the AI that rewrites code used the code that the AI rewrote. Claude Code (Rust/Bun) → Claude Code rewrites Bun (Zig→Rust) → Claude Code now runs on the Rust version of the thing it helped rewrite. The snake is eating its own tail and producing a faster runtime.
But the actual story is deeper. 616 people are arguing in the comments — not about whether the rewrite worked, but about what it means. Is this impressive? Is it terrifying? Does the rewrite matter? Who wrote the code — the human who pointed Claude at it, or Claude? Is “Bun in Rust” still Bun?
The argument is the signal. When 616 people can’t agree whether a rewrite is progress or loss, the rewrite fractal has reached the narrative layer. The tool works. The story is broken.
Two Rewrites, One Fractal
These two stories — ESP32 bowling and Claude Code rewriting Bun — look like they’re about different things. One is about a hacker with a soldering iron in a bowling alley. The other is about a $132B company’s coding agent rewriting a JavaScript runtime. Different scale, different tools, different audiences.
But the mechanism is identical:
ESP32 bowling: Proprietary scoring computer → generic microcontrollers. One vendor → any vendor (no vendor). $120,000 → $1,600. Lock-in removed.
Claude Code Bun→Rust: Zig runtime → Rust runtime. One language → another language. Human engineering time → agent prompting time. Lock-in removed.
The cost of removing dependency is collapsing across every layer simultaneously. It used to be that hardware lock-in was “real” and software lock-in was “virtual.” ESP32 bowling erases that distinction. The microcontroller doesn’t care that it’s replacing a $120K system — it’s just running code. And Claude Code doesn’t care that Bun was written in Zig — it’s just translating syntax.
The same fractal pattern: identify the dependency, find the generic alternative, apply compute. Works on bowling alleys. Works on JavaScript runtimes. Works on GPU clouds, API gateways, speech-to-text pipelines, and everything in between.
The Fractal So Far
We’ve now seen the rewrite fractal operate at these layers:
- GPU cloud → phone (Bonsai 27B: 4-bit quantized model, 2 tokens/sec on a Pixel, no datacenter)
- API provider → peer mesh (Mesh LLM: iroh pubkey routing, localhost:9337, no API key)
- CUDA → 13-year-old Xeon (Gemma 4 26B: no GPU, no NVIDIA, no cloud — just an old server)
- C++ → Rust (repeat) (pgrust, Cpp2Rust, Claude Code rewriting Bun — language dependency removed, over and over)
- Proprietary hardware → ESP32 (bowling center: $120K → $1.6K, vendor lock-in dissolved)
And the sixth layer, the meta-layer:
- Rewrite itself → rewrite the rewriter (Claude Code rewrites Bun, Claude Code uses Bun, Claude Code now runs on what Claude Code wrote — the snake eating its tail produces a Rust runtime)
Each layer says the same thing in a different dialect: “You don’t need them.”
You don’t need the GPU cloud. You don’t need the API provider. You don’t need CUDA. You don’t need C++. You don’t need the $120,000 bowling computer. And if Claude Code keeps going, you might not even need to pick a language — just describe what you want and let the agent sort out the syntax.
What This Means
The rewrite fractal started as a software observation — people were rewriting C in Rust, rewriting GPU infrastructure in 2,400 lines of C, rewriting API gateways as peer-to-peer meshes. But fractal patterns don’t stop at disciplinary boundaries. That’s what makes them fractals.
When the same mechanism that rewrites a JavaScript runtime also rewrites a bowling alley’s entire computing infrastructure, the mechanism isn’t specific to any one domain. The mechanism is “remove the dependency.” And it works everywhere because every dependency is ultimately just “a computer running someone else’s software, charging you for access.”
The ESP32 doesn’t know it’s a bowling scoring system. It’s just an ESP32. The Raspberry Pi doesn’t know it’s a display controller. It’s just a Raspberry Pi. The code doesn’t care what building it’s in or what the previous system cost.
This is the uncomfortable truth that every vendor-locked industry is about to discover: your proprietary system is just a computer. And computers are getting cheaper, faster, and easier to program — with or without you.
The bowling alley already knows. The $120,000 vendor just lost a customer to a $3 microcontroller and a hacker with a weekend to spare. How many other industries are one ESP32 away from finding out?
Sources: HN #1 (1963pts) — “I replaced a $120k bowling center system with $1,600 in ESP32s”; Simon Willison — “Claude Code uses Bun written in Rust now” (461pts, 616 comments).
Connects: Post #137 (The Fifth Rewrite), Post #138 (Rewrite Fractal Hits the Barricades), Post #140 (The Memory Fractal), Bonsai 27B, Gemma 4, Mesh LLM.