Invisible Character Inspector

Inspect Unicode strings character by character in your browser.

No uploadsNo sign-upInstant results
Unicode & UTF-8/16Zero-Width & Homoglyphs100% Local • Zero Uploads
Inspect Characters
Offline engine ready100% private in-browser workspace • Zero cloud uploads
100% Private • Zero Server File Uploads

Why Use Utiliome's Free Invisible Character Inspector?

Built from the ground up for strict privacy, instant execution, and zero friction. No subscriptions, paywalls, or account registrations required.

Invisible & Bidi Override Detection

Surfaces non-printing control and format characters including U+200B ZWSP, U+FEFF BOM, U+00A0 NBSP, U+00AD Soft Hyphen, and Trojan Source bidirectional overrides (U+202A to U+202E, U+2066 to U+2069).

UTF-8 & UTF-16LE/BE Byte Breakdown

Displays exact hexadecimal UTF-8 byte sequences (1 to 4 bytes per RFC 3629) alongside UTF-16LE and UTF-16BE code units, exposing surrogate pairs for supplementary planes above U+FFFF.

UAX #29 Grapheme vs Code-Unit Metrics

Compares extended grapheme clusters against Unicode scalar counts, JavaScript UTF-16 code units, and UTF-8 byte length to diagnose string-slicing bugs and database column overflows.

Homoglyph Diagnostics & Zero-Upload Privacy

Flags UTS #39 confusable lookalikes such as Cyrillic vs Latin glyphs and typographic smart punctuation completely client-side in browser memory so tokens, logs, and code never leave your device.

Utiliome vs Traditional Cloud Alternatives

Compare our local-first WebAssembly engine against legacy cloud tools.

Feature Utiliome (Local Browser) Legacy Cloud Converters
Invisible & Zero-Width Detection Flags ZWSP (U+200B), BOM (U+FEFF), soft hyphens, and BiDi override Trojans Renders invisible characters as blank space with no visual badge
IDN Homoglyph & Spoofing Audit Highlights Cyrillic/Greek lookalike characters mixed into Latin identifiers Shows basic code points without script classification or confusable warnings
Per-Character Encoding Breakdown Displays U+XXXX, UTF-8 hex bytes, UTF-16 surrogates, General Category & NFC/NFD Outputs decimal ASCII codes only and breaks on 4-byte astral emoji
One-Click Sanitization Strip all zero-width, control, or non-ASCII characters instantly in browser Read-only table requiring manual regex cleanup in an external editor
How it works

How to Use Invisible Character Inspector in 3 Easy Steps

No software installation required. Everything runs directly inside your web browser.

1

Paste Text or Drop a File

Paste a string, identifier, log entry, or upload a UTF-8 file containing suspected zero-width characters, broken emoji sequences, or unexpected byte lengths.

2

Inspect Per-Character Metadata

Review each character's U+XXXX scalar code point, official Unicode name, General Category, block assignment, UTF-8 and UTF-16LE/BE hex bytes, and security warning badges.

3

Isolate Anomalies or Copy Clean Output

Filter directly to invisible format characters or confusable homoglyphs, strip unwanted non-printing code points, or copy the byte-level inspection table for bug reports.

Inspecting Hidden Characters, Surrogate Pairs, and Homoglyphs

Quick Answer: Paste any string to decompose it into individual Unicode scalar values, exposing invisible characters like U+200B Zero Width Space or U+FEFF BOM, multi-codepoint ZWJ emoji sequences, and confusable non-ASCII lookalikes alongside their exact UTF-8 and UTF-16 byte sequences.

Parser failures, webhook signature mismatches, and failed SQL lookups frequently stem from characters that render identically—or completely invisibly—in terminal emulators and code editors. Consider an environment variable copied from a documentation portal or chat message that appears visually identical to api_key=prod:

Visual rendering:  api_key=prod
String.length:     14 (expected 12)
UTF-8 byte length: 19 bytes (expected 12 bytes)

