A detailed comparison of Polyglot and Lingo.dev for AI-powered localization. Compare detection, translation quality, pricing, and developer workflows.
Polyglot and Lingo.dev are both AI-powered localization tools built for developers. Both use LLMs, both ship a CLI and a GitHub Action, and both can work with text that's still hardcoded in your components. But they take meaningfully different approaches to the problem.
The core difference: Lingo.dev's Compiler reads your JSX at build time and translates text without manual key extraction. Polyglot wraps hardcoded strings into your existing i18n library's catalogs — message files you own and review — then translates them with a review workflow, local preview, and PR checks. On Team and Scale, Polyglot Automation (early access) adds managed checks and catalog sync, and its Publisher opens a separate catalog-only PR after human review — your team merges it.
| Feature | Polyglot | Lingo.dev |
|---|---|---|
| Hardcoded strings (AST-based) | ✓Yes (reports them and wraps them into your i18n catalogs) | ✓Yes (Compiler parses JSX at build time) |
| Where translations live | Your i18n library's message files, in your repo | Generated at build time by the Compiler, or i18n files via the CLI |
| AI/LLM translation | Built-in | ✓Yes (multiple providers) |
| Local preview | ✓Yes (polyglot preview) | Via your dev server (Compiler) |
| CI/CD integration | ✓Yes (GitHub Action) | ✓Yes (GitHub Action opens translation PRs) |
| CLI support | Primary interface | ✓Yes |
| Web dashboard | ✓Yes (translation review) | ✓Yes |
| Free tier | Free local scanning, 500 source strings (lifetime) | Sandbox ($0) |
| Translation memory | ✓Yes | Not listed on pricing page |
| Glossary support | ✓Yes | ✓Yes |
| Framework detection | ✓Yes (7 frameworks; runtime support varies) | Configured per project |
| Editor integration | VS Code extension (inline diagnostics) | ✕No |
| Supported i18n formats | JSON, YAML, ARB, iOS .strings, Android XML | JSON, YAML, and more |
| Open source | GitHub Action and benchmark harness (MIT) | ✓Yes (Apache-2.0) |
Lingo.dev has clear strengths:
The Lingo.dev Compiler parses your JSX with Babel at build time and translates text without manual key extraction. If you'd rather not maintain translation keys at all, that's a real advantage.
Lingo.dev is Apache-2.0 licensed, so you can inspect, fork, and contribute to it.
Lingo.dev lets you choose between multiple LLM providers for translation (OpenAI, Google, Anthropic). If you have a preference or existing API credits, this flexibility matters.
Lingo.dev's CLI supports more i18n file formats out of the box — JSON, YAML, XLIFF, and others. If your project uses a less common format, Lingo.dev may handle it natively.
Lingo.dev's GitHub Action and GitHub App react to pushes and PRs, translate changed content, and write the results back as commits or pull requests, with an optional approval gate. See Lingo.dev's workflow docs.
Polyglot uses tree-sitter to find hardcoded strings — text in JSX, string literals, component props, Astro frontmatter, SvelteKit templates, and React Native components — and wraps them into your existing i18n library's message files through a saved plan you review before it's applied (and can undo). Detection covers Next.js, Astro, SvelteKit, Vue, Angular, React Native and Flutter; runtime support varies by setup, and Next.js App Router with next-intl is the best-tested path.
Generated translations land in the Polyglot dashboard for review, with version history. Automatic approval is off, so nothing is published without a person signing off.
Polyglot's VS Code extension surfaces untranslated strings inline as you code — scan-on-save, a sidebar of findings, and wrap actions you review before applying. You catch missing translations in the editor, not in a CI failure later.
Polyglot's fine-tuned translation engine scored 4.96/5 across 49 languages on our June 2026 pipeline, AI-judged — reproducible benchmark.
Polyglot maintains a translation memory that grows with your project. Identical and similar strings reuse existing translations, which keeps wording consistent and cuts repeat work.
polyglot preview launches a local server showing your app with translations applied before you deploy, so you can spot layout issues, text overflow, and context problems that are invisible in a JSON file.
Polyglot caches file content hashes and only re-scans changed files, so repeat scans on large codebases stay fast.
| Polyglot Free | Polyglot Pro | Lingo.dev | |
|---|---|---|---|
| Price | $0 | $49/mo ($39 annual) | Sandbox $0; Production $99/mo + usage |
| String detection | Unlimited (local) | Unlimited (local) | N/A |
| Translation | 500 source strings (lifetime) | 10,000 source strings (lifetime) | Usage-based |
| Languages | 2 | 5 | Varies by plan |
| Projects | 1 | 3 | Varies by plan |
| Glossary | Yes | Yes | Yes |
| Translation memory | Yes | Yes | Not listed |
Polyglot's free tier includes unlimited local scanning — you can run polyglot scan on any project you have and never pay a cent. Translation is where the paid tier kicks in, starting at $49/month ($39/month billed annually) for 10,000 source strings (lifetime). Lingo.dev's Sandbox plan is free, and Production is $99/month plus usage (see Lingo.dev pricing).
Competitor pricing checked September 22, 2026.
This is the biggest practical difference between the two tools.
Say your Next.js app has hardcoded text like "Welcome back", "Save changes", and "No results found." Both tools can deal with it, in different ways.
Lingo.dev's Compiler reads that JSX at build time and produces translated output without you creating keys. You skip the extraction step, and translations are generated as part of your build.
Polyglot wraps that text into your existing i18n library (for example next-intl) and adds it to your message catalogs. You review the source patch before it's applied, review generated translations in the dashboard, preview the screen locally, and get PR checks for new untranslated strings. The result is ordinary catalog files in your repo that work without Polyglot at runtime.
Pick the Compiler if you want the least setup and don't need to manage keys. Pick Polyglot if you want catalogs you own and a review step before anything ships.
Start in your terminal
Install the CLI, run a scan, and see exactly what you're missing. Free, no account required.