# 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.

## Video

The video is narrated in English, with English captions.

[General Translation vs. i18n-tasks: which should you use?](https://caxecubb9c64cezv.public.blob.vercel-storage.com/films/kb-general-translation-vs-i18n-tasks.mp4) (45 sec)

i18n-tasks is a Ruby gem that finds missing and unused Rails I18n keys and can fill missing keys through a machine translation provider. General Translation translates whole locale files with your Glossary, Custom Prompts and Dashboard review, and many teams use both: run `npx gt translate` in CI to write every target locale, let later runs retranslate entries whose English changed, and run the i18n-tasks checks after translation in the same job.

## 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.
- [Google Translate alternatives: General Translation vs. 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, but 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.
- [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.
- [What is the best localization software for developers?](https://generaltranslation.com/en-US/kb/best-localization-software.mdx): The best localization software for developers translates content where it is written in the code, with context from your product, and keeps every language current. General Translation does this with open-source libraries, Context Groups, and Locadex, an AI agent which opens pull requests.

## 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/en-US/kb/sitemap.md) for every article.