Unicode Guide: Characters, Code Points, UTF-8 & Symbols

Unicode is the system that allows text written on one computer, phone, website, or application to be represented consistently on another. It gives characters numerical identities so that a letter, punctuation mark, mathematical sign, currency symbol, emoji, or other encoded text element does not have to depend on a particular font or operating system to be recognized.

If you have ever seen a value such as U+00A7, wondered why two nearly identical symbols are actually different characters, or copied an emoji that turned out to contain several hidden code points, this guide explains what is happening underneath the text.

You do not need to understand every technical part of Unicode to use it. For most people, the most useful ideas are simple: a Unicode character has an identity, that identity can be represented by a code point, fonts control how the character looks, and what appears to be one visible symbol is not always stored as one code point.

If you already have an unknown character, you can return to the What Is This Symbol? and paste it directly into the search tool.

What Is Unicode?

Unicode is a character encoding standard designed to provide a common way to represent text from writing systems around the world, along with punctuation, mathematical notation, technical characters, currency signs, emoji, and many other text elements.

Before Unicode became widely adopted, different systems often relied on separate character sets or code pages. The same numerical value could represent different characters depending on which encoding a program expected. Moving text between systems could therefore produce incorrect characters or unreadable text.

Unicode approaches the problem differently. Characters that are encoded in the standard are assigned positions in a shared Unicode codespace. Those positions are called code points.

For example:

Character	Name	Code point
A	Latin Capital Letter A	U+0041
£	Pound Sign	U+00A3
§	Section Sign	U+00A7
α	Greek Small Letter Alpha	U+03B1
→	Rightwards Arrow	U+2192
∞	Infinity	U+221E
★	Black Star	U+2605

The code point identifies the encoded character. It does not prescribe one exact drawing of that character.

What Does U+ Mean?

Unicode code points are normally written using U+ followed by a hexadecimal number.

For example:

• U+003F = ? Question Mark
• U+00A3 = £ Pound Sign
• U+00A7 = § Section Sign
• U+2192 = → Rightwards Arrow
• U+2605 = ★ Black Star

The digits after U+ are hexadecimal, or base 16. Hexadecimal uses the digits 0–9 plus the letters A–F.

This is why Unicode values can contain letters. For example, the A7 in U+00A7 is part of a hexadecimal number; it is not an abbreviation for the character’s name.

The complete Unicode codespace runs from U+0000 through U+10FFFF. Not every position in that range is assigned to a character, and some ranges have specialized purposes.

A Unicode Code Point Is Not the Same as a Glyph

This distinction explains many symbol-display problems.

A code point identifies a position in Unicode. A glyph is the visual form used to draw text on the screen or page.

Consider the letter:

A

Its Unicode identity can remain U+0041 whether the font displays it in Times New Roman, Arial, a monospace font, a bold typeface, or an italic typeface. The character remains the same even though the glyph changes.

The relationship is not always one character to one fixed drawing. Font selection, script shaping, surrounding characters, writing direction, typographic features, and rendering software can all influence what appears on screen.

This is why Unicode does not function as an image library. It encodes text identities rather than supplying one universal image for every character.

Why Can the Same Symbol Look Different on Different Devices?

When you copy a Unicode character, you generally copy its textual identity rather than a screenshot of its appearance. The application that receives the text then chooses how to render it.

That rendering may depend on:

• the font selected by the application;
• fonts installed on the operating system;
• font fallback;
• the browser or rendering engine;
• text-versus-emoji presentation;
• script-shaping rules;
• platform-specific emoji artwork.

As a result, ★, ♥, ⌘, or another Unicode character may not look pixel-for-pixel identical on Windows, macOS, Android, iOS, and Linux.

The different appearance does not automatically mean that the code point changed.

Character, Code Point, Glyph, and Grapheme: What Is the Difference?

These terms are related but should not be used as though they mean exactly the same thing.

Term	Practical meaning
Character	A textual element or abstract character represented by the writing system.
Code point	A numerical position in the Unicode codespace, written in forms such as U+00A7.
Glyph	The visual form used to display one or more characters.
Code unit	A storage unit used by an encoding form such as UTF-8, UTF-16, or UTF-32.
Grapheme cluster	An approximation of what a user perceives as one character, which may consist of multiple code points.

The last distinction is especially important. What appears to you as one character on screen does not necessarily correspond to one Unicode code point.

