About

Leet speak (also written as 1337 or l33t) is a character substitution cipher originating from 1980s bulletin board systems. It replaces Latin characters with visually similar numerals, symbols, or Unicode glyphs. The substitution is non-standardized. A single character like A can map to 4, @, /\, or /-\ depending on the encoding depth. This ambiguity makes automated decoding nontrivial. Naive reverse lookups fail when multi-character sequences like |< (representing K) collide with individual pipe | (representing L or I). This tool resolves collisions by applying longest-match-first decoding.

The converter operates across 4 encoding tiers. Basic performs only unambiguous single-character swaps. Ultra applies multi-glyph digraphs and Unicode homoglyphs. Decoding accuracy degrades at higher tiers because the mapping becomes many-to-one. For instance, both O and D can produce () at the ultra level. The decoder uses tier-specific priority tables to minimize misreads. Limitation: the tool assumes English Latin input. Accented characters, Cyrillic, or CJK pass through unmodified.

Formulas

The encoding function E maps each character c in input string S through a tier-specific substitution table T_k, where k ∈ {1, 2, 3, 4} represents the leet level:

E(S, k) = n∏i=1 T_k(c_i)

where the product operator here denotes string concatenation, and n = |S| is the length of the input. If c_i ∉ dom(T_k), the character passes through unchanged.

Decoding uses the inverse map T_k⁻¹ with a greedy longest-match algorithm. At each position i, the decoder tests substrings of decreasing length m from m_max down to 1:

{

T_k⁻¹(S[i..i+m]) if match foundS[i] otherwise (passthrough)

Where m_max = 4 for the Ultra tier. This greedy approach has time complexity O(n ⋅ m_max) which is effectively linear.

Reference Data

Character	Basic	Intermediate	Advanced	Ultra
A	4	@	/\	/-\
B	8	\|3	13	\|>
C	(	<	[	{
D	\|)	cl	[)	\|>
E	3	&	[-	€
F	\|=	ph	/=	ƒ
G	6	9	&	(_+
H	#	\|-\|	]-[	}{
I	1	!	\|	][
J	_\|	;	_/	_]
K	\|<	\|{	]{	\|X
L	1	\|_	£	\|_
M	/\/\	\|\/\|	^^	(V)
N	\|\\|	/\/	[\]	{\}
O	0	()	[]	Ø
P	\|*	\|°	\|>	\|"
Q	0_	(_,)	<\|	9
R	\|2	12	/2	®
S	5	$	§	ehs
T	7	+	"]["	†
U	\|_\|	(_)	µ	[_]
V	\/	\|/	\\|	\\//
W	\/\/	VV	\^/	(n)
X	><	}{	)(	><
Y	`/	¥	-/	j
Z	2	~/_	7_	%

Frequently Asked Questions

Higher tiers introduce many-to-one mappings. For example, at the Advanced level both K and P can map to |>. The decoder uses a priority table favoring statistically more common English letters, but ambiguity is inherent. For reliable round-trip encoding and decoding, use the Basic tier where mappings are mostly bijective.

Yes. The substitution table is case-insensitive - both uppercase and lowercase characters map to the same leet output. Original case information is lost during encoding. When decoding, all output defaults to lowercase since the leet representation carries no case data.

They pass through unmodified. The substitution map only covers the 26 Latin letters A - Z. Digits 0-9, spaces, punctuation marks, emoji, and Unicode characters outside the Latin alphabet are preserved in their original form in both encoding and decoding directions.

The tool processes up to 10,000 characters per conversion. This limit prevents browser tab freezing on extremely large inputs. For typical use cases (usernames, phrases, short paragraphs), this is more than sufficient. The conversion runs in O(n) time and completes in under 5 milliseconds for inputs at the limit.

Leet speak substitution provides zero cryptographic security. The transformation is a simple substitution cipher that can be reversed trivially. Automated password crackers include leet speak dictionaries (e.g., p@$$w0rd) as standard rule sets. Do not rely on leet encoding for password strength. Use a proper password manager with randomly generated credentials instead.

Characters with no visually similar single numeral or symbol require multi-glyph combinations. M, N, W, and H are common examples. At the Basic level, these may use 2-3 characters. At the Ultra level, sequences can reach 4+ characters, substantially increasing output string length relative to the input. Expect output length to be roughly 1.5× to 3× the input length depending on the tier selected.