---
title: "Linguana vs General Translation: wrapping text or finding it?"
seoTitle: "Linguana vs General Translation (2026): compared"
description: "Linguana vs General Translation (gt-next, gt-react) compared on wrapping text, framework support, review and releases, URL routing, and pricing for your app."
ogTitle: "Linguana vs\nGeneral Translation"
category: comparison
publishedAt: 2026-10-06
author: linguana-team
tags: [comparison, general-translation, compiler]
keywords:
  - linguana vs general translation
  - general translation alternative
  - gt-next alternative
  - gt-react vs linguana
  - next.js i18n without wrapping text
summary:
  - "General Translation pairs open-source React and Next.js libraries with an AI translation platform; Linguana pairs a build-time compiler with a review and release workflow."
  - "With General Translation, you wrap JSX in <T> and strings in useGT() by default; an opt-in compiler can wrap JSX automatically in client-side React apps."
  - "With Linguana, the compiler finds static text in components without wrappers, in React, Vue, Svelte, Solid, TanStack Start, and Next.js."
  - "General Translation leads on Next.js locale routing, the Pages Router, MIT-licensed libraries, and an agent that opens i18n pull requests."
  - "Linguana leads on frameworks beyond React, manual publication with immutable releases, and per-character pricing with spend caps shown up front."
faq:
  - q: "Is Linguana a good General Translation alternative?"
    a: "Yes, if you build with Vue, Svelte, Solid, or TanStack Start, or want text found without wrapping it in components, plus explicit releases you publish and restore. If you need localized URLs in Next.js, the Pages Router, or MIT-licensed libraries, General Translation is a better fit today."
  - q: "Do I have to wrap text in <T> with General Translation?"
    a: "By default, yes: JSX goes in a <T> component and plain strings go through useGT(). General Translation also offers an opt-in compiler that wraps JSX automatically in client-side React apps built with Vite."
  - q: "Does Linguana support localized URLs like /fr/pricing?"
    a: "No. Linguana never changes URLs or routes; the selected language is stored in a cookie. General Translation's Next.js middleware supports locale prefixes in the URL."
  - q: "Can translations change without a redeploy?"
    a: "In both. General Translation loads translations from its CDN by default. Linguana loads the published catalog at runtime, so publishing or restoring a release changes what users see without a deploy."
  - q: "How does pricing compare?"
    a: "General Translation's Starter plan starts at $0 with no platform fee and usage-based billing; Enterprise is custom. Linguana's Free plan includes 50,000 newly translated characters a month, and Pro is $19 a month with 2,000,000 included, then $8 per million."
