Why one hundred?

Not fifty, not a thousand. The number shows up everywhere — in search queries, in tool names, in the way people describe the joke — and it has the feel of a rule somebody set. It isn’t.

The honest answer is that 100 is a round number that happens to sit in the right place on a curve. But the more interesting story is why there’s a curve at all: this game didn’t get invented for fun. It fell out of a real technique used to test machine translation, and the joke is what that technique looks like when it fails.

Why 100, and not 50 or 1000

There’s no authoritative source for the number. Nobody decreed it. It’s a convention that stuck because it works.

The reason it works is diminishing returns. In the first few dozen rounds, every hop changes something — a word choice shifts, an idiom gets flattened, a sentence structure rearranges. Somewhere past a few hundred rounds, further hops mostly stop doing anything new. The text has already collapsed into whatever stable-ish form it’s going to take, and more rounds just move it around inside that form.

So 100 is the point where you’ve done enough damage to make the result funny, but not so much that you’re wasting time watching a number climb. Fifty feels cautious. A thousand is theater.

Which means 100 is a convention, not a threshold. Nothing special happens at round 100. It’s just far enough past the interesting part.

Two machines, two ideas

The earliest versions of this toy — and this part is well known even if the exact dates aren’t — worked differently from Hypertranslate.

They picked a fixed pair of languages, usually English and Japanese, and bounced the text back and forth: English → Japanese → English → Japanese, over and over. The loop stopped when the text stopped changing. At that point the site declared the sentence had reached equilibrium — a fixed point where translating it again produced the same thing.

That design is chasing convergence. It’s asking: will this sentence eventually stabilize?

Hypertranslate runs the opposite experiment. Each hop goes to a randomly chosen language, never the same one twice in a row, and it never lands on your target language until the final round. There is no equilibrium to reach, because the path is different every time. Run the same sentence twice and you get two different endings.

The difference isn’t a technicality. One design asks whether meaning settles. The other asks how far it can drift before you stop recognizing it. Same ingredients, opposite questions.

Back-translation is a real technique

Here’s the part that surprises people: translating something into another language and back again is an actual method in machine translation research. It’s called round-trip translation, or back-translation.

The appeal is obvious once you state the problem it solves. To judge whether a translation is any good, you normally need a reference — a human translation you can compare against. For most of the world’s language pairs, that reference doesn’t exist. Nobody has commissioned professional translations into and out of every low-resource language.

Round-trip translation sidesteps that. Translate the text out, translate it back, compare the result to the original. No reference needed, no trained model needed, works on any language pair you can run through a translator. That’s why it keeps getting rediscovered: it’s cheap, it’s universal, and it requires nothing but the translator you already have.

Why it’s a bad quality signal

It’s also, in the blunt assessment of the European Association for Machine Translation, a very bad way to judge whether a translation is any good.

Three reasons, and they’re all intuitive:

A good round-trip doesn’t prove a good translation. A translator can produce a confidently wrong sentence that happens to survive the return trip intact. If it says something plausible and structurally sound, translating it back will also say something plausible and structurally sound. The round trip agrees with itself. That’s not the same as being right.

A bad round-trip doesn’t prove a bad translation. Some language pairs are simply far apart. A perfectly correct translation into a distant language may come back mangled for reasons that have nothing to do with translation quality — the same reasons this game is fun.

Errors stack, and you can’t separate them. Over a round trip, translator error and inherent round-trip loss are added together into one number. You have no way to tell which part is which. The signal is real, but it’s contaminated by the method itself.

Which brings us to the joke. This game is that failure mode, made visible. The absurdity you’re laughing at is exactly the noise that a round-trip quality check can’t distinguish from a bad translation.

Why researchers came back to it anyway

Despite all that, round-trip translation hasn’t been abandoned. A 2023 paper — Rethinking Round-Trip Translation for Machine Translation Evaluation, by Terry Yue Zhuo, Qiongkai Xu, Xuanli He, and Trevor Cohn, published in the Findings of ACL 2023 — takes it seriously again.

The motivation is the same one that made the technique attractive in the first place. Most modern automatic translation metrics need to be trained, and training them needs parallel corpora. In low-resource settings, that infrastructure isn’t available, so a method that needs no training and no reference data has real value.

The paper’s conclusion isn’t that round-trip translation is secretly great. It’s that the signal is more nuanced than the blanket dismissal suggests — worth studying carefully rather than discarding. Which is a fair summary of where the field has landed: not a good metric, not a useless one.

The joke and the flaw are the same thing

Here’s the thing that makes this whole genre of tool worth playing with.

You find the result funny because you know the original. You can see the drift. You remember “it’s raining cats and dogs” and you’re looking at a sentence about livestock, and the gap between those two things is the joke.

A quality metric doesn’t have that. It has no original to hold up for comparison — that’s the entire reason it’s using round-trip translation instead of a reference. It can measure that the text changed. It cannot measure that the text got worse, because it never knew what the text was supposed to mean.

That’s also why 100 rounds is funnier than 20. It isn’t more accurate or more rigorous. It’s that the drift has crossed the threshold where you can no longer reconcile the output with the input — and that moment of failing to reconcile is the punchline.

Try it now

Go run one at translate 100 times. If you want the mechanics first, the three methods covers manual, spreadsheet, and one-click. If you want to know which languages do the most damage per hop, that’s a separate guide.

Then read your own result and notice what you’re doing: comparing it against a sentence you still remember. The metric can’t do that. You can. That’s the whole trick.