The card grid looked perfect for three weeks. It was filled with lorem ipsum, three lines of it under every title, and the titles all sat neatly on two lines. Then the client sent the real German copy and the first product card read Betriebshaftpflichtversicherung. Thirty-one letters, one word, no place to break it. The title overflowed its box, the button under it slid down eight pixels, and only that one card in the row was wrong.
Nothing was broken in the CSS. The layout had simply never been shown a word longer than thirteen letters, because that is the longest word in the standard lorem ipsum passage. Its average word is 5.35 letters. Seven percent of its words reach ten letters. Real German copy runs past both of those numbers on the first line of the first paragraph, and it does it with characters, ä, ö, ü and ß, that Latin filler contains exactly none of.
Placeholder text is not there to fill a layout. It is there to test one. Text that behaves like the copy you will actually ship finds the box that is too narrow, the heading that wraps to three lines, the excerpt that runs past the fade, and it finds them while the design is still cheap to change.
The generator below makes text you can test with: three vocabularies, four output formats, and a precise mode that fills to an exact character count so you can see what 60 characters looks like in your own card title. It runs entirely in your browser tab and makes no network call of any kind.
Dummy text generator
Dummy text that is worth testing with: Latin, German or English words, real structure, and four output formats including WordPress block markup. Precise mode fills to an exact character count, which is what a meta description at 155 or a card title at 60 actually needs. Every word is picked in this browser tab, nothing is uploaded and no library is loaded.
1 to 100 paragraphs.
Scrambled Cicero. Even word lengths, no diacritics, the shape every designer knows.
Off. Switch it on and the amount, the structure and the format step aside for one plain line of an exact length.
The counts describe the text itself, not the markup around it, so switching format never moves them. Reading time is the word count at 200 words a minute.
What Latin quietly hides
The usual lorem ipsum is a scrambled passage from Cicero’s De finibus bonorum et malorum, written in 45 BC, cut up by a typesetter who wanted words that nobody would read. That last part still works: your eye slides over Latin, so you judge the shape of the block instead of the sentence. That is a genuine advantage, and it is why Latin filler has outlived every attempt to replace it.
The problem is that the shape it gives you is not the shape your copy has. Measured over the standard opening passage of each of the three vocabularies in the tool above, the differences are not subtle.
Three things follow from those numbers. German runs three times as many words of twelve letters or more, so any container sized against Latin is sized against the wrong distribution. Latin contains no umlauts, so a webfont subset with a missing ä, a fallback stack that swaps in a different face for one glyph, or a line height too tight for the diacritics all pass the test silently. And Latin has no compound nouns at all, so overflow-wrap, hyphenation and the point at which a word simply refuses to break are never exercised.
English filler is not safer, it is worse in the other direction: shorter words on average than Latin, and a maximum of fourteen letters in the standard passage. A layout tested with English dummy text and shipped in German has been tested with the easiest text it will ever hold.
Four texts every layout should survive
Generating a thousand words of anything proves very little. Four specific cases find almost every layout bug worth finding, and each of them takes one setting in the generator above.
The longest plausible word
Turn on the long words option. It slips in words of 20 to 37 letters, per vocabulary, and 37 letters is not an exaggeration for German: Rechtsschutzversicherungsgesellschaft is a word people put on invoices. Watch for the container growing instead of the text wrapping, for a word that runs under a neighbouring column, and for a horizontal scrollbar on the whole page rather than on the one element. The fix is usually overflow-wrap: anywhere on the element that holds the title, not a narrower font size.
The shortest plausible sentence
Set the amount to one sentence, or use precise mode with a target of 40 characters. A card designed around three lines of body text looks broken with four words in it: the button floats, the image sits at a different height from its neighbours, the row loses its baseline. This is the case designers skip, because filler is always generous and real copy sometimes is not.
A heading that wraps to three lines
Generate a heading of roughly 90 characters and drop it into your hero. Two lines is what everyone designs for. Three is what happens at 390 pixels wide, and it is where a vertically centred hero starts pushing its own call to action below the fold. If the answer turns out to be a smaller font size on small screens, size it once with a clamp rather than three media queries: type that fits every screen without a single media query covers the arithmetic.
The empty state
The one no generator can produce, and the one you have to check by hand: no excerpt, no subtitle, no image. In WordPress this state is common, because a post with an empty excerpt field does not render nothing. Core’s wp_trim_excerpt() builds one from the content instead, cutting at 55 words and appending a bracketed ellipsis through the excerpt_more filter. So the card that showed a tidy two line summary in the demo shows the first 55 words of an intro paragraph on the real site, at whatever length that happens to be.
Pasting into the block editor
Plain text pasted into the block editor is not taken literally. The paste handler in @wordpress/blocks runs the clipboard content through a Markdown converter first, then through a shortcode converter, then through a chain of HTML filters with names like listReducer, msListConverter, imageCorrector and blockquoteNormaliser, and only then guesses which blocks you meant. A filler line starting with a hyphen becomes a list. A line starting with a hash becomes a heading. A single line with no newline in it, in the default AUTO mode, is pasted inline and produces no new block at all.
There is one clean way past the guessing. Before any of that runs, the handler checks whether the pasted content contains a block delimiter comment, and if it does it hands the whole thing to the block parser untouched, unless the parse collapses into a single classic block. That check is a plain substring test on the opening of a wp: comment. Choose the WordPress blocks output format in the generator and the text arrives as the structure you asked for, every time.
The block markup the tool writes follows the shape the current editor writes itself, checked against real post content on this site: list items as their own blocks inside a ul.wp-block-list, quotes with an inner paragraph block, headings carrying the wp-block-heading class with the level as an attribute.
<!-- wp:heading {"level":3} -->
<h3 class="wp-block-heading">Weit hinten, hinter den Wortbergen</h3>
<!-- /wp:heading -->
<!-- wp:list -->
<ul class="wp-block-list">
<!-- wp:list-item -->
<li>Vokalien und Konsonantien</li>
<!-- /wp:list-item -->
</ul>
<!-- /wp:list -->Paste that into the editor and you get a heading block and a list block, not a paragraph containing angle brackets and not a block warning about unexpected content. If you are going the other way and cleaning up text that arrived from a word processor with its own invisible baggage, that is a different job with a different tool.
Theme demo content is a trap
Importing a theme’s demo content feels like the responsible thing to do, and it is the most misleading test available. Demo content is authored after the design, to fit the design. Every card title in it is the length the card wants. Every excerpt is exactly two lines. Every category holds enough posts to fill the grid and never one more, so pagination never appears, and never one fewer, so the half empty row never appears either.
The numbers on this blog make the point. Across 73 posts, titles run from 35 to 80 characters and 24 of them are longer than 60. The one line subline under each title runs from 50 to 160 characters. No demo import contains that spread, because nobody writing demo content types an 80 character title on purpose.
The right test is your own content model at its extremes: the longest title anyone will realistically write, the shortest, and the field somebody left blank. If the design is meant to be filled from real data rather than typed into by hand, that is worth designing for directly, which is the argument behind building the design once and letting your posts fill it in.
The character targets that matter
Two numbers get quoted everywhere: 60 characters for a title and 155 for a meta description. They are useful as targets and wrong as rules, because search results are truncated by pixel width, not character count, so a title full of capital W behaves differently from one full of lowercase l. The character counters that tell you otherwise are measuring the wrong thing. Still, a target you can generate to exactly is worth more than a range you eyeball, and the presets in precise mode are 60 for a card title, 155 for a meta description, 280 for a short post and 600 for an excerpt.
Precise mode fills to the exact target and never cuts a word in half. It finishes the last few characters by picking a vocabulary word of exactly the right length, backtracking up to eight tokens when no word fits, and every target from 40 to 200 characters lands exactly in all three vocabularies. When it genuinely cannot reach a target it tells you how many characters short it stopped rather than quietly rounding. It is also exclusive: it disables the amount, the structure, the format and the emphasis toggle, says so in its own line, and writes one plain line whatever output format is selected.
What the generator is doing underneath
The text is deterministic on purpose. A seeded linear congruential generator drives every choice, so the same settings always produce the same words. Switch the output format from plain text to HTML to Markdown to blocks and the words do not change, only the wrapping around them. That is what makes it usable for comparison: you can paste the same paragraph into two templates and know the difference you see is the template. New text advances the seed, Reset returns to the opening text. There is no Math.random and no crypto call anywhere in it, because nothing here is a secret.
Limits are clamped rather than obeyed: 100 paragraphs, 300 sentences, 3000 words, 12000 characters, and a precise target between 10 and 2000. An empty or absurd amount falls back to the default for that unit when the field changes. Word and sentence targets are exact. A character target fills up to the nearest whole word, so it never overshoots. The live counts describe the text itself and not the markup around it, which is why they stay put when you change format, and reading time is the conventional 200 words a minute with a one minute floor. A heading is never the last block, because a heading with nothing under it is not a layout test, it is a mistake.
The preview beside the output is built with createElement and textContent only, never innerHTML. It deliberately renders headings as styled divs and links as styled spans, so dropping the tool into a live blog post adds no extra heading to the page outline and no clickable anchors from dummy content. Generated links point at https://example.com/. The long words option is allowed to overflow the preview into its own scrollbar, because seeing that overflow is the entire point of the option.
Where it stops
It does not upload, fetch or store anything, and it offers no download button: copy the text or select it. Only one instance works per page, since the element ids carry the tool prefix rather than a unique instance id. And German shaped filler is not a translation test. It has the letter frequency and the word lengths of German, which is what a layout cares about, but it carries none of the meaning, so a real localisation pass still needs the real strings.
Dummy text also hides a whole class of typographic problem, because it contains almost nothing that goes wrong. No quotation marks to come out straight instead of curly, no numbers to be set in the wrong figures, no acronyms in full capitals, no hyphens standing in for ranges, no URLs to wrap badly. Those are exactly the details in the list of things that give an amateur design away, and a page of Latin will never surface one of them. Test the frame with filler, then test the typography with a real paragraph, quotes, numbers and all.
Last thing: filler ships. It ends up in a footer widget nobody looked at, or in the third tab of a page that went live at midnight. Before launch, search for it.
wp post list --post_type=post,page --post_status=publish
--s="Lorem ipsum" --fields=ID,post_title,post_typeRun it again for “Blindtexte” and for “Far far away” if you generated in those vocabularies, and once more against your options table if your theme puts text in customiser fields.
The reason Latin filler survives is real: unreadable text lets you see a layout as shape, and that is a genuine skill worth keeping. The mistake is treating one passage of scrambled Cicero as a complete test. It is a sample of one language, with one word length distribution, one alphabet and no punctuation worth mentioning, and every layout decision you make against it inherits those limits without telling you.
The practical version takes about five minutes. Generate in the language the site will ship in. Turn on the long words option once and fix whatever breaks. Generate one sentence and look at the card that was designed for four. Generate a title at exactly 60 characters and a description at exactly 155, and put both where they will actually appear rather than in a counter. Then blank a field and reload.
What you are buying with those five minutes is the difference between finding the problem now, while the layout is a file you are still editing, and finding it on the morning the real copy arrives, when the fix has to be a compromise. Filler text cannot write your page for you. It can tell you, before anyone else does, which part of the page was never going to hold it.
