Languine: Open Source Publishing

What is Languine?

What it is

Languine is a self-hosted, Vercel-native localization tool for application text. It lives in the TypeScript and Vercel ecosystem, and it uses a CLI plus a dashboard to translate project strings with an AI model. The concrete problem it solves is repetitive manual localization: a team can point the CLI at a project, create a project record on its own deployment, and run a translate command instead of maintaining every language file by hand.

It replaces a hosted workflow with a deployment that the team owns. The Vercel deployment stores project data in serverless Postgres, exposes a dashboard, and accepts requests from the CLI or a GitHub Action. A shared API key controls access to the dashboard, CLI, and Action, while Vercel AI Gateway supplies the model used for translation.

Key capabilities

The CLI supports npx languine@selfhosted login, init, and translate for interactive localization work.
The CLI can run non-interactively when LANGUINE_BASE_URL and LANGUINE_API_KEY are set in the environment.
A GitHub Action can translate on push to main and open a pull request when create-pull-request is set to true.
The deployment provisions serverless Postgres through the Vercel Marketplace and injects DATABASE_URL automatically.
The build runs drizzle-kit migrate against the fresh database, so database migrations are applied during deployment.
The dashboard shows a status checklist and ready-to-paste CLI commands after the first deploy.
The AI model is configurable through AI_MODEL, with openai/gpt-4.1 as the default slug.

Who uses it and how

Development teams use it when application strings need AI-assisted translation inside a self-hosted Vercel deployment.
Engineers use the CLI during local setup by logging in with a team URL, initializing a project, and running translate.
CI users run the GitHub Action on push to main, passing LANGUINE_API_KEY, LANGUINE_BASE_URL, and project-id.
Operators use the dashboard as the control surface for project creation status and CLI instructions, not as a separate integration hub.

Getting started

Deploy the repository with the Vercel button, set LANGUINE_API_KEY and optionally AI_MODEL, then run npx languine@selfhosted login, init, and translate. For automation, export LANGUINE_BASE_URL and LANGUINE_API_KEY, or use languine-ai/languine@v4 in a GitHub Action.

When to use it — and when not to

Use it when a team wants Vercel-native self-hosted AI localization and can operate the required Vercel project, serverless Postgres, API key, and Deployment Protection. It is less suitable when the stack cannot depend on Vercel AI Gateway or Marketplace Postgres, because the README describes authentication through the project's OIDC token and automatic database injection. The project is young, with zero listed contributors and ten open issues, and the API key becomes publicly visible if Deployment Protection is not enabled.

project readme (upstream, from github) — read inline

Languine

Self-hosted, Vercel-native AI localization. Click Deploy. Run npx languine. That's it.

One-click deploy

What the button does:

Forks this repo to your GitHub account.
Creates a Vercel project with apps/web as the root.
Provisions serverless Postgres via the Vercel Marketplace — DATABASE_URL is auto-injected.
Prompts you for LANGUINE_API_KEY (any random string) and an optional AI_MODEL slug.
Builds and deploys. The build automatically runs drizzle-kit migrate against your fresh database.

After the first deploy, do these two things:

Enable Deployment Protection. In your Vercel project: Settings → Deployment Protection → turn on Vercel Authentication (or Password Protection). This gates the dashboard and /cli/token. Without this, your API key is publicly visible.
Open the dashboard (https://.vercel.app). It shows a status checklist and ready-to-paste CLI commands.

That's it. No additional integrations to configure — Vercel AI Gateway authenticates automatically via the project's OIDC token.

Use the CLI

The self-hosted CLI ships under the selfhosted npm dist-tag so it doesn't disturb users still pointed at the legacy hosted backend. Install it with npx languine@selfhosted ... (or pin "languine": "^4" in your package.json). npx languine@latest continues to resolve to the legacy 3.x CLI for the old hosted service.

In any project that needs translations:

npx languine@selfhosted login --url https://languine.your-team.vercel.app
npx languine@selfhosted init
npx languine@selfhosted translate

languine login opens /cli/token in your browser. Because Deployment Protection is on, only authorized owners can see the page — copy the API key, paste it into the CLI prompt.

languine init creates a project on your deployment via tRPC (project.create) and writes the returned projectId into languine.json. You don't need to provision anything from the dashboard.

For non-interactive use (CI, scripts):

export LANGUINE_BASE_URL=https://languine.your-team.vercel.app
export LANGUINE_API_KEY=<the-key-you-set-on-vercel>
npx languine@selfhosted translate

GitHub Action

name: Languine
on:
  push:
    branches: [main]

jobs:
  translate:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write
    steps:
      - uses: actions/checkout@v4
      - uses: languine-ai/languine@v4
        with:
          api-key: ${{ secrets.LANGUINE_API_KEY }}
          base-url: ${{ vars.LANGUINE_BASE_URL }}
          project-id: prj_xxxxxxx
          create-pull-request: 'true'

Environment variables

Variable	Required	Source	Description
`LANGUINE_API_KEY`	Yes	Set at deploy	Single API key shared between the dashboard, CLI and Action. Generate with `openssl rand -hex 32`.
`DATABASE_URL`	Yes	Auto-injected	Postgres connection string from the Vercel Marketplace integration you picked at deploy.
`AI_MODEL`	No	Set at deploy	Vercel AI Gateway model slug. Defaults to `openai/gpt-4.1`. Examples: `anthropic/claude-sonnet-4`, `openai/gpt-4.1-mini`.
`AI_GATEWAY_API_KEY`	No	Local dev only	Only needed when running locally outside Vercel. In production the Gateway uses the project's OIDC token.

Architecture

Hosting: Vercel (Next.js 16, App Router, Node.js runtime).
Database: Serverless Postgres from the Vercel Marketplace + Drizzle ORM.
Background jobs: Vercel Workflows (workflow SDK) — durable, resumable, observable.
AI: Vercel AI Gateway (@ai-sdk/gateway + AI SDK v6) — single configurable model.
Auth: Single LANGUINE_API_KEY for the CLI/Action; the dashboard is gated by Vercel Deployment Protection.

flowchart LR
  Dev[Developer] -->|languine| CLI
  GHA[GitHub Action] -->|x-api-key| Web
  CLI -->|x-api-key| Web[apps/web on Vercel]
  Web --> Workflows[Vercel Workflows]
  Workflows --> Gateway[Vercel AI Gateway]
  Gateway --> Models[OpenAI / Anthropic / ...]
  Web --> DB[(Postgres)]
  Workflows --> DB
  Owner[Owner browser] -->|Deployment Protection| Web

Local development

git clone https://github.com/languine-ai/languine
cd languine
bun install
cp apps/web/.env.example apps/web/.env  # fill in DATABASE_URL etc.
bun dev

Set AI_GATEWAY_API_KEY in apps/web/.env so the Gateway can authenticate when not running on Vercel.

Tests

bun test                         # everything
bun test --filter @languine/web  # just the web app
bun test --filter languine       # just the CLI

License

Frequently asked questions

Is Languine free to use?

Languine is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does Languine do?

Automated localization for modern development teams

What is Languine written in?

Languine is primarily written in TypeScript. Its source is publicly available at https://github.com/languine-ai/languine, and it has 2,035 GitHub stars.