Tools and software
XLIFF: The XML Localization Interchange Format Translators Actually Ship
XLIFF is the OASIS XML Localization Interchange File Format that round-trips source and target segments, inline tags, and state metadata between CAT tools and
XLIFF is the interchange file every CAT tool reads when a bilingual project crosses a tool boundary. It carries source and target segments, inline tags, and state metadata without losing fidelity. Every certified-translation production lane that starts in one editor and finishes in another leans on XLIFF to make the handoff survive.
Key points
- XLIFF stands for XML Localization Interchange File Format and is maintained by the OASIS XLIFF Technical Committee, which has governed the standard since its first release in 2002.
- The format has evolved through five active versions — 1.0 (2002), 1.1, 1.2 (2008), 2.0 (2014), and 2.1 — with XLIFF 2.1 being the current OASIS Standard.
- XLIFF 1.2 is accepted by Trados, memoQ, Phrase, Smartcat, OmegaT, MateCat, and Wordfast; XLIFF 2.0 is accepted by Trados, memoQ, Phrase, and OmegaT, while cloud platforms continue to close the 2.x adoption gap.
- SDLXLIFF is Trados's native dialect and MQXLIFF is memoQ's — both lose fidelity outside their native tool, while plain XLIFF round-trips cleanly across Phrase, Smartcat, OmegaT, Wordfast, and MateCat.
- Common file extensions are
.xliff,.xlf,.sdlxliff,.mqxliff, and.txlf, each signaling the tool ecosystem it originated from. - A certified-lane LQA gate runs on XLIFF output at $40–$90 per 1,000 words against an MQM-style scorecard aligned to ISO 17100.
- XLIFF 2.x requires BCP 47 tags verbatim in the
source-languageandtarget-languageattributes on the<file>element, so region variants likees-MXorzh-Hantpass through unchanged. - Extraction filters support a wide range of source file formats including HTML, RESX, RTF, Microsoft Office documents, Adobe InDesign, Adobe FrameMaker, and plain text, mapping translatable strings directly into
<source>elements.
What is XLIFF, and why does every CAT tool read it?
XLIFF is the XML Localization Interchange File Format, an OASIS open standard that stores source and target segments, inline tags, translation state, and metadata so bilingual content round-trips between CAT tools, translation management systems, and build pipelines without data loss. It exists so a project started in memoQ can finish in Trados, and so an Angular developer's export arrives at the translator with segment IDs intact.
Four terms disambiguate the format from its neighbors on the SERP.
| Term | What it is | When you need it |
|---|---|---|
| XLIFF | Live bilingual interchange file for one project | Moving source-plus-target between CAT tools or a TMS |
| TMX | Translation-memory exchange format across projects | Importing/exporting the cumulative TM between tools |
| TBX | Term-base exchange format | Moving terminology sets between tools |
| SDLXLIFF / MQXLIFF | Vendor dialects of XLIFF | Only when the receiving tool is the native editor |
What does XLIFF stand for, and who maintains it?
XLIFF stands for XML Localization Interchange File Format and is maintained by the OASIS XLIFF Technical Committee, which has shepherded the specification since version 1.0 in 2002. OASIS publishes the schema, the conformance rules, and the module definitions that CAT-tool vendors implement.
Why did the localization industry need an interchange file format at all?
Before XLIFF, every CAT tool and TMS used proprietary bilingual formats. Translators re-keyed or re-aligned segments every time a project crossed a tool boundary. XLIFF normalizes the interchange so segment IDs and state survive the hop. One open XML schema replaced a dozen closed binary ones, and that is the only reason a modern Angular → Phrase → Trados → build pipeline works at all.
How is an XLIFF file structured inside?
An XLIFF file is XML with a root <xliff> element wrapping one or more <file> elements; each <file> contains a <body> with <trans-unit> (1.2) or <unit>/<segment> (2.x) elements that pair a <source> with a <target>, plus <note>, inline tags, and attributes like id, state, and xml:space. The schema is strict, which is what makes round-tripping possible.
flowchart TD A[xliff root] --> B[file element] B --> C[header] B --> D[body] D --> E[trans-unit] E --> F[source] E --> G[target] E --> H[note] E --> I[alt-trans]
What are the core XLIFF elements a translator will see?
The core XLIFF elements are <xliff>, <file>, <header>, <body>, <trans-unit>, <source>, <target>, <note>, and <alt-trans>, with inline placeholder tags like <g>, <x>, <bpt>, <ept>, and <ph> protecting formatting and variables.
| Element | Role |
|---|---|
| <xliff> | Root element; declares version and namespace |
| <file> | Wraps one source file; carries source-language and target-language |
| <header> | Project metadata, tool info, phase groups |
| <body> | Container for translatable content |
| <trans-unit> | Segment pair in XLIFF 1.2 (replaced by <unit>/<segment> in 2.x) |
| <source> | Original string |
| <target> | Translated string |
| <note> | Developer or reviewer context |
| <alt-trans> | Pretranslation suggestions from TM or MT |
| <g>, <x>, <bpt>, <ept>, <ph>, <sub> | Inline placeholders protecting formatting, variables, and markup |
Which XLIFF attributes carry the metadata that matters?
The attributes that drive production decisions are id, state, translate, xml:space, source-language, target-language, resname, and approved — each one controls how a CAT tool renders or locks the segment.
- id — the segment key; stays stable across the round-trip
- state — new, needs-translation, needs-review-translation, translated, signed-off, final
- translate — yes or no; locks a segment from the editor
- xml:space — preserve keeps whitespace exact
- source-language and target-language — BCP 47 tags on the <file> element
- resname — developer-facing resource key
- approved — reviewer sign-off flag
What does a real trans-unit look like in a bilingual XLIFF sample?
A real trans-unit pairs a <source> and <target> under a shared id, with inline <g> or <ph> tags wrapping formatting, a <note> carrying developer context, and a state attribute tracking where the segment sits in the workflow.
<trans-unit id="btn.save" approved="no"> <source xml:space="preserve">Save <g id="1" ctype="x-strong">now</g></source> <target state="needs-translation" xml:space="preserve">Guardar <g id="1" ctype="x-strong">ahora</g></target> <note from="developer">Primary CTA on billing screen</note> <alt-trans match-quality="92"> <source>Save now</source> <target>Guardar ahora</target> </alt-trans> </trans-unit>
- id="btn.save" — the developer's resource key, surfaced as resname context
- <g id="1"> — inline tag protecting the bold markup; the id matches source to target
- state="needs-translation" — tells the TMS this target has not been produced yet
- <note from="developer"> — context that changes the translator's register
- <alt-trans match-quality="92"> — a 92% TM suggestion pre-populated before the human opens the file
Which XLIFF versions exist, and which one will a translator actually open?
Four XLIFF versions are in active circulation: 1.0 (2002), 1.1, 1.2 (2008, the industry workhorse), and the OASIS Standard 2.0 (2014) with its 2.1 revision. XLIFF 1.2 remains the default across desktop CAT tools, while 2.x adoption is strongest in Trados, memoQ, Phrase, and OmegaT.
What changed between XLIFF 1.2 and XLIFF 2.0?
XLIFF 2.0 replaced <trans-unit> with <unit> and <segment>, split modules out of the core schema, tightened BCP 47 language-code conformance, and simplified inline markup. The tradeoff is stricter validation and partial back-compatibility.
- Segment container renamed from <trans-unit> to <unit> wrapping one or more <segment>
- Modules split out: translation candidates, glossary, metadata, validation, size/length restrictions
- BCP 47 required verbatim in source-language and target-language
- Inline markup simplified to <pc>, <ph>, <sc>, <ec> from the 1.2 family
- No forward-compatible parsing — a 1.2 parser cannot read 2.0
Which XLIFF version do Trados, memoQ, Phrase, Smartcat, OmegaT, MateCat, and Wordfast accept?
XLIFF 1.2 is accepted by Trados, memoQ, Phrase, Smartcat, OmegaT, MateCat, and Wordfast; XLIFF 2.0 is accepted by Trados, memoQ, Phrase, and OmegaT, while cloud-first platforms still lag on full 2.x support. The broader interoperability picture is tracked in the Computer-Assisted Translation Tools: The Working Translator's Field Guide.
| CAT tool | XLIFF 1.2 | XLIFF 2.0 |
|---|---|---|
| Trados Studio | Yes | Yes |
| memoQ | Yes | Yes |
| Phrase | Yes | Yes |
| Smartcat | Yes | Lags |
| OmegaT | Yes | Yes |
| MateCat | Yes | Lags |
| Wordfast | Yes | Lags |
What are the XLIFF file extensions, and what is the difference between.xliff,.xlf,.sdlxliff, and.mqxliff?
The common XLIFF extensions are.xliff and.xlf (both are standard XLIFF, interchangeable in most parsers),.sdlxliff (Trados Studio's dialect),.mqxliff (memoQ's dialect), and.txlf (Wordfast's variant) — the extension signals which filter the CAT tool should apply.
| Extension | Parser triggered | Round-trip fidelity outside native tool |
|---|---|---|
| .xliff | Standard XLIFF filter | Clean across Phrase, Smartcat, OmegaT, Wordfast, MateCat |
| .xlf | Standard XLIFF filter (short form) | Clean across the same tools |
| .sdlxliff | Trados Studio SDLXLIFF filter | Partial in memoQ; lossy elsewhere |
| .mqxliff | memoQ MQXLIFF filter | Partial in Trados; lossy elsewhere |
| .txlf | Wordfast TXLF filter | Native in Wordfast; lossy elsewhere |
What is an.xlf file?
An.xlf file is a standard XLIFF document — the shortened extension is widely used by Angular,.NET, and framework exporters, and it is functionally identical to.xliff for parsers that read XLIFF 1.2 or 2.x. A CAT tool opens a.xlf with the same filter it uses for.xliff.
How do SDLXLIFF and MQXLIFF differ from plain XLIFF?
SDLXLIFF is Trados's XLIFF dialect with Trados-specific namespaces for segmentation rules and TM match data; MQXLIFF is memoQ's equivalent. Both open cleanly in their native tool but lose fidelity when passed to the other — plain XLIFF opens cleanly across Phrase, Smartcat, OmegaT, Wordfast, and MateCat.
How it works
How does XLIFF move through a production translation workflow?
1
How are XLIFF files extracted from source formats like JSON, HTML,.resx, or Angular bundles?
XLIFF extraction runs through format-specific filters that map each translatable string to a discrete <trans-unit> containing a <source> element and a matching empty <target>. Angular's @angular/localize toolchain emits XLIFF 1.2 or 2.0 natively, with ICU plural and select expressions already encoded as inline elements..NET projects export .resx resources via dedicated XLIFF filters, and HTML or JSON files pass through CAT-tool parsers that handle markup languages, resource file formats like RESX, RTF, Microsoft Office products, Adobe InDesign, Adobe FrameMaker, and plain text — preserving non-translatable regions as locked placeholders. The per-stack resource-file map lives Localization Coding: How Translators and Developers Share the Resource File, and the five-format translator view sits i18n Translation: How Translators Produce Localized Builds from JSON, YAML, and XLIFF.
2
How does XLIFF handle translation memory and term bases alongside the live bilingual file?
XLIFF carries pretranslation matches inside <alt-trans> elements for 1.2 or translation-candidates module data for 2.x, while the broader translation memory travels separately as TMX and the term base as TBX. Three formats, three jobs, one workflow. The <note> element is especially important here: it carries contextual explanations that tell translators how placeholders and variables are used within a given string — for instance, clarifying that a positional argument refers to a service name while another refers to a region name, which prevents mistranslation of UI strings that contain dynamic tokens. The TM-side of the story sits TMX Files Explained: Structure, Uses, and Best Practices, and the editing options for that TM are covered TMX Tools Compared: Editing, Converting, and Managing TM Files.
3
How does XLIFF export back into the original format for the developer's build?
XLIFF export merges the translated <target> segments back into the original file format using the same filter that performed extraction, preserving placeholder order, inline tags, and non-translatable regions. A dirty state attribute or a damaged inline tag breaks the merge silently, which is why production TMS platforms validate state values before triggering the export step. Cloud TMS platforms use XLIFF as the desktop bridge between the browser editor and the developer's repository. See Crowdin Translation: How Translators and Agencies Run Projects Inside Crowdin for how that handoff works in practice.
What are the common XLIFF use cases a translator or agency will see?
The four dominant XLIFF use cases are software UI localization, web and marketing content, eLearning courseware, and continuous-delivery app builds. Each case ships XLIFF between a developer's repository or TMS and the translator's CAT editor with different segmentation and tag-density profiles.
How does XLIFF support software localization and SaaS builds?
Software localization uses XLIFF to decouple UI strings from code, so developers ship source strings as XLIFF, translators work them in a CAT tool, and the build system merges locale-specific <target> values back without touching the application logic. SaaS teams running continuous delivery push new XLIFF per sprint rather than per release.
How does XLIFF support web content and marketing localization?
Web and marketing XLIFF files carry HTML fragments wrapped in CDATA or inline <g> tags, with context-type attributes telling the translator whether a segment is body copy, a button label, or an alt attribute. Context metadata changes the translation choice — an alt-text segment reads for assistive technology, a CTA segment reads for conversion.
How does XLIFF support eLearning and courseware?
eLearning XLIFF exports from Articulate, Captivate, and LMS authoring tools bundle slide text, quiz questions, instructions, and multimedia descriptions as trans-units. Segmentation granularity drives both review cost and voiceover alignment downstream — over-segmented quizzes fragment the context, under-segmented narration breaks audio sync.
How do XLIFF language codes work across source-language, target-language, and framework stacks?
XLIFF 2.x requires BCP 47 tags verbatim in the source-language and target-language attributes on the <file> element, so region variants like es-MX or zh-Hant pass through exactly as written. XLIFF 1.2 uses the same attributes but tolerates older IANA language tag forms, which means mixed-version projects can carry inconsistent tags unless the TMS normalizes them on import. Getting the tag right at the XLIFF level matters because every downstream platform derives its own locale directory name or resource qualifier from that attribute value — a mismatch between the XLIFF tag and the target platform's expected form causes the build to drop the translation entirely or fall back to the source language.
Each target platform transforms the BCP 47 value differently: the web and XLIFF 2.x pass the tag through unchanged, Android replaces the hyphen with an r-prefixed region qualifier (producing values-es-rMX), POSIX swaps the hyphen for an underscore (producing es_MX.UTF-8), and iOS appends a .lproj suffix while keeping the BCP 47 form intact. Knowing which transformation applies to your build target is as important as knowing which XLIFF version the CAT tool exports. The full stack conversion rules sit Localization Codes: The Standards Translators and Agencies Use, and the Angular framework context sits i18n: What Internationalization Means for Translators Producing Localized Builds.
| Target platform | Language-code form | Example |
|---|---|---|
| XLIFF 2.x | BCP 47 verbatim | es-MX |
| Web | BCP 47 verbatim | es-MX |
| Android | Hyphen-less with r+region | values-es-rMX |
| POSIX | Underscore separator | es_MX.UTF-8 |
| iOS.lproj | BCP 47 with.lproj suffix | es-MX.lproj |
How does XLIFF compare with other translation file formats?
XLIFF differs from PO, RESX, strings.xml, JSON, and TS by being an interchange format rather than a native resource format. PO lives in gettext projects,.resx.NET, strings.xml on Android, JSON in JS stacks, and TS in Qt — XLIFF is what all of them convert to when they enter a CAT tool. The broader format catalog lives Localization Files: What Translators Receive, Parse, and Return.
XLIFF vs TMX: what is each actually for?
XLIFF carries the live bilingual file in flight — one project, one source-and-target pass — while TMX carries the cumulative translation memory across projects and tools. A CAT tool reads both but writes them for different jobs. The TMX reference sits TMX Files Explained: Structure, Uses, and Best Practices.
XLIFF vs JSON, PO, RESX, and strings.xml: which one does a CAT tool prefer?
A CAT tool consumes XLIFF directly and converts the others through filters. XLIFF is the safest choice for TMS round-trips because it is standardized XML. Custom-nested JSON remains the top filter-failure point across the ecosystem.
| Format | Native habitat | CAT-tool handling |
|---|---|---|
| XLIFF | Interchange, every stack | Native read and write |
| JSON | JS/TS stacks | Filter to XLIFF; nested keys risk breakage |
| PO | gettext projects | Filter to XLIFF; plural forms need mapping |
| .resx | .NET | Filter to XLIFF |
| strings.xml | Android | Filter to XLIFF; plurals via quantity tags |
| TS | Qt | Filter to XLIFF |
How do you open and edit an XLIFF file cleanly?
An XLIFF file opens cleanly in a dedicated CAT editor — Trados Studio, memoQ, Phrase, OmegaT, Smartcat, MateCat, or Wordfast — or in purpose-built XLIFF editors that render the bilingual segment pair as a structured grid. Opening it in a plain XML editor is technically possible but strips the segment-pair view, removes inline-tag protection, and risks corrupting the state attributes that the TMS relies on to track handoff status. For plain XLIFF, round-trip fidelity is clean across Phrase, Smartcat, OmegaT, Wordfast, and MateCat; for vendor dialects like SDLXLIFF or MQXLIFF, fidelity degrades outside the native tool.
Which XLIFF editors protect inline tags and state attributes?
Dedicated XLIFF editors render <source> and <target> as a bilingual grid, lock inline tags as protected objects, surface state and note attributes in-line, and validate on save so a damaged tag fails loud instead of silent. State mapping is especially important when moving files between tools: when a file produced in one CAT environment is imported into another, the receiving tool maps XLIFF state values to its own internal segment-status codes, and a missing or unrecognized state label can cause segments to appear untranslated or block the import entirely. Purpose-built XLIFF editors surface those state labels explicitly so translators correct them before the file re-enters the workflow. The editor-level comparison sits XLIFF Editors That Let You Review and Edit Bilingual Files Cleanly.
What breaks when you edit XLIFF in a non-XLIFF-aware tool?
Plain text editors break XLIFF in at least four ways: by damaging inline <g>, <ph>, <bpt>, or <ept> tags whose IDs must remain paired between source and target; by stripping xml:space="preserve" whitespace that protects code snippets and preformatted blocks; by leaving state attributes stuck on new or needs-translation so the TMS rejects the merge-back; and by silently dropping namespace prefixes through generic XML pretty-printers that do not understand XLIFF's schema. Each of these failure modes is invisible in the editor but fatal at the merge step.
- Hand-edited inline tag IDs drift out of sync between source and target, causing placeholder mismatches in the final output
- Whitespace loss corrupts code snippets and preformatted blocks that depend on
xml:space="preserve" - State left on
newblocks the merge-back step and forces manual TMS intervention - Namespace prefixes silently stripped by generic XML pretty-printers invalidate the XLIFF schema
How does XLIFF fit into a certified-translation production lane?
In a certified-translation production lane, XLIFF carries the bilingual content through pretranslation, human translation, and review, after which every file passes an LQA gate priced at $40–$90 per 1,000 words against an MQM-style scorecard aligned to ISO 17100. The TMS alone does not produce the named-translator attestation that certified work requires — the LQA gate and the certification document are two separate artifacts layered on top of the XLIFF output. XLIFF's structured state attributes make that audit trail possible, because each segment's progression from new through translated to final is machine-readable and timestamped at the TMS level.
Where does the LQA gate sit relative to the XLIFF handback?
The LQA gate runs on the translated XLIFF before merge-back, sampling output at $40–$90 per 1,000 words against accuracy, fluency, terminology, locale convention, and style. A failing score blocks publish on certified lanes regardless of which CAT tool produced the file. The scorecard aligns to ISO 17100 for the review step and borrows the MQM dimension set for error typology. Because the LQA reviewer works directly on the XLIFF bilingual file — comparing <source> and <target> segment by segment — inline tag integrity and accurate state values are prerequisites for a valid LQA pass; a reviewer cannot certify a segment whose inline tags are broken or whose state has not advanced past needs-review-translation.
How does XLIFF-based pretranslation affect certified-translation economics?
At a $0.15/word certified premium, a $525 SaaS subscription amortizes across about 3,500 certified source words; at the top of the band ($0.30 premium) it amortizes across about 1,750 words. XLIFF-based pretranslation protects that margin by letting one translator handle more throughput per LQA gate, because high-confidence TM matches arrive pre-populated <target> and require only review rather than full composition. Certified pricing runs $0.10–$0.25 per source word or
In a certified-translation production lane, XLIFF carries the bilingual content through pretranslation, human translation, and review, after which every file passes an LQA gate priced at $40–$90 per 1,000 words against an MQM-style scorecard aligned to ISO 17100. The TMS alone does not produce the named-translator attestation certified work requires — the LQA gate and the certification are two separate artifacts on top of the XLIFF output.
Where does the LQA gate sit relative to the XLIFF handback?
The LQA gate runs on the translated XLIFF before merge-back, sampling output at $40–$90 per 1,000 words against accuracy, fluency, terminology, locale convention, and style. A failing score blocks publish on certified lanes regardless of which CAT tool produced the file. The scorecard aligns to ISO 17100 for the review step and borrows the MQM dimension set for the error typology.
How does XLIFF-based pretranslation affect certified-translation economics?
At a $0.15/word certified premium, a $525 SaaS subscription amortizes across about 3,500 certified source words; at the top of the band ($0.30 premium) it amortizes across about 1,750 words. XLIFF-based pretranslation protects that margin by letting one translator handle more throughput per LQA gate. Certified pricing runs $0.10–$0.25 per source word or $25–$150 per standard 250-word page, and USCIS filings are the volume case where that math gets tested.
5–
What are the common XLIFF failure modes, and how do you avoid them?
The five common XLIFF failure modes are inline-tag loss between vendor dialects, segment ID collisions after re-segmentation, state attributes left on needs-translation blocking merge-back, mismatched source-language/target-language BCP 47 tags, and context-type metadata stripped during export. Each one corrupts the round-trip.
Why do inline tags get damaged when XLIFF crosses tools?
Inline tags get damaged when a receiving CAT tool reinterprets vendor-specific namespaces: SDLXLIFF Trados-namespace tags collapse to plain placeholders in memoQ, and MQXLIFF's segmentation markers collapse the other way. Plain XLIFF avoids both failures because it uses only the OASIS-standard inline family.
How do segment state attributes block or unblock a handback?
Segment state attributes block or unblock handbacks by signaling workflow position: new, needs-translation, and needs-review-translation keep the file in the loop, while translated, signed-off, and final mark it ready. A TMS merge step that enforces state will reject a file left on an upstream value — the fix is to sweep the state before export, not to patch it in XML by hand.
Where does XLIFF go next, and what should a translator track?
XLIFF 2.1 is the current OASIS Standard, ratified by the OASIS XLIFF Technical Committee, and it adds modules for ITS metadata integration, size and length restrictions, and advanced conformance validation. The trajectory is toward stricter module separation and tighter conformance profiles rather than another full version bump — the committee's public feedback channel exists precisely so practitioners can flag interoperability gaps before they calcify into conflicting tool implementations.
Cloud platform adoption of XLIFF 2.x is the practical signal translators should track. Trados, memoQ, Phrase, and OmegaT already accept XLIFF 2.0, but cloud-first platforms continue to close that gap at different speeds, which is what determines which version a translator actually opens on any given project. Vendor-dialect extensions — SDLXLIFF from Trados Studio and MQXLIFF from memoQ — are unlikely to disappear, so understanding where each dialect loses fidelity outside its native tool remains a durable skill. The safest long-term practice is to request or export plain XLIFF at handoff boundaries whenever the downstream tool is not the same as the authoring tool, preserving round-trip fidelity across the full supply chain.
How we handle XLIFF on certified lanes
We treat XLIFF as the single source of truth for the bilingual state of a certified project. The file arrives, the segments get pretranslated, a human translator completes the targets, and the file passes an LQA gate before it merges back. The certification is attached to the merged deliverable, not to the XLIFF — the XLIFF is the production artifact, not the legal one.
We refuse to hand-edit XLIFF in a plain XML editor to patch a broken tag or reset a state attribute. A tag that fails validation is a signal that the extraction filter is wrong, and the correct fix is in the filter, not in the file. Silent patches hide the same bug on the next sprint.
We refuse to ship SDLXLIFF or MQXLIFF to a tool that is not their native editor. The lossy translation of vendor namespaces into plain placeholders damages tag parity, and tag parity is scored on the LQA scorecard. When a vendor pool is mixed, we convert to plain XLIFF at the hand-off point.
We refuse to apply a single blanket $0.15/word rate to every XLIFF project without looking at segmentation density, inline tag count, and the state of the TM. A short-string UI XLIFF with heavy placeholder tagging does not cost the same to review as a long-prose marketing XLIFF, and a flat rate on both hides margin loss on one of them.
Related
- Translation Management System
- ATA Membership: Tiers, Dues, and What Translators Actually Get
- Back Translation: How It Works, When to Use It, and Its Limits
- American Translators Association Certification: Exam, Eligibility, and Credential Recognition
- Sworn Translator: What the Role Is and How Agencies Produce Sworn Translations
- Desktop Publishing in Adobe InDesign: The Translator's Workflow