Generate Zalgo Glitch Text with a Repeatable Seed
«Glitch me» at intensity 2 with seed 42 becomes G̺̀l̐̓i̬͆t̤̏c̲̎h̘̕ ḿ͂ë́̕, and it comes out exactly the same every time you repeat those settings. Pick from five levels, from a light ripple to a dense storm of marks. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- Glitch me
- Intensity
- 2
- Seed
- 42
- Text
- G̺̀l̐̓i̬͆t̤̏c̲̎h̘̕ ḿ͂ë́̕
Turn ordinary writing into distorted Zalgo glitch text while keeping the transformation predictable. Supply the source text, choose an intensity from one to five, and optionally set an integer seed. The generator adds Unicode combining marks above, through, and below visible characters without relying on random system state. The same text, intensity, and seed therefore produce exactly the same result every time, making the effect practical for repeatable designs, tests, usernames, captions, and creative prototypes.
Create a controlled glitch instead of an accidental one
Zalgo text works by placing Unicode combining marks after ordinary visible characters. Fonts normally use those marks for accents and related writing features, but a dense stack can extend above, through, and below a letter to create the familiar corrupted appearance. This generator chooses marks from all three positions and applies the exact number selected by the intensity setting to each non-whitespace character.
Level one adds a light disturbance that often remains easy to read, while level five produces a much denser texture. Spaces and line breaks are preserved, so the wording and basic layout remain recognizable. Existing combining marks are left untouched rather than decorated again, which prevents a supplied accent from becoming an unpredictable multiplier.
The result is still Unicode text rather than an image.
Use the seed to reproduce the same result
Many novelty text generators vary their output on every run, which is entertaining but inconvenient when a design, snapshot test, or campaign draft must be recreated later. Here, the seed is part of the input and drives a small deterministic number generator. When the source text, intensity, and seed are identical, the sequence of combining marks is identical too.
Change only the seed and you receive another visual variation with the same density; change the intensity and each eligible character receives a different fixed number of marks. The default seed is zero, so omitting it is still repeatable. A seed may be any safe integer, including a negative value, and it is treated consistently by the algorithm.
Record the three inputs alongside an approved output if reproducibility matters.
Choose an intensity that suits the destination
Start with intensity one or two when the words still need to be read quickly. Higher settings are better suited to horror graphics, experimental headings, fictional terminal corruption, or deliberate stress testing of text layouts. Combining marks can increase line height, overlap nearby interface elements, complicate cursor movement, and be announced awkwardly by assistive technology.
For that reason, keep an accessible plain-text version wherever the content carries essential meaning, and avoid using decorated text for passwords, addresses, commands, identifiers, search keys, or data that another program must parse. Test the output in the actual target application because operating systems, browsers, fonts, and social platforms may position, normalize, limit, or remove marks differently. The generator does not damage the source or replace its base characters; it returns a new string with marks inserted.
An out-of-range intensity is rejected instead of being silently clamped, so a configuration mistake is visible and repeatable rather than producing an unexpectedly mild or overwhelming result.
What you can do with it
Design a horror title
Create repeatable corrupted lettering for a poster draft, game screen, or fictional warning while retaining editable text.
Test Unicode rendering
Exercise line height, clipping, selection, and fallback fonts with a deterministic string containing stacked combining marks.
Prepare themed social copy
Generate several seeded variations, review them in the destination platform, and keep the seed for the selected version.
FAQ
What intensity values are supported?
Use an integer from 1 through 5. Values outside that range are rejected as invalid input.
Will the same seed always produce the same text?
Yes. The same text, intensity, and integer seed produce the same sequence of marks with this capability.
Does it replace my original letters?
No. It preserves each base character and inserts Unicode combining marks after eligible non-whitespace characters.
Why does the result look different in another application?
Fonts and text renderers position combining marks differently, and some platforms normalize or remove unusually dense marks.
Where should I avoid using Zalgo text?
Anywhere the words must be read or used reliably: passwords, addresses, commands, identifiers or search terms. The marks can raise line height, overlap nearby elements and sound garbled in screen readers, so keep a plain version of anything important.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/text/zalgo-glitch \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Glitch me","intensity":2}'const res = await fetch("https://api.kit.forhosting.com/text/zalgo-glitch", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Glitch me",
"intensity": 2
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/text/zalgo-glitch",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Glitch me",
"intensity": 2
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/text/zalgo-glitch", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Glitch me","intensity":2}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Glitch me","intensity":2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/text/zalgo-glitch", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"text": "Glitch me",
"intensity": 2
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "text.zalgo_glitch",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_tokens | 20000 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
Choose an intensity that suits the destination
API requests cost $0.002, while the browser version runs locally.
Technical questions
What does an API request cost?
Each API request costs $0.002. The browser version can run locally without an API request.