Become a language pair developer for Apertium

From Apertium
Jump to: navigation, search

En français


This is a step-by-step guide on how to use a development version of Apertium to make a change in a language pair.

[edit] Introduction

You will need:

  • a Unix-based operating system (Linux, BSD, OS X, etc.), or download our VirtualBox if you are on Windows (see next section)
  • a text editor, preferably with good XML highlighting – see XML editors for some popular choices,
  • a thorough understanding of the languages you wish to develop for,
  • an IRC client so you can ask for help when you get into trouble,

If you wish to contribute to the main repository, you will also have to ask for commit access on SourceForge

[edit] Getting Ready

The first thing you need to do, is install the core modules apertium, lttoolbox and apertium-lex-tools. The page Installation shows how to do this, by first installing Prerequisites, and then installing the core modules from SVN. Note that if you're on Windows, you should use the Virtualbox, which comes with core modules already installed.

The Minimal installation from SVN step of the procedure also shows how to install an example language pair apertium-eo-en, you should probably install that language pair just to make sure things work before you move on to whatever language pair you plan on working on.

Note that some existing language pairs have external dependencies, like HFST or Constraint Grammar, the Installation page links to their installation procedures. (Again, the Virtualbox has them preinstalled.)

[edit] Get your language pair(s)

Using the same terminal, you can easily download and add the language pairs you want using a command like:

svn checkout svn://

In the area where it says SVN_MODULE, replace this with the the name of the svn subdirectory where the chosen language pair is.

In the area where it says PAIR_NAME, replace this with the name of the chosen language pair.

For example, if you wanted to retrieve the language pair Spanish/English (which is in trunk) and French/Portuguese (which was in staging as of June 2012) you could type:

svn checkout svn://
svn checkout svn://

You can go to [1] to see a list of SVN modules, clicking on each shows a list of language pairs. Language pairs are sorted into SVN modules based on how "complete" they are, where trunk is release-quality, staging is very close to release-quality, nursery is for stuff that's 1-3 months of concentrated work from release quality, and incubator is fragments and anything not complete enough to live in the other modules.

[edit] Compilation of your language pair

Compilation of a language pair is similar to lttoolbox and apertium, except you don't need to do "sudo ldconfig", and you should not do "sudo make install" since it's easier and faster to run from the source folder:

PKG_CONFIG_PATH=/usr/local/lib/pkgconfig ./
make -j3

for each language pair, replacing the text PAIR_NAME by the appropriate name.

[edit] Changing Things Around

When you want to make a change in Apertium, you more than likely want to add a word to an existing language pair. For a full explanation go to Contributing to an existing pair. You can also check out the Contact page for Apertium mailing lists and live help through IRC.

IMPORTANT: Adding a word won't do you any good if you don't recompile the modules after the change is made. Simply use the terminal like before and enter: make and press the "Enter" key and your computer will create the new files necessary.

There are 3 major steps in adding a new word to a language pair:

1. Add an entry to the dictionary for the first language that will be used.

2. Add an entry to the bilingual dictionary for the pair.

3. Add an entry to the dictionary for the second language that will be used.

You will need to find the module you want to work with on your computer and open the three dictionaries; for example:,, and Note: Each dictionary will have the suffix ".dix" You should open these files in a text editor or specialized XML editor.

[edit] Step 1: Adding to the First Dictionary

When adding entries, you have to enter the lemma (word as you would read it in a dictionary),the part between <i> and </i> that contains the prefix of the word that is common to all inflected forms, and the element in <par> that refers to the inflection paradigm of this word. All entries will have a basic structure like:

      <e lm="(lemma)">
        <par n="(paradigm)"/>

A good example of this would be:

      <e lm="cósmico">
        <par n="absolut/o__adj"/>

Start by opening your first language's dictionary file. For example: (an XML file).

Then, create a new entry with the basic structure next to a similar entry in the dictionary. The order of entries doesn't matter.

Now, between the quotes in the area where it says (lemma) replace (lemma) with your word. Note: Do not include () in entries, but place input between "".

Next, you can enter the prefix in the space between <i> and </i> and replace (prefix).

Finally, enter the paradigm in <par> between the quotations. The paradigm should consist of the prefix of another word that has the same inflection and is already in the dictionary and has the morphological analysis: adj m sg, adj f sg, adj m pl and adj f pl respectively. For example: <par n="absolut/o__adj"/> for cósmico. This entry means that the adjective "cósmico" inflects like the adjective "absoluto" and has the same morphological analysis: the forms cósmico, cósmica, cósmicos, and cósmicas are equivalent to the forms absoluto, absoluta, absolutos, and absolutas and have the morphological analysis: adj m sg, adj f sg, adj m pl and adj f pl respectively.

Now, save your altered dictionary, and DO NOT change file name, directory, or file type.

To finish, use the terminal and navigate to the directory that your module is housed in and enter make. Now press the "Enter" key and allow you computer to recompile the module with the changes you just made.

[edit] Step 2: Adding to the Second Dictionary

Using the same structure, you can create the entry in your second language's dictionary that is the equivalent to your entry in the first dictionary.

The second language dictionary file name should be something such as apertium-en-es.en.dix.

Save your changes and recompile the module.

[edit] Final Step: The Bilingual Dictionary

Adding entries to the bilingual dictionary is considerably easier than adding to the other two dictionaries. An entry in this dictionary has this basic structure:

          <l>(lemmafromfirst)<s n="(partofspeech)"/></l>
          <r>(lemmafromsecond)<s n="(partofspeech)"/></r>

Simply add an entry and replace (lemmafromfirst) with the lemma you added to the first dictionary, (lemmafromsecond) with the lemma from the second, and (partofspeech) with the part of speech for each word.

Save this dictionary and recompile the module one last time.

Adding rules to a language pair can also be done, however, that will not be discussed in this guide. See Contributing to an existing pair for a more detailed and full explanation.

[edit] Errors

It is very possible that you may encounter an error in you changes.

To know how a word is analysed by the translator and find an error, type the following in the terminal (example from Contributing to an existing pair. Follow link for more help.):

$ echo "gener" | apertium-destxt | lt-proc ca-es.automorf.bin

You can replace ca-es with the translation direction you want to test.

The output in Apertium should be:


The string structure is: ^word/lemma<morphological analysis>$. The <sent> tag is the analysis of the full stop, as every sentence end is represented as a full stop by the system, whether or not explicitly indicated in the sentence.

The analysis of an unknown word is (ignoring the full stop information):


and the analysis of an ambiguous word:


Each lexical form (lemma plus morphological analysis) is presented as a possible analysis of the word casa.

If you are still stuck remember that you can always ask questions on IRC.

[edit] Show it to the World

Now that you have added to a language pair you have the option to commit your changes to SourceForge. Committing a change to a language pair is even easier than making the change.

Firstly, you need to register for a free SourceForge account. Then, contact an Apertium administrator here and request access to commit to SVN on SourceForge.

Once granted access, simply open the terminal, navigate to your language pair that was changed, and enter:

svn commit

Remember to include a log message detailing what was changed or added.

It is also possible that svn commit may be followed by -m "message”. That is sometimes easier than having an editor opened automatically.

You have now become a language pair developer for Apertium!

[edit] See also

Personal tools