local-first · git-native · MIT

Your translations belong in your repo.

Glotfile is a translation manager that lives in one JSON file, committed next to your code. Edit in a local web UI, translate with your own AI key, export to your framework's locale format. No platform, no account — nothing leaves your machine except the AI calls you choose to make.

npx glotfile

or view it on npm ↗

Node 20+ · runs on 127.0.0.1 · delete glotfile.json and it's like it never happened

~/your-app

$ npx glotfile

glotfile — local translation manager

✓ found glotfile.json · 142 keys · 8 locales

✓ ui on http://127.0.0.1:3000 — opened in browser

$ glotfile translate --locale fr,pl

✓ 23 strings translated · claude · 4.2s

$ git diff --stat

glotfile.json | 46 ++++++++++++++

1 file changed, 46 insertions(+)

Minutes, not days.

Batch-translate a whole locale in one command. New strings come back filled in seconds — not a vendor turnaround cycle — so the diff is ready before you've left the branch.

No minimum cost.

No per-seat fee, no monthly floor, no per-word markup. You pay your own AI provider by the token — or point it at Ollama and translate for nothing at all.

Two ways this usually goes.

STATUS QUO №1

Hand-editing locale files

Eleven JSON files that drift apart quietly. A Polish fix pasted in from an email. Nobody knows why de.json has three keys the others don't.

STATUS QUO №2

Renting a translation platform

Your strings live in someone else's database and come back as bot PRs. You pay per seat, per word, per month — for access to your own copy.

Glotfile's take: translations are code. Put them in the repo, review them in PRs, and both problems stop existing.

How it works

Start from what you have

Run it in your project. Glotfile finds your existing ARB, PHP, JSON or .po files, imports every key, and writes one deterministic glotfile.json. No config, no account.

$ npx glotfile import

✓ found lib/l10n/app_en.arb · app_de.arb

✓ imported 142 keys → glotfile.json

# one file. commit it.

The glotfile editor: one key shown across English (source), Arabic (right-to-left), German, Spanish, French, Japanese and Polish, each row tagged with its review state — reviewed, machine, or needs review.

Edit & translate in a local UI

One command starts a web UI on 127.0.0.1 — search, plurals, RTL, review states. Fill missing locales with the AI provider you already pay for. Context comes from how the string is used in your code, not a guess.

Export & commit

Write your platform's native locale files and commit everything. Output is deterministic — stable key order, fixed indent — so a translation change is a small reviewable diff, and an unchanged export is a zero-line one. Safe to run in CI.

git diff — glotfile.json

  "export.title": {
    "en": "Export formats",
+   "fr": "Formats d'export",
+   "pl": "Formaty eksportu",
+   "ja": "エクスポート形式",
  },

$ glotfile export → lib/l10n/app_fr.arb · lang/fr/app.php

The whole UI runs on localhost.

Run npx glotfile and it opens on 127.0.0.1 — dark mode, right-to-left, plurals, a “can I ship?” release gate, and an audit log of every AI call. Every panel reads and writes the one JSON file you commit.

Glotfile analytics: a ‘can I ship?’ release gate and per-locale readiness cards showing translation completion for Arabic, German, Spanish, French, Japanese and Polish. — **Analytics** — a “can I ship?” release gate and per-locale readiness at a glance.

Glotfile activity log: AI translation batches tagged with the model used, an expandable system prompt, and before-and-after diffs for each edited string. — **Activity** — every edit and AI batch, with before → after diffs and the model used.

Lingo knows your repo.

Lingo is an AI assistant built into the UI. It reads your code and your string catalogue, then helps you sharpen the things that make machine translation good — context, glossary, tags, length budgets. Press ⌘/Ctrl + J, say what you want, and it proposes the edits for you to approve. It never quietly rewrites your translations.

Lingo claude · reading your repo

The “feed” keys keep coming back wrong in German. What's going on?

Two different senses share the word. plant.feed.cta is used in PlantCareScreen.tsx — that's fertilising a plant. home.feed.title is the activity stream.

Want me to add per-key context and a glossary note so the model stops conflating them?

Approve

Yes, go ahead.

✓ context added to plant.feed.cta

✓ context added to home.feed.title

✓ glossary: “feed” → noted plant vs. social sense

Reads your codebaseGreps your source and opens files to see how a string is actually used — so its suggestions are grounded, not guessed.
Builds the context, not the translationPer-key context, glossary terms, tags and length budgets — the metadata every translation is conditioned on.
One approval, whole taskAgree once and Lingo carries out a multi-step change in a single pass, then shows you exactly what it touched.
Click through to any keyEvery key Lingo mentions is a link — jump straight to it in the editor.
Suggests, never overridesLingo won't write or review translations behind your back. The wording stays yours.

Built like a tool, not a platform.

Zero infrastructure

No server, no sync, no account. One npx command and you're editing. Nothing to host, nothing to cancel.

Git-native

One deterministic state file, committed with your code. Review translations the way you review everything else: in the PR.

Lives on your branch

New strings travel on the feature branch that introduced them — merge, rebase, and revert them alongside the code. No drift between branches, no separate platform to keep in sync.

AI translation, your provider

Anthropic, OpenAI, Bedrock, OpenRouter, Claude Code — or Ollama, fully offline. Your key, your model, your bill.

Half-price batch translation

Send a whole locale through Anthropic's Batch API at roughly half the per-token cost. Glotfile tracks the job and applies the results when it lands — kick it off and walk away.

Context & glossary, always read

Every key can carry context — a usage note, the code locations that reference it, even a screenshot — and your glossary rides along: brand names stay verbatim, fixed terms stay fixed. All of it is sent on every translation, so an ambiguous “Post” comes back as the right verb or noun.

Translations that fit

Give a key a character budget and the model is told the limit, so a translation comes back short enough for the button — German included. The max-length check then flags anything that ever drifts over.

Speaks your framework

First-class export to Flutter ARB, Laravel PHP, i18next, vue-i18n & next-intl JSON, Angular XLIFF, Rails YAML, gettext .po, and Apple .strings/.stringsdict.

Quality tooling built in

Placeholder and spelling lints, unused-key scanning against your codebase, and a CI check that fails when locales drift.

Deterministic by design

Stable key order, fixed indent, one trailing newline. Re-export with no changes and git sees nothing at all.

EXPORTS TO

Flutter ARB
Laravel PHP
i18next JSON
vue-i18n JSON
next-intl JSON
Angular XLIFF
Rails YAML
gettext .po
Apple .strings/.stringsdict

TRANSLATES WITH

Anthropic
OpenAI
AWS Bedrock
OpenRouter
Ollama (local)
Claude Code

Local-first means local.

The server binds to 127.0.0.1 and nowhere else. Your strings travel exactly two places: your git remote, and the AI provider you configure — point it at Ollama and it's just git.

No telemetry, no account, no copy of your strings on anyone else's disk. Your git history is the audit log.

enYour translations belong in your repo.

frVos traductions appartiennent à votre dépôt.

deDeine Übersetzungen gehören in dein Repo.

plTwoje tłumaczenia należą do twojego repo.

ja翻訳はあなたのリポジトリに。

arترجماتك مكانها مستودعك.