Unicode to UTF-16

UTF-16 Explained

UTF-16 (16-bit Unicode Transformation Format) is a variable-length character encoding for Unicode. See UTF-16 on Wikipedia.

Unicode's encoding space is divided into 17 planes, each containing 65,536 code points. The first plane is called the Basic Multilingual Plane (BMP, Plane 0); the remaining planes are called supplementary planes.

BMP vs Supplementary Planes

The BMP contains most commonly used characters (including the majority of CJK characters), while the supplementary planes contain emoji and other less common characters.

Encoding Process

1. Convert the character to its Unicode code point (e.g., str.codePointAt(0))
2. If the code point is less than U+10000, it maps directly to a single UTF-16 code unit
3. If the code point is U+10000 or greater, it is split into a surrogate pair: (codePoint - 0x10000) / 1024 + 0xD800 (high surrogate) and (codePoint - 0x10000) % 1024 + 0xDC00 (low surrogate)

For example, "🍉" has code point 0x1F349. Subtract 0x10000 to get 0x0F349. The high surrogate is 0xD83C and the low surrogate is 0xDF49.

Input Characters to View UTF-16 Encoding

Type any character or text into the input field, and the tool will display the corresponding UTF-16 encoding for each character. Results are shown in hexadecimal, making it easy to cross-reference with Unicode code points.

For characters in the Basic Multilingual Plane (BMP, U+0000 to U+FFFF), the UTF-16 encoding is the same as the Unicode code point itself. For example:

• A → 0041
• 中 → 4E2D
• © → 00A9

Understanding Surrogate Pairs

When a character's code point exceeds U+FFFF (i.e., it lies in a supplementary plane), UTF-16 cannot represent it with a single 16-bit code unit. Instead, it uses a surrogate pair:

• High Surrogate: range D800 – DBFF
• Low Surrogate: range DC00 – DFFF

For example, the character "𠮷" (code point U+20BB7) is encoded as D842 DFB7 in UTF-16, consisting of two code units.

The tool automatically labels which characters use surrogate pairs, helping you understand the encoding structure at a glance.

Emoji Encoding

Emoji are the most common use case for surrogate pairs. The vast majority of emoji have code points in the supplementary planes and therefore require two code units:

• 😀 (U+1F600) → D83D DE00
• 🎉 (U+1F389) → D83C DF89
• 🇨🇳 (flag, composed of two Regional Indicator symbols) → D83C DDE8 D83C DDF3

Some compound emoji (with skin tone modifiers, family sequences, etc.) contain even more code units. Combined with Zero-Width Joiners (ZWJ, U+200D), a single emoji can consist of a dozen or more code units.

Practical Applications in JavaScript

JavaScript strings are internally encoded as UTF-16. Understanding this helps you avoid common string handling pitfalls:

// length returns the number of UTF-16 code units, not characters
'😀'.length          // 2, not 1
'𠮷'.length          // 2, not 1
'hello'.length       // 5

// Use the spread operator or Array.from to split by character
[...'😀'].length     // 1
Array.from('𠮷')     // ['𠮷']

// charCodeAt returns a code unit, codePointAt returns the full code point
'😀'.charCodeAt(0)   // 55357 (0xD83D, high surrogate)
'😀'.codePointAt(0)  // 128512 (0x1F600, full code point)

When the tool shows that a character has been split into a surrogate pair, it means you need to take extra care when processing it with charAt and charCodeAt in JavaScript.

API

JavaScript

You can use iconv-lite for UTF-16 encoding and decoding in JavaScript:

// Encoding
iconv.encode(str, 'utf16')

// Decoding
iconv.decode(buffer, 'utf16')

Python

> 'hello'.encode('utf16').hex()
'fffe680065006c006c006f00'

> bytes.fromhex('fffe680065006c006c006f00').decode('utf16')
hello

FAQ

Q: What is the difference between UTF-16 and UTF-8?

Both UTF-8 and UTF-16 are encoding schemes for Unicode, but they use different strategies. UTF-8 uses a variable-length encoding of 1 to 4 bytes — ASCII characters require only 1 byte, while CJK characters require 3 bytes, making it ideal for English-heavy text and web transmission. UTF-16 uses 2 or 4 bytes — characters within the Basic Multilingual Plane (BMP) use 2 bytes, while characters outside the BMP (such as some emoji and rare CJK characters) use 4 bytes (surrogate pairs). UTF-16 is slightly more space-efficient for CJK-heavy text, but wastes double the space for pure ASCII text.

Q: What is a Surrogate Pair?

A surrogate pair is the mechanism UTF-16 uses to represent characters outside the BMP (Basic Multilingual Plane, U+0000 to U+FFFF). Unicode reserves U+D800 to U+DBFF as high surrogates and U+DC00 to U+DFFF as low surrogates. A high surrogate followed by a low surrogate forms a surrogate pair, which can represent characters in the range U+10000 to U+10FFFF. For example, the emoji "😀" has code point U+1F600 and is encoded in UTF-16 as the surrogate pair D83D DE00.

Q: Does JavaScript use UTF-16 for strings?

Yes, JavaScript internally stores strings using UTF-16 encoding. Each string element is a 16-bit code unit. For BMP characters, one code unit equals one character; for characters outside the BMP, two code units (a surrogate pair) are needed. This is why '😀'.length returns 2 instead of 1. ES6 introduced String.prototype.codePointAt() and the for...of iterator to correctly handle surrogate pairs and avoid splitting a single character into two code units.

Q: Why is an emoji's length 2?

Because most emoji have Unicode code points beyond the BMP range (greater than U+FFFF), they require two 16-bit code units (a surrogate pair) in JavaScript's UTF-16 encoding. The .length property returns the number of code units, not the number of characters, so a single emoji has a length of 2. More complex cases include compound emoji (like 👨‍👩‍👧‍👦), which are composed of multiple code points joined by Zero-Width Joiners (ZWJ) — their .length can be as high as 11. To get the true character count, use [...str].length or Intl.Segmenter.

Q: What is the difference between UTF-16LE and UTF-16BE?

LE and BE stand for Little-Endian and Big-Endian, respectively, referring to the byte order in multi-byte data. For the character "A" (U+0041), UTF-16BE stores it as 00 41 (high byte first), while UTF-16LE stores it as 41 00 (low byte first). Windows systems default to UTF-16LE, while network protocols more commonly use UTF-16BE. To indicate the byte order, files often include a BOM (Byte Order Mark) at the beginning: FE FF indicates big-endian, and FF FE indicates little-endian.