Open Source Parser Generators
Sort By:
Parser Generators
View 5920 business solutionsBrowse free open source Parser Generators and projects below. Use the toggles on the left to filter open source Parser Generators by OS, license, language, programming language, and project status.
-
99.99% Uptime for MySQL and PostgreSQL DatabasesCloud SQL Enterprise Plus delivers near-zero downtime with 35 days of point-in-time recovery. Supports MySQL, PostgreSQL, and SQL Server.
-
Host LLMs in Production With On-Demand GPUsDeploy your model, get an endpoint, pay only for compute time. No GPU provisioning or infrastructure management required.
-
1
Win flex-bison
Win flex-bison is a port Flex & Bison tools to the Windows platform
Win flex-bison is a windows port the Flex (the fast lexical analyser) and Bison (GNU parser generator). win_flex based on Flex version 2.6.3 source code and win_bison based on Bison version 2.7 and they depend on system libraries only. Git repository: https://github.com/lexxmark/winflexbison UPDATE1: Bison version 3.x.x available in Files section in win_flex_bison3-latest.zip package. UPDATE2: Now "winflexbison" available as package in Chocolatey (https://chocolatey.org/packages/winflexbison and https://chocolatey.org/packages/winflexbison3) UPDATE3: You can use VS custom build rules to simplify working with winflexbison in Visual Studio 2010 and upper (https://sourceforge.net/p/winflexbison/wiki/Visual%20Studio%20custom%20build%20rules/). -
2
ANTLR
Parser generator to read, process, or translate structured text
ANTLR (ANother Tool for Language Recognition) is a powerful parser generator for reading, processing, executing, or translating structured text or binary files. It's widely used to build languages, tools, and frameworks. From a grammar, ANTLR generates a parser that can build and walk parse trees. It’s widely used in academia and industry to build all sorts of languages, tools, and frameworks. Twitter search uses ANTLR for query parsing, with over 2 billion queries a day. The languages for Hive and Pig, the data warehouse and analysis systems for Hadoop, both use ANTLR. Lex Machina uses ANTLR for information extraction from legal texts. Oracle uses ANTLR within SQL Developer IDE and their migration tools. NetBeans IDE parses C++ with ANTLR. The HQL language in the Hibernate object-relational mapping framework is built with ANTLR. -
3
tree-sitter
An incremental parsing system for programming tools
Tree-sitter is a parser generator tool and an incremental parsing library. It can build a concrete syntax tree for a source file and efficiently update the syntax tree as the source file is edited. General enough to parse any programming language. Fast enough to parse on every keystroke in a text editor. Robust enough to provide useful results even in the presence of syntax errors. Dependency-free so that the runtime library (which is written in pure C) can be embedded in any application. All of Tree-sitter’s parsing functionality is exposed through C APIs. Applications written in higher-level languages can use Tree-sitter via binding libraries like node-tree-sitter or the tree-sitter rust crate, which have their own documentation. To build the library on a POSIX system, just run make in the Tree-sitter directory. This will create a static library called libtree-sitter.a as well as dynamic libraries. -
4
C#Prolog
C#Prolog -- A Prolog interpreter written in managed C#
C#Prolog -- A Prolog interpreter written in C#. Can easily be integrated in C# programs. Characteristics: reliable and fairly fast interpreter, command line interface, Windows-interface, builtin DCG, XML- and JSON-predicates, SQL-predicates, extendible. -
Gemini 3 and 200+ AI Models on One PlatformBuild generative AI apps with Vertex AI. Switch between models without switching platforms.
-
5
RapidJSON
A fast JSON parser/generator for C++ with both SAX/DOM style API
RapidJSON is a JSON parser and generator for C++. It was inspired by RapidXml. RapidJSON is small but complete. It supports both SAX and DOM style API. The SAX parser is only a half thousand lines of code. RapidJSON is fast. Its performance can be comparable to strlen(). It also optionally supports SSE2/SSE4.2 for acceleration. RapidJSON is self-contained and header-only. It does not depend on external libraries such as BOOST. It even does not depend on STL. RapidJSON is memory-friendly. Each JSON value occupies exactly 16 bytes for most 32/64-bit machines (excluding text string). By default it uses a fast memory allocator, and the parser allocates memory compactly during parsing. RapidJSON is Unicode-friendly. It supports UTF-8, UTF-16, UTF-32 (LE & BE), and their detection, validation and transcoding internally. For example, you can read a UTF-8 file and let RapidJSON transcode the JSON strings into UTF-16 in the DOM. It also supports surrogates and "\u0000" (null character). -
6
Parser for Rust source code
Parser for Rust source code
Parser for Rust source code is a major Rust crate for parsing Rust source code (token streams) into a syntax tree (AST) that procedural macros can inspect or transform. The primary target is macro authors: you can parse TokenStreams into syn::File, syn::Item, syn::Expr, syn::Type, etc. It offers rich data structures, fine-grained parsing, span tracking (for error reporting), traversal and mutation APIs (visit, fold, visit_mut), printing back to tokens, and strong feature-gating so you only compile what you need. The documentation emphasises that while the crate is geared for procedural macros (and custom derives), some of the APIs may be of more general use. Using syn you can effectively write code that analyzes or generates Rust code at compile time. -
7
JSON-Machine
Efficient, easy-to-use, and fast PHP JSON stream parser
json-machine is an efficient and easy-to-use PHP JSON stream parser. It enables processing of large JSON files or streams without loading the entire content into memory, making it suitable for memory-constrained environments. -
8
Portable Executable Parser
lightweight Go package to parse, analyze and extract metadata
Saferwall PE is a lightweight Go package for parsing, analyzing, and extracting metadata from Portable Executable (PE) binaries. Designed with malware analysis in mind, it is robust against malformed PE files and provides detailed insights into executable structures. -
9
Swift Argument Parser
Straightforward, type-safe argument parsing for Swift
Swift Argument Parser is a type-safe, declarative library for building Swift command-line tools by annotating your command types with property wrappers like @Option, @Argument, and @Flag. It handles parsing, validation, automatic help generation, and dispatch to your run() or async entry point, letting you focus on command logic instead of boilerplate. The package supports subcommands, default values, custom parsing strategies, and rich error messages that match platform conventions. It integrates cleanly with Swift Package Manager, works well in CI, and provides incremental improvements such as Sendable conformances for wrappers to help in concurrent contexts. The issue tracker and releases show active maintenance, real-world usage patterns, and design notes for advanced scenarios like collecting unrecognized arguments or mixing parent options with subcommands. Overall, it standardizes CLI ergonomics across the Swift ecosystem with a small, testable surface. -
Custom VMs From 1 to 96 vCPUs With 99.95% UptimeLive migration and automatic failover keep workloads online through maintenance. One free e2-micro VM every month.
-
10
MLton
A whole-program optimizing compiler for Standard ML
MLton is a whole-program optimizing compiler for Standard ML. MLton generates small executables with excellent runtime performance, utilizing untagged and unboxed native integers, reals, and words, unboxed native arrays, fast arbitrary-precision arithmetic based on GnuMP, and multiple code generation and garbage collection strategies. In addition, MLton provides a feature rich Standard ML programming environment, with full support for SML97 as given in The Definition of Standard ML (Revised), a number of useful language extensions, a complete implementation of the Standard ML Basis Library, various useful libraries, a simple and fast C foreign function interface, the ML Basis system for programming with source libraries, and tools such as a lexer generator, a parser generator, and a profiler. -
11
This project has moved to GitHub ! The version here at SourceForge will remain for historic purpose. Koopa is a parser generator, made for COBOL. It can handle source files in isolation (no preprocessing required) and doesn't mind the presence of CICS/SQL fragments. The grammar is easily extensible in a way which minimizes the impact on the overall code.
-
12
UniCC LALR(1) Parser Generator
Parser generator, targetting C, C++, Python, JavaScript, JSON and XML
UniCC (UNIversal Compiler-Compiler) compiles an augmented grammar definition into a program source code that parses the described grammar. Because UniCC is intended to be target-language independent, it can be configured via template definition files to emit parsers in almost any programming language. UniCC comes with out of the box support for the programming languages C, C++, Python (both 2.x and 3.x) and JavaScript. Parsers can also be generated into JSON and XML. -
13
Genparse is a command line parser generator. Based on a simple description of the command line options you want in your program, genparse creates the necessary C, C++ or Java code for their processing.
-
14
JSON Parser
JSON Parser written in C that outputs JSON into D-List list objects
JSON parser is a highly efficient JSON data decoder written in C, that parses JSON data into a form that is very easy to use from within C code. You only need to include the json-parser.h file in your source code. If your project does not already incorporate D-List, you will also need to include dlist.h The JSON parser package also includes a JSON validator that does not parse or create resources, but allows the caller to validate JSON data from unknown sources, prior to any parsing attempts. The JSON data is returned to the caller as a set of hierarchical D-List list objects, that make the data very easy to manage, sort, search or use, and easy to remove when done. Package includes a JSON textural generator which will create JSON grammar data blocks from hierarchical D-List representations of JSON data. The package also includes a variety of support functions to allow C code to easily find, add, and modify JSON values and members in D-List hierarchical structures. -
15
Ox: Attribute Grammar Compiling System
Ox is an attribute-grammar evaluator generator.
Ox is an attribute grammar compiling system that augments Lex and Yacc specifications with definitions of synthesized and inherited attributes written in a combination of Ox and C/C++ syntax. From these augmented specifications, Ox generates ordinary Lex and Yacc specifications that build and decorate attributed parse trees. The user can specify parse-tree traversals for easy ordering of side effects such as code generation. Ox handles the tedious and error-prone details of writing code for parse-tree management, so its use eases problems of security and maintainability associated with that aspect of translator development. -
16
COBOL copybook to XML converter
Converts cobol copybooks to Xml/Java objects
CB2XML (CopyBook to XML) is a COBOL CopyBook to XML converter written in Java and based on the SableCC parser generator. This project includes utilities to convert an XML instance file into its COBOL copybook equivalent string buffer and vice versa. Source is now available in GitHub: https://github.com/bmTas/cb2xml -
17
Lapg is the combined lexical analyzer and parser generator, which converts a description for a context-free LALR grammar into source file to parse the grammar. Generates code for Java, Javascript, C, C++ and C#.
-
18
A parser generator derived from ANTLR with JavaCC like (but not the same) syntax and some new features. It also comes with sample grammars for CSharp, Java, GnuC, Html, XHtml, Xml, ECMA262... etc.
-
19
A universal parsing tool and source code generator for generative programming. It extracts useful information by parsing (BNF parser generator) and generates source code by several techniques, by interpreting a scripting language for flexibility.
-
20
lightJacc is a small but strong grammar parser generator. It adopts a parsing strategy of its own: dynamic concurrent parsing -- which made it much stronger than LR or LL family CCs (YACC, ANTLR, etc), but still keep good performance.
-
21
LR Parser and Lexer Generators: Fortran
LR parser generator and lexer generator for use in Fortran
The generator for LR parsers uses Pager's method, augmented with Tom Pennello's Forward Move Algorithm for error recovery. The grammar specifies identifiers for nodes in the abstract syntax tree, and the identifiers for tokens. It generates Fortran declarations for tree node identifiers and named constants that represent the PDA. The lexer generator accepts regular expressions and generates a DFA. It generates Fortran declarations for character classes, recognized objects, named constants that represent the DFA. A third program generates declarations that connect the parser and lexer. The LR parser generator and lexer generator both use parsers and lexers generated by themselves. An infrastructure to use a generated lexer and parser is therefore included as part of these programs. -
22
Parse software messages and transform them into actions. LazyBat has a command line utility which can transform input data, and also a parser generator for C/C++. LazyBat doesn't support recursive parsing, but rather focuses on common parsing jobs.
-
23
SableCC is a parser generator which generates object-oriented frameworks for building compilers, interpreters and other text parsers. SableCC keeps a clean separation between machine and user code which leads to a shorter development cycle.
-
24
json_library
Another C++ based JSON Library (/w Parser/Generator/Navigator)
Native C++ implementation of a JSON library. Contains a Parser, a Generator and and easy-to-use Navigator in one single class. To build you will need at least a C++11 capable compiler such as MSVC 10 (express edition). There is no other 3rd party library required to compile or run it. -
25
qtBisonC++ is a general-purpose parser generator that converts a grammar description for an LALR(1) context-free grammar into a QT C++ program to parse that grammar. qtBisonC++ reads the given input files for a description of a scanner to generate. The description is in the form of grammar in Backus-Naur Form (BNF), called rules. qtBisonC++ generates as output a C++ source and include file, `lexyy.cpp` and `lexyy.h`, which defines a class `lexyy'. This file is compiled with your code to produce an executable. When the executable is run, it analyses its input to verify that its correspond to the grammar.
Guide to Open Source Parser Generators
Open source parser generators are tools that allow users to create parsers for converting data into a usable form. Parsers, also known as syntactic analyzers, are the component of a compiler which takes an input in the form of a sequence of tokens and produces output in the form of an abstract syntax tree (AST). As opposed to closed-source alternatives, open source parser generators are freely available to everyone for use or modification.
Parser generators simplify many of the difficult tasks associated with creating parsers from scratch. They provide a means for writing the grammar rules for parsing and then generate code that can be used directly by applications. The generated code is efficient, reliable, and often portable across different languages and platforms. Some open source parser generator projects provide tools which streamline entire development cycles including code generation, debugging, testing, and optimization.
One popular example of an open source parser generator is ANTLR (Another Tool for Language Recognition), developed by Terence Parr at San Diego State University. It can be used to define grammars in various programming languages such as Java, C++, Python, Objective-C, JavaScript and more. It was initially written in Java but has since been ported to other languages such as C# and JavaScript. ANTLR supports multiple features like AST construction via construction templates, attribute evaluation via semantic predicates and support for left recursion elimination through direct left-recursion conversion algorithms.
Other notable examples include Irony (a .NET based language implementation toolkit) and Bison (a widely-used Linux/Unix tool). These tools significantly reduce time spent on developing parsers from scratch while providing greater flexibility than commercial solutions. As developers continue to develop new tools tailored towards specific needs they will likely further bolster the growth of open source parser generators in years to come.
Features of Open Source Parser Generators
- Syntax Analysis: Open source parser generators typically provide robust syntax analysis capabilities. This includes the ability to analyze different types of languages, such as Java, C#, and others, and to create a parse tree that accurately reflects the structure of code within a software.
- Error Handling: An important feature of open source parser generators is their ability to detect and handle errors in input files. Parsers typically include an error reporting system which provides details about any issues encountered during parsing processes.
- Optimization: Open source parser generators often contain optimizations which enable efficient parsing performance. These optimizations can be used to speed up the process of analyzing input files and constructing parse trees for tools written in complex languages.
- Generated Code Quality: Some open source parser generators are designed to generate high-quality code at runtime. This code is usually optimized for specific target platforms or architectures, allowing developers to quickly create efficient software applications with minimal effort.
- Flexibility: Open source parser generators are generally very flexible and customizable. Many include support for customizing the generated code or extending existing parsers via plugins or other tools. This allows developers to tailor their solutions for specific problems or scenarios they may encounter while creating software applications.
- Support: Open source parser generators usually have extensive support options available. This includes detailed documentation, community forums, and bug tracking systems that allow developers to quickly get help or report issues they encounter while using the parser generator.
What Are the Different Types of Open Source Parser Generators?
- LR Parsers: LR (Left to Right, Rightmost derivation) parsers are a type of parser that uses bottom-up processing and shift-reduce parsing. They analyze the input strings and generate parse trees for a given grammar. They are limited in the complexity of grammar they can understand and may produce incorrect parses if the grammar is ambiguous.
- LL Parsers: LL (Left to Left, Leftmost derivation) parsers are a type of parser that uses top-down processing and recursive descent parsing. They attempt to recognize patterns in an input string using a set of rewrite rules. Compared to LR parsers, LL parsers provide better error detection, accept more complex grammars, and have better performance when dealing with left recursion.
- Recursive Descent Parser: A recursive descent parser is an LL parser that uses the top-down approach to analyzing strings by matching them against nonterminals from the production rules specified in its grammar. The recursive descent parser follows a predetermined order each time it attempts to find matches in an input string, recursively descending into child nodes until it finds either successful or unsuccessful matches for each rule specified by the grammar.
- GLR Parser: GLR (Generalized Left-to-right Rightmost Derivation) parsers use multiple LR states at once while attempting to parse an input string. This allows them to parse any context-free language without having restrictions on the grammars used like traditional LR parsers do, making them much more powerful than their predecessors while still providing good performance when dealing with ambiguity issues found in many natural languages such as English.
- Packrat Parser: Packrat parsers are an advanced class of LL parser that use backtracking techniques combined with memoization caching so they only need to visit each position in an input string once while parsing it. This makes them very efficient when used for static analysis applications such as syntax highlighting or code completion tools because they don't need to constantly reanalyze code already parsed before moving on to other parts of the source file being processed.
- Earley Parser: The Earley parser is an advanced LL parser that uses dynamic programming algorithms to parse a wide range of grammars. It can analyze both ambiguous and unambiguous strings, making it suitable for natural language processing applications such as automatic translation or speech recognition systems. Additionally, it is one of the few parser generators that can parse arbitrary context-free grammars while still providing good performance even for highly ambiguous inputs.
Open Source Parser Generators Benefits
Open source parser generators provide a wealth of benefits to users, including:
- Cost Savings: Open source parsers are free to use and often come with fewer licensing restrictions than proprietary products. This helps to significantly reduce the cost of developing applications that require complex parsing tasks, allowing businesses and developers to be more efficient in their operations.
- Flexibility: Most open source parser generators are highly customizable, allowing developers to extend or adjust the functionality of the application as needed. This makes it easier for developers to create solutions that fit specific requirements while ensuring they have full control over how the software behaves.
- High Quality Results: Open source parsers produce highly accurate results that can be relied upon for mission critical applications. These tools can also be used in combination with other open source libraries and frameworks for even greater accuracy and flexibility.
- Easy To Use: Open source parser generators are typically designed with simplicity in mind, making them easy-to-use even by those who lack extensive programming experience. This allows companies and individuals alike to quickly develop powerful applications without having to spend time learning complex programming languages or hiring expensive consultants.
- Secure and Reliable: Much like commercial parsing tools, open source parser generators come with built-in security features such as encryption algorithms and authentication protocols which ensure all data is kept secure during processing. They also offer robust reliability features which help prevent data loss or corruption from occurring during operation.
- Support: Open source parser generators are backed by a vibrant community of users who actively provide support in the form of tutorials, documentation, and other helpful resources. This makes it easier for developers to quickly identify and fix any issues that may arise when using the tool.
What Types of Users Use Open Source Parser Generators?
- Programmers: Programmers use open source parser generators to develop software from written code. They often incorporate these tools to improve the speed and efficiency of software development.
- Application Developers: These users utilize open source parser generators when creating applications that require specific programming language support. The generated parsers enable a better understanding of how user interactions affect the application's development.
- System Administrators: System Administrators are responsible for managing, maintaining, and optimizing server-side infrastructure. Parser generators provide an efficient way to quickly interpret log files and troubleshoot system performance issues.
- Researchers: Researchers use parser generators when conducting research that requires them to analyze large data sets quickly. Parser generators automate the process of finding patterns in data and can provide faster insight into research than manual parsing techniques.
- Data Analysts: Data Analysts use open source parser generators to more efficiently extract valuable information from raw data sources such as web logs or databases. Parsing tools help analysts build a deeper understanding of their datasets with less effort than traditional methods require.
- Business Analysts: Business analysts can benefit from the ease of access provided by open source parser generators when analyzing financial documents or customer feedback surveys for insights into business operations or consumer behavior trends.
- Security Analysts: Security analysts use parser generators to automate the process of scanning for vulnerabilities in code. The generated parsers enable a more precise examination of code that can help detect security issues quickly and accurately.
How Much Do Open Source Parser Generators Cost?
Open source parser generator tools are generally available for free. However, the cost of these tools can vary depending on their complexity and features. Some open source parser generators may require a license or subscription fee in order to access advanced features or use them commercially. Others may simply require a donation or voluntary contribution to the project creator in order to gain access. There are even some open source parser generator tools that are entirely free with no strings attached.
Using an open source parser generator can be very beneficial because it allows developers to customize the code and make changes as needed without relying on commercial software solutions. Additionally, these tools can save time and money when compared to creating a custom solution from scratch for each unique project. Ultimately, the cost of an open source parser generator can range from nothing to hundreds of dollars depending on your specific needs and desired features.
What Software Do Open Source Parser Generators Integrate With?
Open source CRM software can integrate with a variety of different types of software, such as accounting and billing software, customer service platforms, ecommerce solutions, marketing automation tools, analytics and reporting tools, and even project management systems. Integrating these various solutions into one streamlined system allows you to streamline processes and increase efficiency. For example, integrating an ecommerce platform can allow customers to make purchases directly from within the CRM system without being redirected to another page.
Additionally, automated marketing tools can help increase customer engagement by automatically sending personalized emails or texts based on segmentations and behavior. By combining these functions within one intuitive system, businesses can gain powerful insights into their customers’ buying habits that they may otherwise miss out on if all the data were stored separately. Ultimately, open source CRM software is highly customizable and allows users to create a powerful business tool tailored specifically to their company’s needs.
Recent Trends Related to Open Source Parser Generators
- Increased Flexibility: Open source parser generators offer a high degree of flexibility, allowing developers to write their own custom parsers that can handle more complex input formats and data structures.
- Greater Availability: Since open source parser generators are freely available, they can be used by anyone, regardless of programming expertise or budget. This makes them ideal for smaller projects that don’t have access to expensive commercial tools.
- More Platforms Supported: Since open source parser generators are not restricted to operating systems platforms such as Windows or MacOS, they can run on almost any platform. This makes them very popular among cross-platform developers.
- Improved Documentation: An increasing number of open source parser generator projects provide detailed documentation about the features and capabilities of their offerings. This makes it easier for developers to understand how the software works before committing to using it.
- Faster Development Cycles: Open source parser generators allow developers to quickly iterate and test new ideas without having to invest in costly development cycles. Additionally, updates and bugfixes are often regular fixtures thanks to an active community of contributors who constantly monitor the project for errors and issues.
- Enhanced Security: Many open source parser generators use secure coding practices which helps ensure greater safety when handling sensitive data from external sources. Additionally, since users often have instant access to security patches, they can keep their system up-to-date with the latest security measures at all times.
- Reduced Cost: Open source parser generators are usually cheaper than their commercial counterparts, allowing developers to save money while still taking advantage of powerful features. Additionally, many open source projects also offer free versions that have a limited feature set but are still suitable for smaller projects.
How Users Can Get Started With Open Source Parser Generator
Using open source parser generators is an easy way to quickly create parsers for any language. The first step to getting started with open source parser generators is to download the necessary software and tools. Many open source parser generators are available online for free, such as SLY, PLY, ANTLR, and Bison. After downloading these tools, users will need to familiarize themselves with the language structures they use in order to write and parse code. This step might require some research and time spent reading the documentation and tutorials that come with each tool.
Once users become comfortable with the language syntax of these tools, they can begin writing their own parsers using the examples provided by the tool or by starting from scratch. They will likely need to define a set of grammar rules which describe how words should be parsed into meaningful components within their chosen language structure in order for it to be properly understood by computers. Depending on the complexity of the language structure used, this process can take some time and experimentation.
Once users have defined their grammar rules, they can begin compiling their code using either an interpreter or compiler depending on their chosen tool. Interpreters are often simpler but slower than compilers which compile code into machine-readable instructions before executing them. Once compiled successfully, users can test out their parsers directly on a computer or even through a web browser using a testing environment such as Online Python Tutor which allows you to debug your tools in real-time while keeping track of variables and function calls within your tool's execution trace log.
Creating parsers may seem daunting at first but becoming comfortable with these open source parser generators can go a long way towards alleviating stress when writing complex tools that require intricate analysis of data sets or text strings in order for them to be interpreted correctly by computers. With some practice and dedication, anyone should be able to get started creating powerful parsers utilizing open source parser generator tools.
