Skip to content
v0.86.2latest

Write natural text. Ship type-safe translations.

The compiler extracts your messages, generates the types and splits bundles per language. Every build lists a missing translation and your CI stops it, so it never reaches your users.

Integrations
~3 KBruntime
13packages
MITlicense
i18n that feels like zero config

Why Verbaly

Four things the compiler does for you, each one running right here.

Zero config, actually

One Vite plugin. No giant init(), no Babel macros, no proprietary formats. Catalogs are plain JSON you can take anywhere.

The keys are yours

By default you never write one. Name them when you want to read them, or declare them in a module when they are a contract with something outside your app, and Verbaly checks every one against your catalog. The text never changes.

Types from your messages

The text itself declares its params, so if you forget one TypeScript stops you.

Plain HTML, first-class

No framework? Verbaly fills every data-verbaly element, updates it when the language changes and picks up new ones.

Your agent translates. You decide.

Connect the MCP server and your agent extracts the messages, translates the missing ones and checks that nothing breaks. What it writes stays marked as the machine's until you mark it as read in Studio.

Works with your agent

  • Claude Code
  • Codex
  • Cursor
  • GitHub Copilot
  • Gemini CLI
  • Windsurf
  • Zed
  • Cline

And with any MCP client. How to connect it

Same job, less machinery

An honest look against the tools you'd otherwise reach for. It shows where Verbaly wins, and where the others are fine too.

FeatureVerbalyVerbalyi18nextLinguiParaglide
Type-safe keys & paramsInferred from your textBuilt in, from a declaration fileText in code, no keys to mistypeA typed function per message
Runtime size (gzip)3.35 KB, zero deps (6.17 with DOM + urls)15.5 KB (22.1 with React)2.3 KB (4.4 with React)compiled, no shared runtime
Key maintenanceNone, auto-extractedWritten by hand, synced by its CLIExtract → compile stepBy hand
Dynamic / CMS contentReal runtime pathYesYesBest with keys known at build time
Plain HTML (no framework)DOM interpreterWith a jQuery plugin——
Missing translationsFails CI, every build lists itA CLI command, for CICI stepinlang check, in CI
Broken translationsFails CI, every build lists itCLI lint, a warning by defaultSyntax errors onlyinlang check, in CI
Catalog formatPlain JSONJSONPO, JSON or CSVinlang format, others by plugin
Coding agentsMCP server + skillSkill, hosted MCP (Locize)Skills + plugin—
Maturity & ecosystemPre-1.0: the API can still changeProven at scale, modules for everythingStable, standard PO for translatorsStable, with the inlang tools
VerbalyVerbaly
Type-safe keys & params
Inferred from your text
Runtime size (gzip)
3.35 KB, zero deps (6.17 with DOM + urls)
Key maintenance
None, auto-extracted
Dynamic / CMS content
Real runtime path
Plain HTML (no framework)
DOM interpreter
Missing translations
Fails CI, every build lists it
Broken translations
Fails CI, every build lists it
Catalog format
Plain JSON
Coding agents
MCP server + skill
Maturity & ecosystem
Pre-1.0: the API can still change
i18next
Type-safe keys & params
Built in, from a declaration file
Runtime size (gzip)
15.5 KB (22.1 with React)
Key maintenance
Written by hand, synced by its CLI
Dynamic / CMS content
Yes
Plain HTML (no framework)
With a jQuery plugin
Missing translations
A CLI command, for CI
Broken translations
CLI lint, a warning by default
Catalog format
JSON
Coding agents
Skill, hosted MCP (Locize)
Maturity & ecosystem
Proven at scale, modules for everything
Lingui
Type-safe keys & params
Text in code, no keys to mistype
Runtime size (gzip)
2.3 KB (4.4 with React)
Key maintenance
Extract → compile step
Dynamic / CMS content
Yes
Plain HTML (no framework)
—
Missing translations
CI step
Broken translations
Syntax errors only
Catalog format
PO, JSON or CSV
Coding agents
Skills + plugin
Maturity & ecosystem
Stable, standard PO for translators
Paraglide
Type-safe keys & params
A typed function per message
Runtime size (gzip)
compiled, no shared runtime
Key maintenance
By hand
Dynamic / CMS content
Best with keys known at build time
Plain HTML (no framework)
—
Missing translations
inlang check, in CI
Broken translations
inlang check, in CI
Catalog format
inlang format, others by plugin
Coding agents
—
Maturity & ecosystem
Stable, with the inlang tools

Checked against each tool's own documentation in November 2026 (i18next 27, Lingui 6, Paraglide 3). Sizes are min + gzip of what an app imports, with React left out.

From words to shipped languages

Three steps and a guardrail, and verbaly init writes your config for you. No key files written by hand: the compiler does the boring parts while you keep writing product copy.

  1. Install

    Three packages: the runtime, the plugin and the command.

     pnpm add verbaly @verbaly/vite
     pnpm add -D @verbaly/compiler
  2. Add the plugin

    Point it at the language you write in.

    vite.config.ts · verbaly.config.ts
    // vite.config.ts
    import verbaly from '@verbaly/vite';
    
    export default { plugins: [verbaly()] };
    
    // verbaly.config.ts
    export default { sourceLocale: 'es' };
  3. Write text, not keys

    Keys, types and catalogs: generated.

    src/app.ts
    import { t, setLocale } from 'verbaly/app';
    
    t`Hola ${name}`;      // keys, types & catalogs: generated
    await setLocale('pt'); // lazy-loads its chunk
  4. Let CI guard it

    Exits 1 while any language is incomplete, so untranslated text never ships.

    .github/workflows/ci.yml
    - run: npx verbaly check  # exits 1 on a missing or broken translation

Your first translated page, in five minutes.

Install, add the plugin and write text. Verbaly extracts the messages, writes the types and loads each language when someone asks for it.

Get started

Already have catalogs? Open them in Studio

Copied to clipboard