Introduction

Mortal Engine is a morphological engine, which allows you to create morphological models of languages, so that you can test the model, use it for spellchecking, transduce between different writing systems, etc. It is available both as a library and as a command line utility. All of the inputs to the program are in XML, and an effort has been made to make the format intuitive.

Getting Started

• Review some basic big-picture concepts
• How to use the command line utility
• A suggested workflow
• Take a look at the examples

You'll want to develop familiarity with test files and morphology files, the two types of files you'll be creating.

Here are some technical details if you have arcane concerns.

For Linguists

Mortal Engine has pretty basic linguistic assumptions, corresponding approximately to structuralist morphology. You're going to be defining morphemes and their allomorphs directly. (There is no provision for SPE-style rules, but you can create new allomorphs from a base allomorph procedurally.)

Mortal Engine supports concantenative morphology. Non-concatenative (or templatic) morphology would have to be handled separately. (There are some Afro-Asiatic languages that are close to my heart, so perhaps this will change one day.)

In terms of computational complexity, Mortal Engine allows you to define context-free languages.

For Developers

License

Mortal Engine is released under the GNU General Public License v3.0, the Lesser GNU General Public License v3.0, the Apache License, and the MIT License.

Building

Mortal Engine is written in C++. Its only dependency is Qt, which you can download for free, and use under the LGPL license.

I have developed and tested Mortal Engine on Windows, but I don't know of any reason it wouldn't work on other systems.

With Qt installed, it can be built with these commands:

qmake -config release
mingw32-make

For Linux-like systems, change mingw32-make to make.

Background & Name

My initial interest was in creating a spellchecking system for an agglutinative language. I assumed that the open-source community would have created a morphological engine for this purpose already. Indeed, I imagined myself having to choose between various open-source libraries. To my great surprise, no such libraries existed—or if they do, I am very bad at searching for them. Hunspell is great, but it limits you to two suffixes.

So initially the goal was to create a full morphological model that could be compiled into something Hunspell-compatible; it was going to be called Meta-Hunspell. As one would expect, however, I quickly thought of more interesting things to do with a morphological engine, and I've never come back to the Meta-Hunspell idea.

I was just about to rename the project from “Meta-Hunspell” to “Morphological Engine,” when the Bard provided a little inspiration for the current, more colorful name. Also, it can be a bit of a killer to use.

Right at the beginning of grad school, I took a course in language technology. The textbook for the course mentioned that one application of computational linguistics was to create a spellchecker. I remember very distinctly that I thought that was about the saddest and least interesting thing a linguist could use a computer to do! How time changes our perspective. In fact, this project has not been terribly interesting from a linguistic perspective, but it has been interesting from a programming perspective, and particularly as I've tried to think about the most straightforward format for the input files.