---
title: "Introducing the Linguana CLI: a translated app in one command"
seoTitle: "Introducing the Linguana CLI: translated apps in one command"
description: "The Linguana CLI scaffolds a blog, SaaS page, or storefront in five frameworks, already in four languages. Then it links the app to your project from the terminal."
ogTitle: "Introducing the\nLinguana CLI"
category: announcement
publishedAt: 2026-10-06
author: linguana-team
tags: [cli, templates, release]
keywords:
  - linguana cli
  - localization cli
  - multilingual app template
  - i18n starter template react vue svelte
  - npx @linguanahq/cli
summary:
  - "The Linguana CLI (@linguanahq/cli 0.1.0, MIT) creates a complete multilingual app with npx @linguanahq/cli create app."
  - "Fifteen templates are available: a blog, a SaaS page, and a storefront, each in React, Vue, Svelte, SolidJS, and TanStack Start."
  - "Demo mode ships English, French, Spanish, and Arabic, needs no account, and makes no Linguana API requests."
  - "When you are ready, login, link, and env pull connect the app to a project, and doctor checks the setup. Linking never starts paid translation."
  - "Every command works non-interactively with --yes and --json, so the CLI runs in CI and from AI coding agents."
faq:
  - q: "Do I need a Linguana account to try the CLI?"
    a: "No. npx @linguanahq/cli create app with demo mode uses bundled English, French, Spanish, and Arabic translations, needs no account, and makes no requests to Linguana. You only sign in when you want to connect the app to a project."
  - q: "Which frameworks do the templates support?"
    a: "React, Vue, Svelte, SolidJS, and TanStack Start. Each of the three templates (a blog, a SaaS landing page, and a storefront) is available in all five, for fifteen apps in total. There is no Next.js template yet."
  - q: "Does linking an app start paid translation?"
    a: "No. Creating or linking an app never starts paid translation and never publishes a catalog. Translation runs start when someone on your team chooses to start one, after seeing the estimated cost."
  - q: "What do I need to run the CLI?"
    a: "Node.js 22.12 or later, or Bun. The CLI works in projects that use npm, pnpm, Yarn, or Bun."
  - q: "Can I use the Linguana CLI in CI or with an AI coding agent?"
    a: "Yes. The CLI runs without prompts when it is not attached to a terminal, or when you pass --yes or --json. With --json it prints machine-readable results, and every option that a prompt asks for is also available as a flag."
cover:
  kind: visual
  name: cli-demo
related: [linguana-vs-lingo-dev, linguana-vs-lokalise]
cta: cli
featured: true
---

Today we are releasing the Linguana CLI. One command creates a complete app (a blog, a SaaS landing page, or a storefront) in your framework, already translated into four languages. When you want your own translations, the same CLI signs you in, links the app to a Linguana project, and checks the setup.

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

