# General Translation Knowledge Base: General Translation vs. a TMS (Crowdin, Lokalise, Phrase)
URL: https://generaltranslation.com/en-US/kb/general-translation-vs-tms.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Choose General Translation when developers want translation generation, code-derived context, and review connected to product releases. Keep your existing catalogs and rendering library, or author inline JSX without translation keys. A TMS fits programs centered on language vendors, CAT editors, and XLIFF exchange; its integrations can automate the file transfers.
Category: Workflow Tools
Last updated: 2026-10-16
Authors: General Translation Team
Published: 2026-10-16

A [translation management system (TMS)](/kb/what-is-a-translation-management-system) stores content and coordinates translation and review. You sync resource files or keys from your repository into the TMS, translators and AI translate them there with translation memory and glossaries, and the results come back as files or a pull request. Smartling, Lokalise, Phrase, Crowdin, and Transifex all work this way, and the model suits large translation programs run by localization managers and language vendors. General Translation brings generation and review into that development workflow: its CLI translates marked source content or existing catalogs before the build, and its libraries render the results. The advantage for engineers is less catalog and context maintenance between writing a feature and shipping it in every language.

## Video

The video is narrated in English, with English captions.

[Why use General Translation instead of a TMS (Smartling, Lokalise, Phrase, Crowdin, or Transifex)?](https://caxecubb9c64cezv.public.blob.vercel-storage.com/films/kb-general-translation-vs-tms.mp4) (46 sec)

A TMS such as Smartling, Lokalise, Phrase, Crowdin or Transifex coordinates translators, but engineers still extract strings, send them out, and wire translations back. General Translation translates content in your code with its context and ships every language with each release: keep the copy inside a `<T>` component, add a language in `gt.config.json`, then let `npx gt translate` or a Locadex pull request translate each change.

## What a TMS does well

A TMS is built to coordinate people and content at scale:

- **Translation tooling.** Editors with translation memory, glossaries, and QA checks for placeholders, length, and terminology, plus workflows that chain translation, review, and proofreading steps.
- **Human translation.** Smartling has its own language services team of more than 4,000 linguists, Lokalise and Phrase let you order professional translation per word, and Crowdin runs a vendor marketplace.
- **File formats.** Each platform reads the common app formats plus XLIFF, the format translation vendors exchange, and ARB.
- **Context for translators.** Screenshots matched to strings, Figma plugins, key descriptions with character limits, and in-context editors for websites.
- **AI translation.** Every vendor now offers it, and their AI features can draw on your glossary, translation memory, and style guide.
- **Mobile delivery.** Lokalise, Phrase, Crowdin, and Transifex ship SDKs that update strings in native mobile apps without an app release.

## What a TMS still leaves to your engineers

In a file-based TMS workflow, engineers configure the following stages. CLIs and repository integrations can automate the repeated transfers:

1. Set up an i18n library, extract each English string into a resource file under a key, and replace the string in the component with a key lookup.
2. Send the files to the TMS through its CLI or a Git integration.
3. Wait for the translations. AI translation can return quickly, but human translation takes longer: [Smartling's help center](https://help.smartling.com/hc/en-us/articles/4427220505755-Module-2-Translation-Cost-and-Turnaround-Times) says many vendors translate and edit about 1,500 to 2,000 words in two business days, and that a review step can make it take significantly longer.
4. Bring the translated files back, merge them, and wire each language into the product: load its files, register the locale, and check every screen.

Git integrations can automate moving the files and returning translations as pull requests; Crowdin's [GitHub integration](https://support.crowdin.com/github-integration/), for example, syncs every hour by default, and you can change the interval. Engineers still choose the message format, configure extraction or source authoring, and connect translated resources to the app. Those setup tasks are not necessarily repeated by hand for every release; review requirements and integration settings determine when new copy is ready to ship.

Two more costs come with the hand-off. Context has to be rebuilt: a TMS attaches screenshots, Figma frames, and key descriptions to each string, and the useful context depends on what your integration supplies. A bare list of keys and values does not explain the surrounding component or the conditions that select a sentence. Smartling's [supported file types](https://help.smartling.com/hc/en-us/articles/360007998893--Supported-File-Types) table, for example, lists no visual context by default for JSON, iOS, and Android files. And cost tracks what you store or who logs in: Crowdin prices mainly by hosted words (source words times target languages), Phrase by Strings seats and managed words, and Lokalise by plan tier, with allowances for processed words, seats, and integrations. ([Crowdin pricing](https://crowdin.com/pricing), [Phrase pricing](https://phrase.com/pricing/), and [Lokalise pricing](https://lokalise.com/pricing/), checked October 2026.)

## How the platforms compare

| Platform | How content gets in | Who translates | What the price scales with |
| --- | --- | --- | --- |
| [Smartling](/kb/general-translation-vs-smartling) | Resource files through the CLI, API, or a GitHub or Git connector | LanguageAI and AI Hub engines, or Smartling's linguists | Per-word rates for machine, AI, and human translation; Enterprise by quote |
| [Lokalise](/kb/general-translation-vs-lokalise) | Keys synced through the CLI, API, or Git integrations | Google Translate or DeepL, or LLMs through Pro AI; Lokalise translators or Gengo | Plan tier, with allowances for processed words, AI-translated words, seats, and integrations |
| [Phrase](/kb/general-translation-vs-phrase) | Keys pushed and pulled with the Strings CLI, or synced from GitHub | Language AI across 30+ engines; human translation ordered in Phrase Strings | Strings seats and managed words, plus machine translation and AI units |
| [Crowdin](/kb/general-translation-vs-crowdin) | Files or strings synced through the CLI or Git integrations | Machine translation engines and AI providers, often with your own API keys; a vendor marketplace | Hosted words and manager seats |
| [Transifex](/kb/general-translation-vs-transifex) | Files through the CLI or Git integrations, or strings pushed from code with Transifex Native | XTM IQ AI with quality scores; vendors such as Gengo | AI-translated words, on one plan sold through sales |
| General Translation | Content stays in your code inside [`<T>`](/docs/react/reference/components/t); the CLI also translates JSON, YAML, PO, iOS, and Android files | AI with context from your code, Glossary, and Custom Prompts; your team reviews in the Dashboard | [Usage, with a $0 platform fee and unlimited users, projects, and languages on Starter](https://generaltranslation.com/pricing) |

## How General Translation works differently

General Translation supports inline authoring with [`<T>`](/docs/react/reference/components/t) and translation generation in the build. It also translates existing resource files without changing the library that renders them. That gives a development team four practical benefits:

- **Faster.** With [`<T>`](/docs/react/reference/components/t), engineers author JSX in place without creating translation keys. Add target languages in `gt.config.json` and run [`npx gt translate`](/docs/cli/reference/commands/translate) in CI before a production build to generate translations for configured content. [Locadex](/docs/platform/locadex/quickstart) can open or update pull requests with translation files on your configured triggers. Your team's review requirements, CI checks, and merge settings determine when those translations ship.
- **Cheaper to run.** Reusing matching translations avoids paying to regenerate unchanged content, and inline authoring removes the work of inventing and maintaining a key for each JSX message. Localization is usage-based, without seat charges or localization feature tiers, so inviting reviewers does not add a per-seat bill. Enterprise differences cover security, governance, and engineering services. Compare your workload using the [current pricing](https://generaltranslation.com/pricing).
- **Higher quality through context and review.** The CLI extracts marked JSX with its element structure, named variable placeholders, branches, and any [`context`](/docs/react/reference/components/t#context) note. Existing resource files can use per-string metadata, plus your Glossary and Custom Prompts. For example, a note can distinguish “Save” in a document editor from “Save” on a pricing page. These inputs give the translation service information a bare value lacks; named placeholders let the app supply live values when rendering. A Context Group applies the same terms and tone to every project you assign it to, so web, docs, and mobile use the same words, and your team reviews and edits translations on the Dashboard's **Translations** page.
- **Lower risk.** Adopt the translation service while keeping your current library and reviewed catalogs. Import existing translations before generating changes; inline JSX can come later. The MIT-licensed `gt-react` and `gt-next` libraries can also render supplied local translations without a GT account or a runtime call to the translation service. [Bundled translations](/docs/react/guides/storing-translations) let the app keep serving its release even when the translation service is unavailable.

General Translation supports Ramp's 11+ locales across its dashboard, landing page, and iOS app; Cursor's 14+ locales across web and docs; and Profound's 47+ locales across its platform and docs. These [production deployments](https://generaltranslation.com/enterprise) show the platform serving multiple product surfaces. General Translation's [enterprise offering](https://generaltranslation.com/enterprise) includes SOC 2 Type II and ISO 27001 certification and GDPR compliance.

## When a TMS is the better fit

Choose a TMS when:

- linguists or agencies translate in a CAT (computer-assisted translation) editor with translation memory and multi-step review;
- you exchange XLIFF, ARB, or Office files with vendors and need a platform built around that exchange;
- you want to buy professional human translation through the same platform;
- native iOS and Android apps need over-the-air string updates through an SDK.

Choose General Translation when most of your product's text lives in code and ships on a release schedule, and you want translation to happen in that release.

## Moving from a TMS

You don't have to change your file layout. The CLI translates the resource files you already have, including [JSON](/kb/translate-json-files), YAML, Markdown and MDX, PO, [iOS String Catalogs](/kb/localize-ios-app) and `.strings`, and [Android `strings.xml`](/docs/cli/reference/formats/android-strings-files). Point `gt.config.json` at them and run [`npx gt upload`](/docs/cli/reference/commands/upload), which sends your source files and any existing translations to the platform. Glossary imports accept CSV, TSV, JSON, and text files, so terms exported from a TMS can go into a Context Group. (See [Defining context for translations](/docs/platform/dashboard/guides/defining-context-for-translations).) Keep the existing renderer and validate one locale before expanding the rollout. Switching generation providers and replacing the rendering library are separate decisions.

## Key takeaways

- A TMS coordinates content, translators, engines, and review. Its integrations can automate file transfers; engineers configure how the app produces and consumes those resources.
- General Translation combines inline JSX authoring or existing resource files with translation generation in the development workflow. Evaluate the fit using your source format, context, review requirements, and release process.
- Its open-source libraries and CLI can load portable translation files. Keep a TMS when you need XLIFF exchange, professional translation services, or native mobile over-the-air updates.

## Related questions

- [What is a translation management system (TMS)?](https://generaltranslation.com/en-US/kb/what-is-a-translation-management-system.mdx): A translation management system (TMS) is software that stores your source content and its translations and runs the translation workflow: translation memory, glossaries, review, machine translation, and integrations. Its translation memory reuses earlier translations by exact or fuzzy match. Crowdin, Lokalise, Phrase, Smartling, and Transifex are common examples.
- [How do I translate i18n JSON files?](https://generaltranslation.com/en-US/kb/translate-json-files.mdx): Translate only the string values in a JSON locale file. Keep nonplural keys, placeholders such as {{name}}, and tags unchanged, but expect plural keys to differ by language: Polish needs inbox_few and inbox_many. Use a format-aware tool or API, then parse and validate the output before review.
- [Smartling alternatives: General Translation vs. Smartling](https://generaltranslation.com/en-US/kb/general-translation-vs-smartling.mdx): Choose General Translation when you want app translations generated from code as part of your release. Smartling combines a translation management system, AI and human services, and a website translation proxy. General Translation keeps copy in your components, carries its context into translation, and gives your team a Dashboard for review.
- [Lokalise alternatives: General Translation vs. Lokalise](https://generaltranslation.com/en-US/kb/general-translation-vs-lokalise.mdx): General Translation is a strong Lokalise alternative for teams that want readable copy in JSX and translation built into development. Lokalise is built around shared keys, design-tool integrations, and mobile over-the-air delivery. General Translation generates translations from the app's marked content and supports review in its Dashboard or in GitHub pull requests.
- [Crowdin alternatives: General Translation vs. Crowdin](https://generaltranslation.com/en-US/kb/general-translation-vs-crowdin.mdx): Choose General Translation to keep copy in your components and generate translations with your build. Crowdin manages translation projects around resource files, translators, and review workflows, which engineers connect to the app and maintain as the product changes. Crowdin remains a strong fit for open-source community translation and vendor-led programs.

## Previous and next questions

- Previous question: [Crowdin alternatives: General Translation vs. Crowdin](https://generaltranslation.com/en-US/kb/general-translation-vs-crowdin.mdx)
- Next question: [General Translation vs. Babel and Flask-Babel: which should you use?](https://generaltranslation.com/en-US/kb/general-translation-vs-flask-babel.mdx)

## Sitemap

See the [Knowledge Base sitemap](https://generaltranslation.com/en-US/kb/sitemap.md) for every article.