Zerolang: Vercel Labs' Graph-Native Language for Coding Agents
The Programming Language for Agents
At a glance
- What is it?
- Zerolang replaces text files with a checked semantic graph that agents query and patch. It is an experimental Vercel Labs project, and the README tells you to keep it away from production.
- Who is it for?
- Adopt Zerolang only if you are building or evaluating agent tooling and can run it in an isolated workspace, because the README marks it experimental and warns about breaking changes and security issues. Do not point it at production systems or sensitive data, and do not treat it as a general-purpose language for human teams; the README says agents should normally keep using zero query and zero patch while humans review the .0 projection.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 1 day ago.
- What is it written in?
- Mainly C, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 17, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
What problem Zerolang claims to solve for agents
Most agent coding loops treat text as the source of truth. The README draws that loop explicitly: the agent writes text, checks it, formats it, builds it, inspects failures, and writes more text. Every one of those steps happens before the compiler has an opinion, so the agent spends tokens guessing at syntax and line ranges that a type checker or a graph hash could have rejected outright.
Zerolang inverts that. The semantic graph is the program database, and `zero.graph` is the checked compiler input for graph-first packages. The stated audience is not a human writing a service by hand; it is an agent that needs explicit handles on a program. The README lists those handles: symbols, node IDs, graph hashes, types, effects, ownership facts, capabilities, imports, call edges, and target facts. With those, an edit can target semantic structure instead of a line range.
The human side is deliberately kept narrow. A `.0` file is described as a human-readable projection, and the README says humans can read it, review it, and occasionally edit it, while agents should normally keep using `zero query` and `zero patch`. That division is the whole pitch: the graph is authoritative, the text is a view.
How the graph, patches and projections fit together
The mechanism is a checked write path. An agent queries the graph, submits a patch, and the compiler decides whether to accept it. If the patch is invalid or stale, the agent goes back to querying. If it is valid, the agent runs task validation, and a human reviews the projection when that is useful.
What makes the rejection meaningful is the set of facts the compiler holds. According to the README, stale graph hashes, unexpected field values, invalid shapes, and type errors all fail before the store is written. That is a stronger guarantee than a formatter or a linter gives you, because the check happens against the same structure the edit targets, not against a re-parse of text that may already have drifted.
The projection boundary is handled by two commands. `zero import` and `zero export` make that boundary explicit, so a human text edit does not silently diverge from the graph. `zero verify-projection` exists to check the text against the graph, and `zero import` is the path for a human who intentionally edited a projection. This is the part of the design that deserves scrutiny: it is easy to describe a round trip and harder to keep it lossless, and the README does not document what happens to a projection edit that the graph cannot represent. If you depend on human edits, test that case yourself.
Installing the compiler and running your first patch
The README gives a single install path: a shell script from zerolang.ai, followed by a PATH export and a version check. Run these three lines in order, and expect `zero --version` to print the compiler version you just installed.
curl -fsSL https://zerolang.ai/install.sh | bash
export PATH="$HOME/.zero/bin:$PATH"
zero --versionThe same README installs an agent bootstrap skill through npx, which is the step that gets the workflow into a coding agent rather than a terminal session.
npx skills add vercel-labs/zerolangThe compiler bundles version-matched skills, and `zero skills` lists them. The README names four: agent, graph, language, and stdlib.
zero skills
zero skills get agent
zero skills get graphFor a first real use, the README's hello world is three commands. `zero init` sets up the package, `zero patch` applies two operations, and `zero run` executes it. The default input is the current directory, and the README says to use `.` only when you want to be explicit.
zero init
zero patch --op 'addMain' --op 'addCheckWrite fn="main" text="hello from zero\n"'
zero runAfter that, `zero export` writes the projection. The README shows the resulting `.0` file as a function `main` taking a `World` and calling `check world.out.write("hello from zero\n")`. If you want to see the full set of patch operations before writing your own, `zero patch --op help` is the documented way to list them.
The daily loop, and where it stops being enough
The README's daily loop for package work is short: `zero query`, `zero patch --op help`, `zero patch --op 'addMain'`, `zero check`, `zero test`, and `zero run -- <args>`. Note the argument separator on the run command; the README writes it that way, and it is the boundary between compiler flags and your program's arguments.
The loop assumes the agent can express what it wants as a patch operation. That is the real constraint. If a change does not map onto an existing operation, the agent is back to reasoning about structure it cannot address, and the README does not describe a general escape hatch beyond `zero import` for a human-edited projection. A language whose editing surface is a fixed operation set is only as capable as that set.
The human review path is separate: `zero export` followed by `zero verify-projection` when someone wants to read the text, and `zero import` followed by `zero check` when someone has intentionally edited it. Treat those as the two ends of a boundary you will cross rarely, not as a normal editing workflow.
Experimental status, and the cases where Zerolang is the wrong tool
The README carries a safety warning in its own words: Zerolang is experimental, and you should expect breaking changes, rough edges, and security issues. It says to run it in isolated workspaces, not against production systems or sensitive data. That is the project's own description of its maturity, and it should set your expectations more than any version number does.
The release history supports the warning. The most recent releases are v0.3.4, v0.3.3, and v0.3.2, all published within four days of each other in June 2026, and the repository's last push was on 2026-09-16. Rapid patch releases in a 0.x line are normal for an experiment and are also exactly what the README means by breaking changes.
Where it is the wrong tool: any codebase a human team needs to read, diff, and merge through ordinary review. The README is explicit that `.0` files are not the normal agent authoring surface, so a team expecting to review pull requests of source text is working against the design. The same applies to anything touching production credentials, since the README asks you not to run it against sensitive data at all. And if your agent already produces correct code in a mainstream language, the graph adds a compiler-specific vocabulary the agent has to learn before it can do anything.
How this differs from asking an agent to edit source files
The obvious alternative is the loop the README itself contrasts with: an agent writes text, a checker and formatter run, the build runs, the agent reads failures, and the cycle repeats. Tools such as a conventional compiler plus a linter and formatter occupy that space, and they are mature in a way Zerolang is not.
The difference is where the check sits. In the text loop, the compiler sees whatever the agent typed and reports errors after the fact. In the graph loop, the agent submits a patch against a graph hash, and the README states that stale hashes, unexpected field values, invalid shapes, and type errors fail before the store is written. One rejects a bad edit after it exists as text; the other refuses to create it.
That comes at a cost the README does not hide. The text loop works with any language, any editor, and any existing repository. The graph loop requires a package built for it, a compiler that understands the operations you need, and an agent holding the bundled skills. The README's own install section points at `zero skills get agent`, `zero skills get graph`, `zero skills get language`, and `zero skills get stdlib`, which tells you how much vocabulary has to be loaded before the workflow functions. If you only need an agent to make small changes to an ordinary codebase, the text loop is the cheaper answer.
Licence, building from source and upgrade cost
Zerolang is Apache-2.0, and the workspace package.json carries the same identifier. Apache-2.0 is a permissive licence with an explicit patent grant, and it imposes notice and attribution obligations when you redistribute. That is a description of the licence text, not advice about your situation; if you plan to ship a modified compiler, read the LICENSE file in the repository rather than a summary.
Building locally is documented and requires Node 24 or later, with pnpm as the package manager. The README gives the sequence: install dependencies, build the native compiler under `native/zero-c`, then run `bin/zero --version`. The package.json pins `pnpm@11.1.3` and sets `"engines": { "node": ">=24" }`.
pnpm install
make -C native/zero-c
bin/zero --versionThe repository also exposes conformance and contract checks, including `pnpm run conformance`, `pnpm run native:test`, and `pnpm run command-contracts`, plus local variants such as `pnpm run conformance:local -- --shard 1/4`. Those names matter for upgrade cost: a graph-first package is coupled to the compiler's operation set, so a minor version bump can invalidate patches that used to apply. The README's warning about breaking changes is the reason to run the conformance suite against your own packages before moving a compiler version, and the reason `zero skills` bundles version-matched skills rather than fetching them from a moving target.
Editorial conclusion
Adopt Zerolang only if you are building or evaluating agent tooling and can run it in an isolated workspace, because the README marks it experimental and warns about breaking changes and security issues. Do not point it at production systems or sensitive data, and do not treat it as a general-purpose language for human teams; the README says agents should normally keep using zero query and zero patch while humans review the .0 projection. Before committing, verify the current zero patch operation set with zero patch --op help, confirm zero verify-projection accepts your exported text, and check that the bundled skills from zero skills match the compiler version you installed.
Frequently asked questions
What coding languages does Elon Musk use?
The README does not discuss Elon Musk or his language preferences, so this cannot be answered from the project's documentation. Zerolang itself is written primarily in C and is described as an experimental graph-native language for agents.
How do you write "I love you" in code?
The README's only worked example is hello world, which uses zero patch with the addMain and addCheckWrite operations and then prints "hello from zero". It gives no example of writing a message such as "I love you", so the documentation does not answer this.
Does NASA use C++ or Python?
The README says nothing about NASA or which languages it uses. The relevant fact here is that Zerolang's primary implementation language is C, with the native compiler built under native/zero-c.
What are the big 3 coding languages?
The README does not rank or list mainstream programming languages, so it offers no answer to this. It only describes Zerolang's own position: an experimental graph-native language where the semantic graph is the program database.
Community notes