comparison:
  competitor: General Translation
  competitorUrl: https://generaltranslation.com
  competitorLogo:
    src: /logos/competitors/general-translation.svg
    dark: /logos/competitors/general-translation-dark.svg
  checkedAt: 2026-10-06
  verdict: "Pick General Translation for a React or Next.js app that needs localized URLs, the Pages Router, or MIT-licensed libraries. Pick Linguana if you want text found without wrappers across five frameworks, and releases your team publishes and restores on purpose."
  chooseUsIf:
    - "You build with Vue, Svelte, Solid, or TanStack Start, not only React and Next.js."
    - "You do not want to wrap every piece of static JSX text in a component."
    - "You want manual publication with immutable releases and one-step restore."
    - "You want the cost of each translation run shown before it starts, under a hard monthly cap."
  chooseThemIf:
    - "You need locale prefixes in your Next.js URLs, such as /fr/pricing."
    - "Your Next.js app uses the Pages Router."
    - "You want MIT-licensed i18n libraries you can use independently of a platform."
    - "You want an agent that opens pull requests adding i18n to your codebase."
  rows:
    - feature: Static JSX text
      linguana: "Found by the compiler at build time. No wrapper."
      competitor: "Wrapped in <T> by default; an opt-in compiler can inject <T> in client-side React apps."
      edge: linguana
    - feature: Strings with values
      linguana: "t(source, values) with the sentence itself, and <T> for links and emphasis."
      competitor: "useGT() for strings, <Var> for dynamic values in JSX."
      edge: tie
    - feature: Frameworks
      linguana: "React, Vue, Svelte, Solid, and TanStack Start on Vite, plus the Next.js 16 App Router."
      competitor: "React and Next.js (App and Pages Router); Vue, React Native, and TanStack Start packages, the last labelled experimental at launch."
      edge: linguana
    - feature: Next.js Pages Router
      linguana: "Not supported."
      competitor: "Supported since gt-react 11."
      edge: competitor
    - feature: Localized URLs
      linguana: "Never changes URLs. The language lives in a cookie."
      competitor: "Next.js middleware with locale prefixes and pathname configuration."
      edge: competitor
    - feature: Review and editing
      linguana: "Strings editor with approve, reject, and edit; edits that break placeholders or the glossary are rejected."
      competitor: "Dashboard translation editor with notes, glossary, context groups, and history."
      edge: tie
    - feature: Releases and rollback
      linguana: "Manual publication by default. Immutable catalog versions with one-step restore."
      competitor: "CDN delivery with publish from the CLI; history can restore a previous state."
      edge: linguana
    - feature: Open source
      linguana: "Free public SDK packages on npm; the CLI is MIT."
      competitor: "MIT-licensed libraries 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: "Starter from $0 with no platform fee, usage-based. Enterprise is custom."
      edge: tie
    - feature: Cost control
      linguana: "Cost shown before each run; runs over your monthly limit do not start."
      competitor: "Usage-based billing; rates listed separately from the plan table."
      edge: linguana
  sources:
    - label: "General Translation documentation"
      url: https://generaltranslation.com/en-US/docs
    - label: "General Translation: translating strings with useGT"
      url: https://generaltranslation.com/en-US/docs/react/guides/translating-strings
    - label: "General Translation compiler 1.3.0 release"
      url: https://generaltranslation.com/en-US/blog/compiler_v1_3_0
    - label: "gt CLI: translate command"
      url: https://generaltranslation.com/en-GB/docs/cli/reference/commands/translate
    - label: "General Translation: storing translations"
      url: https://generaltranslation.com/en-US/docs/react/guides/storing-translations
    - label: "gt-react 11.0.0 release"
      url: https://generaltranslation.com/en-US/blog/gt-react_v11_0_0
    - label: "gt-tanstack-start 0.1.0 release"
      url: https://generaltranslation.com/en-US/blog/gt-tanstack-start_v0_1_0
    - label: "General Translation: Next.js middleware"
      url: https://generaltranslation.com/en-US/docs/next/guides/middleware
    - label: "General Translation: reviewing translations"
      url: https://generaltranslation.com/en-GB/docs/platform/dashboard/guides/reviewing-translations
    - label: "General Translation pricing"
      url: https://generaltranslation.com/en-US/pricing
    - label: "General Translation on GitHub"
      url: https://github.com/generaltranslation/gt
related: [linguana-vs-lingo-dev, linguana-vs-lokalise]
cta: signup
---

General Translation and Linguana both use AI to take an app into more languages, and both care about developer experience. They start from different places. General Translation gives you open-source i18n libraries, `gt-next` and `gt-react`, where you mark text for translation, plus a hosted platform that translates it. Linguana's compiler finds the text in your components on its own, and its dashboard is built around reviewing translations and publishing releases. This comparison is for developers choosing between them.

## The short version

General Translation is a strong choice for React and Next.js. Its libraries are MIT-licensed, its Next.js middleware gives you localized URLs like `/fr/pricing`, it supports the Pages Router, and its Locadex agent can open pull requests that add i18n to your code.

Linguana is the stronger choice when you do not want to touch your components, or when your app is not React. Its compiler finds static text in React, Vue, Svelte, Solid, TanStack Start, and Next.js without wrappers. Every translation is reviewed in the dashboard and reaches users only when someone publishes a release, which you can restore in one step.

## How does General Translation work?

By default, you mark what should be translated. JSX goes inside a `<T>` component, with `<Var>` around dynamic values, and plain strings go through `useGT()`:

```tsx title="With gt-react"
import { T, useGT } from "gt-react";

export function Hero() {
  const gt = useGT();
  return (
    <T>
      <h1>Plan your next trip</h1>
      <input placeholder={gt("Search destinations")} />
    </T>
  );
}
```

The `gt` CLI scans your project for that marked content, sends it for translation, and either publishes the results to General Translation's CDN or saves them as local JSON files. CDN delivery is the default, so translations can update without a redeploy.

General Translation also has an opt-in compiler, released in April 2026, that wraps JSX text in `<T>` automatically during a Vite build. Its documentation describes it for client-side React apps, with a bootstrap step that loads translations before the first render.

