Linguana vs Lingo.dev: two compilers, two approaches to localization

Linguana and Lingo.dev are closer to each other than to traditional translation management systems. Both offer a compiler that finds text in your code at build time, so you can translate an app without inventing keys or wrapping static text in t(). They differ in what surrounds the compiler: which frameworks it supports, who reviews the translations, and how they reach your users. This comparison is for developers choosing between them.

The short version#

Lingo.dev is a localization engineering platform. You configure translation "engines" with a model, brand voice, glossary, and rules, then use them through a CLI, an API, CI workflows, an MCP server, and a React compiler. It is flexible, model-agnostic, and open source under Apache-2.0.

Linguana is a product workflow for web apps. Its compiler works across React, Vue, Svelte, Solid, TanStack Start, and Next.js. Every string moves from build to translation to human review to a release that someone publishes, and can restore, from the dashboard.

How does Lingo.dev work?#

The Lingo.dev compiler parses React code with Babel, extracts text nodes and string attributes, and assigns each a stable hash. In development it uses a pseudo-translator; in CI it calls a configured model, then embeds the translations in per-locale bundles. You can override a single translation with a data-lingo-override attribute. Its documentation covers two setups: Next.js App Router with withLingo(), and Vite with React through lingoCompilerPlugin.

When we checked on October 6, 2026, the compiler documentation described it as alpha: "not recommended for production use", with APIs that may change.

Beyond the compiler, Lingo.dev's CLI translates locale files in 18 formats, including JSON, YAML, Markdown, PO, XLIFF, Flutter ARB, and Android and Xcode strings, and runs in GitHub Actions, GitLab CI/CD, Bitbucket Pipelines, or any runner with Node.js 22 or later. Engines can use any of more than 400 models, chosen per language, with fallbacks and AI quality scoring.

How does Linguana work?#

Linguana's Vite plugin, or @linguanahq/next for Next.js, finds user-facing text at build time: element text, plus attributes like title, placeholder, aria-label, and alt. It skips code, URLs, ids, and classes, never modifies your source, and can fail the build in strict mode when text is ambiguous or unsafe to extract.

The text is uploaded with the build. Someone starts a translation run after seeing its cost. AI translates it with your context profile and glossary, and translation memory reuses earlier work without a new charge. Your team reviews and edits in the dashboard, then publishes a release.

Which frameworks does each compiler support?#

This is the clearest difference. Here is what each compiler supported when we checked:

Lingo.dev's file-based CLI can still translate locale files for any framework, but then you are back to keys and files. If your app is not React, Linguana's compiler is the one that covers it today.

Linguana has limits of its own on Next.js. The Pages Router, localized URL routing, static export, and the Edge runtime are not supported yet. The Next.js guide lists them.

Who reviews translations before users see them?#

Lingo.dev leans on automation: AI reviewers score translations for quality and glossary compliance. Human review and routing are listed on its Enterprise plan.

In Linguana, human review is the default workflow on every plan, including Free. The strings editor shows each string with its context, placeholders, and history. Reviewers approve, reject, or edit, and edits that break placeholders, ICU syntax, or required glossary terms are rejected before they are saved. Roles (Owner, Admin, Editor, and Viewer) control who can do what.

How do translations reach users, and how do you undo them?#

The Lingo.dev compiler embeds translations into per-locale bundles at build time. That is simple and fast at runtime, and it ties every translation change to a build and deploy. Undoing a bad translation means fixing it and deploying again.

Linguana keeps translations out of your deploys. Publishing creates an immutable catalog version, and your app loads the published catalog at runtime, falling back to the source text. To undo a release, restore the previous one; nothing is deleted and nothing needs redeploying.

Pricing compared#

Lingo.dev's pricing on October 6, 2026:

• Sandbox: free, with 100,000 tokens a day.
• Production: $99 a month, with model costs passed through at no markup, plus $2 per million tokens for infrastructure and $0.01 per AI review run. Credit billing with auto-reload.
• Enterprise: custom, with human review and routing, SSO, and audit logs.

Linguana's pricing:

Token-based pricing tracks your model's real cost, which suits teams that want to tune models. Linguana's per-character price is easier to predict, and every run shows its cost before it starts. Runs that would exceed your monthly limit do not start. Use the estimator on the pricing page.

Where Lingo.dev is the better choice#

• Model control. If you want to pick models per language, set fallbacks, and tune engines, Lingo.dev is built for it.
• Many file formats. Translating YAML, PO, XLIFF, ARB, or mobile string files from CI is a core Lingo.dev feature. Linguana translates web source code.
• Open source. Lingo.dev's repository is Apache-2.0. Linguana's SDK packages are free on npm, and its CLI is MIT, but the platform itself is not open source.
• Content beyond the app. Lingo.dev has connectors for GitHub, Payload CMS, and Mailchimp.

Trying Linguana alongside Lingo.dev#

The fastest way to compare is to see a finished app. The Linguana CLI scaffolds a complete blog, SaaS page, or storefront in your framework, already translated into four languages, with no account needed:

$ npx @linguanahq/cli create app

Read Introducing the Linguana CLI for a walkthrough, or follow the install guide to add Linguana to an existing app.