Text Repeater

The scenario needs no introduction, because you have either received it or sent it: a friend announces something mildly good — a new job, a survived exam, a sandwich that looked better than average — and the reply arrives as a solid wall of 😂 that takes three full seconds to scroll. Somewhere behind that wall is a person who did not type a thousand emoji. Somewhere behind that wall is a text repeater, and the person is smiling.

The other half of this tool's life is invisible and respectable. Developers reach for repeated strings the way cooks reach for salt: test data of exactly 256 characters for a form validation, a thousand-line placeholder file for a layout stress test, twenty-eight a's for the regex that is about to melt catastrophically. The prank and the profession use the same button, which is the kind of tool economy we enjoy building.

This text repeater takes your input, an n, and a separator choice, and produces the output instantly in your browser. No signup, no watermark, no 'free plan: 5 repetitions.' You want a thousand, you get a thousand. You want them newline-separated for a test fixture, that is one dropdown. And because the page is local-only, the largest possible output lives and dies in your own tab.

The interface is four decisions and a button, which is the correct number of decisions for a tool like this. What gets repeated, how many times, what goes between the copies, and whether you want the result as one block or one-per-line. Everything else on the page — character counts, code-point counts, copy buttons — is instrumentation around those four choices.

• Text: whatever you type — emoji, Unicode art, a single space, a code snippet, a whole paragraph
• Count: 1 to 10,000, typed or tapped up with the stepper
• Separator: none, space, comma, newline per copy, or any custom string (including emoji)
• Output block: one continuous paste, or line-per-copy for test fixtures and lists
• Live counts: characters, code points, lines, and estimated paste size before you commit

The live counts earn their place the first time you repeat something with emoji. Paste the family emoji 👨‍👩‍👧, set the count to 10, and the tool reports 50 code points for 10 visible characters — the discrepancy that generates half the confused reviews every text tool receives, made visible before you paste somewhere that cares.

1. 1

   Type or paste your text

   One character or one paragraph — the tool treats both identically. Emoji are text; the counts will tell you what you actually have.

2. 2

   Choose the separator before the count

   Separator first, because 'none' at 1,000 copies produces a very different paste than 'space' at 1,000. The preview updates on every change so you can see the shape forming.

3. 3

   Set the count

   Type it or tap the stepper. The size estimate warns you before anything gets sluggish — a courtesy your browser will thank you for.

4. 4

   Copy the output

   One click to clipboard. For very large outputs the tool copies directly rather than forcing a select-all through a multi-megabyte text area.

5. 5

   Count what landed

   If the destination cares about length — a form field, a message limit — the reported character count is what the clipboard actually contains, including separators.

Worth two minutes, because it is the single most common surprise in text tools. Characters, to a computer, are code points — numbers on a giant list. The family emoji is five of those numbers: person, zero-width joiner, person, joiner, person. Your phone draws those five as one picture. Every text field that counts characters counts the five, and every human counting emoji counts the one, and so the two counts disagree forever, amen.

The repeater shows both numbers because both are correct in their own frame. When a message platform enforces a character limit and your emoji wall is 'too long' despite looking short, this is the arithmetic it is silently doing to you. If you need the full anatomy of invisible characters and joiners, the Invisible Character Generator page documents the entire zero-width family — and when you need to know how many words your repeated text contains, the Word Counter is the honest referee.

The family emoji is the famous case, but the pattern runs through the whole emoji panel:

Multiply by the count and the discrepancies scale: a hundred flags is 200 code points, a hundred family emoji is 500. Then UTF-16 adds its own tax on top, because any code point above U+FFFF costs two units. The family's three people all live above that line, so each family emoji is 5 code points but 8 UTF-16 units — a ten-copy wall is 50 code points to one counter and 80 units to another, and a 150-unit bio limit rejects what a 60-emoji reading says should fit.

The repeater reports what you produced; the platform bills what it received, and the two numbers meet only occasionally. Messaging routes are the expensive case, because SMS is sold in segments and segments are counted in units your eyes never see:

Run the classic prank through that table. A wall of one thousand 😂 is two thousand UTF-16 units — to an SMS route without data coverage, that is 2,000 ÷ 67 = 30 concatenated segments, each billed separately, delivered as one visual torrent. The sender pasted once; the network counted thirty. Group chats on data plans never see this arithmetic, which is why it surprises exactly the people who accidentally pay it.

The rule the table keeps repeating: know which layer your destination counts before you size a repeat. Counting visible emoji fits human intuition and nothing else; counting code points matches the clipboard; counting UTF-16 units matches SMS, X, and most JavaScript length checks, because they all sit on the same sixteen-bit foundation. When a repeat needs to land inside a hard limit, generate at the unit the enforcer uses — the live counts here give you two of the three, and the third is the first one doubled for most emoji.

Ask a developer why they keep a text repeater bookmarked and the answer is rarely pranks. Test strings of known size are a daily need: a field validates 8 to 64 characters, so you generate 63, 64, and 65 and test the boundaries. A layout must survive a 2,000-character biography, so you feed it one. A CSV parser gets 500 identical rows because the bug only shows up past row 400. Repetition is the shape of synthetic test data, and a repeater is its lathe.

The most beautiful use is the regex stress test. The classic catastrophic-backtracking demo takes the pattern (a+)+b and a string of a's with no final b: the engine tries an exponential number of ways to divide the a's between the two quantifiers, and at around twenty-eight characters, a innocuous-looking pattern goes from milliseconds to heat death. Producing exactly twenty-eight a's — then forty, then sixty, to watch the cliff — is a repeater's work.

