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.

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.

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 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
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ترجماتك مكانها مستودعك.