Tolgee

Tolgee is an open-source localization platform that eliminates the manual copy-paste cycle between code files and translation spreadsheets. Its standout feature is in-context editing: developers integrate the Tolgee SDK into their app, and translators can then hold ALT/Option and click any visible string to edit it in place—whether in local development or in production via the Chrome extension. Changes propagate back to the platform without touching source files or requiring a new deployment.

The platform integrates machine translation from DeepL, Google Translate, and AWS Translate, combined with a translation memory engine that suggests previously approved translations based on string similarity. An auto-translation feature applies these suggestions automatically when new keys are created, dramatically reducing the manual workload for large projects. Activity logs, per-translation commenting, and full translation history provide the audit trail teams need for quality control.

For developer workflows, Tolgee exposes a REST API, a CLI tool for import/export operations in CI/CD pipelines, a Figma plugin for syncing design copy, and an MCP server that lets AI coding assistants like GitHub Copilot and Cursor query and manage translations directly from the IDE. The platform is self-hostable via Docker or Kubernetes, and a managed cloud version is available at app.tolgee.io.

The backend is written in Kotlin with Spring Boot, the frontend in React with MUI and Vite, and the codebase is split into an Apache 2.0-licensed core and a proprietary EE layer covering enterprise features such as SSO, webhooks, and advanced billing. Over 870 releases since launch and a release cadence of multiple times per week reflect an extremely active project.

What You Get

• In-context translation - Hold ALT/Option and click any string in your running app to edit it inline; changes sync to the platform instantly without modifying source files.
• Production in-context editing - Use the Tolgee Chrome extension with an API key to translate live production apps without requiring developer access or a new deployment.
• AI machine translation - Automatically translate new strings using DeepL, Google Translate, or AWS Translate, with context-aware suggestions served inside the translation editor.
• Translation memory - Get ranked suggestions from previously approved translations based on similarity percentage, key name, and original text to enforce consistency across projects.
• Auto-translation - Configure new keys to be translated immediately upon creation using translation memory or a chosen machine translation provider, eliminating manual queuing.
• MCP server integration - Let AI coding assistants search, create, update, and trigger machine translation on keys without leaving the editor, via the Model Context Protocol.
• Figma plugin - Import text directly from Figma design files into Tolgee projects to keep UI copy in sync between design and engineering.
• CLI and REST API - Automate import and export of translation files in CI/CD pipelines using the Tolgee CLI or interact programmatically through the REST API.
• Translation history and comments - Track every change to a translation key, see who edited it, and leave inline feedback for translators to act on.
• Activity log - View a full audit trail of modifications, reviews, and comments across your entire localization project for accountability and debugging.

Common Use Cases

• Multi-language SaaS product management - A product team deploys Tolgee so non-technical stakeholders can update UI copy in production using the Chrome extension, removing developer bottlenecks from the localization cycle.
• React or Vue app localization with AI - A developer integrates the Tolgee JS SDK, enables auto-translation with DeepL, and lets the platform translate new keys automatically as the product ships new features.
• Client-facing platform with self-service translation - A freelance developer self-hosts Tolgee and gives clients access to update button labels, banners, and error messages independently without code changes.
• CI/CD-integrated translation pipeline - A DevOps team runs the Tolgee CLI as a build step to sync translation files, trigger machine translation on new strings, and export locale bundles for deployment.
• AI-assisted translation from the IDE - A developer uses the Tolgee MCP server so their AI coding assistant can look up existing translation keys, add new ones, and fire machine translation without switching to a browser.
• Design-to-code localization workflow - A frontend engineer uses the Figma plugin to pull approved copy from design mockups directly into Tolgee, eliminating manual string transcription between design handoff and implementation.

Under The Hood

