💡 왼쪽 원문을 읽으면서 오른쪽에 따라 써보세요. Tab 키로 힌트를 받을 수 있습니다.

원문 렌더가 준비되기 전까지 텍스트 가이드로 표시합니다.

Prologue — "Translation is now a build pipeline"

In 2018, "i18n" meant a PM with a spreadsheet of Korean / English / Japanese columns, and a developer manually copying values into JSON to commit. By 2022 TMS platforms like Lokalise, Phrase, and Crowdin had turned key-value sync and translator collaboration into SaaS, and DeepL had raised the bar on MT quality. Then between 2024 and 2026 GPT-4o, Claude, and Gemini turned up with "document-tone, domain-aware" translation, and the game shifted again.

In May 2026, what we call "i18n / localization" splits into **four distinct camps**.

1. **TMS (Translation Management System)** — Lokalise, Phrase, Crowdin, Tolgee, Weblate, Localazy, POEditor, Transifex, Smartling, Lingo (Locize)

2. **AI / MT engines** — DeepL, GPT-4o, Claude translate, Gemini translate, Reverso, Papago, Kakao i Translation, NICT VoiceTra, NTT

3. **Developer libraries** — i18next, FormatJS / react-intl, ICU MessageFormat (spec)

4. **Localization-as-code (LLM-driven)** — Lingo.dev, Locale.dev, OpenStrings

Even under the same label of "translation," Lokalise, Lingo.dev, and i18next solve different layers. A TMS handles humans, translators, translation memory (TM), and glossaries. AI engines decide raw translation quality. Libraries render at runtime and handle plurals / gender. New entrants like Lingo.dev start from a different idea: "treat translations like a git diff and ship them as PRs."

This article lays out the position, strengths, weaknesses, and pricing of the 11+ tools as of May 2026, then answers "what should I pick" across **OSS projects / startups / global SaaS / self-hosted regulated industries**.

Chapter 1 · The 2026 i18n map — four camps: TMS, OSS, libraries, AI

A single table for the whole map.

| Camp | Identity | Representative tools |

| --- | --- | --- |

| TMS (commercial) | SaaS, translator collaboration + key-value sync | Lokalise, Phrase, Crowdin, Smartling, Transifex, Lingo (Locize), POEditor, Localazy |

| TMS (open source) | Self-hostable, community translation | Tolgee, Weblate |

| AI / MT | The translation engine itself | DeepL, GPT-4o, Claude, Gemini, Reverso, Papago, Kakao i |

| Developer libraries | Runtime i18n, format handling | i18next, FormatJS, react-intl, FBT, Lingui, next-intl |

| Standards | Message format specs | ICU MessageFormat, Unicode CLDR, XLIFF, gettext PO |

| Localization-as-code | LLM + git workflow | Lingo.dev, Locale.dev, OpenStrings |

By workload:

| Scenario | Recommended | Why |

| --- | --- | --- |

| OSS project (recruiting volunteer translators) | Crowdin, Weblate, Tolgee | Free / discounted OSS plans, community tooling |

| B2B SaaS startup (productize i18n) | Lokalise, Phrase, Lingo.dev | TMS + GitHub integration, AI workflow |

| Global enterprise | Smartling, Phrase (RWS), Lokalise | Compliance, agency workflow |

| Self-hosted (regulated / sensitive) | Weblate, Tolgee self-host | No data leaves the building, GPL/AGPL |

| Marketing content / blog | DeepL Pro + human review, Lingo.dev | Tone / nuance handling |

| Game / UGC bulk translation | GPT-4o / Claude API + glossary | Cost, context awareness |

One insight to lead with: **TMS, AI engines, and libraries are complements, not substitutes.** Using Lokalise does not eliminate the need for i18next, and DeepL being good does not eliminate the need for a TMS. Figure out where your team is actually spending time first.

Chapter 2 · Lokalise — the TMS leader

Lokalise started in Latvia in 2017, raised a $50M Series B in 2021, and cemented its position as the global TMS leader. As of 2026, more than 5,000 teams use it, and it has become the de-facto standard for "modern SaaS UX + developer-friendly workflow."

