Introduction to Indic Scripts

Indic scripts are in daily use across education, publishing, signage, government identity documents, and software interfaces for hundreds of millions of readers. When a font handles them poorly, the failure isn't cosmetic — misplaced marks and broken conjuncts make text genuinely harder to read, and readers notice.

Most scripts used in India descend from Brahmi, a script attested from the 3rd century BCE. Descent doesn't mean the letterforms look alike — Tamil and Devanagari share almost no visible resemblance — but it does mean they inherited a common structural logic, and a common internal layout inside Unicode.

That shared layout is not an accident. The Unicode blocks for Devanagari, Bengali, Gurmukhi, Gujarati, Odia, Tamil, Telugu, Kannada, and Malayalam were built to mirror the 1988 ISCII standard: the "independent vowel A," "consonant KA," "vowel sign AA," and so on sit at the same relative offset in every one of those blocks. Once you know the pattern in one script's block, you can find your way around the others.

There are important exceptions. Urdu is written in the Perso-Arabic tradition (right-to-left, no inherent vowel), not Brahmic at all. Ol Chiki — designed in 1925 by Raghunath Murmu for the Santali language and used today across Jharkhand, West Bengal, and Odisha — is a deliberately independent invention, not a Brahmi descendant. Meitei Mayek, used for Meitei in Manipur, is a genuine edge case: scholars are split on whether it derives from Brahmic sources or developed on its own, though structurally it behaves as an abugida either way. This series treats each script on its own terms rather than forcing a single family tree onto all of them.

Linguist Peter T. Daniels coined the term abugida in 1990 — borrowed from the first four letters of the Ethiopic Ge'ez script — for writing systems where each base character denotes a consonant plus a default ("inherent") vowel, and other vowels are marked with diacritics rather than full letters. Most Indic scripts fit this pattern: a consonant carries its inherent vowel until a dependent vowel sign (mātrā) attaches before, after, above, or below it, and additional marks modify the sound or spelling further.

For designers, this is the key shift from Latin: you aren't drawing isolated, self-sufficient letters — you're building a combining system that a shaping engine assembles into syllable clusters at render time.

This series starts with the nine scripts that share the ISCII-derived Unicode layout described above (Devanagari, Bengali, Gujarati, Gurmukhi, Odia, Tamil, Telugu, Kannada, Malayalam), then covers scripts outside that family — Meitei Mayek in Manipur, Ol Chiki for Santali — and finally optional historic scripts.

Three ideas get conflated constantly, and keeping them separate will save you real debugging time: Unicode (the encoded characters a string contains), glyphs (the shapes you draw in the font), and orthography (the spelling and usage conventions of a given language). One Unicode character can map to several glyphs depending on context; one glyph can serve several characters; and orthography decides which combinations actually occur in real text.

1. 1Read this article once for the shared concepts: syllables, marks, reordering, shaping engines.
2. 2Pick your target script article (Devanagari, Gurmukhi, and more as they're published) — each follows the same structure.
3. 3Use the Designer Starter Kit below to plan coverage, then use each article's test string pack to validate.
4. 4Iterate: expand test strings → fix clusters → retest across apps and platforms → repeat.

The script-specific articles include a tailored test pack. This universal version covers the coverage plan, the must-have OpenType features, and what to test before calling a script "done."

Continue with the script articles below. Each follows the same structure — Fast Facts, shaping model, glyph production, and a script-specific test string pack — so once you've read one, you'll know your way around the rest.