Tools, references, and engines for building Hangeul-aware software.
Patterns, libraries, and recipes for Hangeul text processing.
Hangeul syllables (가-힣) decompose into Lead, Vowel, and Tail jamo. The arithmetic is precise: each syllable is built from indexed positions.
function decompose(syllable) {
const code = syllable.charCodeAt(0) - 0xAC00;
if (code < 0 || code > 11171) return null;
const lead = Math.floor(code / 588);
const vowel = Math.floor((code % 588) / 28);
const tail = code % 28;
return { lead, vowel, tail };
}Two-set, three-set, and project-specific keyboards all coexist. The composition state machine accepts jamo and emits syllables when the cluster is complete.
Always canonicalize with NFC for storage; NFD for analysis.
Modern fonts compose syllables via OpenType GSUB lookups. The lead, vowel, and tail are positioned in nine block patterns depending on vowel verticality and tail presence.
Revised Romanization (RR) is the default for code; McCune-Reischauer for legacy datasets.
Modern Hangeul block contains every legal syllable as a single codepoint. The space is dense and total: 19 leads x 21 vowels x 28 tails (including null tail) = 11,172.
Pre-modern jamo such as ᄔ require Conjoining Jamo and font shaping.
Korean users search by lead-jamo prefixes. Implementations strip vowels and tails, indexing only the lead positions for autocomplete.
const initials = name
.split('')
.map(toLead)
.join('');Drag, scroll, or move toward the edges. Each glyph rests on a marble stele.
Hangeul was promulgated in 1446 as 훈민정음 -- the correct sounds for instructing the people. As a writing system, it is featural: the shape of each consonant gestures toward the position of the tongue, and each vowel arises from the elementary marks of heaven (ㆍ), earth (ㅡ), and human (ㅣ).
For the engineer, this poetic origin has practical consequences. Because syllables decompose deterministically, every operation -- collation, search, transliteration, breaking, shaping -- can be expressed as small functions over the jamo space. There are no irregular forms to memorize; the rules are the data.
The Unicode Standard encodes the modern syllable block at U+AC00 through U+D7A3. Software libraries that handle Korean text should canonicalize input with NFC before comparison, decompose to jamo with NFD when reasoning about pronunciation, and never assume one Unicode codepoint equals one user-perceived character.
For input methods, the composition state machine maintains a partial syllable: an accumulating sequence of one to three jamo that may grow, recompose, or commit on every keystroke. Errors here are visible to the user and intolerable; correctness is a non-negotiable contract.
Rendering, by contrast, is mostly the font's responsibility. Modern OpenType-shaped Korean fonts handle composition and arrangement via GSUB lookups; the engine's job is merely to deliver the codepoints in the correct order and let the shaper do its work.
This site is a working notebook: snippets, references, and small libraries gathered for those building Hangeul-aware software. It is meant to be read slowly, like watching light shift on the floor of a tide pool.