Skip to main content

We built an i18n format converter for 32 formats. Notes on the strange ones.

2026-06-01

We built an i18n format converter for 32 formats. Notes on the strange ones.

Every localization team eventually hits the same wall. Their content lives in one format, but a tool they need wants another: JSON in, Android XML out; PO in, XLIFF out; iOS Strings in, xcstrings out. Plenty of converters exist, but few round-trip plurals, comments, and translator state without silently throwing data away.

We built i18n-convert, a single Rust binary that converts between 32 i18n file formats (Android XML, iOS Strings, iOS stringsdict, xcstrings, XLIFF 1.2, XLIFF 2.0, PO, ARB, RESX, TMX, SRT, Excel, Qt Linguist, Java properties, YAML Rails, JSON variants, TOML, JSON5, HJSON, NEON, INI, PHP/Laravel, Markdown, plain text, CSV, TypeScript, JavaScript, iSpring XLIFF, Adobe Captivate XML, and others) through a single intermediate representation that preserves what most tools drop.

Why we built another converter

We kept being burned by the converters we already had. Working on translation tooling that has to read and write almost any localization file a customer might send us, we tried, in roughly this order: pandoc (general-purpose, but only knows about a couple of i18n formats and treats the rest as plain text); the format-specific Python scripts that ship with gettext, with babel, with the Android SDK; a handful of browser-based "online converters"; and two commercial SaaS converters that promise "round-trip everything." Every one of them failed at least one of the four properties we care about.

Translator state must survive the round trip. A needs_review flag set by a translator in xcstrings, or a fuzzy flag in PO, or the state="needs-review-translation" attribute on a XLIFF <target>, is the only signal downstream tools have that a string is not ready to ship. Every converter that flattens to a key/value dictionary drops this. Two of the tools we tried even drop it silently, with no warning and no log line, so the first sign anything is wrong is a release that ships with machine-translated drafts displayed to users.

Plurals must not be mangled. This is the single hardest problem in i18n format conversion, and it is where most tools quietly fail. The formats disagree on the conceptual model as well as the syntax. PO uses a numeric Plural-Forms header (nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : ...)); Android XML uses CLDR categories (zero/one/two/few/many/other); ICU MessageFormat (used inside ARB) inlines plural logic into the string itself, and supports both =N exact matches and category fallbacks; some integer-indexed systems (notably older Qt) just number the variants [0], [1], [2]. Going from a category system to an integer-indexed system requires knowing the locale's plural rules to assign categories to indices; going the other way requires the inverse mapping. Most converters punt by emitting only the other form.

Nested keys must not silently collide. Convert a YAML or JSON tree with the keys user.name and user["name"] into Java properties, which is flat, and a naive converter will overwrite one with the other. Convert flat keys like nav_home and nav_about into Android XML and back to nested JSON, and you need a deterministic rule for whether the underscore is a delimiter or part of the key. We watched a tool concat keys with a dot, then try to read its own output back and crash on the dotted-key edge cases.

Data loss must be explicit. If a target format cannot represent something (CSV cannot express plurals, plain text cannot carry comments, Android XML cannot store translator-state), the converter must say so, by name, before it overwrites a file. "It worked, here is the output" is unacceptable when a quarter of the metadata is gone.

We are not the first to want this. translate-toolkit covers a wide format range, i18next-converter does decent JSON/PO conversion, and the formatjs extractor handles ICU well; we used all of them at one point. None of them does all four properties across all the formats we needed, so we wrote one.

The formats were designed in isolation, by different vendors, with different concepts of what a translatable string even is. iOS has stringsdict and xcstrings variations; Android has resource arrays and quantity strings; gettext has msgid/msgstr pairs with header metadata; XLIFF has source/target segments with state machines; ICU MessageFormat has nested select/plural expressions inlined into a single string. Building one tool that does all of this losslessly means picking a conceptual model that is a superset of all of them, and most existing tools refuse to do that. They ship with one format's model baked in and treat the others as second-class.

The intermediate representation: how 32 formats fit one model

The core of i18n-convert is a single Rust type, I18nResource, that every parser produces and every writer consumes. Every conversion is Source → Parser → I18nResource → Writer → Target. The IR has to be expressive enough to represent everything any one format supports, and tolerant enough that a writer for a less-expressive format can degrade gracefully.

