Decrement Code Points

A unique number assigned to each Unicode character (range: U+0000 to U+10FFFF, about 1.1 million possible values). ‘A’ = U+0041 (decimal 65), ‘B’ = U+0042 (66), ‘é’ = U+00E9 (233), ‘中’ = U+4E2D (20013), ‘🌍’ = U+1F30D (127757). The tool subtracts your offset from each character’s code point. With offset 1: ‘B’ (66) → ‘A’ (65).

It’s clamped to U+0000 (NULL character). NOT wrapped (the original FAQ said “may wrap around” – that’s wrong). So ‘A’ (65) − 100 = U+0000, NOT some negative code point or a wraparound to U+10FFFF. The stats card shows how many code points were clamped, which lets you tell when your offset is too large.

Code points U+D800 through U+DFFF are RESERVED for UTF-16 surrogate halves and cannot represent actual characters. If your decrement lands a code point in this range (e.g., starting from U+E000 and subtracting 1 would land at U+DFFF), the tool snaps to U+D7FF (one below the gap) instead. This is necessary because String.fromCodePoint throws RangeError on surrogate values when called with a single code point in that range. The stats card shows how many surrogate-skips happened.

The rainbow flag 🏳️‍🌈 is FOUR code points joined visually: U+1F3F3 (white flag) + U+FE0F (variation selector) + U+200D (zero-width joiner) + U+1F308 (rainbow). When you decrement each by 1, you get U+1F3F2 (white pennant) + U+FE0E (text variation selector) + U+200C (zero-width NON-joiner) + U+1F307 (sunset). The visual rendering breaks completely – you see 4 separate symbols, not a shifted flag. Same problem for family emoji (👨‍👩‍👧‍👦), professional emoji (👩🏽‍💻), and combining accents (é as e + ◌́). This is INTENTIONAL behavior – the tool operates on code points by design. If you need grapheme-aware shifting, the math doesn’t really make sense conceptually (what would “shift the whole grapheme by 1” mean?).

Cyclic shift (iter 415) rotates the ORDER of characters in a string – “ABCDE” shifted left by 2 becomes “CDEAB”. The characters don’t change, just their positions. This tool shifts each character’s code point value by an offset – “ABCDE” with offset 1 becomes “@ABCD” (each one letter earlier). Both have legitimate use cases; pick based on whether you want to rearrange or to substitute.

For toy ciphers and pedagogy: yes. Caesar cipher (offset 3 in the alphabet) is literally a code-point decrement on letters. For real encryption: absolutely NOT. Caesar ciphers can be broken by frequency analysis in seconds. The tool offers zero cryptographic strength. For genuine encryption, use AES via the Web Crypto API (crypto.subtle.encrypt). This tool is for: text puzzles, escape rooms, learning about Unicode, demoing simple substitution ciphers in CS classes.

Use the same offset with a NEGATIVE sign here (which becomes an increment), OR use the companion tool “Increment Code Points” with the same positive offset. They’re inverse operations. If you decremented by 5 and then increment by 5: original text restored, UNLESS some characters were clamped (those went to U+0000 and can’t be recovered).

A negative offset becomes an increment. offset = -3 means “shift each code point UP by 3”. Useful for symmetric calculations and undoing decrements without switching tools. The surrogate-skip logic flips correctly (snap to U+E000 instead of U+D7FF when incrementing past the gap).

Yes. All shifting happens in your browser using native codePointAt and String.fromCodePoint. Text never leaves your device.