Introduction
Leetspeak, or 1337, is an internet writing system that replaces letters with numbers and special characters. It started on BBS systems in the 1980s among hackers and gamers. The name comes from "elite," written as "31337" or "1337." Type your text above and the tool converts it to leetspeak instantly. Three levels are available: light, medium, and hard. The decoder reverses the process using a best-effort heuristic. All processing runs in your browser, so nothing leaves your device.
What this tool does
- Encodes text into leetspeak at three levels. Light uses simple substitutions like A to 4 and E to 3. Medium adds more options like @ for A and $ for S. Hard uses complex ASCII art constructions like /-\ for A and |-| for H.
- Decodes leetspeak back to text using a best-effort heuristic. The decoder tries longer leet sequences first to avoid partial matches, then falls back to shorter ones.
- Cycles through replacement options for variety. When a letter has multiple replacements at the selected level, the encoder rotates through them rather than always picking the first.
- Shows the full mapping table for all 26 letters across all three levels in the settings panel.
- Preserves non-letter characters during encoding. Spaces, punctuation, and digits pass through unchanged.
- All encoding and decoding runs client-side. No text is sent to any server.
How this tool works
The encoder iterates over each character of the input. It uppercases the character and looks it up in the leet mapping table. Each letter has an array of replacement strings for the selected level. The encoder cycles through the options using a counter, so repeated letters get different replacements when multiple options exist. Non-letter characters pass through unchanged. The decoder scans the input left to right. It maintains a lookup table of all leet sequences across all levels, sorted by length descending. At each position, it tries to match the longest leet sequence first. This prevents partial matches: |-| for H is checked before | for I. When a match is found, the corresponding letter is appended and the scanner advances past the matched sequence. Unmatched characters pass through unchanged. The mode and level settings sync to URL query parameters so you can share a link that preserves your configuration.
How leetspeak works
Leetspeak originated on Bulletin Board Systems (BBS) in the 1980s. According to the Wikipedia article on Leet, the practice began as a way to bypass text filters on BBS and early internet forums. System operators would block words like "hacker" or "elite," so users substituted numbers and symbols for letters. The word "elite" became "31337" (E to 3, L to 1, T to 7), which was then shortened to "1337." The Jargon File, a glossary of hacker slang maintained since the 1970s, documents early leetspeak usage.
Eric S. Raymond compiled and edited "The New Hacker's Dictionary," published by MIT Press in 1996. The book is a print version of the Jargon File and documents leetspeak alongside other hacker writing conventions. Raymond describes leetspeak as part of a broader culture of linguistic play among early internet users. The Wikipedia article on the Jargon File traces its origins to the Tech Model Railroad Club at MIT in the late 1950s and its later expansion through ARPANET and Usenet.
Leetspeak has three recognized levels. Light leet uses simple numeric substitutions: A becomes 4, E becomes 3, O becomes 0. The result is readable with some effort. Medium leet adds symbol substitutions: A can become @, S can become $. Hard leet uses ASCII art constructions that bear visual resemblance to the original letter: H becomes |-|, M becomes /\/\, W becomes \/\/. Hard leet is nearly unreadable to untrained readers. The ambiguity of leetspeak makes decoding difficult. The number 1 can represent I or L. The number 0 can represent O or D. This tool's decoder resolves ambiguity by checking longer sequences first and using the first match in its lookup table.
How to use this tool
- Select the mode: "Text to Leetspeak" to encode, or "Leetspeak to Text" to decode.
- If encoding, choose the level: light for simple numeric substitutions, medium for more symbol options, or hard for ASCII art constructions.
- Type or paste your text in the input field. The output updates instantly as you type.
- In encode mode, each letter is replaced with its leet equivalent. The encoder cycles through available replacements for variety. Non-letter characters pass through unchanged.
- In decode mode, the scanner tries longer leet sequences first, then shorter ones. Unmatched characters pass through unchanged.
- Use the swap button to switch between encoding and decoding without retyping. Copy the result using the "Copy result" button.
Real-world examples
Encoding a gamer username
A user types "GAMER" in medium level. The tool looks up each letter. G becomes 6, A becomes @ (the second option at medium level, since the encoder cycles), M becomes /\/\, E becomes 3, R becomes |2. The output reads "6@/\/\3|2". The user copies this and uses it as a stylized username on a gaming forum. In light level, the same input would produce "64/\/\3|2" with simpler substitutions for some letters.
Encoding at hard level
Someone types "HACK" in hard level. The tool produces "|-|/-\(|<". H becomes |-|, A becomes /-\, C becomes < (the third option at hard level), K becomes |<. The result is nearly unreadable to someone unfamiliar with leetspeak. This is the intended effect of hard level: it obscures the text visually while remaining decodable to those who know the mappings.
Decoding an ambiguous leet string
A user pastes "1337" into decode mode. The decoder scans left to right. It tries 1 first, which maps to I (the first match in the lookup table). Then 3 maps to E. The second 3 maps to E again. Then 7 maps to T. The output reads "IEET." The user expected "LEET" because 1 can also represent L. This ambiguity is inherent to leetspeak. The decoder picks the first match in its table, which is I before L. Users who need L should check the mapping table and adjust their expectations.
Comparison with similar methods
| Method | Complexity | Typical use |
|---|---|---|
| Leetspeak (light) | Low | Simple numeric substitutions, gamer tags, forum posts |
| Leetspeak (medium) | Low | Mixed numeric and symbol substitutions, decorative text |
| Leetspeak (hard) | Medium | ASCII art constructions, heavily obfuscated text |
| Emoji cipher | Low | Replacing letters with emoji, novelty encoding |
Limitations or considerations
Leetspeak is a writing convention, not encryption. Anyone familiar with the substitutions can read it. The decoder is best-effort because leetspeak is inherently ambiguous. The number 1 can represent I or L. The number 0 can represent O. The decoder resolves these by checking longer sequences first and using the first match in its lookup table, which may not always match the encoder's intent. The hard level uses ASCII art that depends on monospace rendering. In proportional fonts, constructions like /-\ for A may not align visually. The mapping table covers the 26 English letters. Accented characters and non-Latin scripts pass through unchanged. For actual encryption, use the AES block cipher. For other text transformation tools, try the Emoji cipher, the Pig Latin translator, the Zalgo text generator, or the T9 decoder.
Frequently asked questions
Where did leetspeak come from?
Leetspeak originated on Bulletin Board Systems (BBS) in the 1980s. Users replaced letters with numbers and symbols to bypass text filters that blocked words like "hacker" and "elite." The word "elite" became "31337," then "1337." Eric S. Raymond documented the practice in "The New Hacker's Dictionary" (1996, MIT Press), a print version of the Jargon File. The Jargon File itself traces back to the Tech Model Railroad Club at MIT in the late 1950s.
Why is decoding leetspeak difficult?
Leetspeak is ambiguous. The number 1 can represent I or L. The number 0 can represent O. The symbol | can represent I or L. This tool's decoder resolves ambiguity by checking longer leet sequences first (so |-| for H matches before | for I) and using the first match in its lookup table. This means the decoder may not always produce the text the encoder intended, especially for strings heavy in numbers like "1337."
What is the difference between light, medium, and hard levels?
Light level uses simple numeric substitutions: A becomes 4, E becomes 3, O becomes 0. The result is readable with effort. Medium level adds symbol substitutions: A can become @, S can become $. Hard level uses ASCII art constructions: H becomes |-|, M becomes /\/\, W becomes \/\/. Hard leet is nearly unreadable to untrained readers. The encoder cycles through available options at each level for variety.
Is leetspeak a real cipher?
No. Leetspeak is a writing convention, not a cipher. It provides no security because the substitution table is public and fixed. Anyone who knows the mappings can read it. It was originally used to bypass text filters, not to encrypt data. If you need actual encryption, use a real cipher like AES or a Vigenere cipher with a strong key.
Why does the encoder produce different replacements for the same letter?
When a letter has multiple replacement options at the selected level, the encoder cycles through them using a counter. The first A becomes 4, the second A becomes @ (at medium level), the third A becomes 4 again. This produces visual variety in the output. If you want consistent replacements, use the light level, where most letters have only one option.
Conclusion
The leetspeak translator converts text to 1337 and back across three levels. Pick your level, type your text, and copy the result. For more text transformation tools, try the Emoji cipher, the Pig Latin translator, the Zalgo text generator, or the T9 decoder.