Core concepts

- **Project** — One app or service. Holds key-value pairs.

- **Key** — The identifier. `home.welcome.title` style dot-notation is common. Every language's translation hangs off the same key.

- **Translation memory (TM)** — Past translation database. New keys get fuzzy-matched suggestions automatically.

- **Glossary** — Brand names, product names, forbidden terms.

- **Branching** — Branch the project's translations like git branches. Per-feature translation work.

Developer workflow

- **CLI** — `lokalise-cli` pushes / pulls keys. Supports 30+ formats: JSON, YAML, strings, ARB, xml, and more.

- **GitHub App** — On merge, auto-sync. New keys notify translators.

- **API + webhooks** — Trigger builds on translation completion.

- **Figma plugin** — Extract copy at design time; translation starts in parallel.

Pricing (May 2026)

| Plan | Price | Keys / users |

| --- | --- | --- |

| Start | $120/month | 10 users, 5,000 keys |

| Essential | $230/month | 10 users, 5,000 keys + branching |

| Pro | $585/month | 15 users, 30,000 keys |

| Enterprise | Custom | SSO, audit log, custom |

Strengths and weaknesses

- Strengths: Cleanest UX. Designers, translators, and developers work in one screen. AI auto-translation integration (pick DeepL / OpenAI / Google backends).

- Weaknesses: Expensive. Hard sell for OSS projects. No self-hosting.

When to pick it

B2B SaaS, Series A+ startups, multilingual mobile apps. Teams that need "a modern workflow where designers and translators work together."

Chapter 3 · Phrase + Memsource (RWS) — life after the merger

Phrase started in 2014 as a German startup, acquired Memsource in 2017, then itself was rolled up by the UK's RWS Holdings in 2021. As of 2026 the two product lines run side-by-side under one brand.

- **Phrase Strings** — formerly Phrase. Key-value, developer-friendly TMS. JSON, YAML, iOS strings, Android xml.

- **Phrase TMS** — formerly Memsource. XLIFF / TMX based, translator-friendly CAT (Computer-Aided Translation) tool. A Trados replacement.

Core concepts

- **Project + Branching** — Strings side is nearly identical to Lokalise's key-value model.

- **CAT editor** — TMS side puts sentence-level segments, TM matches, and MT suggestions on one screen.

- **AI Translation** — Phrase NextMT (proprietary engine) + DeepL + GPT backends are selectable. Domain-tuned models on Enterprise.

- **Quality scoring** — Automatic quality scores based on MQM (Multidimensional Quality Metrics).

Developer workflow

- **Phrase CLI** — Key sync. Official GitHub Action and GitLab CI integration.

- **In-context editor** — Drop the SDK into your web app, and translators edit copy on top of the actual UI. (Influenced by Tolgee.)

- **OTA (Over-The-Air)** — Push translations to mobile apps without an app store redeploy.

Pricing

- Strings: starts at $135/month. Scales up quickly as keys and users grow.

- TMS: custom. Enterprise-focused.

Strengths and weaknesses

- Strengths: Covers both TMS and Strings workflows. Direct hook into RWS's global translator network. MQM quality measurement support out of the box.

- Weaknesses: The two products' UX is uneven mid-integration. Pricing is somewhat higher than Lokalise.

When to pick it

Enterprises that work with translation agencies, or teams needing mobile OTA updates. If you already have a relationship with RWS, the choice is natural.

Chapter 4 · Crowdin — OSS project friendly

Crowdin started in Ukraine in 2009. As of 2026 it is the de-facto standard for OSS and game community translation. React Native, Docker, Discord, Minecraft, and Telegram localizations all run on Crowdin.

Core concepts

- **Crowdin for Open Source** — Official free OSS plan (approval-based). Unlimited keys and translators.

- **Pre-translation** — Memsource MT + DeepL + ChatGPT backends.

- **Community translation** — Anonymous or logged-in users propose translations. Moderators approve.

