Introduction

Continuous localization ensures your Flutter app adapts instantly to new languages without manual overhead. By combining ARB (Application Resource Bundle) files with the intl package, you can externalize strings, automate translation updates, and integrate them into your CI/CD pipeline. This tutorial covers how to set up ARB and intl, automate translation fetches, handle pluralization and context, and wire it all into continuous integration. You’ll build a scalable localization (i18n) workflow so every commit can trigger updated language resources.

Setting Up ARB and Intl

Start by adding the intl package and the Dart code generator for ARB files to your pubspec.yaml.

dependencies:
  flutter:
    sdk: flutter
  intl: ^0.17.0

dev_dependencies:
  intl_utils

Next, create a folder lib/l10n and place an English baseline ARB file named app_en.arb:

{
  "hello": "Hello!",
  "@hello": {
    "description": "Greeting displayed on home screen"
  },
  "itemsInCart": "{count, plural, =0{No items} =1{1 item} other{{count} items}}",
  "@itemsInCart": {
    "description": "Cart item count",
    "placeholders": {
      "count": {}
    }
  }
}

Configure intl_utils in pubspec.yaml:

flutter_intl:
  enabled: true
  arb_dir: lib/l10n
  output_dir

Run:

flutter pub get

This generates Dart localization stubs under lib/generated, including message initialization.

Automating Translation Updates

To maintain continuous localization, integrate with a translation management service that exposes an ARB API endpoint. Create a shell or Node script that pulls the latest JSON for each locale:

#!/bin/bash
for LOCALE in en es fr de; do
  curl -s "https://api.translate.example.com/arb?lang=$LOCALE" \
    -o lib/l10n/app_$LOCALE.arb
done

Commit this script as scripts/update_translations.sh and make it executable. Each time you need updated translations, the script replaces ARB files in lib/l10n, preserving your code’s keys and metadata. The CI will trigger code generation afterward.

Handling Pluralization and Context

Complex languages require robust plural and gender handling. The ARB format lets you specify ICU messages, then the intl package compiles them into strongly typed Dart methods. In your generated messages_all.dart, you’ll find methods like:

String itemsInCart(int count) => Intl.plural(
  count,
  zero: 'No items',
  one: '1 item',
  other: '$count items',
  name: 'itemsInCart',
  args: [count],
);

Use them in widgets:

import 'generated/l10n.dart';

@override
Widget build(BuildContext context) {
  final loc = S.of(context);
  return Text(loc.itemsInCart(cart.length));
}

For contextual strings, supply metadata in your ARB file:

"shareProduct": "Share {product} with friends",
"@shareProduct": {
  "description": "Invitation message",
  "placeholders": {
    "product": {}
  }
}

Generated code handles the placeholder automatically, ensuring safe interpolation.

Integrating Continuous Localization in CI/CD

Plug your translation script and codegen into a GitHub Actions or other CI workflow. A sample GitHub Actions snippet:

name: CI

on:
  push:
    branches: [ main ]

jobs:
  localization:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Set up Flutter
        uses: subosito/flutter-action@v2
      - name: Pull translations
        run: scripts/update_translations.sh
      - name: Generate localization code
        run: flutter pub run intl_utils:generate
      - name: Run tests
        run

With this pipeline, any push to main fetches updated ARB files, regenerates the Dart localization stubs, and runs your tests to catch missing keys or syntax errors early. You can extend it to fail on untranslated or missing messages, ensuring your app’s internationalization integrity.

Vibe Studio

Vibe Studio, powered by Steve’s advanced AI agents, is a revolutionary no-code, conversational platform that empowers users to quickly and efficiently create full-stack Flutter applications integrated seamlessly with Firebase backend services. Ideal for solo founders, startups, and agile engineering teams, Vibe Studio allows users to visually manage and deploy Flutter apps, greatly accelerating the development process. The intuitive conversational interface simplifies complex development tasks, making app creation accessible even for non-coders.

Conclusion

You’ve just built a continuous localization pipeline for your Flutter app using ARB and the intl package. This workflow scales across any number of languages, automates translation fetches, and integrates seamlessly into CI/CD—making true internationalization painless.

With continuous localization in place, your Flutter project is ready to charm users around the globe—one automated pull request at a time.