Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Where Unicode Is Still Evolving

The Unicode Standard is not finished. It gets a new major version roughly every year, and each version adds code points, adjusts properties, and occasionally extends the algorithm specs. This chapter covers what changes between versions, how the Consortium decides, and some of the weirder corners where the standard is still being written.

The release cadence

Unicode 1.0 appeared in 1991. The major-version history:

  • 1.0 (1991), 1.1 (1993): early small set.
  • 2.0 (1996): the expansion beyond 16 bits — surrogate pairs introduced.
  • 3.0 – 4.1 (1999–2005): steady growth, first Plane 1 assignments.
  • 5.0 – 5.2: more scripts, Avestan, Bamum, Egyptian Hieroglyphs.
  • 6.0 (2010): the first official emoji. Cancellation of the "maybe emoji don't belong in Unicode" debate.
  • 7.0 onward: roughly annual releases, averaging 5,000–15,000 new code points per release.
  • 16.0 (2024): current version as of this writing. ~155,000 assigned code points.

Every release has its own UAX revisions (Unicode Annexes) — UAX #14 (line breaking), UAX #29 (text segmentation), UAX #31 (identifiers), and others get updated together.

What gets added

Three categories of code point additions dominate:

Historical scripts

New writing systems — usually historical or minority scripts — are added every version. Recent examples: Garay (Unicode 16.0), Gurung Khema, Kirat Rai, Ol Onal, Sunuwar. These additions are driven by scholars and native speakers petitioning for encoding. Once added, they give digital existence to scripts that might otherwise be untypeable and unsearchable.

CJK ideograph extensions

Chinese characters are added in batches called CJK Unified Ideographs Extensions. The current extensions are A through I, with further extensions proposed. Extension G (2020, Unicode 13.0) added ~4,900 characters; Extension H (2022) added ~4,200 more. The need is real: classical Chinese texts, historical personal names, and regional variants all turn up characters that the previous Unicode version didn't cover.

The ideograph extensions tend to live in high supplementary planes — Plane 2 (U+20000–U+2FFFF) and Plane 3 (U+30000–U+3FFFF) — where there's still plenty of space.

Emoji

Each year's Emoji Update adds a set of new emoji. They come from the Unicode Emoji Subcommittee process: anyone can submit a proposal, which is evaluated for compatibility, distinctiveness, and expected usage. Emoji are sometimes added as bare code points (new picture characters) and sometimes as new ZWJ sequences using existing components.

Every year's emoji release also adjusts a handful of existing emoji — adding skin-tone support, adding gender variants, clarifying rendering expectations.

Tag characters

A strange corner of Unicode: tag characters (U+E0000 – U+E007F, 128 code points in Plane 14).

These were originally defined for language tagging — embedding language markers in plain text, like inline HTML lang attributes. The feature was deprecated in 2001; the code points remained but were almost unused.

Then, in 2017, the emoji subcommittee revived them for a different purpose: subnational flag encoding. The flags of Scotland, Wales, and England are encoded as:

🏴 (U+1F3F4 BLACK FLAG)
+ tag sequence encoding the ISO 3166-2 subdivision code
+ U+E007F CANCEL TAG

The flag of Scotland:

U+1F3F4 BLACK FLAG
U+E0067 TAG LATIN SMALL LETTER G
U+E0062 TAG LATIN SMALL LETTER B
U+E0073 TAG LATIN SMALL LETTER S
U+E0063 TAG LATIN SMALL LETTER C
U+E0074 TAG LATIN SMALL LETTER T
U+E007F CANCEL TAG

"gb-sct" — GB subdivision SCT — enclosed in tag characters and terminated by CANCEL TAG. That's seven code points, each of them 4 bytes in UTF-8, for a total of 28 bytes to render a single flag grapheme cluster. The encoding is wildly space-inefficient, but it is compositional: any subdivision code can be encoded, and fonts only need to ship glyphs for the subdivisions they support.

