Open-source alternatives to Pegjs

Jison is a JavaScript parser generator that implements the LALR parsing algorithm. It creates tools to analyze custom programming languages by converting structured input into tokens and trees. The project functions as a Bison-compatible generator, accepting grammars in a format compatible with the Bison parser generator to produce JavaScript parsers. It covers the requirements for compiler frontend development, including the implementation of domain-specific languages and syntax analysis tooling. Its capabilities extend to custom language parsing and the generation of parsers via a command

Participle is a Go parser generator and toolkit for building language frontends. It provides a declarative grammar framework that uses reflection and struct tags to map input patterns directly into typed data structures. The library features a stateful lexical analyzer that employs state machines to handle nested or modal patterns. It includes a lexer code generator to produce optimized code, reducing runtime memory allocations and increasing throughput. The project covers recursive descent parsing with support for union types via sealed interfaces and custom parsing logic through interface-

Grule is a business rule engine for Go that decouples complex decision-making logic from core application code. It provides a framework for defining, versioning, and executing business rules through a domain-specific language, allowing logic to be managed independently of the underlying software implementation. The engine distinguishes itself by utilizing a formal grammar-based parser and a Rete-inspired pattern matching algorithm to evaluate logic against data facts efficiently. It supports dynamic system modeling by enabling runtime updates to policies and providing thread-safe knowledge ba

Bhai-lang is a TypeScript-based toy programming language and custom syntax interpreter. It functions as an educational language implementation designed to demonstrate core concepts of variable management, conditional logic, and execution flow. The project provides a custom command line interface and an interactive code playground for writing and testing scripts. It serves as a framework for programming language prototyping, allowing for the definition of custom syntax and execution logic. The system covers the full interpreter pipeline, including lexical analysis, recursive descent parsing,

Ohm is a formal grammar parser generator and domain-specific language framework. It provides a system for defining custom languages to parse, validate, and extract data from input text, transforming raw strings into hierarchical abstract syntax trees based on specified formal rules. The project utilizes an Earley parsing algorithm, which allows it to support all context-free grammars, including those with left recursion and ambiguity, without requiring predefined operator precedence. It also includes a dedicated debugging toolkit for tracing and visualizing the step-by-step state transitions

Racket is a general-purpose, multi-paradigm programming language in the Lisp family designed for language creation. It functions as a language workbench, providing a platform for designing and implementing custom programming languages through a flexible system of macros and modules. The system distinguishes itself by offering a comprehensive suite for semantics engineering, allowing for the construction of specialized language subsets and educational layers. It includes tools for custom language design, such as lexer and parser generation, as well as the ability to define module expansion rul

Sweet-core is a JavaScript source-to-source compiler and Lisp-style macro system. It functions as a syntax transformer that extends JavaScript by allowing the definition of custom syntax and operators during the compilation process. The system provides a framework for building domain-specific languages through hygienic, recursive macro expansion and the creation of new language constructs. It distinguishes itself by supporting custom operator definitions with configurable associativity and precedence to control expression evaluation. The compiler includes a specialized module system for mana

Chumsky is a parser combinator library used to build high-performance parsers by composing small parsing functions into complex grammars. It provides multiple parsing engines, including recursive descent and precedence-climbing implementations for resolving the order of operations in mathematical and logical expressions. The library is distinguished by its zero-copy text parsing, which minimizes memory allocations to increase throughput, and its ability to run without a standard library for use in embedded or resource-constrained environments. It also features an error-recovering parser that

Janet is a Lisp-based dynamic programming language featuring a register-based bytecode virtual machine and an embeddable scripting engine. It functions as a fiber-based concurrency runtime and includes a parsing engine based on Parsing Expression Grammars. The project is distinguished by its ability to be integrated into C or C++ applications via a minimal header interface. It utilizes a Lisp-style macro system for compile-time code transformation and employs prototype-based table inheritance for object-oriented behavior. The runtime covers a broad set of capabilities, including asynchronous

