Skip to content
Back to search

zerolang

The Programming Language for Agents

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/vercel-labs--zerolang/badge.svg)](/listings/vercel-labs--zerolang)

HTML

<a href="/listings/vercel-labs--zerolang"><img src="/api/listings/vercel-labs--zerolang/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

Install the compiler:

curl -fsSL https://zerolang.ai/install.sh | bash
export PATH="$HOME/.zero/bin:$PATH"
zero --version

Install the agent bootstrap skill:

npx skills add vercel-labs/zerolang

The compiler bundles version-matched skills for agents:

zero skills
zero skills get agent
zero skills get graph
zero skills get language
zero skills get stdlib

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 170 lines · 1 finding marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Zerolang
  2. <p>
  3. <a href="https://vercel.com/labs#active-experiments"><img alt="Vercel Labs Experiment" src="https://img.shields.io/badge/LABS-EXPERIMENT-0a0a0a.svg?style=for-the-badge&amp;logo=Vercel&amp;labelColor=000000" height="28"></a>
  4. <a href="https://github.com/vercel-labs/zerolang/releases/latest"><img alt="Zerolang compiler release" src="https://img.shields.io/github/v/release/vercel-labs/zerolang.svg?style=for-the-badge&amp;labelColor=000000&amp;label=release" height="28"></a>
  5. <a href="https://github.com/vercel-labs/zerolang/blob/main/LICENSE"><img alt="License: Apache-2.0" src="https://img.shields.io/github/license/vercel-labs/zerolang.svg?style=for-the-badge&amp;labelColor=000000" height="28"></a>
  6. </p>
  7. **The programming language for agents.**
  8. Zerolang is an experimental graph-native programming language where the semantic graph is the program database. Humans ask for outcomes. Agents query the graph, submit checked edits, and prove the result.
  9. > **Safety warning**
  10. >
  11. > Zerolang is experimental. Expect breaking changes, rough edges, and security issues. Run it in isolated workspaces, not against production systems or sensitive data.
  12. ## Start With a Request
  13. The expected workflow is a normal conversation:
  14. ```text
  15. build hello world for zerolang
  16. ```
  17. The agent should use the compiler, not guess from source text:
  18. ```sh
  19. zero init
  20. zero patch --op 'addMain' --op 'addCheckWrite fn="main" text="hello from zero\n"'
  21. zero run
  22. ```
  23. The result is still reviewable as a text projection:
  24. ```zero
  25. pub fn main(world: World) -> Void raises {
  26. check world.out.write("hello from zero\n")
  27. }
  28. ```
  29. That `.0` file is a projection of `zero.graph`. Humans can read it, review it, and occasionally edit it. Agents should normally keep using `zero query` and `zero patch`.
  30. ## The Program Database
  31. Traditional agent coding loops treat text as the source of truth:
  32. ```mermaid
  33. flowchart LR
  34. A[agent writes text] --> B[check]
  35. B --> C[format]
  36. C --> D[build]
  37. D --> E[inspect failures]
  38. E --> A
  39. ```
  40. Zerolang moves the agent closer to the compiler:
  41. ```mermaid
  42. flowchart LR
  43. A[agent queries graph] --> B[agent submits checked patch]
  44. B --> C{compiler accepts?}
  45. C -- invalid or stale --> A
  46. C -- valid --> D[agent runs task validation]
  47. D --> E[human reviews projection when useful]
  48. ```
  49. The graph gives agents explicit handles: symbols, node IDs, graph hashes, types, effects, ownership facts, capabilities, imports, call edges, and target facts. Edits can target semantic structure instead of line ranges. Stale graph hashes, unexpected field values, invalid shapes, and type errors fail before the store is written.
  50. ## What Exists Today
  51. - `zero.graph` is the checked compiler input for graph-first packages.
  52. - `.0` files are human-readable projections, not the normal agent authoring surface.
  53. - `zero patch` applies checked graph edits and rejects stale or invalid changes.
  54. - `zero query`, `zero inspect`, `zero check`, `zero test`, and `zero run` expose compiler facts through agent-friendly commands.
  55. - `zero import` and `zero export` make the projection boundary explicit, so human text edits do not silently diverge from the graph.
  56. ## Install
  57. Install the compiler:
  58. ```sh
  59. curl -fsSL https://zerolang.ai/install.sh | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 82 on GitHub
  60. export PATH="$HOME/.zero/bin:$PATH"
  61. zero --version
  62. ```
  63. Install the agent bootstrap skill:
  64. ```sh
  65. npx skills add vercel-labs/zerolang
  66. ```
  67. The compiler bundles version-matched skills for agents:
  68. ```sh
  69. zero skills
  70. zero skills get agent
  71. zero skills get graph
  72. zero skills get language
  73. zero skills get stdlib
  74. ```
  75. ## Daily Loop
  76. For most package work:
  77. ```sh
  78. zero query
  79. zero patch --op help
  80. zero patch --op 'addMain'
  81. zero check
  82. zero test
  83. zero run -- <args>
  84. ```
  85. The default input is the current directory. Use `.` only when you want to be explicit.
  86. When a human wants to review projection text:
  87. ```sh
  88. zero export
  89. zero verify-projection
  90. ```
  91. When a human intentionally edits a projection:
  92. ```sh
  93. zero import
  94. zero check
  95. ```
  96. ## Runtime Goals
  97. The graph-first model should reduce agent guessing without relaxing the runtime goals:
  98. - Token-efficient inspection
  99. - Low memory usage
  100. - Fast startup and builds
  101. - Low runtime latency
  102. - Explicit capabilities
  103. - Small, dependency-free artifacts
  104. ## Developing Zerolang
  105. Build the local compiler:
  106. ```sh
  107. pnpm install
  108. make -C native/zero-c
  109. bin/zero --version
  110. ```
  111. Useful checks:
  112. ```sh
  113. pnpm run docs:build
  114. pnpm run conformance
  115. pnpm run native:test
  116. pnpm run command-contracts
  117. ```
  118. For local iteration:
  119. ```sh
  120. pnpm run conformance:local -- --list
  121. pnpm run conformance:local -- --shard 1/4
  122. pnpm run command-contracts:local
  123. ```
  124. Read the docs at [zerolang.ai](https://zerolang.ai).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.