Running that 14-unit string through the Unicode Character Inspector exposes three distinct anomalies hidden inside seemingly plain ASCII text: a leading Byte Order Mark (<BOM>), a Cyrillic homoglyph replacing Latin a, and an embedded Zero Width Space (<ZWSP>):

[
  {
    "index": 0,
    "badge": "<BOM>",
    "codePoint": "U+FEFF",
    "name": "ZERO WIDTH NO-BREAK SPACE",
    "category": "Cf (Format)",
    "block": "Arabic Presentation Forms-B",
    "utf8Hex": "EF BB BF",
    "utf16BE": "FE FF",
    "utf16LE": "FF FE",
    "warning": "Invisible zero-width format character"
  },
  {
    "index": 1,
    "glyph": "а",
    "codePoint": "U+0430",
    "name": "CYRILLIC SMALL LETTER A",
    "category": "Ll (Lowercase Letter)",
    "block": "Cyrillic",
    "utf8Hex": "D0 B0",
    "utf16BE": "04 30",
    "utf16LE": "30 04",
    "warning": "Confusable homoglyph for Latin U+0061 ('a')"
  },
  {
    "index": 2,
    "glyph": "p",
    "codePoint": "U+0070",
    "name": "LATIN SMALL LETTER P",
    "category": "Ll (Lowercase Letter)",
    "block": "Basic Latin",
    "utf8Hex": "70",
    "utf16BE": "00 70",
    "utf16LE": "70 00",
    "warning": null
  },
  {
    "index": 8,
    "badge": "<ZWSP>",
    "codePoint": "U+200B",
    "name": "ZERO WIDTH SPACE",
    "category": "Cf (Format)",
    "block": "General Punctuation",
    "utf8Hex": "E2 80 8B",
    "utf16BE": "20 0B",
    "utf16LE": "0B 20",
    "warning": "Invisible zero-width format character"
  }
]

The inspector also clarifies why multi-codepoint emojis report wildly different lengths across runtimes. Inspecting the single visible technologist emoji 👨‍💻 reveals three scalar code points joined by <ZWJ> (U+200D), occupying 5 UTF-16 code units in JavaScript and 11 bytes in UTF-8:

