What does NFKC normalisation do?

NFKC stands for Normalization Form KC, or Compatibility Composition. It applies compatibility decomposition, which folds variants like ligatures and full-width letters into their plain forms, then recomposes combining marks into precomposed characters.

How is NFKC different from NFC?

NFC only handles canonically equivalent sequences and preserves the original characters. NFKC additionally collapses compatibility variants, so the ligature fi becomes the two letters f and i, and the full-width A becomes a normal A. NFKC can therefore change which characters appear.

When should I use NFKC?

Use NFKC for identifiers, usernames, search keys, and security checks where you want visually distinct but compatible forms to be treated the same. It prevents tricks like full-width or styled characters bypassing a filter.

It can be. Folding a superscript two into a normal digit two loses the superscript styling, and that cannot be reversed. Use NFKC for comparison and matching, not for round-tripping formatted text you need to preserve.

Does the tool send my text anywhere?

No. NFKC is applied with the browser's built-in String.prototype.normalize, so all processing is local and nothing is uploaded.

What is the Unicode NFKC Normaliser?

Normalise text to Unicode NFKC (Compatibility Composition), folding ligatures, full-width forms, superscripts and circled characters into plain equivalents, then composing marks. Runs in your browser. It runs free in your browser on Gera Tools, with nothing uploaded.

Unicode NFKC Normaliser

Name: Unicode NFKC Normaliser
Creator: Gera Tools
License: https://creativecommons.org/licenses/by/4.0/

NFKC (Normalization Form KC) is the most aggressive Unicode normalisation form. It goes beyond NFC’s canonical equivalence and additionally folds compatibility variants — full-width letters, ligatures, superscripts, circled characters, and styled look-alikes — into their plain equivalents, then composes combining marks. Use it when you want visually different but semantically equivalent text to be treated as the same string.

NFC vs NFKC: what is the difference?

Both forms handle combining marks. The key difference is compatibility decomposition:

Operation	NFC	NFKC
Compose `e` + `◌́` → `é`	Yes	Yes
Fold `ﬁ` → `fi`	No	Yes
Fold `Ａ` (full-width A) → `A`	No	Yes
Fold `²` (superscript) → `2`	No	Yes
Fold `①` (circled digit) → `1`	No	Yes
Fold `™` (trademark) → `TM`	No	Yes
Reversible	Yes	No

NFC only deals with canonical equivalence — two encodings of the same character. NFKC additionally handles compatibility equivalence — characters that have the same basic meaning but different visual presentation. This makes NFKC lossy: the original styling cannot be recovered.

What gets folded under NFKC

Full-width and half-width forms. Characters in the Halfwidth and Fullwidth Forms block (U+FF00–U+FFEF) — such as Ａ (U+FF21), ａ (U+FF41), １ (U+FF11) — are folded to their ASCII equivalents A, a, 1. These appear in East Asian text layout where characters occupy a full double-width cell.

Ligatures. ﬁ (U+FB01), ﬂ (U+FB02), ﬀ (U+FB00), ﬃ (U+FB03), ﬄ (U+FB04), ﬅ (U+FB05), ﬆ (U+FB06) all decompose into their constituent letters.

Superscripts and subscripts. Mathematical superscripts like ² (U+00B2), ³ (U+00B3), ¹ (U+00B9) and the full Superscript/Subscript block (U+2070–U+209F) fold to plain digits and letters.

Circled characters. ①–⑳, Ⓐ–Ⓩ and similar enclosed/circled variants fold to their base digits and letters.

Fraction forms. ½ (U+00BD) → 1⁄2, ¼ (U+00BC) → 1⁄4, and so on.

The security case for NFKC

Because compatibility variants are visually similar to plain text but technically different code points, they are used in homograph attacks and filter bypasses. A username ｅxample (with full-width ｅ) looks identical to example but is a different string. NFKC normalising usernames, email addresses, and search queries before comparison or storage prevents this class of attack.

Unicode Security Mechanisms (Unicode Technical Report #36) recommends NFKC (often combined with casefolding) as part of the standard preprocessing pipeline for identifiers.

How the tool works

NFKC is implemented via the browser’s native String.prototype.normalize("NFKC"), which applies the full Unicode compatibility decomposition mapping followed by canonical composition. The result can have more characters than the input (a two-character ligature becoming two letters) or fewer (combining sequences composing into precomposed forms).

Example

Input	NFKC output	What happened
`ﬁle`	`file`	ﬁ ligature → fi
`Ａpple`	`Apple`	Full-width A → A
`H₂O`	`H2O`	Subscript 2 → 2
`10²`	`102`	Superscript 2 → 2
`①②③`	`123`	Circled digits → digits
`e + ◌́`	`é`	Base + combining mark → precomposed

Because NFKC is not reversible, use it for matching and comparison, not for round-tripping display text you need to preserve. For canonical-only normalisation that keeps visual styling intact, use the NFC tool. All processing runs locally — nothing is uploaded.