# General Translation Knowledge Base: General Translation vs. i18n-tasks: which should you use?
URL: https://generaltranslation.com/en-US/kb/general-translation-vs-i18n-tasks.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: i18n-tasks is a Ruby gem that finds missing and unused Rails I18n keys, tidies locale files, and can fill missing keys through Google Translate, DeepL, OpenAI, Yandex, or watsonx. General Translation translates whole locale files with your Glossary, Custom Prompts, and Dashboard review. They do different jobs, and many teams can use both.
Category: Workflow Tools
Last updated: 2026-10-16
Authors: Kevin Wu, Jackie Chen
Published: 2026-10-16

i18n-tasks is a command-line tool for Ruby apps that use the i18n gem, which includes every Rails app. It scans your code for calls such as `t(".title")`, compares them with your locale files, and reports keys that are missing or unused, and its `translate-missing` command fills gaps with a machine translation service you bring your own key for. It checks your translations and can machine-translate a missing key, but it doesn't keep translations current when English changes. General Translation does the translating: its CLI writes every locale file from your English source, with your Glossary and Custom Prompts, so the two tools fit together more than they compete.

## What i18n-tasks does well

- **Finds missing and unused keys from code.** [An AST scanner reads `.rb` and `.html.erb` files](https://github.com/glebm/i18n-tasks#features--limitations) (and a regexp scanner covers formats such as HAML), resolves relative keys like `t(".title")`, and reports keys used in code but absent from a locale, or present but never used.
- **Plural-aware checks.** With the rails-i18n plural rules, [`missing` reports locales that lack a CLDR form](https://github.com/glebm/i18n-tasks/blob/main/CHANGES.md), such as Polish `few` and `many`.
- **CI-friendly.** `missing`, `unused`, and the other checks exit with status 1 when they find problems, and the gem ships [RSpec and Minitest templates](https://github.com/glebm/i18n-tasks/tree/main/templates) that fail your test suite on missing or unused keys.
- **File housekeeping.** [`normalize` sorts keys](https://github.com/glebm/i18n-tasks#normalize) (and with `-p`, moves them to the files your config assigns), `mv` and `rm` rename or delete keys across locales, `find` shows where a key is used, and `check-consistent-interpolations` catches a `%{count}` that was renamed or dropped in translation.
- **Five translation backends.** [`translate-missing` works with Google Translate, DeepL, Yandex, OpenAI, and IBM watsonx](https://github.com/glebm/i18n-tasks#translation-backends). You can [set DeepL glossary IDs and options](https://github.com/glebm/i18n-tasks/blob/main/templates/config/i18n-tasks.yml), or the OpenAI model (`gpt-4o-mini` by default), system prompt, and a prompt per locale. `%{...}` placeholders are swapped for tokens before sending and restored afterward.
- **Free.** It's [MIT-licensed (version 1.1.2)](https://rubygems.org/gems/i18n-tasks); you pay each translation provider directly, usually per character or per token.

## What i18n-tasks leaves to you

Here's `missing` and `unused` on a small Rails app with English, Polish, and Spanish files, where the inbox view calls a key nobody defined:

```text title="bundle exec i18n-tasks missing (excerpt)"
| Locale | Key                 | Value in other locales or source  |
|  all   | inbox.show.empty    | app/views/inbox/show.html.erb:3   |
|   es   | inbox.show.title    | en Inbox                          |
|   es   | inbox.show.unread   | en {"one" => "You have %{count} unread message.", ...} |
|   pl   | flash.saved         | en Saved.                         |
|   pl   | inbox.show.unread   | few, many                         |
```

```text title="bundle exec i18n-tasks unused"
| Locale | Key                 | Value    |
|   en   | inbox.show.archived | Archived |
```

That report is accurate and useful. Filling the gaps is where the work stays with you:

- **The Google backend sends string values.** In a run with that backend's network call stubbed out, `translate-missing es` sent the values below with placeholders masked, without the keys, file, or view.

  ```text
  ["Inbox", "You have X__0 unread message.", "You have X__0 unread messages.", "Archived"]
  ```

- **Plural forms keep English's shape.** For a Polish key that was missing entirely, it wrote `one` and `other`, and the next `missing` run reported `few, many`.
- **Changed English isn't retranslated.** [`translate-missing` fills keys that don't exist in a locale](https://github.com/glebm/i18n-tasks#translate-missing-keys). When you edit an English string, the existing translations stay as they were.
- **A failed Google request can still write files.** With no Google API key set, `translate-missing --backend=google pl` warned that the slice failed, reported two keys as translated, copied the English values into `pl.yml`, and exited 0. Those keys then dropped out of `missing`; only `eq-base` (translations equal to the source) showed them.

## Where General Translation fits

General Translation handles translation generation while i18n-tasks checks the Rails catalogs. Point the `gt` CLI at your English file and run [`npx gt translate`](/docs/cli/reference/commands/translate) in CI. It writes every target locale, and on later runs it reuses translations for unchanged entries and retranslates the ones whose English changed. Each run uses your project's [Glossary and Custom Prompts](/docs/platform/dashboard/guides/defining-context-for-translations), so terms and tone stay the same in every file, and your team can [review and edit translations](/docs/platform/dashboard/guides/reviewing-translations) in the Dashboard.

Keep i18n-tasks for Ruby source scanning and catalog validation. Run General Translation's Node.js CLI for translation generation, and map the resulting YAML to Rails' locale-rooted format as shown in [General Translation vs. Rails I18n](/kb/general-translation-vs-rails-i18n). Use that workflow for catalogs with matching source and target key structures.

## i18n-tasks vs. General Translation at a glance

| Feature | i18n-tasks | General Translation |
| --- | --- | --- |
| Role | Scans Ruby code and checks missing or unused catalog keys | Generates translations and keeps them current as source copy changes |
| Plural validation | Checks required locale categories | Pair generation with i18n-tasks checks |
| Machine translation | `translate-missing`, through a provider you choose | [`npx gt translate`](/docs/cli/reference/commands/translate) |
| Translation context | Depends on the backend; DeepL accepts glossary IDs and OpenAI accepts prompts | Your file's content and metadata, plus assigned Glossary and Custom Prompts |
| When English changes | Existing translations stay | Changed entries are retranslated |
| Review | Git diff | Dashboard and Git diff |
| Cost | Free gem; provider bills per character or token | [Usage-based translation](https://generaltranslation.com/pricing) |

Choose i18n-tasks alone when translators write your locale files and you need CI to catch missing and unused keys, or when you only want a quick machine draft for a few strings. Use General Translation when you want translations updated as the English changes, with consistent terminology and Dashboard review. Keep i18n-tasks for Rails source scanning and catalog checks.

## Using both in CI

Use the English-to-Spanish catalog setup from the [Rails integration](/kb/general-translation-vs-rails-i18n). Run translation and locale mapping first, then validate key completeness, plural categories, and placeholders with i18n-tasks:

```bash
npx gt translate
ruby script/export_rails_locales.rb                     # export catalogs for Rails
bundle exec i18n-tasks missing                           # keys used in code, plus plural forms
bundle exec i18n-tasks unused
bundle exec i18n-tasks check-consistent-interpolations   # %{name} matches the source
```

Each `i18n-tasks` command exits with status 1 on a problem, so the job fails before a broken file merges. The CLI needs a project ID and an API key with **Files > Write** and **Translation queue > Enabled** permissions, set as `GT_PROJECT_ID` and `GT_API_KEY`. (See [Configuring the CLI](/docs/cli/guides/configuring#credentials).)

## Key takeaways

- i18n-tasks checks missing, unused, and incomplete plural keys in Rails apps.
- `translate-missing` fills missing keys; it leaves existing translations unchanged when you edit the English source.
- General Translation translates whole locale files with your Glossary and Custom Prompts and keeps them current as English changes; run it before i18n-tasks checks in the same CI job.

## Related questions

- [General Translation vs. Rails I18n: do you need both?](https://generaltranslation.com/en-US/kb/general-translation-vs-rails-i18n.mdx): Rails I18n looks up messages and formats dates and numbers. General Translation produces the translations, keeps them current as your English changes, and gives your team a Dashboard for review. Use both to ship translated Rails catalogs with each release.
- [General Translation vs. Mobility: which should you use?](https://generaltranslation.com/en-US/kb/general-translation-vs-mobility.mdx): Mobility stores translated model attributes in your database. General Translation produces those translations through its API, using your Glossary and Custom Prompts. Use both to translate product listings, posts, and other database content while keeping your Rails models.
- [Why use General Translation instead of Google Translate?](https://generaltranslation.com/en-US/kb/general-translation-vs-google-translate.mdx): Google Translate is a quick way to translate one-off text. Shipping a product in another language also needs each string translated in context, consistent terms, correct variables and plurals, review, and a release process. General Translation understands each string's context in your code and automates the whole localization workflow, from code to review to every release.
- [Why use General Translation instead of a TMS (Smartling, Lokalise, Phrase, Crowdin, or Transifex)?](https://generaltranslation.com/en-US/kb/general-translation-vs-tms.mdx): A translation management system (TMS) such as Smartling, Lokalise, Phrase, Crowdin, or Transifex coordinates translators, but engineers still extract strings, send them out, wait for translations, and wire them back into the product. General Translation translates content in your code with its context, ships every language with each release, and runs on open-source libraries with no lock-in.
- [What is the best localization software for developers?](https://generaltranslation.com/en-US/kb/best-localization-software.mdx): Look for one system that covers the whole pipeline, from the i18n library in your code to translation and delivery, instead of stitching together a separate library, translation management system, and translation vendor.

## Previous and next questions

- Previous question: [General Translation vs. GNU gettext: do you need both?](https://generaltranslation.com/en-US/kb/general-translation-vs-gettext.mdx)
- Next question: [General Translation vs. i18next, react-intl, and next-intl: which i18n library should you use?](https://generaltranslation.com/en-US/kb/general-translation-vs-i18n-libraries.mdx)

## Sitemap

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