The editorial argues that Zig's funding structure resembles a 19th-century scientific society rather than a modern open-source foundation, with one wealthy patron carrying a disproportionate share. It contrasts this with Rust's diversified corporate sponsorships, Go/Swift's corporate backing, and Python's broad membership base, framing Hashimoto's recurring contributions as both remarkable generosity and a structural risk.
As HashiCorp co-founder and Ghostty maintainer using Zig in production, Hashimoto has escalated his pledges from $200k in 2024 to $400k in both 2025 and 2026. His continued commitment signals confidence that funding Andrew Kelley and the small ZSF team to ship the self-hosted compiler, incremental build system, and async overhaul is delivering real progress — evidenced by Zig 0.14's stable self-hosted x86 backend.
By submitting the announcement to HN where it rapidly crossed 580 points, tosh and the upvoting community signaled that this kind of individual long-term commitment to a systems language project is noteworthy and worth amplifying, not just a routine check-writing event.
The editorial notes Andrew Kelley's transparency that ZSF runs with a handful of full-time engineers, no office, and no marketing — meaning Hashimoto's contributions can directly fund core developer salaries rather than overhead. This lean structure is what makes a single patron's six-figure check materially move the needle on compiler development, unlike foundations where similar sums would be absorbed by administrative costs.
Mitchell Hashimoto — HashiCorp co-founder, current Ghostty maintainer, and one of the most visible Zig users in production — published a short note on June 21 pledging another $400,000 to the Zig Software Foundation (ZSF) for 2026. The HN thread crossed 580 points within hours, which is unusual for what is, mechanically, a check-writing announcement.
The number matters less than the pattern. Hashimoto pledged $200k in 2024, $400k in 2025, and now $400k for 2026 — roughly $1M from a single individual to a foundation whose total 2024 revenue was reportedly under $700k. Andrew Kelley, Zig's BDFL, has been transparent that the ZSF runs lean: a handful of full-time engineers, no office, no marketing. The math means Hashimoto's personal contributions have, at points, exceeded the salary cost of a Zig core developer.
The stated use is unchanged from prior years: fund Kelley and a small team to keep shipping the self-hosted compiler, the incremental build system, and the async overhaul. Zig 0.14 landed earlier this year with the long-promised self-hosted x86 backend stable enough to bootstrap. 0.15 is in progress. None of this is unusual for a young systems language. The funding structure is.
Look at how other independent-ish languages stay alive. Rust is governed by the Rust Foundation, whose platinum members (AWS, Google, Huawei, Microsoft, Meta) each write low-six-figure annual checks; the foundation's 2023 revenue was around $2.5M, spread across dozens of corporate sponsors. Go is a Google cost center with a public veneer. Swift is Apple's. Python's PSF runs on membership dues, PyCon revenue, and corporate sponsorships — Bloomberg, Microsoft, Meta, AWS at the top tier. Even Deno and Bun are VC-backed companies whose runtimes happen to be open source.
Zig is none of these. The ZSF's funding mix is closer to a 19th-century scientific society than a modern open-source foundation: one wealthy patron carrying a disproportionate share, a few small corporate sponsors (TigerBeetle, Bun's parent Oven), and GitHub Sponsors dust. Kelley has explicitly resisted the obvious upgrade path — taking a strategic investment from a cloud or chip vendor — on the grounds that it would compromise the language's governance independence. The position is consistent. It is also, financially, a tightrope.
The community reaction in the HN thread split along predictable lines. One camp celebrated Hashimoto as the kind of patron open source needs more of — a successful founder recycling capital back into infrastructure he uses. The other camp pointed out, correctly, that a language whose runway depends on one person's continued goodwill is a language with a single point of failure that no amount of compiler engineering can fix. Both are right. The interesting question is whether the patron model is a transitional state or a stable one.
There's precedent on both sides. SQLite runs on a similar small-team, low-overhead model and has for two decades — but D. Richard Hipp built a consortium of paying corporate users, not a sole patron. Lua is funded by PUC-Rio and a handful of grants, surviving on extreme institutional thrift. Tcl had John Ousterhout and Sun, then drifted when both moved on. The pattern: languages that survive 20+ years on lean funding tend to either institutionalize their sponsor base (SQLite) or accept slower velocity in exchange for stability (Lua). Zig is trying to ship like a VC-funded runtime on a patronage budget. That works as long as the patron keeps writing checks.
If you're already running Zig in production — and the list of teams doing so is no longer trivial: Bun (JavaScript runtime), Ghostty (terminal), TigerBeetle (financial database), Roc (compiler infrastructure), parts of Uber's mobile build — the funding model is now a real risk axis on your dependency review. Not because Zig is about to disappear. Because the language's pace of breaking changes is set by a team whose headcount tracks one donor's personal P&L, and you should price that into your upgrade planning.
Concretely: budget for the migration cost of every 0.x release. Zig has been admirably honest that pre-1.0 means pre-1.0 — the async rewrite alone will touch every codebase that touches I/O. The team can only ship those rewrites as fast as it can hire, and it can only hire as fast as the ZSF can fundraise. If Hashimoto's next pledge shrinks, the release cadence shrinks with it. That's not a criticism; it's just the shape of the org chart.
The second-order implication is governance. Patron-funded projects tend to reflect the patron's priorities, whether anyone admits it or not. Hashimoto's public Zig work — Ghostty, mostly — is a GUI terminal that leans hard on cross-platform compilation and incremental builds. Those are exactly the areas Zig has prioritized. There is no conspiracy here; Hashimoto is funding the language he uses. But teams betting on Zig for, say, embedded or kernel work should track whether their use case stays first-class as the foundation's funding base evolves.
The interesting milestone isn't Zig 1.0 — it's the first year the ZSF's corporate sponsor revenue exceeds its largest individual donation. That's when the patron model graduates into the SQLite model, and Zig stops being one founder's hobby budget away from a hiring freeze. Until then, Hashimoto's third $400k check is less a celebration than a status report: the bridge financing is holding, the compiler is shipping, and the question of what happens in year five is still open.
If you're unsure about spending the time to learn Zig, I really recommend watching the following interview with the creator of Zig https://www.youtube.com/watch?v=iqddnwKF8HQ convinced me more than any design doc or blogpost could
It's great to be in a position to do this, however I'm beginning to think that their greater contribution is ghosttyI don't really know how to value things any more when I see someone develop a tool that is kind-of useful that then gets acquired for half a billion dollars. As someone
I think it makes perfect sense for Zig to have their stand against LLM contributions while consumers of the compiler/Zig project overall use whatever code aids they like. Building a language is not a matter of churning out as much greenfield code as possible, but in careful consideration of whe
I have been experimenting with modifying Ghostty lately. It's a well attended codebase and a pleasure to work with, props to Mitchell.Since Ghostty is written in Zig, I ended up adding native Zig AST support in Dirac (https://github.com/dirac-run/dirac/blob/master&
Top 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.
What a word of wisdom right there, the bit about internet is beautiful because it's ok to be weird - this is often the opposite on twitter, fb, reddit and many discords where if you have a different opinion you get mobbed by angry comments making one feel worse about their own weirdness.