The 580-Line Language That Broke Node

[00:00:00]One developer, one year, one apartment in Oakland. The entire grammar of the language he used fits in 580 lines. C++ has a standards committee, no AI agents.

[00:00:11]This was years before any of that existed, and at the end of it, a JavaScript runtime fast enough that the entire Node ecosystem had to answer for itself. The easy explanation is that he was a genius who never slept. He barely slept. That's not the interesting part.

[00:00:27]The interesting part is the promise the language made him. One that no other systems language is willing to make. The promise is this, nothing happens that you didn't write down. That's what Andrew Kelly set out to build in 2016.

[00:00:40]Not a better C++, a language where the text on screen is the whole story. It sounds like a slogan. It's actually a list of very specific refusals. And what they buy you is boring and enormous.

[00:00:53]When something gets slow, you find it by reading instead of profiling for two days. Refusal one, no operator overloading. In C++, a plus b can be a function call. It can allocate memory.

[00:01:06]It can throw. It can call an operator defined four files away. And it can take a microsecond or a millisecond, the line looking identical either way. In Zig, a plus sign is a plus sign. If you want a function to run, you call it, and you can see the call. Refusal two, no invisible cleanup. C++ runs destructor code at the closing brace, silently. Zig gives you defer. The cleanup is written on screen right next to the thing it cleans up. Then the big one, allocators.

[00:01:36]Zig has no garbage collector and no global malloc it quietly reaches for behind your back. If a function needs memory, it takes an allocator as a parameter, which means allocation becomes part of the function signature.

[00:01:48]You can read a function header and know whether it touches the heap. In most languages, finding that out is an archaeology project. The refusals stop there. What Zig hands back is comptime.

[00:01:58]Instead of macros, instead of templates, it runs ordinary Zig code inside the compiler. Same language, one step earlier. So, you can build a lookup table by writing a loop, and at runtime, the loop is gone. Just data in the binary, costing nothing. Now, C makes a version of the same promise, and keeps it by staying primitive. It never grew the features that hide things. Zig keeps the promise and still gives you comptime and a modern toolchain. Add it up and you get something rare. A systems language you can hold in your head.

[00:02:30]That's the promise. The machine does what the text says, and nothing else.

[00:02:34]So, who actually uses this? The first name the Zig community reaches for isn't a toy. It's a database that moves money.

[00:02:40]TigerBeetle is a financial accounting database written entirely in Zig, not partly, entirely, with essentially zero external dependencies. Zig, its standard library, and the discipline to say no to everything else. The part people underestimate is how they test it. They call it deterministic simulation testing. Instead of running unit tests and hoping, they run the entire cluster inside a simulated universe, where the simulator owns the clock, the network, and the disks. Then, it starts breaking things on purpose. Packets get dropped, reordered, duplicated, disks corrupt sectors, machines die mid-write and come back holding garbage. Every run is seeded, so every failure reproduces exactly. A crash that appears once in 10 million operations isn't a ghost story.

[00:03:24]It's a number you type back in. That style of testing only works if you genuinely control the machine. No hidden allocation means no surprise pause at 3:00 in the morning. No garbage collector means no pause you didn't schedule yourself. This is where chapter 1 stops being aesthetic and starts being operational. TigerBeetle is the exhibit the community keeps behind glass. But, notice what it is. A team choosing Zig deliberately for a problem shaped exactly like Zig. The harder question is, what happens when someone picks Zig for a problem that doesn't obviously fit? If this kind of breakdown is useful, you can support the channel on Patreon or by becoming a member. Jarred Sumner found Zig on Hacker News, the language reference on a single page.

[00:04:05]What got him was the level of low-level control it handed over. Then he did something disproportionate. He started rebuilding the JavaScript toolchain. Bun began as a port of S Build's transpiler from Go into Zig. It did not stay there.

[00:04:17]It became a runtime, then a bundler, then a package manager, then a test runner, the entire toolbox in one binary, written in a language that hadn't hit version one, and that most engineers had never opened. Roughly a year of work, one person, that apartment. Here's the detail everyone skips now. This was before the LLM era.

[00:04:36]Every one of those lines was typed by a human who had to keep the whole architecture in his own head, which is precisely the argument for the language.

[00:04:43]When nothing is hidden, there's less to hold. No template metaprogramming to decode. No destructor firing somewhere off screen. No allocator you have to guess at. By his own account, that control is a big part of why he could move that fast. The language got out of the way and stayed out of it. Then Bun shipped. The benchmarks went viral.

[00:05:01]Install times fell off a cliff, and Node suddenly had a competitor it had to take seriously. For a long stretch, that was the whole story, and the best advertisement Zig could have asked for.

[00:05:12]One engineer, a language that hadn't hit version one, and a product that made an entire ecosystem uncomfortable. Now the uncomfortable part. Zig still hasn't hit 1.0. That isn't an insult. It's a statement of intent. The language reserves the right to change itself, and it uses it. Moving between versions has meant real work. Things move. The standard library reshapes. Your build file breaks. For one person who wrote every line, that's an irritating afternoon. You put it there. Scale changes the math. The community is small. The tooling is younger.

[00:05:45]Debuggers, package infrastructure, the whole boring layer nobody notices until it's missing. Hiring is harder because most people who can write Zig learned it on purpose, not because a job asked them to, and memory safety is still yours to enforce. Zig helps far more than C does.

[00:06:02]It does not promise what a borrow checker promises. So, here's the real problem. That code base was built by a single mind in a language whose entire premise is that you can see everything.

[00:06:12]When it's a team, when there's funding, when somebody new has to be on-boarded into it. Does no hidden anything still hold when the person who wrote it isn't the only one reading it? That question isn't hypothetical anymore. It already got answered, and not slowly.

[00:06:28]11 days, 64 AI agents running at peak.

[00:06:32]One of the loudest bets in the language's short history, resolved in a way that split the community straight down the middle, including the man who created Zig. Bun rewrote 535,000 lines of Zig into Rust in 11 days using AI. What it cost, how it was possible, and what it really says about the language. That video is already up.

[00:06:52]Links on screen.