Lingo.dev

Translates static content files (JSON, YAML, CSV, PO, Markdown) by parsing them into an intermediate representation, routing translation requests through a pluggable LLM provider layer (Lingo.dev Engine, OpenAI, Anthropic, Google, Mistral, OpenRouter, Ollama), and writing localized output files with an i18n.lock manifest tracking translation state. The compiler uses AST-aware parsing per format to preserve structure and metadata during round-trip translation.

Integrates into Next.js, Vite, or webpack build pipelines via withLingo() wrapper or lingoCompilerPlugin() to intercept JSX/TSX source files, extract translatable strings, invoke LLM translation, and inject localized content into separate .lingo/ cache bundles per locale. The new compiler (@lingo.dev/compiler) uses AST transformation to rewrite component imports and string literals, enabling zero-runtime overhead for static translations while maintaining source map fidelity.

Provides React-specific bindings (in @lingo.dev/react package) including hooks (useLocale, useTranslate) and context providers that integrate Lingo.dev translations into React component trees. The React package wraps the SDK to provide idiomatic React patterns, enabling components to access current locale, trigger locale switches, and subscribe to translation updates without prop drilling.

Maintains an i18n.lock manifest file that tracks the translation state of every string (which strings have been translated, which are pending, which have changed since last translation). The lock file enables incremental translation workflows where only changed or new strings are re-translated, reducing API costs and improving CI/CD performance. Lock file is version-controlled alongside source code, providing an audit trail of translation history.

Provides a JavaScript/TypeScript SDK (npm install lingo.dev) that localizes strings, objects, and HTML at runtime by querying a locale-aware translation store with automatic fallback chains (e.g., en-US → en → default). The SDK manages locale state, caches translations in memory, and supports both synchronous lookups for pre-compiled translations and async calls for dynamic content, with built-in support for pluralization and interpolation patterns.

Command-line interface (npx lingo.dev@latest run) that recursively discovers translatable files in a project (JSON, YAML, CSV, PO, Markdown), batches them for efficient LLM processing, orchestrates the translation pipeline, and writes localized output files alongside an i18n.lock manifest. The CLI uses a configuration file (i18n.json) to define source directories, target locales, and provider settings, with support for dry-run mode and incremental translation (only translating changed files since last run).

Exposes Lingo.dev as a Model Context Protocol (MCP) server that allows AI agents and IDEs to prompt for i18n needs in natural language and receive generated routing, middleware, and configuration boilerplate. The MCP server translates high-level i18n requirements (e.g., 'support 10 languages with fallback to English') into concrete code artifacts (Next.js middleware, locale routing, provider configuration) without requiring manual setup.

GitHub Action (uses: lingodotdev/lingo.dev@main) that triggers on git push to main, automatically translates changed content files, and commits translated files back to the repository or opens a pull request with translations. The action integrates with GitHub Workflows, caches translation results to avoid redundant API calls, and supports conditional triggers (e.g., only translate if specific files changed).

Manages locale hierarchies and fallback chains (e.g., en-US → en → default) at both compile-time and runtime, allowing applications to support regional language variants without duplicating translations. The system tracks which locales are configured, validates locale codes against IANA standards, and automatically generates fallback paths for missing translations, reducing the number of unique translation strings needed.

Implements pluggable file format loaders for JSON, YAML, CSV, PO (gettext), and Markdown that parse files into an intermediate representation, extract translatable strings while preserving file structure, metadata, and formatting. Each loader uses format-specific parsing (JSON.parse, YAML parser, CSV reader, PO parser, Markdown AST) to maintain round-trip fidelity, ensuring that translations can be written back to the original format without losing structure or comments.

Organizes Lingo.dev as a pnpm + Turborepo monorepo with layered package dependencies (foundational packages like @lingo.dev/_locales and @lingo.dev/_spec have no internal dependencies, while CLI sits at the top consuming everything). Turborepo caching accelerates builds and tests by caching task outputs, while pnpm workspaces enable efficient dependency management and code sharing across CLI, SDK, compiler, React, and spec packages.

Defines a declarative i18n.json configuration file that specifies source directories, target locales, LLM provider settings, file format filters, and translation rules. The configuration schema is validated at runtime, allowing users to control the entire translation pipeline (which files to translate, which locales to target, which provider to use) without code changes. Configuration is shared across CLI, compiler, and SDK, ensuring consistency across all product surfaces.