Your grammar is your AST. Formerly rust-sitter.

Most parser generators make you maintain two things: the grammar and the AST you actually want to use. Adze collapses those into one. You describe your language as Rust types, and the build tooling generates a parser that returns those types directly.

grammar as Rust types  →  generated parser  →  typed Rust AST

not:

grammar  →  generic tree  →  hand-written tree walker  →  hand-written AST mapper

#[adze::grammar("arithmetic")]
pub mod grammar {
    #[adze::language]
    #[derive(Debug, PartialEq)]
    pub enum Expr {
        Number(
            #[adze::leaf(pattern = r"\d+", transform = |v| v.parse().unwrap())]
            i32,
        ),

        #[adze::prec_left(1)]
        Add(Box<Expr>, #[adze::leaf(text = "+")] (), Box<Expr>),

        #[adze::prec_left(2)]
        Mul(Box<Expr>, #[adze::leaf(text = "*")] (), Box<Expr>),
    }

    #[adze::extra]
    #[allow(dead_code)]
    struct Whitespace {
        #[adze::leaf(pattern = r"\s+")]
        _ws: (),
    }
}

let expr = grammar::parse("1 + 2 * 3")?;
// expr = Add(Number(1), (), Mul(Number(2), (), Number(3)))

[dependencies]
adze = { version = "0.8", default-features = false }

[build-dependencies]
adze-tool = "0.8"

[features]
default = ["pure-rust"]
pure-rust = ["adze/pure-rust"]

Add a build.rs pointing at the file that contains your #[adze::grammar] module:

use std::path::PathBuf;

fn main() {
    println!("cargo::rustc-check-cfg=cfg(adze_unsafe_attrs)");
    // src/lib.rs for library crates, src/main.rs for binary crates
    adze_tool::build_parsers(&PathBuf::from("src/lib.rs"));
}

Then call grammar::parse(input) to get Result<YourType, Vec<ParseError>>.

For the shortest path, start with Quickstart: First Parser In 10 Minutes. For the API ladder, read the Mental Model.

Adze is under active development. The core parser pipeline is working and tested. Some broader surfaces — CLI tooling, WASM, runtime2, grammar crates, golden tests, benchmarks, and Tree-sitter bridge/compatibility — are still being hardened.

Support tiers, proof commands, and CI lanes are tracked in docs/status/SUPPORT_TIERS.md.

Rule for documentation and CI promotion: no Stable feature claim without a named proof command in docs/status/SUPPORT_TIERS.md.

Adze is a good fit if you are building a parser or DSL in Rust, you control the grammar, and you want the result as plain Rust types integrated into a normal Cargo build. It is not yet a drop-in replacement for mature parser generators, and surfaces outside the core lane should be treated as developing.

At build time, adze-tool reads your annotated Rust types, constructs a grammar IR, computes LR(1)/GLR parse tables via adze-glr-core, and emits generated Rust through adze-tablegen. At runtime, adze uses those tables to parse input and return your typed value directly — no generic tree, no secondary mapping step.

adze-macro  →  adze-tool  →  adze-ir  →  adze-glr-core  →  adze-tablegen  →  adze runtime  →  typed extraction

Additional workspace areas include grammar crates, benchmarks, WASM demos, golden tests, bridge tooling, and test-support infrastructure. These are useful but not all are part of the supported core lane.

• Getting Started — build your first parser
• Architecture — how the macro, tool, and runtime fit together
• Grammar Examples — patterns for common constructs
• API Reference — generated docs on docs.rs

Contributions are welcome. See CONTRIBUTING.md for guidelines, ROADMAP.md for planned work, and the Developer Guide for internal setup.

just ci-supported      # required PR gate — fmt + clippy + tests on core crates
just ci-product-stable # optional Stable README product canaries
just test              # core lib tests
just clippy            # lint core crates
cargo fmt --all --check
cargo t2               # tests with 2 threads

Licensed under either:

• Apache-2.0
• MIT

at your option.