Unicode

What Is Unicode?

Unicode is the reason one text field can hold English, Hindi, Arabic and emoji at the same time. It gives every character a unique number, called a code point, so different apps and devices agree on what each character is. The Unicode Consortium has maintained the standard since the early 1990s.

Unicode lets software refer to encoded characters using shared identities rather than incompatible local numbering schemes. It covers many writing systems and symbols, but not every proposed or historical character is already encoded.

It is a text standard, not a font collection. A code point identifies a numbered position; a font supplies glyphs. The same encoded text can have different shapes on different devices.

Code points, bytes and what you actually see

Code-point notation uses U+ followed by hexadecimal digits. Latin capital letter A has code point U+0041. UTF-8 encodes that scalar value as the single hexadecimal byte 41.

One displayed character can contain several code points. A lowercase e followed by a combining acute accent is a two-code-point sequence that forms one default extended grapheme cluster. UTF-16 unit counts and UTF-8 byte counts answer different questions.

Normalization can bring canonically equivalent accent sequences into a consistent form. It does not guarantee recovery of damaged files or removal of all invisible characters and lookalikes.

Unicode is not the same as UTF-8. Unicode defines encoded character identities and properties; UTF-8 represents Unicode scalar values using one to four bytes each, so a multi-value sequence can take more bytes.

The encoded repertoire changes with published versions, so a version-specific chart or release report is the right source for a character count. The code-point address space also includes unassigned positions and surrogate code points, so its size is not an encoded-character count.

Code points range from U+0000 to U+10FFFF, and not all positions are assigned characters. Surrogate positions U+D800 through U+DFFF are excluded from Unicode scalar values. The Basic Multilingual Plane is the range U+0000 through U+FFFF; supplementary planes contain other characters, including many emoji and mathematical letters.

A valid scalar value uses one to four UTF-8 bytes or one to two UTF-16 units. Values above U+FFFF need two UTF-16 units, which is why JavaScript string length counts them as two. Code-point iteration keeps a valid surrogate pair together but can still split a combining or emoji sequence; grapheme clusters address that different problem.

Unicode blocks organise ranges. They do not guarantee that every position is assigned, that a font contains every glyph, or that a platform permits every character. Strings that look the same are not always identical: precomposed and decomposed accents can be canonically equivalent while their original sequences differ, and lookalike letters can be different characters entirely, so normalization is not a general identity or security check.

The same text counted four ways

• U+0041 identifies LATIN CAPITAL LETTER A. Its UTF-8 representation takes one byte.
• U+00E9 identifies LATIN SMALL LETTER E WITH ACUTE. U+0065 U+0301 is its canonically equivalent decomposed sequence.
• U+1F602 identifies FACE WITH TEARS OF JOY. It takes two UTF-16 units and four UTF-8 bytes.
• U+2764 U+FE0F is a heart followed by an emoji presentation selector. The sequence has two code points, not one.

U+0041

U+00E9

U+0065 U+0301

U+1F602

U+2764 U+FE0F

When these differences matter

• Exchanging multilingual documents with an agreed encoding such as UTF-8.
• Inspecting saved text when a counting, normalization or decoding issue appears.
• Understanding character substitutions used by styling tools. Plain-text copying carries characters, not CSS colour or font settings.
• Checking the exact receiving app and field before publishing styled text. Unicode identity does not guarantee font coverage or permission.