ROT47 is self-inverse across the 94 printable ASCII characters from code point 33 to 126, so the same operation that encodes a string also decodes it, and running it on the same input always produces the same output. Because the rotation distance of 47 is exactly half the size of the character set of 94, each supported character maps to a unique partner, and applying ROT47 twice moves every value through the full 94-position cycle back to its starting point. There is no key, no seed, no session state, and no toggle between modes, which means a single deterministic rule determines the result every time. Any implementation that applies 33 plus the quantity (value minus 33 plus 47) modulo 94 to code points in the printable ASCII interval will produce identical output for identical input. That reproducibility is the foundation of every reliable workflow with the ROT47 Encoder Decoder, and it is also why copying the output into another system can subtly change the result if that system reinterprets punctuation or line endings.
The Fixed Rule Behind Every Identical Result
ROT47 works on a narrow, well-defined slice of the Unicode table: the 94 characters whose code points sit between 33 (the exclamation mark) and 126 (the tilde). The official Unicode Basic Latin chart documents these values, and the implementation iterates Unicode code points one at a time using the approach described in the ECMAScript specification for String.prototype.codePointAt. For each character that falls inside the interval, the tool computes the rotated value; for every code point outside the interval, the tool copies the original code point without normalization. There is no random component, no per-session salt, and no optional behavior to enable. Two separate runs of the ROT47 Encoder Decoder on the same input always produce the same output, because the only variable is the text itself.
This determinism is what lets you "repeat the same result" without saving the output anywhere. If you paste the string Hello, World! into the field today and apply ROT47, the result is the same string you would get tomorrow, on a different browser, or on another machine. The mapping is fixed by the printable ASCII interval and the constant offset of 47. As long as the input is identical and the intermediary that holds it does not silently modify characters, the transformation is reproducible by hand using nothing more than the constant 47 and a printable ASCII lookup table.
Reproduce the Same Output Every Time
The exact procedure for getting the same ROT47 result on demand is short and unambiguous. Because the tool has only one operation, the same three steps cover both encoding and decoding, and there is no need to remember any setting between sessions.
- Paste the exact text you want to transform into the input field, including any spaces, tabs, or line breaks you want preserved in the output.
- Select Apply ROT47 and copy the resulting printable-ASCII substitution from the output area.
- To reproduce the original from a ROT47 string, paste the output back into the input field and select Apply ROT47 once more — no separate decoder is needed.
The second pass exists because ROT47 is its own inverse. The same button handles both directions, and the output of step 2 can always be reconstructed from scratch by following the three steps again with the original input. If you ever need to verify a saved result, paste the original text and apply the operation again; you will see the same substitution character for character.
What ROT47 Transforms and What It Preserves
Not every character is rotated. The tool is explicit about its interval so that implementations with different preservation choices cannot produce silently different results. The table below summarizes the only behavior you should expect from a faithful ROT47 implementation.
| Character category | Code point range | ROT47 behavior |
|---|---|---|
| Space | 32 | Copied unchanged |
| Printable ASCII (letters, digits, punctuation, symbols) | 33 to 126 | Rotated by 47 positions within the interval |
| Control characters (tabs, newlines, NUL, DEL) | 0 to 31 and 127 | Copied unchanged |
| Non-ASCII (accented letters, CJK, emoji) | 128 and above | Copied exactly without normalization |
This fixed rule is enough to reproduce every result independently. If a tool returns a different value for the same input, the divergence almost always traces back to one of two causes: the implementation rotated a code point outside the 33 to 126 interval, or the intermediary between your clipboard and the tool silently altered a character before the substitution ran. The mapping itself has no variability, so once you confirm the interval is correct, the rest is bookkeeping.
Why the Same Input Sometimes Produces Different Output
ROT47 itself never changes between runs, but the systems around it can. Several common interference patterns break reproducibility even though the algorithm is fixed:
- Smart-quote or em-dash substitution. A curly apostrophe (U+2019) falls outside the printable ASCII interval and is preserved unchanged, while the straight apostrophe U+0027 rotates. Two visually similar inputs give two different outputs.
- URL, HTML, or shell escaping. Pasting ROT47 output into a chat client, a forum post, or a shell command can change how punctuation is interpreted. Characters such as &, <, >, and " all rotate under ROT47, and a receiving system may convert them into entities or escape sequences before storage.
- Line-ending normalization. Windows-style CRLF and Unix-style LF line breaks live outside the rotation interval, but a copy operation that collapses or rewrites them changes byte counts and can shift what appears on either side of a line break in the output panel.
- Input size above the 200,000-code-point limit. The tool caps interactive conversion to keep copying responsive; a truncated paste produces a shorter output that does not match the result you would get from the full string.
If a repeated run looks wrong, verify that the intermediary has not escaped punctuation, converted smart quotes, or rewritten line endings. Those are the only realistic sources of variation; the algorithm itself is stable across browsers and sessions. A guided walk-through of these failure modes is available in the article on fixing a result that looks wrong after using ROT47.
Round-Trip the Original in a Single Action
The shortest way to confirm that a result is repeatable is to round-trip it. Take the output from the first pass, paste it back into the input field, and apply ROT47 once more. The output of the second pass should equal the original input character for character, because the self-inverse property guarantees that 47 plus 47 equals the full 94-character interval.
A concrete illustration with the letter A (code point 65):
- Step 1: 33 + ((65 − 33 + 47) modulo 94) = 33 + ((32 + 47) modulo 94) = 33 + (79 modulo 94) = 33 + 79 = 112.
- Step 2: 33 + ((112 − 33 + 47) modulo 94) = 33 + ((79 + 47) modulo 94) = 33 + (126 modulo 94) = 33 + 32 = 65.
Code point 65 is A, and 112 is p, so one pass turns A into p and the next pass turns p back into A. The math works the same way for every printable ASCII character in the interval, which is why the same operation that encodes a string also decodes it. There is no key, no mode switch, and no extra button.
For longer strings, the same round-trip pattern holds for every supported code point. Punctuation rotates, digits rotate, lowercase and uppercase letters all rotate, while the surrounding whitespace and any non-ASCII content stay fixed in their original positions. The output is deterministic, and the input can always be recovered by applying the operation once more. The same self-inverse logic is unpacked at greater length in the guide on whether ROT47 needs a separate decoder.