One Visible Character Can Contain Multiple Code Points

A common example involves accented letters.

The character é can be represented as the single precomposed character:

U+00E9

But text can also represent an equivalent visible result using:

U+0065 LATIN SMALL LETTER E
+
U+0301 COMBINING ACUTE ACCENT

Those representations are not the same sequence of code points, even though properly rendered text can make them look the same.

Unicode defines rules for handling such equivalent representations. This leads to the concept of Unicode normalization, which is covered later in this guide.

What Is a Grapheme Cluster?

A grapheme cluster is a sequence of code points that software can treat approximately as one user-perceived character.

This matters because operations such as cursor movement, backspacing, selection, and character counting should not always operate on individual code points.

For example, a visible letter plus a combining accent may form a single grapheme cluster even though the underlying text contains two code points.

Emoji provide more striking examples. A person may see one emoji on the screen while the underlying representation contains several Unicode characters joined into a sequence.

Unicode Is Not the Same as UTF-8

This is one of the most common Unicode misunderstandings.

Unicode defines the character identities and code points.

UTF-8 is one method of encoding Unicode code points as bytes for storage or transmission.

A useful simplified model is:

Character
↓
Unicode code point
↓
Encoding such as UTF-8
↓
Bytes stored or transmitted

For example, knowing that § is U+00A7 tells you its Unicode code point. A UTF encoding determines how that value is represented in encoded data.

UTF-8, UTF-16, and UTF-32

The Unicode Standard defines three Unicode encoding forms: UTF-8, UTF-16, and UTF-32. All three can represent the Unicode repertoire. They differ primarily in how code points are represented as code units.

Encoding form	Code-unit size	Representation
UTF-8	8 bits	A Unicode scalar value is represented with one to four bytes.
UTF-16	16 bits	A Unicode scalar value is represented with one or two 16-bit code units.
UTF-32	32 bits	A Unicode scalar value is represented with one 32-bit code unit.

UTF-8 is particularly important on the web. Its first 128 code points correspond directly to ASCII values, which also makes ASCII text valid UTF-8.

How Does UTF-8 Work?

UTF-8 uses a variable-length representation.

Characters in the ASCII range use one byte. Other Unicode values use additional bytes, up to four.

This design allows ordinary ASCII text to remain compact while still making the entire Unicode codespace representable.

It is important not to confuse the number of UTF-8 bytes with the number of characters a user sees. One visible character may involve:

• one Unicode code point stored in several UTF-8 bytes;
• multiple code points;
• multiple code points that together form a grapheme cluster or emoji sequence.

Therefore, counting bytes is not a reliable way to count visible characters.

What Is UTF-16?

UTF-16 uses 16-bit code units.

Unicode scalar values in much of the Basic Multilingual Plane can be represented with a single UTF-16 code unit. Characters outside that range require a pair of 16-bit code units known as a surrogate pair.

The surrogate ranges are reserved for the mechanics of UTF-16. Surrogate code points themselves are not Unicode scalar values and should not appear as standalone encoded characters.

This distinction is one reason developers should be careful when software reports a “string length”: in a UTF-16-based environment, a character outside the Basic Multilingual Plane can occupy two code units even before emoji sequences or combining marks are considered.

What Is UTF-32?

UTF-32 uses 32-bit code units. Each Unicode scalar value is represented by one 32-bit code unit.

This makes code-point indexing conceptually simpler than UTF-8 or UTF-16, but it does not mean that one 32-bit unit always equals one visible character. A grapheme cluster can still contain several Unicode scalar values.

What Is the Basic Multilingual Plane?

The Unicode codespace is divided into 17 planes, numbered 0 through 16. Each plane contains 65,536 code-point positions.

Plane 0 is called the Basic Multilingual Plane, commonly abbreviated BMP.

It spans:

U+0000 through U+FFFF

The BMP contains many widely used writing systems and characters, including Basic Latin, Greek, Cyrillic, Hebrew, Arabic, many symbols, punctuation marks, and a large collection of CJK characters.

Additional characters are encoded in supplementary planes above U+FFFF.

The fact that a character is outside the BMP does not make it less valid or less Unicode-compliant.

What Are Unicode Blocks?

Unicode blocks are named ranges of code points used to organize the codespace.

Examples include:

