biblical-transliteration

Biblical Hebrew and Koine Greek transliteration in three schemes — academic (SBL), simple ASCII, and phonetic. Pure Python, no dependencies.

from biblical_transliteration import (
    HebrewTransliterator, HebrewScheme, HebrewOptions,
    GreekTransliterator, GreekScheme, GreekOptions,
)

heb = HebrewTransliterator(HebrewOptions(scheme=HebrewScheme.SBL))
heb.transliterate("בְּרֵאשִׁית")
# 'bǝrēʾšîṯ'

grk = GreekTransliterator(GreekOptions(scheme=GreekScheme.SBL))
grk.transliterate("Ἐν ἀρχῇ ἦν ὁ λόγος")
# 'En archē ēn ho logos'

Install

pip install biblical-transliteration

Requires Python 3.10+. Zero runtime dependencies.

Schemes

Each transliterator supports three output styles via TransliterationScheme:

What this handles

Hebrew (~1,000 lines of rules):

• Full nikkud (vowel point) coverage, including hataf vowels
• BeGaD KeFaT spirantization with proper SBL macron-under marks (ḇ ḡ ḏ ḵ p̄ ṯ)
• Vocal vs silent shewa distinction
• Qamats qatan (o) vs qamats gadol (a) detection
• Dagesh forte vs lene
• Shin/sin dot disambiguation
• Final letter forms (ך ם ן ף ץ)
• Cantillation marks (te'amim) drive stress placement in the PHONETIC scheme, backed by an OSHB-derived stress lexicon when no te'am is present
• The Tetragrammaton is never rendered as the qere-vowel hybrid (yǝhwāh, the "Jehovah" error) — bare consonants by default, or a substitute of your choice (Adonai, Hashem, …)
• Maqaf, meteg, sof pasuq

Koine Greek (~800 lines of rules):

• Diphthongs in canonical order (αι, ει, οι, υι, αυ, ευ, ηυ, ου), uppercase and lowercase
• Breathing marks read off either vowel of a diphthong
• Iota subscript (macron-only ā ē ō in SBL so it can't collide with the αι diphthong; i appended in Simple; silent in Phonetic)
• Final sigma (ς)
• Koine-correct phonemes in SBL/Simple — β = b (not modern v), φ = ph (not modern f), υ = u in diphthongs; the PHONETIC scheme is Erasmian, spelled for English readers (χ = kh, φ = f)
• Eta/omega macron distinction in SBL
• Accents and breathing marks normalized

Why three schemes?

Open-source transliterators tend to pick one and stick with it, which forces you to choose between accuracy (SBL is hard to read for non-specialists) and readability (loose ASCII loses important phonemic distinctions). Three schemes lets you produce SBL-compliant output for academic work, ASCII for UI labels, and pronunciation cues for learners — from the same source text.

Why a separate Hebrew + Greek package?

Most existing PyPI packages are language-specific and use inconsistent APIs. This package presents a single mental model — Transliterator(Options(scheme=...)) — that works identically across both languages, so consumer code that transliterates whatever script it encounters stays clean.

Comparison with related packages

This package fills a specific gap in the Python biblical-NLP ecosystem. Other tools cover adjacent problems well; here's what they do differently so you can pick the right one:

If your workflow needs SBL Handbook of Style-compliant academic transliteration with proper diacritics for both Hebrew (bǝrēʾšîṯ, šālôm) and Greek (logos, Iēsous), this package is the only option in the Python ecosystem at the time of writing.

Limitations

• Hebrew text must be Unicode (with or without nikkud). Beta-coded Hebrew (CCAT/Michigan-Claremont format) is not handled by this library — use a beta→Unicode converter first.
• Greek text is assumed Koine. Modern Greek and Classical Greek work with the SBL and SIMPLE schemes, but PHONETIC is calibrated for Koine and may not match what you expect for Classical or Modern texts.
• Qamats qatan detection is rule-based, not perfect. Texts with explicit U+05C7 marking (modern WLC) work reliably; older texts using the ambiguous U+05B8 may occasionally guess wrong. Meteg is not consulted, so a meteg-disambiguated qamats gadol (e.g. חָֽכְמָה "she was wise" vs חָכְמָה "wisdom") is still read as qatan.
• Unpointed Hebrew gets consonant-skeleton output. BeGaD KeFaT letters default to their stop values (b g d k p t) since there is no dagesh information; final kaf/pe keep the spirant (post-vocalic position). Nikkud detection is per transliterate() call, not per word: an unpointed word mixed into pointed text uses the pointed defaults.

Examples

from biblical_transliteration import HebrewTransliterator, HebrewOptions, HebrewScheme

# All three schemes for the same word
word = "שָׁלוֹם"
for scheme in HebrewScheme:
    t = HebrewTransliterator(HebrewOptions(scheme=scheme))
    print(f"{scheme.value:10} {t.transliterate(word)}")
# sbl        šālôm
# simple     shalom
# phonetic   shah-LOHM

from biblical_transliteration import GreekTransliterator, GreekOptions, GreekScheme

# John 1:1
text = "Ἐν ἀρχῇ ἦν ὁ λόγος, καὶ ὁ λόγος ἦν πρὸς τὸν θεόν, καὶ θεὸς ἦν ὁ λόγος."
for scheme in GreekScheme:
    t = GreekTransliterator(GreekOptions(scheme=scheme))
    print(f"{scheme.value:10} {t.transliterate(text)}")

Development

git clone https://github.com/curran-gehring/biblical-transliteration.git
cd biblical-transliteration
python -m venv .venv
source .venv/bin/activate     # Windows: .venv\Scripts\activate
pip install -e ".[dev]"
pytest

License

MIT — see LICENSE.

Acknowledgments

Transliteration rules were developed against the Society of Biblical Literature Handbook of Style (2nd ed., 2014) and validated against verses from the CATSS parallel corpus.

The phonetic stress lexicon (biblical_transliteration/data/stress_lexicon.json) is derived from the cantillation accents of the Westminster Leningrad Codex as encoded by the Open Scriptures Hebrew Bible (morphhb), used under the Creative Commons Attribution 4.0 International License. The bundled file contains only derived stress positions; regenerate it with tools/build_stress_lexicon.py.