- **Vendors marketplace** — Call professional translation agencies from inside the project.

Developer workflow

- **Crowdin CLI** — Key sync.

- **GitHub integration** — Detect main branch changes, push to Crowdin, auto-open PR when translations are complete.

- **String repository** — Reuse the same keys across multiple projects.

- **Screenshot context** — Attach UI screenshots per key for translator context.

Pricing

| Plan | Price |

| --- | --- |

| Free (small) | $0, 1 project, 60,000 characters |

| Pro | $50/month |

| Team | $250/month |

| Business | $450/month |

| Enterprise | Custom |

| OSS | Free (approval required) |

Strengths and weaknesses

- Strengths: OSS plan is exceptionally generous. Community translation tooling is the most mature. Gamification (translator rankings, badges) drives voluntary contribution.

- Weaknesses: UI feels a touch older than Lokalise / Phrase. Enterprise RBAC / SSO / audit logs cost extra.

When to pick it

OSS projects, game communities, products where users themselves translate. The "don't hire translators, recruit them" case.

Chapter 5 · Tolgee — open source in-context editor

Tolgee is a relatively new OSS TMS that started in Czechia in 2020. As of 2026 it has 4,500+ GitHub stars under the MIT license. Both self-hosted and SaaS versions are available.

The signature feature — in-context editor

Tolgee's calling card is that **on the dev server you can Alt + click any copy and edit it in place**. The React / Vue / Angular SDKs drop hidden markers into the DOM, and a Tolgee browser extension picks them up. Designers and PMs edit translations directly on the UI.

// React example

const tolgee = Tolgee()

.use(DevTools())

.use(FormatIcu())

.init({

apiUrl: 'https://app.tolgee.io',

apiKey: process.env.NEXT_PUBLIC_TOLGEE_API_KEY,

language: 'en',

})

export default function App() {

return (

)

}

Core concepts

- **Screenshot auto-capture** — Captures screenshots automatically whenever a key appears on screen.

- **Translation memory** — In-house TM + DeepL / OpenAI auto-translation integration.

- **Activity** — Per-key change history. Who changed what, when.

- **CLI + Push/Pull** — JSON, YAML, xliff, Apple strings, and more.

Pricing

| Plan | Price | Keys |

| --- | --- | --- |

| Free | $0 | 1,000 strings, 3 users |

| Cloud Standard | $69/month | 10,000 strings |

| Cloud Enterprise | Custom | Unlimited |

| Self-hosted Free | $0 | Unlimited (small teams) |

| Self-hosted Business | Custom | SSO, audit logs |

Strengths and weaknesses

- Strengths: Smoothest in-context editor. OSS means self-hosting is possible. Much cheaper than Lokalise / Phrase.

- Weaknesses: Ecosystem is still small. Translator marketplace / agency integration is weak.

When to pick it

Small teams where "PMs and designers edit copy directly," startups that don't want data leaving the building, seed-stage teams that find Phrase / Lokalise pricing painful.

Chapter 6 · Weblate (Czech OSS) / Localazy / POEditor

If Lokalise, Phrase, and Crowdin are the SaaS top three, this category covers the next tier — favored by OSS communities and mid-sized teams.

Weblate — GPL full-stack self-hosted

- Started in 2012 by Michal Čihař in Czechia. GPL licensed, 4,700+ GitHub stars.

- gettext PO-centric. The standard for Linux desktop project (GNOME, KDE) localization.

- Self-hosting is genuinely easy. Docker compose one-liner. Postgres + Redis only.

- Hosted Weblate (SaaS) also exists, and OSS projects can apply for free hosting.

- AI auto-translation: pick DeepL / Google / Microsoft / OpenAI backends.

- Weakness: UI is a bit old-school. Mobile app workflow (iOS strings, Android xml) is weaker than Lokalise.

Localazy — another Czech contender

- Launched 2019 in Czechia. "Automation + community translation marketplace" concept.

- ShareTM — community translation memory. Reuse translations from other projects for free.

- Mobile-app friendly. Solid iOS, Android, React Native, Flutter SDKs.