Architecture Tolgee is structured as a Gradle monorepo with well-defined subprojects for the API, application, data layer, testing utilities, security, and EE extensions, each with explicit dependency boundaries enforced at the build level. The backend follows a classic layered architecture via Spring Boot: HTTP handling, service business logic, and JPA data access are cleanly separated, with Liquibase managing schema migrations. The OSS/EE split is a first-class architectural concern: enterprise features live under the ee/ directory and the webapp/src/ee path, loaded conditionally at runtime, allowing the community to audit and extend the core platform without touching proprietary code. Frontend and backend are independently deployable units that share a semantic release pipeline.

Tech Stack The backend is written in Kotlin with Spring Boot 3 running on Java 21, using JPA and Hibernate for ORM, PostgreSQL as the primary database, and Liquibase for schema version control. A dedicated Spring Batch module handles background jobs such as bulk translation operations. The frontend is a React 18 single-page application using MUI component library, React Query for server state, Zustand for client state, React Router for navigation, and Vite as the build tool with extensive Rollup configuration for OSS/EE code splitting. The platform ships via Docker with a compose stack bundling PostgreSQL and an optional SMTP relay, and supports Kubernetes for production deployments. WebSocket support handles real-time in-context editing events. ktlint and EditorConfig enforce consistent Kotlin formatting while Prettier handles TypeScript.

Code Quality The backend testing story is comprehensive: over 500 Kotlin test files span unit, integration, context-recreating, security, and WebSocket scenarios, organized through a dedicated testing subproject that provides base classes, custom assertions, and reusable fixtures. A sharded CI matrix runs multiple parallel Gradle test commands on each push, including separate EE test suites and ktlint enforcement. The frontend has 154 Cypress end-to-end specs covering key user flows from administration to branching and glossary management. Frontend unit test coverage is limited relative to the backend. Error handling is explicit through typed exceptions and a centralized Spring exception handler. The codebase uses TypeScript in strict mode on the frontend and Kotlin’s type system on the backend, with descriptive naming and DTOs enforcing immutable data contracts across API boundaries.

What Makes It Unique The in-context editing SDK is the platform’s defining technical innovation: rather than being a translation management UI that imports and exports files, Tolgee embeds itself directly into the running application through a lightweight JavaScript SDK. This means the translation interface is overlaid on the actual production UI, giving translators pixel-accurate context that no file-based system can replicate. The MCP server integration is a forward-looking addition that positions Tolgee as a translation backend that AI development tools can natively interact with, turning translation management into a first-class part of the AI-assisted development loop. The clean OSS core plus EE commercial layer—enforced by directory structure rather than runtime feature flags alone—lets self-hosters audit exactly what they are running, which builds trust that proprietary platforms cannot match.

Self-Hosting

Tolgee uses a dual-license model. The core platform—everything outside the ee/ directory—is released under the Apache License 2.0, a permissive open-source license that allows commercial use, modification, distribution, and sublicensing with no copyleft obligations. The ee/ directory and webapp/src/ee are covered by the Tolgee EE License v1, which restricts use to non-commercial purposes and explicitly prohibits offering the EE features as a hosted or managed service to third parties. In practice, this means a company can freely self-host and use the full platform internally, but cannot resell it as a service.

Running Tolgee yourself requires Docker and a PostgreSQL database, both of which the provided compose file handles out of the box for small teams. At scale you will need to provision your own Postgres instance with appropriate connection pooling, configure persistent file storage (the platform supports local disk or S3-compatible object stores), and manage rolling upgrades—Liquibase automates schema migrations, but you are responsible for applying them and verifying compatibility. The platform is actively developed with multiple releases per week, so keeping a self-hosted instance current requires a disciplined upgrade discipline or acceptance of running behind head.

The managed cloud at app.tolgee.io adds hosted infrastructure, automated backups, support SLAs, and access to all EE features including SSO (SAML/OIDC), advanced webhooks, billing management, and seat-based subscription enforcement. Self-hosters get the same EE feature code but must manage their own license activation against the Tolgee licensing server. Teams choosing self-hosting trade operational control and data sovereignty for the overhead of infrastructure management, while the cloud tier trades control for reduced operational burden and guaranteed uptime.