A Windows char code lookup that reveals every Unicode scalar value in a string is the Unicode Encoder / Decoder: a local browser tool that iterates text by Unicode code point, keeps supplementary-plane characters as single values, and accepts U+XXXX or \u{...} tokens for decoding. On Windows this matters because the operating system ships with several partial solutions — Character Map, the Win+. emoji panel, Alt+X in Word, and the registry-tweaked Alt + numpad sequence — and none of them expose the full scalar sequence inside a string you have already copied or received. Character Map is the closest analogue, dating back to Windows 95, but it lists installed glyphs one at a time and never opens up a buffer to show what is in it. The tool below was built to fill exactly that gap.
Windows Has Tools for One Character — Not for Whole Strings
Every character-lookup facility that ships with Windows is designed around insertion, not inspection. Character Map (charmap.exe, present since Windows 95) lists installed glyphs alongside their U+ label and copies the selected glyph to the clipboard; it does not show what is in a string you have already pasted. Win + . opens the modern emoji picker for search and insert, but the underlying scalar values stay hidden. Alt + X inside Microsoft Word converts the four hex digits to the left of the caret into the matching character, which is convenient for typing yet useless for diagnosing what is already in a buffer. The Alt + numpad trick, enabled with a small registry edit, accepts a decimal or hex entry for one character at a time and only for code pages Windows has loaded.
| Windows method | What it shows | Where it stops |
|---|---|---|
| Character Map (charmap.exe) | One glyph with its U+ label | No view of the rest of a string or its sequences |
| Win + . Emoji panel | Emoji search and insert | Does not expose the code points it inserts |
| Alt + X (Microsoft Word) | Converts a four-digit hex prefix into the character | Requires Word; no paste-inspection |
| Alt + numpad (registry-enabled) | Decimal or hex entry, one character at a time | Limited to installed code pages; one character at a time |
| Unicode Encoder / Decoder (browser) | Every scalar value in the full string | Capped at 100,000 code points per run |
The pattern is identical in every case: Windows tools identify characters one at a time and leave multi-codepoint emoji, decomposed accents, and invisible characters invisible. A browser-based tool that iterates the whole string closes that gap.
Look Up Every Code Point in a String on Windows
Open the Unicode Encoder / Decoder in any modern browser on Windows — Edge, Chrome, or Firefox — and work through the following steps to see every scalar value in a string you have copied from another application, a log file, or a script output.
- Choose the text-to-code-points direction. The tool runs entirely in your browser, so nothing leaves the machine. Select the encoding direction labelled for turning text into code points; the decoding direction is the separate option covered below.
- Paste the exact Unicode string, including any invisible characters. Control characters, zero-width joiners, and other default-ignorable code points travel with the paste. A newline becomes U+000A and a zero-width joiner becomes U+200D, both visible in the output.
- Convert and inspect each U+ token. The output is rendered as uppercase U+ hexadecimal with a minimum of four digits, so ASCII A becomes U+0041. Supplementary-plane characters keep their full value: 😀 encodes as the single token U+1F600 rather than as two surrogate halves.
- Copy the U+ sequence. Use the copy action to take the tokens into a log, a bug report, or another diagnostic step. Token boundaries matter, especially when adjacent values could otherwise be mistaken for one longer hexadecimal number.
If you need the reverse operation — you already have U+ or \u{} tokens from documentation, source code, or a log entry — switch to decode mode and follow the next section.
Decode U+ and \u{} Tokens Back Into Text
Decode mode accepts tokens that begin with U+ or that use the JavaScript-style backslash-u notation, including the brace form for supplementary-plane values. Tokens may be separated by spaces, commas, or line breaks; the parser treats all three the same. Hexadecimal digits are case-insensitive, so U+00e9 and U+00E9 are equivalent.
The decode step validates every token before constructing output text. A token whose value lies outside U+0000 through U+10FFFF is rejected, and so is anything in the surrogate interval U+D800 through U+DFFF, which is reserved for UTF-16 code units and does not identify a standalone character. Missing prefixes and non-hexadecimal digits fail the same way: rather than silently substituting a replacement character, the tool surfaces the bad token so the input can be corrected. Only after every token passes scalar-value validation does the output text get assembled, which is what makes round-tripping reliable.
The brace form is essential for supplementary characters. Writing \u{1F600} produces 😀; writing \uD83D\uDE00 produces the same glyph via its UTF-16 surrogate pair, but those surrogate halves are not valid scalar tokens here and the decoder will refuse them. This is consistent with how ECMAScript's String.fromCodePoint is specified: scalar values are the right unit, not UTF-16 code units (ECMAScript String.fromCodePoint).
Why One Visible Symbol Can Hide Several Code Points
A code point is not the same thing as a user-perceived character. The visible emoji 👩💻, which a person sees as one symbol, contains three scalar values: U+1F469 (woman), U+200D (zero-width joiner), and U+1F4BB (laptop). Many flags, family emoji, skin-tone modifiers, and accented forms are sequences too. The tool does not claim to segment grapheme clusters; it shows the raw scalar sequence so you can see exactly what is in the string.
Accented letters offer another example. The precomposed é is the single scalar U+00E9. A visually identical but decomposed é is the pair U+0065 (e) followed by U+0301 (combining acute accent). Both render alike, both are valid Unicode, and both can show up in the same dataset. They are different scalar sequences, and searching or comparing them as equal will fail. The tool deliberately does not normalize; the difference is the diagnostic signal.
Hidden control and formatting characters surface the same way. A newline is U+000A, a carriage return is U+000D, a zero-width space is U+200B, and a zero-width joiner is U+200D. When text pasted from another source fails an exact comparison, looks wrong in a filename, or moves a cursor unexpectedly, the scalar sequence usually explains it. Showing these values explicitly is the value of running text through a code-point inspector.
Limits and What This Tool Does Not Cover
Three boundaries are worth knowing before relying on the output. First, the input is capped at 100,000 code points per run so rendering and copying stay responsive on a Windows laptop; a long document should be split or filtered before pasting. Second, the tool shows abstract code points, not UTF-8 bytes. The precomposed é is U+00E9, but its UTF-8 representation is the two bytes C3 A9, which is what protocols, file formats, and network payloads transmit. When the question is byte-level encoding, the UTF-8 Encoder / Decoder is the right tool. Third, the tool does not look up character names, scripts, confusable status, or language meaning, and it does not validate whether a sequence forms a recommended emoji or orthographic cluster; those are separate Unicode properties beyond reversible scalar conversion.
Normalization is intentionally not performed. A precomposed é and a decomposed e + combining acute accent are both accepted as-is so the difference remains visible. That exactness is what makes the output useful for diagnosing search, identifier, filename, and comparison problems on Windows systems where data has been moved between code pages, applications, and shells.
Used together, Windows' native insertion tools and a local code-point inspector cover both halves of the task: insert a special character with Character Map or Win + ., then run the resulting string through the encoder to verify exactly which scalar values were carried over.
If you're weighing options, URL Decode Cheat Sheet: Common Codes and Quick Fixes covers this in detail.