- Pricing: Free 1,000 source, Startup $39/month, Pro $129/month.

- Strength: Good features for the price. Automation and CLI feel polished.

POEditor

- Launched 2012 in Romania. The most classic key-value TMS.

- Lowest priced (Free 1,000 strings, Start $14.99/month).

- Minimal UI. Plenty for small teams.

- Direct integration with GitHub, GitLab, Bitbucket, Azure DevOps.

Comparison summary

| --- | --- | --- | --- | --- |

Chapter 7 · Lingo (Locize) / Transifex / Smartling — the rest

Lingo / Locize — flat-fee, i18next's sibling

- Lingo rebranded to Locize. A TMS built by i18next maintainer Jan Mühlemann.

- Core idea: **flat-fee pricing**. €25/month for 100,000 keys, decoupled from usage.

- Perfect integration with i18next. One line of `i18next-locize-backend` and you're done.

- AI auto-translation integration (DeepL, Google).

- Weakness: UI design is relatively plain. Designer-friendly workflow lags Lokalise / Phrase.

- When to pick it: React / Node teams on i18next, places where pricing predictability matters.

Transifex — the old guard

- Started 2007 in Greece. One of the oldest SaaS TMS platforms.

- Translation infrastructure for WordPress, Mozilla, Eclipse.

- Lost ground to Lokalise / Phrase through the 2020s, but still stable.

- "Live" feature: in-context editing, tried before Tolgee.

- Pricing: Starter $70/month, Growth $250/month.

- Strength: Stability, long-standing integrations.

- Weakness: Slow innovation pace and older-style UI.

Smartling — enterprise-only

- Started 2009 in the US. Customers include Lyft, British Airways, Pinterest.

- Full-stack: in-house TMS + in-house translation agency network.

- LanguageAI — proprietary AI translation + human review workflow.

- Pricing: custom. Six figures and up.

- Strength: Enterprise compliance (SOC2, ISO 27001, GDPR), agency quality guarantees.

- Weakness: Overkill for small teams, high price floor.

Chapter 8 · AI translation — DeepL / GPT-4o / Claude / Gemini / Reverso

If TMS is the infrastructure, AI is the engine. As of 2026 the new bar for translation quality is LLM-based.

DeepL — still the specialist standout

- Based in Cologne, Germany. Since launching in 2017 has stayed ahead of Google / Microsoft on EU language pairs (German / French / Italian / Spanish / Portuguese / Dutch).

- DeepL Write (writing assistance) in 2024, next-gen LLM-based engine in 2025.

- Strengths: Formal / informal toggle, glossary accuracy, domain models (legal, finance, etc.).

- Weakness: For Asian languages (Korean / Chinese / Japanese), some say it trails GPT-4o / Claude slightly.

- Pricing: API Pro from $5.49/month + usage.

GPT-4o (OpenAI) translation

- OpenAI's 4o model is top-tier across 100+ languages.

- Strengths: Context awareness (decides meaning from surrounding sentences), code-comment translation, markdown / HTML structure preservation.

- Weakness: Occasional hallucinations. LLMs alone don't enforce glossaries 100 percent — need RAG / few-shot.

- Pricing: input $2.50/1M tokens, output $10/1M tokens.

Claude (Anthropic) translation

- Claude Sonnet and Opus shine on long-form document translation. A 1M-token context handles entire books.

- Strong reputation for tone (brand voice) preservation.

- Multiple benchmarks in 2025 reported lower hallucination rates than GPT.

- Pricing: Sonnet input $3/1M, output $15/1M.

Gemini (Google) translation

- Google's home turf. 100+ languages, split between Vertex AI Translate API and the LLM API.

- Strength: Google's existing translation corpus combined with LLMs. Strong on multilingual OCR and document translation.

- Pricing: 1.5 Pro input $1.25/1M, output $5/1M.

Reverso

- Started 1998 in France. Translation + context search (showing similar example sentences from a real document corpus).

- Translators use it alongside others for "checking word nuance."

