# tabnas

> tabnas is a parsing engine that can handle any language. Grammars are data, so you extend one that already works instead of starting over — and an agent can write one directly.

Documentation on this site describes @tabnas/parser 0.8.10; the exact
package pins are at https://tabnas.dev/versions.json.

## Site

- [Home](https://tabnas.dev/): what it is, and the addition grammar four ways
- [Why](https://tabnas.dev/why): the long-form motivation and the algorithm
- [Docs](https://tabnas.dev/docs): documentation hub (Diátaxis)
- [How to](https://tabnas.dev/how-to): task-oriented guides for the problems that come up in practice
- [Playground](https://tabnas.dev/playground): run a grammar in the browser, as ABNF or as a rule table
- [Examples](https://tabnas.dev/examples): real languages built on the engine
- [Status](https://tabnas.dev/status): per-repository CI, release and compliance state
- [FAQ](https://tabnas.dev/faq): what it does, and what it won't do
- [Community](https://tabnas.dev/community): discussion, issues, contributing
- [Releases](https://tabnas.dev/releases): every package and its current version
- [Other parsers](https://tabnas.dev/comparisons): how it differs from ANTLR, Peggy, Chevrotain, nearley, tree-sitter
- [Sponsors](https://tabnas.dev/sponsors): who pays for it
- [Privacy](https://tabnas.dev/privacy): what the hosted MCP endpoint records (shape only) and never records (your documents)

## For agents

- [Agents](https://tabnas.dev/agents): how to build with tabnas — the format to emit, the constraints, how to verify your work
- [Skills](https://tabnas.dev/skills): portable Agent Skills for authoring, debugging, testing and shipping grammars, as one Agent Plugins package
- [MCP](https://tabnas.dev/mcp): connect an agent over MCP — seven tools, and the same seven as a `tabnas` command-line tool
- [Error reference](https://tabnas.dev/errors): every error code the engine and its plugins raise; the code, not the message, is the cross-runtime contract
- [versions.json](https://tabnas.dev/versions.json): machine-readable: which package versions this documentation describes

## Documentation

13 reference pages under /docs and 12 task guides under /how-to. The full text of both is at https://tabnas.dev/llms-full.txt.

## Core packages

- [@tabnas/parser](https://github.com/tabnas/parser): The engine — a pluggable, rule-based parsing machine and a uniform syntax tree.
- [@tabnas/abnf](https://github.com/tabnas/abnf): Compile RFC 5234 ABNF straight into a working grammar.
- [@tabnas/debug](https://github.com/tabnas/debug): Inspect a live grammar — describe it, render it back as ABNF.
- [@tabnas/railroad](https://github.com/tabnas/railroad): Render railroad (syntax) diagrams from a grammar.
- [@tabnas/jsonic](https://github.com/tabnas/jsonic): A dynamic JSON parser that isn't strict and can be customised.
- [@tabnas/expr](https://github.com/tabnas/expr): Pratt-parser expressions — infix, prefix, suffix, ternary, with configurable precedence.

28 packages in total; the full list is at https://tabnas.dev/releases

## Notes for agents

- Start by checking whether an existing grammar already parses something close to your format, and extend it. Extension is what the engine is built for.
- Emit the rule table as data. The engine's `$`-builtin actions (`@object$`, `@array$`, `@key$`, `@setval$`, `@push$`, `@value$`, `@reset$`) are referenced by name, so a grammar can be pure JSON with no functions in it.
- Alternate mark names for `@ref` actions are assigned by the compiler. Ask for them with `tabnas-abnf --marks -f grammar.abnf` rather than guessing.
- A parse failure carries a structured diagnostic. The `code` is the contract across the TypeScript and Go runtimes — the message text is not, so match on the code and look it up at https://tabnas.dev/errors/<code>.
- Validate a grammar before running it: `tabnas validate --grammar g.json`, or the `validate_grammar` MCP tool. The grammar JSON Schema is at https://github.com/tabnas/parser/blob/main/schema/grammar.schema.json.
- Pin behaviour with the fleet's shared `.tsv` fixtures — one row runs in both runtimes. An `ERROR:<code>` cell pins the code, which is stronger than a bare `ERROR`.
- Every package repository ships an `AGENTS.md`, and every grammar plugin a machine-readable `tabnas.plugin.json` descriptor.
- npm packages are under the `@tabnas/*` scope; Go modules under `github.com/tabnas/<name>/go`. Everything is pre-1.0 — pin exact versions.
- Every package ships tested, runnable README examples (`// =>` assertions are executed in CI).
- A minimal end-to-end example (ABNF): `val = add` / `add = NR [ PL add ]` / `PL = "+"` parses `1+2+3`. Add `'@val:o:add'` to zero a total on `val`'s node and `'@add:o:NR'` to do `r.parent.node.value += r.o[0].val` — the tail self-reference compiles to a same-depth repeat, so `r.parent` is `val` for every repetition — and `parse('1+2+3').value` is `6`.