A Rust developer rebuilt his JSONPath library in Zig, and the surprise was the tooling

Language comparisons are usually written by people who spent a weekend with the newcomer. This one is worth reading because the author picked a harder test: he already maintained a JSONPath implementation in Rust — the query language standardised as RFC 9535 — and rebuilt the same thing in Zig, so the two versions can be held against each other feature by feature rather than by impression.

Three observations from the write-up are worth carrying away.

The missing IDE turned out to be the story. Coming from a full JetBrains setup, he found Zig offered little beyond highlighting and basic completion, and the workaround was to run everything through build.zig from the command line — named steps for the test suite, a filtered single test, a debug variant, the compliance suite. His verdict is the interesting part: what began as a deficiency ended as a preference, and it pushed him off the IDE entirely.

Allocators are the language, not a detail of it. Nearly every function takes one and nearly every structure holds one. Nobody who reads the Zig documentation is unprepared for this, but reading about explicit allocation and living inside it for the length of a real library are different experiences, and the write-up is honest that the cost is paid in every signature.

Flat beats nested, and the language quietly insists. Rust lets you tune the balance between file size and directory depth for as long as you have patience for it. Zig makes nesting mildly awkward and, in doing so, asks what the depth was buying. His answer after the rewrite: less than he assumed.

What it means

A rewrite by the same author is the only fair language comparison, and it is rare. The usual article compares someone's first Zig project against their tenth year of Rust. Here the domain, the specification and the person are held constant, which means the differences that remain are more likely to be about the languages. If you are evaluating a language for your team, this is the shape of evidence worth asking for — not benchmarks, not syntax tours.

Tooling is a language feature, and teams keep pricing it at zero. The part of this report that will decide adoption in most shops is not the allocator model; it is that a developer coming from a mature IDE spends the first weeks rebuilding his workflow. That cost is real, it lands on every hire, and it rarely appears in the evaluation document — while the borrow checker, which people argue about, is a one-week problem.

And note what the author does not claim. He states up front that this is his first Zig project, that some of his choices are Rust habits rather than Zig idiom, and that a more experienced reader will find parts of it naive. An experience report that names its own limits is more useful than a confident verdict, and it is the reason this one is worth your twenty minutes.

Both libraries are linked from the post, so the comparison can be checked rather than believed.