Why Do Designers Use Lorem Ipsum?

The short answer

Placeholder text exists to answer a layout question, not a content question. A designer fills a wireframe with lorem ipsum because the arrangement of type — how the headline wraps, how the paragraph block sits against the whitespace, whether a card's fixed height survives real sentences — has to be judged before anyone has agreed on what the words will be. Real copy at that stage is a distraction; empty frames are blind.

The reason it is nonsense rather than filler English is deliberate: unreadable text keeps feedback on hierarchy, spacing and weight instead of starting an argument about wording. The reason it is Latin is that Latin word lengths and letter mix look like European-language prose at a glance while being obviously not the final copy, so nobody mistakes it for content.

That is the whole logic. Everything below expands it, then covers where the practice goes wrong — which is more often than designers admit, especially for products that ship in more than one language.

Placeholder text is not placeholder shape

The empty frame is the problem. A layout drawn as empty rectangles cannot fail: nothing overflows, nothing wraps, nothing gets pushed off the screen. Empty boxes look calm and balanced because there is nothing in them to fight. Fill the same boxes with text and the design starts to break in ways you can only see once something has been broken.

So placeholder text is not decoration for the mockup; it stands in for the shape of real writing. Three properties carry the load. Length: a headline that runs two words longer wraps to a second line and shifts every element below it. Word length: long words set the rag of a paragraph — the uneven right edge — force hyphenation decisions, and open rivers of whitespace running down justified columns. Line rhythm: paragraphs of different sentence lengths make blocks of text look dense or airy, and a page lives or dies on that texture.

None of those problems show up while the boxes are empty, and none show up with five-character filler words. They show up with text of realistic length, realistic word length and realistic line rhythm. That is exactly what dummy text supplies on demand, which is why designers reach for it before the words exist.

Fixed-size components make the point sharper: a button, a table cell, a card with a two-line clamp is only tested by fullness. You learn which layout survives the moment you paste in a paragraph that is honestly long.

• The things a frame only reveals when it is full:
• Where headings wrap, and whether the second line orphans one word.
• How ragged the right edge of each paragraph actually is.
• Which blocks read as dense content and which read as gaps.
• Which fixed-size components clip, shrink or wrap when text exceeds them.

Why nonsense rather than real copy

Readable content pulls the eye. Put the actual headline into a mockup and everyone who looks at it — you, the client, the product manager — reads the sentence and reacts to the sentence. Feedback becomes word choice and tone, and the layout stays unjudged because nobody can evaluate hierarchy underneath copy they are currently arguing about. Meaningful words are magnets; you cannot ask people to look past them, because that is not how reading works.

Nonsense text refuses to participate in that. Nobody has an opinion about “consectetur adipiscing elit”, so the conversation stays where it needs to be while the layout is being decided: hierarchy, spacing, weight, scale. That is not a rule or a trick — it is the recognition that asking stakeholders to ignore the meaning of readable words is a request they will not honour.

There is a quieter benefit too: placeholder text carries no commitment. Real draft copy implies the page says something, and people treat circulated drafts as approved content. Dummy text announces itself as unfinished, keeping the layout discussion from becoming a content-approval discussion.

Why Latin specifically

Once you accept that the filler should be unreadable, you still need it to look like writing, and that is the Latin part. Dummy text fails at its job if it looks fake: a field of “asdf asdf asdf” photographs as a placeholder and the eye slides off the layout instead of reading it as a page. Latin words have the shape of European-language prose — mixed word lengths, short connectives, familiar punctuation, ascenders and descenders distributed like English or German — close enough that a paragraph of it reads as a paragraph at the distance you evaluate a layout.

It is also transparently not the final copy. Greek would look like a design choice; French would be read by half the room; a made-up language takes work to keep consistent. Latin occupies a stable middle: everyone recognises it as a language nobody is shipping, so it stands in for content without anyone mistaking the dummy for a decision. That recognisability is why the same opening line has survived as a convention — its meaning is “this slot is not filled yet”.

The catch is that “the shape of European-language prose” means Latin script, space-separated words, roughly the character mix of English — and nothing more. It says nothing about how German expands, or how Chinese breaks lines. That limitation is the subject of the failure section below.

Where lorem ipsum came from

The origin story gets told with more confidence than the evidence supports. Here is the broadly accepted account, with the uncertain parts marked.

A classical Latin source

