Translation memory, explained: reuse without repeating mistakes
A translation memory (TM) is a database of source-and-target segment pairs built up as translation happens. Every time a sentence, line of dialogue, or UI label is translated, the pair goes into the TM. The next time the same or a similar segment appears — in this file, in a future update, in a different project that shares the TM — the translator can pull up the stored translation instead of starting from a blank page.
That sounds simple, and the core idea is simple. But how a TM decides what counts as 'the same segment,' and what a translator does when it is only 'similar,' is where most of the practical value and most of the risk live.
Exact matches and fuzzy matches
An exact match means the new source segment is character-for-character identical to a segment already in the TM. If your game repeats the line 'Press A to confirm' in five menus, translating it once and reusing it four times is a pure win: same source, same correct translation, no extra work.
A fuzzy match means the new segment is similar but not identical — different punctuation, a swapped word, a different placeholder. TM tools typically report fuzzy matches as a percentage of similarity and show the translator a diff against the stored segment. The translator's job is to look at what changed in the source and decide whether the stored translation still applies, needs a small edit, or does not apply at all.
The percentage number is a similarity score on the source text only — it says nothing about whether the translation is still correct. A 95% fuzzy match can be perfectly reusable, or it can be the one word that flips the meaning.
Why reuse pays off
The direct benefit is speed and cost: previously translated content does not have to be translated from scratch. In a large localization project with repeated UI strings, tutorial text, or recurring dialogue patterns, this adds up quickly.
The less obvious benefit is consistency. If a term or phrase is always pulled from the same TM entry, it will always read the same way across the game, rather than being independently re-translated (and possibly re-worded) by whoever happens to touch that file next.
Where reuse goes wrong
The same mechanism that gives you consistency can propagate a mistake. If the stored translation was wrong — a mistranslation, an outdated term, a line that has since been redesigned in the source game — every future exact or fuzzy match will reuse that same wrong translation until someone catches it and fixes the TM entry itself, not just the one file it showed up in.
The sharper risk is identical source text with a different meaning depending on where it appears. The English word 'Match' as a verb ('match the colors') and as a noun ('a 1v1 match') can be the same string in source text pulled from different UI contexts, but require different translations in many target languages. A TM keyed only on the source string, with no context, will happily offer the wrong one as a high-confidence match.
- Wrong reuse from missing context: identical source text, different meaning per screen
- Stale reuse: the source line changed meaning during development but the TM entry was never re-reviewed
- Fuzzy-match overconfidence: a translator accepts a high percentage match without reading what actually changed
TM hygiene
A TM is only as trustworthy as its worst entries, so it needs upkeep, not just accumulation. Practical habits: attach context (screen name, character, surrounding lines) to entries wherever the tooling allows it, rather than storing bare source-target pairs; review and correct an entry in the TM itself when a translation error is found, not only in the file where it was spotted; and periodically prune entries tied to text that no longer exists in the source, so stale matches stop surfacing.
How TM differs from a glossary
It is easy to conflate the two, but they solve different problems. A glossary is a list of individual terms — character names, item names, recurring UI words — each mapped to one approved translation, used to enforce terminology consistency at the word level.
A translation memory stores whole segments (usually sentences or lines) with their full translations, used to reuse entire pieces of work. A glossary tells a translator what word to use for 'potion'; a TM tells them that the exact sentence 'You found a potion!' has already been translated and how. Most professional workflows use both together: the glossary constrains terminology inside every translation, and the TM reuses whole segments that follow that terminology.