Java Compiler Compiler (JavaCC) is the most popular parser generator for use with Java applications.

A parser generator is a tool that reads a grammar specification and converts it to a Java program that can recognize matches to the grammar.

In addition to the parser generator itself, JavaCC provides other standard capabilities related to parser generation such as tree building (via a tool called JJTree included with JavaCC), actions and debugging.

All you need to run a JavaCC parser, once generated, is a Java Runtime Environment (JRE).





This example recognizes matching braces followed by zero or more line terminators and then an end of file.

Examples of legal strings in this grammar are:

{}, {‎{‎{‎{‎{}}}}} // … etc

Examples of illegal strings are:

{}{}, }{}}, { }, {x} // … etc



/** Simple brace matcher. */
public class Example {

  /** Main entry point. */
  public static void main(String args[]) throws ParseException {
    Example parser = new Example(;



/** Root production. */
void Input() :
  MatchedBraces() ("\n"|"\r")* <EOF>

/** Brace matching production. */
void MatchedBraces() :
  "{" [ MatchedBraces() ] "}"


$ java Example
$ java Example
Lexical error at line 1, column 2.  Encountered: "x"
TokenMgrError: Lexical error at line 1, column 2.  Encountered: "x" (120), after : ""
        at ExampleTokenManager.getNextToken(
        at Example.getToken(
        at Example.MatchedBraces(
        at Example.Input(
        at Example.main(
$ java Example
ParseException: Encountered "}" at line 1, column 3.
Was expecting one of:
    "\n" ...
    "\r" ...
        at Example.generateParseException(
        at Example.jj_consume_token(
        at Example.Input(
        at Example.main(

Getting Started

Follow the steps here to get started with JavaCC.

This guide will walk you through locally building the project, running an existing example, and setup to start developing and testing your own JavaCC application.

Download & Installation

JavaCC 7.0.12 is our latest stable release.

All JavaCC releases are available via GitHub and Maven including checksums and cryptographic signatures.

For all previous releases, please see stable releases.

The GitHub 8.0 branch contains the next generation of JavaCC that splits the frontend – the JavaCC parser – from the backends – the code generator targeted for Java, C++ &and C# –. Status of JavaCC is experimental and not production ready.


To install JavaCC, navigate to the download directory and type:

$ unzip
$ tar xvf javacc-7.0.12.tar.gz

Then place the binary javacc-7.0.12.jar in a new target/ folder, and rename to javacc.jar.

Once you have completed installation add the scripts/ directory in the JavaCC installation to your PATH. The JavaCC, JJTree, and JJDoc invocation scripts/executables reside in this directory.

On UNIX based systems, the scripts may not be executable immediately. This can be solved by using the command from the javacc-7.0.12/ directory:

chmod +x scripts/javacc

Building JavaCC from Source

The source contain the JavaCC, JJTree and JJDoc sources, launcher scripts, example grammars and documentation. It also contains a bootstrap version of JavaCC needed to build JavaCC.

Prerequisites for building JavaCC:

$ git clone
$ cd javacc
$ ant

This will build the javacc.jar file in the target/ directory

Developing JavaCC

Minimal requirements for an IDE are:

IntelliJ IDEA

The IntelliJ IDE supports Maven out of the box and offers a plugin for JavaCC development.

Eclipse IDE


JavaCC is by far the most popular parser generator used with Java applications with an estimated user base of over 1,000 users and more than 100,000 downloads to date.

It is maintained by the developer community which includes the original authors and Chris Ainsley, Tim Pizney and Francis Andre.


Don’t hesitate to ask!

Contact the developers and community on the Google user group or email us at JavaCC Support if you need any help.

Open an issue if you found a bug in JavaCC.

For questions relating to development please join our Slack channel.


The documentation is located on the website and in the docs/ directory of the source code on GitHub.

It includes detailed documentation for JavaCC, JJTree, and JJDoc.





Parsing theory

Powered by JavaCC

JavaCC is used in many commercial applications and open source projects.

The following list highlights a few notable JavaCC projects that run interesting use cases in production, with links to the relevant grammar specifications.

User Use Case Grammar File(s)
Apache ActiveMQ Parsing JMS selector statements SelectorParser.jj, HyphenatedParser.jj
Apache Avro Parsing higher-level languages into Avro Schema idl.jj
Apache Calcite Parsing SQL statements Parser.jj
Apache Camel Parsing stored SQL templates sspt.jj
Apache Jena Parsing queries written in SPARQL, ARQ, SSE, Turtle and JSON sparql_10, sparql_11, arq.jj, sse.jj, turtle.jj, json.jj
Apache Lucene Parsing search queries QueryParser.jj
Apache Tomcat Parsing Expression Language (EL) and JSON ELParser.jjt, JSONParser.jj
Apache Zookeeper Optimising serialisation/deserialisation of Hadoop I/O records rcc.jj
Java Parser Parsing Java language files java.jj
JOSM Parsing MapCSS files MapCSSParser.jj


JavaCC is an open source project released under the BSD License 2.0. The JavaCC project was originally developed at Sun Microsystems Inc. by Sreeni Viswanadha and Sriram Sankar.