{"id":8597,"date":"2026-11-02T06:00:00","date_gmt":"2026-11-02T06:00:00","guid":{"rendered":"https:\/\/poeditor.com\/blog\/?p=8597"},"modified":"2026-10-30T07:22:49","modified_gmt":"2026-10-30T07:22:49","slug":"rails-i18n","status":"publish","type":"post","link":"https:\/\/poeditor.com\/blog\/rails-i18n\/","title":{"rendered":"Rails i18n: How to translate a Ruby on Rails app with YAML locale files"},"content":{"rendered":"\n
\"\"<\/figure>\n\n\n\n

Ruby on Rails is a web framework for Ruby that follows the principle of convention over configuration. A new application comes with its database layer, routing, views and asset handling already set up, so there\u2019s less to configure before you can start building.<\/p>\n\n\n\n

As soon as an app serves people in more than one country, they expect to read it in their own language, with dates and numbers written the way they\u2019re used to. Internationalization (i18n) is the work that makes the code ready for that, and localization (l10n) supplies the translations and formats for each language.<\/p>\n\n\n\n

In this guide, we\u2019ll translate a Rails TO-DO app into French using Rails\u2019 built-in I18n API, YAML locale files, the rails-i18n gem and POEditor, while keeping English as the default language.<\/p>\n\n\n\n

What Rails I18n already does<\/h2>\n\n\n\n

The TO-DO app runs on Rails 8.1 and Ruby 4.0, with a SQLite database. You register with a username and password, create lists, add tasks, mark them as done and filter a list by open or completed tasks. Labels, buttons and flash messages are hardcoded in English in the ERB views and controllers. Counts use Rails\u2019 pluralize<\/code> helper or custom singular and plural conditions, and dates are formatted with strftime<\/code> in the US style.<\/p>\n\n\n\n

\"\"
The lists page before translation<\/em><\/figcaption><\/figure>\n\n\n\n

To follow along you need Ruby 4.0.9, the version the Gemfile<\/code> asks for. Run bundle install<\/code> and bin\/rails db:prepare<\/code>, which creates the database along with a demo<\/code> account whose password is demo1234<\/code>, then start the app with bin\/rails server and open the address it prints.<\/p>\n\n\n\n

Rails ships with the i18n gem<\/a> and reads its translations from every .yml<\/code> and .rb<\/code> file under config\/locales<\/code>, subfolders included. Some of the TO-DO app\u2019s text is already translated through Rails\u2019 built-in locale files: validation messages such as \u201cName can\u2019t be blank\u201d come from Rails\u2019 English translations. Rails\u2019 English locale files also hold the month and day names that the l<\/code> helper uses for dates, which the app switches to later. Rails only ships this data in English, so for French you add the rails-i18n<\/a> gem, which supplies French validation messages, month names, number formats and the French plural rule.<\/p>\n\n\n\n

Add the gem to the Gemfile and run bundle install<\/code>:<\/p>\n\n\n\n

# Gemfile\ngem \"rails-i18n\", \"8.1.0\"<\/code><\/pre>\n\n\n\n
Then tell Rails which languages the app supports and which one it uses by default:<\/p>\n\n\n\n
# config\/application.rb\nmodule TodoApp\n  class Application < Rails::Application\n    # ...\n\n    # The languages the app is translated into; English is the default.\n    config.i18n.available_locales = [ :en, :fr ]\n    config.i18n.default_locale = :en\n  end\nend<\/code><\/pre>\n\n\n\n
available_locales<\/code> also limits what rails-i18n loads. The gem contains data for over a hundred locales, but with this setting it only adds English and French to the app. Restart bin\/rails server<\/code> after these two changes, because Rails doesn\u2019t reload the Gemfile or config\/application.rb<\/code> while it runs.<\/p>\n\n\n\n
Moving view text into en.yml<\/h2>\n\n\n\n
A Rails translation is stored under a key in a YAML file and retrieved with the t helper. You can write the full key, as in t(\"lists.index.title\")<\/code>, but views usually use the shorter form with a leading dot, known as lazy lookup. In app\/views\/lists\/index.html.erb, t(\".title\")<\/code> looks up lists.index.title<\/code>, because the key is built from the template\u2019s folder and file name. Partials drop the underscore, so t(\".tasks_left\")<\/code> in lists\/_list.html.erb<\/code> reads lists.list.tasks_left<\/code>, and the layout\u2019s strings live under layouts.application<\/code>.<\/p>\n\n\n\n
Here is the lists page with its strings replaced:<\/p>\n\n\n\n
<%# app\/views\/lists\/index.html.erb %>\n<% content_for :title<\/em><\/strong>, t(\".title\") %>\n\n<div<\/strong> class<\/strong>=\"card shadow-sm mb-4\"><\/strong>\n  <div<\/strong> class<\/strong>=\"card-body\"><\/strong>\n    <%= form_with model: @new_list, url: lists_path, id: \"new-list-form\", class<\/strong>: \"row g-2 align-items-start\" do<\/strong> |form| %>\n      <div<\/strong> class<\/strong>=\"col-12 col-sm\"><\/strong>\n        <%= form.label :name<\/em><\/strong>, t(\".new_list\"), class<\/strong>: \"form-label\" %>\n        <%= form.text_field :name<\/em><\/strong>, placeholder: t(\".placeholder\"),\n              class<\/strong>: class_names(\"form-control\", \"is-invalid\": @new_list.errors.include?(:name<\/em><\/strong>)) %>\n        <%= field_errors @new_list, :name<\/em><\/strong> %>\n      <\/div><\/strong>\n      <div<\/strong> class<\/strong>=\"col-12 col-sm-auto align-self-sm-end\"><\/strong>\n        <%= form.submit t(\".create\"), class<\/strong>: \"btn btn-primary w-100\" %>\n      <\/div><\/strong>\n    <% end<\/strong> %>\n  <\/div><\/strong>\n<\/div><\/strong>\n\n<% if<\/strong> @lists.empty? %>\n  <p<\/strong> class<\/strong>=\"text-body-secondary\"><\/strong><%= t(\".empty\") %><\/p><\/strong>\n<% else<\/strong> %>\n  <p<\/strong> class<\/strong>=\"text-body-secondary\"><\/strong><%= t(\".count\", count: @lists.size) %><\/p><\/strong>\n  ...\n<% end<\/strong> %><\/code><\/pre>\n\n\n\n
rails new<\/code> creates config\/locales\/en.yml<\/code> with a single hello<\/code> key. Replace it with the app\u2019s own strings, nested by folder, template and key:<\/p>\n\n\n\n
# config\/locales\/en.yml<\/em>\nen:<\/strong>\n  layouts:<\/strong>\n    application:<\/strong>\n      menu:<\/strong> \"Menu\"\n      signed_in_as_html:<\/strong> \"Signed in as <strong>%{username}<\/strong>\"\n      log_out:<\/strong> \"Log out\"\n      log_in:<\/strong> \"Log in\"\n      register:<\/strong> \"Register\"\n  lists:<\/strong>\n    index:<\/strong>\n      title:<\/strong> \"Your lists\"\n      new_list:<\/strong> \"New list\"\n      placeholder:<\/strong> \"Groceries\"\n      create:<\/strong> \"Create list\"\n      empty:<\/strong> \"You don't have any lists yet. Create your first one above.\"<\/code><\/pre>\n\n\n\n
Values that change at runtime go in as %{name}<\/code> placeholders and are passed to t as options, for example t(\".signed_in_as_html\", username: current_user.username)<\/code> in the navbar. A key that ends in _html<\/code> is marked as safe HTML, so the <strong> tag<\/code> reaches the page as markup, while Rails still escapes the username you pass in. Without the suffix, the tag would be escaped and shown as text.<\/p>\n\n\n\n
Because every string has its own key, the same English word can be translated differently in different places. The TO-DO app shows \u201cDone\u201d both as a filter tab above the tasks and as a badge on each completed task. In French, the tab refers to several tasks and the badge to one, so lists.show.filters.done<\/code> becomes Termin\u00e9es<\/code> and tasks.task.done<\/code> becomes Termin\u00e9e<\/code>.<\/p>\n\n\n\n
Translating flash messages and model attributes<\/h2>\n\n\n\n
Lazy lookup also works in controllers, where the key is built from the controller and the action. t(\".created\")<\/code> in ListsController#create<\/code> reads lists.create.created<\/code>:<\/p>\n\n\n\n
# app\/controllers\/lists_controller.rb<\/em>\ndef<\/strong> create\n  @new_list = current_user.lists.new(list_params)\n\n  if<\/strong> @new_list.save\n    redirect_to @new_list, notice:<\/em><\/strong> t(\".created\", name:<\/em><\/strong> @new_list.name)\n  else<\/strong>\n    load_lists\n    render :index<\/em><\/strong>, status:<\/em><\/strong> :unprocessable_content<\/em><\/strong>\n  end<\/strong>\nend<\/strong><\/code><\/pre>\n\n\n\n
The original app built some of these messages by joining strings, as in \"Task \\\"\" + @task.text + \"\\\" marked as done.\"<\/code>. A translator can\u2019t change the word order when a sentence is split across three pieces of code, so put each message in a single string with a placeholder:<\/p>\n\n\n\n
# app\/controllers\/tasks_controller.rb\ndef toggle\n  @task.mark_done!(params.expect(:done) == \"1\")\n\n  message = @task.done? ? t(\".done\", text: @task.text) : t(\".open\", text: @task.text)\n  redirect_to list_path(@list, show: filter_param), notice: message\nend\n\n# config\/locales\/en.yml\n  tasks:\n    toggle:\n      done: \"Task \\\"%{text}\\\" marked as done.\"\n      open: \"Task \\\"%{text}\\\" marked as open.\"<\/code><\/pre>\n\n\n\n
Validation messages need a different kind of key. Rails builds \u201cText can\u2019t be blank\u201d from the attribute\u2019s name and a message, and it looks for the name under activerecord.attributes<\/code> before falling back to a humanized column name. The tasks.text <\/code>column, for instance, reads better as \u201cTask\u201d:<\/p>\n\n\n\n
# config\/locales\/en.yml<\/em>\n  activerecord:<\/strong>\n    attributes:<\/strong>\n      list:<\/strong>\n        name:<\/strong> \"Name\"\n      task:<\/strong>\n        text:<\/strong> \"Task\"\n      user:<\/strong>\n        username:<\/strong> \"Username\"\n        password:<\/strong> \"Password\"\n        password_confirmation:<\/strong> \"Password confirmation\"<\/code><\/pre>\n\n\n\n
The same names label the username and password fields of the registration form, because form.label :username<\/code> without any text of its own looks up the model\u2019s attribute name. You don\u2019t translate the messages themselves: once the page is in French, rails-i18n supplies doit \u00eatre rempli(e)<\/code>, and with Texte de la t\u00e2che<\/code> as the French name of task.text<\/code>, an empty task shows \u201cTexte de la t\u00e2che doit \u00eatre rempli(e)\u201d.<\/p>\n\n\n\n
rails-i18n doesn\u2019t cover every message Rails has, though. has_secure_password<\/code> rejects a password longer than 72 bytes with the message errors.messages.password_too_long<\/code>, and rails-i18n 8.1.0 has no French translation for it, so in development a French page shows \u201cTranslation missing\u201d there, and in production the English message. Copy the English message into en.yml<\/code>, and it goes to POEditor with the rest of the strings:<\/p>\n\n\n\n
# config\/locales\/en.yml<\/em>\n  # Rails' own message for a password over 72 bytes, which rails-i18n has no French version of yet.<\/em>\n  errors:<\/strong>\n    messages:<\/strong>\n      password_too_long:<\/strong> \"is too long\"<\/code><\/pre>\n\n\n\n
Plurals with the count option<\/h2>\n\n\n\n
The original app counted tasks with pluralize(list.open_count, \"task\")<\/code>, which builds the plural word from Rails\u2019 English inflection rules. In a translated app, pass the number to t<\/code> as the count<\/code> option and add an entry for each plural form under the existing lists<\/code> key in en.yml<\/code>:<\/p>\n\n\n\n
<%# app\/views\/lists\/_list.html.erb %>\n<p class=\"card-text mb-2\">\n  <%= t(\".tasks_left\", count: list.open_count) %>\n  <span class=\"text-body-secondary\">\n    &middot;\n    <%= t(\".tasks_total\", count: list.total_count) %>\n  <\/span>\n<\/p>\n\n# config\/locales\/en.yml\n  lists:\n    list:\n      tasks_left:\n        one: \"%{count} task left\"\n        other: \"%{count} tasks left\"\n      tasks_total:\n        one: \"%{count} task in total\"\n        other: \"%{count} tasks in total\"<\/code><\/pre>\n\n\n\n
count<\/code> both chooses the form and fills in %{count}<\/code>. Which form it chooses depends on the language\u2019s plural rule. Rails on its own applies the English rule to every language, one for exactly 1 and other<\/code> for everything else, but French uses the singular for 0 as well, and rails-i18n adds that rule. With rails-i18n installed, a finished list reads \u201c0 t\u00e2che restante\u201d instead of \u201c0 t\u00e2ches restantes\u201d. The \u201cYou have 3 lists.\u201d line on the lists page works the same way, with one and other entries under lists.index.count.<\/p>\n\n\n\n
The list page has a sentence under its filter tabs that changes with both the filter and the number of tasks, \u201cShowing 5 completed tasks.\u201d for example. The original app picked it with a case<\/code> statement and a singular or plural branch for each filter. Now each filter has a plural key, and the view builds the key name from the current filter:<\/p>\n\n\n\n
<%# app\/views\/lists\/show.html.erb %>\n<p class=\"text-body-secondary small mb-3\"><%= t(\".showing.#{@filter}\", count: @tasks.size) %><\/p><\/code><\/pre>\n\n\n\n
Dates, times and percentages<\/h2>\n\n\n\n
The l<\/code> helper formats a date or time with a named format from the locale files, and it fills in month and day names in the current language. A list card shows the day the list was created, and each task shows when it was added:<\/p>\n\n\n\n
<%# app\/views\/lists\/_list.html.erb %>\n<%= t(\".created_on\", date: l(list.created_at.to_date, format: :long<\/em><\/strong>)) %>\n\n<%# app\/views\/tasks\/_task.html.erb %>\n<%= t(\".added_on\", time: l(task.created_at, format: :short<\/em><\/strong>)) %><\/code><\/pre>\n\n\n\n
A Date<\/code> uses the formats under date.formats, while a Time<\/code> uses time.formats<\/code>, which is why the list card converts created_at<\/code> with to_date<\/code>. Rails\u2019 own English long<\/code> date format is %B %d, %Y<\/code>, which pads the day to \u201cOctober 09, 2026\u201d, and its time formats use a 24-hour clock. To keep the app\u2019s original output, override the formats in en.yml<\/code>. The app\u2019s locale files load after the ones in Rails and rails-i18n, so the same key replaces theirs:<\/p>\n\n\n\n
# config\/locales\/en.yml<\/em>\n  date:<\/strong>\n    formats:<\/strong>\n      # October 9, 2026 (strftime: %B month name, %-d day, %Y year)<\/em>\n      long:<\/strong> \"%B %-d, %Y\"\n\n  time:<\/strong>\n    formats:<\/strong>\n      # October 9, 2026 at 8:12 AM (strftime: %-I hour on a 12-hour clock, %M minutes, %p AM or PM)<\/em>\n      long:<\/strong> \"%B %-d, %Y at %-I:%M %p\"\n      # 10\/09\/2026 at 4:22 PM (strftime: %m month, %d day, %Y year)<\/em>\n      short:<\/strong> \"%m\/%d\/%Y at %-I:%M %p\"<\/code><\/pre>\n\n\n\n
These formats are stored in en.yml like any other translation, so they can be translated along with the rest of the file. In French, the format is %-d %B %Y<\/code>, with the day before the month. The comments explain the strftime<\/code> codes to whoever translates them, and they travel with the file into POEditor. %B<\/code> becomes octobre<\/code> in French because l<\/code> takes the month names from rails-i18n.<\/p>\n\n\n\n
The progress text under each list, \u201c83% done\u201d, comes from a translation with a %{percent}<\/code> placeholder, so the translator decides where the number and the percent sign go. French typography puts a space before the percent sign, which makes the French translation %{percent} % termin\u00e9<\/code>.<\/p>\n\n\n\n
Setting the locale from the URL<\/h2>\n\n\n\n
Rails keeps the current language in I18n.locale<\/code>, and the app has to set it at the start of every request. The Rails guides recommend putting the locale in the URL, so each page has a language-specific address and shared links open in the same language for everyone. Wrap the routes in an optional locale<\/code> segment:<\/p>\n\n\n\n
# config\/routes.rb<\/em>\nRails.application.routes.draw do<\/strong>\n  # English pages have no prefix (\/lists\/1), French ones start with \/fr (\/fr\/lists\/1).<\/em>\n  scope \"(:locale)\", locale:<\/em><\/strong> \/en|fr\/ do<\/strong>\n    root \"lists#index\"\n\n    resource :registration<\/em><\/strong>, only:<\/em><\/strong> %i[<\/strong>new create]<\/strong>\n    resource :session<\/em><\/strong>, only:<\/em><\/strong> %i[<\/strong>new create destroy]<\/strong>\n\n    resources :lists<\/em><\/strong>, only:<\/em><\/strong> %i[<\/strong>index show create update destroy]<\/strong> do<\/strong>\n      resources :tasks<\/em><\/strong>, only:<\/em><\/strong> %i[<\/strong>create update destroy]<\/strong> do<\/strong>\n        patch :toggle<\/em><\/strong>, on:<\/em><\/strong> :member<\/em><\/strong>\n      end<\/strong>\n    end<\/strong>\n  end<\/strong>\n\n  get \"up\" => \"rails\/health#show\", as:<\/em><\/strong> :rails_health_check<\/em><\/strong>\nend<\/strong><\/code><\/pre>\n\n\n\n
Then set the locale in ApplicationController <\/code>with an around_action<\/code>, which switches the language for the rest of the request and restores the previous one afterwards:<\/p>\n\n\n\n
# app\/controllers\/application_controller.rb<\/em>\nclass<\/strong> ApplicationController < ActionController::Base\n  allow_browser versions:<\/em><\/strong> :modern<\/em><\/strong>\n  # ...<\/em>\n\n  # Runs before require_login, so everything after it, including require_login's redirect, uses the request's language.<\/em>\n  around_action :switch_locale<\/em><\/strong>\n  before_action :require_login<\/em><\/strong>\n\n  helper_method :current_user<\/em><\/strong>\n\n  private\n\n  # The language comes from the locale in the URL; a missing or unsupported one means English.<\/em>\n  def<\/strong> switch_locale(&action)\n    locale = params[:locale<\/em>]<\/strong> if<\/strong> I18n.locale_available?(params[:locale<\/em>]<\/strong>)\n    I18n.with_locale(locale || I18n.default_locale, &action)\n  end<\/strong>\n\n  # Keeps the \/fr prefix on every link and redirect the app generates.<\/em>\n  def<\/strong> default_url_options\n    { locale:<\/em><\/strong> (I18n.locale unless<\/strong> I18n.locale == I18n.default_locale) }\n  end<\/strong>\n\n  # ...<\/em>\nend<\/strong><\/code><\/pre>\n\n\n\n
The route constraint only accepts en<\/code> and fr<\/code> in the path, but params[:locale] can also come from the query string, and by default I18n.with_locale<\/code> raises I18n::InvalidLocale<\/code> for a language that isn\u2019t in available_locales. The locale_available?<\/code> check turns an address like \/?locale=de<\/code> into a normal English page instead of an error. default_url_options<\/code> adds the locale to every URL helper, so once a visitor is on a French page, list_path(list) <\/code>returns \/fr\/lists\/1<\/code> and they stay in French. Returning nil<\/code> for English keeps the English URLs without a prefix.<\/p>\n\n\n\n
The language switcher in the navbar links to the current page in each language. Each language name is written in that language, so the names aren\u2019t translated. The partial\u2019s only translated string is its aria-label<\/code>, which goes under the layouts: key<\/code> in en.yml<\/code>:<\/p>\n\n\n\n
<%# app\/views\/layouts\/_language_switcher.html.erb %>\n<nav class=\"btn-group btn-group-sm\" aria-label=\"<%= t(\".label\") %>\">\n  <% { en: \"English\", fr: \"Fran\u00e7ais\" }.each do |locale, name| %>\n    <%= link_to name, switch_locale_path(locale), lang: locale, hreflang: locale,\n          class: class_names(\"btn\", locale == I18n.locale ? \"btn-secondary\" : \"btn-outline-secondary\"),\n          aria: { current: (\"true\" if locale == I18n.locale) } %>\n  <% end %>\n<\/nav>\n\n# config\/locales\/en.yml\n  layouts:\n    language_switcher:\n      label: \"Language\"<\/code><\/pre>\n\n\n\n
The links come from a helper. On an ordinary page, url_for(locale: locale)<\/code> rebuilds the current URL with the other locale, and the list page\u2019s task filter is passed along so it survives the switch. When a form fails validation, Rails renders the page in response to the POST, and a link can\u2019t repeat a POST, so the helper links to the page that holds the form instead:<\/p>\n\n\n\n
# app\/helpers\/application_helper.rb<\/em>\n# The current page in another language, with the same task filter. A page<\/em>\n# shown after a form failed is the answer to a POST, which a link can't<\/em>\n# repeat, so it links to the page that holds the form instead.<\/em>\ndef<\/strong> switch_locale_path(locale)\n  locale = nil if<\/strong> locale == I18n.default_locale\n\n  if<\/strong> request.get?\n    url_for(locale:<\/em><\/strong> locale, show:<\/em><\/strong> @show)\n  elsif<\/strong> @list\n    list_path(@list, locale:<\/em><\/strong> locale, show:<\/em><\/strong> @show)\n  elsif<\/strong> current_user\n    root_path(locale:<\/em><\/strong> locale)\n  else<\/strong>\n    url_for(action:<\/em><\/strong> :new<\/em><\/strong>, locale:<\/em><\/strong> locale)\n  end<\/strong>\nend<\/strong><\/code><\/pre>\n\n\n\n
In the layout, render the switcher in the navbar with <%= render \"layouts\/language_switcher\" %><\/code>, and change <html lang=\"en\"> to <html lang=\"<%= I18n.locale %>\"><\/code>, so browsers and screen readers know which language the page is in.<\/p>\n\n\n\n
Before French has any translations, \/fr<\/code> shows each missing string in a view as the last part of its key, title-cased, such as \u201cTitle\u201d for lists.index.title<\/code>, inside a span with a translation_missing<\/code> class and a title naming the key it looked for. In a submit button\u2019s label, a placeholder or the browser tab\u2019s title, that markup appears as text, and where a view writes t<\/code> straight into an HTML attribute, such as the switcher\u2019s aria-label<\/code>, it ends the attribute early, so fragments like Label\"><\/code> show up on the page. This happens in development. In production, a missing French key shows the English text instead, because the production.rb<\/code> that rails new generates sets config.i18n.fallbacks = true<\/code>.<\/p>\n\n\n\n
Translating en.yml in POEditor<\/h2>\n\n\n\n
In POEditor, create a project for the app from the +<\/strong> button on the Dashboard<\/strong> and name it TO-DO app (Rails). Add English and French as its languages.<\/p>\n\n\n\n
\"\"
The project\u2019s languages, before any import<\/em><\/figcaption><\/figure>\n\n\n\n
Open Import<\/strong> and choose config\/locales\/en.yml<\/code> on the Import Terms<\/strong> page. On a project\u2019s first import, Also import translations to a language<\/strong> is already switched on, so leave it on and choose English from the list under it. POEditor recognizes YAML from the .yml<\/code> extension, and Import to project<\/strong> starts the import.<\/p>\n\n\n\n
\"\"
Importing<\/em> en.yml, with its values going into English<\/em><\/figcaption><\/figure>\n\n\n\n
POEditor drops the en:<\/code> root, turns each last key into a term and the path above it into the term\u2019s context, so lists.index.title<\/code> arrives as the term title<\/code> with the context \"lists\".\"index\"<\/code>. Plural keys, the ones whose children are one<\/code> and other<\/code>, become a single plural term each, and a comment above a key, such as the ones above the date formats, becomes that term\u2019s comment. A comment above a parent key, such as the one above errors<\/code>:, doesn\u2019t appear on any term, but POEditor keeps it and writes it back into the YAML export. <\/p>\n\n\n\n
The TO-DO app\u2019s en.yml<\/code> gives 82 terms, with English at 100%. Since the terms are keys, translators need to see the English text alongside them. The import doesn\u2019t set this automatically. Go back to the project page, click the gear icon to open the project settings, click Edit Details<\/strong>, set DEFAULT REFERENCE LANGUAGE<\/strong> to English and click Save project details<\/strong>.<\/p>\n\n\n\n
Now open French and translate. Each row shows the English text, with the key and its context in smaller type below it. Keep placeholders such as %{name}<\/code> and %{count}<\/code> as they are, though you can move them within the sentence. If a translation drops or changes one, QA Checks flag it when you save. A plural term lists its English forms, and its translation box has a tab for each French plural form: ONE<\/strong>, MANY<\/strong> and OTHER<\/strong>.<\/p>\n\n\n\n
\"\"
French translations, with the plural terms\u2019 ONE, MANY and OTHER tabs<\/em><\/figcaption><\/figure>\n\n\n\n
French uses the MANY<\/strong> form for exact multiples of a million, as in \u201c1 000 000 de t\u00e2ches\u201d. The rails-i18n French rule only has one<\/code> and other<\/code>, so Rails doesn\u2019t use that form unless you add your own French plural rule, in a .rb<\/code> file in config\/locales<\/code> that sets i18n.plural.rule<\/code>. Fill it in anyway: until every form has a translation, POEditor treats the term as untranslated. <\/p>\n\n\n\n
If you\u2019d like a first draft to review, Automatic Translation can pre-fill the French terms with Google Translate, DeepL or Azure AI Translator, and you can use AI translation from providers such as OpenAI or Anthropic\u2019s Claude once you add your own API key.<\/p>\n\n\n\n
Automatic Translation only fills the singular form of a plural term, so complete MANY<\/strong> and OTHER<\/strong> yourself if you use it, while AI translation fills every form. Whichever you use, check the date and time formats it translates, since those have to stay valid strftime <\/code>codes.<\/p>\n\n\n\n
To try the translations in the app, click Export<\/strong> on the French language page, set FILE FORMAT<\/strong> to YAML (.yml)<\/strong> and click Export File<\/strong>. With the default settings, the export writes every term, and an untranslated one comes out as an empty string, such as title: \"\"<\/code>. <\/p>\n\n\n\n
Rails treats an empty string as a translation, so the page shows nothing where that text should be, and it doesn\u2019t fall back to English even in production. An empty date format is worse, because it replaces the format from rails-i18n and the date disappears.<\/p>\n\n\n\n
While French is incomplete, switch on Advanced export options<\/strong> and set EXPORT<\/strong> to Translated<\/strong>, which leaves those terms out of the file. Alternatively, choose English as the Fallback Language<\/strong> in the same Advanced Options<\/strong>, and untranslated terms come out with their English text instead of an empty string. i18n-tasks then no longer reports them as missing, though, because they have a value. <\/p>\n\n\n\n
A plural term gets the English text only in its ONE<\/strong> form, and its MANY<\/strong> and OTHER<\/strong> forms stay empty, so a count of 2 or more still shows nothing until OTHER<\/strong> is translated.<\/p>\n\n\n\n
\"\"
Exporting the French translations as YAML<\/em><\/figcaption><\/figure>\n\n\n\n
The download is named TO-DO_app_Rails_French.yml<\/code>. Save it as config\/locales\/fr.yml<\/code>. It has the same structure as en.yml<\/code>, under a fr: root<\/code>, and keeps the comments from en.yml<\/code>:<\/p>\n\n\n\n
# config\/locales\/fr.yml\nfr:\n  lists:\n    list:\n      tasks_left:\n        one: \"%{count} t\u00e2che restante\"\n        many: \"%{count} de t\u00e2ches restantes\"\n        other: \"%{count} t\u00e2ches restantes\"\n  date:\n    formats:\n      # October 9, 2026 (strftime: %B month name, %-d day, %Y year)\n      long: \"%-d %B %Y\"<\/code><\/pre>\n\n\n\n
The development server picks up a new or changed locale file on the next request, so reload the page and click Fran\u00e7ais<\/strong> in the navbar. In production, restart the app after you deploy the new file.<\/p>\n\n\n\n
\"\"
The lists page in French, with French plurals and dates<\/em><\/figcaption><\/figure>\n\n\n\n
On a list page, the badge on each completed task reads Termin\u00e9e<\/code> while the filter tab reads Termin\u00e9es<\/code>, the dates follow the French formats, and a form that fails validation shows the rails-i18n message.<\/p>\n\n\n\n
\"\"
A list in French, with a validation message from rails-i18n<\/em><\/figcaption><\/figure>\n\n\n\n
Wrapping up<\/h2>\n\n\n\n
When you add a string to the app, add its key to en.yml<\/code> and import the file into POEditor again. Also import translations to a language<\/strong> starts switched off once the project has terms, so switch it on and choose English, or the new terms arrive without their English text. <\/p>\n\n\n\n
The import adds the new terms, which show up untranslated in French, and leaves the existing translations alone, including the English text of keys you\u2019ve reworded, unless you also switch on Overwrite existing translations<\/strong>. Switch on Mark strings as fuzzy in other languages<\/strong> as well, so the French translations of reworded keys are flagged for review. <\/p>\n\n\n\n
If you\u2019ve renamed or removed keys, POEditor follows the import with an Obsolete Terms<\/strong> page listing the terms that are no longer in the file, which you can tick and remove with Delete Selected<\/strong>. To automate this for every release, use the POEditor API<\/a>, or a code hosting integration<\/a> with its webhooks, to upload en.yml and download the translated files.<\/p>\n\n\n\n
Create a free POEditor account<\/a> and import your own en.yml to start translating your Rails app.<\/p>\n\n\n
Ready to power up localization?<\/h3>Subscribe to the POEditor platform today!<\/span><\/div>See pricing<\/a><\/div>\n\n\n\n
For other stacks in this series, see these guides:<\/p>\n\n\n\n