The leet speak translator above swaps letters for the digits and punctuation marks that resemble them, which is the whole of what leet is. It works in both directions, offers three levels of aggression, and reports whether the specific text you typed can be recovered afterwards.
That last feature is the reason Arb Digital built this rather than another one-way novelty converter. Leet is a substitution scheme, and substitution schemes are only reversible when the mapping is one to one. The moment both i and l become the digit 1, information is gone, and no decoder can get it back. The tool makes that visible instead of pretending otherwise, and the level selector lets you stay inside the reversible subset if you need the round trip to work.
What This Leet Speak Translator Does
Level 1 uses six substitutions chosen because each has a unique reverse: a becomes 4, e becomes 3, i becomes 1, o becomes 0, s becomes 5 and t becomes 7. Nothing else changes. Encode any text at this level and decode it again and you get the original back exactly, provided the original contained no digits that now look like substitutions, which the tool checks for you.
Level 2 is the classic form most people picture. It adds b as 8, g as 6, z as 2 and, critically, l as 1. That last one is why the canonical spelling of the word is 1337 rather than l337, and it is also the moment the scheme stops being reversible, because 1 now stands for two different letters. The decoder has to pick one, and it picks whichever produces the more common reading, which will sometimes be wrong.
Level 3 abandons single characters entirely for the letters that have no digit lookalike. The letter m becomes a pair of slashes and backslashes, w becomes another arrangement of the same, h becomes a hash, k becomes a pipe and an angle bracket. This is the form that turns a short word into a long string of punctuation, and decoding it requires matching the longest sequences first or the output dissolves into fragments.
How to Use It
- Set the direction before you paste. Encoding treats your input as ordinary text, decoding treats it as leet, and getting this backwards produces confident nonsense.
- Choose a level. Stay on level 1 if anything downstream needs to read the original back. Move up if you want the look rather than the reversibility.
- Type or paste your text. Everything with no mapping at the chosen level passes through untouched, including digits, punctuation, spaces and non-Latin characters.
- Check the round trip indicator. It says yes only if encoding then decoding this exact text returns it character for character.
- Copy the result. The copy button takes the output line, not the input, so you can chain conversions without retyping.
The Formula: How the Substitution Works
Encoding is a straight per-character table lookup. For each character of the input, if the lower-case form appears in the level's map, emit the replacement; otherwise emit the character unchanged. Case is not preserved for substituted letters, because a digit has no case.
Decoding is longest-match-first. The decoder sorts every replacement string by length, longest first, and at each position tries to match one of them before falling back to copying the character. Sorting matters: if a two-character sequence starts with a character that is itself a single-character replacement, matching the short one first would consume half a glyph and corrupt everything after it.
Work the default at level 1. The input is "leet speak translator". The letters e, s, t and a have mappings, l and the rest do not, so the output is "l337 5p34k 7r4n5l470r". Decoding that string reverses each mapping uniquely and returns "leet speak translator" exactly, so the round trip indicator reads yes. Switch to level 2 and l also becomes 1, giving "1337 5p34k 7r4n51470r"; decoding now has to guess what each 1 was, it reads them all as i, and the round trip indicator correctly reads no.
Leet Is Not Obfuscation, and Certainly Not Security
The single most important thing to say about leet is that it hides nothing. The substitutions are public, there are perhaps a dozen of them, and any filter written after about 1998 normalises them before matching. Using leet to slip a word past a moderation system, a keyword filter or a search index works for roughly as long as it takes someone to add six lines to a normalisation table.
The same applies to passwords, and this is where the belief does real harm. Turning "password" into "p455w0rd" adds no meaningful strength, because every password-cracking wordlist has applied the standard leet mutations to every dictionary word for decades. The substitution is deterministic, so it multiplies the search space by one, not by anything. NIST Special Publication 800-63B, Digital Identity Guidelines: Authentication and Lifecycle Management, moves away from composition rules of exactly this kind, advising that verifiers should not impose rules requiring mixtures of different character types, and instead emphasises length and screening against known-compromised secrets. If you want to see what actually moves the number, the password entropy calculator shows how much length buys compared with clever substitution, and the password generator produces strings that were never a dictionary word to begin with.
The Serious Cousin: Homoglyph Spoofing
Leet's harmless letter-swapping has a genuinely dangerous relative. Replacing a Latin letter with a visually identical character from another script produces a string that looks the same to a reader and is entirely different to a computer, which is the basis of domain-name and identifier spoofing attacks.
Unicode Technical Standard #39, Unicode Security Mechanisms, is the document that addresses this. It defines confusable detection, using a skeleton transformation to compare strings that render alike, along with identifier profiles and mixed-script detection, precisely because visually identical strings are a spoofing risk in domain names, email addresses and program identifiers.
This tool deliberately stays in the ASCII sandbox: every replacement it produces is an ordinary digit or punctuation mark, so nothing it emits is a homoglyph attack. If you want text that looks styled but is built from alternative Unicode characters, the fancy text generator does that job explicitly, and it is worth understanding that such text is not searchable, not screen-reader friendly and not the same characters you typed.
Where Leet Came From, and Why the Mapping Is Not Fixed
Leet grew out of bulletin-board culture in the 1980s, where filtering and status-signalling both pushed users toward deliberate misspelling, and it spread through early online gaming. It has never had a standard. There is no committee, no specification and no canonical table, which is why two leet translators frequently disagree about the same word.
That matters practically. If you encode with one tool's level 3 mapping and decode with another's, the result is garbage, because the two disagree about whether r is 2 or a pipe and a 2, whether g is 6 or 9, and whether a is 4 or a slash-hyphen-backslash. This page documents its own tables in the level descriptions so you can see exactly what it will do, and it stays conservative at every level for that reason. A scheme with no standard cannot be interoperable, and pretending otherwise sets up a failure that only appears once your text is already converted.
For comparison, schemes that do have fixed definitions behave completely differently. The ROT13 encoder and decoder and the Caesar cipher translator both apply a fixed alphabet rotation that reverses exactly, and the Morse code translator follows a published international standard. Leet has none of that, and it is the only one of the four that can lose information.
Arb Digital builds free tools like this one because useful pages earn attention. If you want tools, calculators or content built for your own audience, we can help.
Browse All Free Tools Talk to Arb DigitalCommon Mistakes to Avoid
- Expecting level 2 or 3 to round-trip — once one character stands for two letters the original is unrecoverable, and the indicator will tell you so.
- Using leet in a password — cracking wordlists applied these substitutions decades ago, so the mutation adds no real strength.
- Assuming it evades filters — normalising leet is a handful of lines of code and every serious filter already does it.
- Encoding text that already contains digits — a 4 you typed yourself is indistinguishable from an a that was converted, which breaks decoding.
- Mixing tools — there is no standard leet table, so text encoded elsewhere may not decode here and vice versa.
Related Free Tools From Arb Digital
For reversible letter transformations with a fixed definition, use the ROT13 encoder and decoder or the Caesar cipher translator. The letters to numbers converter maps letters to alphabet positions rather than lookalikes, and the Pig Latin translator rearranges words instead of swapping characters. Change capitalisation with the case converter, flip text with the upside down text generator or the reverse text generator, and check length with the character counter. Everything else is in the free online tools hub.
Frequently Asked Questions
Because at the higher levels one character stands for more than one letter. The digit 1 represents both i and l in the classic mapping, so a decoder has to guess which was meant. Level 1 on this page avoids every such collision, which is why it reverses exactly.
No. The substitutions are a short fixed list, and password-cracking wordlists have applied them to every dictionary word for decades. Turning a word into its leet form multiplies the search space by essentially nothing. Length and unpredictability are what matter.
There is not. Leet grew out of bulletin-board and gaming culture without any specification, so different tools disagree about several letters. This page documents its own three tables so you can see exactly what it does rather than assuming compatibility with another converter.
Not for long, and usually not at all. Normalising the common substitutions before matching takes a few lines of code, and filters have done it for many years. Treat leet as a style, not as evasion.
Leet uses ordinary digits and punctuation, so the result is visibly altered and harmless. Homoglyph spoofing substitutes characters from other scripts that render identically, producing a string that looks unchanged but is different underneath. Unicode Technical Standard 39 exists to detect the second kind.
Because a digit you typed deliberately is indistinguishable from a digit that replaced a letter. If the input already contained a 4, the decoder cannot tell it apart from a converted a, and the round trip indicator will report that the text does not survive.
It encodes your text and immediately decodes the result, then compares that against what you typed, character for character. It reads yes only on an exact match, so it reflects your specific text rather than a general claim about the level.
Because letters with no digit lookalike are drawn out of punctuation instead. The letter m becomes four characters, w becomes four, and a short word can triple in length. The decoder handles it by matching the longest sequences first, before any single-character replacement.