In the dashboard, a translation editor lets your team edit translations, leave notes, apply a glossary, organize context, and restore earlier states from history.

## How does Linguana work?

Linguana's compiler runs in your build through a Vite plugin, or `@linguanahq/next` for Next.js. It finds user-facing text, including attributes like `title`, `placeholder`, `aria-label`, and `alt`, and skips code, URLs, ids, and classes. Your source files never change. Here is the same component:

```tsx title="With Linguana"
export function Hero() {
  return (
    <>
      <h1>Plan your next trip</h1>
      <input placeholder="Search destinations" />
    </>
  );
}
```

Each build uploads the text. Someone starts a translation run after seeing its cost; AI translates it with your context profile and glossary, and translation memory reuses earlier work at no new charge. People review and edit, then publish a release.

::visual{name="workflow"}

## Do you need to wrap your text?

With General Translation's default libraries, yes. That makes translation explicit: you can see in the code exactly what is translated, and the libraries never guess. The cost is that every new piece of copy needs a wrapper, and forgotten wrappers ship as untranslated text.

The opt-in compiler removes most of that for client-side React apps on Vite. Server-rendered Next.js apps and non-React frameworks still use the explicit APIs.

With Linguana, static text needs no wrapper in any supported framework, server-rendered or not. Text with values uses `t(source, values)` with the sentence itself, and links and emphasis use `<T>`, so both tools have explicit APIs for the dynamic cases. The [dynamic text guide](https://docs.linguana.dev/docs/build-with-code/dynamic-text-and-links) has the details. If the compiler meets text it cannot extract safely, it reports a diagnostic, and strict mode can fail the build.

::visual{name="keys-vs-source"}

## Which frameworks are supported?

| Framework | Linguana | General Translation |
| --- | --- | --- |
| React | Yes | Yes |
| Next.js App Router | Yes (Next.js 16) | Yes |
| Next.js Pages Router | Not yet | Yes |
| TanStack Start | Yes | Package labelled experimental at launch |
| Vue | Yes (3.5+) | gt-vue package |
| Svelte | Yes (5+) | Not documented |
| Solid | Yes (1.9+) | Not documented |
| React Native | No | gt-react-native package |

If your app is React or Next.js, both tools cover you. Beyond React, Linguana's coverage is broader and documented for production use.

## Localized URLs

General Translation's Next.js middleware detects the locale from the URL, a cookie, or browser headers, and supports locale prefixes like `/fr/pricing` with an `app/[locale]` folder structure. If you want each language to have its own URLs, for example for international SEO, that is a real advantage.

Linguana deliberately never changes URLs or routes. The selected language is stored in a cookie, so adding Linguana never moves a page. That keeps setup small, but it means one URL serves every language.

## How do translations reach users?

Both tools can update translations without a redeploy. General Translation publishes to its CDN from the CLI, and its dashboard history can restore an earlier state.

Linguana makes the release itself the unit of control. Publication is manual by default. Each release is an immutable catalog version, and restoring an earlier one changes what the app loads without deleting anything. Editing a translation creates a new version and never changes what is already live.

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

## Pricing compared

On October 6, 2026, General Translation listed two plans. Starter begins at $0 with no platform fee and usage-based billing, and includes unlimited projects, users, and languages, the translation editor, the CDN, the GitHub integration, and the Locadex agent. Enterprise is custom and adds SSO, role-based access control, and dedicated support. Per-word usage rates are listed separately from the plan table.

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 |

Linguana shows the cost of every run before it starts, and a run that would exceed your monthly limit does not start. Try the estimator on the [pricing page](/pricing).

## Where General Translation is the better choice

- **Localized URLs in Next.js.** Locale prefixes and pathname configuration are built in.
- **The Pages Router.** Supported since `gt-react` 11. Linguana supports the App Router only.
- **Open-source libraries.** The General Translation libraries are MIT-licensed and work independently of the platform.
- **Automated code changes.** The Locadex agent opens pull requests that add i18n to your app.
- **React Native.** General Translation has a package for it; Linguana is web-only.

## Trying Linguana

The fastest comparison is a finished app. The Linguana CLI scaffolds a blog, SaaS page, or storefront in React, Vue, Svelte, SolidJS, or TanStack Start, 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.