Tag characters are Default_Ignorable_Code_Point — they should not be visible to a user when they appear in text (they are expected to be consumed by the rendering process). If your filter doesn't strip them, though, they can be a vector for invisible-content attacks, similar to zero-width characters. In 2024, several phishing kits were observed exploiting tag characters in URLs to evade visual inspection.

Script property additions

When a new script is encoded, every code point in it gets a Script property. Existing properties (like the Script-specific collation tailoring in CLDR) may need updating.

The Unicode Consortium is currently working on several scripts in various stages:

  • Proto-Sinaitic, one of the earliest known alphabetic scripts.
  • Linear Elamite, recently deciphered.
  • Indus Valley Script, still undeciphered but with enough attested characters for proposal.
  • Various constructed scripts (Tolkien's Tengwar is encoded in the Supplementary Multilingual Plane).

For languages that are alive, encoding can transform digital life: speakers can finally type in their native script, use it in search engines, and preserve their literature digitally.

Backward compatibility

One of the strongest guarantees of the Unicode Standard is stability. Once a code point is assigned:

  • Its code point number never changes.
  • Its name never changes (rarely, a typo is corrected via an alias).
  • Its General Category, Canonical Combining Class, and Decomposition Mapping are essentially frozen.

This means that UTF-8 files you wrote in 2005 decode identically in 2026. A string normalized to NFC in 2010 is still normalized in NFC terms as of the current version. Emoji from Unicode 6.0 are still valid.

The price of this guarantee is that mistakes don't get corrected. U+FB01 (the fi ligature) would probably not be added today, but it exists and is locked in. U+200B (zero-width space) continues to be a security hazard nobody can remove.

The Consortium process

Unicode is decided by the Unicode Consortium, a nonprofit whose full members include Apple, Google, Microsoft, Meta, Netflix, and several national governments. Proposals for new characters, new properties, or standard changes go through:

  1. Submission to the relevant subcommittee (UTC, Emoji Subcommittee, CJK Ideograph Working Group).
  2. Review and revision, often across multiple quarterly meetings.
  3. Adoption into a specific Unicode version.
  4. Publication with that version's release.

The process is open: anyone can submit a proposal (unicode.org/pending/proposals.html), and technical discussion is largely public. If you care strongly about some corner of Unicode, you can participate.

What's not going to change

Some things are architecturally fixed:

  • The code point range: U+0000–U+10FFFF. (Determined by UTF-16's capacity.)
  • The encoding triad: UTF-8, UTF-16, UTF-32.
  • The surrogate pair mechanism in UTF-16 (because removing it would break every UCS-2/UTF-16 system).
  • The reserved range U+D800–U+DFFF remaining unassigned (used by surrogates).

There is no credible path toward a Unicode beyond U+10FFFF. Even if all 1.1 million code points were fully assigned, there are currently ~955,000 unused ones, with the vast majority of future writing-system additions comfortably fitting in the remaining space.

Keeping up with new versions

Practically: you probably don't need to. If you're using a modern language whose standard library tracks Unicode, you get upgrades for free when you upgrade the runtime. Python 3.15 ships with Unicode 16.0 data; Node.js tracks the latest ICU.

If you care about emoji specifically, a library like emoji-regex publishes updates within weeks of each Unicode release.

If you care about less-common properties (new scripts, new CJK extensions), you may need to compile against the latest ICU. ICU's release cadence lags Unicode by a few months.

The one place you do need to keep up: your font stack. New emoji added in Unicode 16.0 look like tofu until Apple, Google, Microsoft, Twitter, and the free font projects (Noto Emoji, Twemoji) ship their glyphs. This typically happens 6–18 months after the Unicode release, per vendor.

The tension

Unicode's evolution has a built-in tension: it aims to be universal (every writing system, every symbol people want) while also being stable (no breaking changes, ever). As the standard grows, maintaining stability requires compromises — keeping ligature code points, keeping cruft, keeping security-hostile characters.

Every programmer who works with Unicode long enough starts to see it not as a character set but as a negotiated settlement — an international treaty with an API. That's exactly what it is. Remarkably, it works.

Next, we point you at the best further reading, tooling, and references for continuing the journey.