The standard passage descends from real Latin. Its opening words are a disturbed excerpt from Cicero’s De Finibus Bonorum et Malorum — “On the Ends of Good and Evil”, a first-century-BC treatise on ethics — from a passage near the start of book one discussing pleasure and pain. That Cicero is the source is the part scholars and design writers agree on; the exact section reference is cited variously across retellings, and what survives shows the excerpt chopped and patched, syllables cut mid-word and pieces rejoined. “Lorem ipsum dolor sit amet” is not a Latin sentence; it is the wreckage of one.

So the question “is it real Latin?” has an honest answer: the seed text was Latin, and it was broken deliberately.

A printing practice, not an invention

The scrambling matters more than the source, and it predates any single product. For centuries, printing type specimens and proofs have used Latin that looked like real prose but could not be mistaken for anyone’s book — filler that demonstrated the typeface without offering readable text to copy. Lorem ipsum is one survivor of that practice, not the invention of one clever person at one moment. How far back the earliest example sits is genuinely fuzzy in the popular telling: you will see dates scattered across the second half of the second millennium, and most of them trace to a small number of online retellings leaning on each other. Treat any precise year in this story as a guess someone made.

The 1960s story, and what you can actually cite

The folklore version says a typesetter — or a 1960s dry-transfer lettering sheet — invented the passage and spread it through design studios, with desktop publishing finishing the job. The broad shape is plausible: the text was already in print-trade use, a mass-market product then made it universal, and design software standardised it from there. The commonly repeated specifics — who cut the sheets, which year, which famous designer — are not something you can cite precisely, and the people who have tried to document them have not managed to pin the details down. If you need one reliable sentence: nobody knows who made lorem ipsum standard, but standard it became.

What is not folklore is what happened next: once desktop publishing and web design picked the text up, newcomers copied what existing tools produced, and the convention locked in. That is why most generators still start with the same three recognisable words.

How lorem ipsum works

Mechanically, dummy text generation is one of two things, and they are easy to confuse. The first is the canonical passage extended by scrambling: take the mangled Cicero excerpt and keep applying the same process — remove letters, insert others, shift endings — and you get page after page of Latin-ish text that never resolves into sentences. That is where the classic “lorem ipsum” look comes from.

The second is a word bank and a random draw: the generator holds a list of Latin-looking words and picks from it to assemble the paragraphs you request. No grammar, no meaning, no model of any real language; the output is prose-shaped noise. Most tools you actually use, including the generator linked at the end of this guide, work this way.

Both methods exploit the same property: recognisability lives at the level of shape, not correctness. You evaluate a paragraph from a foot and a half away, which is a distance at which word lengths, line breaks and the density of ink matter and spelling does not. Nonsense with the right shape passes as content at a glance — which is exactly what a layout test needs.

Know the trick’s limits too: a random draw gives plausible length and rhythm, not the word mix of genuine prose, which leans hard on a handful of short common words. At layout distance nobody notices, and layout distance is the standard being met.

Where it goes wrong

Placeholder text has a narrow job, and three failures account for most of the damage it does.

Leaving it in the deliverable

The classic disaster is the live page still carrying “consectetur adipiscing elit” because nobody swapped the copy. In a mockup, dummy text announces “not finished yet”; in a shipped product it announces “we did not care”. Real headings, navigation labels and button text need to be in place long before the file leaves your machine — they are the elements every reviewer reads first, and the ones whose length you should never have guessed.

There is a subtler version: filling every slot with dummy except the important ones. A pricing table built with placeholder tier names has tested nothing, because the tier that actually reads “Enterprise Annual Contract” is the one that wraps.

Reviewing accessibility or content with it

Dummy text tells you nothing about real content length, which makes it the wrong material for anything that depends on meaning. A screen reader will recite nonsense flawlessly, so an accessibility pass over lorem ipsum finds every problem in text that has none — while alternative text, link purpose and reading order under real headings go untested. Usability sessions on dummy copy produce participants paraphrasing nonsense, which is a session wasted politely.

The same applies to length. Lorem ipsum paragraphs average whatever the generator’s parameters say; real product copy has error messages several times the length of the placeholder, product names with no spaces, and user-entered strings as long as the field allows. Dummy text can approximate the average. It cannot approximate the tail.

Testing a multilingual product with English-shaped dummy text

This is the failure with the most real cost, and most explainers skip it entirely. The standard text approximates English-length, space-separated, Latin-script prose. Three variables that actually decide whether a layout survives translation — how much space text takes, where lines may break, and which direction text runs — are all pinned to English by that choice, so an English lorem ipsum paragraph tests none of them for any other locale.

