In 2023, Zig’s Andrew Kelley made a decision that should terrify every CTO: he filed for divorce from LLVM. By 2025, that divorce was final, and Zig had completely left Microsoft’s GitHub. This isn’t just a technical story—it’s a roadmap for anyone questioning whether their dependencies are helping or hurting them.
The dependency weight was substantial. LLVM itself is written in 40.9% C++ and 30.9% C, with the complex toolchain dependencies that come with it. When you depend on LLVM, you inherit not just a compiler but an entire C++ ecosystem.
When you depend on LLVM, you inherit not just a compiler but an entire C++ ecosystem.
The LLVM Divorce: Nine Reasons to Walk Away
Andrew didn’t just leave LLVM. He documented exactly why:
- LLVM is slow.
- Using a third-party backend for the compiler limits what kind of end-to-end innovations are possible.
- Bugs in Zig are significantly easier for us to fix than bugs in LLVM.
- LLVM regularly ships with regressions even though we report them against release candidates.
- Building Zig from source is made obnoxiously difficult by LLVM.
- Many of our users are interested in avoiding an LLVM monoculture.
- LLVM development moves slowly.
- We want to add support for many more target CPU architectures than LLVM supports.
- We cannot control the quality of the LLVM libraries that appear in the wild.
Read that list again. It’s not about LLVM being bad—it’s about control. When you rely on someone else’s code, you inherit their priorities, their timeline, their bugs. Your urgency becomes their backlog ticket.
The Self-Hosted Backend: 5x Speed as Proof
June 8, 2025. Zig makes its self-hosted x86 backend default in debug mode. The result: 5x faster compilation. Why compete with LLVM on code generation? Because they could ‘dramatically outperform LLVM at compilation speed.’
This isn’t just about speed—it’s about autonomy. The self-hosted backend means:
- All bugs are belong to Zig
- No dependency on C++ toolchain
- Complete control over compilation pipeline
- Ability to innovate end-to-end without asking permission
When you control your entire stack, you don’t wait for upstream fixes. You fix them yourself.
The Breaking Point: GitHub Actions
The final straw wasn’t technical. It was operational. GitHub Actions, the CI/CD platform that developers depended on, was crumbling under Microsoft’s ownership.
The story centers on safe_sleep.sh—a four-line Bash script with a catastrophic bug:
SECONDS=0
while [[ $SECONDS != $1 ]]; do
:
doneInstead of actually sleeping, it busy-waited. On overloaded CI machines, if the process wasn’t scheduled during the exact one-second interval when $SECONDS had the correct value, it would spin forever, consuming 100% CPU for hours.
Zig’s team found multiple processes running for hundreds of hours, silently taking down runner services for weeks. This wasn’t an isolated incident. It was systemic neglect.
As Matthew ‘mlugg’ put it in August 2025:
The sloppy coding which is evident here, as well as the inaction on core Actions bugs, is forcing the Zig project to strongly consider moving away from GitHub Actions entirely. We can no longer trust that Actions can be used to implement reliable CI infrastructure.
Andrew was more direct in Zig’s migration announcement. He didn’t mince words: ‘Putting aside GitHub’s relationship with ICE, it’s abundantly clear that the engineering excellence that created GitHub’s success is no longer driving it. Priorities and engineering culture have rotted, leaving users inflicted with some kind of bloated, buggy JavaScript framework in name of progress. Stuff that used to be snappy is now sluggish and often entirely broken.’
Codeberg: Choosing Commons Over Capitalism
November 26, 2025. Zig migrates to Codeberg. This isn’t just a platform change—it’s a philosophical statement.
Codeberg is:
- Non-profit and community-led
- Based in Berlin, Germany (European sovereignty)
- 390,203 projects
- 256,133 users
- 1,300+ members
- ‘Supporting the commons comes first’
Contrast this with Microsoft: a trillion-dollar monopoly treating open source as a vehicle to lock developers into their AI ecosystem.
The Hard Questions
Which brings us to you. Have you questioned your dependencies?
Every dependency is a vote of confidence in someone else’s ability to fix bugs faster than you can adapt around them. Every platform choice is a bet that someone else’s priorities align with yours.
Zig’s journey teaches us something crucial: when you control your stack, you control your destiny. The cost of maintaining your own infrastructure is always higher than you think, but the cost of being dependent on someone else’s neglect is always higher than you can calculate.
Ask yourself:
- What critical systems depend on platforms you don’t control?
- How many times have you waited for someone else to fix a bug blocking your work?
- Could you deliver value faster if you owned more of your stack?
The Zero-Dependency Mindset
This isn’t about writing everything from scratch. It’s about strategic independence:
- Own what matters: Your critical path should be your code.
- Control interfaces: dependencies should be replaceable, not essential.
- Plan exits: every dependency should have an escape route.
Zig didn’t eliminate LLVM overnight. They built their own backend incrementally. GitHub’s neglect didn’t force an immediate migration—it provided the urgency to execute the plan.
Owning your tech isn’t about isolation. It’s about having the ability to say ‘no’ to someone else’s roadmap, bugs, and priorities.
The question isn’t whether you can afford to own your stack. It’s whether you can afford not to.