Zig Software Foundation Calls Out Zen Over Licensing Model and Copied Code

The Zig Software Foundation has published a formal statement taking direct aim at Zen, a closed-source fork of Zig maintained by connectFree, citing concerns over Zen's commercial licensing terms and the incorporation of Zig code — most notably its async/await implementation — without adequate acknowledgment.

The statement lands at a time when Zig's own development continues to advance: Zig 0.16 has been released, making the contrast between the two projects' trajectories sharper than ever.

What Zen Is, and Where It Came From

Zen is a closed-source compiler and language maintained by connectFree, a company founded by Kristopher Tate. According to connectFree's own "Evolution from Zen" page, Zen has developed independently from Zig since version 0.3.0. That claim of independence is, in broad strokes, accurate — the language surface has diverged — but the Foundation's statement identifies a specific area where the divergence narrative breaks down.

Tate is not a peripheral figure in the Zig community. He is listed as the number-five contributor to the Zig project, a non-trivial position in a relatively small open-source ecosystem. That background makes the Foundation's complaint more pointed: this is not a case of an outside actor lifting code, but of a former contributor building a proprietary product on top of work he helped create — work that also carries the contributions of many others.

The Licensing Problem

The core commercial issue is straightforward. ConnectFree has announced a licensing model under which software developers must purchase a yearly subscription to distribute compiled releases of their code. In practical terms, this means that building and shipping a binary using the Zen compiler is a subscription-gated activity.

For systems programmers evaluating Zen as a production tool, the implications are immediate. Unlike Zig, which is MIT-licensed and places no encumbrance on compiled output, Zen's model inserts a recurring cost and a vendor dependency into the build chain itself — not just into tooling or IDE support, but into the right to ship. That is a meaningful distinction in environments where supply-chain clarity and license auditability are non-negotiable, such as embedded systems, safety-critical software, or any organisation with strict open-source policy review processes.

The Foundation stops short of claiming that this licensing model is illegal, but the statement makes clear that it raises concerns about how Zig's own MIT-licensed code is being used as the substrate for a commercial offering that restricts downstream distribution.

The Async/Await Question

The more technically specific allegation concerns async/await. The Foundation states that async/await functionality was first introduced in Zig at version 0.6.0, and that connectFree incorporated it into Zen with virtually no change. This is a concrete, verifiable claim about code provenance — not a general complaint about fork culture.

Under the MIT licence, forking Zig is entirely permitted. The licence asks for attribution and preservation of the copyright notice, nothing more. The question the Foundation is implicitly raising is whether those minimal obligations were met, and whether connectFree's public narrative around Zen's independence accurately represents the degree to which the project continues to rely on work originally done upstream.

Worth noting here: the Foundation is not arguing that forking is wrong in principle. Open source depends on the right to fork. What the statement appears to contest is the combination of factors — taking materially copied functionality, wrapping it in a proprietary compiler, attaching a distribution-gating subscription, and then presenting the result as a largely independent evolution.

Historical Pattern

We have seen this dynamic play out before. In the early 2000s, several commercial vendors built proprietary products on GPL- and LGPL-licensed components, then found themselves in tense standoffs with the originating foundations when the terms of those licences were tested in court or in public. The specifics here are different — the MIT licence is far more permissive than the GPL — but the underlying tension is familiar: a contributor who was once inside the tent moves outside it, commercialises the work, and the original project's stewards feel the need to publicly clarify the record. These episodes rarely end in litigation. They more often end in reputational pressure and, sometimes, in the commercial fork quietly updating its attribution or adjusting its public messaging.

The Foundation's Position

The Zig Software Foundation is a 501(c)(3) non-profit created by Andrew Kelley, Zig's original author. Its mission is to support and develop the language in the open. Publishing a named statement about Zen is not a routine move for an organisation of this type; it signals that the Foundation considered the situation serious enough to address on the record rather than let it accumulate quietly in forum threads and social media commentary.

The Foundation maintains its official news and announcements at ziglang.org/news, where the full statement can be read. The language in the statement is measured rather than combative, but the substance is not ambiguous.

What This Means for Developers Evaluating Both Projects

For engineers currently looking at Zig for systems work — embedded, OS-level, WebAssembly targets, or high-performance services — the Foundation's statement does not change Zig's technical fundamentals. The language continues to progress on its own roadmap, with 0.16 now out.

For those who have encountered Zen in the wild, or who were drawn to it by connectFree's positioning, the statement is a prompt to re-examine the licence terms carefully before committing a build pipeline to the compiler. A yearly subscription requirement to distribute compiled output is not inherently disqualifying, but it is a dependency that should be consciously chosen, not discovered after the fact.

The Foundation's framing around the async/await implementation also raises a narrower but meaningful question for anyone doing due diligence: if a significant chunk of the compiler's functionality traces directly to MIT-licensed upstream code, the attribution chain deserves scrutiny before your legal or procurement team asks about it.

Looking at the broader picture, this episode is a reminder that the systems-language space — still relatively small compared to the JVM or interpreted-language ecosystems — is not immune to the commercial pressures that have always reshaped open-source projects once they reach a level of production viability. Zig's growing adoption in performance-sensitive domains makes it an increasingly attractive foundation for exactly this kind of commercial derivative work. The Foundation's decision to respond publicly, and on the record, is arguably a necessary step in establishing norms for how that derivative activity should proceed.