The package is [`@linguanahq/cli`](https://www.npmjs.com/package/@linguanahq/cli) 0.1.0, released under the MIT license. It needs Node.js 22.12 or later, or Bun, and works with npm, pnpm, Yarn, and Bun projects.

::video[A 24-second tour: create an app, switch between four languages, then log in, link, and run doctor. Account and project values are samples.]{src="/blog/media/introducing-the-linguana-cli.mp4" poster="/blog/media/introducing-the-linguana-cli-poster.jpg"}

## Why a CLI for localization

Most localization tools start after you have built something: you add an i18n library, invent keys, move your copy into JSON files, and wire up a sync. Linguana already removes most of that. Its build-time compiler finds the text in your components, so there are no keys and no locale files to maintain. You can read more about that approach on the [product page](/).

The CLI removes the remaining step: the blank project. Instead of reading a setup guide and hoping your config is right, you start from an app where everything is already connected, and then make it yours.

## Create a translated app in one command

Run `create app` and answer four prompts: the template, the framework, the package manager, and whether to connect to Linguana or try the demo.

Each answer is also a flag, so you can skip the prompts entirely:

```bash title="Terminal"
npx @linguanahq/cli create app my-store \
  --template storefront \
  --framework vue \
  --package-manager pnpm \
  --demo
```

Run `npx @linguanahq/cli templates list` to see every template and the frameworks it ships in.

## Fifteen apps, five frameworks

There are three templates, and each one is a finished app rather than a skeleton:

- **Elsewhere**, a blog: six complete articles, search and categories, and localized dates.
- **Relay**, a SaaS landing page: an interactive product preview, monthly and annual pricing, and accessible demo forms.
- **Common Goods**, a storefront: eight original products, search, sort, and filters, and a persistent shopping cart.

Every template is available in React, Vue, Svelte, SolidJS, and TanStack Start: fifteen apps in total. You can browse them, with screenshots, in the [template gallery](/templates).

::visual{name="template-gallery"}

The templates are frontends. Demo forms send nothing and the storefront's checkout takes no payments. CMS services, customer accounts, and real payments are yours to add.

## Four languages, including right-to-left

In demo mode, each app ships with English, French, Spanish, and Arabic. Switching to Arabic flips the layout to right-to-left, so you can see how your design holds up in both directions before you write any code.

::visual[Demo mode switches between bundled translations. Text shown is sample content.]{name="language-switch"}

Demo mode needs no account and makes no requests to Linguana. It is the quickest way to see what a multilingual app built with Linguana looks like.

## Connect when you are ready

When you want to translate your own copy, three commands connect the app to a project.

:::steps
1. **`login`** opens your browser and shows a short code. Confirm it matches, approve the request, and the terminal is signed in. Codes expire after ten minutes. On a remote machine, `login --no-browser` prints the address instead.
2. **`link`** connects the app to an organization and project, creating them if you need to, and writes the project's credentials to an ignored `.env.local` file.
3. **`env pull`** refreshes those credentials later, for development, staging, or production.
:::

```terminal title="Terminal"
npx @linguanahq/cli login
npx @linguanahq/cli link
```

The CLI is careful with credentials. Your session is stored outside the project, separately for each API origin. Build tokens go only into an ignored environment file and never get a browser prefix, and the CLI refuses to write to tracked environment files. `logout` revokes the CLI session without signing your browser out.

:::callout{tone="tip"}
[Linking never costs money]
Creating or linking an app never starts paid translation and never publishes a catalog. You decide when a translation run starts, after you see its estimated cost, and you decide when a release goes live.
:::

## Check your setup with doctor

`doctor` checks everything the app needs to build with Linguana: the SDK packages, the build configuration, your CLI session, the environment file, and the project token. Each check either passes or tells you what to fix.

```terminal title="Terminal"
npx @linguanahq/cli doctor
```

`doctor` supports Vite and TanStack Start apps today. `whoami`, `orgs list`, and `projects list` show which account, organizations, and projects the CLI can see.

## Built for CI and AI coding agents

Every prompt has a flag, and the CLI never waits for input when it is not attached to a terminal. Add `--yes` to accept defaults and `--json` for machine-readable output:

```bash title="CI"
npx @linguanahq/cli create app my-store \
  --framework vue --template storefront --demo \
  --package-manager pnpm --skip-install --yes --json
```

That makes the CLI a good fit for AI coding agents like Claude Code, Cursor, Codex, and Copilot. An agent can scaffold a template, run `doctor`, and read the JSON result without guessing at prompts. The [AI agent setup guide](https://docs.linguana.dev/docs/getting-started/ai-agent-setup) has a copy-paste prompt for adding Linguana to an existing app.

## What the CLI doesn't do yet

- There is no Next.js template, and `doctor` does not check Next.js apps yet. Next.js apps are supported by the SDK through [`@linguanahq/next`](https://docs.linguana.dev/docs/getting-started/nextjs).
- The CLI does not deploy your app or sign in to a hosting provider.
- `--yes` never chooses connected mode on its own, because connecting needs an account.

## Get started

:::steps
1. Run `npx @linguanahq/cli create app` and pick a template.
2. Start the dev server and switch languages in the app.
3. When you are ready for your own translations, run `login` and `link`.
:::

The [CLI documentation](https://docs.linguana.dev/docs/cli) covers every command and flag, and the [CLI page](/cli) has the full command reference. The [changelog](/changelog) lists everything else we have shipped.