Skip to content

Product · Translation Memory

A translation memory the whole platform reads

Every segment you confirm is stored as a source–target pair and offered back the next time that sentence, or one close to it, appears. The same translation memory that fills the editor prices the quote and decides when machine translation isn't needed. The memory is on every plan, including the free one, and it leaves as TMX whenever you want it to.

Translation memory match loopA confirmed segment is stored in the translation memory with usage counts and version history; when the same or a similar sentence appears in a later file, a scored match is offered and applied with one click, and the confirmation writes back to the memory.Confirmsegment approvedStoreusage · historyNext filea close sentenceMatchApply TM 100% / 87%Applyone click · undoableevery confirmation writes back — the memory compounds

The loop

The memory writes itself as you work

A translation memory is a store of sentence pairs: your source on one side, the translation a person confirmed on the other. In LionRapid every confirmation writes the pair into the memories attached to the file — no separate save step, no end-of-job export ritual.

The store keeps its history. Confirm the same target again and the entry's usage count goes up rather than duplicating; change your mind and the entry updates, keeping the last ten versions with their authors. A client's authoritative memory is written only at payment, deliberately, so drafts never contaminate the record of what was actually delivered.

The next time that sentence — or one near it — appears, the match comes back to the row with a score and the name of the memory it came from. Applying it is one click, and undoable like everything else in the editor.

app.lionrapid.com

Matching

A 100% match wins outright. Fuzzy starts at 75.

When source text repeats exactly, the stored translation is a 100% match: it can pre-fill before machine translation is even consulted, and in the editor it appears as "Apply TM 100%", with the memory named. When the text is close but not identical, similarity is scored, and anything at 75 or above is offered as a fuzzy match — up to two per row, so the menu stays a menu instead of a search result.

A fuzzy match is a draft from your own past work — worth starting from, still yours to review before it counts as done. An exact match is closer to a fact: the sentence has been translated before, and the row says so.

Rows with leverage announce it before you open anything: a row-level indicator carries the match percentage, so a long file can be read by how much of it is already yours.

  • Exact match = 100%
  • Fuzzy cutoff at 75
  • Up to two matches per row
  • Every match names its memory
  • Undoable, 100 steps deep

One corpus

The quote and the editor read the same translation memory

Matching, quote analysis, and machine translation share one corpus, so they can never disagree. The bands your matches land in — 95 and up, 85 and up, 75 and up — are the same bands the analysis that prices your project uses, which is why a strong memory doesn't just speed the work: it visibly changes the number on the estimate.

The memory also decides what machine translation is for. Exact matches are reused before the model is asked, segments close enough to a past translation can skip machine translation at a threshold the project sets, and repetitions can fill themselves in — opt-in, only into untouched rows, never over a human edit.

  • CAT bands: ≥95 / ≥85 / ≥75
  • Exact matches reused before MT
  • Close matches can skip MT
  • Repetition fill: opt-in, never over an edit

Management

Open the memory, search it, fix it

The memory here is a first-class asset, not a hidden index. The resources view lists every memory you can reach — personal or organization-owned, each with its language pair, optional region and script, and a subject domain — and lets you create one empty, upload one, rename it, or delete it, with a warning that tells you which projects still have it attached.

Open a memory and you are in the entries: a list that stays fast when the memory is large, search across source, target, or both, edits made inline, deletions when an entry has earned one, and a download whenever you want a copy. Glossaries get the same treatment, plus a write policy — read-only, owner-only, or open to project members.

  • Create, upload, rename, delete
  • Search source, target, or both
  • Inline entry edits
  • Language pair, script, domain
  • Glossary write policies

Portability

Bring your translation memory with you. Leave with it, too.

Years of translations in Trados or memoQ are an asset, and TMX is how they travel: import TMX 1.4 or CSV into any memory, and export the same ways, on every plan. Termbases move as TBX, CSV, or tab-separated files, and finished translations leave as XLIFF, per file or as a whole-project ZIP. The translation-memory guide in the docs covers the formats step by step.

Nothing about your memory is rented. It doesn't expire, it isn't locked behind a plan change, and deleting it is a right, not a ticket. Elsewhere in this category an entry-level memory can be kept for 180 days, and export can sit behind a plan many times the price.

Ownership is literal: personal memories belong to you, organization memories to the organization and its owner. What a project generates for a client becomes exportable when the job is paid — the same moment the authoritative memory is written.

  • TMX 1.4 & CSV, in and out
  • TBX / CSV / tab for termbases
  • XLIFF export, file or project ZIP
  • No expiry on any plan
  • GDPR erasure

Terminology

The memory holds sentences. The termbase rules on words.

A translation memory reuses whole segments; a termbase governs the words inside them. One remembers that you translated "Click Save to continue" — the other insists that Save is always Tallenna, and never anything else, in every sentence it appears in.

Insists is the right word. When a glossary is authoritative, a mandated term you missed is an error on the row, and a forbidden term is an error everywhere. Matching is lemma-aware in around 35 languages, so an inflected form doesn't slip past, and term hits are highlighted in the source as you type — precomputed, and toggleable when you'd rather read clean text. It is common for a glossary to be advisory: shown to the translator, checked by nothing.

Termbases grow the way memories do: add a term from the editor with a shortcut, gated by the glossary's write policy, or — with read-only access — suggest it into a review queue. You can also attach IATE, the EU's terminology base, with reliability grades, definitions, and source links on every term. How terms surface while you translate is in the docs.

  • Mandated & forbidden terms
  • Errors, not suggestions
  • Lemma-aware, ~35 languages
  • Add terms from the editor
  • Suggest & review workflow
  • IATE attachable

Memory vs machine

Memory first, model second

The memory retrieves something a person already approved; machine translation generates something new. They are not rivals here — they are ordered. The memory is consulted first, exact matches are reused as they stand, close matches can stand in for the model, and only what remains is machine translated, inside the CAT editor where every machine-translated row carries a quality-estimation score.

Order matters in the other direction too: attach a memory after machine translation has already run, and the platform flags the targets worth another pass, so a late TM is a correction, not a regret.

FAQ

Translation memory, answered

Product

Your memory starts with the next file

Import a TMX you already have, or attach an empty memory and let the confirmations fill it.