nom is a parser combinator framework for Rust used to build complex parsers by combining small, reusable parsing functions. It functions as a zero-copy parsing tool that minimizes memory overhead by returning slices of the original input instead of allocating new memory. The framework is designed for diverse data formats, serving as a binary data parser with configurable endianness and a bitstream processing library capable of extracting values of arbitrary bit length. It also functions as a streaming data parser that can process data arriving in chunks and signal when additional input is req

js-yaml is a JavaScript library providing a programmatic interface for parsing and dumping YAML data. It functions as a parser and serializer that converts YAML strings into JavaScript objects and transforms JavaScript objects back into YAML format. The library includes a command-line interface for parsing or dumping YAML data via direct input or data pipes. It also features an abstract syntax tree transformer to modify the structure of data during serialization. The project provides capabilities for multi-document processing and the definition of custom schemas and tags to handle specialize

TrumpScript is a Python-based domain specific language and compiler extension that wraps the Python runtime to enforce custom grammar and vocabulary rules. It transforms a specialized, case-insensitive vocabulary and natural speech patterns into executable Python instructions. The implementation distinguishes itself through strict constraints on source code, including a variable name system that restricts identifiers to a predefined whitelist and a numeric parser that rejects any integer not exceeding one million. It further utilizes a token-filtering preprocessor to remove filler words and n

DBML is a domain-specific language and schema definition language used for documenting database architecture and design. It provides a human-readable text format for defining database tables, columns, and relationships in a standardized way. The project functions as a relational schema parser and SQL schema generator. It transforms declarative design specifications into an abstract syntax tree for programmatic manipulation and converts these definitions into executable SQL statements across various database dialects. The system covers relational data modeling, database schema design, and arc

Railroad-diagrams is a utility for generating visual representations of formal grammars and language structures. It functions as a library that transforms dense notation systems, such as Backus-Naur Form or regular expressions, into readable flowcharts. The tool utilizes a coordinate-based layout engine and recursive component composition to construct diagrams as hierarchical trees. By separating geometric calculation logic from the output layer, it supports rendering through Scalable Vector Graphics or Unicode text, ensuring diagrams remain clear and scalable across different environments.

Taichi is a domain-specific programming language embedded in Python designed for high-performance numerical computing and computer graphics. It functions as a parallel compiler that translates high-level mathematical expressions into optimized machine instructions, enabling developers to write compute-intensive algorithms that execute across diverse hardware architectures, including CPUs, GPUs, and specialized accelerators. The project distinguishes itself through a hardware-agnostic execution layer that maps parallel operations to multiple backends such as CUDA, Metal, and Vulkan. By utilizi

InfluxDB is a specialized time series database platform engineered for the high-speed ingestion, compression, and retrieval of timestamped data at scale. It functions as a distributed metrics platform, providing the infrastructure necessary to organize and analyze massive volumes of time-stamped information to identify trends, patterns, and anomalies within complex data streams. The platform distinguishes itself through a functional dataflow engine that utilizes a specialized programming language for complex analytical transformations and automated tasks. This architecture is supported by a p

KaTeX is a typesetting library and web math renderer that transforms TeX and LaTeX mathematical notation into high-quality HTML and CSS for web browsers. It functions as a math notation parser and LaTeX to HTML converter, capable of operating as both a client-side library and a server-side math renderer to generate static HTML expressions. The project supports a wide range of specialized mathematical rendering, including chemical equation rendering, Bra-ket notation for quantum mechanics, and mathematical logic typesetting. It provides comprehensive controls for structural layouts such as mat

This project is a C language interpreter and a practical implementation of a programming language. It parses and executes C source code directly, removing the requirement for a separate compilation step. The interpreter is designed for self-hosting, meaning it is capable of interpreting its own source code to demonstrate recursive language processing and execution. The system covers the primary stages of language processing, including lexical analysis, recursive descent parsing, and tree-walk interpretation using an abstract syntax tree. It manages memory and scope through a dynamic symbol t

