# General Translation Knowledge Base: General Translation vs. SimpleLocalize: which should you use?
URL: https://generaltranslation.com/en-US/kb/general-translation-vs-simplelocalize.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Choose General Translation to keep UI copy and translation context in your components, generate changed messages before the build, and review wording without seat fees. You can also keep existing i18next or next-intl catalogs. SimpleLocalize fits teams that want a keyed translation editor with on-page editing, customer-specific wording, and native mobile over-the-air updates.
Category: Workflow Tools
Last updated: 2026-11-13
Authors: Jackie Chen
Published: 2026-11-13

SimpleLocalize is a hosted translation management system built for software teams. Your app keeps its existing i18n library, such as i18next or react-intl, and SimpleLocalize manages the catalog that library reads: you upload keys from your locale files, translate them in its web editor with machine translation, AI, or your team, and download the results or serve them from its CDN. A CLI and a GitHub App automate the file exchange. General Translation starts from the code instead: copy stays in your components, and translation runs as part of the build.

## What SimpleLocalize does well

- **A focused translation editor.** The [Translation Editor](https://simplelocalize.io/docs/) gives each key its translations, history, comments, screenshots, and two kinds of [descriptions](https://simplelocalize.io/docs/general/descriptions/): a code description that travels with your files and a translator description written in the editor. Glossary, translation memory, QA checks, and reviews are built in.
- **AI auto-translation with project context.** [Auto-translation](https://simplelocalize.io/docs/general/auto-translation/) uses SimpleLocalize AI, or your own key for supported providers such as OpenAI, Anthropic, Gemini, DeepL, and Google Translate. Its AI workflow can use key descriptions, screenshots, comments, and previous translations; the context available depends on the selected provider.
- **Automated file sync.** The [GitHub App](https://simplelocalize.io/docs/integrations/github-app/) uploads source files on push or pull request, auto-translates new content, opens pull requests with translated files, runs checks, and flags hardcoded strings. The [CLI](https://simplelocalize.io/docs/cli/get-started/) exposes upload, auto-translate, and download commands for your own build pipeline, plus extraction from react-intl, react-i18next, Android, and iOS projects.
- **Hosting and over-the-air updates.** [Translation Hosting](https://simplelocalize.io/docs/translation-hosting/get-started/) publishes translations to a CDN with separate Latest and Production environments and rollbacks, and mobile SDKs update [Android](https://simplelocalize.io/docs/integrations/android-ota/) and [iOS](https://simplelocalize.io/docs/integrations/ios-macos-ota/) strings without an app release.
- **Editing and feedback on the page.** The SimpleLocalize Chrome extension finds, edits, and reviews translations on your live website, and public suggestions let users propose fixes.
- **Per-customer wording.** Customer translations let you override wording for individual customers, and an MCP server, IDE extensions, a Figma plugin, and Shopify and Webflow integrations connect the editor to the rest of your stack.

## What SimpleLocalize still leaves to your engineers

SimpleLocalize manages the catalog your library reads. In a react-i18next app with source text in JSON, the component refers to a key and maps its rich-text elements:

```tsx title="src/TrialBanner.tsx"
import { Trans } from 'react-i18next';

export function TrialBanner({ name }: { name: string }) {
  return (
    <p>
      <Trans
        i18nKey="trial.banner"
        values={{ name }}
        components={{ planLink: <a href="/pricing" /> }}
      />
    </p>
  );
}
```

```json title="locales/en/translation.json"
{
  "trial": {
    "banner": "Welcome back, {{name}}. Your trial ends soon. <planLink>Compare plans</planLink>"
  }
}
```

With the GitHub App, uploading, auto-translating, and opening a pull request with the translated files can run on configured pushes. You can also use the CLI to translate and download during a build. Engineers still configure extraction or source catalogs, map messages and placeholders to the UI, maintain project metadata, and decide how reviewed translations reach a release. Some libraries let you write defaults inline and extract IDs automatically; the catalog and its connection to the app still need maintaining. In the example above, the source sentence and the React elements it refers to live in different files.

SimpleLocalize plans include 500 translation keys on Community through 12,000 on Business, with team-member limits and a monthly auto-translation character allowance. You can adjust limits or add members; crowd-sourced contributors are unlimited. (See [SimpleLocalize pricing](https://simplelocalize.io/pricing/), checked November 2026.)

## SimpleLocalize vs. General Translation at a glance

| Feature | SimpleLocalize | General Translation |
| --- | --- | --- |
| Where strings live | Keys in locale files read by your i18n library, managed in the SimpleLocalize editor | In your code inside [`<T>`](/docs/react/reference/components/t), or in the resource files you already have |
| How code connects | The GitHub App on push and pull request, or the CLI in CI | [`npx gt translate`](/docs/cli/reference/commands/translate) in your build, or [Locadex](/docs/platform/locadex/quickstart) pull requests |
| Who translates | Machine translation or AI auto-translation, reviewed by your team or contributors | AI with context from your code, Glossary, and Custom Prompts, reviewed by your team in the Dashboard |
| Context for each string | Key descriptions, screenshots, comments, and translation history, depending on provider | Marked JSX structure and notes; optional source lines; shared Glossary and Custom Prompts; metadata for existing files |
| New UI text | The GitHub App flags hardcoded strings | In Next.js and React apps, Locadex wraps unmarked text in a pull request |
| Delivery | Downloaded files, or Translation Hosting on a CDN with environments; mobile OTA SDKs | Local files in your build, or General Translation's CDN for React and Next.js |
| Pricing | Free plan; paid plans by translation keys, with team-member limits | [Usage-based translation](https://generaltranslation.com/pricing), unlimited users on Starter |

## Why teams choose General Translation over SimpleLocalize

General Translation translates the copy in your components, so there are no keys to create or keep in sync. Here is the same banner with `gt-react`, after [setting up its provider](/docs/react/react-quickstart):

```tsx title="src/TrialBanner.tsx"
import { T, Var } from 'gt-react';

export function TrialBanner({ name }: { name: string }) {
  return (
    <T>
      <p>
        Welcome back, <Var>{name}</Var>. Your trial ends soon.{' '}
        <a href="/pricing">Compare plans</a>
      </p>
    </T>
  );
}
```

The sentence, the name, and the link stay in the component, and [`npx gt translate`](/docs/cli/reference/commands/translate) translates the block as one unit while keeping the name untranslated.

- **Faster.** In the banner above, the copy, variable, and link are edited together. The CLI extracts that block and generates changed translations before your build, reusing matching completed work. This removes source-key and rich-text mapping work from each copy change.
- **Usage-based billing.** SimpleLocalize's member and key allowances affect what you pay as your catalog or review team grows. General Translation's [usage-based pricing](https://generaltranslation.com/pricing) has no seat charges or key-count tiers, so inviting another reviewer doesn't increase a seat bill.
- **JSX structure as context.** Keep a note such as "Trial means a software subscription trial" next to the banner. The extracted structure carries the greeting and pricing link together, and reviewers can correct the generated wording in the [Dashboard](/kb/review-translations). The [context guide](/kb/ai-translation-context) shows how to add surrounding source lines and shared terminology.
- **Lower risk.** Start with the i18next or next-intl catalogs your app already renders and retain reviewed translations. Inline JSX can come later. For React and Next.js repositories, configured Locadex **Generate code** runs propose wrappers for newly unmarked text in a reviewable pull request. An app configured to load all translations locally with the MIT-licensed `gt-react` or `gt-next` can render them without a GT account or runtime service calls.

## When SimpleLocalize is the better fit

Choose SimpleLocalize when translators or reviewers want to edit text on your live site through a browser extension, when you want users to suggest translations, when you need different wording for individual customers, when native mobile apps need over-the-air string updates, or when your apps use formats such as [Flutter ARB, XLIFF, Java properties, or Excel](https://simplelocalize.io/docs/file-formats/arb/).

## Moving from SimpleLocalize to General Translation

1. **Export and back up.** Export a matching snapshot of your source and complete, reviewed target files from SimpleLocalize, and keep a backup. Finish incomplete locales first, so untranslated entries aren't imported as translations.
2. **Pause SimpleLocalize's writes.** Before General Translation writes any files, pause the GitHub App and remove SimpleLocalize download steps from CI. If two tools write the same files, whichever writes last wins.
3. **Set up context.** Configure `gt.config.json` for those files, carry key descriptions and length limits into [keyed metadata](/docs/cli/reference/keyed-metadata) for JSON or YAML, and import your glossary into a Context Group, so the first translations use them.
4. **Upload.** Run [`npx gt upload`](/docs/cli/reference/commands/upload) to import the target files that match the source snapshot.
5. **Translate and verify.** Run [`npx gt translate`](/docs/cli/reference/commands/translate) and check a locale in the app. For i18next or next-intl, keep your existing library while the CLI [generates subsequent translations](/docs/cli/guides/generating-translations); moving copy inline is a separate, later choice.

## Is General Translation an alternative to SimpleLocalize?

Yes. Your reviewed translations, key descriptions, and glossary carry over, and an i18next or next-intl app keeps its library. What changes is the loop: translation runs in your build from the component or file instead of through a synced catalog, and you can move copy inline into [`<T>`](/docs/react/reference/components/t) one feature at a time, as described in [Migrating i18n libraries](/docs/react/guides/migrating-i18n-libraries). On-page editing, user suggestions, and per-customer wording are the SimpleLocalize features you'd give up.

## Related questions

- [General Translation vs. a TMS (Crowdin, Lokalise, Phrase)](https://generaltranslation.com/en-US/kb/general-translation-vs-tms.mdx): 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.
- [General Translation vs. Tolgee: which should you use?](https://generaltranslation.com/en-US/kb/general-translation-vs-tolgee.mdx): Tolgee combines keyed messages, in-context editing, and AI translation in a self-hostable platform. General Translation keeps readable copy directly in your components and generates translations from the marked JSX, so you can ship new copy in every language without maintaining message keys.
- [General Translation vs. Localazy: which should you use?](https://generaltranslation.com/en-US/kb/general-translation-vs-localazy.mdx): Choose General Translation to translate web and native app copy with shared terminology and build automation, while keeping reviewed catalogs or adopting inline components. Its CLI translates in your build, reviewers edit in the Dashboard, and pricing follows usage, not key counts. Localazy fits teams that need broader file-format support, built-in professional translation services, and native mobile over-the-air updates.
- [What's the best continuous localization tool for teams that ship daily?](https://generaltranslation.com/en-US/kb/best-continuous-localization-tools.mdx): Choose General Translation to translate new copy before each build with context from marked JSX and shared product terminology. Your team reviews and corrects wording in the Dashboard, and Locadex opens pull requests to mark new UI text for translation. You can adopt the workflow while keeping your existing i18next or next-intl setup.
- [How do I give AI translation enough context for software strings?](https://generaltranslation.com/en-US/kb/ai-translation-context.mdx): Translate complete messages with meaning notes, placeholder roles, length limits, and shared terminology. General Translation's CLI extracts marked JSX as a structured block and carries context notes into generation. For existing JSON and YAML catalogs, keyed metadata supplies per-string instructions. Context Groups apply your Glossary and Custom Prompts across assigned projects, and reviewers correct the output in the Dashboard.

## Previous and next questions

- Previous question: [General Translation vs. Localazy: which should you use?](https://generaltranslation.com/en-US/kb/general-translation-vs-localazy.mdx)
- Next question: [How do I give AI translation enough context for software strings?](https://generaltranslation.com/en-US/kb/ai-translation-context.mdx)

## Sitemap

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