Expansion first. Translations into most European languages need visibly more space than the English original; a rule of thumb commonly quoted in localisation is that German, French and Spanish each need roughly 15-35 percent more, with German usually the longest of the common ones. A column sized from a thirteen-word English dummy paragraph is a column that a twenty-word German sentence walks straight out of.

Break rules second, and this is the one that bites hardest. Chinese and Japanese text uses no spaces at all: there are no words for a line-break algorithm to choose between, breaking happens between characters, and the density per line looks like nothing in Latin script. Testing an English lorem ipsum paragraph for those locales means you have not tested wrapping at all. The mirror-image problem is the unbreakable string — a URL, an email address, one long German compound noun — which behaves like CJK in miniature and overflows the container that handled “lorem ipsum” beautifully.

Direction third. Arabic and Hebrew reverse the layout — alignment, list markers, reading order — and a Latin paragraph tells you nothing about how the mirrored design behaves. None of this means drop dummy text for international products; it means the dummy has to match the target locale’s shape, not English’s.

What to use instead

Placeholder text is the wrong tool the moment the question stops being “does the layout survive” and becomes “does the page work”. Three swaps cover almost every case.

Real content early. The strongest fix is to stop using dummy text as soon as words exist. Headlines, navigation, button labels and section intros are usually written before the design review; put the drafts in and let the layout absorb the truth about their length, even if the wording changes later. A designer working against real headings still gets layout feedback, and the wording arguments happen sooner, when they are cheap.

Length-faithful dummy for the target locale. If the product ships in German, generate the German shape. Two routes: pseudo-translation, which rewrites each real string as longer synthetic accented text in proportion to estimated expansion, so you see length without waiting for translators; or dummy paragraphs simply made longer — around 1.3 times the English volume — for the specific locale. For CJK, paste in real Chinese or Japanese prose of realistic length; the break behaviour is the whole point, and only genuine text exercises it.

Worst-case real strings. Before handoff, replace the dummy with the longest input the field can actually receive: the double-barrelled name, the product title that runs long, the full-length email, the longest error message you have written. It is boring, and it is the highest-return pass you can run, because layouts ship on their edge cases, not their averages.

• The swap list in one place:
• Exploring layout, style and hierarchy: dummy text, keep it.
• Deciding component sizing and breakpoints: real draft content at realistic length.
• Designing international locales: pseudo-translation or target-locale dummy.
• Usability testing, accessibility review, content review: only real words.

Using a lorem ipsum generator properly

The generator linked from this page is built for the layout job and nothing else. You choose the number of paragraphs, from 1 to 10, and optionally set sentences per paragraph and words per sentence; leave either control blank and it randomises within a range — 4 to 9 sentences per paragraph and 8 to 18 words per sentence. The randomisation is the point: five identically sized paragraphs look like a placeholder, and you cannot judge a ragged right edge when every line ends at the same spot. A checkbox keeps the classic “Lorem ipsum dolor sit amet” opening line if you want the mockup to read as the recognised convention. At the maximum settings — 10 paragraphs, 9 sentences each, 18 words per sentence — the output is 10 × 9 × 18 = 1,620 words.

Under the hood it is the word-bank method, not the classical scramble: a fixed bank of 280 Latin words, of which only the opening stretch follows the Cicero-derived passage; the rest is assorted Latin vocabulary, with a few irregular tokens mixed in. Words are drawn independently and uniformly with Math.random, so repeated runs look different from each other, and nothing about the output is modelled on real Latin word frequency. It is prose-shaped noise on purpose — the job is realistic length and rhythm, not a philologically correct fake.

Its edges are worth stating plainly, because they are design choices and not defects to discover later. The output is plain text in a box with a copy button. There is no HTML markup mode, no list or heading mode, and no file download — for pasting into code or a design tool you wrap the paragraphs yourself, which keeps the structure yours. It runs entirely locally, and nothing you generate is sent anywhere.

Practically: pick the paragraph count that matches the section you are designing, leave the sentence and word controls blank for natural variation, paste into the frame — and then swap in the strings that will actually exist before anyone outside your team sees the file.

• What the generator will do: 1 to 10 paragraphs of plain dummy text, optional sentence and word controls, optional classic opening line.
• What it will not do: generate HTML, lists or headings, save a file, or send anything you write anywhere.

Frequently asked questions