┌──────────────────────────────────────────────────────────────┐
│                       I18nResource                           │
│                                                              │
│   metadata: ResourceMetadata                                 │
│     ├─ source_format, locale, source_locale                  │
│     ├─ headers, properties, encoding, direction              │
│     ├─ tool_name, tool_version, created_at, modified_at      │
│     └─ format_ext: Option<FormatExtension>  ◄─── per format  │
│                                                              │
│   entries: IndexMap<String, I18nEntry>                       │
│     │                                                        │
│     └── I18nEntry                                            │
│         ├─ key: String                                       │
│         ├─ value: EntryValue                                 │
│         │    ├─ Simple(String)                               │
│         │    ├─ Plural(PluralSet { zero, one, two,           │
│         │    │                     few, many, other,         │
│         │    │                     exact_matches,            │
│         │    │                     range_matches,            │
│         │    │                     ordinal })                │
│         │    ├─ Array(Vec<String>)                           │
│         │    ├─ Select(SelectSet { variable, cases })        │
│         │    └─ MultiVariablePlural(pattern, variables)      │
│         │                                                    │
│         ├─ comments: Vec<Comment>                            │
│         │    └─ role: Developer | Translator |               │
│         │            Extracted | General                     │
│         ├─ source, previous_source, previous_comment         │
│         ├─ placeholders: Vec<Placeholder>                    │
│         ├─ state: Option<TranslationState>                   │
│         ├─ approved, obsolete, translatable                  │
│         ├─ max_width, min_width, max_bytes, ...              │
│         ├─ device_variants: Option<Map<DeviceType, Value>>   │
│         ├─ alternatives: Vec<AlternativeTranslation>         │
│         ├─ source_references: Vec<SourceRef>                 │
│         └─ format_ext: Option<FormatExtension>  ◄─── per fmt │
└──────────────────────────────────────────────────────────────┘

The plural set is a CLDR-category superset. PluralSet has five optional named slots (zero, one, two, few, many) plus a required other, and on top of that it has an exact_matches: IndexMap<u64, String> field for ICU-style =0 / =1 exact-count variants and a range_matches: Vec<PluralRange> field for numeric ranges, though no parser fills either one and only the ARB writer reads exact_matches. The ordinal: bool flag distinguishes cardinal plurals (one apple, two apples) from ordinal plurals (1st, 2nd, 3rd); the categories are the same, but the rule that picks them is different. A PO parser assigns the indexed forms to categories by position, using the nplurals count from the Plural-Forms header (2 if there is none) in a simplified table rather than the target locale's CLDR rules; a writer going to PO does the inverse with the same count. A category outside that table is dropped quietly, with no warning.

Comments carry roles. PO distinguishes between # (translator), #. (extracted from source), and #: (source reference). Android XML uses generic XML comments but they're conventionally treated as developer notes for translators. XLIFF has <note from="developer"> and <note from="translator"> explicitly. xcstrings has a single comment field that is semantically "extracted from source." The IR has a CommentRole enum with Developer, Translator, Extracted, and General, and parsers fill the right one. Writers for formats that distinguish roles emit them properly; writers for formats that don't (Android XML, plain text) collapse roles into a single comment block.

Format-specific extensions sit on every level. ResourceMetadata and I18nEntry each carry an optional format_ext: Option<FormatExtension>. FormatExtension is an enum with one variant per format (AndroidXmlExt, XcstringsExt, ArbExt, ...) holding data that doesn't fit anywhere else in the IR but is needed for byte-equivalent round trips. The Android XML extension records the formatted="false" attribute and the product qualifier; the ARB extension keeps @@x-* custom fields verbatim; the iSpring XLIFF extension records which XLIFF version variant the source used. Writers for other formats ignore extensions they don't understand. So PO → IR → PO can be byte-equivalent, because the PO writer reads the PoExt extension and reconstructs the header, comment ordering, and Plural-Forms line. PO → IR → JSON is lossy on PO-specific data, but the JSON writer doesn't care; it doesn't read the PoExt.

Capability matrices drive the warnings. Each format declares 15 capability flags via a FormatCapabilities struct: plurals, arrays, comments, context, source_string, translatable_flag, translation_state, max_width, device_variants, select_gender, nested_keys, inline_markup, alternatives, source_references, custom_properties. Before a write, the converter walks the IR and diffs what's present against what the target supports, for every flag except translatable_flag, nested_keys, and inline_markup. Each mismatch becomes a DataLossWarning with a severity (Info, Warning, Error), a message, the affected keys, and the lost attribute. The CLI prints each severity and message and prompts for confirmation; --force skips the prompt; --dry-run shows the warnings without writing anything.

