{"id":48413027,"url":"https://github.com/maatlabs/maat","last_synced_at":"2026-05-16T02:25:52.923Z","repository":{"id":348475567,"uuid":"1107969663","full_name":"maatlabs/maat","owner":"maatlabs","description":"Turing-complete programming language for writing zero-knowledge proofs (ZKPs)","archived":false,"fork":false,"pushed_at":"2026-05-09T00:39:15.000Z","size":1727,"stargazers_count":2,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2026-05-09T02:37:17.860Z","etag":null,"topics":["compiler","computational-integrity","maat","rust","zero-knowledge-proofs","zk-starks","zkp"],"latest_commit_sha":null,"homepage":"","language":"Rust","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/maatlabs.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE-APACHE","code_of_conduct":"CODE_OF_CONDUCT.md","threat_model":null,"audit":null,"citation":null,"codeowners":".github/CODEOWNERS","security":"SECURITY.md","support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2025-12-01T21:12:44.000Z","updated_at":"2026-05-07T21:28:12.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/maatlabs/maat","commit_stats":null,"previous_names":["maatlabs/maat"],"tags_count":20,"template":false,"template_full_name":null,"purl":"pkg:github/maatlabs/maat","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/maatlabs%2Fmaat","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/maatlabs%2Fmaat/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/maatlabs%2Fmaat/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/maatlabs%2Fmaat/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/maatlabs","download_url":"https://codeload.github.com/maatlabs/maat/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/maatlabs%2Fmaat/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":33085111,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-15T20:25:35.270Z","status":"ssl_error","status_checked_at":"2026-05-15T20:25:34.732Z","response_time":103,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.5:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["compiler","computational-integrity","maat","rust","zero-knowledge-proofs","zk-starks","zkp"],"created_at":"2026-04-06T06:33:34.845Z","updated_at":"2026-05-16T02:25:52.917Z","avatar_url":"https://github.com/maatlabs.png","language":"Rust","funding_links":[],"categories":[],"sub_categories":[],"readme":"\u003cdiv align=\"center\"\u003e\n  \u003ch1\u003eMaat\u003c/h1\u003e\n  \u003ch2\u003eTuring-complete programming language for writing zero-knowledge proofs\u003c/h2\u003e\n  \u003cimg src=\"./assets/maat-lang-transparent-logo.png\" alt=\"Logo\" height=\"200\" width=\"200\"\u003e\n  \u003cbr /\u003e\n\u003c/div\u003e\n\n\u003cdiv align=\"center\"\u003e\n\u003cbr /\u003e\n\n[![CI](https://github.com/maatlabs/maat/workflows/CI/badge.svg)](https://github.com/maatlabs/maat/actions)\n[![License](https://img.shields.io/crates/l/maat.svg)](https://github.com/maatlabs/maat#license)\n[![Crates.io](https://img.shields.io/crates/v/maat.svg)](https://crates.io/crates/maat)\n[![Releases](https://img.shields.io/github/v/release/maatlabs/maat)](https://github.com/maatlabs/maat/releases)\n[![PRs welcome](https://img.shields.io/badge/PRs-welcome-ff69b4.svg?style=flat-square)](https://github.com/maatlabs/maat/blob/main/CONTRIBUTING.md)\n\n\u003c/div\u003e\n\n**WARNING:** This is a research project. It has not been audited and may contain bugs and security flaws. This implementation is NOT ready for production use.\n\n## Overview\n\nProof-Driven Development (PDD) is software development methodology that emphasizes formal verification and mathematical proofs to ensure the correctness and reliability of code. It is an extension of test-driven development (TDD), but instead of relying solely on tests, it uses formal methods to prove properties of the code.\n\nSource files written in Maat use the `.maat` extension. Compiled bytecode files use the `.mtc` extension.\n\n## Getting Started\n\n### Prerequisites\n\n- [Rust](https://www.rust-lang.org/tools/install) 1.85 or later (with `rustup`)\n- Cargo (comes with Rust)\n\n### Installation\n\nInstall the latest release directly from [crates.io](https://crates.io/crates/maat):\n\n```bash\ncargo install maat\n```\n\nOr build from source:\n\n```bash\ngit clone https://github.com/maatlabs/maat.git\ncd maat\ncargo build --release\n```\n\n\u003e **Note (source builds):** When running from a source build instead of `cargo install`, substitute `cargo run --release --` for `maat` in all commands below (e.g., `cargo run --release -- run file.maat`).\n\n### The `maat` Binary\n\nMaat provides a single binary with seven subcommands:\n\n| Subcommand                               | Description                                               |\n| ---------------------------------------- | --------------------------------------------------------- |\n| `maat run \u003cfile.maat\u003e`                   | Compile and execute a `.maat` source file                 |\n| `maat build \u003cfile.maat\u003e -o \u003coutput.mtc\u003e` | Compile a `.maat` file to `.mtc` bytecode                 |\n| `maat exec \u003cfile.mtc\u003e`                   | Execute a pre-compiled `.mtc` bytecode file               |\n| `maat repl`                              | Start an interactive REPL session                         |\n| `maat trace \u003cfile.maat\u003e -o \u003coutput.csv\u003e` | Generate an execution trace (CSV) for ZK proof inspection |\n| `maat prove \u003cfile.maat\u003e [options]`       | Generate a STARK proof of correct program execution       |\n| `maat verify \u003cproof.bin\u003e`                | Verify a STARK proof file                                 |\n\nTo see version information:\n\n```bash\nmaat --version\n```\n\n### Running Source Files\n\nCompile and execute a Maat source file in a single step:\n\n```bash\nmaat run examples/hello_world.maat\n```\n\nOr use the build-then-execute workflow for faster repeated execution:\n\n```bash\nmaat build examples/hello_world.maat -o hello_world.mtc\nmaat exec hello_world.mtc\n```\n\n### Multi-Module Projects\n\nMaat supports multi-file programs with `mod`, `use`, and `pub`. Imports are resolved relative to the entry file, and the compiler builds a dependency graph, type-checks each module, and produces a single linked bytecode output.\n\nGiven a project layout:\n\n```txt\nmy_project/\n  main.maat\n  geometry.maat\n  math.maat\n```\n\n**`main.maat`**:\n\n```rust\nmod geometry;\nmod math;\n\nuse geometry::Point;\nuse math::add;\n\nlet p = Point { x: 3, y: 4 };\nprint(add(p.x, p.y));\nprint(p.sum());\n```\n\n**`geometry.maat`**:\n\n```rust\npub struct Point {\n    pub x: i64,\n    pub y: i64,\n}\n\nimpl Point {\n    pub fn sum(self) -\u003e i64 { self.x + self.y }\n}\n```\n\n**`math.maat`**:\n\n```rust\npub fn add(a: i64, b: i64) -\u003e i64 { a + b }\n\nfn internal_helper() -\u003e i64 { 0 }\n```\n\nRun it:\n\n```bash\nmaat run my_project/main.maat\n```\n\nBuild it to a single `.mtc`:\n\n```bash\nmaat build my_project/main.maat -o my_project.mtc\nmaat exec my_project.mtc\n```\n\nKey rules:\n\n- `mod foo;` declares a dependency on `foo.maat` (or `foo/mod.maat`) relative to the declaring file\n- `use foo::bar;` or `use foo::{bar, baz};` imports specific public items -- no glob imports (`use foo::*`) for ZK auditability\n- Items without `pub` are module-private and inaccessible to importers\n- Circular module dependencies are detected and rejected at compile time\n- `pub use foo::bar;` re-exports items through intermediate modules\n\nA working multi-module example is included at `examples/modules/`.\n\n### Running the REPL\n\nStart an interactive REPL session. The REPL compiles each line to bytecode and executes it on the VM:\n\n```bash\nmaat repl\n```\n\nExample session:\n\n```rust\n\u003e\u003e 5 + 10;\n15\n\n\u003e\u003e let add = fn(x, y) { x + y };\n\u003e\u003e add(2, 3);\n5\n\n\u003e\u003e let new_adder = fn(x) { fn(y) { x + y } };\n\u003e\u003e let add_five = new_adder(5);\n\u003e\u003e add_five(10);\n15\n\n\u003e\u003e let fibonacci = fn(x) {\n..     if x == 0 {\n..         0\n..     } else if x == 1 {\n..         return 1;\n..     } else {\n..         fibonacci(x - 1) + fibonacci(x - 2)\n..     }\n.. };\n\u003e\u003e fibonacci(15);\n610\n\n\u003e\u003e let map = fn(arr, f) {\n..     let iter = fn(arr, acc) {\n..         if arr.len() == 0 {\n..             acc\n..         } else {\n..             iter(arr.split_first(), acc.push(f(arr.first().unwrap())))\n..         }\n..     };\n..     iter(arr, [])\n.. };\n\u003e\u003e map([1, 2, 3, 4], fn(x) { x * x });\n[1, 4, 9, 16]\n\n\u003e\u003e let unless = macro(cond, cons, alt) {\n..     quote(\n..         if !(unquote(cond)) {\n..             unquote(cons);\n..         } else {\n..             unquote(alt);\n..         }\n..     )\n.. };\n\u003e\u003e unless(10 \u003e 5, \"not greater\", \"greater\");\ngreater\n\n\u003e\u003e let double = macro(x) { quote(unquote(x) * 2) };\n\u003e\u003e double(21);\n42\n```\n\n### Zero-Knowledge Proofs\n\nGenerate a STARK proof of correct program execution:\n\n```bash\n# Generate a proof (development mode, ~12 bits security)\nmaat prove examples/felt_arithmetic.maat\n\n# Generate a proof with production security (~97 bits)\nmaat prove examples/felt_arithmetic.maat --production\n\n# Specify output path and dump execution trace\nmaat prove examples/felt_arithmetic.maat -o felt_arithmetic.proof.bin -t trace.csv\n```\n\nVerify a proof:\n\n```bash\nmaat verify examples/felt_arithmetic.proof.bin\n```\n\nThe proof file embeds all public inputs (program hash, input values, output), so verification requires only the proof file itself.\n\n\u003e **Note:** `println!` is for debugging only and does not affect the proof. The provable output is the program's return value.\n\nPublic inputs can be provided via command line or JSON file:\n\n```bash\n# Command-line inputs\nmaat prove program.maat --input \"1,2,3\"\n\n# JSON file inputs\necho '[1, 2, 3]' \u003e inputs.json\nmaat prove program.maat --inputs-file inputs.json\n```\n\n#### Current Limitations\n\nThe STARK proof system is functional for **primitive-typed** programs (`i8`..`i64`, `u8`..`u64`, `usize`, `bool`, `Felt`), **fixed-size arrays** `[T; N]` over primitive `T`, and user-defined functions over those types -- including parameters, return values, nested calls, and bounded recursion. The following remain planned for future releases:\n\n- **Composite-type tracing**: Programs that use the surface composite types (`Vector\u003cT\u003e`, `Map\u003cK, V\u003e`, `Set\u003cT\u003e`, `str`, `struct`, `enum` including `Option\u003cT\u003e` / `Result\u003cT, E\u003e`, closures) execute correctly under `maat run` but cannot yet be proven end-to-end. `maat prove` will emit a proof on a composite-typed program, but the verifier will reject it.\n- **Ordering for `u64`/`i64` and signed types**: `\u003c`, `\u003e`, `\u003c=`, `\u003e=` are proven for `u8`/`u16`/`u32`/`usize`/`char` in v0.14.0; full-width 64-bit and signed ordering require a tighter range primitive and are deferred.\n- **STARK-to-SNARK wrapping**: STARK proofs ship today; succinct on-chain verification via Groth16 over BN254 is planned.\n\nNote that I/O side effects (`println!`) are not captured in the proof--the proof attests to correct computation of the return value.\n\n### Running Tests\n\nRun the full test suite:\n\n```bash\ncargo test --workspace\n```\n\n### Running Benchmarks\n\nMaat includes a Criterion-based benchmark suite for the bytecode VM:\n\n```bash\n# Run all benchmarks\ncargo bench -p maat_tests --bench benchmarks\n\n# Run specific benchmarks\ncargo bench -p maat_tests --bench benchmarks -- hello_world\n\n# Save a baseline and compare after changes\ncargo bench -p maat_tests --bench benchmarks -- --save-baseline before\n# ... make changes ...\ncargo bench -p maat_tests --bench benchmarks -- --baseline before\n```\n\nHTML reports are generated at `target/criterion/report/index.html`.\n\n### Fuzz Testing\n\nMaat includes [cargo-fuzz](https://github.com/rust-fuzz/cargo-fuzz) targets covering both the compiler pipeline and the proof system. Fuzz testing requires the nightly Rust toolchain.\n\n```bash\n# Install cargo-fuzz (one-time)\ncargo install cargo-fuzz\n\n# List available fuzz targets\ncargo +nightly fuzz list\n```\n\n#### Compiler pipeline targets\n\nlibfuzzer starts from a single null byte and builds coverage-guided from there. Text and binary parsers are naturally explorable from minimal input, so no pre-generated seeds are required.\n\n```bash\ncargo +nightly fuzz run fuzz_lexer        -- -max_total_time=60\ncargo +nightly fuzz run fuzz_parser       -- -max_total_time=60\ncargo +nightly fuzz run fuzz_typechecker  -- -max_total_time=60\ncargo +nightly fuzz run fuzz_compiler     -- -max_total_time=60\ncargo +nightly fuzz run fuzz_deserializer -- -max_total_time=60\n```\n\n#### Proof-system targets\n\n`fuzz_trace_recorder` and `fuzz_air_constraints` ship with small authored seed files found in `fuzz/corpus/`. `fuzz_proof_deserializer` and `fuzz_verifier` additionally need real STARK proof bytes, so run `corpus_gen` once after a fresh clone (or after any proof-system change) to populate those corpora:\n\n```bash\n# Required after a fresh clone, or after any proof-system change.\ncargo run --release -p maat_tests --bin corpus_gen\n\n# Run proof-system fuzz targets\ncargo +nightly fuzz run fuzz_proof_deserializer -- -max_total_time=60\ncargo +nightly fuzz run fuzz_verifier           -- -max_total_time=60\ncargo +nightly fuzz run fuzz_trace_recorder     -- -max_total_time=60\ncargo +nightly fuzz run fuzz_air_constraints    -- -max_total_time=60\n```\n\n`fuzz_proof_deserializer` and `fuzz_verifier` verify that malformed byte streams are always rejected with a structured error and never cause a panic. `fuzz_trace_recorder` verifies that arbitrarily mutated source text never panics the compiler or prover pipeline. `fuzz_air_constraints` verifies the soundness property: any tampered execution trace must be rejected by the verifier.\n\nCrash artifacts (if any) are saved to `fuzz/artifacts/\u003ctarget\u003e/`. Seed corpora live in `fuzz/corpus/`.\n\n### Property-Based Testing\n\nMaat uses [proptest](https://github.com/proptest-rs/proptest) for property-based testing. These tests verify invariants (round-trip correctness, execution determinism, type soundness) over thousands of randomly generated programs.\n\n```bash\n# Run all property tests\ncargo test -p maat_tests --test properties\n\n# Run a specific property test\ncargo test -p maat_tests --test properties -- bytecode_roundtrip\n```\n\n### Development\n\n#### Code Formatting\n\nFormat code using nightly rustfmt:\n\n```bash\ncargo +nightly fmt\n```\n\n#### Linting\n\nRun Clippy for linting (zero warnings policy):\n\n```bash\ncargo clippy --all-features --all-targets -- -D warnings\n```\n\n#### Building Documentation\n\nGenerate and view documentation:\n\n```bash\ncargo doc --all-features --no-deps --open\n```\n\n## Architecture\n\nMaat uses a multi-module compilation pipeline. Source files are parsed into per-module ASTs, organized into a dependency graph by `maat_module`, type-checked independently with cross-module visibility enforcement, compiled to bytecode by a shared `maat_codegen` compiler instance (which implicitly links all modules into a single instruction stream), and executed on the stack-based `maat_vm`. The `maat_eval` crate (the tree-walking evaluator) is reduced to a macro-expansion-only engine (`define_macros`/`expand_macros`). The STARK proof system begins with `maat_trace`, a trace-generating VM that records every instruction step into a 56-column algebraic witness matrix over the Goldilocks field (sub-selector witnesses for 16 opcode sub-classes, comparison and division auxiliaries, and a per-row encoded operand width); heap accesses go through per-instance memory segments via `MemorySegmentManager`, and a relocation pass between trace finalization and proof generation flattens those segments into the single AIR address space, fills sparse-segment holes, and appends the public-memory accumulator's dummy rows. `maat_air` encodes the CPU semantics as 81 main + 20 auxiliary Winterfell transition constraints (output correctness for arithmetic/bitwise/ordering/equality, universal PC advance, unified memory permutation, public-memory accumulator over the multi-cell output segment, range-check sub-AIR, and builtin-segment ABI), with static `pub const` transition-degree arrays (no per-trace FFT detection); `maat_prover` wires the AIR to Winterfell to produce and verify proofs.\n\nThe type checker infers types for each module using Hindley-Milner inference (Algorithm W), with imported bindings injected from dependency modules' public exports. Type annotations are optional--the inference engine deduces types from usage--but can be provided on `let` bindings, function parameters, and return types for documentation or to constrain polymorphism. Generic functions with parametric polymorphism are supported (`fn identity\u003cT\u003e(x: T) -\u003e T { x }`). Tuples, `char`, `Map\u003cK, V\u003e`, `Set\u003cT\u003e`, `Vector\u003cT\u003e`, and fixed-size arrays `[T; N]` are all first-class types with full inference support. `Felt` (Goldilocks field element) is a first-class numeric type for zero-knowledge arithmetic.\n\nCustom types follow Rust syntax: `struct`, `enum` (with unit, tuple, and struct variants), `trait`, and `impl` blocks (both inherent and trait impls). Pattern matching via `match` supports literal, identifier, tuple-struct, wildcard, and or-patterns. Methods are statically dispatched via compile-time type-directed dispatch. `Option\u003cT\u003e` and `Result\u003cT, E\u003e` are pre-registered as language-level enums with full method suites (`map`, `and_then`, `unwrap_or`, `unwrap_or_else`, `ok`, `err`, `flatten`, `zip`, `map_err`, `or_else`, etc.) and the `?` operator for ergonomic error propagation. Range syntax (`0..10` and `0..=10`) produces first-class `Range\u003cT\u003e`/`RangeInclusive\u003cT\u003e` values generic over all integer types and integrates with `for..in` loops.\n\nErrors are reported with precise `file:line:col` locations using source maps and [`ariadne`](https://docs.rs/ariadne) diagnostics. Compiled bytecode can be serialized to `.mtc` files and deserialized for later execution, enabling the `build`/`exec` workflow.\n\n### Crate Organization\n\n| Crate             | Description                                                                                                        |\n| ----------------- | ------------------------------------------------------------------------------------------------------------------ |\n| [`maat`]          | The CLI for commands such as `build`, `trace`, `repl`, `prove`, and `verify`                                       |\n| [`maat_span`]     | Source location tracking and span management                                                                       |\n| [`maat_errors`]   | Unified error handling with `Result` type alias                                                                    |\n| [`maat_lexer`]    | `logos` compile-time DFA tokenizer                                                                                 |\n| [`maat_ast`]      | Abstract Syntax Tree definitions and transformations                                                               |\n| [`maat_parser`]   | `winnow` combinator-based parser                                                                                   |\n| [`maat_eval`]     | Macro expansion engine (`quote`/`unquote`)                                                                         |\n| [`maat_runtime`]  | Value system, built-in functions, and compiled types                                                               |\n| [`maat_types`]    | Hindley-Milner type inference (Algorithm W)                                                                        |\n| [`maat_field`]    | Goldilocks field element (`Felt`) arithmetic                                                                       |\n| [`maat_bytecode`] | Instruction set encoding/decoding and serialization (50 opcodes)                                                   |\n| [`maat_trace`]    | Trace-generating VM producing a 56-column algebraic execution trace for ZK proving                                 |\n| [`maat_air`]      | CPU constraint system (AIR): 101 polynomial constraints (81 main + 20 aux) with static declared transition degrees |\n| [`maat_prover`]   | STARK prover and verifier: generates and validates cryptographic proofs of execution                               |\n| [`maat_codegen`]  | AST-to-bytecode compiler with scope analysis                                                                       |\n| [`maat_module`]   | Module resolution, dependency graph, and multi-module pipeline                                                     |\n| [`maat_vm`]       | Stack-based virtual machine                                                                                        |\n| [`maat_stdlib`]   | Embedded standard library sources (`std::math`, `std::vec`, …)                                                     |\n\n## Contributing\n\nThank you for your interest in contributing to this project! All contributions large and small are actively accepted. To get started, please read the [contribution guidelines](./CONTRIBUTING.md). A good place to start would be [Good First Issues](https://github.com/maatlabs/maat/labels/good%20first%20issue).\n\n## License\n\nLicensed under either of [Apache License, Version 2.0](./LICENSE-APACHE) or [MIT license](./LICENSE-MIT) at your option.\n\nUnless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this codebase by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.\n\n## Security\n\nAll 18 crates enforce `#![forbid(unsafe_code)]`. The compiler and VM have been hardened against adversarial input with resource limits, checked arithmetic, and safe type conversions. Field element arithmetic uses the Winterfell library's constant-time implementations. See [`SECURITY.md`](./SECURITY.md) for the full threat model.\n\n## Roadmap\n\nMaat's development follows a phased milestone plan.\n\n| Milestone | Focus                                                               | Status          |\n| --------- | ------------------------------------------------------------------- | --------------- |\n| **1**     | Rust-native, ZK-correct-by-design, working compiler                 | **Complete**    |\n| **2**     | STARK-based ZK backend (proof generation and verification)          | **In Progress** |\n| **3**     | Advanced type system (linear types, effect system) and self-hosting | Planned         |\n\n## Status\n\nMaat is currently at version `0.14.0`. The compiler frontend, type system, module system, bytecode VM, and CLI toolchain are functional and tested. The ZK backend proves and verifies user-defined function calls with parameters, return values, nested calls, bounded recursion, arithmetic, bitwise operations, unsigned ordering comparisons, and fixed-size arrays `[T; N]` over primitive `T`. See the [current limitations](#current-limitations) for gaps deferred to future releases.\n\n## Disclaimer\n\nEarly adopters should be aware that Maat `0.14.0` is a step toward Maat 1.0, for which a formal audit process is expected. In the meantime, we invite you to explore and experiment with Maat, but we do not recommend using it to build mission-critical systems.\n\n## Acknowledgments\n\nMaat's early architecture (v0.1--v0.4) was inspired by Thorsten Ball's [Writing An Interpreter In Go](https://interpreterbook.com), [The Lost Chapter: A Macro System for Monkey](https://interpreterbook.com/lost/), and [Writing A Compiler In Go](https://compilerbook.com). The lexer structure, Pratt parser skeleton, tree-walking evaluator, macro system, and initial bytecode VM design trace back to these books, translated from Go to Rust.\n\nSince then, Maat has diverged substantially. The language now features `Hindley-Milner` type inference, Rust-native custom types (structs, enums, traits, impl blocks, pattern matching), a multi-file module system with visibility enforcement, a ZK-first design that rejects floating-point and implicit truthiness, built-in `Option\u003cT\u003e` and `Result\u003cT, E\u003e`, source-location diagnostics, bytecode serialization, and a CLI toolchain--none of which originate from the source material.\n\n---\n\n[`maat`]: ./compiler/maat/README.md\n[`maat_air`]: ./compiler/maat_air/README.md\n[`maat_ast`]: ./compiler/maat_ast/README.md\n[`maat_bytecode`]: ./compiler/maat_bytecode/README.md\n[`maat_codegen`]: ./compiler/maat_codegen/README.md\n[`maat_errors`]: ./compiler/maat_errors/README.md\n[`maat_eval`]: ./compiler/maat_eval/README.md\n[`maat_field`]: ./compiler/maat_field/README.md\n[`maat_lexer`]: ./compiler/maat_lexer/README.md\n[`maat_module`]: ./compiler/maat_module/README.md\n[`maat_parser`]: ./compiler/maat_parser/README.md\n[`maat_prover`]: ./compiler/maat_prover/README.md\n[`maat_runtime`]: ./compiler/maat_runtime/README.md\n[`maat_span`]: ./compiler/maat_span/README.md\n[`maat_trace`]: ./compiler/maat_trace/README.md\n[`maat_types`]: ./compiler/maat_types/README.md\n[`maat_vm`]: ./compiler/maat_vm/README.md\n[`maat_stdlib`]: ./library/README.md\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmaatlabs%2Fmaat","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fmaatlabs%2Fmaat","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmaatlabs%2Fmaat/lists"}