- B2C tool. APIs exist but it's not infrastructure-grade.

Anthropic translation API + Korean / Japanese majors

- Anthropic does not ship a dedicated "translation API"; you go through the Messages API with system prompts plus glossary.

- Korea's Papago and Kakao i Translation, Japan's NTT and DeepL's Japanese data centers are covered in chapters 13 and 14.

Quality comparison (2025 in-house benchmark, KO / EN / JA)

| --- | --- | --- | --- | --- |

| Google Translate | Mid | Mid | Low | Low |

Chapter 9 · Lingo.dev — LLM-based localization-as-code

Lingo.dev (formerly Replicant.ai Translation) is the new camp that arrived in 2024. The premise is different: **"translations should be treated like a git diff and shipped as PRs."**

Core idea

- A developer edits `en.json`, the Lingo CLI calls an LLM (pick OpenAI / Anthropic / Google), auto-translates into `ko.json` / `ja.json`, and opens a PR.

- OSS and small teams can run multilingual products without translators or a TMS.

- Instead of TMS key-value sync, git diff is the source of truth.

Example

Install

npm i -g lingo.dev

Initialize

lingo init

i18n.json

{

"source": "en",

"targets": ["ko", "ja", "zh-CN"],

"files": ["locales/*.json"],

"model": "anthropic/claude-sonnet-4",

"glossary": "glossary.json"

}

Auto-translate and open a PR

lingo translate --open-pr

Strengths

- Saves TMS cost. Sensible for seed-to-Series-A startups.

- Free choice of LLM model. Swap Claude / GPT / Gemini backends at will.

- Glossary controls brand terms.

- Translation history flows naturally through git diff.

Weaknesses

- No human-translator workflow. "Legal / regulated copy" still wants TMS + human review.

- LLM quality on minor languages (Swahili, Persian, etc.) is uneven.

- At scale, LLM API cost can exceed list-price TMS.

When to pick it

OSS projects, small SaaS, marketing sites, blogs. Teams where "one full-stack developer also owns the i18n infrastructure."

Competitors

- **Locale.dev** — arrived 2025. Very similar to Lingo.dev. PR-based.

- **OpenStrings** — OSS library. Built-in LLM translation + cache management.

Chapter 10 · ICU MessageFormat — plurals and gender

Having mapped the upper layers, time to drop to the standards. ICU (International Components for Unicode) is the i18n standard from IBM and Unicode. **MessageFormat** handles tricky things like plurals, gender, and dates inside a single string.

Why it matters

In English, "1 item / 2 items" is easy, but Russian has three plural forms (singular, paucal, plural), Arabic has six. Japanese has no plural (same word). Korean attaches separate counter units. The grammar to express all this in a single key:

