The Complete Guide to Unicode: How to Look Up Any Character, Code Point, and Encoding

Every character you read on this page — every letter, number, emoji, punctuation mark, and space — is ultimately just a number inside your computer. The system that maps those numbers to characters is called Unicode, and it is the silent backbone of the modern web. Without Unicode, a single document could not hold English, Thai, Arabic, Chinese, math symbols, and 🚀 in the same file. With Unicode, they all coexist seamlessly.

Yet despite its ubiquity, Unicode trips up developers constantly. Invisible characters break JSON parsers. The "same" string fails a comparison check. An emoji renders as tofu (□) because the font lacks the glyph. A stray UTF-8 BOM corrupts an HTTP header. Knowing how to look up a character, inspect its code point, and understand its encoding is a core development skill.

In this guide, you will learn how Unicode works, how to search for any of the 150,000+ defined characters, how the UTF-8/UTF-16/UTF-32 encodings differ, and how to use our free Unicode Lookup tool to resolve character mysteries in seconds.

What is Unicode?

Unicode is an international standard for representing text in writing systems across the world. Before Unicode, computers relied on dozens of incompatible encodings — ASCII, EBCDIC, ISO-8859 variants, Shift-JIS, Big5 — and moving text between systems frequently produced mojibake (garbled text). Unicode solved this by assigning every character a single, unique number called a code point, so the same number means the same character everywhere.

The standard is maintained by the Unicode Consortium and currently defines over 150,000 characters across:

• Latin, Greek, Cyrillic, Hebrew, Arabic, Devanagari, Thai, CJK, and 140+ other scripts
• Mathematical operators and technical symbols
• Punctuation, currency, and formatting marks
• Arrows, box-drawing, and geometric shapes
• 1,400+ emoji (updated yearly)
• Historical and rare scripts (Egyptian hieroglyphs, cuneiform, runic, etc.)

Each Unicode character is catalogued in the Unicode Character Database (UCD), which stores its name, category, block, bidirectional properties, and more. Our Unicode Lookup tool lets you query this database instantly — no install required.

Understanding Code Points (U+XXXX)

A code point is the number Unicode assigns to a character. Code points are written in the form U+XXXX, where XXXX is a hexadecimal number. The Unicode codespace ranges from U+0000 to U+10FFFF, giving over 1.1 million possible slots — of which roughly 150,000 are currently assigned.

Planes and Blocks

The codespace is divided into 17 planes of 65,536 code points each. The first plane, the Basic Multilingual Plane (BMP) — U+0000 to U+FFFF — holds almost all common scripts. Characters beyond the BMP (code points above U+FFFF) live in the Supplementary Multilingual Plane (SMP) and are called astral characters; this is where most emoji and historic scripts live.

Each plane is further sliced into blocks — named ranges like "Basic Latin", "Currency Symbols", "Emoticons", or "Supplemental Arrows-C".

Unicode Encodings: UTF-8, UTF-16, and UTF-32

A code point is a logical number, but bytes must physically travel through files, networks, and memory. Encodings define how code points are serialized into bytes. Unicode defines three main encodings:

UTF-8

A variable-width encoding using 1 to 4 bytes per code point. ASCII (U+0000–U+007F) stays identical to legacy ASCII — one byte each — which made UTF-8 the runaway winner for the web. Over 98% of all web pages now use UTF-8. Characters in the BMP beyond ASCII take 2 or 3 bytes, and supplementary characters take 4 bytes.

UTF-16

A variable-width encoding using 2 or 4 bytes (1 or 2 16-bit code units). BMP characters fit in one code unit; supplementary characters use a surrogate pair (two 16-bit units). UTF-16 is used internally by JavaScript, Java, C#, and Windows APIs. Its surrogate-pair mechanics are the reason "🚀".length === 2 in JavaScript — a common gotcha.

UTF-32

A fixed-width encoding using exactly 4 bytes per code point. Constant-time indexing into characters is trivial, but the storage cost is enormous, so UTF-32 is rarely used in practice.

Encoding Comparison

How to Search for Unicode Characters

Finding the right character is half the battle. Here are the most effective search strategies, all of which our Unicode Lookup tool supports:

• Search by name — type heart, arrow, rocket, or greek letter to match character names.
• Search by code point — enter U+1F600 or just 1F600 to jump straight to a character.
• Paste and inspect — paste any character (even invisible ones) and instantly see its code point, name, and category.
• Filter by block or category — browse entire ranges like "Currency Symbols" or "Letter, Uppercase".
• Search by HTML entity — look up ♥ or ♥ to find the named/numeric reference.

💡 Tip: Zero-width characters such as the Zero Width Space (U+200B) and Zero Width Joiner (U+200D) are a frequent source of invisible bugs. Paste your string into the Lookup tool to reveal them.

Common Unicode Categories Explained

Unicode groups every character into a General Category. Knowing these helps when writing regex, validating input, or parsing text.

Normalization Forms

Characters that look identical can have different code point sequences. For example, é can be a single code point (U+00E9) or a base e (U+0065) plus a combining acute accent (U+0301). Unicode defines four normalization forms to resolve this:

• NFC — composed form (default for the web)
• NFD — decomposed form
• NFKC — composed, compatibility
• NFKD — decomposed, compatibility

If two "equal" strings fail a comparison, normalization is almost always the culprit.

HTML Entities and CSS Escapes

When you cannot safely type a character — or want it to survive encoding corruption — you can reference it by code point.

HTML Entities

<!-- Named entity -->
<p>I &hearts; Unicode</p>

<!-- Decimal numeric entity -->
<p>Copyright &#169; 2026</p>

<!-- Hexadecimal numeric entity -->
<p>Rocket &#x1F680; launched</p>

All three render identically: I ♥ Unicode, Copyright © 2026, and 🚀 launched.

CSS Escapes

In CSS, escape a Unicode code point with a backslash followed by up to six hex digits (optionally padded with a space):

/* Content property with an emoji */
.icon::after {
  content: '\1F680'; /* 🚀 */
}

/* Using a hex code point in a selector (for IDs/classes) */
.\1F600 {
  font-size: 2rem;
}

JavaScript

JavaScript exposes Unicode through String.prototype.charCodeAt, String.fromCodePoint, and String.prototype.codePointAt:

// Get the UTF-16 code unit (BMP only)
'A'.charCodeAt(0); // 65

// Get the full code point (works for astral chars)
'🚀'.codePointAt(0); // 128640

// Build a character from a code point
String.fromCodePoint(0x1f680); // '🚀'
String.fromCodePoint(0x0041, 0x03a9, 0x0e01); // 'AΩก'

// Escape sequence in a string literal
const rocket = '\u{1F680}'; // modern syntax
const heart = '\u2665'; // BMP escape

Remember that charCodeAt returns a 16-bit code unit, not a code point — use codePointAt for characters above U+FFFF.

How to Use Our Unicode Lookup Tool

Our Unicode Lookup tool makes all of the above painless. Here is the typical workflow:

1. Enter your query — type a character, paste a string, or enter a code point like U+1F600.
2. Browse the results — each match shows the glyph, code point, official name, block, category, and UTF-8/UTF-16/UTF-32 byte sequences.
3. Copy what you need — grab the HTML entity, CSS escape, JavaScript escape, or raw bytes with one click.
4. Filter by block or category — drill down into "Emoticons", "Mathematical Operators", "Currency Symbols", and more.

The tool runs entirely in your browser — no sign-up, no tracking, no data leaves your device. It is perfect for quick lookups during development, design, or debugging.

Practical Use Cases

• Web developers — find the exact HTML entity for a symbol, or inspect a string that breaks your parser.
• Designers — discover arrows, bullets, and dingbats to enrich an interface without image assets.
• Localization engineers — verify that translated text uses the correct code points and normalization form.
• Data engineers — detect zero-width characters, BOMs, and control characters lurking in CSV or JSON files.
• Educators & students — explore scripts, math symbols, and emoji while learning how text is encoded.
• Security analysts — spot homoglyph attacks (e.g., раypal.com using Cyrillic а vs Latin a).

Best Practices for Working with Unicode

• Always declare your encoding. Serve HTML with <meta charset="utf-8"> and set Content-Type: text/html; charset=utf-8 on HTTP responses.
• Normalize before comparing. Use NFC for storage and comparison; it prevents look-alike mismatches.
• Use a Unicode-aware language/port. In regex, prefer Unicode property escapes (\p{L}, \p{Emoji}) over ASCII ranges.
• Count characters correctly. string.length counts UTF-16 code units, not visible characters. Use grapheme-segmentation libraries (e.g., Intl.Segmenter) for accurate counts.
• Watch for invisible characters. Zero-width spaces, soft hyphens, and BOMs are easy to paste by accident — inspect suspicious text with the Lookup tool.
• Prefer named HTML entities for readability when an obvious name exists (&copy;, &mdash;, &hearts;).
• Test with real-world data. Mix scripts, emoji, and RTL text in your test fixtures to catch encoding bugs early.
• Keep fonts in mind. A tofu box (□) usually means the font lacks the glyph, not that the code point is wrong.

Conclusion

Unicode is the reason text works at all in a global, multi-script digital world. Understanding code points, encodings, and character properties lets you build software that handles any language, any symbol, and any emoji with confidence. Whether you are debugging a mysterious byte sequence, hunting for the perfect arrow glyph, or verifying an HTML entity, the fundamentals in this guide will keep you unblocked.

Ready to put it into practice? Open our free Unicode Lookup tool and start exploring the 150,000+ characters at your fingertips.

Related Tools

• Number Base Converter — Convert between binary, octal, decimal, and hexadecimal. Perfect for turning code points into byte values.
• Hash Generator — Generate MD5, SHA-1, SHA-256, and SHA-512 hashes of any text, useful for verifying normalized Unicode strings.
• Regex Tester — Test regular expressions with full Unicode property escape support (\p{L}, \p{Emoji}, \p{Script=Thai}).