For any format F, we aim for F → IR → F to produce a byte-equivalent file. We get there for most formats but not for a couple. XML namespace declaration ordering is one example where strict byte-equivalence is impossible without preserving the original DOM verbatim, and for those the round trip is semantically equivalent: every translatable value, comment, state, and metadata field survives, even if the bytes differ by whitespace or attribute order.

The formats nobody talks about

Most of the writing on i18n format conversion is about JSON → some-other-thing or PO → XLIFF. The formats in this section get less attention, mostly because they're scoped to a single platform, framework, or vendor. They're also where the most interesting design decisions live.

xcstrings: Apple's String Catalog

Apple introduced xcstrings in Xcode 15 as a single replacement for .strings, .stringsdict, and ad-hoc per-locale folder hierarchies. It is JSON, schema-versioned ("version": "1.0"), and it embeds both plural variations and device variations alongside translation state per locale. Most third-party tools treat xcstrings as a glorified .strings file and either drop the variations or refuse the file outright.

Variations nest under a single per-locale block. A string with both a plural and a device variation holds two separate variation trees under the same key, with no Cartesian product. In the IR, this lands as an entry whose value is either a Plural(PluralSet) or whose device_variants field is populated, but typically not both for the same key. (The IR can technically hold both; the writers for formats that lack one or the other will warn.)

A real example from the test fixtures: an Arabic plural for item_count carries all six CLDR categories (Arabic uses all six). PO has no named categories, only indexed msgstr[N] forms, so the writer needs a form count. It does not consult Arabic's plural rules. It reads nplurals from the resource's Plural-Forms header and uses 2 when there is none, so an xcstrings source, which has no such header, comes out with only the one and other forms, and the other four are dropped without a warning. A PO resource whose header declares nplurals=6 keeps all six:

msgid "%lld item"
msgid_plural "%lld items"
msgstr[0] "لا عناصر"
msgstr[1] "عنصر واحد"
msgstr[2] "عنصران"
msgstr[3] "%lld عناصر"
msgstr[4] "%lld عنصرًا"
msgstr[5] "%lld عنصر"

The index-to-category mapping is a fixed table per nplurals value, not a CLDR lookup. With six forms it maps zero → 0, one → 1, two → 2, few → 3, many → 4, other → 5, which matches Arabic. Going the other way, a PO file with six indexed forms parses to a PluralSet with all six named slots filled. The XcstringsExt extension records version: "1.0" and any extraction_state so that an xcstrings → PO → xcstrings round trip restores the JSON's schema version exactly.

The state field is per-string-unit. The IR's TranslationState enum has variants for the xcstrings states the converter reads (new, translated, needs_review, stale) plus others that other formats need, such as Final, and writers map gracefully across formats: a xcstrings needs_review becomes a PO fuzzy flag or an XLIFF state="needs-review-translation", and Android XML, which has no state field, drops it with a warning.

ARB: Flutter's Application Resource Bundle

ARB looks like JSON until you notice the metadata pattern. Every translatable key foo is paired with a sibling key @foo that holds a JSON object of metadata. File-level metadata sits under double-@ keys: @@locale, @@last_modified, @@author, and the convention-blessed @@x-* for custom fields.

{
  "@@locale": "en",
  "itemCount": "{count, plural, =0{No items} one{1 item} other{{count} items}}",
  "@itemCount": {
    "description": "Number of items in the cart",
    "placeholders": {
      "count": { "type": "int", "example": "3" }
    }
  }
}

The hard part is that the plural is encoded inside the value string itself as ICU MessageFormat. We do not expand it on read: the ARB parser keeps itemCount as a Simple(String) holding the ICU text, so ARB → ARB keeps the plural exactly as written, and converting to another format copies that text across as an ordinary string without any plural warning. The @itemCount sibling becomes a comments entry with role Extracted and placeholders populated from the metadata. The ARB writer does expand in the other direction: it renders a Plural(PluralSet) from the IR as ICU text, so Android <plurals> converted to ARB come out as {count, plural, ...} strings.