{count, plural,

=0 {No items}

one {# item}

other {# items}

}

That syntax is ICU MessageFormat. JavaScript, Java, Swift, Kotlin, and Go all have ICU-compatible libraries.

Korean and Japanese specifics

Korean: {count, plural, other {#개 아이템}}

Japanese: {count, plural, other {#件}}

Korean's plural rules are simple (everything is `other`), but particle handling (eun / neun, i / ga, eul / reul) is not solved by ICU. Korean i18n usually adds a particle helper or rewrites the sentence.

Select (gender, context)

{gender, select,

male {He registered}

female {She registered}

other {They registered}

}

SelectOrdinal (ordinals)

{position, selectordinal,

one {#st}

two {#nd}

few {#rd}

other {#th}

}

MessageFormat 2.0 (MF2)

- Unicode shipped the first stable release of MessageFormat 2.0 in 2024.

- Cleans up the original MF's painful escape and nesting issues.

- As of 2026, i18next, FormatJS, and LinguiJS all support MF2.

Chapter 11 · i18next — the JS i18n standard

The most widely-used i18n library in the JavaScript ecosystem. Started 2011, 8M+ weekly npm downloads in 2026. Runs on React, Vue, Svelte, Node, Express, Electron — basically anywhere.

Core concepts

- **i18next core** — Environment-agnostic core. Key lookup, interpolation, plurals, namespaces.

- **react-i18next, vue-i18next** — Framework bindings.

- **Backends** — locize, http, fs, chained, and more.

- **Plugins** — Language detector, ICU formatter, postProcessor, etc.

Example (React)

i18n.use(initReactI18next).init({

resources: {

en: { translation: { welcome: 'Hello, {{name}}' } },

ko: { translation: { welcome: '안녕하세요, {{name}}' } },

lng: 'en',

fallbackLng: 'en',

})

function Greeting({ user }) {

const { t } = useTranslation()

return <h1>{t('welcome', { name: user.name })}</h1>

}

When writing about placeholders such as `{{name}}` in MDX prose, always wrap them in inline code to avoid MDX parsing them as JSX expressions.

Namespaces

A large app doesn't stuff every key into one JSON.

{

"common": { "save": "Save" },

"checkout": { "title": "Checkout" }

}

Access with `t('checkout:title')` using the colon convention.

Plural handling

i18next ships its own plural rules (`_one` / `_other` suffix) but also offers an ICU-compatible mode. Enable the `i18next-icu` plugin and you get MF1 / MF2 syntax as is.

Lazy loading

- HTTP backend splits chunks per language to keep the initial bundle light.

- Integrates with Next.js / Remix for key prefetching inside SSR.

Strengths and weaknesses

- Strengths: Ecosystem size and plugin count are unmatched. Backends are pluggable.

- Weaknesses: API feels heavyweight. For React Server Components / App Router, next-intl / use-intl are often considered better fits.

Chapter 12 · FormatJS / react-intl — React i18n

FormatJS is the i18n toolchain Yahoo built. The headline: **ICU MessageFormat as a first-class citizen**.

Components

- **@formatjs/intl** — Core. Wraps the web-standard Intl API.

- **react-intl** — React bindings.

- **@formatjs/cli** — Message extraction tool. Collects every `defineMessages` call from your source.

- **@formatjs/icu-messageformat-parser** — The ICU parser.

Example

const messages = {

en: { greeting: 'Hello, {name}' },

ko: { greeting: '안녕하세요, {name}님' },

}

function App() {

return (

)

}

Strengths

- ICU MessageFormat is first-class. Consistent plurals, gender, dates, numbers.

- Message extraction CLI is strong. Source goes straight to JSON for TMS push.

- Component-friendly: `<FormattedNumber>`, `<FormattedDate>`, `<FormattedRelativeTime>`, etc.

Weaknesses

- Outside React it isn't as versatile as i18next.

- Long message IDs make debugging harder.

Other React i18n tools

- **next-intl** — Next.js App Router optimized. Both SSG and SSR.

- **LinguiJS** — Inline JSX translation component (`<Trans>`). Auto-generates message IDs.

- **FBT** — Meta's library. Custom tokenizer handles compound sentences.

Chapter 13 · Korea — Papago, Kakao i Translation

The Korean market is too specific to ignore.

Naver Papago

- Launched 2016. As of 2026, the dominant translation service in Korea.

- Strengths: Out-performs global engines on KO↔EN, KO↔JA, KO↔CN, especially KO↔EN naturalness.

- API: Papago Translation on Naver Cloud Platform (NCP). 10,000 characters/day free, then per-character pricing.

- Introduced an LLM-based next-gen engine (based on HyperCLOVA X) in 2024.

- Weakness: Weak on non-English / non-Asian language pairs. DeepL beats it on European languages.

Kakao i Translation

- Operated by Kakao Enterprise. Integrated with KakaoTalk and Daum Search.

- API on Kakao i Cloud. Lower share than Papago but strong inside the Kakao ecosystem.

- Offers domain-tuned models for business content and news separately.

Usage patterns

- Typical i18n stack at Korean companies: TMS (Lokalise / Crowdin) + DeepL / Papago side-by-side + in-house review.

- B2C content translation (webtoons, web novels, media) leans on Papago / Kakao + human review.

- Global SaaS more often goes with DeepL / Claude / GPT.

Papago API call

const res = await fetch('https://naveropenapi.apigw.ntruss.com/nmt/v1/translation', {

method: 'POST',

headers: {

'X-NCP-APIGW-API-KEY-ID': process.env.PAPAGO_ID,

'X-NCP-APIGW-API-KEY': process.env.PAPAGO_KEY,

'Content-Type': 'application/x-www-form-urlencoded',

body: new URLSearchParams({

source: 'ko',

target: 'en',

text: '안녕하세요',

}),

})

Chapter 14 · Japan — NICT VoiceTra, NTT, Cygames in-house

NICT VoiceTra

- Multilingual speech translation system built by Japan's National Institute of Information and Communications Technology (NICT).

- 31 languages for text translation, 17 for speech recognition / synthesis.

- Widely deployed in government and tourism infrastructure (JR stations, airports). The meteorological and customs agencies have also adopted it.

- Free app (VoiceTra) and academic / public-sector preferential API.

- Strength: Japanese domain fine-tuning (legal, medical, tourism, disaster response).

NTT — COTOHA Translator and tsuzumi

- Run by NTT's AI division (NTT Artificial Intelligence Laboratory).

- COTOHA Translator — specialized in business documents. Adopted by 100+ Japanese large enterprises.

- tsuzumi (2024) — NTT's in-house LLM. Marketed as a Japanese-specialized model whose Japanese expression feels more natural than OpenAI.

- Operates Japanese domestic data centers, favored by data sovereignty / finance / medical industries.

Cygames and other game-company in-house systems

- Japan's large game studios (Cygames, Square Enix, Bandai Namco) maintain in-house LQA (Localization Quality Assurance) teams plus proprietary translation workflows.

- They use Crowdin / Lokalise / Phrase, but manage in-house glossaries and character voice databases separately.

- Cygames recently built an internal LLM-based translation tool that does first-pass Japanese to English / Chinese / Korean, with human LQA polishing afterward.

What makes the Japanese market specific

- Three-script blend (kanji, katakana, hiragana). LLM handling varies model by model.

- Honorifics (sonkeigo / kenjougo / teineigo) — decisive in business content.

- Whether to render English loanwords as katakana or in original kanji / Japanese varies by domain.

Chapter 15 · Who should pick what — OSS / startup / global / self-hosted

The four scenarios answered.

OSS project (community translation)

- **First pick**: Crowdin OSS plan or Weblate.

- **Why**: Free, mature community translation tooling.

- **Library**: i18next, gettext.

- **AI assist**: Use the pre-translation feature with DeepL / OpenAI backends.

- **If self-hosting matters**: Weblate.

B2B SaaS startup (seed to Series A)

- **First pick**: Tolgee Cloud or Lingo.dev.

- **Why**: Reasonable pricing. Tolgee for in-context editing, Lingo.dev for PR-based automation.

- **Library**: i18next + react-i18next, or next-intl (Next.js).

- **AI assist**: Direct Claude / GPT-4o API calls, or Tolgee's built-in auto-translation.

Global enterprise

- **First pick**: Phrase (RWS) or Lokalise.

- **Why**: Compliance (SOC2 / ISO / GDPR), agency workflow, MQM quality measurement.

- **AI + human review workflow**: DeepL + in-house fine-tunes + translator review.

- **If compliance is paramount**: Smartling.

Self-hosted (regulated / sensitive)

- **First pick**: Tolgee self-hosted or Weblate.

- **Why**: No data leaves the building. Medical, finance, government.

- **AI integration**: In-house LLM (e.g., Llama 3.3, Qwen 2.5) or Azure OpenAI private endpoints.

Seven anti-patterns

1. "The TMS does everything." It doesn't — without a library (i18next, etc.) runtime falls apart.

2. Trusting AI translation and skipping review. Brand voice and legal copy break.

3. Using the English message as the key name. Edit the message and the key changes, exploding git diffs. Use semantic IDs.

4. Branching on count with if / else instead of ICU MessageFormat. Every new language forces a code change.

5. Loading every key on every page in one shot. Bundle and SSR time both explode. Lazy-load.

6. LLM translation without a glossary. Brand and product names come out differently every time.

7. Not backing up the database of your self-hosted OSS tool. Weblate / Tolgee DBs still need scheduled backups.

What's next

- Future posts: **i18n libraries deep dive — code-level comparison of i18next vs FormatJS vs next-intl vs Lingui**, **MessageFormat 2.0 migration in practice**, **LLM translation quality evaluation (MQM / BLEU / COMET) and building an in-house benchmark**.

> "TMS manages key-values, libraries render at runtime, AI produces raw translations, humans own tone and context. Drop any one of the four layers and i18n collapses."

— Localization & i18n Tools 2026, end.

References

- [Lokalise — Translation Management Platform](https://lokalise.com/)

- [Phrase — Localization Platform (RWS)](https://phrase.com/)

- [Phrase TMS (formerly Memsource)](https://phrase.com/platform/tms/)

- [Crowdin — Localization Management](https://crowdin.com/)

- [Crowdin Open Source program](https://crowdin.com/page/open-source-project-setup-request)

- [Tolgee — Open source localization](https://tolgee.io/)

- [Tolgee GitHub — tolgee/tolgee-platform](https://github.com/tolgee/tolgee-platform)

- [Weblate — Web-based translation](https://weblate.org/)

- [Weblate GitHub — WeblateOrg/weblate](https://github.com/WeblateOrg/weblate)

- [Localazy — Localization for mobile and web](https://localazy.com/)

- [POEditor — Translation management](https://poeditor.com/)

- [Lingo (Locize) — i18next backend service](https://www.locize.com/)

- [Transifex — Localization platform](https://www.transifex.com/)

- [Smartling — Translation Services & Software](https://www.smartling.com/)

- [Lingo.dev — LLM localization-as-code](https://lingo.dev/)

- [Locale.dev — AI translation for developers](https://locale.dev/)

- [DeepL — Translator and Pro API](https://www.deepl.com/)

- [DeepL Pro API documentation](https://developers.deepl.com/)

- [OpenAI API — GPT-4o models](https://platform.openai.com/docs/models/gpt-4o)

- [Anthropic Claude API — Messages](https://docs.anthropic.com/en/api/messages)

- [Google Gemini API](https://ai.google.dev/)

- [Reverso Context](https://context.reverso.net/translation/)

- [i18next documentation](https://www.i18next.com/)

- [i18next GitHub — i18next/i18next](https://github.com/i18next/i18next)

- [react-i18next](https://react.i18next.com/)

- [FormatJS — Internationalize your web apps](https://formatjs.io/)

- [react-intl documentation](https://formatjs.io/docs/react-intl/)

- [next-intl — Next.js i18n](https://next-intl-docs.vercel.app/)

- [LinguiJS](https://lingui.dev/)

- [FBT — Facebook i18n framework](https://facebook.github.io/fbt/)

- [ICU MessageFormat — Unicode CLDR](https://unicode-org.github.io/icu/userguide/format_parse/messages/)

- [MessageFormat 2.0 specification](https://unicode-org.github.io/message-format-wg/)

- [Unicode CLDR](https://cldr.unicode.org/)

- [XLIFF 2.0 specification — OASIS](https://docs.oasis-open.org/xliff/xliff-core/v2.0/xliff-core-v2.0.html)

- [GNU gettext](https://www.gnu.org/software/gettext/)

- [Naver Papago — Translator](https://papago.naver.com/)

- [Naver Cloud Platform Papago Translation API](https://www.ncloud.com/product/aiService/papagoTranslation)

- [Kakao i Translation](https://kakaoi.ai/)

- [NICT VoiceTra](https://voicetra.nict.go.jp/en/index.html)

- [NTT COTOHA Translator](https://www.ntt.com/business/services/application/ai/cotoha-translator.html)

- [NTT tsuzumi LLM](https://www.rd.ntt/e/research/JN202310_19069.html)

- [MQM — Multidimensional Quality Metrics](https://themqm.org/)