How to Use the SymbolFYI Unicode Lookup Tool

The Unicode Lookup tool at /tools/unicode-lookup/ answers a precise question: given a Unicode code point, what exactly is this character? Enter a code point like U+2764 and the tool immediately renders the character, gives its official name, and presents its full encoding breakdown — HTML entity, CSS escape, JavaScript escape, Python literal, UTF-8 bytes, and UTF-16 code units — all in one panel. This guide explains every aspect of the tool and when it is the right one to reach for.

How to Enter a Code Point

The input field accepts code points in several formats, and the tool normalizes them all to the same result:

• U+ notation: U+2764, U+1F600, U+00A9 — the standard way to write Unicode code points, as seen in documentation and specifications. The U+ prefix is optional but supported.
• Hex digits only: 2764, 1F600, A9 — the tool recognizes hexadecimal input without a prefix. Leading zeros are optional.
• Uppercase or lowercase: u+2764, U+2764, 2764, 2764 — case does not matter in the input.

The lookup is instantaneous. As soon as you enter a valid code point and leave the field (or press Enter), the character detail panel populates with all available information.

If you enter a value that is not a valid Unicode code point — a number greater than U+10FFFF, a non-hexadecimal string, or a value in the surrogate range (U+D800–U+DFFF, which are not valid standalone characters) — the tool displays a clear error message explaining why the value cannot be resolved.

What the Tool Displays

For a valid code point, the tool renders a complete character information panel. Here is what each section contains.

Character Rendering

At the top of the panel, the character is displayed at a large size — typically 64px or larger — so you can see it clearly regardless of how small it might appear in normal text. This rendering uses the same font stack as your operating system, so it reflects how the character will actually appear in your content.

If your system's fonts do not include a glyph for this code point, the rendering area shows a small square (tofu). The absence of a visual rendering does not mean the character is invalid; it means your current font stack lacks coverage for this code point. The rest of the information panel will still be fully populated with the character's Unicode data.

The official Unicode character name is displayed prominently below the rendering. Names are always uppercase: HEAVY BLACK HEART (U+2764), COPYRIGHT SIGN (U+00A9), SNOWMAN (U+2603), LATIN SMALL LETTER A (U+0061). Unicode names are permanent — once assigned, they never change, even if the description seems inaccurate in retrospect.

Unicode Properties

A properties section shows the character's classification within the Unicode standard:

Block — the named range of code points the character belongs to. The block is a geographic designation — it tells you where in Unicode space the character lives. Examples: Basic Latin (U+0000–U+007F), General Punctuation (U+2000–U+206F), Mathematical Operators (U+2200–U+22FF), Emoticons (U+1F600–U+1F64F). Blocks are a primary navigation tool in Unicode documentation, and knowing a character's block helps you find neighboring related characters.

Script — the writing system the character is associated with. Examples: Latin, Greek, Cyrillic, Arabic, Han, Hiragana, Common. Characters like digits, punctuation, and symbols shared across writing systems are assigned the Common script. Combining marks that inherit their script from the preceding base character are assigned the Inherited script. Script information is important for bidirectionality handling and for security analysis — lookalike characters from different scripts have identical glyph appearances but different script values.

General Category — a two-letter code identifying the character's fundamental type. The category is one of the most useful properties for programmatic text processing. Common categories:

Bidirectional Class — how the character behaves in Unicode's bidirectional algorithm, which governs text rendering in mixed left-to-right and right-to-left content. Values include L (strong left-to-right), R (strong right-to-left), AL (Arabic letter), WS (whitespace), and several others. For developers working with Arabic, Hebrew, or other RTL scripts, the bidirectional class determines whether a character anchors text direction or is neutral.

Combining Class — a numeric value (0–254) relevant for combining characters like accents and diacritical marks. A combining class of 0 means the character is a base character (or a non-combining character). Non-zero values indicate the character is a combining mark and specify its positioning behavior for normalization. Most characters have a combining class of 0.

Decomposition — whether the character has a canonical or compatibility decomposition to a sequence of simpler characters. For example, ñ (U+00F1, LATIN SMALL LETTER N WITH TILDE) decomposes canonically to n (U+006E) + combining tilde (U+0303). Characters with canonical decompositions are the basis for NFC/NFD normalization. The decomposition field shows the mapped sequence when one exists.

Encoding Table

Below the Unicode properties, the tool displays the character's representation in every major encoding format used in software development:

Each row in the encoding table has a dedicated copy button. Click the button for any row to copy exactly that format to your clipboard. This makes the Unicode Lookup tool a quick encoding converter for any single character: look it up once, then copy the format you need for your specific context — HTML template, CSS content property, JavaScript string literal, Python source file, or database inspection.

