OpenCCG is a Java library which can handle both parsing and generation. I’ve mostly used it for surface realization, converting fairly syntactic meaning representations into a natural language text, but you can use it for parsing or for generation from higher-level semantic representations if you’d like.
This tutorial is intended to help you:
- Install the current version of OpenCCG
We’re partly following the OpenCCG README in these guidelines, and you should defer to the official documentation if anything in this tutorial conflicts with that, unless otherwise noted.
- Java 1.6 or later
- Python 2.4 or later (check Py3 compatibility)
Getting the code
If you want to keep your version up to date with the official releases, the easiest way to do that is to clone the repository from GitHub:
git clone https://github.com/OpenCCG/openccg.git
This will create a directory
openccg/ in your current working directory and fill it with the code from the project.
Alternatively, you can download a compressed archive of OpenCCG on SourceForge.
At the time of writing, the SourceForge page provides version 0.9.5 while GitHub has version 0.9.6. The differences between these two, however, appear to be purely cosmetic (i.e. the version number was updated when files were prepared for release on GitHub).
Getting required libraries for the Git Repo
The one downside to using
git is that it is not intended to track binary files, so if you chose to clone the git repo above, you will need to download the archive from SourceForge anyway in order to get the following libraries:
The libraries are located in the
lib/ directory of
openccg-0.9.5.tgz. If you installed via
git, copy these files to the
lib/ directory of your OpenCCG git repository.
If you’re installing from SourceForge, they’re already in the right place, so you can ignore this step.
Building and installing OpenCCG
In order to use OpenCCG, we first have to compile the code. This requires setting a few ‘environment variables’ on your computer so it knows where to find (1) the Java Development Kit (JDK) and (2) OpenCCG.
Then we can run the
ccg-build script to build the project and make it executable.
Setting Environment Variables
We have to set at least two environment variables for OpenCCG to work:
JAVA_HOME, which is where our JDK is installed, and
OPENCCG_HOME for the location of our
In bash, you can find out where Java is installed by running
which java. The following examples show the result on my computer:
$ which java /usr/bin/java
This is often a symbolic link (a shortcut), though, so it is helpful to get the full listing and keep going until we have a real file and not a shortcut:
$ ls -l /usr/bin/java /etc/alternatives/java $ ls -l /etc/alternatives/java /usr/lib/jvm/java-1.8.0-openjdk-188.8.131.52-1.b12.fc25.x86_64/jre/bin/java
We see here that this is the location of
java, but several of the OpenCCG scripts call
javac (the Java compiler) by adding
bin/javac to the
JAVA_HOME environment variable, so we want to set our
If you run into errors, double check that you have
javac installed in addition to java. Plain Java is often distributed as the Java Runtime Environment (JRE) to run compiled Java code from, e.g.,
.jar files, while
javac is a part of the JDK.
In Linux & Mac you can use the bash shell in a terminal window to set
$ export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-184.108.40.206-1.b12.fc25.x86_64
(Note that the
$ is not a part of the command. It just represents the command prompt.)
If you are using something other than bash on Mac or Linux, try googling ‘setting environment variables in OPERATING SYSTEM OR TERMINAL’ for your operating system or terminal/shell. The OpenCCG README also includes some details for configuring these variables in Windows.
We should similarly set the environment variable
OPENCCG_HOME to point to the
openccg/ directory. If installed to
user’s home directory, this would be
$ export OPENCCG_HOME=/home/user/openccg
on most (all?) Linux distributions. Setting persistent environment variables
In Linux, you can modify the
.bashrc file located in your user’s home directory to include the export statements mentioned above. Otherwise you will have to re-set them every time you want to run OpenCCG in a new session.
In a terminal, navigate to your
openccg/ directory and execute the following:
The OpenCCG project uses Apache’s “Ant” build system to handle all the compiling (and then some).
If this worked, you should see a bunch of output followed by “BUILD SUCCESSFUL” and an estimate of how long the build took.
And that’s it! Now you should be able to use OpenCCG. If you’re not sure what to do next, keep an eye out for additional OpenCCG tutorials in the near future.