Unicode Planes and the BMP

Unicode's total code point space — U+0000 through U+10FFFF — is enormous: 1,114,112 possible values. To keep this vast range organized, the standard divides it into 17 contiguous regions called planes, each containing exactly 65,536 (2^16) code points. Most of the characters you encounter every day live in Plane 0, the Basic Multilingual Plane (BMP), but the supplementary planes hold everything from emoji and ancient scripts to rare CJK ideographs and special-purpose control characters. This guide walks through all 17 planes, explains what they contain, and shows how the plane structure affects encoding and programming.

Overview of All 17 Planes

Planes 4 through 13 are entirely unassigned — ten empty planes held in reserve for future growth. With approximately 154,998 characters assigned (as of Unicode 16.0) out of 1,114,112 total slots, there is no shortage of room.

Plane 0: Basic Multilingual Plane (BMP)

The BMP is the most densely populated and most important plane. It covers U+0000 through U+FFFF and holds the characters needed for virtually every modern writing system in active use.

What's in the BMP

The BMP alone covers Latin, Greek, Cyrillic, Arabic, Hebrew, Devanagari, Thai, Chinese, Japanese, Korean, and dozens of other scripts — enough for the vast majority of modern text.

The Surrogate Gap

The range U+D800 through U+DFFF (2,048 code points) is permanently reserved for UTF-16 surrogates. These are not characters and will never be assigned. They exist solely as a mechanism for UTF-16 to encode code points above U+FFFF using pairs of 16-bit code units.

This means the BMP has a theoretical capacity of 65,536 code points but an effective capacity of 63,488 (65,536 minus 2,048 surrogates).

Plane 1: Supplementary Multilingual Plane (SMP)

The SMP (U+10000–U+1FFFF) is the second most important plane and the one that has grown fastest in recent Unicode versions, largely thanks to emoji.

Key contents

The SMP is where you find emoji, historic and archaic scripts (Cuneiform, Egyptian Hieroglyphs, Old Italic, Linear B), musical notation, and mathematical letter variants (bold, italic, script, fraktur, double-struck alphabets used in formal mathematics).

Plane 2: Supplementary Ideographic Plane (SIP)

The SIP (U+20000–U+2FFFF) exists to extend the CJK Unified Ideographs beyond what the BMP can hold. As of Unicode 16.0, it contains over 60,000 characters across several extension blocks:

These are rare or historical CJK characters — personal names, place names, variant forms, and characters from classical texts. Most everyday Chinese, Japanese, or Korean text uses only the BMP characters, but scholarly work and government databases frequently need SIP characters.

Plane 3: Tertiary Ideographic Plane (TIP)

The TIP (U+30000–U+3FFFF) was introduced in Unicode 13.0 (2020) for even rarer CJK ideographs:

These extensions accommodate characters needed for historical texts, regional variants, and comprehensive dictionaries.

Planes 4–13: Unassigned (Reserved for Future)

Ten full planes — 655,360 code points — are completely empty. They serve as a buffer ensuring that Unicode can accommodate future needs without running out of space. No characters are currently planned for these planes, and any future allocation would go through the standard Unicode proposal and review process.

Plane 14: Supplementary Special-purpose Plane (SSP)

The SSP (U+E0000–U+EFFFF) contains two specialized blocks:

The Tags block was originally designed to embed language information in plain text (e.g., tagging a run of text as English or Japanese). This use was deprecated because language tagging is better handled by markup (HTML lang attribute) or text protocols. However, these tag characters found new life in emoji flag sequences — regional indicator sequences use them to form subdivision flags (like the flag of Scotland 🏴󠁧󠁢󠁳󠁣󠁴󠁿 or Texas 🏴󠁵󠁳󠁴󠁸󠁿).

The Variation Selectors Supplement provides standardized variation sequences for CJK ideographs, allowing fonts to select specific glyph variants for characters that have multiple accepted visual forms.

Planes 15–16: Private Use Area Planes

These two planes are entirely designated as Private Use Area space, extending the 6,400 BMP PUA code points with an additional 131,068 slots. Organizations, communities, and software vendors can assign any meaning to these code points for internal use — but the assignments are not interoperable without prior agreement between parties.

The ConScript Unicode Registry (CSUR) maintains informal assignments in these planes for constructed scripts (Klingon, Tengwar, Cirth) and other community projects.

How Planes Affect Encoding

The plane structure has direct consequences for the three Unicode encoding forms:

UTF-8

For BMP characters, UTF-8 uses one byte for ASCII (U+0000–U+007F), two bytes for U+0080–U+07FF, and three bytes for U+0800–U+FFFF. Characters outside the BMP always require four bytes.

UTF-16

UTF-16 was designed around the BMP. When Unicode expanded beyond 65,536 code points, the surrogate mechanism was added to handle planes 1–16. Each non-BMP character is encoded as a pair of 16-bit surrogates.

UTF-32

Every code point takes exactly 4 bytes regardless of plane. This makes random access trivial but wastes space for text that is primarily BMP characters.

Programming Implications

Detecting the Plane

You can determine a code point's plane by examining its numerical value:

def get_plane(code_point: int) -> int:
    # Return the Unicode plane number (0-16) for a code point.
    return code_point >> 16

# Examples
print(get_plane(0x0041))    # 0 — BMP
print(get_plane(0x1F600))   # 1 — SMP
print(get_plane(0x20000))   # 2 — SIP
print(get_plane(0xE0001))   # 14 — SSP
print(get_plane(0x100000))  # 16 — SPUA-B

JavaScript String Length Pitfall

Because JavaScript strings use UTF-16 internally, characters outside the BMP (planes 1–16) appear as two code units:

// BMP character — 1 code unit
"A".length         // 1
"中".length        // 1

// SMP character — 2 code units (surrogate pair)
"😀".length        // 2
"𝐀".length         // 2 (U+1D400, Mathematical Bold Capital A)

// Correct code-point-aware counting
[..."😀"].length   // 1

This is one of the most common bugs in JavaScript string processing. Any code that uses .length, .charAt(), .charCodeAt(), or .slice() on strings containing non-BMP characters can produce incorrect results. Use the spread operator, for...of, or codePointAt() instead.

Database Storage

If your database column uses UTF-16 (like SQL Server's NVARCHAR), non-BMP characters consume 4 bytes instead of 2. MySQL's utf8 charset only supports the BMP — you need utf8mb4 to store characters from planes 1–16 (including all emoji).

-- MySQL: use utf8mb4 for full Unicode support
CREATE TABLE messages (
    id INT PRIMARY KEY,
    content TEXT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci
);

Key Takeaways

• Unicode divides its 1,114,112 code points into 17 planes of 65,536 code points each.
• Plane 0 (BMP) holds the vast majority of commonly used characters across all modern writing systems.
• Plane 1 (SMP) contains emoji, historic scripts, and mathematical letter variants.
• Planes 2–3 (SIP, TIP) hold rare and historical CJK ideographs.
• Plane 14 (SSP) provides variation selectors and (deprecated) language tags.
• Planes 15–16 are Private Use Areas for application-specific characters.
• Planes 4–13 are entirely unassigned, reserved for future growth.
• The plane boundary matters for encoding: non-BMP characters require 4 bytes in UTF-8, surrogate pairs in UTF-16, and can cause .length bugs in JavaScript.
• Use MySQL utf8mb4 (not utf8) to support all Unicode planes.