Gimeltra

Gimeltra is a Python 3.9+ tool for simple transliteration between 20+ writing systems, mostly of Semitic origin.

Gimeltra performs simplified abjad-only transliteration, and is primarily intended for translating simple texts from modern to ancient scripts. It uses a non-standard romanization scheme. Arabic, Greek or Hebrew letters outside the basic consonant set will not transliterate.

Installation

python3 -m pip install --upgrade git+https://github.com/twardoch/gimeltra

Usage

Command-line

$ gimeltrapy -h
usage: gimeltrapy [-h] [-t TEXT] [-i FILE] [-s SCRIPT] [-o SCRIPT] [--stats] [-v] [-V]

optional arguments:
  -h, --help            show this help message and exit
  -t TEXT, --text TEXT
  -i FILE, --input FILE
  -s SCRIPT, --script SCRIPT
                        Input script as ISO 15924 code
  -o SCRIPT, --to-script SCRIPT
                        Output script as ISO 15924 code
  --stats               List supported scripts
  -v, --verbose         -v show progress, -vv show debug
  -V, --version         show version and exit

Examples:

$ gimeltrapy -t "لرموز"
lrmwz
$ gimeltrapy -t "لرموز" -o Hebr
לרמוז
$ gimeltrapy -t "لرموز" -o Narb
𐪁𐪇𐪃𐪅𐪘
$ gimeltrapy -t "لرموز" -o Sogo
𐼌𐼘𐼍𐼇𐼈

Or from stdin / via piping:

$ echo لرموز | gimeltrapy -o Grek
λρμυζ

Python

from gimeltra.gimeltra import Transliterator
tr = Transliterator()
print(tr.tr("لرموز", sc='Arab', to_sc='Hebr')

Less efficient:

from gimeltra import tr
print(tr("لرموز")

Supported scripts / tech background

Gimeltra supports 24 scripts:

• Latn (Latin)
• Arab (Arabic)
• Ethi (Ethiopic)
• Armi (Imperial Aramaic)
• Brah (Brahmi)
• Chrs (Chorasmian)
• Egyp (Egyptian hieroglyphs)
• Elym (Elymaic)
• Grek (Greek)
• Hatr (Hatran)
• Hebr (Hebrew)
• Mani (Manichaean)
• Narb (Old North Arabian)
• Nbat (Nabataean)
• Palm (Palmyrene)
• Phli (Inscriptional Pahlavi)
• Phlp (Psalter Pahlavi)
• Phnx (Phoenician)
• Prti (Inscriptional Parthian)
• Samr (Samaritan)
• Sarb (Old South Arabian)
• Sogd (Sogdian)
• Sogo (Old Sogdian)
• Syrc (Syriac)
• Ugar (Ugaritic)

Conversion steps

The conversion uses the .json file derived from the .tsv table. The selection of the conversion rules is based on ISO 15924 script codes. The code mimics a simple OpenType glyph processing model, but with Unicode characters:

1. Preprocessing with a ccmp table

1. Split ligatures into single letters, also
2. Decompose into Unicode NFD and drop the marks.

2. Character replacement in the csub table

1. Try direct source-target script mapping.
2. If that does not exist, convert into Latn.
3. Try from Latn to target script
4. If that’s not available, fallback from Latn to <Latn and try to convert to the target script.

3. Postprocessing

1. Replace letters by their contextual final forms using the fina table.
2. Replace series of letters by Unicode ligatures using the liga table.

Characters that aren’t covered by the mappings are passed through. This may change in future (or there will be an option to keep non-letters but drop letters and marks).

Data table

The below table exists in .numbers and .tsv formats. The .numbers file is the source, which I export to .tsv, and then I update the .json, which the transliterator uses.

There are some simple conventions in the table:

• | separates alternate versions of a character
• < prefix means that we should only convert from this character but not to it
• > prefix means that we should only convert to this character but not from it
• ~ prefix indicates that this is a final form
• % separates the from and to strings of a character ligature

(Keep on mind that if the characters in the table are RTL, the browser renders the entire cell as RTL and changes > to < and vice versa 😀 )

The Latn column serves as the intermediary (all conversions are done from the source script through Latn to the target script). The column contains some characters that have equivalents only in some scripts. This allows less lossy coversion between, say, Hebrew and Arabic or Ethiopic and Old South Arabian.

The <Latn column provides fallback Latin characters if the target script does not have an equivalent to the Latn character. This gives lossier but still plausible conversion.

License

Copyright © 2021 Adam Twardoch, MIT license

Other projects of interest

• Wiktra — Python transliterator for 100+ scripts and 500+ languages, mostly into Latin but in some cases across other scripts. Uses the Wiktionary transliteration modules written in Lua. Needs Lua runtime.
• Aksharamukha - Python (plus JS and web) transliterator within the Indic cultural sphere, for 94 scripts and 8 romanization methods. Does conversion between scripts.