Unicode notation guide: every way to write U+00E9

The letter é, code point U+00E9, has more aliases than most suspects. In a Unicode document it appears as U+00E9. In a C header it is 0xE9. In JavaScript it is \u00E9, in an HTML file é or é, in a stylesheet \00E9, and in a URL it dissolves into %C3%A9. Every one of these strings, pasted into the Unicode converter, decodes to the same single character:

U+00E9    -> é
0xE9      -> é
\u00E9    -> é
\u{E9}    -> é
\xE9      -> é
é    -> é
é    -> é
é  -> é
\00E9     -> é
%C3%A9    -> é

Ten spellings, one character. This guide maps each notation to the grammar that owns it, because the number 233 only means é inside a specific set of rules.

U+00E9: the Unicode standard's own notation

Appendix A of The Unicode Standard defines the convention: an individual code point is written U+ followed by four to six hexadecimal digits, using the digits 0-9 and uppercase letters A-F. Leading zeros are omitted unless the value would have fewer than four digits, so it is U+00E9, never U+E9 and never u+00e9. The Unicode Character Database uses the same numbers without the prefix, which is why a lookup of 00E9 in UnicodeData.txt returns the formal name LATIN SMALL LETTER E WITH ACUTE, block Latin-1 Supplement, general category Ll.

This is the only notation in the list that names a code point and nothing else. It does not belong to any programming language, file format or wire protocol, so nothing around it can change its meaning. When you report a bug or write a spec, U+00E9 is the spelling that survives every copy-paste.

0xE9: just a number in C-style syntax

The 0x prefix is the hexadecimal integer literal from C, now shared by C++, Java, JavaScript, Python, Rust and most other languages. It denotes the number 233 and says nothing about characters at all. Whether 0xE9 means é depends entirely on context: as a code point it is é, but as a byte in a UTF-8 file it is an error, because é in UTF-8 is the two-byte sequence C3 A9. As a byte in Latin-1 it is é again, which is exactly the ambiguity that makes 0x treacherous in text discussions. The number is unambiguous; its role is not.

\u00E9 and \u{E9}: programming language escapes

In JavaScript and Java, \u00E9 is an escape with exactly four hex digits, and it names a UTF-16 code unit, not a code point. For é the two coincide, because U+00E9 fits in one 16-bit unit. The difference shows up above U+FFFF: U+1F600 in four-digit form is the surrogate pair \uD83D\uDE00, a lead surrogate (also called high surrogate) followed by a trail surrogate (also low). ECMAScript 2015 added \u{1F600}, which names the code point directly and takes one to six hex digits.

Rust borrowed the braced form. \u{E9} is the only Unicode escape Rust accepts, and the value must be a Unicode scalar value: a code point that is not a surrogate. Ask for \u{D83D} and the compiler rejects it, because a surrogate alone is not a character Rust will store in a char.

\xE9 and \x{E9}: byte-era shorthand

In JavaScript, \xE9 takes exactly two hex digits and produces the code unit 0x00E9. The form dates from the era when one byte was one character, so it cannot reach anything above 0xFF: there is no \x1F600. Perl owns the same syntax with different semantics. There \xE9 takes up to two hex digits and denotes code point 0xE9, while \x{E9} with braces accepts any number of digits and reaches the full codespace. Same characters on the keyboard, two different grammars.

é, é and é: markup character references

HTML and XML offer numeric character references in decimal (é) or hexadecimal (é), and both name the code point directly with no length limit. HTML also keeps a list of named references, so é works in any HTML document. XML only predefines five names (amp, lt, gt, quot, apos), so a named entity like é in raw XML needs a DTD declaration or it fails to parse. One practical detail: the converter's Hex NCRs panel pads to four digits and emits é, which parses identically to é. Padding is cosmetic here, not structural.

\00E9: the CSS escape, and its greedy appetite

CSS Syntax Level 3 defines an escape as a backslash followed by one to six hex digits, optionally followed by a single whitespace character that the parser consumes as a terminator. So \E9, \00E9 and \0000E9 all decode to é. The catch is greediness: the parser takes as many hex digits as it can, up to six. Write \E9c intending é followed by the letter c, and you get U+0E9C LAO LETTER PHO SUNG instead, because c is a hex digit and gets absorbed into the number. That is why the converter's CSS panel emits \00E9 with a trailing space: the space ends the escape and is eaten by the parser, leaving the letter after it intact.

%C3%A9: the odd one out

%C3%A9 is the only entry that is not a code point notation. Percent-encoding, defined for URIs in RFC 3986, quotes bytes, and the bytes being quoted are the UTF-8 form of é (RFC 3629, now STD 63). Two percent-encoded bytes stand for one code point. This is the notation to remember when decoding form submissions and URLs, and the one most often mangled: treating each %XX as a separate code point is how %C3%A9 turns into the mojibake é. The converter's percent panel decodes the byte sequence as UTF-8, so %C3%A9 becomes é, while feeding the single byte %E9 through a UTF-8 decoder is invalid and only makes sense under Latin-1.

Nine of these notations name a code point. The tenth names two bytes. Knowing which one you are looking at is the whole game.

Why U+ wins every argument

Each of the other spellings borrows digits into a grammar that can bend them. CSS eats following hex digits. JavaScript splits code points above the BMP into surrogate pairs. \x means a code unit in one language and a code point in another. Percent-encoding quotes bytes instead of characters. The U+ convention has no such context: uppercase prefix, four to six uppercase digits, one code point, done. When precision matters, in bug reports, standards citations and code reviews, write U+00E9 and let every reader map it into their own grammar.

Field checklist

• Unknown notation in front of you? Paste it into the converter's main input; it recognizes all ten forms and shows the characters panel verdict.
• In CSS, always terminate short escapes with a space or pad to six digits, or the next character becomes part of the number.
• In JavaScript, reach for \u{...} so emoji and historic scripts stay one code point instead of two code units.
• In URLs, remember the unit is the byte: one code point can hide behind two, three or four %XX groups.
• When writing anything meant to last, use U+ notation. It is the only spelling defined by the standard itself.