Grapheme clusters (UAX #29): 1   -> [ "👨‍💻" ]
Unicode scalar code points:  3   -> U+1F468 (Man) + U+200D (<ZWJ>) + U+1F4BB (Laptop)
UTF-16 code units (.length): 5   -> D83D DC68 + 200D + D83D DCBB
UTF-8 encoded bytes:         11  -> F0 9F 91 A8 + E2 80 8D + F0 9F 92 BB

Unicode Encoding Mechanics, Grapheme Boundaries, and Security Risks

Quick Answer: Unicode maps 1,112,064 valid scalar values across 17 planes into variable-width UTF-8 (1 to 4 bytes per RFC 3629) or UTF-16 (2 or 4 bytes via surrogate pairs per RFC 2781). Discrepancies between grapheme clusters, canonical normalization forms, and invisible bidi controls cause parser bugs and security vulnerabilities.

Scalar Values, UTF-8 Prefix Bits (RFC 3629), and UTF-16 Surrogates (RFC 2781)

The Unicode codespace spans U+0000 through U+10FFFF across 17 planes of 65,536 code points each. Excluding the 2,048 reserved surrogate positions (U+D800 to U+DFFF), exactly 1,112,064 Unicode scalar values exist:

  • UTF-8 encodes Plane 0 Basic Latin (U+0000 to U+007F) in 1 byte (0xxxxxxx), U+0080 to U+07FF in 2 bytes (110xxxxx 10xxxxxx), remaining Basic Multilingual Plane (BMP) characters (U+0800 to U+FFFF) in 3 bytes (1110xxxx 10xxxxxx 10xxxxxx), and supplementary astral planes (U+10000 to U+10FFFF) in 4 bytes (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx). Because continuation bytes always begin with 10, UTF-8 is self-synchronizing and never contains null (0x00) bytes inside non-null characters.
  • UTF-16 represents BMP scalar values directly as one 16-bit code unit. Characters from U+10000 to U+10FFFF subtract 0x10000 to yield a 20-bit offset (0x00000 to 0xFFFFF), splitting the upper 10 bits into a lead/high surrogate (0xD800 to 0xDBFF) and the lower 10 bits into a trail/low surrogate (0xDC00 to 0xDFFF). UTF-16BE serializes the most significant byte first (D8 3D DC 80), whereas UTF-16LE reverses byte order within each 16-bit unit (3D D8 80 DC).

Canonical Equivalence (UAX #15) and Grapheme Segmentation (UAX #29)

Visually identical text frequently has different underlying byte representations. Under Unicode Standard Annex #15, é can be stored in Normalization Form C (NFC) as precomposed U+00E9 (UTF-8 C3 A9) or in Normalization Form D (NFD) as base U+0065 (e) followed by U+0301 (COMBINING ACUTE ACCENT, General Category Mn, UTF-8 65 CC 81). macOS file systems normalize filenames toward NFD shapes while Linux, Windows, and browser form submissions default to NFC—causing naive byte-wise string comparisons, S3 object key lookups, and HMAC checks to fail unless normalized first.

Similarly, slicing strings by UTF-16 index (str.slice(0, 10)) can sever a high surrogate from its low surrogate (producing lone unpaired surrogates that serialize to U+FFFD replacement characters in UTF-8) or split a base character away from its combining diacritics, variation selectors (U+FE0E, U+FE0F), or regional flag indicators (U+1F1E6 to U+1F1FF). User-perceived characters must be segmented along UAX #29 extended grapheme cluster boundaries.

Trojan Source (`CVE-2021-42574`) and UTS #39 Confusables

Two classes of characters in Unicode pose acute application-security hazards:

  1. Bidirectional Overrides (Cf): Code points U+202A through U+202E (<LRE>, <RLE>, <PDF>, <LRO>, <RLO>) and isolates U+2066 through U+2069 (<LRI>, <RLI>, <FSI>, <PDI>) instruct text renderers to reverse display order without altering logical memory order. Attackers use unterminated bidi controls to disguise active conditional checks inside comments or string literals (CVE-2021-42574).
  2. Homoglyph Spoofing (UTS #39): Cross-script lookalikes (U+0430 Cyrillic а, U+03BF Greek ο, U+FF21 Fullwidth A) allow adversaries to forge deceptive domain names (IDN homograph attacks), shadow variables in source code (CVE-2021-42694), or bypass keyword blocklists.

Unicode Character Inspector vs Sibling Text and Encoding Tools

Quick Answer: Use Unicode Character Inspector to audit a string character by character for hidden control codes, homoglyphs, and byte sequences. Use ASCII Reference Table for static 0 to 255 code lookups, Unicode Converter for bulk text-to-codepoint conversion, or Unicode Escape Tool for language-specific escape literals.

Choose the right utility in the character and encoding cluster based on whether you are diagnosing an unknown string, looking up a standard byte chart, or transforming string literals for source code:

Capability Unicode Character Inspector ASCII Reference Table Unicode Converter Unicode Escape Tool
Primary Workflow Per-character diagnostic audit of pasted strings or files Interactive reference chart for byte codes 0–255 Bulk conversion between text, code points, and byte arrays Escaping and unescaping source-code string literals
Hidden & Bidi Warnings Highlights <ZWSP>, <BOM>, <NBSP>, and Trojan Source bidi codes Lists C0 (0–31, 127) and C1 (128–159) control codes Encodes control codes numerically without security badges Converts non-ASCII characters to visible \uXXXX escapes
Homoglyph Detection Flags cross-script UTS #39 lookalikes and smart punctuation Covers 7-bit US-ASCII and ISO-8859-1 Latin-1 only No confusable script analysis No confusable script analysis
Grapheme vs UTF-16 Diff Shows UAX #29 graphemes, scalar points, UTF-16 units, and UTF-8 bytes Fixed 1-byte (8-bit) table rows Outputs full UTF-8, UTF-16, and UTF-32 streams Preserves or pairs UTF-16 surrogates (\uD83D\uDE80 vs \u{1F680})
Language Escape Syntax Displays raw hex code points (U+XXXX) and byte values Shows C/JS escapes, caret notation (^M), and HTML entities Formats hex/decimal code point lists Dedicated JS, JSON, Python, CSS, Rust, and HTML escape modes
  • Switch to the ASCII Reference Table when you need a fast lookup chart for 7-bit US-ASCII (0–127) and Extended Latin-1 (128–255) binary bitmasks, octal codes, and terminal caret notation.
  • Use the Unicode Converter when you want to batch-convert an entire block of text into continuous U+XXXX lists or UTF-8/UTF-16/UTF-32 hexadecimal streams.
  • Use the Unicode Escape Tool when preparing or decoding \uXXXX, \u{XXXXX}, \xXX, or CSS \XXXXXX sequences for JSON payloads and source files, or open the Character Counter when checking copy against SEO meta tag and SMS GSM-7/UCS-2 segment limits.
FAQ

Invisible Character Inspector FAQ and Technical Guide

Everything you need to know about using Utiliome's free online unicode character inspector.

Why does JavaScript String.length return 2 or more for a single visible character?

JavaScript, Java, and C# measure string length in 16-bit UTF-16 code units rather than Unicode scalar values or UAX #29 extended grapheme clusters. Any character outside the Basic Multilingual Plane (above U+FFFF, such as U+1F680 Rocket) requires a high and low surrogate pair, giving it a .length of 2. Composite emoji sequences joined with U+200D Zero Width Joiner (<ZWJ>) and U+FE0F Variation Selector-16 combine multiple scalar values into one visual glyph, often producing .length values between 5 and 11.

Which invisible Unicode characters most commonly break JSON, YAML, and source code?

The four most common culprits are U+00A0 No-Break Space (<NBSP>, frequently typed by accident via Option+Space on macOS, breaking YAML indentation and SQL parsers), U+FEFF Byte Order Mark (<BOM>, embedded mid-stream when concatenating files saved by Windows editors), U+200B Zero Width Space (<ZWSP>, copied from rich-text docs, PDFs, or chat apps into API tokens), and typographic smart quotes (U+201C and U+201D) replacing ASCII straight quotes (U+0022).

How do I detect Trojan Source bidirectional override attacks in code snippets?

Trojan Source (CVE-2021-42574) exploits nine Unicode General Category Cf bidirectional control characters—U+202A (<LRE>), U+202B (<RLE>), U+202C (<PDF>), U+202D (<LRO>), U+202E (<RLO>), U+2066 (<LRI>), U+2067 (<RLI>), U+2068 (<FSI>), and U+2069 (<PDI>)—to visually reorder source tokens so executable statements appear commented out during human review. Pasting suspicious code into the inspector reveals every hidden bidi code point at its exact character index.

Why do two visually identical accented strings fail strict equality checks?

Unicode allows multiple canonically equivalent representations under UAX #15. For example, 'é' in Normalization Form C (NFC) is a single precomposed scalar value U+00E9 (UTF-8 bytes C3 A9), whereas in Normalization Form D (NFD) it consists of two scalar values: U+0065 ('e') followed by Combining Acute Accent U+0301 (UTF-8 bytes 65 CC 81). Inspecting both strings exposes the differing code point sequences so you can apply .normalize('NFC') before hashing or comparison.

Is pasted text or uploaded data transmitted to any server?

No. Character segmentation, code point extraction, UTF-8 and UTF-16LE/BE byte calculation, and confusable homoglyph checks run entirely in your browser using native client-side JavaScript APIs. API keys, production logs, and private source snippets remain strictly in local memory.