Hangul Jamo

What is Hangul Jamo?

Hangul is the alphabetic writing system of the Korean language, invented in 1443 by King Sejong the Great. Unlike logographic Chinese characters, Hangul is fully phonetic: each syllable is composed of individual phonetic units called jamo. A jamo is a single consonant or vowel element — similar in concept to a Latin letter — but Hangul syllables are written as compact two-dimensional blocks rather than as linear sequences.

Unicode encodes Hangul across three distinct blocks, each serving a different purpose.

The Three Unicode Hangul Blocks

1. Hangul Jamo (U+1100–U+11FF)

This block contains the individual jamo components in their "combining" form: 19 initial consonants (choseong), 21 vowels (jungseong), and 28 final consonants (jongseong, including a null final). These code points are the raw building blocks. They are not normally displayed in isolation; their purpose is algorithmic syllable composition. A Unicode-conformant renderer receiving a choseong, jungseong, and optional jongseong in sequence will compose and render them as a single syllable block.

2. Hangul Compatibility Jamo (U+3130–U+318F)

This block provides jamo in their standalone "compatibility" form, suitable for display as individual characters — for example, in alphabetical lists, keyboard labels, or dictionary entries. These are distinct from the composing jamo in U+1100. They cannot be algorithmically combined into syllable blocks and are intended for display contexts only. Mixing them with composing jamo can cause unexpected rendering.

3. Hangul Syllables (U+AC00–U+D7AF)

This is the largest of the three blocks, containing all 11,172 precomposed modern Hangul syllable blocks. Every legal combination of initial consonant, vowel, and optional final consonant has a dedicated code point. The block is algorithmically structured: given a syllable's code point S, you can compute its components exactly.

Algorithmic Composition and Decomposition

Unicode defines a precise algorithm for mapping between precomposed syllables (U+AC00 range) and their jamo components (U+1100 range):

# Hangul syllable composition
HANGUL_BASE = 0xAC00
CHOSEONG_COUNT = 19   # initial consonants
JUNGSEONG_COUNT = 21  # vowels
JONGSEONG_COUNT = 28  # final consonants (including null)

def compose_hangul(lead: int, vowel: int, trail: int = 0) -> str:
    # Compose a Hangul syllable from jamo indices (0-based).
    code_point = (
        HANGUL_BASE
        + (lead * JUNGSEONG_COUNT + vowel) * JONGSEONG_COUNT
        + trail
    )
    return chr(code_point)

def decompose_hangul(syllable: str) -> tuple[int, int, int]:
    # Decompose a Hangul syllable to (lead, vowel, trail) indices.
    index = ord(syllable) - HANGUL_BASE
    trail = index % JONGSEONG_COUNT
    vowel = (index // JONGSEONG_COUNT) % JUNGSEONG_COUNT
    lead = index // (JUNGSEONG_COUNT * JONGSEONG_COUNT)
    return lead, vowel, trail

This algorithm underpins NFD/NFC normalization for Korean text and enables efficient Korean text processing without exhaustive lookup tables.

Quick Facts