---
title: "Linguana vs Lingo.dev: two compilers, two approaches to localization"
seoTitle: "Linguana vs Lingo.dev (2026): compiler i18n compared"
description: "Linguana vs Lingo.dev: both translate apps without keys. Compare framework support, review and releases, model choice, file formats, and pricing in detail."
ogTitle: "Linguana vs\nLingo.dev"
category: comparison
publishedAt: 2026-10-06
author: linguana-team
tags: [comparison, lingo-dev, compiler]
keywords:
  - linguana vs lingo.dev
  - lingo.dev alternative
  - lingo.dev compiler
  - i18n compiler without keys
  - lingo.dev vs linguana
summary:
  - "Linguana and Lingo.dev both offer a compiler that translates an app without translation keys or t() wrappers for static text."
  - "Linguana's compiler covers React, Vue, Svelte, Solid, TanStack Start, and the Next.js 16 App Router; Lingo.dev's compiler documents Next.js App Router and Vite with React."
  - "Linguana adds a review dashboard and immutable, versioned releases with one-step restore; Lingo.dev's human review and routing is on its Enterprise plan."
  - "Lingo.dev offers more model choice and a CLI for 18 file formats in CI; Linguana focuses on translating web app source code."
  - "Linguana costs $0 or $19 a month plus $8 per million new characters; Lingo.dev's Production plan starts at $99 a month plus usage."
faq:
  - q: "What is the difference between Linguana and Lingo.dev?"
    a: "Both use a compiler to find text in your code without keys. Linguana pairs its compiler with a review dashboard and versioned releases you publish and roll back, and supports React, Vue, Svelte, Solid, TanStack Start, and Next.js. Lingo.dev is a broader localization engineering platform with configurable engines, many models, a file-based CLI, and a React compiler."
  - q: "Does the Lingo.dev compiler support Vue or Svelte?"
    a: "On October 6, 2026, the Lingo.dev compiler documentation covered Next.js App Router and Vite with React. We did not find documented compiler support for Vue or Svelte. Lingo.dev's CLI can still translate locale files for other frameworks."
  - q: "Is the Lingo.dev compiler production ready?"
    a: "When we checked on October 6, 2026, Lingo.dev's compiler documentation described it as alpha and not recommended for production use. Check their documentation for the current status."
  - q: "Can I choose the AI model in Linguana?"
    a: "No. Linguana manages translation for you, with context profiles, a glossary, and translation memory. If choosing among many models matters to you, Lingo.dev offers that."
  - q: "How does pricing compare?"
    a: "Linguana's Free plan includes 50,000 newly translated characters a month; Pro is $19 per month with 2,000,000 included, then $8 per million. Lingo.dev's Sandbox is free with 100,000 tokens a day, and Production is $99 a month plus model costs and $2 per million tokens of infrastructure."
comparison:
  competitor: Lingo.dev
  competitorUrl: https://lingo.dev
  competitorLogo:
    src: /logos/competitors/lingo-dev.png
  checkedAt: 2026-10-06
  verdict: "Pick Lingo.dev if you want a configurable localization engine with model choice and file-based translation across many formats. Pick Linguana if you want keys-free translation across five web frameworks, with people reviewing every string and releases you control."
  chooseUsIf:
    - "Your app uses Vue, Svelte, Solid, or TanStack Start, not only React."
    - "You want people to review translations before they go live, on every plan."
    - "You want releases you can publish and roll back without redeploying."
    - "You want a flat monthly price and per-character translation costs you can predict."
  chooseThemIf:
    - "You want to choose from hundreds of models, per language, with fallbacks."
    - "You translate locale files in many formats, such as YAML, PO, XLIFF, ARB, or Xcode strings, from CI."
    - "You want an Apache-2.0 codebase you can read and contribute to."
    - "You also localize CMS content or email through ready-made connectors."
  rows:
    - feature: Translation keys
      linguana: "None. Static text is found at build time."
      competitor: "None with the compiler. Text is found at build time."
      edge: tie
    - feature: Compiler frameworks
      linguana: "React, Vue, Svelte, Solid, TanStack Start (Vite 7 or 8), and the Next.js 16 App Router."
      competitor: "Next.js App Router and Vite with React."
      edge: linguana
    - feature: Compiler status
      linguana: "Publicly released SDK (0.1) with build diagnostics and an optional strict mode."
      competitor: "Documented as alpha and not recommended for production when checked."
      edge: linguana
    - feature: Human review
      linguana: "Review, edit, approve, and reject in the dashboard on every plan, with roles."
      competitor: "AI quality scoring; human review and routing on the Enterprise plan."
      edge: linguana
    - feature: Releases and rollback
      linguana: "Manual publication. Immutable catalog versions with one-step restore."
      competitor: "Translations are embedded in per-locale bundles at build time; rolling back means redeploying."
      edge: linguana
    - feature: Model choice
      linguana: "Managed for you. Not selectable."
      competitor: "400+ models, chosen per language, with fallbacks."
      edge: competitor
    - feature: File formats and CI
      linguana: "Translates web app source code."
      competitor: "CLI for 18 formats, with GitHub Actions, GitLab, and Bitbucket support."
      edge: competitor
    - feature: Source code
      linguana: "Free public SDK packages on npm; the CLI is MIT."
      competitor: "Apache-2.0 repository on GitHub."
      edge: competitor
    - feature: Pricing
      linguana: "Free for 50,000 characters a month. Pro: $19 a month with 2,000,000 included, then $8 per million."
      competitor: "Sandbox: free, 100,000 tokens a day. Production: $99 a month plus model costs and $2 per million tokens."
      edge: linguana
    - feature: Cost control
      linguana: "Cost shown before each run; runs over your monthly limit do not start."
      competitor: "Credit billing with auto-reload; model costs passed through without markup."
      edge: linguana
  sources:
    - label: "Lingo.dev compiler overview"
      url: https://lingo.dev/en/compiler
    - label: "Lingo.dev compiler: how it works"
      url: https://lingo.dev/en/compiler/how-it-works
    - label: "Lingo.dev pricing"
      url: https://lingo.dev/en/pricing
    - label: "Lingo.dev documentation"
      url: https://lingo.dev/en/docs
    - label: "Lingo.dev on GitHub"
      url: https://github.com/lingodotdev/lingo.dev
    - label: "Lingo.dev product overview"
      url: https://lingo.dev
related: [linguana-vs-lokalise, introducing-the-linguana-cli, linguana-vs-general-translation]
cta: signup
---

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.

::visual{name="workflow"}

## Which frameworks does each compiler support?

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

| Framework | Linguana | Lingo.dev compiler |
| --- | --- | --- |
| React on Vite | Yes | Yes |
| Next.js App Router | Yes (Next.js 16) | Yes |
| TanStack Start | Yes | Not documented |
| Vue | Yes (3.5+) | Not documented |
| Svelte | Yes (5+) | Not documented |
| Solid | Yes (1.9+) | Not documented |

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](https://docs.linguana.dev/docs/getting-started/nextjs) 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.

::visual{name="release-timeline"}

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

| Plan | Price | Translation included |
| --- | --- | --- |
| Free | $0 | 50,000 newly translated characters a month |
| Pro | $19 per organization per month | 2,000,000 characters, then $8 per million |
| Enterprise | Contact sales | Volume rates, SSO, dedicated support |

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](/pricing).

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

```terminal title="Terminal"
npx @linguanahq/cli create app
```

Read [Introducing the Linguana CLI](/blog/introducing-the-linguana-cli) for a walkthrough, or follow the [install guide](https://docs.linguana.dev/docs/getting-started/install) to add Linguana to an existing app.