Pattern: (a+)+b
Input:   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa        (28 × 'a', no b)
Result:  the engine backtracks exponentially — seconds to minutes,
         depending on the regex engine, before reporting no match

Generate the input here: text 'a', count 28, separator 'none'.

That example is not an indictment of regex — it is the standard classroom demonstration of why backtracking has a cost curve, used in security training to explain denial-of-service-via-pattern. If you build forms that run user-supplied patterns, you have met this beast professionally. Everyone else can enjoy it as performance art.

The scenario: a signup form with four validated fields ships tomorrow, and QA wants boundary coverage — the values just inside, exactly on, and just outside every limit. This is textbook boundary value analysis, and a repeater turns an hour of careful typing into about four minutes of copy-paste.

Boundary strings earn their keep because bugs live at edges, not middles. An off-by-one error — a validator written as length < 20 where the spec said length ≤ 20 — passes every test at 10 characters and fails exactly one: the 20-character string. Middles never catch it; boundaries always do.

One fixture the table doesn't show but the session should: the password field that accepts emoji, tested with them. Twelve copies of 👨‍👩‍👧 look like twelve characters to the interface and count as 60 code points to the backend — inside the 8–64 limit either way, but only if both layers agree on how to count. When they don't, the bug report writes itself, and the repro string is already in your clipboard.

A repeater is such a simple operation that it exists everywhere, in every register, from browser tool to spreadsheet formula to shell one-liner. The comparison is a fair fight worth having in the open.

The pattern across all of them: repetition is native to every environment because concatenation is. What a dedicated repeater adds is not capability but packaging — the separator presets, the live counts, and the copy button, arranged so that the thirty-second task stays thirty seconds instead of becoming a console session with a joke inside it.

Now the social half, because the tool's most popular use deserves straight talk. Group chats are a comedy genre with their own physics, and the repeated-emoji reply is one of its oldest bits: it works because it is absurd, it costs the sender nothing, and everyone scrolls past it in two seconds. That is the healthy version — one wall, one group, one laugh.

The unhealthy version is volume aimed at a person. Repeated text hammering someone's DMs is not a prank; it is harassment with extra steps, and every messaging platform's moderation treats it exactly that way. There is also a mundane cost nobody mentions: on metered mobile connections, a multi-megabyte message of repeated emoji is genuinely expensive to receive, in money rather than attention. The rule of thumb we would carve somewhere: group chats absorb walls, individuals do not, and 'stop' ends the experiment.

The cap is 10,000 repetitions, and the reason is physics-of-the-browser rather than business model: text areas become genuinely unpleasant past a few million characters, and no legitimate use — prank or professional — has ever needed more. Output is plain text; if you need repeated structured data (numbered rows, incrementing IDs), a repeater is the wrong tool and a spreadsheet or a ten-line script is the right one.

The tool also cannot count what your destination will do with the text. Platforms trim, split, or reject long messages by rules that change without notice, and a 4,000-character paste that fits today may chunk into eight messages tomorrow. For everything you control — the input, the n, the separator — the tool is exact. For everything downstream, it is honest about being unable to promise anything.

• Group-chat personalities, arming the next perfectly timed wall of 😂
• QA engineers generating boundary strings and known-size fixtures faster than they can be specified
• Frontend developers stress-testing layouts against pathological content lengths
• Teachers demonstrating regex backtracking and string behavior with visible inputs
• Streamers and content creators filling chat prompts and donation alerts with repeated bits
• Load testers building large payloads strings for POST bodies without a generator script

The split is roughly half mischief, half engineering, which is a respectable ratio for any tool. If you are in the mischief half, the Text Reverser makes the reply unreadable in the other direction, and the Random Word Generator supplies words nobody repeated on purpose.

Some observations from watching the tool get used, in no particular order of importance. The distribution of counts people type is sharper than anyone predicts: 10, 100, and 1,000 dominate, with 100 the runaway favorite. Odd numbers like 37 or 250 are almost always engineers — they are the only users who need a count nobody would pick by reflex.

The most common mistake in the wild is a spreadsheet ambush: pick the comma separator, paste into Excel or Sheets, and watch one string shatter into a hundred cells, because comma is the first delimiter those programs split pasted text on. The escape is the tab character as a custom separator — tab-delimited pastes land as one column — or newline mode, which puts one copy per row, the shape spreadsheets wanted all along.

The second most common: forgetting that separators have length. Five copies of 'ha' joined by spaces is fourteen characters, not ten, and every length-limited destination enforces the difference without a warning. The live count exists because the arithmetic is trivial and the forgetting is universal.

And one from the prank demographic: messaging platforms chunk oversized pastes, so a wall that exceeds a platform's per-message cap arrives as a series. The sender sees one paste, the group receives several in sequence — occasionally funnier than the original plan, and always a surprise the first time.

Repeating a string is a single built-in function call in JavaScript, which means shipping this tool to a server would be a performance art piece about waste. Everything — parsing, separator logic, counts, clipboard — runs locally, with no account, no log, and no stored text. The tool works offline, which is both the privacy statement and the simplest possible architecture review.

The repeater is one instrument in the small orchestra of dumb-brilliant text utilities: the Word Counter tells you what you actually produced, the Text Reverser flips it for the committed bit, and the Random Word Generator supplies content no human would repeat. All free, all local, all waiting for the group chat's next historic moment.