Fast, practical, browser-based developer tools
Reverse text instantly in your browser. This tool lets you reverse characters, reverse word order, or reverse lines for notes, snippets, formatting tasks, experiments, and text transformation workflows.
A text reverser is useful for quick formatting, playful transformations, string experiments, testing, and simple text-processing tasks. You can reverse the full character sequence, flip the order of words, or reverse the order of lines with one click.
This text reverser is designed to work directly in your browser during normal use. That makes it useful for quick local text transformations without requiring external software.
For more details about site usage and analytics, read our Privacy Policy.
Paste or type your text into the input box, choose the type of reversal you want, and get the transformed output instantly. You can then copy the result for your workflow.
Input: hello world Characters: dlrow olleh Words: world hello
"Reverse the characters" sounds like the simplest possible string operation, and for
plain ASCII it is. It is also the single most common way developers discover that a
JavaScript "character" is not what they think. The snippet everyone reaches for —
str.split('').reverse().join('') — is broken for anything outside
ASCII, because split('') splits on UTF-16 code units, not
on characters.
An emoji like 😀 lives above U+FFFF, so JavaScript stores it as
a surrogate pair: two 16-bit code units, a high one followed by a low one.
Reversing by code units swaps them into an invalid low-then-high order, producing lone
surrogates that render as the replacement character �. Reverse
"a😀b" that way and you don't get "b😀a" — you get a broken
emoji in the middle. This page is a hands-on demonstration of that distinction; its
character reversal deliberately avoids the split('') bug, as the next section
explains.
There is a ladder of correctness, and each rung fixes a different class of bug:
str.split(''). Splits surrogate pairs and
corrupts every astral character. Never use it to reverse text.[...str].reverse().join('') or
Array.from(str). The spread and Array.from iterate by code
point, so surrogate-pair emoji stay intact. This is what this tool's
Reverse Characters uses, which is why a plain 😀
survives here. It still splits combining marks off their base letter, though.Intl.Segmenter with
granularity: 'grapheme'. Collect the grapheme segments, reverse
that array, then join. This is the only fully correct reversal: it keeps
accented letters, emoji with skin-tone modifiers, flag emoji, and joined sequences
whole.
Even code-point reversal — the correct-looking middle rung — mangles combining marks. A
letter such as é can be stored in decomposed (NFD) form as two code points:
a base e followed by U+0301, a combining acute accent that
renders on top of whatever precedes it.
Reverse by code point and the order becomes accent-then-e, so the combining
mark re-attaches to the previous character instead of its own. Reverse a
decomposed café and the accent can end up floating over the wrong letter, or
over a space. The base letter and its marks have to move together as one unit — which is
exactly what a grapheme cluster is, and exactly what code-point reversal fails to respect.
Some emoji are built from several other emoji glued together. A family like
👨👩👧 is actually multiple person code points joined by
zero-width joiners (U+200D). Reverse it by code point and
the joiners land in the wrong places, so the single family shatters into separate people
in reversed order — the ZWJ sequence is destroyed.
Flag emoji have the same shape of problem: each flag is a pair of regional-indicator code
points, and reversing them either swaps the pair into a different country or breaks it
entirely. Only grapheme-cluster reversal via Intl.Segmenter keeps ZWJ
sequences and flags whole, because it treats each complete cluster as one indivisible
character.
These two operations get conflated, but they are different and produce different output.
Character reversal flips the entire sequence, so
hello world becomes dlrow olleh. Word-order
reversal keeps each word readable and only flips their sequence, so
hello world becomes world hello.
This tool offers both, plus line-order reversal, which flips the order of lines while preserving each line's own text — handy for inverting a chronological log or a stacked list. Pick the one that matches the structure you actually want to change: characters within a string, words within a sentence, or lines within a block.
Because the common one-liner str.split('').reverse().join('') splits on
UTF-16 code units, not characters. An emoji above U+FFFF is stored as
two code units (a surrogate pair), and reversing them puts the pair in an invalid
order, so it renders as �. Iterate by code point or grapheme cluster
instead.
Partly. The spread operator iterates by code point, so surrogate-pair emoji stay
intact — this is what fixes the basic 😀 case. But it still splits
combining accent marks off their letters and breaks zero-width-joiner sequences like
family emoji, so it is not fully correct.
Segment by grapheme cluster with Intl.Segmenter using
granularity: 'grapheme', collect the segments into an array, reverse that
array, and join it. Only this treats accented letters, emoji with modifiers, flags,
and ZWJ sequences as single units.
Because the text held a combining mark. In decomposed (NFD) form, é is a
base e plus a separate combining accent that attaches to whatever
precedes it. Reversing at the code-point level moves the accent ahead of its letter,
so it lands on the wrong character.
A family emoji is several person code points joined by zero-width joiners
(U+200D). Reversing by code point scatters the joiners, so the single
glyph breaks into individual people in reversed order. Grapheme-cluster reversal keeps
the joined sequence whole.
No. Character reversal flips the whole sequence
(hello world → dlrow olleh), while word-order reversal
keeps each word readable and only flips their sequence
(hello world → world hello). This tool provides both, plus
line-order reversal.