OnlineDocTranslatorGuides

i18n-editor: What Translators Use to Edit JSON Translation Files

An i18n-editor is a desktop or web tool translators use to edit JSON, YAML and XLIFF translation files directly, with placeholder parity checks and ICU plural

Translators receive JSON handoffs faster than any other format, and a standalone i18n-editor is the surface where those files get edited without the overhead of a full TMS login or a developer's IDE.

What is an i18n-editor and what does it actually do for translators?

An i18n-editor is a desktop or browser tool that opens JSON, YAML, PO, or XLIFF translation files in a key-by-key grid, so translators edit per-locale strings side-by-side, preserve {{name}} and ICU placeholders, and save back to the same files without opening the source code or a full TMS. The editor sits on top of the engineering layer described in i18n: What Internationalization Means for Translators Producing Localized Builds and consumes what that layer emits. Its primary function is to present every translation key as an editable row in a locale-aware grid so the translator never has to parse raw JSON syntax or touch the surrounding application code.

Translation keys are the backbone of every i18n project. A well-structured i18n-editor exposes those keys alongside their source-language values and lets the translator work one cell at a time, which eliminates the most common class of handoff errors — stray commas, mismatched braces, and accidental key deletions that break a JSON parser at runtime. The editor is responsible for reading the file in, showing a structured interface, and writing the file back out in exactly the encoding and indentation the build pipeline expects.

The editor does four jobs:

  • Loads a /locales folder and parses each language file into rows.
  • Shows source and target columns side-by-side with the key locked.
  • Validates placeholder parity and ICU plural blocks on save.
  • Writes files back to disk in the same encoding, indentation, and key order.

Some editors, such as the open-source Java desktop application distributed on GitHub, target flat and nested JSON only, keeping the tool lightweight and focused. Others cover a much wider surface: nested JSON, Vue single-file components, Angular XLIFF, Android strings.xml, iOS .strings files, and ICU plural blocks — all editable in a single visual interface. IDE extensions take a third approach, resolving translation keys inline inside the component tree and flagging missing translations directly in the gutter so the developer or bilingual engineer never has to leave the editor. Finally, in-context web editors render strings on the live page itself, giving translators a character-budget view that no file-based tool can match.

Which file formats does an i18n-editor open?

An i18n-editor opens the resource bundle formats that react-i18next, vue-i18n, next-intl, @angular/localize, and golang.org/x/text emit on handoff. Format coverage varies significantly by tool: some handle only flat JSON, while others extend to XLIFF 2.0, Android XML, and iOS property lists. The table below maps format to framework and to editor coverage.

FormatFrameworkOpened by
Flat JSONreact-i18next, golang.org/x/textAll major editors
Nested JSONvue-i18n, next-intlVisual editors, IDE extensions, TMS-connected tools
YAMLRails, JekyllIDE extensions, advanced visual editors
Java .propertiesSpring, StrutsDesktop editors, advanced visual editors
gettext .poDjango, WordPressVisual editors, IDE extensions
Android strings.xmlAndroid nativeVisual editors, TMS-connected tools
iOS .strings / .stringsdictiOS nativeVisual editors, TMS-connected tools
XLIFF 1.2 / 2.0@angular/localizeVisual editors, TMS-connected tools

How is an i18n-editor different from a TMS or an in-context platform?

An i18n-editor edits files directly on disk with no server, no translation memory, and no team workflow. A TMS stores segments in a database with TM leverage, glossary enforcement, and reviewer gates. An in-context platform renders strings on the live page for post-editing, which is useful when character budgets and typographic fit matter more than raw throughput.

  • i18n-editor: file in, file out, local only, zero infrastructure.
  • TMS: segment database, TM, QA profiles, reviewer roles, audit log.
  • In-context platform: live-page overlay, character budgets visible, SDK required.

Centralizing translation management adds features like bulk-edit, cross-language search, namespace filtering, and tag-based categorization that no standalone file editor offers. Namespaces let teams group keys by feature, module, or release to match codebase structure, while tags slice the translation set in any direction needed for QA or release gating. The choice of surface depends on team size, pipeline complexity, and whether CI automation or live-page verification matters more to the project.

Which i18n-editors do translators actually meet in 2025?

