Fluent

Project Fluent is a localization paradigm designed to unleash the expressive power of natural language translations.

Background

Software localization has been dominated by an outdated paradigm: the translation is just a dictionary of strings which map one-to-one to the English (en-US) copy. This paradigm is unfair and limiting to languages with grammars more complex than English. For any grammatical feature not supported by English, a special case must be added to the source code, leaking logic into all translations. Furthermore, creating good UIs which depend on multiple external arguments is hard and requires the developer to understand the grammar of the languages the product targets.

Goals

• Design a DSL for creating expressive translations which can depend on many internal and external arguments.
• Design a low-level API for parsing and formatting translations which keeps localizations isolated from each other.
• Create a reference implementation which can be used to build localization frameworks.

Non-Goals

• Create a new localization framework.
• Solve IO for all platforms.

Design Philosophy

Localization is an essential part of the user's experience. The localizers should have control over the translation and be able to adapt it easily to the circumstances and external arguments.

Simple things are simple and complex things are possible. The syntax used for describing translations is easy to read and understand. At the same time it allows, when necessary, to represent complex concepts from natural languages like gender, plurals, conjugations, and others.

Each language is isolated and the localization logic of one language doesn't leak into other other languages nor into the source code.

Translations are objects with values and additional data which can be mapped to attributes of UI widgets and components.

The project builds on top of established resources like Unicode, ICU and CLDR.

Project Pillars

The intended outcome of Project Fluent is a syntax for describing translation resources and a low-level API for formatting translations into strings.

• Syntax specification
• Requirements and good practices for API implementations
• A reference implementation in JavaScript
• Implementation in Python
• Implementation in Rust

Relation to L20n

Project Fluent is a spin-off from L20n, a localization framework developed by Mozilla. It only consists of the low-level internals of L20n. By releasing the foundation of L20n as a separate project we hope to enable more organizations to use it. Project Fluent implementations aim to be: atomic, synchronous and pure (no IO).

L20n (and L20n.js specifically) is a bundled deal. If you buy into it, there are many things that change: the localization happens on the client side and is async, it is bound to DOM and uses a new file format; the way you make your app localizable is different too. If you’re developing a web application, you likely already have some way of working with the DOM and you’re using an opinionated framework to stay sane. L20n adds a layer on top with its own opinions and paradigms.

By decoupling Project Fluent from the rest of L20n’s bundled deal, it will become easier for external parties to adopt it. And we don’t even have to actively try to convince them. We’ve already seen interest from Java, C# and Rust developers. We also know that ICU is interested in revising MessageFormat. With FTL, we can tap into this interest without bringing the entire DOM and async API baggage along.