GraminTurn grammar files into facts you can review.

Common, versioned Grammar IR and deterministic structural features for parser grammars — without executing semantic actions.

Try the sandbox

Get started

Common, versioned IR

Normalize Yacc, BNF, ANTLR4, Menhir, and PEG grammars at a JSON-Schema-backed boundary.

Deterministic facts

Count rules, dependencies, recursion, reachability, and more using stable definitions.

Review-ready reports

Produce JSON, Markdown, LLM digests, SARIF, and feature diffs from one analysis result.

grammar.y

value
  : object
  | array
  | STRING
  | NUMBER
  ;

object
  : '{' members? '}'
  ;

deterministic features

7Rules

17Alternatives

6Recursive rules

0Unresolved symbols

semantic actions not executed

The path from source to review

Understand a grammar before you change it.

Gramin separates format-specific parsing from format-independent analysis, so the same contract powers exploration, review, CI, and custom tooling.

Grammar source→Frontend→Grammar IR v1→Features→JSON · Markdown · SARIF

Why Gramin

Explore

Find large rules, recursion, unresolved symbols, unreachable rules, and the diagnostics that deserve attention.

Understand the analysis →

Review

Compare before and after features without pretending that every metric is comparable across representations.

Learn about metric classes →

Automate

Use a baseline, regression policy, and SARIF output to bring structural review into GitHub Actions.

Add it to CI →

Build

Use the IR schema and external frontend protocol as a stable boundary for your own grammar tooling.

Connect a frontend →

Supported formats

Many syntaxes, one analysis boundary.

Support is intentionally format-aware. See the matrix for dialects, capabilities, and lossy cases before interpreting a result.

Format family	Frontend ID	Files	Main strengths	Important boundary
Yacc / Bison / Lrama	`yacc-family`	Single	Precedence, actions, named references	Recovery can be lossy
BNF / EBNF	`bnf`	Single	Grouping, choice, repetition	First file only
ANTLR4	`antlr4`	Multi-file	Parser/lexer grammar, EBNF, imports	Target code is lossy
Menhir	`menhir`	Single	Classic rules, inline, parameterized symbols	Some attributes are unsupported
Peggy / PEG.js	`peggy`	Single	Ordered choice, predicates, scannerless	Actions are not retained

View the complete support matrix →

Same language, different representation

Numbers need context.

The same JSON language can have different structural measurements when written in Yacc, ANTLR4, or Peggy. Gramin makes that context visible instead of hiding it behind one complexity score.

Metric	Class	Yacc	ANTLR4	Peggy
`Rules`	A	7	5	10
`Alternatives`	A	17	11	16
`Reachable rules`	A	7	5	8
`Recursive rules`	B	6	4	4
`Nullable rules`	B	0	0	N/A

Learn how cross-format comparison works →

Trust boundaries

Structure only. No execution.

Browser sandbox analysis stays local. Semantic actions and target code are never executed or retained as IR. Unsupported or lossy syntax is reported as diagnostics, and not-applicable metrics are not shown as fake zeroes.

Read the safety model

FAQ

What Gramin does — and does not do.

Does Gramin generate parsers?

No. It analyzes grammar structure; it does not generate a parser or prove language-level correctness.

Can I compare different grammar formats?

Yes, with context. Class A metrics are designed for cross-format comparison, while Class B and C metrics require capability or representation context.

Does the sandbox upload my grammar?

No. The browser sandbox runs the parser frontend and analyzer in a Web Worker without sending grammar contents to a server.

Can I send the LLM digest directly to an AI service?

The sandbox only creates a bounded, copyable digest. It does not call an LLM service or send your grammar anywhere.