Upside Down Text Generator

Reverse plus lookalike substitution

The illusion of upside-down text is built from two operations. First, the input string is reversed character by character so the last letter of each line ends up first. Second, each ASCII letter is swapped for a Unicode codepoint whose glyph visually resembles the rotated form: a for ɐ (U+0250), e for ǝ (U+01DD), g for ƃ (U+0183), and so on. Letters whose rotated form is itself (l, o, s, x, z) keep the same glyph.

Inputs are lowercased first because most lookalike substitutes only exist for the lowercase alphabet. HELLO becomes oʅʅǝɥ: the H drops to lowercase before mapping. Mirror-pair punctuation like ? and ! use the Spanish opening forms ¿ and ¡, which are the canonical inverted versions. Brackets swap (( -> )) because reversal naturally inverts their direction.

The output is real Unicode, not a CSS rotate. It pastes into Instagram, Twitter, Discord, and TikTok bios and posts without any styling. Because the substitutes come from scattered Unicode blocks, screen readers will spell each one out by its formal name, which is often surprising.

How to use upside down text generator

1Paste or type your text into the input panel on the left.
2The flipped result appears in the output panel as you type.
3Click Copy in the output header to copy the result.
4Paste it into a bio, display name, or post body.
5For a horizontal flip without rotation, use the mirror text generator instead.

Keyboard shortcuts

Drive TextResult without touching the mouse.

Shortcut	Action
`Ctrl` `F`	Open the find & replace panel inside the input Plus
`Ctrl` `Z`	Undo the last input change
`Ctrl` `Shift` `Z`	Redo
`Ctrl` `Shift` `Enter`	Toggle fullscreen focus on the editor Plus
`Esc`	Close find & replace, or exit fullscreen
`Ctrl` `K`	Open the command palette to jump to any tool Plus
`Ctrl` `S`	Save current workflow draft Plus
`Ctrl` `P`	Run a saved workflow Plus

What this tool actually does

Reverse the input string

The whole input is read in code-unit order, then reversed. hello world becomes dlrow olleh internally before letter substitution. Line breaks are kept in place; only the characters within each line are reversed.

Lookalike letter map (lowercase only)

Each lowercased letter is swapped via a hand-picked Unicode lookalike. Examples: a -> ɐ (U+0250), e -> ǝ (U+01DD), f -> ɟ (U+025F), g -> ƃ (U+0183), i -> ᴉ (U+1D09), m -> ɯ (U+026F), n -> u (and back), r -> ɹ (U+0279), v -> ʌ (U+028C), y -> ʎ (U+028E).

Punctuation that has a flip

? -> ¿ (U+00BF), ! -> ¡ (U+00A1), . -> ˙ (U+02D9), , -> '. Brackets swap orientation: ( -> ), [ -> ], { -> }. Other punctuation passes through unchanged.

Capitals lowercased first

There is no full inverted-capitals alphabet in Unicode. The tool calls toLowerCase() before mapping, so HELLO and hello produce the same flipped output. If you need uppercase styling, run the result through bold with the bold serif variant after flipping.

Not a CSS rotation

The output is plain Unicode characters. There are no styling tags, no transforms, no images. That is why it pastes into bios and chat. The downside: screen readers spell each codepoint out, and a small handful of glyphs (the inverted-i U+1D09) may render awkwardly in older fonts.

Worked example

Each line is reversed independently, then each letter is swapped for its Unicode lookalike. The ? at the end of "What?" becomes ¿ at the start of the flipped line.

Input

hello world
What?

Output

plɹoʍ ollǝɥ
¿ʇɐɥʍ

Settings reference

Behaviour	Effect on output
Letter mapping	Lowercased input, each letter swapped via a hand-picked Unicode lookalike. `a` -> `ɐ`, `e` -> `ǝ`, `g` -> `ƃ`, `n` -> `u`, etc.
Self-flipping letters	`l`, `o`, `s`, `x`, `z` map to themselves because their rotated form is the same glyph.
Reversal	Each line is reversed character by character before substitution.
Punctuation with flips	`?` -> `¿`, `!` -> `¡`, `.` -> `˙`, `,` -> `'`, brackets swap.
Capital letters	Lowercased before mapping. Output is always lowercase lookalikes.
Digits and emoji	Pass through unchanged. Digit lookalikes do exist in some Unicode blocks but are not part of this map.
Whitespace	Spaces pass through. Line breaks are preserved (only intra-line characters reverse).

FAQ

Is this real rotated text?

No. Each "flipped" letter is a separate Unicode codepoint whose glyph happens to look like an inverted ASCII letter. The substitutes come mostly from the IPA and Latin Extended blocks. There is no CSS rotation involved, which is why the output survives copy-paste through web inputs.

Why are my capitals flipped as lowercase?

Unicode does not include a full set of inverted capital letters. The tool lowercases input before substitution to land in the only alphabet that has any coverage. HELLO and hello produce the same flipped string.

Will this work in my Instagram bio?

Yes. Instagram, Twitter, TikTok, Discord, and Reddit all accept these Unicode codepoints in bios and post bodies. The IPA and Latin Extended blocks have shipped on every modern OS for years.

Why does the inverted-i look slightly off?

The inverted-i character is U+1D09 (Latin small letter turned i, ᴉ). Most fonts render it as a turned i with the dot below the line, but a few older fonts draw it without the rotation. The ? -> ¿ and ! -> ¡ punctuation swaps render universally.

How do I get the original text back?

There is no clean reverse. Lookalike characters do not normalize via NFKC because they are not compatibility decompositions of ASCII letters; they are independent codepoints. To recover, you would have to undo the lookalike map by hand and reverse the string. Save the original input separately if you need it.

Also known as

upside down text generator flip text upside down upside down text copy paste flipped text generator turn text upside down inverted text generator rotate text 180 upside down letters copy paste