How Many Writing Systems Are in Active Use Today

“How many writing systems” sounds like it needs a linguist’s judgement. It does not: the Unicode Consortium maintains both a count of encoded scripts and a published classification of how each one is used, and those two datasets answer the question with dates attached.

The encoded count

Unicode 16.0, published by the Unicode Consortium in September 2024, encodes 168 scripts. The count is a property of the standard rather than an estimate: each script has an identifier in the Script character property defined by UAX #24, and the values are enumerated in the standard’s own data files. UAX #24 defines the Script property, and PropertyValueAliases.txt lists every value in the current release.

That 168 is not the answer to the question in the title, because it counts Linear B, Egyptian hieroglyphs, Old Persian cuneiform and Gothic alongside Latin and Han. Unicode encodes scripts for scholars as readily as for speakers, and it does not remove one when its last writer dies.

Unicode classifies them by usage, and publishes it

The distinction between living and historic is not left to the reader. CLDR — the Unicode Common Locale Data Repository — ships a data file, scriptMetadata.txt, with a Usage field carrying one of four values per script:

RECOMMENDED    In widespread modern use. The everyday scripts.
ASPIRATIONAL   Limited modern use, with an active community
               working toward broader adoption.
LIMITED_USE    In modern use by a smaller community, or for a
               restricted purpose.
EXCLUSION      Historic or specialised; not in general modern use.
               Linear B, Old Italic, Egyptian Hieroglyphs, Gothic.

This is the primary source for the question, and it is machine readable, which means the count can be recomputed rather than quoted. The same tiering appears in UTS #39, Unicode Security Mechanisms, which defines a set of Recommended Scripts for use in identifiers — the scripts considered safe and widespread enough that a domain name or username in them should be accepted without special scrutiny.

Roughly a hundred of the encoded scripts fall outside EXCLUSION, which is to say they have some contemporary use. That is the defensible answer to “in active use today”, and it is much larger than most people expect — largely because LIMITED_USE covers a long list of scripts with real but small communities: N’Ko, Vai, Tifinagh, Osage, Cherokee, Yi, Bamum and many more.

The thirty that carry nearly all daily text

The RECOMMENDED tier is short, and it is worth reading in full because its shortness is the point:

Arabic     Armenian   Bengali    Bopomofo   Cyrillic
Devanagari Ethiopic   Georgian   Greek      Gujarati
Gurmukhi   Han        Hangul     Hebrew     Hiragana
Kannada    Katakana   Khmer      Lao        Latin
Malayalam  Myanmar    Oriya      Sinhala    Tamil
Telugu     Thaana     Thai       Tibetan

Twenty-nine scripts, plus the two special-purpose values Common (punctuation, digits, symbols shared across scripts) and Inherited (combining marks that take the script of the character they attach to). Practically every piece of text a consumer product will ever receive is written in one of these, and a system that handles all twenty-nine correctly is handling the writing of the overwhelming majority of the world’s literate population.

The list is also a useful design checklist, because it is diverse in exactly the ways that break software: right-to-left scripts (Arabic, Hebrew, Thaana), scripts without word spacing (Thai, Lao, Khmer, Han), scripts with complex shaping and stacked consonants (Devanagari, Khmer, Myanmar), and a logographic script with tens of thousands of characters (Han). If your text stack survives all twenty-nine, it is unlikely to be surprised by the rest.

The list also spreads across every structural type a writing system can take, and the type matters more than the character count for how text behaves in software. Latin, Cyrillic, Greek, Armenian and Georgian are alphabets with separate vowel letters. Arabic and Hebrew are abjads, where short vowels are largely unwritten and must be inferred. Devanagari, Bengali, Tamil, Telugu, Khmer and Myanmar are abugidas, where a consonant carries an inherent vowel modified by marks. Hiragana and Katakana are syllabaries. Han is logographic, and Hangul is a featural alphabet composed into syllable blocks. Those differences drive how many characters a reader must learn and how many code points a word occupies — the ground covered in logographic versus alphabetic scripts and how many characters are needed to read a language.

Scripts are not languages

The counts above are of scripts, and the mapping to languages is many-to-many in both directions, which is the source of most confusion about this question.

• One script serves many languages. Latin writes English, Vietnamese, Turkish, Swahili, Indonesian and hundreds more — with different diacritics, different letter inventories and different orthographic rules. Arabic script writes Arabic, Persian, Urdu, Pashto and Uyghur, each adding letters the others lack.
• One language uses several scripts. Japanese uses Hiragana, Katakana, Han and Latin in ordinary sentences, which is why it appears four times in the tier above. Serbian is written in both Cyrillic and Latin. Punjabi is written in Gurmukhi in India and in the Arabic-derived Shahmukhi in Pakistan.
• Some languages change script by decision. Kazakh is undergoing a transition from Cyrillic to Latin; Azerbaijani has already made it. A dataset spanning the transition contains both and matches neither.

So “how many writing systems” and “how many languages” have unrelated answers — roughly 168 encoded scripts against Ethnologue’s count of just over 7,100 living languages in its 27th edition (2024). Most languages have no writing system in regular use at all.

Why the tiers matter in a pipeline

The three-way split maps onto three engineering decisions rather than being trivia.

For the RECOMMENDED set, correct handling is table stakes and should be tested: rendering, input, sorting, search, line breaking and normalisation. For LIMITED_USE and ASPIRATIONAL scripts, the realistic target is graceful handling — text must round-trip through your storage without corruption and render as the right characters even if you have no model that understands it. Losing bytes is a bug; not understanding them is a limitation.

For EXCLUSION scripts, the presence of one in user input is almost always a signal rather than content: a mojibake artefact, a homoglyph attack, or a copy-paste from a scholarly document. UTS #39 exists precisely because mixed-script identifiers are a security concern, and treating an unexpected historic script as suspicious rather than as text is the right default.