From 7be2cd8da9c31da0cb0871ca6906f3e569cb9b8f Mon Sep 17 00:00:00 2001 From: Daniel Krizan Date: Tue, 28 Apr 2026 15:55:43 +0200 Subject: [PATCH 1/4] docs: add translation memory management page Cover org-level shared and project-only memories, manual entries, TMX import/export, project assignment, and write rules. Refresh the existing translation_memory page to describe the redesigned editor panel and link to the new management page. Add the new page to the Translation Process sidebar. --- .../managing_translation_memories.mdx | 186 ++++++++++++++++++ .../translation_memory.mdx | 71 ++++--- sidebarPlatform.js | 1 + 3 files changed, 231 insertions(+), 27 deletions(-) create mode 100644 platform/translation_process/managing_translation_memories.mdx diff --git a/platform/translation_process/managing_translation_memories.mdx b/platform/translation_process/managing_translation_memories.mdx new file mode 100644 index 000000000..febe8665b --- /dev/null +++ b/platform/translation_process/managing_translation_memories.mdx @@ -0,0 +1,186 @@ +--- +id: managing_translation_memories +title: Manage Translation Memories +sidebar_label: Manage Translation Memories +image: /img/og-images/platform.png +description: Create shared translation memories, manage entries, import and export TMX files, and assign memories to projects. +--- + +import { ScreenshotWrapper } from '../shared/_ScreenshotWrapper'; + +When a team translates the same product across many projects, the same phrases keep getting re-translated. A login screen string in one project, a button label in another, an error message in a third — all written by different people, each making slightly different choices. The result is inconsistent wording across products and wasted translator time. + +Translation memory management lets your organization curate one or more shared memories, fill them with approved translations, and reuse them across every project that should follow the same wording. The [Translation Memory](/platform/translation_process/translation_memory) feature in the editor then surfaces matches from any memory connected to the current project. + +:::info +Translation memory management is available on advanced plans. The feature must be enabled for your organization for the management UI to appear. +::: + +## Translation memory types + +Tolgee distinguishes two kinds of memories. + +A **shared** memory lives at the organization level and stores its own entries. You add entries by importing a TMX file, by manual entry, or automatically as translators save translations in any assigned project. Multiple projects can read from and write to the same shared memory, so a translation reviewed once becomes available everywhere. + +A **project-only** memory is created automatically when the Translation Memory feature is enabled on an organization, one per project. Its content is **virtual**, computed on the fly from the project's own translations. You cannot import into a project-only memory or add entries manually, but you can configure whether it should suggest only reviewed translations. + +In the memory list, each row shows a `Shared` or `Project only` chip so you can tell them apart at a glance. + +## Open the translation memories list + +The list of memories lives in organization settings. + +1. Open `Organization settings` +2. Select `Translation memories` in the side menu + +Anyone in the organization can see the list. Only an organization maintainer or owner can create, edit, or delete a memory, and only a maintainer can manage entries inside one. If you cannot see the `+ Translation memory` button, ask an organization owner to grant you the maintainer role. + + + +## Create a shared translation memory + +Create a shared memory when you want a single source of approved translations that several projects should reuse. + +1. On the translation memories list, click `+ Translation memory` +2. Enter a `Name` that describes its scope (for example, `Marketing copy` or `iOS app`) +3. Pick a `Base language` — every project assigned to this memory must use the same base language +4. Set a `Default penalty` (0–100%) — the penalty is subtracted from match scores when suggestions from this memory appear in the editor +5. Optionally toggle `Only accept reviewed translations` to gate writes (see [Write rules](#write-rules) below) +6. Optionally add the projects this memory should cover, with read or write access and a per-project penalty +7. Click `Create` + + + +The base language is locked once any project is assigned. If you need to change it later, disconnect every project first. + +## Add entries manually + +Open the memory by clicking its row in the list. The entries view shows every stored translation, grouped by source text, with one column per language. + +1. Click `+ Entry` +2. Type the source text in the base language column +3. Type translations in any of the other language columns +4. Click `Save` + + + +To edit an entry, click any cell in its row. To delete entries, select them with the row checkboxes and use the `Delete` action in the batch toolbar that appears at the top. + +The entries view supports two layouts. Use the toolbar buttons to switch between **One row per entry** (a compact grid that shows every language in a single row) and **Stack languages vertically** (one row per language, useful when entries have many translations). Filter by language with the language picker, and use the search field to find entries by source or target text. + +## Import a TMX file + +Importing TMX is the fastest way to seed a memory with translations you already have, for example after migrating from another translation system or after exporting from a CAT tool. + +1. Open the memory you want to import into +2. Click the `Import TMX` button (cloud-upload icon) in the toolbar +3. Drop a `.tmx` file into the upload area, or click to browse +4. If the memory already has entries, choose how to handle conflicts: + - `Keep existing entries` — new entries are added, previously imported entries are kept unchanged + - `Override existing entries` — new entries are added, previously imported entries are replaced with the new translations +5. Click `Import` + +Only **TMX 1.4b** files are supported. Once the import finishes, a summary shows how many entries were created, updated, or skipped. + + + +You cannot import into a project-only memory because its content is computed from the project translations. + +## Export a TMX file + +Export a memory to TMX when you need to back it up, share it with an external translator, or move it to another organization. + +1. Open the memory +2. Click the `Export TMX` button (download icon) in the toolbar + +The browser downloads a TMX 1.4b file containing every entry in the memory. + +## Assign a memory to projects + +Assigning a memory to a project lets translators see suggestions from that memory in the editor and, if write access is enabled, lets the project contribute new translations back to the memory. + +You can manage assignments in two places. + +**From the memory** — open the memory's `Settings` (three-dot menu on the list, or click `Manage all TMs` from the project's translation memory section). The settings dialog has a `Used in projects` section where you can add or remove projects, toggle each project's `Read` and `Write` access, and set a per-project `Penalty` that overrides the memory's default. + +**From the project** — open `Project settings` → `Translation memory`. This view lists every memory assigned to the project in priority order. Drag a row by its handle to change priority — memories higher in the list are preferred when scoring is tied. + + + +Only projects whose base language matches the memory's base language can be assigned. Projects with different base languages are hidden from the project picker so the assignment cannot fail at submit. + +## Configure write rules + +The `Only accept reviewed translations` switch controls when a translation flows from a project into a shared memory. + +When the switch is **off** (default), every saved translation is written to the memory, including translations still in progress. This builds the memory faster but mixes draft and final wording. + +When the switch is **on**, only translations marked `Reviewed` are written. If a previously reviewed translation is later un-reviewed, the corresponding entry is removed from the memory. TMX import and direct edits in the entries view bypass this filter — they always succeed. + +For shared memories, this setting is fixed at creation time. To change behaviour, create a new shared memory. Project-only memories carry the same switch (under the label `Only include reviewed translations`) and can be toggled at any time. + +## Delete a translation memory + +Deleting a shared memory permanently removes it and every entry it contains. The action cannot be undone, so you must confirm by typing the memory's name in upper case. + +1. Open the three-dot menu on the memory's row +2. Select `Delete` +3. Type the memory name in upper case to confirm + +Project-only memories cannot be deleted manually — they are removed automatically if the Translation Memory feature is disabled for the organization. + +## Reference + +### Memory types + +| Type | Stored entries | TMX import | Manual entries | Multi-project | +|----------------|----------------|------------|----------------|---------------| +| `Shared` | Yes | Yes | Yes | Yes | +| `Project only` | No (virtual) | No | No | No (one project) | + +### Per-project assignment options + +| Option | Effect | +|--------------|--------| +| `Read` | Suggestions from this memory appear in the editor | +| `Write` | New translations saved in this project are written into the memory | +| `Priority` | Order in the project's memory list — higher priority wins ties | +| `Penalty` | Lowers the match score for suggestions from this memory in this project, overriding the memory's default penalty | + +### Suggestion ordering + +When the editor needs to pick a TM match, it considers every memory the project can read from. Each candidate match is scored by: + +1. Similarity between the source text and the candidate's source text +2. Minus the applicable penalty (per-project override, or the memory's default) + +Matches below 50% similarity are not shown. Ties are broken by the memory's priority in the project's translation memory list. See [Translation Memory](/platform/translation_process/translation_memory) for how matches appear in the editor. + +### Permissions + +| Action | Required role | +|--------|---------------| +| View the list of memories | Any organization member with project access | +| Create, edit, delete a memory | Organization owner or maintainer | +| Manage entries (add, edit, delete, import) | Organization owner or maintainer | +| Configure project's TM list, priority, per-project access | Project user with `project.edit` permission | +| Configure project-only memory's `Only include reviewed translations` | Project user with `project.edit` permission | + +### TMX format + +Tolgee imports and exports **TMX 1.4b**. Other TMX revisions are not supported. The TMX `srclang` is taken from the memory's base language; `tuv` elements outside the memory's languages are ignored on import. diff --git a/platform/translation_process/translation_memory.mdx b/platform/translation_process/translation_memory.mdx index f828b618c..f5272d9b0 100644 --- a/platform/translation_process/translation_memory.mdx +++ b/platform/translation_process/translation_memory.mdx @@ -1,28 +1,45 @@ ---- -id: translation_memory -title: Translation Memory -sidebar_label: Translation Memory +--- +id: translation_memory +title: Translation Memory +sidebar_label: Translation Memory image: /img/og-images/platform.png ---- - -import { ScreenshotWrapper } from '../shared/_ScreenshotWrapper'; - -Translation memory (TM) searches for similar texts in your project and suggests them to you. This helps you to reuse translations and save time. - -## Translation memory matches - -Translation memory matches are shown in the editor. Suggestions with match percentages lower than 50% won't be displayed. - -For each TM match, the following information is shown: - -- Translation of the base text -- Base text -- Match percentage (similarity) -- Key name - -To add the TM match to the editor, simply click on the suggestion. - - +description: Reuse previously translated phrases through translation memory matches in the editor. +--- + +import { ScreenshotWrapper } from '../shared/_ScreenshotWrapper'; + +Translators waste time re-translating the same phrase. A button label, an error message, a marketing line — the same source text appears across keys, projects, and products, but each translation is rewritten from scratch and worded slightly differently each time. + +Translation memory (TM) searches for similar texts your team has translated before and suggests them in the editor. Matches come from the project's own translations and from any shared memory connected to the project, so a phrase translated and reviewed once becomes available everywhere it appears again. + +To curate, share, and import memories at the organization level, see [Manage translation memories](/platform/translation_process/managing_translation_memories). + +## Translation memory matches + +Matches appear in the editor as a ranked list. Matches below 50% similarity are not shown. + +For each TM match, the panel shows: + +- The translation in the target language +- The source text it was translated from +- A match-score pill, coloured by tier (high / medium / low) so strong matches stand out +- The translation memory name, the source key, and how long ago the entry was added + +To insert a match into the editor, click the suggestion. To insert it as-is without picking up its formatting, hold a modifier as you click — see the editor's keyboard shortcut hints. + + + +## How matches are scored + +Each candidate match is scored by similarity between its source text and the text being translated, then reduced by any **penalty** configured on the memory or its assignment. A penalty is useful when one memory is less authoritative than another — for example, a draft memory penalised by 20% will only beat a high-quality memory when its raw similarity is much higher. + +When two matches end up with the same score, the memory's priority in the project's translation memory list breaks the tie. You can reorder memories from `Project settings` → `Translation memory`. + +## Where matches come from + +Every project has a project-only memory that mirrors its own translations. Beyond that, an organization owner or maintainer can connect one or more shared memories to the project, each with its own read or write access and penalty. The editor merges results from every connected memory and shows the strongest matches first. + +See [Manage translation memories](/platform/translation_process/managing_translation_memories) for how to create shared memories, import TMX files, and assign memories to projects. diff --git a/sidebarPlatform.js b/sidebarPlatform.js index eb9e1e29c..ad497d89f 100644 --- a/sidebarPlatform.js +++ b/sidebarPlatform.js @@ -59,6 +59,7 @@ module.exports = { type: 'category', items: [ 'translation_process/translation_memory', + 'translation_process/managing_translation_memories', 'translation_process/machine_translation', 'translation_process/ai_translator', 'translation_process/ai-playground', From 29f79c68f5da15c9e538932c59441984b462a3c8 Mon Sep 17 00:00:00 2001 From: Daniel Krizan Date: Tue, 28 Apr 2026 16:05:22 +0200 Subject: [PATCH 2/4] docs: fix broken anchor link in managing_translation_memories The "Configure write rules" section slugifies to #configure-write-rules, not #write-rules. Docusaurus broken-anchors check fails the build. --- platform/translation_process/managing_translation_memories.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/platform/translation_process/managing_translation_memories.mdx b/platform/translation_process/managing_translation_memories.mdx index febe8665b..e37eb3689 100644 --- a/platform/translation_process/managing_translation_memories.mdx +++ b/platform/translation_process/managing_translation_memories.mdx @@ -48,7 +48,7 @@ Create a shared memory when you want a single source of approved translations th 2. Enter a `Name` that describes its scope (for example, `Marketing copy` or `iOS app`) 3. Pick a `Base language` — every project assigned to this memory must use the same base language 4. Set a `Default penalty` (0–100%) — the penalty is subtracted from match scores when suggestions from this memory appear in the editor -5. Optionally toggle `Only accept reviewed translations` to gate writes (see [Write rules](#write-rules) below) +5. Optionally toggle `Only accept reviewed translations` to gate writes (see [Configure write rules](#configure-write-rules) below) 6. Optionally add the projects this memory should cover, with read or write access and a per-project penalty 7. Click `Create` From db0f7181ae0fc6fd6d8da4430b8809e856adf16a Mon Sep 17 00:00:00 2001 From: Daniel Krizan Date: Tue, 28 Apr 2026 16:55:04 +0200 Subject: [PATCH 3/4] docs: nest TM pages under a Translation Memory category Sidebar restructure: turn the single Translation Memory entry into a category landing on translation_memory.mdx, with two children labelled "Matches in the editor" (translator-facing) and "Manage memories" (admin-facing). Page titles unchanged. --- sidebarPlatform.js | 19 +++++++++++++++++-- 1 file changed, 17 insertions(+), 2 deletions(-) diff --git a/sidebarPlatform.js b/sidebarPlatform.js index ad497d89f..50db8be1e 100644 --- a/sidebarPlatform.js +++ b/sidebarPlatform.js @@ -58,8 +58,23 @@ module.exports = { label: 'Translation Process', type: 'category', items: [ - 'translation_process/translation_memory', - 'translation_process/managing_translation_memories', + { + label: 'Translation Memory', + type: 'category', + link: { type: 'doc', id: 'translation_process/translation_memory' }, + items: [ + { + type: 'doc', + id: 'translation_process/translation_memory', + label: 'Matches in the editor', + }, + { + type: 'doc', + id: 'translation_process/managing_translation_memories', + label: 'Manage memories', + }, + ], + }, 'translation_process/machine_translation', 'translation_process/ai_translator', 'translation_process/ai-playground', From bf62051420514a467db40e7f3e76c6411d85ec00 Mon Sep 17 00:00:00 2001 From: Daniel Krizan Date: Wed, 6 May 2026 11:37:35 +0200 Subject: [PATCH 4/4] docs: drop redundant Translation Memory child in sidebar When the category links to translation_memory.mdx, listing the same doc as a child makes the parent header and the first sub-item point to the same URL. Keep only Manage memories as a child so the category header itself serves as the link to the editor-side page. --- sidebarPlatform.js | 5 ----- 1 file changed, 5 deletions(-) diff --git a/sidebarPlatform.js b/sidebarPlatform.js index 50db8be1e..166e5601a 100644 --- a/sidebarPlatform.js +++ b/sidebarPlatform.js @@ -63,11 +63,6 @@ module.exports = { type: 'category', link: { type: 'doc', id: 'translation_process/translation_memory' }, items: [ - { - type: 'doc', - id: 'translation_process/translation_memory', - label: 'Matches in the editor', - }, { type: 'doc', id: 'translation_process/managing_translation_memories',