Translators meet five i18n-editors in production: i18n-editor by jcbvm, BabelEdit, VS Code i18n Ally, Tolgee, and the Lokalise desktop export app. Each matches a different project shape. The matrix below scores them on JSON nesting depth, ICU plural handling, placeholder validation, and git workflow fit.

EditorNested JSONICU pluralsPlaceholder validationGit workflow fit
i18n-editor by jcbvmFlat onlyNoBasicManual
BabelEditFullVisual plural editorStrongGood
VS Code i18n AllyFullPartialInline gutter warningsNative
TolgeeFullFull ICUServer-sideVia CLI
Lokalise desktopFullFullSyncs to TMS QAVia TMS

What is the i18n-editor by jcbvm and when is it still the right pick?

The i18n-editor by jcbvm is an open-source Java desktop app distributed on GitHub that opens a folder of flat JSON locale files in a side-by-side grid. It remains the right pick for small i18next projects under about 1,500 keys that ship no continuous-localization pipeline. The app flattens nested keys and ignores ICU plural blocks, so projects that use either should pick a different editor.

What does BabelEdit do that jcbvm's editor does not?

BabelEdit handles deeply nested JSON, Vue single-file components, Angular XLIFF, and ICU plurals with a visual plural editor, where jcbvm's i18n-editor flattens nested keys and ignores ICU. BabelEdit is the default when a React, Vue, or Angular project uses nested namespaces. It also opens Android strings.xml and iOS .strings natively, which jcbvm does not.

When does an in-IDE editor like i18n Ally replace a standalone app?

VS Code i18n Ally replaces a standalone i18n-editor when the translator is also the developer. Keys resolve inline in the component tree, missing-translation warnings surface in the editor gutter, and git diffs stay inside the same window. The tab-switch between editor and codebase disappears. For dedicated linguists without IDE fluency, a standalone app stays easier.

How does Tolgee's in-context editor compare to a file-based i18n-editor?

Tolgee renders the live app around each string, so a translator sees context — character budget, surrounding UI, RTL mirroring — that a file-based i18n-editor hides. The tradeoff is that Tolgee requires a running build and a Tolgee SDK integration, which many client handoffs do not include. For JavaScript projects, the broader pipeline shape sits in JS Localization: How Translators Fit Into a JavaScript i18n Pipeline.

How does a translator open a JSON handoff in an i18n-editor without breaking it?

A translator opens a JSON handoff by cloning the branch, pointing the i18n-editor at the /locales folder, locking the key column, and running a placeholder-parity check before saving. The goal is to keep {{name}}, ICU {count, plural, …}, and <Trans> tag indices byte-identical to source. A single misplaced brace or a dropped double-curly delimiter is enough to throw a runtime interpolation error in production, so the editor's validation layer is not optional — it is the primary safety mechanism between the translator's output and the deployed build.

JSON resource bundles carry strict formatting requirements that the editor must honor on every save: stable key order, UTF-8 encoding without a byte-order mark, LF line endings, and 2-space indentation must all match the source file exactly. Placeholder parity with the source string is equally mandatory — every interpolation token present in English must appear in the target locale string, even if its position changes to match target-language word order. Editors that enforce these constraints at save time eliminate an entire category of CI failures before the pull request is even opened.

  1. Clone the repository and check out the locale branch.
  2. Open the i18n-editor and point it at /locales or /i18n.
  3. Set the source language to the English file.
  4. Lock the key column against accidental edits.
  5. Translate row by row, keeping placeholders untouched.
  6. Run the placeholder-parity check on the editor's QA panel.
  7. Save with stable key order, UTF-8 no BOM, LF line endings, 2-space indent.
  8. Commit, push, and open a pull request against the main branch.

