Upside down text is not rotated. It is a substitution cipher followed by a string
reversal, built from whatever glyphs Unicode happens to offer. We opened the map inside
our own upside down text generator and counted every entry, and the results explain why
flipped text looks convincing for some words and wrong for others.
The two-step transform
The tool runs two operations in a fixed order. First it substitutes each character
through a 78 entry map: 26 lowercase letters, 26 uppercase letters, 10 digits, and 16
punctuation marks. Then it reverses the entire string. Characters missing from the map
pass through the substitution unchanged and still get reversed.
The reversal matters because a 180 degree rotation reads bottom to top. Without the
reversal, flipped text would spell your words in the original order and read as
gibberish when rotated.
Fourteen characters that never change
Fourteen map entries point at the input character itself: lowercase l, o, s, x, and z,
uppercase H, I, N, O, S, X, and Z, and the digits 0 and 8. These shapes read the same
rotated 180 degrees, so the tool leaves them alone. They still move position when the
string reverses.
A word built entirely from these letters, such as osso or hiss, flips to another word
made of the same letters. This is the mechanic behind most upside down text party
tricks, and it fails the moment you add letters outside the set.
Borrowed glyphs from five other scripts
Unicode has no turned version of some Latin letters, so the map substitutes lookalikes
from elsewhere. The uppercase G maps to פ, a Hebrew letter pe. The digit 2 maps to ᄅ, a
Hangul letter rieul. The digits 4 and 7 map to ㄣ and ㄥ, Bopomofo characters. The digit
5 maps to ϛ, a Greek koppa. The uppercase V maps to Λ, a Greek capital lambda, and J
maps to ſ, the long s. F maps to Ⅎ, one of the few genuinely turned Latin forms in the
standard.
Other entries are ordinary letters doing rotation duty. The pairs b and q, d and p, n
and u, and m and w swap through plain letters or turned forms, so flipped text contains
real English letters in place of rotated ones. Anyone learning Hebrew, Korean, or Greek
will recognize characters from their own alphabets inside your flipped string.
The bracket double swap
Punctuation is the subtlest part of the map. The map itself swaps paired marks: opening
and closing parentheses, brackets, braces, and angle brackets exchange places, and the
period maps to an overhead dot. Then the string reversal runs. The swap and the reversal
cancel for paired brackets, which lands each bracket in the correct visual position.
Work it with the string (a). The map converts it to )ɐ(. The reversal produces (ɐ). The
parentheses read correctly around the flipped letter, without a single bracket-specific
position rule in the code.
Strikethrough and underline are combining marks
Two of the five effects append a combining character after every letter instead of
substituting. Strikethrough appends U+0336, the combining long stroke overlay.
Underline appends U+0332, the combining low line. Spaces are skipped, and the string is
never reversed.
The combining approach has a known failure mode: rendering depends on the font stacking
the mark over the correct base character. Long runs sometimes drift, and text engines
that reorder combining marks can place the stroke over a neighboring letter. If you need
exact strikeout placement, use a format with real formatting such as HTML or Markdown.
Zalgo by the numbers
The glitch effect stacks random combining diacritics from three pools: 48 marks above
the letter, 23 marks at middle height, and 40 marks below, for 111 marks total. The
intensity setting fixes how many marks each character receives:
| Intensity | Above | Middle | Below | Marks per character |
| Low | 1 | 0 | 1 | 2 |
| Medium | 3 | 1 | 3 | 7 |
| High | 8 | 3 | 8 | 19 |
A 10 character word at high intensity carries 190 combining marks on 10 base letters.
Spaces and line breaks receive no marks, so word boundaries stay clean.
The marks are chosen at random on every render, which produces two behaviors worth
knowing. Typing one more letter regenerates the marks on every character you already
converted. The tool ships a regenerate button that forces this re-roll on demand, and
what you copy is the current render, never a stable canonical form.
Where the tool breaks
All transforms in this component split the string into UTF-16 code units before
mapping and reversing. Emoji live outside the Basic Multilingual Plane and encode as
surrogate pairs, so splitting them apart produces invalid fragments. Paste an emoji and
run the mirrored effect, and the output contains two broken half-characters where the
emoji stood. The same applies to the flip path. Our bold text generator spreads the
string into code points instead, which is why it passes emoji through intact.
Screen readers are the other casualty. Combining mark stacking and phonetic borrowed
glyphs produce output that is silent, garbled, or read letter by letter in the wrong
order.
Checklist before you post flipped text
- Your text avoids emoji, because the reversal corrupts them.
- You accept that l, o, s, x, z, H, I, N, O, S, X, Z, 0, and 8 come through unchanged.
- You accept Hebrew, Hangul, Bopomofo, and Greek stand-ins for some letters.
- You use zalgo sparingly, because 19 marks per character overflows comment layouts.
- You do not need screen readers to parse the result.
- You copy immediately after generating zalgo, because the next keystroke re-rolls it.
Every rule above is deterministic in the code except the zalgo mark selection, which is
random by design.
Run your own string through the
[upside down text generator](https://webrecast.com/en/upside-down-text) and count the
characters that came through untouched. If your count disagrees with the fourteen listed
here, that is a real finding and worth reporting, because the number comes straight from
the map in the shipping code.
