NFC vs NFD: Unicode Normalization Explained

Quick Answer: NFC vs NFD

Use NFC for storage, APIs, HTML, search indexing, and most production text handling. Use NFD only when you intentionally need decomposed characters for analysis, accent stripping, or compatibility with systems that store decomposed filenames. If you are unsure, choose NFC.

What Unicode Normalization Is

Unicode normalization converts equivalent strings into a consistent form so visually identical text behaves consistently in code, search, storage, and comparison. Without normalization, two strings that look the same on screen can fail equality checks because they are stored as different code-point sequences.

The most common comparison is NFC vs NFD. NFC keeps characters in composed form where possible. NFD decomposes them into base characters plus combining marks. Both are valid Unicode. They are not interchangeable unless you normalize them first.

Composed vs Decomposed: Visual Code Point Comparison

The character "e with acute accent" can be stored two ways in Unicode. Both render identically on screen, but they are different byte sequences.

More complex characters have larger differences. The Korean syllable "ga" in NFC is a single code point (U+AC00), while in NFD it decomposes to three code points (U+1100 U+1161). Characters with multiple combining marks, like "o with diaeresis and macron," can decompose to three or more code points.

NFC vs NFD Side by Side

Comparison summary: NFC is the default form for storage, indexing, APIs, and most web application text. NFD is mainly useful when you intentionally need decomposed characters for analysis or accent stripping.

NFKC and NFKD: Compatibility Normalization

Beyond NFC and NFD, Unicode defines two compatibility forms: NFKC and NFKD. These replace compatibility characters with their canonical equivalents in addition to composing or decomposing.

Compatibility normalization folds characters that are semantically equivalent but visually distinct. Examples include:

• Fullwidth digits: １ (U+FF11) becomes 1 (U+0031)
• Ligatures: fi (U+FB01, fi ligature) becomes fi (two characters)
• Superscripts: ² (U+00B2) becomes 2 (U+0032)
• Circled letters: Ⓐ (U+24B6) becomes A (U+0041)

Use NFKC when you need maximum folding for search or identity comparison. Do not use it for display or storage where the visual distinction matters, because the normalization is lossy and cannot be reversed.

When to Use NFC

• Database storage: normalize user input before insert and comparison
• Search indexing: avoid missed matches on accented text
• API payloads: keep signatures, checksums, and comparisons consistent
• Slug generation: normalize before transliteration in the URL Slug Generator
• General web content: use NFC as the safe default for production text

When to Use NFD

• Accent stripping: decompose first, then remove combining marks
• Character-level analysis: inspect combining marks directly
• Special compatibility cases: work with systems that already store decomposed text

Normalization in Databases

Most databases store Unicode text as raw bytes and do not normalize on write. This means your application is responsible for normalization.

Cross-Platform Normalization Differences

Operating systems handle filename normalization differently, which causes bugs in cross-platform applications and file-syncing tools.

If your application handles files across platforms, normalize filenames to NFC before storing paths in a database or performing lookups.

W3C and WHATWG Recommendations

The W3C Character Model specification recommends NFC for all web content. WHATWG specifications for HTML and the URL standard also assume NFC. Specifically:

• HTML documents should use NFC for text content. The HTML spec does not enforce this, but mixed forms cause interoperability issues with search, indexing, and comparison.
• URLs use percent-encoding for non-ASCII characters. The URL standard expects the text to be NFC before percent-encoding. Encoding NFD text produces longer URLs with different byte sequences for the same visible characters.
• Form submissions send text as-is. If a user's browser submits NFD text (common on macOS), the server receives NFD unless it normalizes on ingestion.

When Not to Mix Forms

Do not keep mixed NFC and NFD strings in the same database, index, or comparison workflow. That creates subtle bugs: duplicate-looking values, failed lookups, incorrect length checks, and inconsistent slugs. Normalize at input boundaries and normalize again before equality-sensitive comparisons if necessary.

Common Bugs Caused by Mixed Forms

Bug summary: Mixed normalization forms most often break lookup consistency, regex behavior on accented text, character counts, and slug output across systems.

Code Examples

JavaScript

const composed = "\u00E9";
const decomposed = "e\u0301";

console.log(composed === decomposed); // false
console.log(decomposed.normalize("NFC") === composed); // true

function normalizeForStorage(value) {
  return value.normalize("NFC").trim();
}

// NFKC for search indexing (folds ligatures, fullwidth, etc.)
function normalizeForSearch(value) {
  return value.normalize("NFKC").toLowerCase().trim();
}

Python

import unicodedata

composed = "\u00E9"
decomposed = "e\u0301"

print(composed == decomposed)  # False
print(unicodedata.normalize("NFC", decomposed) == composed)  # True


def normalize_for_storage(value):
    return unicodedata.normalize("NFC", value).strip()


# NFKC for search indexing
def normalize_for_search(value):
    return unicodedata.normalize("NFKC", value).casefold().strip()


# Accent stripping via NFD
def strip_accents(value):
    nfd = unicodedata.normalize("NFD", value)
    return ''.join(c for c in nfd if unicodedata.category(c) != 'Mn')

FAQ

Related Tools

• Text Analysis Tool to inspect text length and spot suspicious character-count behavior
• URL Slug Generator to create clean slugs after normalization
• URL Encoder / Decoder to inspect encoded Unicode in URLs and query strings
• Remove Line Breaks to clean copied text before further normalization work
• Regex Tester Online to test regex patterns on normalized text

Related Guides

• utf8proc NFC Normalization in C for implementing normalization in C projects
• Hidden Unicode Characters Guide for detecting and removing invisible characters
• Regex Debugging Guide for troubleshooting patterns that interact with Unicode text