Who owns your translation memory, and how to take it with you
この記事を日本語で読むIf you are moving off a translation vendor after several years and want to know who owns the translation memory you built together, the honest first answer is that it depends on what your agreement says and on the law that governs it. Paying for the translations does not settle it by itself, and neither does the fact that the database lives on the vendor's servers. Read the clauses listed below in your own contract, and have a lawyer qualified in the relevant jurisdiction confirm your position before you put it in writing to the vendor.
Ownership on paper is only half the problem. A memory you are entitled to can still arrive as a file that is half usable: drafts mixed with approved lines, two codes for one language, segments whose formatting tags were stripped. This article covers both halves — the contract questions, the full list of things to request, a script that tests a handed-over memory, the arithmetic of what a complete versus an incomplete memory is worth on your next update, and what to do if the file never comes. The format itself is explained in TMX and TBX explained, so it is not repeated here.
Ownership is settled by the agreement, so read these clauses first
Several documents can bear on the answer: a master services agreement, a statement of work per title, the vendor's standard terms, sometimes a purchase order that references them. Collect all of them before you ask the vendor anything, then look for the points below. None has a universal answer; each is something to confirm in your own text and, where the wording is unclear, with counsel.
- How deliverables are defined. If the agreement lists the translation memory, glossary and style guide among the deliverables, you are asking for something already promised. If deliverables means only the translated files, the memory may sit outside that definition, and that gap is the thing to take to a lawyer.
- What the intellectual property clause covers. Some clauses speak only of the translations; others extend to work product, materials or databases created for you. Note which words your clause actually uses rather than assuming the broader reading.
- What the vendor reserves as its own. Look for a clause keeping the vendor's pre-existing tools, methods and materials. A memory can mix your lines with generic interface phrases the vendor reuses elsewhere, so if such a clause exists, check how it treats that mix.
- Confidentiality. Your unreleased text sits in the memory. Check what the agreement requires the vendor to do with your confidential material when the relationship ends — return it, delete it, or keep it under obligation. That clause can matter even where ownership is unclear.
- Exit and handover terms. Look for a notice period, a duty to hand over materials on termination, the format and deadline of that handover, and whether an export fee applies. Anything not written down will be negotiated, and that is easier while the relationship is still active.
- Subcontractors. If freelance translators did the work, what the vendor can pass on to you depends on its own contracts with them. You cannot read those, but you can ask the vendor to confirm in writing that it holds what it is handing over.
If the documents say nothing about the memory, do not fill the silence with an assumption in either direction. Whether paying for translations implies anything about the database built while producing them is exactly the kind of question that differs between agreements and jurisdictions. Get advice before you take a position. In parallel, keep the conversation practical: a request framed as a list of files and a date is easier to answer than a debate about ownership.
What to request: the full handover list, not just the memory
Ask for the memory alone and you get the memory alone. Much of what kept the translations consistent lives in other documents, and a new team without them will reinvent your terminology on the first update. Put the whole list in one written request, per language, and ask for every item to be dated.
- The translation memory for every language pair and every title it covers, exported as TMX so any tool can read it. If the new vendor uses the same tool as the old one, a native export as well can carry tool-specific properties that a TMX export may drop; ask the new vendor which it wants.
- Which units are approved. A memory can hold drafts, rejected attempts and lines that never shipped next to the final text. Ask how status is recorded in the export and what the field is called, so you can filter on it.
- The glossary or termbase, including forbidden terms, usage notes and the date each term was decided. Approved character names, item names and interface terms are the fastest thing for a new team to absorb.
- Style guides for each language: register, how the player is addressed, punctuation, how numbers and units are written, length conventions.
- The query log: the questions translators asked and the answers your team gave. Those answers are decisions you made, and they may exist nowhere else.
- Metadata that ties the memory to your game: the string key on each unit, creation and change dates, and any context notes. Without the key, a two-word string cannot be told apart from the same two words on a different screen.
- A statement describing the export: character encoding, the language codes used, the number of units per language, and the export date. That unit count is what you compare against in the check below.
Test the file before you sign off the handover
A file that parses is not necessarily a file you can use. Run the well-formedness check from the TMX guide first; the script below assumes the XML is valid and looks at the content. To show what slips through, I built a ten-unit TMX 1.4 file of the kind a vendor might return — English source, Japanese target, a status property on most units — and seeded it with problems a careless export can produce. Python's standard XML parser does the counting. A separate Node count by pattern matching agreed on the totals: 10 units, 10 English variants, 8 tagged ja-JP and 1 tagged ja, 1 empty segment, 2 inline placeholder elements.
- Unit count against the vendor's statement. If the statement and the file agree, move on; if not, ask before anything else.
- Two codes for one language. One unit is tagged ja and the rest ja-JP. A tool comparing tags literally treats them as two languages, so that unit quietly stops matching. Normalise the codes on a copy, never on the original export.
- Status. Seven approved, two drafts, one with no status. Whether you import drafts is a decision, not a default: a draft can be a better start than nothing, but once imported, a match from a draft can look as authoritative as one from shipped text, unless your tool shows where each match came from.
- Empty and one-sided units. dlg.elder.01 has an empty Japanese segment and dlg.elder.02 has no Japanese at all. These are unfinished lines and add nothing to reuse.
- Duplicates and conflicts. The exact duplicate is harmless. The conflict is not an error: Continue is つづける on the menu and コンティニュー on the game-over screen, and both are right in their place. Only the key tells the next translator which screen each belongs to.
- Inline elements. The placeholder check passes because {item} survives in both languages, but the English carries two inline elements for the yellow colour tag and the Japanese carries none. The colour formatting is gone from that translation, and of the checks in this script, only the inline element count catches it.
# check.py -- run as: python3 check.py handover.tmx
# Rename 'x-status' and 'ja-JP' to what your own export uses.
import sys, re, collections
import xml.etree.ElementTree as ET
XL = '{http://www.w3.org/XML/1998/namespace}lang'
root = ET.parse(sys.argv[1]).getroot()
hdr = root.find('header')
src = hdr.get('srclang')
print('tmx version:', root.get('version'), '| srclang:', src)
tus = root.findall('./body/tu')
print('tu units:', len(tus))
langs = collections.Counter(t.get(XL) for tu in tus for t in tu.findall('tuv'))
print('tuv languages:', dict(langs))
PH = re.compile(r'\{[^}]+\}|%[ds]')
def text(seg): return ''.join(seg.itertext())
status = collections.Counter()
pairs = collections.defaultdict(set); seen = collections.Counter()
empty = []; onelang = []; inline = []; phmiss = []; tagmiss = []
for tu in tus:
st = tu.find("prop[@type='x-status']")
status[st.text if st is not None else '(none)'] += 1
tuvs = {t.get(XL): t.find('seg') for t in tu.findall('tuv')}
if len(tuvs) < 2: onelang.append(tu.get('tuid'))
for lang, seg in tuvs.items():
if text(seg).strip() == '': empty.append(tu.get('tuid') + ' ' + lang)
if len(list(seg)): inline.append(tu.get('tuid') + ' ' + lang + ' ' + str(len(list(seg))) + ' inline element(s)')
s = tuvs.get(src); tgt = [v for k, v in tuvs.items() if k != src]
if s is not None and tgt:
st_, tt = text(s), text(tgt[0])
pairs[st_].add(tt); seen[(st_, tt)] += 1
if tt.strip() and sorted(PH.findall(st_)) != sorted(PH.findall(tt)):
phmiss.append(tu.get('tuid'))
if tt.strip() and len(list(s)) != len(list(tgt[0])):
tagmiss.append(tu.get('tuid') + ' %d->%d' % (len(list(s)), len(list(tgt[0]))))
print('status:', dict(status))
print('units with only one language:', onelang)
print('empty segments:', empty)
print('segments with inline elements:', inline)
print('exact duplicate units:', sum(n - 1 for n in seen.values() if n > 1))
print('same source, different targets:', {k: sorted(v) for k, v in pairs.items() if len(v) > 1})
print('placeholder mismatch (non-empty targets):', phmiss)
print('inline element count differs (source->target):', tagmiss)
clean = set()
for tu in tus:
st = tu.find("prop[@type='x-status']")
tuvs = {t.get(XL): t.find('seg') for t in tu.findall('tuv')}
s, t = tuvs.get(src), tuvs.get('ja-JP')
if st is not None and st.text == 'approved' and s is not None and t is not None and text(t).strip() and len(list(s)) == len(list(t)):
clean.add((tu.get('tuid'), text(s), text(t)))
print('clean approved en-US/ja-JP units, duplicates removed:', len(clean), 'of', len(tus))
$ python3 check.py handover.tmx
tmx version: 1.4 | srclang: en-US
tu units: 10
tuv languages: {'en-US': 10, 'ja-JP': 8, 'ja': 1}
status: {'approved': 7, 'draft': 2, '(none)': 1}
units with only one language: ['dlg.elder.02']
empty segments: ['dlg.elder.01 ja-JP']
segments with inline elements: ['item.get en-US 2 inline element(s)']
exact duplicate units: 1
same source, different targets: {'Continue': ['つづける', 'コンティニュー']}
placeholder mismatch (non-empty targets): []
inline element count differs (source->target): ['item.get 2->0']
clean approved en-US/ja-JP units, duplicates removed: 5 of 10
# Two of the ten units, as they sit in the file:
<tu tuid="item.get">
<prop type="x-status">draft</prop>
<tuv xml:lang="en-US"><seg>You obtained <ph x="1"><color=yellow></ph>{item}<ph x="2"></color></ph>!</seg></tuv>
<tuv xml:lang="ja-JP"><seg>{item}を手に入れた!</seg></tuv>
</tu>
<tu tuid="save.slot">
<prop type="x-status">approved</prop>
<tuv xml:lang="en-US"><seg>Slot %d - %s</seg></tuv>
<tuv xml:lang="ja"><seg>スロット %d - %s</seg></tuv>
</tu>Still checking translation files by eye?
Loclint scans your CSV/JSON localization files and flags broken placeholders, untranslated strings, and encoding risks in seconds.
After all that, five of the ten units are clean, approved, tagged ja-JP and unique. The ratio is a product of the demonstration and says nothing about real exports; the point is that the number to agree on at handover is the clean count, not the file size. The status property name and language codes in the sample were made up for it, so change them to whatever your export uses.
What a complete memory is worth on the next update
A memory pays off when the new vendor runs your current source text against it and sorts every segment into match bands, each weighted according to the agreed discount grid. To see how much the completeness of the handover matters, take a hypothetical game with 120,000 source words and two hypothetical discount grids. The counts and the weights are invented for the arithmetic, not market figures; your real numbers come from the new vendor's analysis and quote.
- With the full memory, the update costs the equivalent of 58.6 to 73.8 percent of translating everything fresh, depending on the grid.
- If the export is missing recent units — here 15,000 words that would have been exact matches, plus 2,000 words of fuzzy coverage, fall to no match — the figure rises to 68.7 to 80.4 percent. The gap is 12,050 weighted words under grid A and 7,950 under grid B, on one update, and it recurs on every update that touches the same text.
- Match percentages come from the new tool's algorithm and segmentation, so the same memory can produce a different breakdown elsewhere; what a CAT tool does to your strings and your quote shows how much that calculation can vary.
- An exact match is not free under either grid, because someone still checks it in context. That is the conflicting Continue pair again: the memory offers a correct translation that may belong to another screen.
- Ask for the new vendor's analysis on your real files before the old relationship ends, so a missing slice is noticed while it can still be requested. The rest of the cost formula is in how to estimate game localization costs.
Hypothetical update: 120,000 source words run against the handed-over memory. Word counts and both discount grids are invented for illustration. band full memory memory missing recent units grid A grid B exact 54,000 39,000 0.25 0.50 95-99% 9,000 8,000 0.50 0.70 85-94% 12,000 11,000 0.70 0.85 75-84% 7,000 7,000 0.85 1.00 no match 38,000 55,000 1.00 1.00 full TM grid A | weighted 70350 | 58.6% of no-TM full TM grid B | weighted 88500 | 73.8% of no-TM TM missing recent units grid A | weighted 82400 | 68.7% of no-TM TM missing recent units grid B | weighted 96450 | 80.4% of no-TM no TM at all | weighted 120000 | 100.0% of no-TM
If the memory never arrives, rebuild from what you already hold
If the memory is refused, delayed or unusable, you are not starting from zero as long as you kept the localized string files you shipped. Whether you may hand those files to another vendor is again a question for your agreement, but technically a keyed string table is a memory in disguise: pair each source string with its translation by key and you have translation units. Below, six rows of a shipped table were paired in Node and the result run through the same check.
strings.csv (the localized string table you shipped)
key,en,ja
menu.start,Start,はじめる
menu.continue,Continue,つづける
gameover.continue,Continue,コンティニュー
shop.confirm,Buy {item} for {price} gold?,{item}を{price}ゴールドで買いますか?
dlg.elder.01,The bridge to the north washed away in last night's storm.,北の橋は、ゆうべの嵐で流されてしもうた。
credits.thanks,Thank you for playing!,
Pair by key, write TMX, run the same check:
rows: 6 | units written: 5 | skipped (no target): credits.thanks
tu units: 5
tuv languages: {'en-US': 5, 'ja-JP': 5}
status: {'(none)': 5}
same source, different targets: {'Continue': ['つづける', 'コンティニュー']}
inline element count differs (source->target): []Six rows gave five units; the row with no Japanese was skipped. The rebuilt memory has three limits. It holds only what shipped in that file, so earlier wording, revisions and anything translated but never integrated are absent. It has no status field, which matters less here because shipped text is approved by definition — the check reports zero approved units only because there is nothing to read. And formatting written in the game's own markup arrives as plain text rather than inline elements. The conflict check still flags Continue, correctly, and the key in tuid is what keeps the two apart. The demo split rows on commas naively; an export with commas inside text needs a real CSV parser.
Whichever path you take, close the move with two habits specific to handover so the question does not come back. Write the exit terms into the next agreement now: the handover list above, its format and deadline, and the acceptance test — the clean unit count, not the file size. And run the same check on every delivery, not only at the exit, so a missing slice surfaces while it is still cheap to fix. The glossary and style guide you now hold belong in the localization kit you hand to translators.
Ship your next update with every string checked
Upload a CSV/JSON file and Loclint checks every entry — placeholders, untranslated text, duplicate keys, length limits — and tracks regressions between runs.