Skip to main content

i18n-keyless vs Tolgee: keyless SDK vs open-source localization platform

· 8 min read
Arnaud Ambroselli
Founder of i18n-keyless

Tolgee is the open-source localization platform developers actually enjoy using. Click a string in your running app, translate it right there, done. It's Apache 2.0 licensed, self-hostable, and has a growing community of contributors who genuinely care about developer experience.

i18n-keyless takes a different bet: what if you didn't need to click anything at all? Write the string in your code, the AI translates it, you override the ones that matter. No keys, no platform, no workflow.

Both tools are self-hostable. Both target developer-led teams. The question is whether you want a platform to manage translations or an SDK that makes translation invisible.

TL;DR​

i18n-keylessTolgee
Product typeDeveloper SDK with AI translationOpen-source localization platform
Source of truthSource string in your codeTranslation keys in Tolgee
Translation keysNone — source string is the keyRequired — you name every key
Translation methodAI auto-translation, override-ableIn-context editing, machine translation, or human translators
In-context editingNoYes — click-to-translate in your running app
Self-hosted cost€30 lifetime licence, unlimited projectsFree (Apache 2.0), but you run the infra
Setup time~5 minutes30 min–2 hours (Tolgee server + SDK)
Best forSmall teams, MVPs, engineer-driven copyTeams who want open-source with in-context editing

Pick i18n-keyless if you want multilingual without a translation workflow. Pick Tolgee if you want an open-source platform with in-context editing and community translation.

The fundamental difference: keys vs no keys​

Tolgee still uses translation keys. Their SDK wraps the key in a component:

// Tolgee: you define a key "checkout_confirm" in the Tolgee platform
import { T } from "@tolgee/react";
<button><T keyName="checkout_confirm">Confirm payment</T></button>

The keyName is the lookup. The child text is a fallback. You still manage keys in the Tolgee platform — create them, organize them, assign them to namespaces.

i18n-keyless removes the key entirely:

import { I18nKeylessText } from "i18n-keyless-react";
<button><I18nKeylessText>Confirm payment</I18nKeylessText></button>

The source string is the key. No keyName to name, no platform to create it in. The AI translates it on first encounter, caches forever, and you override from the dashboard when it misses.

Where Tolgee genuinely wins​

We respect Tolgee. It solves a real problem well. Here's where it's better:

In-context editing​

This is Tolgee's superpower. You wrap your app in the Tolgee provider, and translators (or you) can click any string in the running app to translate it directly. The context is immediate — you see the button, the layout, the surrounding text. No guessing what checkout.confirm.cta looks like in production.

i18n-keyless has a dashboard with the source string and the translation side by side. It works, but it's not in-context. If visual context during translation is critical for your workflow, Tolgee wins here.

Fully open source​

Tolgee is Apache 2.0. You can read every line, fork it, contribute to it. The community is active and the maintainers are responsive. If open-source licensing matters to your organization — for compliance, for auditing, for the principle — Tolgee is transparent in a way a SaaS cannot be.

i18n-keyless publishes its product source code under the Elastic License 2.0 (ELv2), which is source-available but not OSI-approved open source.

Machine translation integrations​

Tolgee integrates with DeepL, Google Translate, and AWS Translate. You can pick the engine you trust and use it as a suggestion layer that translators then review. Multiple providers, configurable per project.

i18n-keyless uses AI translation (Mistral by default, configurable to OpenAI, Anthropic, Google, or any OpenAI-compatible provider on self-hosted). The translation is the default — you override, not approve.

Screenshot-based context​

Tolgee can capture screenshots of where a string appears and attach them to the translation key. Translators see the screenshot alongside the string. For distributed translation teams, this is excellent.

Where i18n-keyless wins​

Truly keyless​

Tolgee reduced friction compared to i18next, but it still has keys. You still decide what checkout_confirm means, still keep the platform and the code in sync, still deal with "who renamed that key?" in code review.

i18n-keyless has no keys to name, sync, or manage. The string in your code is the identity. New engineers read the source text directly in the JSX — no context-switching to a platform.

AI translation as the default​

In Tolgee, machine translation is a suggestion you review. In i18n-keyless, AI translation is the shipped value you override when needed. For product UI strings — buttons, labels, modals, error messages — modern AI is excellent, and the override rate is low. You save time on the 95% that are fine and spend time on the 5% that need nuance.

Simpler self-hosted setup​

Self-hosting Tolgee means running a Java application server (Spring Boot) with a PostgreSQL database, configuring SMTP for invitations, setting up an nginx reverse proxy, and keeping it updated. It's real infrastructure.

Self-hosting i18n-keyless is one Docker container:

docker run -v data:/storage -p 80:80 ghcr.io/ambroselli-io/i18n-keyless

SQLite by default (Postgres optional), no SMTP (invitations are copy-paste links), no Java runtime. A €30 lifetime licence unlocks unlimited projects. Total infrastructure cost: whatever your smallest VM costs per month.

No SDK lock-in for basic usage​

i18n-keyless SDKs exist for React, Vue, Angular, Node, Laravel, Rails, Flutter, Python, Go, Swift, and Kotlin. But the protocol is plain HTTP — any fetch call works. Tolgee's in-context editing requires their SDK wrapper; without it, you lose the feature that distinguishes Tolgee from simpler tools.

A practical decision rubric​

  1. Is in-context editing important to you?

    • Yes → Tolgee.
    • No → either works.

  2. Do you want to manage translation keys?

    • Yes (you like the control) → Tolgee.
    • No (you want to skip that) → i18n-keyless.

  3. Do you need OSI-approved open-source licensing?

    • Yes → Tolgee (Apache 2.0).
    • No → either works.

  4. What's your self-hosted budget?

    • You can run a Java app server → Tolgee (free licence).
    • You want a single Docker container for €30 → i18n-keyless.

  5. Who translates?

    • A team using in-context editing → Tolgee.
    • No one — AI does it, engineers override → i18n-keyless.

FAQ​

Is Tolgee fully open source?​

Yes. Tolgee is Apache 2.0 licensed. The platform, the SDKs, and the self-hosted edition are all open source. They also offer a cloud-hosted version with paid plans. i18n-keyless publishes its product source under ELv2 (source-available, not OSI open source).

Can i18n-keyless do in-context editing?​

Not currently. Translations are managed via the dashboard — you see the source string, the current translation, and an override field. It works, but there's no click-to-translate-in-your-running-app experience. If in-context editing is a dealbreaker, Tolgee is the better fit.

Which is cheaper to self-host?​

Depends on how you count. Tolgee's licence is free (Apache 2.0), but you run a Java app server + Postgres — expect a 2GB+ VM. i18n-keyless costs €30 once and runs on the smallest VM you can find (256MB is enough with SQLite). Over a year, the infrastructure cost difference usually exceeds €30.

Can I migrate from Tolgee?​

Yes. Export your translations from Tolgee as JSON, then use i18n-keyless's import endpoint to seed the dashboard. Your source strings stay the same — you replace <T keyName="..."> with <I18nKeylessText> and drop the keyName. The migration from i18next guide covers the same pattern.

Next steps​