An i18n-editor must preserve four placeholder syntaxes untouched. Each syntax is framework-specific, and confusing them — for example, collapsing double-curly braces to single-curly — silently breaks runtime interpolation without throwing a JSON parse error, making the bug invisible until the UI renders.

  • react-i18next double-curly: {{name}}, {{count}}, {{user.firstName}} — the double-curly delimiter must be preserved byte-for-byte.
  • next-intl single-curly with ICU: {name}, {count} with optional ICU formatters — the single-curly syntax follows ICU MessageFormat conventions.
  • ICU MessageFormat plural blocks: {count, plural, one {# item} other {# items}} — the entire block must be reauthored to the target language's CLDR plural categories, not just the inner strings.
  • Indexed JSX tags from the React Trans component: <0></0>, <1></1>, <2/> — index order must be preserved even when target-language syntax reorders surrounding words.

The Trans component collapses JSX markup into segments that break CAT tools expecting discrete atomic segments, so segment-merging falls to the translator or the LSP. The React i18n: How Translators Fit Into a React Localization Pipeline page covers that pattern end-to-end.

How does an i18n-editor handle ICU plural keys for Arabic, Russian, and Polish?

An i18n-editor exposes CLDR plural categories as sibling keys so that each source string expands into as many target rows as the target language requires. ICU MessageFormat plural and select blocks must be reauthored to the target language's CLDR categories inside the editor — simply copying the English two-category structure to a six-category language like Arabic produces a broken plural at runtime. The table below shows what the grid looks like per source string.

LanguagePlural keys per stringCategory names
English2_one, _other
Polish4_one, _few, _many, _other
Russian4_one, _few, _many, _other
Arabic6_zero, _one, _two, _few, _many, _other

Arabic requires six plural keys per string under react-i18next — _zero, _one, _two, _few, _many, and _other — which raises per-key TMS licensing costs without raising the billable source-word count. An editor that does not surface all six categories forces the translator to add the missing keys by hand in raw JSON, reintroducing the exact file-corruption risk the editor is supposed to prevent. The React i18n: How Translators Fit Into a React Localization Pipeline page explains the pricing impact in more detail.

What does a safe save-and-commit look like from an i18n-editor?

A safe save writes stable key order, UTF-8 without BOM, LF line endings, and 2-space indentation to match the source JSON exactly. Deviating from any one of these four constraints — for instance, writing CRLF line endings on a Windows machine or reordering keys alphabetically — produces a noisy diff that buries the actual translation changes and can fail the project's JSON-schema lint step. The translator then runs the project's lint script, opens a pull request from a locale branch, and waits for CI placeholder-parity and JSON-schema checks before requesting review.

  • Diff only the target locale file, not the source English file.
  • Keep the key order byte-identical to source for clean diffs.
  • Push to a per-locale branch, not to main.
  • Wait for CI to clear placeholder-parity and JSON-schema checks before requesting a code review.

When does an i18n-editor stop scaling and the project need a TMS?

An i18n-editor stops scaling at roughly 5,000 translation keys, four or more target locales, or any continuous-localization cadence that commits weekly. File-based editing loses translation memory leverage, has no reviewer gate, and cannot run the LQA sampling that certified lanes require under an MQM-style scorecard aligned to ISO 17100.

What quality gates does a file-based i18n-editor skip?

A standalone i18n-editor skips three gates a TMS enforces:

  1. Segment-level review at $0.04–$0.08 per source word, with reviewer sign-off tracked per segment.
  2. LQA sampling at $40–$90 per 1,000 words against an MQM-style scorecard aligned to ISO 17100.
  3. Mandatory sign-off on the certificate of accuracy for certified lanes.

Which signals say it is time to graduate from an i18n-editor?

Four signals say the project has outgrown an i18n-editor:

  • Key count above ~5,000.
  • More than four active locales.
  • Pull-request-driven weekly releases.
  • A client who requires per-segment review history for audit.

Any one of them makes a hosted TMS the lower-friction option. The decision tree below maps project shape to the correct editor class.

Project shapeRight editor class
<500 keys, 1–2 locales, one-offRaw IDE or VS Code i18n Ally
500–5,000 keys, 2–4 locales, quarterlyStandalone i18n-editor desktop app
Any key count, visual context requiredIn-context platform (Tolgee)
>5,000 keys, 4+ locales, weekly commitsFull TMS with connector

How it works

How does an i18n-editor fit into a certified translation production workflow?

1

Translator edits JSON in the i18n-editor on a locale branch.

2

CI runs placeholder-parity and JSON-schema checks on the pull request.

3

Reviewer scores segments in the TMS at $0.04–$0.08 per source word.

4

LQA samples roughly 10% of volume at $40–$90 per 1,000 words against the MQM-aligned scorecard.

Related