Streem is a stream-based programming language and data pipeline orchestrator. It provides a domain-specific language for defining concurrent data flows, allowing users to link data sources to destinations through a sequence of operations that transform and filter individual stream elements. The system uses a custom script syntax to define data-flow connections and pipeline definitions. This allows for the orchestration of concurrent data processing where multiple pipeline stages execute simultaneously to move data elements through the system. The platform covers functional data transformatio

syn is a Rust syntax tree parser and token stream converter. It serves as a toolkit for procedural macro development, providing a framework to parse Rust source code into structured syntax trees for analysis and transformation. The project enables the manipulation of Rust abstract syntax trees through specialized visitor and folder patterns for traversing and mutating nodes. It provides a bidirectional mapping that allows developers to convert token streams into structured trees and print those trees back into tokens for code generation. The library covers a broad range of syntax analysis ca

Cake is a cross-platform build automation system and scripting framework that allows users to define software build pipelines using C# scripts. It functions as a CI/CD pipeline orchestrator and build runner, providing a strongly-typed domain-specific language to simplify the orchestration of compilation, testing, and packaging processes across Windows, Linux, and macOS. The system ensures reproducible build environments by pinning the versions of build tools, modules, and dependencies. It distinguishes itself by enabling a C# scripting workflow with full IDE support, including autocomplete, s

Nearley is a JavaScript parser toolkit used to define context-free grammars and generate corresponding parsers. It features an EBNF grammar compiler that transforms language definitions written in extended Backus-Naur Form into executable JavaScript code, utilizing an Earley parser implementation to process any context-free grammar. The toolkit distinguishes itself by its ability to handle left-recursion and ambiguity without failing, allowing it to identify and return multiple valid derivations for a single input string. It also includes a grammar fuzzing generator to produce random strings

Acorn is a JavaScript parser that converts source text into a structured abstract syntax tree. It follows the ESTree specification to produce a standardized JSON tree format, enabling consistent analysis of code structure and language versions. The project features a plugin-based grammar extension system that allows the base parser to be extended with custom rules for experimental or non-standard language features. It also includes syntax error recovery, which inserts placeholder nodes into the tree when encountering invalid code to allow parsing to continue. The toolset covers static analys

Kaitai Struct is a framework for declarative binary specification that provides automated parser and serializer generation across multiple programming languages. It uses a portable, domain-specific language to describe the layout of binary files and network packets, converting these specifications into source code for reading and writing binary data. The system enables cross-language data processing by translating a single structural definition into native source code for languages including C++, C#, Go, Java, JavaScript, Python, and Rust. This approach allows the same binary data specificati

Wuffs is a toolset for generating memory-safe, sandboxed parsers and decoders from domain-specific language specifications. It functions as a compiler that transforms these specifications into executable code for C, Go, or Rust, specifically designed to decode untrusted file formats while preventing buffer and integer overflows. The project employs a sandboxed execution model that prohibits system calls and manual memory management to ensure computations are side-effect free. It utilizes a refined type system and compile-time constraint verification to enforce memory safety, alongside saturat

Emmet is a markup code generator and web development productivity toolkit. It serves as an expansion engine that converts shorthand abbreviations and CSS-like selectors into full HTML, XML, and other markup structures. The project features a dedicated CSS shorthand expansion engine that transforms concise property codes into full style declarations, including the automatic generation of vendor prefixes and gradients. It distinguishes itself by offering a programmable expansion process through custom snippet definitions, abbreviation alias mapping, and script-based extensibility. The toolkit

Mint is a front-end programming language and compiled web framework designed for building interactive user interfaces. It functions as a transpiler that converts a specialized domain-specific language into standard JavaScript and CSS for execution in a web browser. The toolchain enables type-safe UI development by utilizing static type analysis to validate data structures during the build phase. It organizes web interface logic into a component-based architecture, where encapsulated units synchronize internal state with the rendered view. The system covers a full compiled web toolchain, incl