Georgian Script

Georgian script is one of only 14 scripts in the world that are used by a single country's official language, making it inseparable from Georgian national identity. What makes Georgian truly remarkable among the world's writing systems is that it has three distinct script forms — Asomtavruli, Nuskhuri, and Mkhedruli — all encoded separately in Unicode. This guide explores the history, structure, and Unicode encoding of the Georgian writing system, along with practical advice for developers and designers.

A Three-Script Heritage

Georgian is unique in having three historical script forms that developed sequentially over 1,600 years. All three are still used today in specific contexts:

In 2016, UNESCO inscribed the three Georgian scripts on the Representative List of the Intangible Cultural Heritage of Humanity, recognizing their coexistence as a living cultural phenomenon.

Asomtavruli (Capital Letters)

Asomtavruli (from aso "letter" + mtavari "head/capital") is the oldest Georgian script. Its earliest known inscriptions date to the 5th century CE, found in churches in Bethlehem and Bolnisi (Georgia). The script has a monumental, rounded appearance similar to Greek uncials.

Asomtavruli was the primary script for all purposes until roughly the 9th century. Today it appears in church inscriptions, decorative contexts, and as capital letters in the Khutsuri ecclesiastical pair.

Nuskhuri (Minuscule Letters)

Nuskhuri (from nuskha "copy/inventory") developed as a faster, more cursive form for manuscript copying. It is smaller and more angular than Asomtavruli. Together, Asomtavruli (uppercase) and Nuskhuri (lowercase) form the Khutsuri ("priestly") bicameral pair, still used in Georgian Orthodox Church publications.

Mkhedruli (Military/Secular Script)

Mkhedruli (from mkhedari "warrior/horseman") became the dominant secular script by the 11th century and is the script used for modern Georgian. Uniquely, Mkhedruli is unicameral — it has no uppercase/lowercase distinction in traditional usage. All 38 letters have a single form.

However, in 2019, the Georgian government and Unicode Consortium introduced Mtavruli (Georgian capitals) to support an uppercase/lowercase distinction for Mkhedruli. This enables modern typographic conventions like title case.

The Georgian Alphabet

38 Modern Letters

Modern Georgian (Mkhedruli) uses 38 letters — 33 from the original set plus 5 additional letters. However, 5 of the original letters are now obsolete, leaving 33 active letters in contemporary use:

Georgian writing is almost perfectly phonemic — each letter represents exactly one sound, and each sound is represented by exactly one letter. There are no silent letters, no digraphs, and no ambiguous readings. This makes Georgian one of the most phonetically transparent writing systems in the world.

Notable Phonological Features

Georgian has several sounds that are rare or unique among the world's languages, each with its own letter:

The ejective consonants (produced with a glottalic airstream) are a hallmark of Kartvelian languages and required dedicated letters in Mashtots's original design — borrowed scripts like Greek or Latin had no way to represent them.

Georgian in Unicode

Main Georgian Block (U+10A0–U+10FF)

Georgian Supplement (U+2D00–U+2D2F)

This block contains Nuskhuri (Khutsuri lowercase) letters:

Georgian Extended (U+1C90–U+1CBF)

Added in Unicode 11.0 (2018), this block contains Mtavruli uppercase letters for Mkhedruli, completing the bicameral pair:

Case Mapping

Before Unicode 11.0, Mkhedruli was unicameral — toUpperCase() on Georgian text was a no-op. With Mtavruli, case mapping now works:

# Modern Python with Unicode 11.0+ support
text = "საქართველო"  # "Georgia" in Georgian
print(text.upper())  # ᲡᲐᲥᲐᲠᲗᲕᲔᲚᲝ (Mtavruli)
print(text.lower())  # საქართველო (Mkhedruli)
print(text.title())  # Საქართველო

// JavaScript (modern engines)
const text = "საქართველო";
console.log(text.toUpperCase()); // ᲡᲐᲥᲐᲠᲗᲕᲔᲚᲝ
console.log(text.toLowerCase()); // საქართველო

Note that older fonts and rendering engines may not support Mtavruli. Fallback rendering typically displays the lowercase (Mkhedruli) form.

Georgian Typography and Digital Challenges

No Spaces Between Words (Historical)

Old Georgian texts (Asomtavruli) were written in scriptio continua — without word spaces. Modern Georgian uses spaces between words, following the convention adopted during the medieval period. However, word boundaries in historical texts require specialized knowledge to identify.

Line Breaking

Georgian follows relatively simple line-breaking rules. Words can be broken at syllable boundaries, and Georgian syllable structure (typically CV or CVC) makes hyphenation straightforward. The Unicode Line Breaking Algorithm classifies Georgian letters as class AL (Alphabetic), so standard algorithms produce acceptable results.

Font Recommendations

Collation

Georgian alphabetical order has been stable since the script's creation. The Unicode DUCET handles Georgian sorting correctly. The five obsolete letters sort in their historical positions within the alphabet.

Detecting Georgian Script in Code

import unicodedata

def is_georgian(ch):
    name = unicodedata.name(ch, "")
    return "GEORGIAN" in name

def script_of(ch):
    cp = ord(ch)
    if 0x10A0 <= cp <= 0x10FF:
        return "Mkhedruli/Mtavruli"
    elif 0x2D00 <= cp <= 0x2D2F:
        return "Nuskhuri"
    elif 0x1C90 <= cp <= 0x1CBF:
        return "Mtavruli (Extended)"
    return "Not Georgian"

# Check text
for ch in "საქართველო":
    print(f"{ch}: U+{ord(ch):04X} — {script_of(ch)}")

// JavaScript: Georgian detection with Unicode property escapes
const georgianRegex = /\p{Script=Georgian}/u;
console.log(georgianRegex.test("თ")); // true
console.log(georgianRegex.test("A")); // false

Key Takeaways

• Georgian has three script forms — Asomtavruli (5th c.), Nuskhuri (9th c.), and Mkhedruli (10th c.) — all encoded separately in Unicode and recognized as UNESCO Intangible Cultural Heritage.
• Modern Georgian uses 33 active letters from the Mkhedruli script, which was historically unicameral (no case distinction) until Mtavruli capitals were added in Unicode 11.0 (2018).
• Georgian is perfectly phonemic — each letter maps to exactly one sound with no digraphs, silent letters, or ambiguity, making it one of the world's most transparent writing systems.
• Georgian occupies three Unicode blocks: Georgian (U+10A0–U+10FF), Georgian Supplement (U+2D00–U+2D2F), and Georgian Extended (U+1C90–U+1CBF).
• The addition of Mtavruli (Georgian Extended block) in 2018 enabled toUpperCase() and toLowerCase() to work on Georgian text — older systems may not support this.
• Georgian ejective consonants (ყ, წ, ჭ) are typologically rare sounds that required dedicated letters and could not be represented in borrowed scripts like Greek or Latin.