For characters without a named HTML entity — the majority of Unicode characters — the tool shows "no named entity" and provides only the numeric reference forms. Numeric references (both decimal &#XXXXX; and hex &#xXXXX;) work for every valid Unicode code point regardless of whether a named entity exists.

Use Cases

Debugging Unknown Characters in Text

You received text containing a character that displays oddly, causes search mismatches, or behaves unexpectedly. You need to identify it precisely.

The fastest workflow: copy the character, paste it into the Symbol Search tool at /tools/search/, then follow the link from the result to the Unicode Lookup (or use the Character Analyzer at /tools/character-counter/ to break the whole string apart). Once you have the code point, enter it in Unicode Lookup to read the character's full properties. The official name, general category, and bidirectional class usually explain the behavior.

Common surprising characters this workflow uncovers:

• U+00A0 (NO-BREAK SPACE) — looks like a regular space, causes string comparison failures
• U+200B (ZERO WIDTH SPACE) — completely invisible, silently breaks exact-match searches
• U+2019 (RIGHT SINGLE QUOTATION MARK) — a "curly apostrophe" that doesn't match a straight apostrophe U+0027
• U+FEFF (BYTE ORDER MARK / ZERO WIDTH NO-BREAK SPACE) — a BOM from a UTF-8 encoded file, invisible in text but present in the string

Verifying a Code Point Before Using It

You found a code point in a Unicode reference chart or documentation and want to confirm it's the right character before building it into code. Enter the code point, see the character rendered and named, and verify it matches what you expect. The properties panel confirms the character's script, block, and category, ensuring you've found the intended character rather than a lookalike in a different script or block.

Learning Unicode Properties

For developers building Unicode-aware text processing — search normalization, input validation, sorting, or character filtering — understanding Unicode properties is foundational. The Unicode Lookup tool provides a hands-on reference: enter any code point and read its complete property set. Entering a series of related code points — for example, the various dash characters from U+2010 through U+2015 — lets you compare their properties and understand how they differ structurally, not just visually.

Preparing Encoding Formats for Code

You need to include a specific character in source code and want the correct escape sequence. Enter the code point, find the row for your target language in the encoding table, and copy the escape. The tool handles the differences between JavaScript's \uXXXX (BMP-only), \u{XXXXX} (full Unicode), Python's \uXXXX versus \UXXXXXXXX, and CSS's \XXXX without a trailing semicolon — each format is correct for its context.

Pro Tips

Looking Up Astral Plane Characters

Characters above U+FFFF live in Supplementary Planes (Planes 1 through 16) — often called astral plane characters. These include emoji (Plane 1, Emoticons block), mathematical styled letters (Plane 1, Mathematical Alphanumeric Symbols), historic scripts (Plane 1), and various other extended character sets.

Astral plane characters require 5–6 hex digits in their code point notation. The Unicode Lookup tool accepts them without modification:

• U+1F600 — GRINNING FACE emoji
• U+1D400 — MATHEMATICAL BOLD CAPITAL A
• U+1F004 — MAHJONG TILE RED DRAGON
• U+10000 — LINEAR B SYLLABLE B008 A (the first supplementary character)

For astral characters, the encoding table shows their surrogate pair representation in UTF-16 — two 16-bit code units required to encode characters outside the Basic Multilingual Plane. For example, U+1F600 encodes as the surrogate pair \uD83D\uDE00 in UTF-16. This is what JavaScript's legacy \uXXXX escape requires; the modern \u{1F600} syntax avoids surrogates entirely.

The UTF-8 encoding for astral characters is always 4 bytes. The encoding table shows all four byte values in hex, which is useful for inspecting binary representations or debugging byte-level string handling.

Checking Normalization Properties

The Decomposition field in the properties section is the entry point for understanding Unicode normalization. A character with a canonical decomposition entry is not in NFD (canonical decomposition) form — NFD represents it as the decomposed sequence instead. Characters without a decomposition entry are already in their simplest canonical form.

For example: - U+00E9 (LATIN SMALL LETTER E WITH ACUTE) has a canonical decomposition to U+0065 + U+0301. In NFC form, it is U+00E9. In NFD, it becomes two code points. - U+0041 (LATIN CAPITAL LETTER A) has no decomposition. It is identical in all normalization forms.

If you are comparing strings that might have been normalized differently, looking up the code points of differing characters in Unicode Lookup reveals whether a decomposition difference explains the mismatch.

Cross-Referencing with Related Tools

The Unicode Lookup tool is the most focused tool in the SymbolFYI toolkit — it does one thing precisely: given a code point, display everything about that character. It pairs naturally with:

Symbol Search (/tools/search/) — when you know a description but not the code point. Search, find the character, follow its detail link to get the code point, then use Unicode Lookup for the complete properties view.

Character Analyzer (/tools/character-counter/) — when you have a string and need to look at its characters one by one. The analyzer breaks the string into code points; each code point links to its detail page, which presents the same information as the Unicode Lookup tool in a symbol-detail format.

Encoding Converter (/tools/encoding-converter/) — when you want to convert across multiple encoding formats in bulk, or when you need to go in the reverse direction (from an HTML entity or CSS escape back to the character and code point).

Symbol Table (/tools/symbol-table/) — when you want to browse the block surrounding a character. If Unicode Lookup tells you a character lives in the Miscellaneous Symbols block, the Symbol Table lets you navigate to that block and see all neighboring characters in context.

Unicode Lookup is the definitive single-character reference — the tool to open when you have a code point and want to know everything about it.