You paste a username into a Discord bio and it overflows the box with symbols crawling above and below every letter. A friend sends you a message that looks genuinely corrupted, characters stacking vertically past the line boundaries, text appearing to break down at the rendering level.
This is hacked text, and it works through Unicode combining characters rather than anything related to actual code execution or the visual style produced by the hacker typer. Both create a "technical breakdown" aesthetic, but through completely different mechanisms. Hacked text is a Unicode edge case. This guide covers what the combining characters are, why the style is called Zalgo, how generators produce it, and where the visual actually works versus where it gets filtered out.
What Is Hacked Text?
Hacked text is standard text with Unicode combining diacritical marks layered onto each base character. Under normal circumstances, combining characters add a single accent to a base letter: the acute accent (U+0301) turns an e into é, the macron (U+0304) produces ā, the cedilla (U+0327) produces ç. These are legitimate typographic marks used across hundreds of languages.
The hacked text technique stacks them in volume. Instead of adding one or two combining marks per character, a generator adds twenty, thirty, or fifty. Unicode does not limit how many combining characters can be applied to a single base character. Most rendering engines honor that and try to display them all, stacking the marks above and below the base character until they overflow the line height and bleed into adjacent lines.
The result looks like a rendering error or data corruption, but it is technically valid Unicode. Every character in a hacked text string has a defined code point. The visual chaos is a consequence of rendering an edge case that the Unicode specification permits but that text layout engines were not designed to handle gracefully.
What Is Zalgo Text and Where Did It Come From?
The name "Zalgo" comes from a 2004 webcomic by Dave Kelly. The strip featured a distorted image with corrupted text underneath, and "ZALGO" appeared as the corrupted caption. The image spread as an early internet horror meme, appearing unexpectedly across forums as a joke about something disturbing hiding beneath normal content.
The style of corrupted, overflowing text became associated with the character because it matched the visual language of the meme: something ordinary that had been fundamentally broken at a structural level. By 2008 and 2009, generators producing Unicode-overflowed text were called "Zalgo generators" and the name spread. Now Zalgo text refers to any maximum-intensity combining character output.
Not all hacked text is Zalgo text. Light combining character stacks produce a subtle glitch effect without overflowing line boundaries. Zalgo specifically refers to the variant where the stacking is heavy enough to make the text visually unintelligible and to overflow beyond the character's normal vertical space. The distinction matters when you are choosing intensity: a mild glitch reads as stylized, while maximum Zalgo reads as corrupted and is often unreadable.
How Unicode Combining Characters Actually Work
Unicode is organized into blocks of code points. The combining diacritical marks block runs from U+0300 to U+036F and contains 112 characters: grave accent, acute accent, circumflex, tilde, macron, overline, breve, dot above, diaeresis, and dozens more. These are not spacing characters. Each one attaches to the preceding base character.
A second block, the combining diacritical marks supplement (U+1DC0 to U+1DFF), adds 64 more. Hacked text generators draw from the main block and sometimes the supplement, applying a random selection from the available 112 to 176 combining marks per character.
The number of marks per character controls the visual intensity:
- 2 to 5 marks per character: subtle accent effect, slightly unusual but readable
- 5 to 15 marks: noticeable glitch, vertical overflow becomes visible
- 15 to 30 marks: strong Zalgo effect, text becomes difficult to read
- 30 or more marks: maximum corruption, text is essentially unreadable as characters
The hash generator uses cryptographic functions to produce fixed-length output from arbitrary input — the output length is the same regardless of what you put in. Hacked text has no fixed output length. The more combining marks you add, the longer the rendered text string becomes, even though the underlying base characters remain the same count. The base64 encoder and decoder is another example of a transformation with a predictable output ratio: every 3 bytes of input become 4 characters. Hacked text has no such ratio because the intensity is configurable and random.
Why Hacked Text Looks Different on Each Platform
The same hacked text string can look dramatically different depending on where you paste it.
Discord applies Unicode normalization to message content. High stacks of combining characters get reduced or stripped, which is why heavy Zalgo text in Discord often appears with reduced combining marks or as plain text. This is intentional behavior to prevent layout disruption in chat channels.
Twitter and X allow combining characters with moderate stack depth. Text with 5 to 10 combining marks per character usually renders. Text with 30 or more marks per character may be truncated or have the excess marks removed during processing before display.
Instagram is more permissive in bios and comments. Zalgo text with heavy stacking often renders fully in Instagram bios, which is why the effect appears frequently in gaming and streetwear account profiles.
WhatsApp applies its own sanitization in the chat view. Heavy combining character stacks often display as spacing anomalies rather than the intended overflow.
Web browsers render hacked text exactly as the Unicode standard describes. This is why Zalgo text in HTML produces the full intended visual including line overflow. The overflow behavior in HTML can cause layout problems if the text is inside a container with overflow: hidden set.
The normalization form that strips combining characters is NFKC (Normalization Form Compatibility Decomposition, followed by Canonical Composition). Platforms that apply NFKC normalization to input before storing or displaying it remove excess combining characters automatically.
What Is the Difference Between Hacked Text and Leet Speak?
Leet speak, also spelled l33t speak, is a substitution cipher that replaces letters with visually similar numbers and symbols. A becomes 4, E becomes 3, T becomes 7, S becomes 5, O becomes 0. The form was used in early internet gaming communities as an in-group signaling system and to evade basic keyword filters by spelling words in ways that were readable to humans but invisible to simple text matching.
Leet speak produces readable text with no rendering anomalies. Every character in a leet speak string is a standard ASCII character. The text displays identically in every app and renders at normal line height.
Hacked text is unreadable at high intensity and relies entirely on Unicode combining character behavior for its effect. A leet speak string is a cipher where the meaning survives. A hacked text string is a Unicode edge case where the visual degrades as intensity increases.
Both are sometimes described as "hacker fonts" or "hacker text" in casual usage, which conflates two techniques that work through completely different mechanisms. For other text transformations and encoding work, the developer tools section has relevant utilities.
Where the Hacked Aesthetic Comes From
The corrupted text visual is part of a broader aesthetic built around systems appearing to fail or be compromised. It shares visual DNA with glitch art, the green terminal look explored in the hacker aesthetic and green code guide, and the general visual language of media that depicts hacking as chaotic and visually overwhelming.
Glitch art as a movement intentionally exploits errors in digital media encoding — compression artifacts, bit errors, corrupted video headers — to produce images that look damaged or in transition between states. Hacked text applies the same principle to typography by exploiting a Unicode rendering edge case.
The practical effect is that hacked text reads immediately as "something has gone wrong here," which makes it useful for horror content, cyberpunk and dystopian design work, and any context where you want to signal technical disruption visually. It does not communicate actual hacking any more than the hacker typer executes real code when you type into it. Both trigger the same cultural association with systems under stress, built through decades of film and media that established the visual vocabulary for what "hacked" is supposed to look like.
How to Generate Hacked Text
Most people use a browser-based Zalgo or hacked text generator. These tools take your input, apply a configurable number of combining diacritical marks to each character, and return a copyable Unicode string. Most offer three intensity levels: mini (1 to 5 marks per character), normal (5 to 15), and maximum (15 or more).
When choosing intensity, check the normalization behavior of your target platform before committing. Maximum Zalgo pasted into a platform that applies NFKC normalization produces plain text with no visual effect.
You can also generate hacked text in JavaScript without any external library:
const combiningMarks = [
0x0300, 0x0301, 0x0302, 0x0303, 0x0304, 0x0305,
0x0306, 0x0307, 0x0308, 0x0309, 0x030A, 0x030B,
0x030C, 0x0323, 0x0324, 0x0325, 0x0326, 0x0327
];
function hackedText(input, intensity = 10) {
return [...input].map(char => {
let result = char;
for (let i = 0; i < intensity; i++) {
const mark = combiningMarks[Math.floor(Math.random() * combiningMarks.length)];
result += String.fromCodePoint(mark);
}
return result;
}).join('');
}
The intensity parameter controls how many combining marks are added per character. Spreading the input string with [...input] handles multi-byte characters correctly, which matters when the input contains emoji or characters outside the basic multilingual plane.
To reverse hacked text and strip the combining marks back to plain text, apply NFKC normalization:
const plain = corruptedString.normalize('NFKC');
This is the same normalization form that platforms like Discord apply automatically. Calling it yourself lets you clean hacked text input before storing it in a database or displaying it in a context where the overflow would cause layout issues.
For design mockups where you need the full Zalgo visual without platform stripping, screenshot the output in a browser where Unicode rendering is most faithful. This avoids the platform normalization problem entirely and gives you complete control over the final appearance.
The developer tools collection has tools for encoding transformations and text format conversion for other common development workflow tasks.