ARB also supports select expressions in the same inline-ICU style, {gender, select, male{Mr. ...} female{Ms. ...} other{Dear ...}}, and the parser keeps those as text too. The IR has a Select(SelectSet { variable, cases }) value that the ARB writer renders as ICU, but no parser builds one, so an ARB select string reaches other formats as plain text and the converter prints no select warning for it.

The @@x-* custom fields are project-specific: Flutter tooling, Google's internal localization pipelines, and third-party tools all add their own. The ArbExt extension holds them as an IndexMap<String, serde_json::Value> so an ARB → IR → ARB round trip preserves them verbatim, even if no other format in the chain understands what @@x-myCompany-reviewerEmail means.

NEON: the Czech YAML-but-not

NEON is the configuration language for the Nette framework, used heavily in Czech and Slovak PHP shops and a few Drupal-adjacent projects. It looks like YAML at first glance (indent-sensitive blocks, key-value pairs, comments starting with #, list syntax with leading dashes), but the scalar parsing rules differ in ways that bite. NEON allows tab indentation and has its own datetime literal syntax. It supports entity-like values with parentheses: Color(red, green, blue). Like YAML 1.1, it reads unquoted yes and no as booleans, so i18n-convert keeps every NEON value as a string and quotes yes, no, true, false, and null when it writes. These differences matter for i18n because NEON files often hold locale data for Nette's translation extension, and a YAML parser will silently coerce strings that happen to look like booleans or numbers into the wrong type.

A NEON fixture from the test suite:

# Application strings
greeting: Hello

# Farewell message shown on exit
farewell: Goodbye

app_name: My App

# Navigation section
nav:
	# Home page link
	home: Home
	about: About

The IR attaches each comment to the entry directly below it (# Application strings to greeting, # Home page link to nav.home) with the General role and no annotation target; the comment above the nav section header (# Navigation section) is dropped on read. Nested keys are flattened to nav.home and nav.about in the IR's flat IndexMap, with the dot serving as the canonical delimiter; the NEON writer reconstructs the nesting. Plurals follow Nette's underscore-suffix convention, items_one and items_other, which the NEON parser groups into a single Plural(PluralSet) entry keyed items, matching how Nette's Translator::translate would resolve them at runtime.

HJSON: comments and trailing commas in JSON's clothing

HJSON ("Human JSON") is JSON minus the syntactic friction: unquoted keys, unquoted single-line strings, // and /* */ comments, trailing commas, and triple-quoted ''' multi-line strings. It is popular for hand-edited configuration files and shows up as a locale format in a few Node and Electron projects.

{
  // Nested HJSON example
  common: {
    greeting: Hello
    farewell: Goodbye
  }
  pages: {
    home: {
      title: Home Page
      description: Welcome to our website
    }
    about: {
      title: About Us
    }
  }
  simple_key: A top-level value
}

The trouble with converting HJSON via a strict JSON parser is that you lose every comment. Strict JSON parsers can be written to be tolerant of unquoted keys and trailing commas, but they cannot recover comments; those bytes are gone before the parser produces a value. Our HJSON parser keeps comments tied to the key that follows them, with role Developer if they're block comments above a key and General if they're floating between sections.

Triple-quoted multi-line strings are another HJSON-specific feature. They preserve indentation and line breaks, and they're commonly used for long-form translator notes or extracted source paragraphs. The IR's Simple(String) holds the dedented content; the HjsonExt extension is empty but reserved for future use (the format itself doesn't have many features to extend on).

iSpring XLIFF: the non-standard standard

iSpring Suite is a Russian-developed e-learning authoring tool, very popular in corporate training pipelines, that exports translation jobs as XLIFF. Its XLIFF is almost OASIS XLIFF 1.2, but not quite. The differences are subtle enough to slip past a quick visual inspection and severe enough to break strict XLIFF parsers.

A sample:

<?xml version="1.0" encoding="UTF-8"?>
<xliff version="1.2" xmlns="urn:oasis:names:tc:xliff:document:1.2">
  <file original="ispring_course" source-language="en"
        target-language="fr" datatype="plaintext">
    <header>
      <tool tool-id="ispring" tool-name="iSpring Suite"/>
    </header>
    <body>
      <trans-unit id="slide1_title">
        <source>Introduction to the Course</source>
        <target>Introduction au cours</target>
      </trans-unit>
      ...
    </body>
  </file>
</xliff>

iSpring uses XLIFF 1.2 element names but mixes in elements with the iSpring namespace, drops the xml:lang attributes that strict XLIFF expects on <source> and <target>, and embeds slide-position metadata in attributes that aren't part of the XLIFF 1.2 spec. Most XLIFF parsers either crash on the unrecognized attributes or pass them through as opaque blobs. We have a dedicated ispring-xliff parser because the heuristics that identify it (the tool-id="ispring" hint, plus the missing xml:langs) need to be distinct from generic XLIFF 1.2 detection. Auto-detection lets a regular .xliff file go through the strict parser, and only files explicitly typed ispring-xliff or recognized via the tool-id hint take the lenient path. The IspringXliffExt extension records which sub-variant of the format the file used so that an iSpring → iSpring round trip stays byte-equivalent.

Adobe Captivate XML: inline rich text in translatable strings

Adobe Captivate is another e-learning authoring tool, this one with deeper history and a more idiosyncratic export format. Captivate exports translation jobs as XML with XLIFF-shaped containers but Captivate-specific attributes: css-style directly on <trans-unit> elements, inline markup with non-XLIFF tags inside <source> text, and slide and item IDs that double as keys.

<trans-unit id="slide_1_item_1" css-style="font-family:Arial;font-size:24px;">
  <source>Course Title</source>
</trans-unit>
<trans-unit id="slide_2_item_1" css-style="font-weight:bold;">
  <source>Section Header</source>
  <note>Main section heading</note>
</trans-unit>
<trans-unit id="slide_3_item_1" css-style="text-align:center;font-size:18px;">
  <source><g id="1" ctype="bold">Final Exam</g> - Read carefully</source>
</trans-unit>

The inline <g id="1" ctype="bold"> element inside the source text is an XLIFF inline-element pattern, but Captivate uses it to mean "make this run bold in the slide's rendered text," and the bold portion has to survive translation as a single span. If a translator's tool unwraps the <g> element, the formatting is lost; if a converter strips it, the IR loses fidelity entirely. The Captivate parser preserves the <g> markers inside the IR's value string as inline placeholders, recorded in the entry's placeholders list with type information. The CaptivateXmlExt extension records the css-style attribute per entry and the slide/item ID pair (which together compose the key in Captivate's internal model). Going Captivate → IR → CSV is lossy on the inline formatting but preserves the strings themselves; going Captivate → IR → Captivate is byte-equivalent because every Captivate-specific attribute lives in the extension.

Real conversions, real warnings

The CLI is built around the principle that surprises are bugs. When a conversion loses an attribute the tool checks, it prints a warning before writing, and the warning names the attribute that's being dropped and how many entries are affected. The three walk-throughs below all use the canonical fixtures.

JSON to Android XML, the boring lossless case. This is the most-requested conversion in mobile localization, and it's also the easiest because both formats are simple key/value stores. Input:

{
  "welcome": "Welcome to our app",
  "goodbye": "See you later",
  "app_title": "My Application"
}

Command and output:

$ i18n-convert simple.json --to android-xml -o strings.xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_title">My Application</string>
    <string name="goodbye">See you later</string>
    <string name="welcome">Welcome to our app</string>
</resources>

No warnings. The entries come out alphabetized because the JSON reader sorts object keys; the Android XML writer keeps the order it receives. The writer does not check key names, so keys with dots, hyphens, or leading digits are written as-is, without a warning.

Android XML to iOS Strings, with comments and a translatable flag. This one looks lossless on the surface, but Android has a translatable="false" flag that iOS Strings has no native way to express. Input:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <!-- App name -->
    <string name="app_name">My App</string>
    <string name="greeting">Hello, World!</string>
    <string name="untranslatable" translatable="false">DEBUG_MODE</string>
</resources>

Output:

$ i18n-convert simple.xml --to ios-strings -o Localizable.strings
/* App name */
"app_name" = "My App";

"greeting" = "Hello, World!";

"untranslatable" = "DEBUG_MODE";

The XML comment becomes a /* */ C-style comment above its entry; that's the IR's General role being rendered through the iOS Strings writer. The translatable="false" flag is in the IR (I18nEntry.translatable = Some(false)), but iOS Strings has no syntax to express it, so the entry is written normally and the flag is dropped. We declare a translatable_flag capability but the data-loss check does not compare it, so this conversion prints no warning:

$ i18n-convert simple.xml --to ios-strings --dry-run
No data loss warnings.

If a downstream tool needs the flag, or you plan to round trip back to Android, carry it across yourself; nothing in the output tells you it was dropped.

PO to XLIFF 2, where the metadata model differs. PO encodes its target language in a header pseudo-entry; XLIFF 2 wants it on the <xliff> root. Input:

# Simple PO file for testing
msgid ""
msgstr ""
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: de\n"
"MIME-Version: 1.0\n"

msgid "Hello"
msgstr "Hallo"

msgid "Goodbye"
msgstr "Auf Wiedersehen"

msgid "Welcome to %s"
msgstr "Willkommen bei %s"

Output:

$ i18n-convert simple.po --to xliff2 -o simple.xliff
<?xml version="1.0" encoding="UTF-8"?>
<xliff xmlns="urn:oasis:names:tc:xliff:document:2.0" version="2.0" trgLang="de">
  <file id="f1">
    <unit id="Hello">
      <segment>
        <source>Hello</source>
        <target>Hallo</target>
      </segment>
    </unit>
    <unit id="Goodbye">
      <segment>
        <source>Goodbye</source>
        <target>Auf Wiedersehen</target>
      </segment>
    </unit>
    <unit id="Welcome to %s">
      <segment>
        <source>Welcome to %s</source>
        <target>Willkommen bei %s</target>
      </segment>
    </unit>
  </file>
</xliff>

The Language: de header becomes trgLang="de" on the root. The %s placeholder is preserved verbatim in both the source and target; neither format requires lifting it into a structured placeholder element. No warnings: every PO concept has an XLIFF 2 equivalent here. When the PO file has plurals, the nplurals count in the Plural-Forms header decides which CLDR category each indexed msgstr[N] form gets, but the XLIFF 2 writer has no plural support. Run a PO file with two plural entries through --to xliff2 or --to csv and you get [ERROR] 2 entries have plurals that will be lost and a prompt; --force writes only the other form for each.

The warnings have three severities. Error is for structured values the target cannot hold: plurals, arrays, select/gender, and device variants, such as plurals going to CSV. Warning is for annotations the target has no field for: comments, context, and source strings. Info is for translation state, max-width constraints, alternative translations, source references, and custom properties.

What it doesn't do (and why that's fine)

It doesn't translate content. i18n-convert changes the shape of your localization files. It does not translate Hello to Hallo. If you want translation, that's a different problem; see i18nagent.ai's MCP server, which is the AI translation tool we built around the same 32 formats and which talks to Claude or any MCP-aware client. The two stay separate because format conversion is a pure, deterministic transformation and AI translation is a stochastic, model-driven one. Combining them in a single binary would mean shipping a CLI that depends on network access and API keys to do a job that should be offline-only.

It doesn't have a GUI. The people who hit this problem are mostly engineers who script their build pipelines, and a CLI plugs into Make, npm scripts, cargo make, GitHub Actions, GitLab CI, and Bazel without any wrapping. A GUI is a different product for a different audience; building one would dilute focus.

It doesn't auto-detect locale from file content. Format detection uses the extension plus content sniffing (@@locale in JSON for ARB, the xcstrings schema marker, the XML root element, etc.), but locale detection is purely from explicit metadata: the Language: header in PO, the xml:lang or target-language attribute in XLIFF, and the @@locale field in ARB. If your input file has no locale metadata, the IR's locale is None and downstream writers either inherit from CLI flags or warn. Guessing locale from content (statistical text analysis) is unreliable for short translation files. A wrong guess selects the wrong plural rules, so plural entries come out confident-but-wrong, which is worse than no output.

It doesn't try to be a translation memory. It has no fuzzy match database, no reuse of past translations, and no TM exchange beyond writing TMX files when asked. Translation memory is its own discipline with its own tools (OmegaT, MemoQ, Trados, Phrase TMS), and we have no intention of building a TM badly when existing tools do it well.

Get it

  • npm: npm install -g @i18n-agent/i18n-convert
  • crates.io: cargo install i18n-convert
  • Homebrew: brew install i18n-agent/tap/i18n-convert
  • GitHub: github.com/i18n-agent/i18n-convert

If you want translation too, i18nagent.ai is the MCP server we built to add AI translation across the same 32 formats to Claude and other AI tools.