• Basic Latin;
• Latin-1 Supplement;
• Greek and Coptic;
• Arrows;
• Mathematical Operators;
• Geometric Shapes;
• Miscellaneous Symbols.

A block is useful for locating and organizing characters, but it should not be treated as a precise semantic category.

For example, a character being located in Miscellaneous Symbols does not tell you one universal meaning for that character. Likewise, symbols used in mathematics can be found across multiple Unicode blocks.

What Is a Unicode Character Name?

Many encoded characters have a formal Unicode character name.

Examples include:

• § — SECTION SIGN
• £ — POUND SIGN
• → — RIGHTWARDS ARROW
• ∞ — INFINITY
• ★ — BLACK STAR

Unicode names are useful for precise identification, but they are not always the names people use in everyday conversation.

For example:

• / has the Unicode name SOLIDUS, while most people call it a slash or forward slash;
• | is VERTICAL LINE, while programmers commonly call it a pipe;
• ^ is CIRCUMFLEX ACCENT, while it is also commonly called a caret in computing;
• ` is GRAVE ACCENT, while programmers often call it a backtick.

A good character identifier therefore needs to distinguish between the official Unicode identity and common names used in real contexts.

Unicode Names Do Not Define Every Possible Meaning

Knowing a character’s Unicode name answers the question “which character is this?” It does not necessarily answer every question about what the character means.

Consider |. Its encoded character identity remains the same, but it may function as:

• a vertical separator;
• a mathematical delimiter;
• an absolute-value boundary;
• a conditional notation element;
• a pipe operator in computing.

The underlying character and its contextual meaning are related but separate concepts.

This is why identifying the exact Unicode character is often the first step rather than the final interpretation.

Unicode General Categories

Unicode associates characters with properties that help software process text. One commonly encountered property is the General Category.

Examples include:

Category	Meaning	Example
Lu	Uppercase Letter	A
Ll	Lowercase Letter	a
Nd	Decimal Number	5
Po	Other Punctuation	!
Sm	Mathematical Symbol	+
Sc	Currency Symbol	£
So	Other Symbol	★

These categories are technical properties. They should not be interpreted as a complete description of how a character is used.

Is Every “Special Character” a Unicode Symbol?

No.

The phrase special character is an informal, context-dependent term. A password form, programming language, regular expression, database, or keyboard guide may each use the phrase differently.

A character such as # may be treated as a special character by a password system, but Unicode categorizes it according to its own character properties.

Similarly, Unicode distinguishes letters, numbers, punctuation, separators, marks, symbols, controls, and other categories. Calling all non-letter characters “symbols” may be convenient in everyday language, but it is not a precise description of the Unicode data model.

Why Do Some Characters Look Almost Identical?

Different Unicode characters may have similar or nearly identical glyphs.

For example:

• - Hyphen-Minus — U+002D
• – En Dash — U+2013
• — Em Dash — U+2014
• − Minus Sign — U+2212

They are separate characters and should not automatically be substituted for one another.

Another example is:

• Latin capital letter A;
• Greek capital letter alpha Α;
• Cyrillic capital letter A А.

Depending on the font, these may look extremely similar while representing characters from different writing systems.

When exact identity matters, compare code points rather than relying only on appearance.

What Are Combining Characters?

A combining character is designed to combine visually with a preceding base character rather than normally appearing as an independent spacing symbol.

For example:

e
+
◌́
=
é

The accent can be encoded as U+0301 COMBINING ACUTE ACCENT.

Combining marks are one reason visual character counting can differ from code-point counting.

They can also cause copied text to behave unexpectedly if software assumes that every visible symbol corresponds to exactly one code point.

What Is Unicode Normalization?

Unicode allows some equivalent text to have different underlying code-point sequences.

Normalization provides standardized ways to transform Unicode strings into consistent forms for comparison and processing.

The four normalization forms are:

Form	Description
NFC	Canonical decomposition followed by canonical composition.
NFD	Canonical decomposition.
NFKC	Compatibility decomposition followed by canonical composition.
NFKD	Compatibility decomposition.

NFC and NFD preserve canonical equivalence. NFKC and NFKD additionally remove certain compatibility distinctions.

Compatibility normalization should not be applied blindly to arbitrary text because distinctions that matter in some contexts can be lost.

For ordinary users, the main lesson is that two strings can look identical and represent equivalent text while still containing different sequences of code points.

Why Can Two Identical-Looking Strings Fail to Match?

Suppose one string contains precomposed é while another contains e followed by a combining acute accent.

A naive byte-for-byte or code-point-for-code-point comparison can report them as different even though Unicode defines them as canonically equivalent.

Software that performs Unicode-aware searching, matching, or comparison often uses normalization so equivalent forms can be handled consistently.

This is particularly relevant for:

• search systems;
• usernames and identifiers;
• database matching;
• filenames;
• text processing;
• copy-and-paste workflows.

Emoji Are Part of Unicode, but Emoji Can Be Sequences

Many emoji have Unicode code points, but an emoji visible on screen is not necessarily represented by a single code point.

Unicode defines emoji characters and several kinds of emoji sequences.

For example, a visible emoji can be constructed using:

• an emoji character;
• a variation selector;
• a skin-tone modifier;
• a Zero Width Joiner;
• multiple regional indicator characters;
• several characters combined into a standardized sequence.

This is why an emoji identifier should preserve the entire sequence rather than taking only its first code point.

What Is a Variation Selector?

A variation selector is a Unicode character that can request a particular presentation of an eligible preceding character.

Two selectors frequently encountered with emoji are:

• U+FE0E — variation selector used to request text-style presentation in supported sequences;
• U+FE0F — variation selector used to request emoji-style presentation in supported sequences.

For example, a base character may be capable of appearing as either a text-like glyph or an emoji-style glyph depending on the supported variation sequence and rendering environment.

The variation selector itself is normally invisible.

Not every character supports arbitrary variation-selector combinations, so these characters should not be treated as universal formatting switches.

What Is a Zero Width Joiner?

U+200D ZERO WIDTH JOINER, commonly abbreviated ZWJ, is an invisible Unicode character involved in joining behavior.

In standardized emoji sequences, ZWJ can participate in sequences that render as a single emoji presentation.

For example, what appears as one profession or family emoji may internally contain multiple emoji characters joined by ZWJ characters.

The visible result depends on whether the platform supports that standardized sequence. Unsupported sequences may be shown as separate component emoji instead of one combined design.

Why Does Copying an Emoji Sometimes Copy More Than One Character?

Because the visible emoji may be a sequence.

For example, copying one displayed emoji can place several Unicode code points onto the clipboard. The destination application receives the sequence and then attempts to render it.

If the destination supports the sequence, it may still appear as one visual emoji. If support is missing, some or all components may appear separately.

This behavior is normal and is not evidence that the clipboard duplicated the emoji.

What Are Invisible Unicode Characters?

Unicode contains characters that normally have no visible glyph of their own.

Examples can include:

• spaces and special separators;
• combining marks in certain contexts;
• Zero Width Joiner;
• Zero Width Non-Joiner;
• variation selectors;
• directional formatting characters;
• other format or control characters.

An invisible character can still change text processing or rendering.

If copied text behaves differently even though it looks identical, hidden Unicode characters are one possible explanation.

What Is U+FFFD Replacement Character?

The character � is U+FFFD REPLACEMENT CHARACTER.

It is commonly used by software when incoming data cannot be correctly interpreted as the intended character.

Seeing:

�

does not normally mean that your font is simply missing the original glyph. It often means the original text could not be decoded or converted correctly and a replacement character was inserted.

Once the original character has already been replaced by U+FFFD, the replacement character itself generally does not contain enough information to reconstruct what the lost character originally was.

Replacement Character vs Missing Font Glyph

These two situations are easy to confuse.

Replacement character

If the actual text contains:

� — U+FFFD

then the replacement character itself is present in the data.

Missing glyph

If the text contains the correct Unicode character but the selected font cannot display it, you may instead see a blank box, outlined square, box containing markings, or another missing-glyph indicator.

In that case, copying the character may still preserve the correct code point even though it is not being rendered correctly.

What Is Font Fallback?

A single font rarely contains glyphs for every Unicode character.

When the selected font lacks the necessary glyph, an operating system or browser may attempt to find another installed font that can display it. This is known as font fallback.

Fallback is why a webpage can display characters that are not present in its primary typeface.

It also explains why some Unicode symbols can have a slightly different visual style from the surrounding text: the browser may be using a different font for those glyphs.

Does Unicode Guarantee That Every Device Can Display Every Character?

No.

Unicode defines character identities and encoding behavior, but actual display requires suitable fonts and rendering support.

A newly encoded character, rare historical script, specialized notation, or recently standardized emoji may not display on an older device.

The underlying Unicode data can still be valid even when the local system does not have a suitable glyph.

What Are Private-Use Characters?

Unicode reserves certain code-point ranges for private use.

Characters in these ranges do not have one universally defined meaning assigned by the Unicode Standard. Organizations, applications, or fonts can agree privately on what a particular value represents.

This means a private-use character may display correctly only when the expected font or software environment is available.

If you encounter one outside its original system, it may be impossible to determine its intended meaning from the code point alone.

ASCII and Unicode

ASCII is an older character encoding standard that represents 128 basic characters, including Latin letters, digits, punctuation, and control characters.

Unicode includes the ASCII characters at the same initial code-point values from U+0000 through U+007F.

Examples include:

• A — ASCII 65 — Unicode U+0041
• ? — ASCII 63 — Unicode U+003F
• # — ASCII 35 — Unicode U+0023
• / — ASCII 47 — Unicode U+002F

UTF-8 preserves this compatibility: ASCII bytes from 00 through 7F represent the corresponding Unicode code points directly.

Unicode in HTML

If an HTML document is correctly encoded as UTF-8, Unicode characters can usually be included directly in the document.

For example:

<p>§ £ → ★ α</p>

HTML also supports numeric character references.

For example, the section sign can be represented as:

§

or using hexadecimal notation:

§

Both refer to the same Unicode character §.

Some characters also have HTML named character references, but HTML entity names and Unicode character names are separate systems. Not every Unicode character has a convenient HTML named reference.

Unicode Code Points vs HTML Entities

These should not be confused.

Form	Example for §
Character	§
Unicode code point	U+00A7
HTML decimal reference	§
HTML hexadecimal reference	§
HTML named reference	§

These are different ways of referring to or representing the same underlying character in different contexts.

How to Find the Unicode Code Point of a Symbol

If you can copy the character, paste it into the symbol identification tool.

For an exact character match, the result can provide information such as:

• the character itself;
• its Unicode name;
• its code point;
• its Unicode block;
• its general category;
• similar-looking characters.

Exact lookup is particularly useful when the symbol could be confused with another character.

How to Identify a Character You Cannot Copy

If the symbol appears only in an image, screenshot, printed document, sign, or other non-selectable source, there may not be any Unicode character to copy.

Start by describing its visual features:

• circle or ring;
• triangle;
• square;
• arrow direction;
• horizontal or vertical line;
• slash or cross;
• star shape;
• dots;
• letters or numbers inside a shape.

Context is also useful. A mark found in mathematics may have a different likely identity from a similar mark on a keyboard, map, piece of clothing, dashboard, or electrical diagram.

Not every visual symbol has a Unicode equivalent. Unicode encodes text elements, not every logo, pictogram, proprietary icon, road sign, or graphic design.

Why Context Matters When Identifying Symbols

A Unicode code point can tell you exactly which encoded character you have. It cannot by itself explain every use of that character.

For example:

! is U+0021 EXCLAMATION MARK.

In ordinary writing it marks an exclamation. In mathematics it can be used for factorial notation. In programming languages it may be used for logical or syntactic purposes.

The character identity remains the same while its role depends on context.

For accurate symbol identification, it is therefore useful to separate:

1. What character is this?
2. What does it mean in this context?

Can Unicode Characters Be Dangerous or Misleading?

Unicode itself is necessary for global text, but visually similar characters can sometimes create confusion.

For example, letters from different scripts may look nearly identical. Invisible formatting characters can also make text behave differently from what is immediately visible.

When exact identity matters—particularly in source code, usernames, domain-related text, identifiers, financial information, or security-sensitive data—do not rely only on appearance. Inspect the actual characters or code points.

Common Unicode Mistakes

Thinking Unicode and UTF-8 are the same thing

Unicode defines the character system. UTF-8 is an encoding of Unicode.

Assuming one visible symbol always equals one code point

Combining sequences, grapheme clusters, variation sequences, and emoji sequences can contain multiple code points.

Assuming similar-looking symbols are interchangeable

A hyphen, minus sign, en dash, and em dash are separate characters.

Assuming the Unicode name is the only common name

Unicode names are technical identities. Everyday, typographic, mathematical, and computing terminology may differ.

Assuming a missing glyph means corrupted text

The character may be valid while the local font lacks a glyph for it.

Assuming U+FFFD is a font problem

� is itself a Unicode replacement character and usually indicates that decoding or conversion failed earlier.

Assuming every visual symbol belongs in Unicode

Unicode encodes text characters. Many logos, icons, signs, and graphics are images rather than Unicode characters.

Frequently Asked Questions About Unicode

What is a Unicode character?

A Unicode character is an encoded textual element represented in the Unicode Standard. Encoded characters are associated with code points and character properties used for consistent text processing.

What is a Unicode code point?

A code point is a numerical position in the Unicode codespace. It is normally written with the prefix U+, such as U+00A7 for the section sign.

What does U+003F mean?

U+003F identifies the Unicode code point for the question mark ?. The hexadecimal value after U+ uniquely identifies that code-point position.

How many Unicode code points are there?

The Unicode codespace contains 1,114,112 code-point positions ranging from U+0000 through U+10FFFF. Not all of those positions are assigned to encoded characters.

Is UTF-8 Unicode?

UTF-8 is a Unicode encoding form. Unicode defines characters and code points, while UTF-8 specifies how Unicode scalar values are represented using 8-bit code units.

Does every Unicode character use one byte?

No. In UTF-8, ASCII-range characters use one byte, while other Unicode scalar values use two, three, or four bytes.

Can one character have more than one code point?

A single encoded character has a code-point identity, but what a user perceives as one character can be represented by a sequence of multiple code points. Combining characters and emoji sequences are common examples.

Why do emoji look different on iPhone, Android, and Windows?

Unicode defines the underlying emoji characters and sequences, while platforms provide their own artwork and rendering. The encoded text can therefore be the same even when its appearance differs.

Why does a Unicode symbol show as a box?

The current font or system may not contain a glyph for that character. Font fallback may solve the problem; otherwise the system can display a missing-glyph box even though the underlying Unicode character is valid.

What does � mean?

� is U+FFFD REPLACEMENT CHARACTER. It is generally used when software cannot correctly decode or convert incoming character data.

What is the difference between a symbol and a glyph?

A glyph is a visual representation. A Unicode character is an encoded textual identity. The same character can be displayed with different glyphs in different fonts.

Can I copy a Unicode character between devices?

Usually, yes. Copying transfers the text rather than one fixed visual image. The receiving device may render the same character differently depending on its fonts and software support.

Why does copied text sometimes change appearance?

The destination application may use a different font, shaping engine, emoji style, or fallback font. The underlying character or sequence can remain unchanged.

Can Unicode represent every symbol in the world?

No. Unicode has broad coverage of writing systems and encoded symbols, but it is not a catalog of every logo, graphic icon, road sign, proprietary mark, or visual design.

What is the best way to identify an unknown Unicode symbol?

If the mark is selectable text, copy the exact character and use the What Is This Symbol? tool. Exact-character lookup provides more reliable identification than guessing from appearance alone.

Unicode Reference Summary

Concept	Quick definition
Unicode	A standard for encoding and processing text characters.
Code point	A numerical position such as U+00A7.
Glyph	The visual form used to display a character.
UTF-8	A variable-length Unicode encoding using 8-bit code units.
UTF-16	A Unicode encoding using 16-bit code units.
UTF-32	A Unicode encoding using 32-bit code units.
BMP	Unicode Plane 0, from U+0000 through U+FFFF.
Combining mark	A character designed to combine with another character.
Grapheme cluster	An approximation of one user-perceived character that may include several code points.
Normalization	Standardized transformations for handling equivalent Unicode sequences.
Variation selector	A character used in defined sequences to request a supported presentation variant.
ZWJ	Zero Width Joiner, used in joining behavior and standardized emoji sequences.
U+FFFD	Replacement Character, commonly used after a decoding or conversion problem.

Official Unicode References

This guide focuses on practical character identification. For normative definitions and deeper technical details, consult the Unicode Consortium’s official documentation:

• Unicode Technical Introduction
• Unicode Glossary
• UTF-8, UTF-16, UTF-32 and BOM FAQ
• Unicode Normalization Forms
• Unicode Text Segmentation
• Unicode Emoji

Unicode continues to evolve as new characters, scripts, properties, and supporting specifications are added or updated. When exact conformance or implementation details matter, the current Unicode Standard and its associated technical reports should be treated as the authoritative reference.