<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/">
    <channel>
        <title>SimpleLocalize Blog</title>
        <link>https://simplelocalize.io/feed.xml</link>
        <description>SimpleLocalize Blog</description>
        <lastBuildDate>Thu, 12 Feb 2026 18:40:24 GMT</lastBuildDate>
        <docs>https://validator.w3.org/feed/docs/rss2.html</docs>
        <generator>awesome</generator>
        <language>en</language>
        <image>
            <title>SimpleLocalize Blog</title>
            <url>https://simplelocalize.io/card.png</url>
            <link>https://simplelocalize.io/feed.xml</link>
        </image>
        <copyright>All rights reserved 2026, SimpleLocalize</copyright>
        <item>
            <title><![CDATA[Webflow localization made easy with SimpleLocalize]]></title>
            <link>https://simplelocalize.io/blog/posts/webflow-simplelocalize-integration</link>
            <guid>https://simplelocalize.io/blog/posts/webflow-simplelocalize-integration</guid>
            <pubDate>Mon, 02 Feb 2026 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to localize your Webflow website using SimpleLocalize. Easily sync content, manage translations, and deliver multilingual Webflow sites without complex setups.]]></description>
            <content:encoded><![CDATA[Building a beautiful website in Webflow is fast and enjoyable. But when your product or business starts reaching users in different countries, managing multiple languages quickly becomes a challenge. Static text, CMS content, and UI labels all need to stay consistent across languages, without slowing down your team or breaking layouts. That's where SimpleLocalize comes in.

In this article, we will walk through how the Webflow integration with SimpleLocalize works, why it's a great choice for localization, and how you can connect everything in just a few steps.

Why localize a Webflow site?

Webflow gives designers and developers incredible control over layout and content. However, native multilingual support is limited, especially when it comes to:

Managing multiple languages at scale

Collaborating with translators

Keeping translations in sync with content changes

Supporting CMS-based and dynamic content

A dedicated localization platform solves these problems by separating content management from translation management while keeping everything connected.



What is SimpleLocalize?

SimpleLocalize is a localization platform designed for modern websites and applications. It helps teams manage translations, automate workflows, and deliver localized content without complex setups.

With SimpleLocalize, you can:

Store and manage all translations in one place

Support multiple languages and locales

Collaborate with translators and editors

Automate updates via API or integrations

Keep content structured and consistent

The Webflow integration makes this process smooth and beginner-friendly.



How the Webflow + SimpleLocalize integration works

The Webflow integration allows you to connect your Webflow site with SimpleLocalize, synchronize content, and manage translations externally, without rebuilding your site.

At a high level, the process looks like this:

Register at SimpleLocalize.

Install SimpleLocalize app in your Webflow project.

Sync content from Webflow to SimpleLocalize.

Translate content in SimpleLocalize.

Deliver translated content back to your localized Webflow site.

No custom backend. No complicated scripts.

Check details in the Webflow integration documentation.

Watch this setup video to see the integration in action:

Step 1: Register at SimpleLocalize

If you haven't already, start by creating a SimpleLocalize account. The 14-day free trial gives you access to all Team plan features so you can explore the platform with higher translation key limits.

At this step, you can also create a new project for your Webflow site, or you can do it later when connecting the integration.

In case you need more time or higher limits, let us know at contact@simplelocalize.io.

Step 2: Connect Webflow to SimpleLocalize

Install the SimpleLocalize app from the Webflow App Marketplace or search for "SimpleLocalize" in the Apps section of your Webflow project.

SimpleLocalize app in Webflow

Confirm the installation and authorize access to your Webflow project.

Authorize SimpleLocalize in Webflow

Next, select an existing SimpleLocalize project or create a new one to connect with your Webflow site.

Connect Webflow to SimpleLocalize project

Step 3: Synchronize content

Once connected, SimpleLocalize will open the integration settings. Here, you can choose which content types to sync from Webflow to SimpleLocalize, such as pages, components, and CMS collections.

Each piece of content becomes a translation key in SimpleLocalize, making it easy to manage and reuse across languages.

Webflow SimpleLocalize sync settings

Click "Synchronize translations" button to fetch your Webflow content into SimpleLocalize.

If your content changes in Webflow, you can sync again anytime to keep translations up to date.

Step 4: Translate and manage consistent

This is where SimpleLocalize really shines.

Inside the translation editor, you can:

Translate content manually in the interface

Invite translators or team members to collaborate

Use machine or AI translation to speed up initial drafts

Track missing or outdated translations

Organize content with tags and filters

Check issues with built-in QA tools

The interface is clean and intuitive, so even non-technical users can contribute safely.

SimpleLocalize translation editor

Step 5: Deliver localized content to Webflow

Once translations are ready, SimpleLocalize delivers them to your localized Webflow setup. Any translated content is automatically inserted into the appropriate language versions of your site.

Who is this integration for?

The Webflow + SimpleLocalize integration is ideal for:

Marketing websites targeting multiple regions

SaaS products built on Webflow

Startups scaling internationally

Teams without a dedicated backend

It offers a simple, cost-effective way to manage localization without complex development work.

Why choose SimpleLocalize for Webflow?

Ease of use: No coding required. The integration is designed for non-technical users.

Centralized management: Keep all translations in one place, separate from Webflow.

Clean and modern interface: SimpleLocalize is built for collaboration and efficiency.

Scalability: Handle growing content and languages without headaches.

Friendly for both developers and content teams: Everyone can contribute.

Affordable pricing: Competitive plans that grow with your needs.

Get started today

If you are ready to localize your Webflow site, SimpleLocalize makes it straightforward from day one.
Connect your Webflow project, sync content, and start translating, without changing how you build or design.

Sign up for SimpleLocalize and try the Webflow integration today. If you have any questions or need help, our support team is here to assist you at contact@simplelocalize.io.
Localization doesn't have to be hard. With Webflow and SimpleLocalize, it's just another smooth part of your workflow.
]]></content:encoded>
            <category>translation management</category>
            <category>webflow</category>
            <category>integration</category>
            <category>product updates</category>
            <enclosure url="https://simplelocalize.io/blog/webflow.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[Best free translation tools for developers (APIs, TMS & open source)]]></title>
            <link>https://simplelocalize.io/blog/posts/best-free-translation-tools-for-developers</link>
            <guid>https://simplelocalize.io/blog/posts/best-free-translation-tools-for-developers</guid>
            <pubDate>Wed, 28 Jan 2026 00:00:00 GMT</pubDate>
            <description><![CDATA[Discover the best free translation tools developers can actually use — from translation APIs and open-source tools to lightweight TMS platforms like SimpleLocalize.]]></description>
            <content:encoded><![CDATA[Building software that supports multiple languages shouldn't be painful or expensive. Today, developers have access to a wide range of free translation tools, from machine translation APIs to open-source editors and developer-friendly localization platforms.

In this post, we focus on tools you can realistically use in development workflows. That means clear free tiers, usable APIs, predictable limits, and honest trade-offs, not just marketing promises.

What “translation tools” mean for developers

In a developer context, translation tools usually fall into one (or more) of these categories:

Machine Translation (MT) APIs

Programmatic access to translation engines you can integrate into apps, scripts, or pipelines.

Translation Management Systems (TMS)

Platforms that help manage translation keys, editors, automation, and delivery to production.

Localization platforms / CAT tools

Tools for translators and contributors, often with translation memory and glossary support.

Open-source libraries and platforms

Self-hosted or offline tools that give full control but require more setup.

Each category solves a different part of the localization problem, and many teams combine multiple tools.

Free translation tools developers can use today

Below is a practical selection of free or free-tier translation tools, covering APIs, TMS platforms, and open-source solutions commonly used by developers.

For a broader overview focused purely on APIs, see our list of top machine and AI translation providers.

SimpleLocalize

SimpleLocalize is a developer-focused Translation Management System (TMS) designed to fit directly into modern development workflows. It combines a hosted translation editor, automation, APIs, and CDN-based delivery of translation files.

SimpleLocalize's Translation Editor

Category: Translation Management System (TMS)

Free tier: Community plan (up to ~250 keys, unlimited projects & languages)

Paid plans: From $15/month for larger projects

Website: simplelocalize.io

What developers like

Translation keys hosted and delivered via CDN (no redeploy needed for copy updates)

CLI and REST API for syncing translations with your codebase

GitHub, GitLab, CI/CD, and framework integrations

Built-in auto-translation using your own MT API keys

Predictable pricing - number of languages doesn't increase cost

Optional public suggestion links for crowdsourced translations

Limitations

Community plan is limited to ~250 keys

Larger apps require a paid plan

When it makes sense

SimpleLocalize works well when you want a lightweight TMS built for developers, not translators, especially if you care about automation, Git-based workflows, and avoiding per-language pricing.

Tolgee

Tolgee is a localization platform and translation management tool with a free tier and optional self-hosting. Like other TMS tools, it offers UI editing, translation memory, and machine translation integrations, but it approaches these features with a different product experience.

Tolgee Localization Platform

Category: Localization platform & TMS

Free tier: Free plan (key limits, MT credits)

Paid plans: Team and business plans available

Website: tolgee.io

What it offers

Visual translation editor

SDKs for various frameworks

Translation memory support

Integrated machine translation options

Self-hosted deployment (open-source edition)

Notes

Tolgee provides many of the typical TMS features you'd expect, such as memory and editing tools. Product experiences differ from platform to platform, but both SimpleLocalize and Tolgee aim to help developers manage translations without heavy manual overhead.

When it fits

Tolgee may appeal if you are specifically looking for an open-source deployable TMS and want to explore different UI and workflow options.

LibreTranslate

LibreTranslate is an open-source, privacy-focused machine translation API that you can self-host. There are no hard usage limits beyond what your infrastructure can handle, and the API is simple to integrate using JSON requests.



Category: Machine Translation API

Free tier: Fully open-source (self-hosted)

Paid plans: None

Website: libretranslate.com

What developers like

No API quotas or usage fees

Full control over data and deployment

Simple REST API

Trade-offs

Translation quality is generally lower than commercial providers

Language coverage is limited

You handle hosting, scaling, and maintenance

When it makes sense

LibreTranslate is a good choice for internal tools, prototypes, or privacy-sensitive projects where cost and control matter more than translation quality.

LibreTranslate Web Translator

Microsoft Translator Text API

Microsoft's Translator Text API offers neural machine translation with broad language support and a generous free tier. It integrates well with Azure services and supports real-time and batch translation.



Category: Cloud Translation API

Free tier: 2 million characters/month

Paid plans: $10 per million characters beyond free tier

Website: Microsoft Translator Text API

Docs: Azure Translator Docs

Benefits

Large free monthly quota

High-quality neural translations

Wide language support

Reliable for production workloads

Limitations

Requires Azure account and setup

Costs scale with usage

When it makes sense

A solid option for apps that need high-volume automatic translation while staying within a predictable budget.

Google Cloud Translation API

Google Cloud Translation is one of the most widely used translation APIs. It supports dozens of languages, automatic detection, and batch translation jobs.



Category: Cloud Translation API

Free tier: 500,000 characters/month + $300 free credit for new users

Paid plans: $20 per million characters

Website: Google Cloud Translation

Docs: Google Cloud Translation Docs

Benefits

Excellent language coverage

Fast and reliable

Easy integration with Google Cloud services

Limitations

Costs beyond the free tier can grow quickly

Pricing less forgiving for large-scale use

When it makes sense

Good for projects that already use Google Cloud and need broad language support.

DeepL API

DeepL is known for producing especially fluent translations, particularly for European languages. Its API is straightforward and popular for quality-sensitive use cases.



Category: Machine Translation API

Free tier: 500,000 characters/month

Paid plans: From $5.49/month + usage fees

Website: DeepL API

Docs: DeepL API Docs

Benefits

Often higher perceived translation quality

Simple REST API

Strong performance for European languages

Limitations

Fewer supported languages than Google or Microsoft

Paid usage required beyond the free tier

When it makes sense

Choose DeepL when translation quality matters more than coverage, especially for European markets.

Open-Source localization & editor tools

These tools are not hosted SaaS platforms, but they remain useful in many developer and open-source workflows.

OmegaT and Virtaal

Desktop CAT tools with translation memory and glossary support.

Translatewiki.net and Pootle

Web-based, community-driven localization platforms commonly used in open-source projects.

When they make sense

Best suited for offline work, volunteer localization, or community-maintained projects where SaaS platforms aren't desired.

What about AI / LLM-based translation?

Large language models can produce fluent translations, but they are not standalone localization tools. They lack consistent output, glossary enforcement, and change tracking.

In practice, LLMs work best inside a TMS as an auto-translation engine, not as a replacement for proper localization tooling.

Quick comparison

Here is a summary table of the tools discussed:

| Tool                     | Category        | Free Tier                    | Best For                               | Self-hosted |
|--------------------------|-----------------|------------------------------|----------------------------------------|-------------|
| SimpleLocalize           | TMS             | Community plan               | Developer-oriented localization         | ❌          |
| Tolgee                   | TMS             | Free plan + self-hosted      | Open-source deployable TMS             | ✅          |
| LibreTranslate           | MT API          | Unlimited (self-hosted)      | Privacy & internal tools               | ✅          |
| Microsoft Translator     | Cloud MT        | High free quota              | High-volume MT                         | ❌          |
| Google Translation API   | Cloud MT        | Moderate free quota          | Broad language coverage                | ❌          |
| DeepL API                | Cloud MT        | Moderate free quota          | High-quality MT                        | ❌          |
| OmegaT / Virtaal         | CAT tools       | Free                         | Local manual translation               | ✅          |
| Translatewiki / Pootle   | Open web tools  | Free                         | Community-driven localization          | ✅          |

Tips for developers choosing translation tools

Start small: Free tiers are often enough for MVPs and side projects

Combine tools: A TMS + MT API usually works better than either alone

Automate early: Use CLI and CI/CD to avoid manual syncs

Track quotas: Cloud MT costs can scale quietly

Optimize for maintainability: Consistency beats perfect translations

Conclusion

Modern translation tooling doesn't have to be expensive or disruptive. Free APIs, open-source tools, and TMS platforms make it possible to localize apps without slowing down development.

A thoughtful combination, like a TMS for structure and automation plus an MT API for volume, helps keep translations lean, consistent, and integrated into your build pipeline. Whether you choose SimpleLocalize, Tolgee, or other tools here, you now have many approachable paths for localizing your software.
Happy coding and translating!
]]></content:encoded>
            <category>developer</category>
            <category>auto translation</category>
            <category>machine translations</category>
            <enclosure url="https://simplelocalize.io/blog/translation-tools/translation-tools-for-developers.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[How to handle pluralization across languages]]></title>
            <link>https://simplelocalize.io/blog/posts/pluralization-guide</link>
            <guid>https://simplelocalize.io/blog/posts/pluralization-guide</guid>
            <pubDate>Fri, 23 Jan 2026 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how pluralization works in different languages and how to implement it correctly in multilingual software. Includes ICU examples and SimpleLocalize tips.]]></description>
            <content:encoded><![CDATA[Pluralization: it sounds simple at first. Just add an “s” when there's more than one, right? But as soon as you start translating your app into multiple languages, you quickly discover that languages handle quantities in wildly different ways. Getting plural forms right isn't just cosmetic, it's about clarity, professionalism, and trust in your product.

In this guide, you'll learn why pluralization matters in software localization, how plural rules differ across languages, and how to implement plural forms reliably in multilingual applications using standards like ICU MessageFormat and tools like SimpleLocalize.

Why pluralization isn't one-size-fits-all in software localization

Every language has its own grammar, and pluralization is one of its trickiest parts. In English, we generally distinguish between:

Singular / one: "1 apple"

Plural / other: "0 apples", "2 apples"

But other languages have many more rules. For example:

Polish uses one, few, and other, with few covering numbers like 2, 3, 4 and other covering most larger numbers. For example:

1: "1 kot" (one cat)

2: "2 koty" (few cats)

5: "5 kotów" (other cats)

Arabic can have six different plural forms depending on the number.

Pluralization example: cat in Polish

This matters because a direct translation from English, even something as common as “You have booked 2 rooms”, can become grammatically incorrect or even confusing if its plural logic isn't adapted to the target language.

Why users notice bad pluralization in apps and websites

Plural errors are subtle, but users notice them immediately, especially native speakers. Incorrect plural forms can:

Make your product feel unfinished or poorly localized

Reduce trust in important flows like checkout, billing, or booking

Create ambiguity ("Did I book one room or several?")

Lead to misunderstandings that impact user experience

In customer-facing software, these small language details directly affect perceived quality.

Bad pluralization example

How ICU MessageFormat solves pluralization challenges in multilingual software

To handle plurals correctly, most modern localization systems (including SimpleLocalize) use ICU MessageFormat, a standard syntax for defining plurals and other language variants in a single message.

In ICU, you define a plural with a syntax that looks like this:

Here:

numRooms is the variable representing the number of rooms.

plural tells ICU you're handling a plural case.

one and other are the plural categories for English.

When you translate this message into another language, you adjust the plural categories according to that language's rules. For example, in Polish, it would look like this:

Notice how Polish needs extra categories to express the natural grammar of the language. Without those, translations would feel awkward or be technically incorrect.

Learn more about ICU in our ICU MessageFormat guide.

ICU plural categories explained (in plain terms)

ICU defines plural categories, not numeric rules. That means:

Categories like one, few, or many do not always correspond to the same numbers.

The mapping depends entirely on the language.

For example:

In English, one = exactly 1

In Polish, one = exactly 1, few = 2-4

In Arabic, two is a separate grammatical form

This is why plural logic should live in translations, not in application code.

Plural categories by language (ICU overview)

Here's a quick overview of plural categories for some common languages:

| Language   | Plural categories               |
|------------|-------------------------------|
| English    | one, other                    |
| Polish     | one, few, other               |
| Spanish    | one, other                    |
| German     | one, other                    |
| Italian    | one, other                    |
| Portuguese | one, other                    |
| Czech     | one, few, other               |
| Arabic     | zero, one, two, few, many, other |
| Russian    | one, few, many, other         |
| French     | one, other                    |
| Japanese   | other                         |
| Chinese    | other                         |
| Turkish    | one, other                    |

For a complete and authoritative list, check the Unicode CLDR Plural Rules.

Best practices for pluralization with ICU MessageFormat

ICU MessageFormat is widely used across localization tools, frameworks, and platforms because it provides a language-aware way to handle plural forms. To get the most out of it, there are a few best practices worth following.

One key, many forms

A common mistake is creating separate translation keys for different quantities, for example:

room_single

room_plural

This approach doesn't scale once you introduce languages with more than two plural forms.

With ICU, you define one translation key, e.g. booking.rooms_booked, and express all plural variations directly in the message:

Why this works better:

Plural logic lives inside the translation, not in your application code.

Languages can define as many plural forms as they need.

The same key works consistently across all locales.

Translation files stay cleaner and easier to manage.

SimpleLocalize pluralization example

Keep plural logic out of code

Avoid writing conditional logic like if (count === 1) in your app. Different languages treat numbers differently, and assumptions based on English will eventually break.

Instead:

Pass the numeric value (e.g. count) to your translation layer.

Let ICU select the correct plural form for the active language.

This makes your app easier to maintain and far safer to localize.

Handle zero explicitly (when it matters)

Some languages have a dedicated zero category, while others reuse other. Even if ICU handles zero correctly, you may want to customize the message:

"No rooms booked" instead of "0 rooms booked"

"You have no unread messages" instead of "0 unread messages"

You can handle this by either:

Using a zero category (where supported)

Or combining plural rules with select



Always include the other category

In ICU plural rules, other is mandatory. It acts as a safety net:

It covers numbers that don't match any explicit rule.

It's required even in languages that appear to have only one form.

It prevents runtime errors and missing translations.



Even languages without grammatical plurals (like Japanese or Chinese) still rely on other.

Use language-specific categories

Plural categories like few or many are language-specific abstractions. Never assume their numeric meaning.

For example:

few means “2-4” in some Slavic languages (e.g. Polish and Czech)

few means something entirely different in Arabic

some languages use a special form for exactly 2

Always follow ICU and CLDR rules for each language.

Combine plurals with select for richer messages

ICU allows you to nest plural rules with select, which is useful for more expressive messages:

This way, you can handle both quantity and context in a single message.

Test edge cases early

Always test your ICU messages with:

Zero quantities (0)

One (1)

Boundary values (2, 4, 5, 11, 21)

Large numbers (1000+)

Multiple languages

Plural rules can behave differently than expected, especially in Slavic and Semitic languages. Catching issues early saves time and prevents costly re-translation.

How SimpleLocalize helps manage pluralization

SimpleLocalize supports ICU MessageFormat out of the box, making it easy to:

Define plural forms in a single translation key

Preview plural behavior per language

Validate ICU syntax before deployment

Keep translators focused on language, not code

By centralizing plural logic in your translations, you reduce bugs, simplify development, and ensure your product reads naturally in every supported language.

Learn more about pluralization in SimpleLocalize.

Conclusion: building correctly localized plural forms

Pluralization is one of those details that separates "translated" software from truly localized software.

By using ICU MessageFormat, defining one key per message, and letting language-specific rules do the heavy lifting, you build products that feel natural, trustworthy, and professional, no matter the language.

If you're working with multiple languages, getting plurals right isn't optional, it's essential. With the right tools and practices, you can master pluralization and deliver a seamless experience to users worldwide.
]]></content:encoded>
            <category>software localization</category>
            <category>localization</category>
            <category>tips</category>
            <category>icu</category>
            <category>developer</category>
            <enclosure url="https://simplelocalize.io/blog/icu-pluralization.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[11 common localization mistakes (and how to avoid them)]]></title>
            <link>https://simplelocalize.io/blog/posts/common-localization-mistakes</link>
            <guid>https://simplelocalize.io/blog/posts/common-localization-mistakes</guid>
            <pubDate>Thu, 22 Jan 2026 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn the most common localization mistakes teams make and how to avoid them with practical tips, real examples, and SimpleLocalize best practices.]]></description>
            <content:encoded><![CDATA[Localization can make or break the experience for international users. In software products, poor localization doesn't just sound awkward, it causes confusion, slows down workflows, and quietly damages trust.

For product teams, localization is no longer a one-off task handled just before launch. It's an ongoing process that touches product, design, engineering, content, and marketing.

In this article, we'll walk through the most common localization mistakes teams make, explain why they matter, and show practical ways to avoid them. Where relevant, we'll use hotel and PMS examples to illustrate the point, but the lessons apply to any software product.

What is localization and how it differs from translation?

Translation focuses on converting text from one language to another. Localization goes further: it adapts language, tone, formats, and context so the product feels natural to users in each market.

For example, translating a label like “No Show Fee” word-for-word may technically be correct, but if the term isn't commonly used in that market, users may misunderstand it or interpret it as a different concept.

This distinction is at the heart of many localization problems. Let's look at the most common ones.

Common mistakes in localization

1\. Treating localization as just translation

The mistake: Assuming that literal translation is enough.

Localization vs Translation

In hospitality software, short UI labels like “Extend stay”, “Early check-in”, or “Early bird” carry specific operational meaning. A direct translation may miss that meaning entirely.

How to avoid it:

Translate intent, not just words.

Add explanations for industry-specific terms

Review translations with someone familiar with the domain.

How SimpleLocalize helps:

Auto-translation can generate a strong first draft, but adding descriptions, screenshots and comments to keys ensures translators understand what the text actually does in the product.

Learn more about context in localization.

2\. Ignoring regional language variants

The mistake: Using one language version for all regions (for example, one Spanish version for the entire world).

Regional differences can be significant

Spanish in Spain uses different vocabulary and formalities compared to Latin American Spanish. For example, "reservation" translates to "reserva" in Spain but might be better understood as "reservación" in Mexico.

How to avoid it:

Treat regional variants as separate locales (es-ES, es-MX, es-CL).

Adapt phrasing to local expectations, not just spelling.

How SimpleLocalize helps:

No languages limit means you can create as many regional variants as needed. Learn how to add new languages and locales.

3\. Hard-coding text in the application

The mistake: Embedding user-facing text directly in code.

Hard-coded text is easy to miss

This often happens with small labels or error messages like “Room not available” or “Invalid arrival date”. These strings are easy to miss, and even easier to forget when updating translations.

How to avoid it:

Externalize all user-facing text into localization files.

Use keys to reference text in the code instead of hard-coded strings.

Regularly audit the codebase for any hard-coded text.

How SimpleLocalize helps:

By hosting translations centrally and integrating them via SDKs or API, you can update text without redeploying your application.

4\. Providing no context to translators

The mistake: Sending translators isolated strings with no explanation.

Example of lack of context

A label like “Check-in” could refer to a button to start the check-in process, a status indicator, or even a noun describing the act of checking in. Without context, translators may choose the wrong meaning.

How to avoid it:

Add descriptions and usage examples for each string.

Include screenshots or mockups showing where the text appears in the UI.

How SimpleLocalize helps:

Screenshots, descriptions and comments live right next to each key, reducing misunderstandings and back-and-forth.

5\. Over-reliance on machine translation or AI

The mistake: Publishing machine/AI-translated content without review.

Translation with AI workflow

Terms like “No Show”, “Rate Plan”, or “Folio” often confuse general-purpose translation engines, especially outside hospitality. Same with very general phrases like “Manage booking” that lack specific context.

How to avoid it:

Use machine translation as a first draft, not the final version.

Have human translators review and edit machine-generated translations.

Provide translators with context and domain knowledge.

How SimpleLocalize helps:

Auto-translation can speed up initial translation, but combining it with human review ensures accuracy and appropriateness. When using AI tools, provide them with context to improve results.

Check out our tips for effective auto-translation to get the best out of machine-generated content.

6\. Inconsistent terminology across the product

The mistake: Translating the same concept in different ways.

Inconsistent terminology example

If “Reservation” is translated one way in the booking flow and another way in reports, users start questioning whether those things are actually different.

How to avoid it:

Decide on preferred terms early in the localization process.

Keep related strings organized.

Review translations holistically, not key by key.

Create and maintain a terminology glossary.

Use translation memory to ensure consistent use of terms.

How SimpleLocalize helps:

Translation memory suggests previously used translations for similar strings, promoting consistency across the product. Tags, structured key naming, and filtering make it easier to spot inconsistencies and keep terminology aligned.

7\. Forgetting local date, time, and currency formats

The mistake: Displaying the same formats everywhere.

Date and number formatting differences

A date like 05/04/2026 or a price like 1,200.50 can be interpreted very differently depending on locale, especially in booking confirmations or invoices.

How to avoid it:

Handle formatting programmatically based on locale.

Test the product in different locales to ensure formats appear correctly.

Keep translations focused on text, not formatting.

Good practice: Use locale-aware libraries for dates, times, and numbers, and keep them separate from translation files.

Check out our guide on number formatting in JavaScript for practical tips.

8\. Not designing for text expansion

The mistake: Designing UI only for the source language.

Text expansion example in a website header

Many languages are longer than English. A button labeled “View Invoice” may expand significantly when translated, breaking layouts or truncating text.

How to avoid it:

Design flexible UI components that can accommodate longer text.

Test the UI with translations in multiple languages.

Use relative sizing and hard character limits where possible.

How SimpleLocalize helps:

With SimpleLocalize, you can preview translations in context using In-Context Editor or directly in Figma, see the character count for each translation and set character limits to prevent overflow issues.

9\. Skipping localization quality assurance

The mistake: Shipping localized content without checks.

Example of localization QA issue

Small errors like wrong plural forms, missing variables, or outdated translations, can slip into production unnoticed.

How to avoid it:

Add a review step before release.

Check placeholders, numbers, and consistency

Use automated tests to check for missing translations or formatting issues.

How SimpleLocalize helps:

Built-in automated QA checks and review statuses help teams catch issues before users do.

Learn more about controlling translation quality in our guide to translation reviews.

10\. Treating localization as a one-time task

The mistake: Localizing once and never revisiting it.

Ongoing localization process

Products evolve, new features are added, and terminology changes. Without ongoing localization efforts, translations quickly become outdated and falls out of sync.

How to avoid it:

Adopt a continuous localization mindset.

Sync translations as part of your release process.

Regularly review and update translations.

How SimpleLocalize helps:

Automations, CLI tools, and integrations allow translations to stay aligned with product updates.

11\. Ignoring localization SEO

The mistake: Translating content without considering search intent.

If you publish localized landing pages, help articles, or documentation, ignoring local keywords and metadata means missing organic traffic in international markets.

How to avoid it:

Research keywords for each target market.

Localize meta titles, descriptions, and URLs, not just body text.

Monitor performance and adjust based on local search trends.

Learn more about localization SEO best practices.

How SimpleLocalize helps prevent these mistakes

SimpleLocalize is designed to support the entire localization lifecycle, not just translation. Key features include:

Contextual tools like screenshots, descriptions, and comments to reduce misunderstandings.

Auto-translation with AI providers

Review workflows and QA checks

Locale-based organization and tagging

Translation hosting and delivery via CDN

Integrations with design tools and CI/CD pipelines

Together, these features help teams avoid common pitfalls and maintain high-quality localized experiences as products scale.

SimpleLocalize Translation Editor

Conclusion

Good localization is invisible when done right, and painfully obvious when done wrong. By avoiding these common mistakes and building better localization practices into your workflow, you create software that feels clear, professional, and trustworthy in every market.

Explore more localization best practices on the SimpleLocalize blog and see how thoughtful localization can support your global growth.
]]></content:encoded>
            <category>software localization</category>
            <category>translation management</category>
            <category>tips</category>
            <enclosure url="https://simplelocalize.io/blog/common-localization-mistakes.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[Managing ARB translation files in Flutter]]></title>
            <link>https://simplelocalize.io/blog/posts/manage-arb-translation-files-flutter</link>
            <guid>https://simplelocalize.io/blog/posts/manage-arb-translation-files-flutter</guid>
            <pubDate>Wed, 21 Jan 2026 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to manage ARB translation files in Flutter. Covers ARB structure, metadata, placeholders, plurals, and practical best practices using SimpleLocalize.]]></description>
            <content:encoded><![CDATA[ARB (Application Resource Bundle) files are the standard way to handle localization in Flutter applications. They are simple JSON files, but with a few important conventions that make them powerful for translations: metadata, descriptions, placeholders, plurals, and gender rules.

In this article, we will take a practical look at ARB files, how they work in Flutter, common challenges teams face when managing them, and how SimpleLocalize helps you keep translations under control as your app grows.

If you have worked with other formats like XLIFF, CSV, PO/POT, or YAML, you will notice that ARB has its own quirks. Understanding them early will save you time later.

What is an ARB file?

ARB stands for Application Resource Bundle. Technically, it's a JSON file with a naming convention and a few reserved keys used by Flutter's localization tooling.

A typical ARB file looks like this:

Each file represents a single locale. For example:

app_en.arb for English

app_de.arb for German

app_es.arb for Spanish

Flutter uses these files together with flutter_localizations and intl to generate strongly typed localization code.

Learn more about setting up Flutter localization in the official Flutter docs on internationalization.

ARB metadata and descriptions

One important difference between ARB and plain JSON is metadata entries. Any key that starts with @ is treated as metadata for the corresponding message.

Example:

In this example, the @welcomeUser key provides additional context for translators, like descriptions and placeholder details. Why this matters:

Translators see context, not just raw strings

Placeholders are clearly defined, reducing errors

Flutter can generate safer localization code

When metadata is missing, translations often become ambiguous. A short description can prevent many mistakes.

Currently SimpleLocalize supports descriptions metadata. Placeholder details are not yet supported but are planned for future releases. Learn more in our ARB integration documentation.

Handling placeholders in ARB files

Placeholders allow you to inject dynamic values into translations. In ARB files, placeholders are written using curly braces:

In the metadata section, you define the placeholder details:

Tips for placeholders:

Use clear, descriptive names (userName instead of name)

Keep placeholder usage consistent across languages

Avoid embedding formatting logic directly in strings

When translators see well-defined placeholders, they can create accurate translations without guessing.

Plurals and ICU message format

ARB files use ICU MessageFormat, which allows proper pluralization and complex language rules.

Example of pluralization:

This approach is much better than string concatenation and works correctly for languages with complex plural rules.

When managing plurals:

Always use ICU syntax instead of manual logic

Test plural forms in multiple languages

Keep messages readable — long ICU strings benefit from descriptions

SimpleLocalize fully supports ICU message format in ARB files, making it easy to manage plurals and complex translations.

Common challenges with ARB files

ARB files are simple at first, but real projects grow quickly. Common issues include:

Missing or outdated translations: As new keys are added, older ARB files may fall behind. Without visibility, it's easy to ship incomplete translations.

Lack of context for translators: Without descriptions and screenshots, translators guess, and guessing leads to errors.

Broken placeholders: Renaming or removing placeholders without updating translations can cause runtime errors.

Large files and merge conflicts: ARB files often live in Git. When many people edit the same file, conflicts become frequent.

Inconsistent formatting: Manual edits can lead to formatting issues that break parsing.

These challenges can make ARB file management painful without the right tools and processes.

Managing ARB files with SimpleLocalize

SimpleLocalize supports ARB files natively, making it easy to upload, manage, and download translations. Integrate it into your Flutter workflow with just a few steps.

Importing ARB files

You can upload ARB files directly to SimpleLocalize. The system:

Reads message keys and values

Extracts metadata and descriptions

Detects and validates placeholders automatically

This makes it easy to start from existing Flutter projects.

Importing ARB files in SimpleLocalize

Editing translations safely

In SimpleLocalize:

Placeholders are protected from accidental removal

Plural rules are clearly visible

Descriptions help translators understand usage

Validation checks ensure consistency across languages

This reduces the risk of broken builds caused by incorrect translations.

Add more languages, run auto-translation and quality checks, update review statuses, add more context with screenshots — all from a user-friendly interface.

Editing ARB translations in SimpleLocalize

Collaboration and workflow

Instead of editing ARB files manually:

Developers focus on source language updates

Translators work in a dedicated UI

Reviewers can approve changes before export

This separation keeps ARB files clean and predictable.

Exporting back to Flutter

Once translations are ready, you can export them back as ARB files:

One file per locale

No manual formatting required

Placeholders intact

The exported files can be committed directly to your repository or integrated into your CI/CD pipeline.

Exporting ARB files from SimpleLocalize

Learn more about SimpleLocalize's CLI tools and REST API for automating ARB file management.

Best practices for ARB localization

Here are a few tips that work well in real projects:

Use descriptive keys: Instead of generic keys like msg1, use welcomeUser or errorNetwork

Keep keys stable: changing keys breaks existing translations

Write descriptions early: context is cheaper than fixes

Use one source language: usually English

Validate placeholders during code reviews

Avoid duplicate strings with different meanings

Regularly sync ARB files with your localization platform

Small habits make a big difference over time. By following these practices, you can keep your ARB files manageable and your translations accurate.

Conclusion

ARB files are easy to start with, but managing them at scale requires structure and good tooling. With clear metadata, consistent placeholders, and a solid workflow, Flutter localization becomes predictable instead of painful. Using a platform like SimpleLocalize takes much of the manual work out of managing ARB files, letting your team focus on building great apps that speak multiple languages.

Get started with SimpleLocalize today and see how it can help you manage ARB translation files in Flutter with ease!
]]></content:encoded>
            <category>software localization</category>
            <category>arb</category>
            <category>flutter</category>
            <category>developer</category>
            <enclosure url="https://simplelocalize.io/blog/arb-flutter.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[How to manage Shopify blog translations]]></title>
            <link>https://simplelocalize.io/blog/posts/shopify-blog-translations</link>
            <guid>https://simplelocalize.io/blog/posts/shopify-blog-translations</guid>
            <pubDate>Mon, 12 Jan 2026 00:00:00 GMT</pubDate>
            <description><![CDATA[Discover how to translate Shopify blog posts using SimpleLocalize. Keep your multilingual content consistent, maintain SEO, and reach global readers effectively.]]></description>
            <content:encoded><![CDATA[For Shopify merchants looking to reach global audiences, blog content is as important as product pages. Blog posts help drive traffic, engage customers, and improve SEO. Translating them effectively ensures your brand speaks consistently in every market. SimpleLocalize makes this process manageable, even as your content library grows.

If you haven't already, check out our Shopify SimpleLocalize integration guide for an overview of connecting your store and translating pages and products. This post focuses specifically on blog post translations.

Why translate Shopify blog posts?

Blog posts are more than marketing, they are engines for organic traffic and engagement. Translating them:

Boosts organic traffic from international search engines. Properly localized content signals to search engines that your site is relevant for users in different regions and languages. Learn more in our Localization SEO guide.

Expands brand visibility across markets. Multilingual blogs show your audience that your brand speaks their language, improving trust and engagement.

Provides localized content that resonates with readers. This includes adjusting examples, measurements, and cultural references for each target audience.

Manually translating posts in Shopify can quickly become time-consuming, especially with frequent updates or multiple authors. SimpleLocalize centralizes translations, keeping everything consistent and easy to manage.

SEO considerations for localized blogs

Properly localized blogs aren't just readable, they improve search visibility. Here's what to keep in mind:

URL structure matters: Use language-specific subdirectories (e.g., /en/blog/post-title/, /es/blog/post-title/) or subdomains instead of query parameters. Learn more in our URL localization guide.

Hreflang tags: Let search engines know which version of a blog post corresponds to which language to avoid duplicate content issues. Learn more in our Hreflang guide.

Translate metadata: Titles, meta descriptions, and image alt texts should all be localized to boost SEO performance in target languages.

Canonical URLs: Use canonical tags for the original post if you have minor variations or automatically generated translations.

Keyword localization: Adapt keywords for each language to match search intent and improve rankings.

Following these SEO practices ensures your translated blogs are discoverable and effective in every market.

Step-by-step: Translating Shopify blog posts

Here's a clear workflow for translating blogs with SimpleLocalize:

Connect your Shopify store to SimpleLocalize

If you haven't done so already, connect your Shopify store to SimpleLocalize using our integration guide. This connection allows SimpleLocalize to access your blog posts for translation.

Create project in SimpleLocalize.

Install the SimpleLocalize Shopify app.

Authenticate your store and set up the connection.

Choose resource types to sync, including blog posts.

Synchronize your existing blog posts to SimpleLocalize.

Check out the video below for a walkthrough of connecting your Shopify store and syncing blog posts:

Connecting Shopify store and blog posts

Translate blog posts

Open your blog post in the SimpleLocalize editor, optimized for long-form content. You can work on translations manually or use machine translation to speed up the process. Review and edit machine translations to ensure quality.

Translating Shopify blog posts in SimpleLocalize

Translate also the blog post metadata, including titles and meta descriptions, to maintain SEO effectiveness. All metadata fields are available in the SimpleLocalize editor.

Editor features for blog posts

The SimpleLocalize editor offers features tailored for blog post translations:

Comments: Leave notes for translators or reviewers on specific text segments.

Version history: Track changes and revert to previous versions if needed.

Rich text formatting: Maintain headings, lists, links, and other formatting elements.

Review status: Track progress with translation review statuses.

QA checks: Detect missing translations, formatting errors, or inconsistent terms before publishing.

Side-by-side view: Compare source and target texts easily.

Learn more about visual rich text and markdown translation.

Note: Make sure the key type is set to "Rich text" to preserve formatting like headings, lists, and links.

Key type rich text for blog posts

Check translated content in Shopify

Translated blog posts will automatically sync back to your Shopify store. Review them in the Shopify admin to ensure everything appears correctly.

Review translated blog posts in Shopify

Synchronization and updates

Translation updates made in SimpleLocalize will automatically sync to Shopify. This includes edits to existing posts or new blog posts added to your store.

To download new content from Shopify, use the "Synchronize" action button in the editor or in the integration settings.

Add new languages in Shopify and enable them in the integration settings. Click "Synchronize" to fetch new languages and their content.

Synchronize with Shopify action button

Best practices for Shopify blog translations

To get the most value from multilingual blogs on Shopify:

Prioritize high-traffic Shopify posts. Start with posts that drive the most traffic to your store. Thanks to this, your translation efforts have the biggest impact on engagement and sales. You can check traffic via Shopify Analytics or Google Analytics.

Localize content fully for e-commerce context. Adapt examples, product mentions, measurements, or currency to the target audience. For instance, if your post references pricing or product availability, make sure it aligns with the local market.

Keep translations in sync with Shopify updates. Shopify allows you to update blog content regularly. Use SimpleLocalize to track changes so translated posts automatically reflect updates without manual duplication.

Optimize Shopify-specific SEO fields. Translate blog titles, meta descriptions, summaries, handles, alt text for images, and Shopify tags.

Leverage Shopify Liquid for dynamic content. If your blog contains dynamic content or snippets (like product recommendations), ensure these are localized properly in your translated version using Shopify Liquid variables.

Conclusion

Translating your Shopify blog posts goes beyond language; it's about creating a consistent, localized experience that connects with international customers, strengthens your brand, and drives SEO performance. With SimpleLocalize, you can manage translations efficiently, maintain formatting and SEO fields, track updates, and collaborate with your team or professional translators without leaving Shopify.

By integrating translation management into your Shopify workflow, every blog post can reach the right audience in the right language. Start translating today and unlock the full potential of your Shopify store for global growth.
]]></content:encoded>
            <category>translation management</category>
            <category>shopify</category>
            <category>blog</category>
            <category>markdown</category>
            <enclosure url="https://simplelocalize.io/blog/shopify-blog-translations.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[Shopify + SimpleLocalize: Easy multilingual store management]]></title>
            <link>https://simplelocalize.io/blog/posts/shopify-simplelocalize-integration</link>
            <guid>https://simplelocalize.io/blog/posts/shopify-simplelocalize-integration</guid>
            <pubDate>Tue, 16 Dec 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Manage Shopify translations with the SimpleLocalize integration. Sync products, collections, and content translations across languages automatically, from one place.]]></description>
            <content:encoded><![CDATA[Expanding a Shopify store into new markets comes with one major challenge: managing translations efficiently. Store content lives in many places: products, collections, pages, blog posts, and keeping everything consistent across languages can quickly become overwhelming.

That's why we built the Shopify + SimpleLocalize integration. It connects your Shopify store with SimpleLocalize, giving you a centralized translation management system designed specifically for multilingual e-commerce. Instead of handling translations manually inside Shopify, you can sync your store content to SimpleLocalize, manage translations in one place with automations, and push updates back to your store automatically.

The result is a simpler workflow, fewer errors, and a scalable foundation for growing your Shopify store internationally.



Why Shopify + SimpleLocalize?

Shopify provides built-in support for multiple languages, but managing translations directly inside the admin can quickly become limiting as your store grows. Content is spread across products, collections, pages, and blogs, and collaboration with translators or content editors often requires manual work.

The Shopify + SimpleLocalize integration solves this by moving translation management to a dedicated platform. Your store content is synchronized with SimpleLocalize, where translations can be created, reviewed, and maintained in one place, without disrupting your existing Shopify workflow.

This approach keeps Shopify focused on commerce, while SimpleLocalize handles localization at scale.

How the integration works

The integration connects your Shopify store with a SimpleLocalize project and synchronizes translatable content between them.

After installing the SimpleLocalize app in Shopify and connecting it to your project, you can choose which resources should be synchronized. Once enabled, SimpleLocalize fetches your store's translatable content and keeps it organized by language and resource type.

SimpleLocalize app in Shopify

Translations added or updated in SimpleLocalize can then be pushed back to Shopify automatically. When you add a new language to your Shopify store, it’s picked up during synchronization and becomes available in SimpleLocalize without additional configuration.

This creates a reliable, repeatable translation workflow that fits naturally into day-to-day store management.

Learn more in our Shopify integration documentation.

Getting started

Here's how to set up the Shopify + SimpleLocalize integration in a few easy steps:

Install the SimpleLocalize Shopify app from the Shopify App Store.

Connect your store to a SimpleLocalize project.

Choose the resources you want to synchronize: products, collections, blogs, etc.

Click “Synchronize translations” to bring your store content into SimpleLocalize.

Once connected, every update you make in SimpleLocalize can be pushed back to Shopify automatically. Want to add a new language? Just add it in Shopify, SimpleLocalize will pick it up on the next sync.

Watch this setup video to see the integration in action:

What you can translate

The integration supports multiple Shopify resources, allowing you to manage translations for key store content in one place, including:

Products: Titles, descriptions, variants

Collections: Names, descriptions

Pages: Content, metadata

Blog posts: Titles, content

Navigation menus: Link titles

Checkout and system messages

JSON template files

All translated content stays linked to its original source, making updates and maintenance straightforward as your store evolves.

Translated products in Shopify

Built for real translation workflows

SimpleLocalize is designed to support real-world localization needs, not just basic text editing.

With the Shopify integration, you can:

Collaborate with translators and editors in a shared workspace

Use translation memory to maintain consistency across products and content

Review and update translations without touching Shopify's admin

Scale your store to new languages without duplicating effort

This is especially useful for stores with frequent content updates or multiple contributors working on translations.

Benefits for multilingual Shopify stores

By combining Shopify with SimpleLocalize, you get a translation setup that's easier to manage and ready to scale.

Shopify translation workflow

Key benefits include:

Reduced manual work when managing multiple languages

Better consistency across translated content

Faster rollout of new languages and markets

A single source of truth for all translations

Instead of treating translations as a one-time task, the integration turns localization into a manageable, ongoing process.

Important things to know

A few points are worth keeping in mind when using the integration:

The default (primary) language content is still managed directly in Shopify

Shopify supports up to 20 languages per store

Some older Shopify themes may have limited multilingual support

These are platform limitations rather than integration constraints, and they're easy to plan around when setting up your localization strategy.

Start managing Shopify translations with SimpleLocalize

The Shopify + SimpleLocalize integration is designed to remove friction from multilingual store management. By syncing your store content with SimpleLocalize, you gain clarity, control, and flexibility over translations, without complicating your Shopify setup.

This post covers the foundation. In upcoming articles, we'll take a closer look at:

Managing product translations

Translating blog posts

Best practices for multilingual SEO in Shopify

If you're ready to simplify translation management for your Shopify store, the integration is a great place to start. Sign up for a SimpleLocalize account and install the Shopify app to get going today!
]]></content:encoded>
            <category>translation management</category>
            <category>shopify</category>
            <category>integration</category>
            <category>product updates</category>
            <enclosure url="https://simplelocalize.io/blog/shopify.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[Mastering XLIFF files: How to manage & translate them]]></title>
            <link>https://simplelocalize.io/blog/posts/manage-xliff-translation-files</link>
            <guid>https://simplelocalize.io/blog/posts/manage-xliff-translation-files</guid>
            <pubDate>Thu, 04 Dec 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn what XLIFF files are, how they work, and how to easily manage and translate them using SimpleLocalize. Includes examples, best practices, and real-world workflows for developers and localization teams.]]></description>
            <content:encoded><![CDATA[When you step into the world of software localization, sooner or later you encounter XLIFF — the XML-based industry standard for exchanging translation data across platforms and tools. XLIFF files are used in mobile apps, web applications, desktop software, and even enterprise systems because they provide a structured, predictable, and tool-agnostic way to store translations.

In this guide, we'll break down what XLIFF is, why it's so widely used, and how to manage and translate XLIFF files efficiently using SimpleLocalize.

We will focus primarily on the widely adopted XLIFF 1.2 version, as it's the most common in real-world projects and fully supported by SimpleLocalize.

What is XLIFF?

XLIFF (XML Localization Interchange File Format) is a standardized XML format designed to move translation data between systems, developers, and translators.

It exists to solve a simple but common problem:



Why XLIFF is popular

XLIFF has become the go-to format for localization due to several key advantages:

Tool-agnostic: Most CAT tools, translation management systems, and localization platforms support it

Human- and machine-readable: It's XML, so it's structured but still editable

Supports metadata: notes, context, developer comments

Preserves structure: placeholders, tags, formatting, whitespace

Version control friendly: works great in Git and other VCS

While the newer XLIFF 2.0 exists, many platforms, including iOS, SAP, many CAT tools, and several web frameworks, still rely heavily on XLIFF 1.2, which keeps it relevant and widely used.

Inside an XLIFF 1.2 file (structure breakdown)

To understand how translations are stored, let's look at a simple XLIFF 1.2 example:

Key components:

\<xliff version="1.2">: Specifies the XLIFF version. This post focuses on the 1.2 variant.

\<file>: Contains metadata such as source and target languages, the original file name and datatype (plaintext, html, xhtml, etc.).

\<trans-unit>: Represents a single translation entry. Contains:

\<source> (original text)

\<target> (translation)

\<note> (context or translator hint)

This structure is why XLIFF is so useful: it bundles text + translation + context into one clean package.

When should you use XLIFF?

XLIFF (especially 1.2) is ideal when:

You work with translation agencies or freelancers. Because XLIFF is widely supported, agencies love it.
They can import XLIFF directly into CAT tools like memoQ, SDL Trados, etc.

Your app uses placeholders, variables, or rich formatting. XLIFF preserves inline markup safely, something basic file formats like CSV or TXT can break.

You want clean version control. XLIFF is text-based, meaning diffs and merges are manageable.

You work cross-platform. Many ecosystems use XLIFF: iOS (exports/imports via .xcloc), Angular, Symfony, .NET, Desktop & enterprise apps.

You need to exchange translations between different tools. XLIFF acts as a lingua franca for localization data.

And when XLIFF might be “too much”?

If your app has only 20 strings and one extra language, a simple JSON or .strings file might be enough.

But most teams outgrow that quickly, and XLIFF becomes a lifesaver.

Managing XLIFF files with SimpleLocalize

SimpleLocalize fully supports importing and exporting XLIFF 1.2, making it easy to build a clean, automated localization workflow.

What SimpleLocalize can do with XLIFF:

Upload your existing .xliff file

Edit and translate strings in the translation editor

Run quality checks (placeholders, length, missing entries, etc.)

Add notes and context for translators

Use AI translation or share with human translators

Export translations back to XLIFF 1.2 (or any other format you need)

Upload, translate and export XLIFF translation files

You can upload and export XLIFF files directly from the SimpleLocalize translation editor or automate the process using:

CLI tool with XLIFF support: Automate uploads/downloads in your CI/CD pipeline

REST API: Integrate XLIFF management into your custom tools or scripts

GitHub Action: Sync XLIFF files directly from your GitHub repository

GitHub App: Automate localization workflows with pull requests

and more integrations.

Best practices for working with XLIFF files

Here are some tips to keep your workflow smooth:

Use stable, descriptive IDs. Avoid using source text as the ID (use welcome_title instead of Welcome to our app!). This prevents issues when source text changes.

Add clear context using \<note>. Translators work faster and more accurately when they understand usage.

Don't remove or modify placeholders manually. XLIFF handles them safely.

Keep translation units small. One sentence or UI element per unit is usually ideal.

Validate your XLIFF. Especially if you generate it manually or use multiple tools in the pipeline.

Example: Translating an iOS App using XLIFF

iOS apps can export localization data as XLIFF files using Xcode. Here's a quick workflow:

Export .xcloc package from Xcode (contains XLIFF files)

Extract .xliff files from the bundle

Upload XLIFF to SimpleLocalize

Translate or review in the editor

Download updated XLIFF

Re-import into Xcode to update localized strings

Ship the app with updated translations

This is the safest way to work with translation agencies or distributed teams, and avoids painful manual editing of .strings files.

Learn more about iOS translation file formats.

Conclusion

XLIFF is one of the most reliable and flexible ways to exchange translation data in modern software development. With its structured XML format, contextual information, and deep tool support, it has become an industry standard for good reason.

If you're maintaining a mobile app, building a multilingual SaaS product, or collaborating with external translators, SimpleLocalize makes it easy to import, edit, translate, and export XLIFF 1.2 files without headaches.

Get started with XLIFF localization in SimpleLocalize today and see how much simpler managing translations can be!
]]></content:encoded>
            <category>software localization</category>
            <category>translation management</category>
            <category>xliff</category>
            <category>developer</category>
            <enclosure url="https://simplelocalize.io/blog/manage-xliff-translation-files.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[How to choose a TMS for your SaaS startup]]></title>
            <link>https://simplelocalize.io/blog/posts/how-to-choose-tms-for-saas-startup</link>
            <guid>https://simplelocalize.io/blog/posts/how-to-choose-tms-for-saas-startup</guid>
            <pubDate>Tue, 02 Dec 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Expand your SaaS globally with ease. Learn how to choose the right translation management system (TMS) for startups, with checklists and real-world examples.]]></description>
            <content:encoded><![CDATA[Launching a SaaS product globally used to be something only mature companies could do. Today, even a small team with a lean stack can reach thousands of users across different countries, if they localize early and choose the right translation workflow.

But here's the tricky part: What localization setup is right for your stage of growth?
Should you start with spreadsheets? Jump straight to a translation management system (TMS)? Or mix automation with manual processes?

This guide teaches startup teams how to choose the right TMS, without overpaying, over-engineering, or creating technical debt that hurts you later.

Why early SaaS teams struggle with localization

If you're a founder, engineer, or product owner in a growing SaaS company, the story usually looks like this:

You start with one language (often English) to validate your idea quickly.

Then you notice signups from Germany, Spain, Poland, Japan…

Support tickets pile up asking for local versions.

You add “Localization” to the roadmap; somewhere between “Improve onboarding” and “Fix billing.”

You try to manage translations in spreadsheets, then JSON files, then Git branches.

It works… until it doesn't.

At some point, the pain becomes clear:

strings get lost,

translations are not accurate or consistent,

translators ask for context repeatedly,

translations are out of sync with the product,

the UI breaks in languages with long text,

and deployment slows down because translations aren't ready on time.

This is the moment a startup begins looking for translation management options.

Step 1: Understand whether you actually need a TMS yet

Not every SaaS startup needs a full-fledged TMS from day one. Here's a quick diagnostic:

You probably DON'T need a TMS yet if:

You support only one new language.

Your UI has fewer than ~300 strings.

You ship updates monthly or less often.

You don't expect user growth from non-English markets yet.

In those cases, a simple spreadsheet or static JSON/YAML files may work fine.



You probably DO need a TMS if:

You're adding 2+ new languages.

Translators work outside your dev team.

Strings change weekly or daily.

You have different contributors (PMs, engineers, translators, contractors, community members).

You want to avoid slowing down releases.

You plan to expand into new markets this year.

This is where a TMS becomes not a luxury, but a growth enabler.

Step 2: Focus on startup-relevant TMS features (not enterprise ones)

Enterprise localization tools promote features like SSO, legal compliance workflows, role hierarchies, audit logs, multi-team departments, and localization procurement integrations.

These are great—for enterprise. But for a startup, they add complexity and cost without much benefit.

Here are the features that actually matter for early SaaS teams:

Fast onboarding with minimal setup

You should be able to:

import your language files,

connect your repo,

and invite translators

...without reading a 40-page manual.

If the setup takes more than 20 minutes, it's not startup-friendly.

Importing translations to SimpleLocalize's Editor

Support for the file formats your devs already use

Most SaaS startups use:

JSON

YAML

i18next

Next.js / React Intl

Flutter ARB

iOS .strings

Android Strings

Your TMS should support all of these out of the box with no transformations required.



Automation that removes repetitive work

This is where early-stage teams save a lot of time:

automatic import/export

translation hosting or CDN

CLI for CI/CD pipelines

webhooks or Git sync

machine translation suggestions

translation review and auto-translation automation

You don't need enterprise workflow builders, just automation that keeps translations in sync with your product.

Context tools so translators don't guess

Your biggest startup localization risks:

broken UI

incorrect text

misunderstood intent

inconsistent terminology

Context tools like screenshots, descriptions or in-context editor reduce these mistakes.

Sample translation with context

Affordable pricing that scales with you

Startups rarely have a localization budget.

Look for:

per-project or per-string/translation key pricing

no “per-seat” charges

ability to grow gradually

predictable limits

Expensive LSP-oriented tools aren't built for startups.

Learn more about difference between strings and translation keys

Step 3: Choose a TMS that can grow with you

A startup needs something that works now, but also:

handles more languages later

integrates with automation (CI/CD)

adds collaboration features as your team grows

and doesn't break your product when scaling to higher volumes

This is not the same as choosing an enterprise system from day one.

Think of it like choosing a database:
You don't need a huge distributed system with sharding to store your first 10,000 rows, but you do want something that won't require a full rebuild later.

Real-world example: How a young SaaS company expanded using a lightweight TMS

A good example is Automa.Net, a fast-growing industrial-automation marketplace founded in 2021. As they expanded across Europe, they needed to support many languages early on and keep translations consistent without slowing product development.

Instead of building a heavy enterprise workflow, they adopted a simple translation management setup with SimpleLocalize that:

let non-technical team members handle translations,

automatically updated new keys,

and scaled easily as they added more languages.

This kind of approach works perfectly for startups: minimal overhead, fast integration, and the flexibility to grow from a few languages to many as the product gains traction.

Step 4: Decide whether you need machine translation + human review

For startups, the most efficient workflow is often:

Auto-translate new strings

Have translators review important UI or marketing content

Ship fast, iterate fast

This hybrid approach gives:

speed

cost-efficiency

good-enough quality for early product stages

You can switch to fully manual translations later as you grow.

Learn more about automating auto-translation and review workflows in SimpleLocalize.

Step 5: Create a localization workflow that doesn't slow you down

Once you pick a TMS, set up a lightweight workflow such as:

Developer adds/updates strings
→ Files sync automatically with the TMS.

Translators (or community contributors) translate
→ They see context and screenshots.

Review only high-impact content
→ onboarding flows, landing pages, pricing pages.

TMS pushes translations to production
→ Through API, CLI, or CDN.

Developer keeps shipping without waiting
→ Continuous localization, not bottlenecks.

CI/CD workflow after translation changes

Check more examples of AI powered localization workflows.

Checklist: Is this the right TMS for my startup?

Use this as a final filter. Your TMS should:

\[ ] support your file formats natively

\[ ] import your project in under 10 minutes

\[ ] enable automation without DevOps headaches

\[ ] allow translators to work without Git

\[ ] provide MT + translation memory

\[ ] provide affordable pricing for early-stage teams

\[ ] scale to more languages without breaking your workflow

\[ ] avoid heavy enterprise features you don't need yet

If the answer is “yes” to most of these, you're choosing the right tool.

Check our list of best TMS for SaaS.

Conclusion: The right TMS helps startups move faster, not slower

Choosing a translation system for a SaaS startup is really about answering one question:

“How do we ship features fast, expand globally, and avoid creating a localization mess we'll regret later?”

A good TMS like SimpleLocalize gives you:

speed

structure

scalability

better UX for global customers

Without the cost, complexity, and enterprise baggage you don't need yet.
Start small, think big, and localize smartly. Your global users are waiting!
]]></content:encoded>
            <category>software localization</category>
            <category>translation management</category>
            <category>SaaS</category>
            <category>startup</category>
            <enclosure url="https://simplelocalize.io/blog/tms-for-saas-startup.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to manage translations in CSV files: Best practices, examples & workflow]]></title>
            <link>https://simplelocalize.io/blog/posts/managing-translations-in-csv-files</link>
            <guid>https://simplelocalize.io/blog/posts/managing-translations-in-csv-files</guid>
            <pubDate>Thu, 27 Nov 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Manage translations in CSV files with SimpleLocalize. Learn CSV formats, workflows, and best practices to simplify localization for apps and websites.]]></description>
            <content:encoded><![CDATA[If you've worked on a multilingual product for more than a week, you know the pattern: the team starts adding languages, new features arrive, product copy changes, marketing wants their own translations… and suddenly your translation files look like an overgrown garden.

For many teams, CSV is often the first localization format they turn to, and for good reason. It's simple, universally supported, and easy to edit. But managing translations in CSV files well takes some structure, a few smart decisions, and the right tools to keep everything organized.

In this guide, we'll explore how to build a clean, scalable CSV-based translation workflow using SimpleLocalize, plus examples, use cases, pitfalls, and professional tricks that teams learn only after years of localization work.

Why CSV is still a great format for translation workflows

CSV (Comma-Separated Values) format isn't fancy, and that's its biggest strength. It's:

readable by humans

understood by every spreadsheet program

easy to import/export

lightweight and version-control friendly

perfect for non-technical translators

More importantly, CSV supports a columns = languages structure that closely matches how humans actually think about translations.

Columns as languages in CSV

But the real advantage? CSV enables collaboration without requiring translators to know JSON, YAML, or any framework-specific syntax. This makes it ideal for:

marketing teams

contractors or freelancers

external localization agencies

early-stage startups

cross-department product teams

When combined with a translation management platform like SimpleLocalize, CSV becomes even more powerful. It becomes the foundation of a structured, trackable localization workflow.

What a good CSV translation file actually looks like

A lot of teams assume “CSV = simple,” so they throw a few columns together and hope for the best. But a clean structure is what keeps translations from becoming chaos.

Here's a realistic CSV structure that scales:

This is the minimal version: just keys and languages, perfect for smaller apps.

But as your app grows, you'll appreciate having context:

Descriptions give translators clarity without needing access to your UI. Namespaces keep things organized without splitting files too early.

This is where CSV beats JSON for collaboration: translators don't have to dig through a nested tree of objects.

A realistic CSV-to-translation workflow

Here's a step-by-step workflow that many SimpleLocalize users follow to manage translations in CSV files:

CSV translation workflow

Start by extracting all UI text into keys

Developers add something like:

to the codebase instead of hardcoding strings.

Build the initial CSV file

Generated either manually, via scripts, or exported from existing formats.

CSV structure example

Upload it to SimpleLocalize

From here, your CSV becomes a collaborative resource, not just a file.
Translators get a clean interface; developers still keep CSV in Git.

Uploading CSV to SimpleLocalize

Translate internally or externally

In-house translators, agencies, freelancers, or auto-translation (DeepL, Google, OpenAI) are all supported without changing the workflow.

Review and validate

Using SimpleLocalize's built-in QA checks and review system, you can ensure quality before pushing changes live. Check:

missing variables

inconsistent punctuation

untranslated strings

duplicates

Export into your desired format

SimpleLocalize lets you export back into:
CSV
JSON
YAML
iOS / Android formats
gettext
…and more.

Check all supported formats here.

Commit to Git and deploy

CI/CD picks it up → your app gets updated translations. Use SimpleLocalize's CLI or API for automation, or integrate directly with GitHub for seamless updates.

CI/CD workflow

This flow is simple, human-friendly, and doesn't require adopting a complicated localization pipeline.

Practical use cases where CSV is the best choice

CSV isn't for everything, but for many workflows, it's exactly right.

Early-stage products. Small teams don't need a huge localization system. A single CSV file + SimpleLocalize = perfect setup.

Marketing & website translations. Marketing teams live in spreadsheets. Let them. Export CSV → translate → upload → done.

Onboarding freelance translators. No JSON. No XML. No YAML. Just a familiar spreadsheet.

Projects with lots of short UI strings. When you have hundreds or thousands of small strings, CSV's flat structure shines. CSV works beautifully for lists of button labels, titles, navigation items, settings, and short messages.

Bulk editing and mass language additions. Need to add 12 new languages? CSV makes it trivial, especially with auto-translation.



Common pitfalls and how to avoid them

CSV is great, but you need to treat it right. Here are some common mistakes teams make:

Multiple CSV files with overlapping keys

This causes merge conflicts and loss of context.

Fix: use namespaces or keep one main file.

Inconsistent key naming

loginTitle vs. login.title vs. titleLogin.

Fix: define a naming convention early and stick to it.

Learn more about best practices for naming translation keys here.

Broken variables

Translators sometimes change {value} into something like {valor}.

Fix: use SimpleLocalize's validation tools to catch these issues before deployment.

Descriptions missing

Translators get confused without context which leads to poor translations and rework.

Fix: always add a description column for UI strings.

Encoding issues

Saving in non-UTF-8 corrupts special characters like ñ, é, ü.

Fix: enforce UTF-8 (SimpleLocalize handles this automatically).

When CSV starts to hit limits and what to do next

CSV works for:

up to ~5–10 languages

up to a few thousand strings

flat, non-nested translations

Beyond that, you may start to feel the pain:

performance slows down

managing context becomes harder

complex formatting (ICU, plurals) gets tricky

If your app becomes highly complex (e.g., ICU messages, plural rules, structured content), you may eventually switch your app format to JSON or YAML.

Learn more about managing translations in JSON and YAML.

Good news: You can still keep CSV as your “human collaboration format” and export JSON/YAML just for the app build. This hybrid approach is common and recommended.

How SimpleLocalize makes CSV translation enjoyable

Without tooling, CSV can become messy. With SimpleLocalize, it becomes your superpower.

Key benefits:

Spreadsheet-like editor: anyone can translate, no CSV formatting mistakes.

Auto-translation: bulk translate CSV content using DeepL, Google Translate, OpenAI or OpenRouter with one click. Great for adding new languages with minimal effort.

History & versioning: track changes, revert mistakes, see who did what and collaborate safely.

Comments & discussion: translators can ask questions right next to the string.

Validation: catch missing variables, inconsistent formatting, duplicates.

Export to any format: CSV → JSON, YAML, iOS, Android, PO, XML, etc.

CI/CD integration: automate pulling updated translations into your app.

By combining CSV's simplicity with SimpleLocalize's power, you get the best of both worlds: human-friendly collaboration and developer-friendly integration.

Conclusion: CSV is simple, and that's why it works

CSV isn't the trendiest format.
It's not exotic.
It doesn't try to be clever.

But that's exactly why it continues to be one of the most effective ways to manage translations, especially for teams that want clarity, flexibility, and a collaboration-friendly workflow.

When paired with a platform like SimpleLocalize, CSV transforms from a basic file format into a robust localization solution that scales with your product. It becomes:

structured

scalable

safe

automation-friendly

translator-friendly

developer-friendly

Whether you're building a small app or preparing to ship in 20 languages, CSV is a solid foundation, and SimpleLocalize helps keep everything organized while giving your team a toolset that grows with your product.

FAQ

Can I use CSV as the main translation format for my app?

Yes, many projects rely on CSV as their central translation format because it's simple, easy to edit, and widely supported. For production apps, you can still use CSV for collaboration, and export to JSON, YAML, iOS, Android, or other formats required by your framework.

What's the difference between " and ” in CSV files?

Both are used to denote text strings. However, " (straight quotes) are standard in CSV files, while ” (curly quotes) are typographic and may cause parsing issues. Always use straight quotes in CSV files.

How do I collaborate with translators using CSV?

You can:

share the CSV directly (Excel, Google Sheets)

upload it to a platform like SimpleLocalize

let translators work in an editor optimized for localization

export updated translations back to CSV
This avoids formatting mistakes and allows better tracking.

How do I prevent duplicates in CSV translation files?
Use unique, consistent keys. Platforms like SimpleLocalize also detect duplicates automatically.
]]></content:encoded>
            <category>software localization</category>
            <category>csv</category>
            <category>translation management</category>
            <category>developer</category>
            <enclosure url="https://simplelocalize.io/blog/translations-in-csv.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[What is pseudo-localization? A practical guide for localization testing]]></title>
            <link>https://simplelocalize.io/blog/posts/pseudo-localization-guide</link>
            <guid>https://simplelocalize.io/blog/posts/pseudo-localization-guide</guid>
            <pubDate>Tue, 25 Nov 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn what pseudo-localization is, why it matters, and how to use it to catch localization issues early. Practical examples and tips for pseudo-localization.]]></description>
            <content:encoded><![CDATA[If you've ever launched a global product or app, you know that localization can get tricky very fast. One small translation issue can lead to broken layouts, unreadable UI, or confusing customer experiences.

Before you even think about sending strings to translators, there's a powerful technique that can save you from a long list of internationalization headaches: pseudo-localization.

In this guide, we'll walk through what pseudo-localization is, why it matters, and how teams use it to ship global-ready products with confidence.

TL;DR: Pseudo-localization transforms text to test UI layouts, placeholders, and encoding before real translations. Use it early in development, simulate text expansion, RTL, and accented characters, and always complement with real translations for final QA.

What is pseudo-localization?

Pseudo-localization (also known as pseudolocalization or pseudo-translation) is a testing technique where your app's text is replaced with artificially modified versions that mimic real translations. Instead of translating "Book now" button text into dozens of languages, pseudo-localization might turn it into:

Book now > \[!!! ßööķ ŉøŵ !!!]

The modified text includes special characters, accents, extra length, and different writing patterns before actual translations come in. This simulates how real translations will look and behave in the UI.

Pseudo-localization is not about translating content for users. It's about testing your app's ability to handle different languages and scripts early in the development process.

Why pseudo-localization is so effective

Here's what a good pseudo-localization test can do for your localization efforts:

Detect text expansion problems

Some languages expand or contract text length significantly:

English to German: +30%

English to French: +20%

English to Spanish: +25%

English to Chinese: -30%

Percentages vary by context, but these are common averages for UI strings.

Text length example in different languages

If your “Login” button barely fits in English, a pseudo-localized version like “Łôğįññññ” will immediately show you if the design needs flexibility.

Reveal character encoding issues

Characters like ç, ñ, ś, ø, ł, β, д, 你 can quickly show whether your fonts and components support Unicode properly. If your pseudo-localized text displays correctly, you're likely in good shape for real translations.

Identify hard-coded or missing strings

If “Guest” shows as “Guest” instead of “Ǥűëšţ” in pseudo-localization, that's a red flag; it means the word is hard-coded and won't be translated in real languages either.

Test layout adaptability

If your pseudo-localized text includes mirrored characters or RTL markers (like Unicode RTL override characters), you can check whether your layout adapts correctly for languages such as Arabic or Hebrew.

Validate placeholders and variables

Pseudo-localization reveals broken placeholders and malformed interpolation patterns. If you see Welcome, {userName}! turn into Wëłçőmę, {userName}!!!, you know your placeholders are intact.

Save time before translations begin

Teams don't have to wait for actual translations to uncover major problems. You can catch most issues in development or staging.

Examples of pseudo-localization in action

Here are some simple examples to illustrate common issues it helps uncover:

Example 1: Button text overflow

Original: Submit

Pseudo-localized: Šûƀmįţţţţ

If the button suddenly stretches or text spills outside, you've found a UI constraint that needs fixing.

Button overflow example

Example 2: Broken labels or icons

Original: Search

Pseudo-localized: Šęåŗčĥħħ

If icons shift or alignment breaks, your design wasn't ready for longer text.

Broken label example

Example 3: Missing translations

If your UI shows mostly transformed text but one element still appears as Next, it's likely hard-coded or missing from your localization files.

Missing translation example

Example 4: Placeholder issues

Original: Hello, {userName}!

Good pseudo-localized result: Hęłłő, {userName}!!!

Bad pseudo-localized result: Hęłłő, {user name}!!! (placeholder broken)

The placeholder changed shape (a space appeared), meaning the pseudo-localization process mistakenly modified it. This indicates that your placeholder format isn't properly protected or escaped.

Placeholder issue example

Pseudo-localization exposes these problems instantly.

How to implement pseudo-localization in SimpleLocalize

SimpleLocalize treats pseudo-localization like any other language, which keeps your workflow clean and predictable. You simply create a pseudo-localization language inside your project and use it just like any other language, but exclusively for testing.

Here's how SimpleLocalize makes the process smooth and flexible:

Create a pseudo-language in seconds

You can create a custom language like “Pseudo (accented)”, “Pseudo (expanded)”, “Pseudo (RTL simulation)”. This keeps your testing strings organized and makes it easy for developers to switch between real and pseudo-localized versions.

Languages list with pseudo-localization language

Catch issues automatically (placeholders, missing keys, hard-coded text)

SimpleLocalize highlights issues like placeholder mismatches automatically via automated QA checks.
It checks placeholder integrity so pseudo-localization never accidentally modifies variables. This is one of the fastest ways to catch i18n bugs.

Placeholder validation in SimpleLocalize

Learn more about QA in localization projects.

Integrate with your stack

No custom tools required. SimpleLocalize integrates with GitHub, CLI, CDN delivery, API, translation files in your repo, and more.

That means you can load the pseudo-localized language into your local environment or staging app just like any other language.
Switching languages during development instantly reveals issues like overflow, alignment bugs, or broken fonts.

Use multiple pseudo strategies

You can create more than one pseudo-local language to test different types of scenarios, for example:

Pseudo-expanded: +40% text length

Pseudo-accented: Unicode characters

Pseudo-symbolized: additional brackets or delimiters

Pseudo-RTL: simulating right-to-left directionality

This allows you to stress-test your UI against several potential translation challenges.

Preview pseudo-localization live

With SimpleLocalize's In-context Editor, you can see pseudo-localized text directly in your running application. This gives you a real-time view of how layouts adapt and whether any issues arise during actual usage.
It's a great way to validate your localization readiness in a live environment without deploying separate builds.

Common pseudo-localization mistakes

While pseudo-localization is straightforward, here are some pitfalls to avoid:

Relying solely on pseudo-localization. It's a great first step, but real translations can still reveal unexpected issues.

Over-testing with too many decorative characters (unrealistic). Keep it believable to simulate real-world scenarios.

Ignoring mobile or responsive views. Always test across different screen sizes.

Not protecting placeholders before transformation. Ensure your pseudo-localization tool respects variable syntax.

Assuming pseudo-RTL is a perfect substitute for true RTL testing. Always validate with real RTL languages later.

Best practices for pseudo-localization

Here are some simple ways to get the most out of pseudo-localization:

Include accented and extended characters. This reveals font and rendering problems.

Simulate text expansion. Add 20-40% extra length to see if layouts adapt.

Test early, preferably in CI/CD. Catching issues in development is far cheaper than fixing them after translations.

Try an RTL pseudo-localization pass. If you plan to support Arabic or Hebrew, simulating RTL early helps avoid layout surprises.

Don't forget mobile views. Small screens reveal problems faster than desktop.

When NOT to use pseudo-localization

Pseudo-localization is a great early testing tool, but it's not suitable for every scenario:

Final translation QA: It cannot check grammar, meaning, or cultural accuracy.

Production environments: Never show pseudo-localized text to real users.

Non-text elements: Images, icons, or multimedia need separate testing.

Performance testing at scale: Real translations give more accurate results.

Overuse: Use it early in development—not repeatedly at later stages.

Conclusion

Pseudo-localization is simple to enable, fast to run, and incredibly powerful. It helps teams:

fix UI issues before they become expensive

detect missing or hard-coded strings

ensure layouts are translation-proof

build truly international-ready products

Pseudo-localization doesn't replace real translations — it ensures you're ready for them.

With tools like SimpleLocalize, integrating pseudo-localization into your development process takes minutes, but saves hours (or days) of debugging later.

Learn more

SimpleLocalize documentation

UI tips for localization

Step-by-step localization workflow for developers

Localization tips and tricks

AI-powered localization workflows

FAQ

Are extra characters like ⟦✦✦⟧, ⟦⟡⟧, ⟦★⟧ necessary in pseudo-localization?

Extra characters are optional visual markers. They help quickly identify pseudo-localized text in the UI, making it obvious which strings are being tested. However, they aren't strictly necessary if your pseudo-localization already includes accents or length changes that stand out.

The benefits of including such characters are:

They highlight the string boundaries

Increase visual length

Make it clear the text is pseudo-localized

How are texts pseudo-localized?

Pseudo-localization typically involves automated tools that transform your original strings by:

Adding accents to letters (e.g., "a" becomes "á", "e" becomes "é") for Unicode testing

Expanding text length by inserting extra characters or repeating letters

Inserting extra characters or brackets around the text for visibility

Simulating RTL directionality by reversing text order or adding RTL markers

Why should we use pseudo-localization before real translations?

Pseudo-localization catches UI issues, placeholder problems, and encoding errors early, saving time and cost. It ensures your app can handle text expansion, special characters, and RTL layouts before sending strings to translators.

How do I handle placeholders in pseudo-localized strings?

Ensure your pseudo-localization tool respects variable placeholders like {userName} or %s. Some tools may accidentally alter them, which can break your UI or code if not protected.

When should I run pseudo-localization tests?

Ideally, early in development, during UI design, and integrated into CI/CD pipelines. Testing early avoids costly fixes later.

Can pseudo-localization handle multiple languages at once?

Typically, pseudo-localization uses a single “pseudo-language,” but you can create multiple variants to simulate text expansion, RTL, or accented characters for different scenarios.

Does pseudo-localization affect performance?

Usually minimal. It only transforms text for testing, but if applied in production environments unnecessarily, it could slightly increase rendering time.
]]></content:encoded>
            <category>software localization</category>
            <category>tips</category>
            <category>quality assurance</category>
            <category>ui</category>
            <enclosure url="https://simplelocalize.io/blog/pseudo-localization.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Never miss a translation update again: Notifications, Webhooks, and more]]></title>
            <link>https://simplelocalize.io/blog/posts/translation-update-notifications</link>
            <guid>https://simplelocalize.io/blog/posts/translation-update-notifications</guid>
            <pubDate>Fri, 07 Nov 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to track every translation update automatically in SimpleLocalize using notifications, webhooks, and the API to keep your localization team aligned.]]></description>
            <content:encoded><![CDATA[Keeping track of translation changes can be a real challenge when multiple people are working on the same localization project. Translators update strings, reviewers mark texts as needs review, and project managers try to stay in the loop, everything at once.

With SimpleLocalize, you can stay perfectly in sync with your project. Whether you prefer quick in-app notifications, email updates, or full automation through webhooks and the API, we've got you covered.

In this post, we will show you three simple ways to track translation updates, complete with real examples of how different teams use them.

1\. In-app and email notifications

SimpleLocalize notifications are perfect for translators and reviewers who want to know what's happening without constantly refreshing the project page.

You can get notified when:

A new translation is added

A translation is updated

A translation is marked as "needs review"

Besides, you get notifications about new comments, mentions, or new translation suggestions.

Notifications are sent to you via email, so you can act immediately even if you are not logged in. They ensure no translation sits unnoticed for days, improving turnaround time.

Notifications settings in SimpleLocalize

Use case examples

Translators receive an email when new strings appear in their assigned languages, helping them start translating right away. It's great for keeping up with fast-paced projects.

Translators get notified when a translation changes to Needs review, so they can quickly address any issues and ensure quality.

Reviewers are alerted when translations are updated, allowing them to re-evaluate and approve the changes promptly.

Project managers get notified when a translation is marked as Needs review, allowing them to follow up with the relevant team members.

Thanks to these notifications, everyone stays informed and can respond quickly to any translation changes.

Learn more about notification settings.

2\. Real-time updates with Webhooks

For teams that rely on external tools like Slack, Discord, Jira, or custom dashboards, webhooks are the key to seamless automation.

Webhooks let SimpleLocalize automatically send an event whenever something important happens in your project, for example, when translations change, are imported, exported, or auto-translated. It eliminates manual status checks, saving hours of coordination.

Webhook settings in SimpleLocalize

Use case examples

Send a Slack, Discord or Microsoft Teams message when there is any translation update, so your team can stay informed without leaving their communication tools.

Log all updates in an internal dashboard to track activity across projects.

Track all translation changes in Jira. When someone edits a translation, SimpleLocalize can trigger a webhook and send that info to Jira. You can set up an automation (for example, in Zapier or Make) that creates a new Jira issue.

Trigger deployment or QA checks after publishing. When you publish new translations, SimpleLocalize can automatically notify your CI/CD pipeline, or ping your QA team.

Learn more about setting up webhooks.

3\. Build custom workflows with the API

If your organization has unique needs, the SimpleLocalize API gives you full flexibility.
You can fetch project activity, translation keys with review statuses, or other metadata; and integrate that data with your internal systems.

SimpleLocalize API documentation

Use case examples

Create a custom reporting tool that tracks translation changes and generates reports for stakeholders.

Build a custom dashboard highlighting all keys that are currently marked as Needs Review.

Integration with a CI/CD pipeline to ensure all translations are reviewed before deployment.

Browse all available endpoints and event types in the SimpleLocalize API documentation.

Combine methods for maximum efficiency

These three methods work even better together:

In-app & email notifications keep translators up to date.

Webhooks alert your whole team automatically in other tools.

API integrations give project managers full control and insights.

Together, they create a powerful workflow where no translation update goes unnoticed.

Conclusion

Staying on top of translation changes is crucial for any localization project. With SimpleLocalize's notifications, webhooks, and API, you can ensure that everyone involved is always in the loop.

Whether you prefer email alerts, Slack messages, or automated reports, SimpleLocalize makes sure you never miss a translation update again.

Ready to stay in sync? Log in to SimpleLocalize and enable notifications or webhooks today; your team will never miss a translation update again.
]]></content:encoded>
            <category>software localization</category>
            <category>translation management</category>
            <category>webhooks</category>
            <category>tutorial</category>
            <enclosure url="https://simplelocalize.io/blog/translation-update-notifications.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Translation Keys vs Strings]]></title>
            <link>https://simplelocalize.io/blog/posts/translation-keys-vs-strings</link>
            <guid>https://simplelocalize.io/blog/posts/translation-keys-vs-strings</guid>
            <pubDate>Thu, 30 Oct 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[What is the difference between translation keys and strings? Learn what is the difference and how to calculate your project size in SimpleLocalize.]]></description>
            <content:encoded><![CDATA[What is the difference between translation keys and strings? This question we get very often from our users.
Sometimes people confuse these two terms, especially when it comes to calculating project volume in SimpleLocalize.

Translation keys vs Strings and Languages

Strings

Strings are the actual pieces of text that need to be translated in your application or website.
They can be anything from a single word, like "Submit," to longer phrases or sentences, such as "Please enter your email address to continue."

Watchout, some services may refer to strings as "words", but in SimpleLocalize, we use the term "strings" to represent the individual text elements that require translation.

Translation keys

Translation keys, on the other hand, are unique identifiers that represent these strings in your codebase.
They act as placeholders for the actual text and are used to reference the strings in your translation files.

For example, instead of hardcoding the string "Submit" directly into your code, you would use a translation key like BUTTON.SUBMIT.
This way, when you need to display the "Submit" button in different languages, you can simply look up the translation for the BUTTON.SUBMIT key in your translation files.

For technical users familiar with JSON files, here's an example to illustrate the difference:

In this case, there is 1 key (BUTTON.SUBMIT) and 3 strings (one per language). So when we say "unlimited strings", it means you can have as many translations and languages as you need, but the number of unique keys (i.e. distinct phrases to translate) may be limited depending on your plan.

How to estimate translation keys?

It's simple, if you know the number of strings and number of languages in your projects, you can calculate the number of translation keys.

Example

If your project has 100 strings and supports 5 languages, the number of translation keys would be:
Translation keys = 100 strings / 5 languages = 20 translation keys

It can be even simpler if you know the number of strings for your source language only (e.g. English).
In such case, the number of translation keys is equal to the number of strings in your source language.

What if you would like to add a new language to your project in the future?

It won't affect your project size, as the number of translation keys will remain the same.

Where is the catch?

There is no catch, this is how we count project size is very straightforward, and encourages you to use as many languages as you want without worrying about increasing your project volume.
This approach allows you to focus on providing a great user experience in multiple languages without being concerned about the cost implications of adding more languages to your project.

Can I increase my translation keys limit?

Yes, and you can do it without changing your plan. If you reach your translation keys limit, you can simply purchase an additional pack of translation keys to increase your limit.

Next steps

Ready to get started with SimpleLocalize? Sign up today and start managing your translations! Import your translation keys with existing translations to SimpleLocalize by following our getting started guide.
]]></content:encoded>
            <category>product</category>
            <category>pricing</category>
            <category>billing</category>
            <category>tutorial</category>
            <enclosure url="https://simplelocalize.io/blog/translation-key-vs-strings.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[Tips for effective auto-translation in software localization]]></title>
            <link>https://simplelocalize.io/blog/posts/auto-translation-tips</link>
            <guid>https://simplelocalize.io/blog/posts/auto-translation-tips</guid>
            <pubDate>Mon, 13 Oct 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Check out our tips for effective auto-translation in software localization using SimpleLocalize. Learn how to set up your project for best auto-translation results.]]></description>
            <content:encoded><![CDATA[Auto-translation has become an essential tool in modern software localization. It helps to speed up the translation process and reduce costs. However, to get the best results from auto-translation, it's important to follow some best practices. Here are our tips for effective auto-translation in software localization using SimpleLocalize.

Set your default (source) language

Setting a default language is the biggest factor for auto-translation to work effectively. It helps the system understand which language to use as the source for machine translation. The default language should be the one that is most complete and accurate, as it will serve as the basis for translating into other languages.

In SimpleLocalize, you can set your default language in the project settings (edit language in the Languages tab).

Set default language

Use review statuses

Review statuses play a key role in managing translation quality and workflow, and they also help the system decide which translations should be used as the source for auto-translation.

By marking translations as Reviewed, you signal that these strings are accurate and contextually clear, allowing the system to use them as reliable reference points. Meanwhile, Needs review status indicates that a translation is still evolving and may be safely updated by auto-translation.

Translations with accepted review statuses

Learn more about review statuses in SimpleLocalize.

Add descriptions

Machine translation engines perform much better when they understand the context of a string.

Descriptions help AI models like OpenAI, OpenRouter, and DeepL produce more accurate and natural translations by providing contextual clues (e.g., UI button text vs. error message).

In SimpleLocalize, you can add descriptions to keys that explain where and how the text will appear in your app. Use the key details panel to add descriptions.

Translation key with description

Tip: Short labels such as “Save,” “Close,” or “Cancel” can have multiple meanings and be translated using different forms. Adding a description like “Button label for saving user profile” can make all the difference.

Use system prompts and project context

For AI-based translators (OpenAI, OpenRouter, DeepL), you can define system prompts or project contexts to guide translation style and tone. For example:

These settings help maintain a consistent voice across your product, especially if multiple translators or AI models are involved.

You can configure the system prompt (OpenAI, OpenRouter) or project context (DeepL) in the project settings under the Auto-translation tab. Click on the Configure button next to the selected provider and add your prompt or context.

Auto-translation settings with project context

Maintain consistency with DeepL glossary

Terminology consistency is vital in software localization, and glossaries make it easy. A glossary defines key terms (like product names, feature names, or common UI labels) that should be translated in a specific way.

In SimpleLocalize, you can create and manage glossaries directly in the platform. When using DeepL for auto-translation, the system will reference your glossary to ensure that specified terms are translated consistently across all languages.
For example, you can specify that:

“Workspace”: always translated as “Espace de travail” (not “Bureau”)

“Pillow Hotel”: always kept in English

DeepL glossary example

Learn more about DeepL glossary in SimpleLocalize.

Choose the right provider and model

Not all translation engines are created equal. Here's how to get the best from each:

OpenAI: Use GPT-4.1 for the most accurate translations. It's slower than smaller models (like “mini” or “nano”) but delivers higher quality and better contextual understanding.

DeepL: Ideal for European languages, with excellent support for glossaries and style preferences.

Google Translate: Great for fast, general-purpose translations.

OpenRouter: Allows fine-tuning model selection and system prompts for advanced control and power users.

Check out our list of auto-translation providers and models to choose the best fit for your project.

Handle variables and placeholders correctly

Auto-translation tools like DeepL and Google Translate may sometimes attempt to translate variables (like {username} or %s). SimpleLocalize can detect and protect these variables during auto-translation to prevent them from being altered,
by applying special filters while maintaining their correct placement in the text and meaning of the sentence. You can adjust variable recognition settings in the project settings under the Auto-translation tab.

LLM-based translators like OpenAI have built-in variable recognition in SimpleLocalize, and they do not require additional settings.

Learn more about variables and phrases exclusion in auto-translation.

Disable auto-translation for specific keys or languages

In some cases, you may want to disable auto-translation for specific keys or languages. For example, if a key contains sensitive information or if a language is not well supported by the chosen translation engine.

To disable auto-translation for specific keys, right-click on the key in the translation editor and select Manage key. Then, toggle on the Disable auto-translation option.

Disable auto-translation for specific key

To disable auto-translation for specific languages, go to the Languages tab in the project settings and click on the language you want to edit. In Translation provider section, select Disabled from the dropdown.

Use QA checks to verify translations

Auto-translation is a great starting point for drafts and pre-translations, but human review remains essential.

SimpleLocalize's built-in QA checks automatically flag potential issues like missing variables, inconsistent terms, or empty translations, saving you time and ensuring quality before release.

QA checks example

Learn more about QA checks in SimpleLocalize.

Report incorrect translations

If you spot an inaccurate QA issues, don't hesitate to report them via email on our Discord chat. We use user feedback to continuously improve our AI models and translation suggestions.
Your input helps make auto-translation more accurate for everyone.

Conclusion

Auto-translation can dramatically speed up your localization process when used correctly.
By setting your default language, adding context, maintaining glossaries, and using review statuses, you can get the most out of SimpleLocalize's auto-translation features, with high-quality results and minimal rework.

Get started at simplelocalize.io and see how auto-translation can transform your localization workflow!
]]></content:encoded>
            <category>software localization</category>
            <category>tutorial</category>
            <category>auto translation</category>
            <category>tips</category>
            <enclosure url="https://simplelocalize.io/blog/auto-translation-tips.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[What is localization QA? Definition, benefits & best practices]]></title>
            <link>https://simplelocalize.io/blog/posts/what-is-localization-qa</link>
            <guid>https://simplelocalize.io/blog/posts/what-is-localization-qa</guid>
            <pubDate>Thu, 09 Oct 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn what Localization QA (LQA) is, why it's crucial for global products, and how tools like SimpleLocalize ensure accurate, functional, and culturally relevant translations.]]></description>
            <content:encoded><![CDATA[Ever seen a button on a website with text spilling out of it, or a date format so confusing you weren't sure if you'd booked for January or December? That's what happens when Localization QA gets skipped.

When you are growing your business internationally, translating your product is just the first step. What really makes or breaks the user experience is Localization QA (Quality Assurance), the process of making sure your product feels right for users in every market.

Skipping this step can lead to confusing, clunky, or even embarrassing results. But with the right approach and tools, like SimpleLocalize, you can make localization QA smooth, collaborative, and stress-free.

What is Localization QA?

Localization QA (often shortened to LQA) is the process of reviewing localized content inside the product itself to check:

Does the text fit properly in the design?

Is the translation accurate and natural in context?

Are dates, currencies, and units adapted to the local market?

Does the interface still work correctly after localization?

It's not just about correct grammar, but delivering a product that feels like it was created locally from the ground up.
Think of LQA as the final dress rehearsal before launching your product on the global stage.

Why is Localization QA important?

Let's look at some practical examples. Imagine you are translating a hotel booking website.

Example 1: The "Book Now" button in French becomes "Réserver Maintenant". If the button is too small, the text might overflow, making it hard to read or click.

QA fail example

Example 2: "Your stay includes breakfast" is translated by Google Translate to "W cenę pobytu wliczone jest śniadanie" in Polish. While accurate, a more natural phrasing would be "Śniadanie wliczone w cenę pobytu".

Unnatural phrasing example

Example 3: The date format "MM/DD/YYYY" is used in the US, but in Germany, it should be "DD.MM.YYYY". If this isn't changed, users might get confused about their booking dates.

Date format example

These small details can lead to big problems if not caught during Localization QA:

Text length issues. If the translated text is too long, it might break the layout, making buttons hard to click or text unreadable.

Overly literal translations. If the translation is too literal, it might sound awkward or confusing to native speakers.

Date and number formats. If formats aren't adapted, users might misinterpret booking dates, prices, or measurements, leading to frustration.

Broken functionality. If interface elements don't function properly after localization, users may encounter bugs or errors.

Cultural disconnects. If cultural references aren't adapted, users might feel the product is out of touch with their local context.

Visual elements. If images or icons aren't appropriate for the local culture, users might feel alienated or confused.

Device compatibility. If localized content isn't tested on different devices and screen sizes, users may have a poor experience on mobile or tablets.

How Localization QA is done

A typical LQA process involves:

Linguistic review: Making sure the translation is natural, consistent, and follows tone guidelines.

Functional testing: Checking if placeholders ({name}, %d, etc.) and plural rules work properly.

Visual/UI testing: Ensuring text isn't cut off or breaking layouts. For example, French tends to be ~20% longer than English, and German can be even longer.

Cultural review: Making sure images, colors, and references are appropriate. (For example, a US “mm/dd/yyyy” date format would confuse users in Europe.)

How SimpleLocalize helps with Localization QA

Managing all of this across spreadsheets, translators, and developers can quickly get overwhelming. That's where SimpleLocalize comes in.

With SimpleLocalize, you can:

Collaborate easily: Developers, translators, and QA testers work in one platform, reducing back-and-forth emails.

See translations in context: Preview them in your app or website to avoid guesswork (use in-context editor, add screenshots and descriptions).

Catch UI issues early: Ensure text length, placeholders, and RTL (right-to-left) languages like Arabic or Hebrew are handled correctly.

Automate checks: Validate placeholders, plural rules, and formatting before they cause bugs.

Track the review process: Leave comments and approve translations when ready.

Centralize your localization: No more scattered spreadsheets; all your translations live in one place.

Live QA checks in SimpleLocalize

Learn more about live automated QA checks and using review status in SimpleLocalize.

Best practices for effective Localization QA

To get the most out of your Localization QA process, keep the below tips in mind.

People

Involve native speakers: They can catch nuances, idioms, and cultural references that non-native speakers or machine translation might miss.

Engage with local communities: Whenever possible, gather input from real users in your target markets—nothing beats authentic feedback. Use our public suggestions feature to collect ideas and corrections from your user base.

Communicate and document clearly: Make sure translators, developers, and testers understand expectations. Document decisions and feedback to improve consistency over time.

Process

Plan for localization early: Integrate localization into your design (Figma plugin) and development process (check GitHub integration) from the start; this avoids costly layout fixes later.

Use a standardized QA checklist: Define what to check—text length, placeholders, date formats, tone, visuals, so nothing slips through the cracks.

Prioritize and iterate: Focus QA on your key markets first, gather feedback from users, and use analytics to refine future releases.

Technology

Test in context and on real devices: Always check how translations look and work within the actual product across different screen sizes, operating systems, and browsers.

Leverage technology: Tools like SimpleLocalize help streamline collaboration, automate format checks, and centralize translations so your QA process is faster and more reliable.

Automate where possible: Use automated tests to catch common issues like missing placeholders or formatting errors before they reach human reviewers.

Conclusion

Localization QA isn't just quality control, it's an investment in trust. When users feel at home in your product, they are far more likely to stay, recommend it, and come back.

By combining best practices with a translation management tool like SimpleLocalize, you can make QA faster, easier, and more reliable. The result? Happier users, smoother global launches, and a product that truly speaks your customers' language.

Ready to make localization QA a breeze? Try SimpleLocalize today and see how much easier managing translations can be.

FAQ

What is the difference between QA and Localization QA?

General QA (Quality Assurance) checks whether a product works correctly: functionality, performance, usability. Localization QA (LQA) focuses specifically on how well the product has been adapted to different languages and cultures, ensuring it feels natural for users in every market.

When should Localization QA be done?

LQA should be integrated throughout the localization process, not just at the very end. Early checks (in design and development) catch issues like text expansion or date formats before they become costly to fix. Final reviews should happen just before launch to ensure nothing slipped through.

Who is responsible for Localization QA?

It's usually a shared responsibility:

Translators ensure linguistic accuracy and tone.

QA testers check functionality and UI layout.

Developers handle placeholders, formatting, and technical aspects.

Product managers or localization managers coordinate the process.

What are the most common localization QA issues?

Text that's cut off or too long for buttons/menus

Literal translations that sound unnatural

Wrong date, time, or number formats

Missing or incorrect placeholders

Cultural mismatches in images, icons, or colors

Functionality bugs after localization

Inconsistent terminology across the product

Can automation replace human Localization QA?

Automation and live QA checks can catch technical issues like placeholder errors, missing translations, or wrong date formats. But only native speakers can judge naturalness, cultural appropriateness, and overall user experience. The best approach is combining automation with human review.

How does Localization QA improve user experience?

LQA ensures users don't stumble over confusing text, broken layouts, or awkward translations. A product that feels local builds trust, reduces errors, and increases user satisfaction, which directly impacts retention and conversions.

Do small startups really need Localization QA?

Yes. Even for small teams, LQA prevents embarrassing mistakes and support issues. Starting with basic checks and leveraging tools like SimpleLocalize helps scale QA as you expand to more markets.
]]></content:encoded>
            <category>software localization</category>
            <category>translation management</category>
            <category>quality assurance</category>
            <enclosure url="https://simplelocalize.io/blog/what-is-lqa.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Introducing: Quality Assurance checks]]></title>
            <link>https://simplelocalize.io/blog/posts/introducing-qa-checks</link>
            <guid>https://simplelocalize.io/blog/posts/introducing-qa-checks</guid>
            <pubDate>Wed, 24 Sep 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[QA checks are now available in SimpleLocalize! Quickly identify and fix common translation issues to ensure high-quality localization and improved localization workflow.]]></description>
            <content:encoded><![CDATA[QA checks are now available in SimpleLocalize! This new feature helps you maintain high-quality translations by automatically identifying common issues in your localization files.

What are QA checks?

QA checks are automated validations that scan your translation files for potential problems. They can detect issues such as:

Missing or incorrect placeholders

Inconsistent punctuation

Formatting errors

Inconsistent capitalization

Extra whitespace

HTML tag issues

Unicode problems

Length constraints

And much more...

In total, there are over 30 check types available, with more being added as we continue to improve the feature.

Quality Assurance is crucial in localization to ensure that translations are accurate, consistent, and professional. Poor-quality translations can lead to misunderstandings, damage your brand reputation, and negatively impact user experience.

With SimpleLocalize's QA checks, you can catch these issues instantly, saving time and effort in the review process.

How does it work?

QA checks run automatically for every change made to your translations, whether through the web interface, API, CLI, or integrations. SimpleLocalize analyzes the text and compares it against a set of predefined rules to identify potential issues.

Key details about QA checks:

They run on all translation updates, regardless of the source.

QA checks and AI-assisted fixes are available for all projects on paid plans.

They need a defined default language to function properly.

Option to ignore specific checks in your translations if needed.

You can run AI-assisted fixes for detected issues in bulk.

See instantly which translations have issues directly in the editor.

You can filter out translations with issues.

QA checks are disabled for missing translations, as missing translations are a separate concern and should be handled differently.

Show QA issues in the editor

Make sure to show Quality issues option in the editor settings to see issues directly in the translation interface. Also, in the List view, you can show a warning icon for translation keys in row details option.

Show QA issues in the editor

Click on the check icon next to a translation to see the list of detected issues. Each issue includes a description and the specific check that was triggered.

Translation issues example

Live issue highlighting

Whenever you edit a translation, QA checks run instantly, and any detected issues are highlighted in real-time. This immediate feedback helps you correct problems as you work, ensuring higher quality translations.

Live issue highlighting

Fix with AI

For each detected issue, you can use the AI-assisted fix option to automatically generate a corrected version of the translation. This feature leverages advanced AI to suggest improvements, saving you time and effort.

Fix with AI

Click on the warning icon in the translation key row to see the list of all issues and fix them in bulk.

Run QA checks

You can run QA checks manually from the Translations tab. Click on the editor options (three dots) and select Run quality checks. This will re-evaluate all translations in the project and update the issue statuses.

Run QA checks

Use this option for the initial scan of existing translations or if you want to re-check all translations after updating your content.

More to come

The QA checks feature is just getting started. We plan to add more check types, customization options, and reporting features in the future. Stay tuned for updates!

We hope you'll love this new feature as much as we do! Try it out today and let us know your feedback.
If you have any questions or need assistance, feel free to reach out to our support team.

Learn more about Quality Assurance checks in SimpleLocalize in our documentation.
]]></content:encoded>
            <category>tutorial</category>
            <category>software localization</category>
            <category>translation management</category>
            <category>product updates</category>
            <category>quality assurance</category>
            <enclosure url="https://simplelocalize.io/blog/introducing-qa-checks.jpeg" length="0" type="image/jpeg"/>
        </item>
        <item>
            <title><![CDATA[How to manage iOS translation files (.strings, .xcstrings, .xliff)]]></title>
            <link>https://simplelocalize.io/blog/posts/manage-ios-translation-files</link>
            <guid>https://simplelocalize.io/blog/posts/manage-ios-translation-files</guid>
            <pubDate>Wed, 24 Sep 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to manage iOS translation files (.strings, .stringsdict, .xcstrings, .xcloc, .xliff) effectively and improve your localization workflow with SimpleLocalize.]]></description>
            <content:encoded><![CDATA[Localizing your iOS app is essential if you want to reach users worldwide. But Apple gives you multiple translation file formats: .strings, .stringsdict, .xcstrings, .xcloc, and .xliff, and it's not always clear which one you should use, when, or how they work together.

In this guide, we will walk through each of the iOS localization formats, explain their differences, show examples, and share best practices. You will also learn how to manage them all in SimpleLocalize to simplify your workflow and keep translations consistent.

Why file format choice matters

iOS supports several file formats for localization, each designed for specific scenarios. The choice of file format can impact the ease of translation, the ability to handle complex linguistic features, and the overall efficiency of your localization workflow.

Choosing the right file format isn't just a technical detail:

Some formats support pluralization and device-specific variants, others don't.

Some formats carry metadata, comments, and translation states, which help translators.

Some are better for working with agencies or translation tools.

Apple is actively evolving which formats it recommends.

SimpleLocalize supports import, export, CLI, API for all major iOS localization formats, which enables automating sync with your builds.

Does Apple impose a specific format?

Apple doesn’t force you to use a single format, but there are defaults that depend on your tools and iOS version:

Historically (.strings + .stringsdict):

.strings files were the standard. If you localized a project in older Xcode versions, Apple generated Localizable.strings by default.

Pluralization was handled separately via .stringsdict files.

Today (.xcstrings):

Since Xcode 15, the default when you add a new localized string in the String Catalog editor is .xcstrings.

This format combines .strings and .stringsdict into a single structured file, with added support for metadata and translation state.

Exchange formats (.xcloc & .xliff):

.xcloc and .xliff are not default storage formats in your repo, they are used when exporting/importing translations for collaboration with agencies

In practice, Apple will load translations from any of these supported formats as long as the files are placed in the correct \*.lproj language folder inside your app bundle.

If your project contains only .strings, iOS will load them.

If it contains .xcstrings, iOS will load those.

You can use both formats side by side, which makes gradual migration possible.

Apple is clearly nudging developers toward string catalogs (.xcstrings), but older formats remain supported.

Comparison of iOS translation formats

Here's a summary of the main formats you'll see, what they support, and when to use them. Later sections deepen those details.

| Format        | Structure       | Plural support | Metadata / context| Best use case                              |
|-------------- |-----------------|--------------- |-------------------|--------------------------------------------|
| .strings    | Key-value pairs | No             | No                | Basic UI strings, small apps, legacy projects      |
| .stringsdict | XML             | Yes            | Limited           | Plurals, device-specific variants, complex text    |
| .xcstrings  | JSON-like       | Yes            | Yes (comments, state, variants)             | Modern projects, recommended going forward |
| .xcloc      | Catalog of .xliff + metadata   | Yes           | Yes               | Export/import full localization projects |
| .xliff      | Standard XML             | Yes            | Yes               | Collaboration with agencies, translators  |

.strings: The classic format

.strings files are simple key-value pairs:

About:

Plain text key-value pairs, e.g. "key" = "Translated text";

Stored inside \*.lproj folders (e.g., en.lproj/Localizable.strings).

Classic format for static strings in iOS / macOS.

Limitations:

No pluralization.

No metadata or context for translators.

No built-in device variants.

Use .strings if you are maintaining a legacy app or just need quick, simple localization.

SimpleLocalize support:

You can manage .strings files directly in SimpleLocalize:

Import/export .strings files straight from the translation editor.

Automate sync with the CLI, REST API, or set up a GitHub integration to keep translations in step with your repository.

Uploading and downloading .strings files in SimpleLocalize's translation editor

Check out our docs for more details regarding .strings support in SimpleLocalize.

.stringsdict: Handling plurals and variants

.stringsdict files are XML-based and support pluralization and device-specific variants:

About:

XML format that supports pluralization rules and device-specific variants.

Must be paired with a .strings file for non-plural text.

Usage:

For strings that vary depending on count (plural forms).

For device-specific versions (e.g. different wording or instructions on Mac vs iPhone).

SimpleLocalize support:

You can manage .stringsdict files directly in SimpleLocalize:

Import/Export: Fully supported. Upload .stringsdict files directly from the translation editor or via CLI/API.

In the translation editor, plural forms will be shown as separate translation keys (e.g. items_count.one, items_count.other).

.stringsdict file upload example

Check out our docs for more details regarding .stringsdict support in SimpleLocalize.

.xcstrings: The modern string catalog

.xcstrings files are JSON-like and combine the features of .strings and .stringsdict, with added metadata:

About:

Apple’s recommended format starting with Xcode 15.

JSON-like structure that replaces .strings + .stringsdict.

Supports pluralization, device variants, comments, and translation state.

Why use it:

Modern, structured, future-proof.

Easier to manage in Xcode's GUI.

Built-in support for plural forms and device variants.

SimpleLocalize support:

String catalogs are fully supported:

Import and export just one .xcstrings file per language or multiple files (namespaces).

Manage all translations centrally in the translation editor, add new languages, and run auto-translation and quality checks.

Use CLI, API, or GitHub integration for continuous localization.

Check out our docs for more details regarding .xcstrings support in SimpleLocalize.

Translation workflow with Localizable XC Strings

.xcloc: Localization catalogs

.xcloc files are packages that contain .xliff localization files along with metadata about the localization project.

About:

A folder (bundle) containing .xliff files and a Contents.json metadata file.

Generated by Xcode when you use Export for Localization.

Use case:

Full localization handoff to translators.

Best when working with external agencies or teams that use .xliff.

Learn more about .xcloc file format.

.xliff: The exchange format

.xliff (XML Localization Interchange File Format) is a standard XML-based format for exchanging localization data between different tools.

About:

Industry-standard XML format for exchanging translations.

Widely supported outside Apple’s ecosystem.

Can represent complex structures, including plural forms and context.

Use .xliff if you need to collaborate with translation agencies or tools that don’t use Xcode.

SimpleLocalize support:

You can import and export .xliff files directly in SimpleLocalize, from the translation editor or via CLI/API.

Check out the details in our docs regarding .xliff support in SimpleLocalize or read our dedicated blog post about XLIFF files.

.xliff translation file management example

Managing iOS translations with SimpleLocalize

Manually handling multiple iOS localization formats and translation updates can lead to errors, inconsistencies, and wasted time. SimpleLocalize TMS makes the translation management easier by allowing you to:

Import/export of all iOS formats via CLI, REST API, or GitHub integration.

Centralize all your iOS translation files in one place.

Provide translators with context, comments, and plural forms.

Collaborate with teams and agencies.

Auto-translate and run quality checks.

Automate review process and translation workflows.

Keep translations in sync with your codebase.

Check some examples of AI-powered localization workflow automation with SimpleLocalize.

Best practices for iOS localization

While iOS provides flexibility in localization formats, following best practices can help to improve your workflow and ensure high-quality translations:

Use keys, not hardcoded strings. Make them consistent and descriptive.

Prefer .xcstrings for new projects.

For large projects, consider namespacing your strings into multiple files.

Store pluralization in .stringsdict or .xcstrings.

Provide context and comments for translators.

Regularly review translations and run quality checks.

Export .xcloc or .xliff when working with agencies.

Automate with SimpleLocalize to avoid manual mistakes.

If you are using .strings, keep one Localizable.strings per language. For new projects, prefer .xcstrings catalogs, one per language.

Final thoughts

Apple’s localization formats have evolved from .strings to .xcstrings, with .xcloc and .xliff for translation exchange. While multiple formats are supported, Apple is clearly moving toward string catalogs as the future of iOS localization.

With SimpleLocalize, you don’t have to worry about file quirks. Upload any format, manage translations in one place, and sync them back to your app with a single command.

Ready to simplify your iOS localization workflow? Start with SimpleLocalize.

FAQ

Is Localizable.strings and .strings the same thing?

Yes, Localizable.strings is just a common filename convention for .strings files. You can name your .strings files anything, but Localizable.strings is the default name Xcode uses when you add localization.

Can I mix .strings and .xcstrings in the same app?

Yes. iOS will load translations from both as long as the files are placed in the correct \*.lproj folders. This allows you to migrate gradually instead of all at once.

Do I still need .stringsdict if I use .xcstrings?

No, .xcstrings supports pluralization and device variants natively, so you can consolidate everything into a single file per language.

How do I choose between .xcloc and .xliff?

Use .xcloc when exporting/importing full localization projects from Xcode, especially when working with agencies. Use .xliff if you need a more universal format that works across different tools.

Can SimpleLocalize automatically sync translations with my repository?

Yes. Besides manual import/export, you can:

Use the CLI for batch upload/download.

Call the REST API for automation.

Set up the GitHub integration for continuous localization: every commit can trigger a sync of translations.

What if I only need to translate a few strings?

That’s fine. You can import just one .strings or .xcstrings file into SimpleLocalize, add a new language, run auto-translation, and export it back without touching your whole project.

Will Apple remove support for .strings files?

Not in the near future. .strings files are still widely used and supported. However, Apple is clearly moving toward .xcstrings catalogs as the long-term format, so it’s a good idea to adopt them for new projects.
]]></content:encoded>
            <category>developer</category>
            <category>ios</category>
            <category>software localization</category>
            <category>translation management</category>
            <category>xliff</category>
            <category>strings</category>
            <category>xcstrings</category>
            <enclosure url="https://simplelocalize.io/blog/ios-translation-files.jpeg" length="0" type="image/jpeg"/>
        </item>
        <item>
            <title><![CDATA[Introducing: OpenRouter for auto-translation]]></title>
            <link>https://simplelocalize.io/blog/posts/introducing-openrouter</link>
            <guid>https://simplelocalize.io/blog/posts/introducing-openrouter</guid>
            <pubDate>Fri, 12 Sep 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to integrate OpenRouter with SimpleLocalize for enhanced auto-translation capabilities. Ai-powered localization made easy!]]></description>
            <content:encoded><![CDATA[We are excited to announce the integration of OpenRouter with SimpleLocalize as a new auto-translation provider. This integration allows you to leverage OpenRouter's advanced AI capabilities for efficient auto-translation workflows.

With OpenRouter, you can expect improved translation quality and faster processing times, making it easier to manage your localization projects. Generate translation drafts quickly and accurately, ensuring your content reaches a global audience without the usual delays.

About OpenRouter

OpenRouter is a powerful API for integrating various AI translation models. You can choose from a range of models, including those from OpenAI, Google, Sonoma, and others.

OpenRouter models comparison

Check all available models on OpenRouter Models.

Configuration

To start using OpenRouter with SimpleLocalize, follow these steps:

Sign up for OpenRouter: Create an account on OpenRouter and obtain your API key.

Configure SimpleLocalize: In your SimpleLocalize project settings, navigate to the "Auto-translation" section and select "OpenRouter" from the providers. Click on "Configure".

OpenRouter integration setup

Enter API Key: Input your OpenRouter API key to establish the connection.

Select Models: Enter the AI model you want to use for translations. Copy the model name from the OpenRouter Models page and paste it.

OpenRouter models selection

Enter System Prompt: Provide a system prompt to guide the translation process. This prompt will help the AI understand the context and produce more accurate translations.

OpenRouter configuration

Language translation settings

Now, select OpenRouter as your auto-translation provider. Go to the Languages tab, choose the language and click on "Edit". There, in the language settings, select OpenRouter from the "Translation provider" dropdown.

OpenRouter provider selection

Make sure to choose the auto-translation provider for each language you want to translate.

Translate with OpenRouter

Once you have configured OpenRouter as your auto-translation provider, you can start translating your content.

Click on the Start auto-translation button to translate to your selected language from the "Languages" tab or run auto-translation directly from the editor.

Auto-translating strings using OpenRouter

Learn more about auto-translation.
]]></content:encoded>
            <category>tutorial</category>
            <category>software localization</category>
            <category>developer</category>
            <category>product updates</category>
            <category>auto-translation</category>
            <category>ai</category>
            <enclosure url="https://simplelocalize.io/blog/introducing/openrouter.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to manage translation file versioning with tags]]></title>
            <link>https://simplelocalize.io/blog/posts/manage-translation-file-versioning-with-tags</link>
            <guid>https://simplelocalize.io/blog/posts/manage-translation-file-versioning-with-tags</guid>
            <pubDate>Wed, 10 Sep 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to manage translation file versioning using translation key tags in SimpleLocalize. Organize releases and track changes with a simple tagging workflow.]]></description>
            <content:encoded><![CDATA[Versioning is one of the trickiest parts of managing translation files. Each new release introduces fresh strings, updates old ones, and sometimes retires keys altogether. Without a clear strategy, it's easy to lose track of what belongs where, especially when collaborating with multiple translators and developers.

That's where translation key tags in SimpleLocalize come in. Tags are a simple but powerful way to track changes, organize keys, and keep your translation files under control, no matter how many versions or languages you are managing.

In this post, we'll show you how to use translation key tags in SimpleLocalize as a lightweight versioning system. (If you are new to tags, check out our introductory post on translation editor tags first.)

What are translation key tags?

Translation key tags are customizable, color-coded labels you can assign to translation keys in your project. Think of them as sticky notes that help you mark and organize keys.

You can use tags to:

Group keys by feature (e.g., Checkout, Dashboard)

Track keys by version (e.g., Beta, v1.0, v2.0)

Highlight priority (e.g., High Priority, Low Priority)

Control access (e.g., Internal, Public)

Tags show up right next to your keys in the SimpleLocalize translation editor, so you can filter and find exactly what you need in seconds.

Why use tags for versioning?

Traditional version control systems (like Git) are great for code but don't provide translators with the context they need. Tags in SimpleLocalize bridge this gap:

Clearly mark which keys belong to which release version.

Highlight outdated or changed keys that need review.

Filter and export translations per version for easier release management.

Improve collaboration between developers, translators, and product teams.

Setting up a tagging workflow

To get started, create version-specific tags in your project settings. For example:

v1.0 for the initial release

v1.1 for minor updates

v2.0 for major overhauls

Legacy for keys that are still needed for backward compatibility

Create version tags in project settings

Applying version tags

When you add or update translation keys, assign the appropriate version tag. Here's a simple workflow you can adopt:

Tag new keys by release. Whenever developers introduce new strings for an upcoming version, add the relevant version tag (e.g., v1.1).

Mark updated keys for review. If an existing string changes in the source language, other translations are marked as needing review.

Retire old keys. For removed strings, swap their version tag for a Legacy tag. This keeps history intact without cluttering active releases.

Combine tags with features. Add feature-level tags like Checkout, Profile, or Onboarding alongside version tags. This way, you can filter by both release and feature when preparing updates.

Translation keys with version tags in the editor

Keeping this workflow consistent ensures everyone on your team knows how to manage translation versions effectively.

Filtering and exporting by tags

When working in the translation editor, you can easily filter keys by their version tags:

Filter translations by tags

Combine filters (e.g., v2.0 + Onboarding + Needs review status) to focus on translations that require attention.

When it's time to export translations for a specific release, in Data > Export, select the desired tags to export only the relevant translations for that release.

Export translations by tags

You can export translations by tags also using our CLI download or API export, making it easy to integrate into your deployment pipeline.

Bonus: Combine tags with GitHub integration

If you use our GitHub integration, you can automate tagging based on pull requests. For example, when a PR is merged for a new feature or version, you can set up rules to automatically tag the associated translation keys. This reduces manual work and ensures consistency.

If you already manage your translation files in GitHub, you can combine it with tags in SimpleLocalize for a complete versioning workflow.

GitHub handles file history: every commit keeps a record of changes to your translation files.

SimpleLocalize tags provide context: easily see which keys belong to which release and their status.

Together, they ensure developers and translators stay in sync: code is versioned in GitHub, while translations are organized and review-ready in SimpleLocalize.

Learn more about the SimpleLocalize GitHub integration.

Best practices for version tagging

When using tags for versioning, keep these best practices in mind:

Be consistent: Stick to a naming convention: use consistent labels (vX.Y) across projects.

Plan your cleanup: Periodically move outdated version tags into Legacy to avoid clutter.

Document your tagging rules: Make sure developers and translators know when and how to apply tags.

Use color coding: Assign distinct colors to different version tags for quick visual identification.

Leverage filters: Regularly use tag filters to review and manage translations before releases.

Use bulk actions: Take advantage of SimpleLocalize's bulk tagging features to quickly update multiple keys at once.

Conclusion

Translation key tags aren't just for organizing by features or teams, they are a powerful tool for managing translation file versioning. With a solid tagging strategy, you will know exactly which strings belong to which release, making it easier to coordinate updates, reviews, and exports.

Try introducing version tags in your next release cycle, and see how much easier it becomes to manage translations across versions.

Happy tagging!
]]></content:encoded>
            <category>translation management</category>
            <category>tips</category>
            <category>developer</category>
            <category>tutorial</category>
            <enclosure url="https://simplelocalize.io/blog/manage-translation-file-versioning-with-tags.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to translate PO and POT files]]></title>
            <link>https://simplelocalize.io/blog/posts/translate-po-pot-files</link>
            <guid>https://simplelocalize.io/blog/posts/translate-po-pot-files</guid>
            <pubDate>Wed, 10 Sep 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to translate PO and POT files easily with gettext for software localization. Step-by-step guide with examples, best practices, and tools like SimpleLocalize.]]></description>
            <content:encoded><![CDATA[PO and POT files are at the heart of gettext-based localization workflows, powering translations for frameworks like Django, WordPress, GNU projects, and many desktop or CLI apps. They've been around for decades and remain a standard in open-source and enterprise software. But how do you actually translate them?

In this guide, you'll learn how to translate PO and POT files effectively, avoid common issues, and adopt tools that make the workflow faster and safer.

What are PO and POT files?

PO (Portable Object) files store translations for a given language.
POT (Portable Object Template) files act as the source template, they contain original strings (msgid) but no translations yet.

Together, they form the gettext ecosystem for handling i18n strings.

Here's a basic example:

PO/POT files characteristics

Here are some key characteristics of PO/POT files:

File extensions: .po (translations), .pot (template).

Structure:

'msgid' for source strings.

'msgstr' for translated strings.

Headers store metadata (project, language, encoding, plural forms).

Comments:

Default comments (#).

Translator comments (#.).

References (#: file:line).

Flags (#, fuzzy).

Plural forms handled explicitly with indexed msgstr\[n].

Standardized format widely supported across frameworks and tools.

PO/POT in i18n frameworks

PO/POT files are used by many ecosystems:

Django: uses PO files for translations, with built-in support for extracting and compiling them.

WordPress: relies on .po/.mo files in languages directories for themes and plugins.

GNU/Linux apps: gettext standard across CLI and desktop tools

Flask, Pyramid, PHP gettext: rely on PO files for translations

C, C++ projects: GNU gettext-native

Common challenges in translating PO files

Even though PO files are straightforward, translators often face challenges:

Fuzzy translations: Marked as uncertain, may slip into production unnoticed.

Plural forms: Different languages have 2–6 plural categories; mismatched rules break logic.

Encoding issues: UTF-8 vs. ISO-8859-1 can cause corrupted characters.

Context loss: Same msgid in different places may need different translations.

Comments ignored: Developers forget to add #. translator notes.

Sync issues: POT updated, but PO not regenerated → missing translations.

Merge conflicts: Multiple translators editing the same .po file.

Here's a broken example:

How to translate PO files

There are several ways to translate PO files, depending on the project size, team skills, and budget.

Manual translation

Small projects may translate PO files manually with a text editor.

Duplicate the .pot into .po for a target language.

Open the .po file in a text editor.

Fill in each msgstr with the translation.

Keep plural rules consistent with the language header.

Compile .po into .mo using msgfmt before deploying.

Translating PO file manually

You can translate .po files either in a text editor or in a gettext-aware editor that validates syntax and plural rules. This gives you full control but also requires caution to avoid mistakes.

Pros: no extra tools, maximum control.

Cons: error-prone, slow, poor collaboration.

Localization platform (recommended)

Modern localization platforms like SimpleLocalize provide a user-friendly interface for translating PO files.

Here are the steps:

Import .po or .pot files into the platform.

Pre-translate new strongs using auto-translation.

Collaborate with translators in a shared UI.

QA check: placeholders, length, plural rules, fuzzy entries.

Export clean .po files back into your repo.

Automate sync in CI for continuous updates.

Translating PO file in SimpleLocalize

Pros: scalable, context-rich, automated sync.

Cons: requires adopting a new tool.

Learn more about translating PO files with SimpleLocalize.

Best practices for translating PO files

When working with PO/POT translation files, follow these best practices:

Keep POT up to date: Run xgettext whenever source changes.

Sync PO files regularly with msgmerge or automation.

Freeze source strings before translation to avoid churn.

Add translator notes (#.) for ambiguous terms.

Use placeholders consistently: %s, %d, or {name} should be documented.

Handle plurals correctly: Define plural rules in headers, provide all forms.

Validate before shipping: Run msgfmt --check to catch errors.

Avoid context collisions: Use pgettext for identical strings with different meanings.

Review fuzzy entries: Ensure they are accurate before finalizing.

Backup PO files: Use version control to track changes and revert if needed.

Automate PO translation with SimpleLocalize

You can turn gettext workflows into a smooth CI/CD step with SimpleLocalize:

Connect your repository with GitHub App, GitLab, Bitbucket, or upload files directly.

Import and scan all strings, with full msgid/msgstr structure.

Pre-translate automatically. Run auto-translation for new or changed strings to create a high-quality draft instantly.

Review with context. Attach screenshots, descriptions, comments and use QA checks to catch issues early.

Keep translations in sync. Detect new msgids and auto-translate using an automation.

Export production-ready PO files with a single click, via CI or API.

Make it continuous. Wire SimpleLocalize into CI so every push:

imports updated PO/POT files,

triggers pre-translation,

and exports ready-to-deploy files.

Check more examples of AI-powered localization workflows.

FAQ

What is the difference between PO and POT files?

POT files are templates containing all source strings (msgid) but no translations.
PO files are language-specific, storing the translated strings (msgstr).
Think of POT as the blueprint and PO as the finished translation.

What is the difference between PO and MO files?

PO files are human-readable text files used for translations. MO (Machine Object) files are the compiled binary versions of PO files that gettext libraries use at runtime for faster access.

How do I create a POT file?

You can create a POT file using the xgettext command-line tool. For example:

How do I update a PO file when the source text changes?

Use the msgmerge tool to merge changes from the updated POT file into your existing PO files:

Or use a localization platform like SimpleLocalize to automate this process.

How do I handle plural forms in PO files?

Define the plural rules in the PO file header. For example, for English:

Then provide translations for each plural form:

What is a “fuzzy” translation in a PO file?

Fuzzy translations are marked as uncertain (#, fuzzy) when gettext cannot confirm accuracy. Review and correct these before deploying.

How often should I update PO files?

Update PO files whenever the source strings change. Regularly sync them with the latest POT file to ensure all translations are current.

Are there tools that help automate PO translations?

Yes, localization platforms like SimpleLocalize, Lokalise, or Crowdin offer collaborative translation, QA checks, auto-translation, and CI/CD integration.

Conclusion

PO and POT files are a cornerstone of gettext localization, powerful but tricky when managed manually. By combining good practices (plural rules, context, regular sync) with automation and collaboration in a platform like SimpleLocalize, you can eliminate fuzzy errors, merge conflicts, and tedious manual edits.

Upload your PO files, auto-translate them, invite reviewers, and export production-ready translations in minutes. Ready to streamline your gettext workflow? Import your PO files to SimpleLocalize and ship multilingual software with confidence.
]]></content:encoded>
            <category>translation management</category>
            <category>gettext</category>
            <category>pot</category>
            <category>po</category>
            <category>developer</category>
            <category>software localization</category>
            <enclosure url="https://simplelocalize.io/blog/translate-po-pot-files.jpeg" length="0" type="image/jpeg"/>
        </item>
        <item>
            <title><![CDATA[Crowdsource translations with public suggestions]]></title>
            <link>https://simplelocalize.io/blog/posts/crowdsource-translations-public-suggestions</link>
            <guid>https://simplelocalize.io/blog/posts/crowdsource-translations-public-suggestions</guid>
            <pubDate>Wed, 27 Aug 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to crowdsource translations and collect user feedback with SimpleLocalize Public Suggestions. Engage your community in app localization.]]></description>
            <content:encoded><![CDATA[Building world-class localized apps doesn't have to be expensive or slow. By involving your users, you gain native speakers, product experts, and passionate fans who help translate, fix context errors, and suggest better phrasing.

In this post you'll learn when crowdsourcing makes sense, how to set up SimpleLocalize Public Suggestions, practical moderation and quality-control tips, and ways to motivate your community.

Why crowdsource translations?

Crowdsourcing translations can be a game-changer for your localization efforts. Here are three major benefits:

Native fluency & context: Real users speak real language; they supply idiomatic phrasing and correct UI-specific issues like gender, pluralization and tone.

Speed, scale & costs: Volunteers let you localize and review more strings and languages faster than a single vendor can handle, often at lower cost.

Product-focused translations: Contributors who actually use the feature can propose phrasing that fits the product context (help text, error messages, CTAs).

Crowdsourcing works best as a complement to professional and AI translation, not a replacement. The best results come from combining community input with structured review workflows and automation.

If your customers prefer custom translations over default app strings, check out our Customer Translations feature.

When crowdsourcing is a good idea?

Crowdsourcing works best when:

You have an active user base or community (forums, Discord, Slack, GitHub, social channels).

Your product has frequent updates and you need continuous localization.

You want to improve existing translations and fix context issues.

You need contextual, product-specific phrasing that only users will suggest.

You want to prioritize localization for markets where professional translation budget is limited.

You are looking to increase product engagement and let users shape the product experience.

When to avoid or postpone crowdsourcing:

For final marketing campaigns where brand voice must be tightly controlled; prefer professional copywriters with a final review loop.

For legally sensitive text, e.g., contracts, privacy policy, or compliance notices; use legal-reviewed translations.

When you don't have resources to moderate and approve suggestions; unreviewed public content risks inconsistency.

What are Public Suggestions?

Public Suggestions in SimpleLocalize is a feature that allows you to open up your localization projects to the public. Users can suggest translations directly from a simple web interface, making it easy for anyone to contribute. You can then review, approve, or reject these suggestions within the SimpleLocalize translation management system.

Key characteristics:

Easy to use: A straightforward interface for users to submit suggestions without needing an account.

Moderation tools: Built-in features to review, approve, or reject suggestions.

Integration: Seamlessly integrates with your existing SimpleLocalize projects and workflows.

Notifications: Get alerted when new suggestions are submitted, so you can stay on top of contributions.

Context: Users can see the context of the string they are translating, helping them provide more accurate suggestions.

Review pipeline: Suggestions do not overwrite production strings until reviewed and approved by your team.

Audit trail: Each suggestion stays visible in the history for transparency and rollback.

Accepted translation suggestion

This model encourages community contributions while keeping control with your localization team.

Quick setup guide

Enable Public Suggestions

Open your SimpleLocalize project, navigate to the Settings tab, choose the Suggestions section, and enable the Public Suggestions option.

Public Suggestions setup

Customize settings

Next, customize the settings to fit your needs:

Branding: Upload your brand logo to make the suggestion interface recognizable.

Project display name: Set a clear and inviting name for your project.

Languages: Select which languages you want to open for suggestions.

Intro message: Write a welcoming message to encourage contributions and give instructions.

Public Suggestions settings

Go to your Profile > Notifications and enable email and internal alerts for new suggestions to stay updated.

Adding new languages

If you want to crowdsource translations for a new language, first add the language to your SimpleLocalize project. Then, enable it in the Public Suggestions settings.

Adding new language for suggestions

This way, you can engage native speakers from your community right away.

Share with your community

Successful crowdsourcing depends on outreach. Use multiple channels and give contributors a low-friction way to suggest changes.
Use the Public URL generated in the settings to share the suggestion interface. Here are some ideas:

Channels:

In-app widget or feedback button

Community forum (Discourse, Reddit)

Chat (Discord, Slack)

Email campaigns or newsletters

Social media posts and product changelogs

GitHub issues / PRs (for open-source projects)

The more visible and accessible the suggestion link is, the more contributions you'll receive.

Example announcement copy:

We're improving translations for \[language]. Help us make the app sound natural! Suggest improvements here: \[link]. Small contributions earn recognition and help users just like you!

or

Love using \[product]? Help us improve by suggesting better translations! Your input makes a big difference. Click here to contribute: \[link]

How to suggest a translation:

Adding translation suggestion

Review & approve workflow

The review process is simple and keeps you in control:

Contributor submits suggestion with optional comment/context.

You receive a notification (email/internal) about the new suggestion.

Open the translation in SimpleLocalize (from the notification or translations directly).

Review the suggestion in context, check for accuracy, tone, and appropriateness.

Approve to update the translation.

Export updated translations to your app.

Reviewing and accepting translation suggestion

To make collecting and reviewing suggestions easier:

Provide context for translation keys like screenshots and descriptions.

Set up a regular review schedule to avoid backlog.

Use comments with your team to discuss tricky suggestions.

Recognize and thank top contributors to encourage ongoing participation.

Motivate your community

Motivation is key to sustaining contributions, but it's not all. Often, people contribute because they care about the product and want to help. In most cases, they just want to use the product in their native language with good quality.

Here are some strategies to keep contributors engaged:

Recognition: Publicly acknowledge top contributors in release notes, newsletters, or a dedicated "Hall of Fame" page.

Access & perks: Offer early access to new features or beta programs, special support channel or priority issue handling.

Gamification: Points for accepted suggestions, levels, and milestone rewards.

Swag & micro-rewards: Stickers, T-shirts, or small gift cards for significant contributions.

Community events: Host translation sprints, webinars, or Q\&A sessions to build camaraderie.

Feedback loop: Show contributors how their suggestions improved the product (screenshots, metrics).

Clear, fast feedback: Contributors are much more engaged when they receive quick decisions and constructive comments.

With your customers, open-source users, or passionate fans, you can build a vibrant community that helps shape the product experience.

Tip: Ask your support team to share the Public Suggestions link with users who report translation issues. Turning feedback into contributions is one of the fastest ways to grow community involvement.

Summary

Crowdsourcing translations with Public Suggestions is a cost-effective way to improve localization quality, engage your users, and scale to more languages. To succeed:

Start small, pilot a language or a subset of strings.

Require context and clear instructions for contributors.

Set up a regular review process to maintain quality.

Motivate contributors with recognition, perks, and fast feedback.

Combine crowdsourcing with professional review for the best results.

When done thoughtfully, community contributions become a sustainable part of your localization pipeline.

Ready to try? Enable Public Suggestions in your SimpleLocalize project today and invite your community to shape the product with you.

FAQ

Here are answers to common questions about crowdsourcing translations with Public Suggestions:

Q: Will community suggestions instantly overwrite my production translations?

A: No, suggestions go into a review queue. You must approve them before they replace existing translations.

Q: Should I accept every community suggestion?
A: Not necessarily. Review each suggestion for accuracy, tone, and appropriateness. You can reject or modify suggestions as needed.

Q: Can I combine crowdsourced suggestions with professional or machine translation?
A: Yes. Many teams use machine translation for drafts, open them up for community review, then have professionals polish final text.

Q: Do I need large community to benefit from crowdsourcing?
A: Not at all. Even a small, active group of users can provide valuable improvements. Quality matters more than quantity.
]]></content:encoded>
            <category>software localization</category>
            <category>translation management</category>
            <enclosure url="https://simplelocalize.io/blog/crowdsource-translations.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to auto-translate YAML files]]></title>
            <link>https://simplelocalize.io/blog/posts/auto-translate-yaml-files</link>
            <guid>https://simplelocalize.io/blog/posts/auto-translate-yaml-files</guid>
            <pubDate>Sun, 24 Aug 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Skip manual edits. Learn how to auto-translate YAML files with SimpleLocalize using upload, batch MT, and CI/CD so every push ships with fresh translations.]]></description>
            <content:encoded><![CDATA[Auto-translating YAML files turns localization from a manual chore into a repeatable step in your build. With SimpleLocalize, you can import your YAML, run machine translation (MT) automatically, check and review quality, and export validated files back to your repo, all without leaving your CI/CD pipeline.

This guide walks you through the end-to-end automation flow, including project setup, one-click pre-translation, review, and continuous integration examples.

Why auto-translate YAML?

Auto-translation saves time and reduces errors by eliminating manual copy-paste. It also offers:

Speed: Generate high-quality drafts for every locale in minutes.

Consistency: Keep keys in sync across languages automatically.

Safety: Guard placeholders, plural forms, and YAML syntax with built-in checks.

Scalability: Easily add new languages and strings as your app grows.

What you'll automate

Not only will you auto-translate YAML files, but you'll also integrate the process into your development workflow. The key steps are:

Upload YAML files: Push your source YAML files from your repo (e.g. GitHub, GitLab), using CLI or API, or import them manually.

Pre-translate with MT: Use SimpleLocalize's batch machine translation to auto-translate all strings.

Review and edit: Optionally review and refine translations in the SimpleLocalize editor.

Export translated YAML: Download the translated files or push them back to your repo.

Repeat on every push via CI.

Project setup (one time)

First, create a SimpleLocalize account and set up a new project. Next go to the Languages tab and add your target locales (e.g. es, fr, de).

Add languages in SimpleLocalize

Next, connect your repository. Use the new SimpleLocalize GitHub App for first-class Git integration, automatic imports/exports, and safe PR workflows.

Check docs for GitLab CI, Bitbucket Pipelines or use the CLI or API for custom workflows.

Import your YAML files

You can import your YAML files in several ways:

Manual upload

Once your project is set up, open Translations tab and choose YAML as the file format. Choose your file configuration (one file per language or one file with all languages) and upload your source YAML file.

Uploading YAML file in SimpleLocalize

Using CLI

Use the upload command to push YAML files from your local machine or CI/CD pipeline.

See the how to import translations vis CLI.

Using API (cURL)

You can also use the REST API to upload YAML files programmatically.

See the how to import translations via REST API.

Using the GitHub App (recommended)

Install the SimpleLocalize GitHub App to your repository or organization. Once installed, the app can:

Automatically import translations from a specific path (e.g., i18n/english.yml).

Open pull requests with translation files for target languages.

Trigger automations when new keys are added or changed.

See the GitHub App installation and configuration guide for step-by-step instructions.

Run auto-translation (pre-translate)

Now, run auto-translation. You can do this manually in the UI from the Languages by clicking Auto-translate all. This will use machine translation to pre-translate all untranslated strings in your target languages.

Auto-translate all strings in SimpleLocalize

Learn more about using auto-translation.

You can also trigger auto-translation via the CLI:

or start auto-translation via API:

Check our tips for effective auto-translation to improve quality.

Automate auto-translation

You can also set up automations to run auto-translation whenever new keys are added or existing keys are updated.

Auto-translation automation example

See the automation docs for more examples.

Edit & review

After auto-translation, you can review and edit translations in the SimpleLocalize editor. This step is optional but recommended for quality assurance.

Customize the editor view and options to focus on untranslated or auto-translated strings.

Use filters to find specific keys or languages.

Add screenshots and key descriptions to provide context for translators.

Invite team members or professional translators to review and improve translations.

Add comments and collaborate with team members.

Translation editor in SimpleLocalize

You can also control the translation review status, marking translations as Accepted or Needs review.

Learn more about controlling the translation quality with review statuses.

Export translated YAML files

Once you're happy with the translations, you can export the translated YAML files. You can do this manually from the Data tab by selecting YAML as the export format, choosing the structure, and downloading the files.

Exporting YAML files in SimpleLocalize

You can also use the CLI to export files:

See the CLI docs for more download options.

Or use the API:

See the API docs for exporting translations for more details.

Wire it into CI/CD

Finally, integrate the entire flow into your CI/CD pipeline to ensure translations are always up-to-date with every push.
The easiest way to automate YAML translation is with the SimpleLocalize GitHub App.

Here's an example simplelocalize.yaml config for a project that uses frontend JSON namespaces and backend YAML files:

How it works:

On push to main, develop, or feature/\*, the GitHub App uploads your English source files (.json and .yml) into SimpleLocalize.

New or changed keys are automatically pre-translated into your target locales (es, fr, de).

A pull request is created with updated translation files for frontend JSON and backend YAML.

You review, approve, and merge, keeping translations always in sync with your codebase.

Conclusion

Auto-translating YAML with SimpleLocalize gives you fast drafts, safe placeholders, correct plurals, and clean exports, all wired into CI. Import your YAML, run pre-translation, review the bits that matter, and ship every locale alongside your code.

Ready to try it? Import your YAML, enable auto-translation, and connect your pipeline, your next release can ship in every language by default.
]]></content:encoded>
            <category>developer</category>
            <category>yaml</category>
            <category>software localization</category>
            <category>tutorial</category>
            <category>auto translation</category>
            <enclosure url="https://simplelocalize.io/blog/auto-translate-yaml-files.jpeg" length="0" type="image/jpeg"/>
        </item>
        <item>
            <title><![CDATA[How to translate YAML files for localization]]></title>
            <link>https://simplelocalize.io/blog/posts/translate-yaml-files</link>
            <guid>https://simplelocalize.io/blog/posts/translate-yaml-files</guid>
            <pubDate>Sat, 23 Aug 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to translate YAML files easily for app or website localization. Step-by-step guide with examples, best practices, and tools like SimpleLocalize.]]></description>
            <content:encoded><![CDATA[YAML is a developer's best friend for clean, human-readable configuration, and it's also a popular format for storing translation strings in frameworks like Ruby on Rails, Symfony, Laravel, Next.js, and more. But translating YAML files can get messy fast: indentation is unforgiving, keys drift out of sync across locales, and collaboration between developers and translators often happens in spreadsheets or DMs.

In this guide, you'll learn how to translate YAML files effectively, without breaking the structure or losing context. We'll cover common challenges, best practices, and tools that make the process smoother.

What is YAML?

YAML (YAML Ain't Markup Language) is a human-friendly data serialization standard often used for configuration files and data exchange between languages with different data structures. It emphasizes readability and simplicity, making it a popular choice for developers.

Here is a simple example of a YAML file used for localization:

YAML characteristics

YAML has several key features that make it suitable for localization:

File extension: .yml or .yaml

Human-readable with a clean, minimal syntax.

Indentation defines structure (spaces only, no tabs).

Scalars can be plain (hello), single-quoted ('hello'), or double-quoted ("hello") (for escapes and interpolation)

Collections: maps (key–value objects) and sequences (lists).

Comments start with # and are ignored by parsers.

Anchors & aliases (& / \*) let you reuse content.

Multi-line strings using | (literal) or > (folded).

Supports Unicode for international characters.

Check our our block post and learn more about differences between JSON and YAML files in localization.

YAML in i18n frameworks

YAML is widely used for localization (i18n) keys in popular stacks:

Ruby on Rails: Uses YAML files for storing translations in config/locales/\*.yml.

Symfony: Supports YAML for translations in translations/\*.yaml.

Laravel: Often JSON, but YAML is used in tooling and configs in resources/lang.

Django: Primarily uses .po files, but YAML can be used with third-party packages.

Static sites & JAMStack: docs, marketing sites, MDX with YAML front-matter.

Common challenges in translating YAML files

While YAML is great for localization, it comes with its own set of challenges:

Indentation errors: One extra space breaks structure and your app fails to parse.

Key mismatches: en gains a new key that never reaches es, causing missing translations at runtime.

Placeholder mismatches: {name}, %{name}, or {{name}}, frameworks differ. Translators may accidentally change or delete placeholders.

Pluralization complexity: Languages have many plural forms; mapping them to YAML keys (e.g., one, few, many, other) is easy to get wrong.

Collaboration friction: Not everyone is comfortable editing YAML. PRs with merge conflicts or syntax mistakes slow things down.

QA at scale: Manually checking hundreds of keys across multiple languages is error-prone and time-consuming.

Context loss: Short keys like title or save lack context, leading to vague or incorrect translations.

How to translate YAML files

There are several approaches to translating YAML files.

Manual translation

Depending on your team's size and workflow, you might choose to translate YAML files manually.

If you go for managing translations in multiple YAML files (e.g., en.yml, es.yml, fr.yml):

Duplicate your source file (e.g., en.yml) to create a new locale (e.g., es.yml).

Keep identical key paths; translate only the values.

Use a YAML linter or validator to check for syntax errors after editing.

Translating YAML files manually

For multi-language files (e.g., locales.yml):

Add new language sections under the root key (e.g., es:).

Translate values while preserving the structure.

Validate the entire file to ensure no syntax issues.

Here is an example of a simple multi-language YAML file:

Pros: full control, no new tools.

Cons: slow, error-prone, hard to scale or collaborate.

Assisted translation (code-aware editor)

If your team is comfortable with YAML but wants some help, use a code-aware editor that understands YAML, like VSCode.

Install YAML extensions for syntax highlighting and validation.

Use multi-cursor editing to translate multiple lines at once.

Use search-and-replace for placeholders or common phrases.

Translating YAML files in VSCode

Pros: faster than raw text editing, fewer syntax errors.

Cons: still manual, limited collaboration features.

Localization platform (recommended)

Centralize your keys in a translation platform like SimpleLocalize and let it handle structure, context, and synchronization.

Typical workflow:

Import your YAML files (upload, Git integration, CLI or API).

Pre-translate with auto-translation to create a baseline.

Review & collaborate with translators and developers in one place.

QA check for placeholders, length, and missing translations.

Export clean, validated YAML files back to your repo.

Automate the loop in CI so new keys are detected and distributed automatically.

Translating YAML files with SimpleLocalize

Pros: scalable, less risk, faster release cycles.

Cons: introduces a new tool (with big time savings).

Check out our guide on how to auto-translate YAML files with SimpleLocalize.

Best practices for translating YAML files

Here are some tips to keep your YAML translations clean and maintainable:

Mirror the same key tree across all locales: Keep key paths identical. Use tooling to detect missing or extra keys.

Keep keys stable; change values only: Keys are your API. Changing them causes churn across all languages.

Use descriptive, namespaced keys: Prefer checkout.payment.failed over failed.

Add context notes: Provide translator notes (comments, screenshots, descriptions) for ambiguous strings.

Translation key screenshot and description context in SimpleLocalize

Protect placeholders: Decide on a placeholder style (e.g., %{name}) and enforce it. Add QA rules that block exports when placeholders change.

Handle pluralization explicitly: Use plural keys required by your framework. Example:

Avoid embedding HTML when possible: Prefer plain text with placeholders; if markup is necessary, document allowed tags.

Validate early and often: Add a linter to pre-commit/CI. Catch indentation, duplicate keys, and invalid YAML before review.

Freeze source language first: Review and approve en (or your source) before translation to prevent rework.

Glossary and style guide: Maintain product names, capitalization, and tone guidelines; enforce them in QA.

Automate YAML translation with SimpleLocalize

Turn YAML localization into a continuous, low-touch workflow with SimpleLocalize:

Connect your repository. Point SimpleLocalize to your YAML paths (e.g., config/locales/\*\*/\*.yml). It scans and imports keys with their full path, preserving structure.

Use GitHub App, GitLab, Bitbucket, or upload files directly.

Pre-translate automatically. Run auto-translation for new or changed strings to create a high-quality draft instantly. Placeholders are protected, so %{name} stays intact.

Review with context. Add screenshots and descriptions so translators see how strings are used. Use comments and community suggestions to resolve questions quickly.

Keep locales in sync. When a developer adds checkout.payment.failed in en.yml, SimpleLocalize detects it, marks it “needs review" and can run an automation to auto-translate it to all target languages.

Export production-ready YAML. Download or sync back to your repo/CI. SimpleLocalize validates syntax, placeholders, and missing translations before export, so you never break your app.

Make it continuous. Wire SimpleLocalize into CI so every push:

imports updated YAML,

triggers pre-translation,

and exports ready-to-deploy files.

Result: fewer PR ping-pong sessions, no broken indentation, and faster, safer multilingual releases.

Check more examples of AI-powered localization workflows.

Conclusion

Translating YAML files doesn't have to mean manual edits, broken indentation, or last-minute string hunts. By keeping consistent keys, validating syntax, and centralizing your workflow in SimpleLocalize, you can turn localization into a smooth, repeatable part of your release process.

Upload your YAML files, run machine translation for a head start, invite reviewers, and export clean, synchronized locales in minutes, not days. Ready to ship a truly multilingual product? Import your YAML to SimpleLocalize and see how much time (and stress) you save on your next release.
]]></content:encoded>
            <category>developer</category>
            <category>yaml</category>
            <category>software localization</category>
            <enclosure url="https://simplelocalize.io/blog/translate-yaml-files.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[GitHub App available!]]></title>
            <link>https://simplelocalize.io/blog/posts/github-app-for-localization</link>
            <guid>https://simplelocalize.io/blog/posts/github-app-for-localization</guid>
            <pubDate>Wed, 20 Aug 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[SimpleLocalize GitHub App is now live! Connect your repository, add simplelocalize.yml and automate uploading & downloading translations with pull requests.]]></description>
            <content:encoded><![CDATA[The SimpleLocalize GitHub App is now live! You can connect your GitHub repository directly to SimpleLocalize and automate the most common localization workflows without scripting or manual CLI runs.

What you get

Automatic upload of source translations on push

Automatic download + pull requests with updated translations

Smart path patterns with {lang} and {ns} placeholders

Configurable branches, PR title/body, and labels

Tag-based filtering and format flexibility

Reports on translation updates in pull requests



How it works

The GitHub App listens to events in your repository, such as pushes or pull requests. When a change is detected, it automatically uploads source translations to SimpleLocalize and downloads updated translations back to your repository,
by creating a pull request with the changes like this:

Example Pull Request from SimpleLocalize bot in GitHub

GitHub App vs. CLI

GitHub App covers the most common workflows, and can do basically the same thing, giving you some more benefits like reports.
SimpleLocalize CLI is better where you need a more sophisticated workflow that is not yet covered by GitHub App.

GitHub App makes it much easier to transfer and scale the workflow than the CLI, as it requires just a simple configuration file (simplelocalize.yml) in your repository and connecting the repository to your SimpleLocalize project.

Quick start

Install the SimpleLocalize GitHub App from your Project Settings (GitHub section)

Add a simplelocalize.yml file to the root of your repo

Commit & push

When translations change in SimpleLocalize, the app prepares updated files and opens a pull request for review. You keep full control over merging.

Minimal config



GitHub App configuration file shares similar syntax in some parts to the SimpleLocalize CLI configuration file, but they are not interchangeable.

Placeholders

Use placeholders:

{lang} - language key

{ns} - namespace (when you split translations across files)

Example:

Generates: src/i18n/en/common.json, src/i18n/pl/dashboard.json, etc.

Resources

Documentation: GitHub App

Documentation: File formats
]]></content:encoded>
            <category>github</category>
            <category>developer</category>
            <category>integration</category>
            <enclosure url="https://simplelocalize.io/blog/github-app/github-app.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[YAML vs JSON for translation files: Key differences and best practices]]></title>
            <link>https://simplelocalize.io/blog/posts/yaml-vs-json-translation-files</link>
            <guid>https://simplelocalize.io/blog/posts/yaml-vs-json-translation-files</guid>
            <pubDate>Wed, 20 Aug 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Should you use YAML or JSON for translation files? Let's compare their key differences, pros and cons, and best practices to help you choose the right format for your localization project.]]></description>
            <content:encoded><![CDATA[Localization teams spend a lot of time reading and editing translation files. The file format you choose, YAML or JSON, affects readability, tooling, and how smoothly translators, developers, and CI/CD pipelines collaborate.

In this guide, we will break down the key differences, pros and cons, and best practices for using YAML vs JSON in translation files. By the end, you will know which format best fits your project.

Choose YAML if people edit files, you need comments, multi-line strings, or cleaner diffs.

Choose JSON for strict structure, fast parsing, and broad tooling, ideal for front-end apps.

SimpleLocalize supports both, so you can import/export whichever your team prefers.

YAML vs JSON: Key differences

Both YAML and JSON are popular structured data formats, but their design priorities are very different. Here's a quick comparison:

| Feature                | YAML                                      | JSON                                      |
|------------------------|-------------------------------------------|-------------------------------------------|
| Extension         | .yaml or .yml                      | .json                                   |
| Syntax                 | Indentation-based, flexible           | Bracket-based, strict           |
| Readability            | More human-friendly, supports comments    | Can get noisy with quotes/braces    |
| Comments               | ✅ Yes (# some explanation)           | ❌ No comments allowed                       |
| Trailing commas       |  ✅ Allowed                                 | ❌ Not allowed                                  |
| Multi-line strings     | ✅ Yes (e.g., with >)                  | Escape newlines with \n                |
| Anchors & aliases     | ✅ Yes (e.g., \&anchor and \*alias)       | ❌ Not supported         |
| Parsing libraries      | Slower parsers, larger               | Fast parsers, smaller                   |
| Schema validation      | Limited     | JSON Schema ecosystem |

File format overview

JSON file

JSON (JavaScript Object Notation) is a lightweight data format. It's machine-friendly, language-agnostic, and widely supported.



Example JSON file:

Pros of JSON:

Strict syntax helps catch errors early.

Parsers are fast and lightweight.

Supported by nearly every language, library, and framework.

Cons of JSON:

Cluttered with braces and quotes in large files.

No inline comments allowed.

Multi-line strings require escaping.

YAML file

YAML (YAML Ain't Markup Language) is more human-centric, designed for configuration and readability.



Example YAML file:

Pros of YAML:

Supports inline comments.

Supports inline comments.

Handles multi-line strings elegantly (| and >).

Allows anchors & aliases to reduce repetition.

Cons of YAML:

Parsers are slower and heavier.

Indentation errors can easily break files.

Weak schema validation compared to JSON.

YAML and JSON in localization

When choosing a format for translation files, consider how translators and developers will interact with them.

Translator context and comments

Translators often need hints. YAML supports comments directly in the file:

JSON doesn't support comments, so context must live in your TMS like SimpleLocalize, documentation, or metadata files.

Translation key description in SimpleLocalize

Multi-line strings (emails, legal, etc.)

YAML's block style (> or |) makes it easy to write multi-line strings:

\> breaks lines but keeps them in one string, while | preserves line breaks.

JSON requires escaping newlines:

Reuse with anchors (YAML only)

YAML's anchors (&) let you define a piece of content once and give it a label. Aliases (\*) let you reference that label elsewhere in the file.

This is a great DRY (Don't Repeat Yourself) feature, but not all tools preserve anchors, so check your TMS before relying on them.

ICU Message Format, placeholders and plurals

Both YAML and JSON can handle ICU message format, which is great for complex translations with placeholders and plurals. However, YAML's readability shines here:

In JSON, it looks more cluttered:

What matters here is your i18n library's support for ICU messages, not the file format, e.g., FormatJS, i18next, messageformat, zero-intl. The format won't change ICU behavior; it just carries the string. Both YAML and JSON can handle it just fine.

Ordering and diffs

Neither JSON nor YAML guarantee order by default, but many tools keep insertion order. YAML's lighter syntax tends to produce cleaner diffs, which helps reviews. JSON's strictness reduces accidental structure changes.

Use Update order import option in SimpleLocalize to keep the order you set in your translation files in the translation editor.

Update order import option in SimpleLocalize

Nested structures

Both formats can handle nested structures, but YAML's indentation makes it more visually clear. JSON uses brackets and commas, which can get messy in large files.
For example, a nested structure in YAML:

In JSON, it looks like this:

Encoding and emoji

Both work fine with UTF-8. YAML can include emojis directly, while JSON can use \uXXXX escapes if needed.

Emoji example in YAML and JSON

Security and parsing

Both formats can be secure if you use trusted libraries.

JSON: safer by default, thanks to strict syntax

YAML: flexible, but some older parsers had vulnerabilities (avoid !! tags unless needed).

Best practices for YAML and JSON in translation files

Here are some best practices to follow when using YAML or JSON for translation files:

One locale per file, or small per-namespace files (e.g., en.json, fr.json, home.yaml, auth.yaml). This keeps files manageable and avoids conflicts.

Use clear keys: Use descriptive keys that make it easy to understand the context of each string. Avoid abbreviations or cryptic names.

Document placeholders: Describe variables like {{name}} or %{count}.

Don't overnest: Don't nest too deeply and keep structures simple.

Keep context near strings: YAML comments or TMS descriptions.

Automate validation: Check missing/extra keys across locales using tools or scripts.

With SimpleLocalize, you can:

Import/export both YAML and JSON.

Preserve order during import with Update order option.

Add descriptions for translators.

Assign tags or namespaces for better organization.

Automate updates with CLI or API.

Decision time: YAML or JSON?

Choose the format that fits your workflow. For machine-only processing, JSON offers speed and strict validation. For files frequently edited by people, YAML's readability and support for comments make collaboration easier.

Choose YAML if:

Translators or non-developers edit files directly.

You need comments, multi-line strings, or anchors.

You want cleaner diffs for easier reviews.

Choose JSON if:

The runtime (web/mobile) consumes translations directly.

You want speed, strict validation, and compact size.

Your team already uses JSON across the stack.

Best of both worlds: let translators use YAML in your TMS, then export JSON for runtime. Tools like SimpleLocalize make switching formats easy, so you can adapt as your project evolves.

Conclusion

Both YAML and JSON are excellent for translations, but they serve different audiences:

YAML = human-friendly editing, context, and readability.

JSON = machine efficiency, strictness, and performance.

With SimpleLocalize supporting both, you don't need to lock into one format, pick whichever best fits your workflow.

FAQ

Is YAML better than JSON for translations?

YAML is better if translators edit translation files, since it supports comments and multi-line strings. JSON is better for performance, strict validation, and front-end apps.

Can JSON files include comments?

No, JSON does not support comments. Use a translation management system (TMS) like SimpleLocalize to add descriptions or context.

Which is faster: YAML or JSON?

JSON is faster and more lightweight to parse. YAML is slower due to its flexible, indentation-based syntax.

Can both YAML and JSON handle multi-line strings?

Yes. YAML supports multi-line strings with | or >. JSON requires escaping newlines with \n.

Can I use both YAML and JSON in the same project?

Yes. Many teams use YAML for translators and export JSON for runtime. Tools like SimpleLocalize support both formats.
]]></content:encoded>
            <category>software localization</category>
            <category>yaml</category>
            <category>json</category>
            <category>developer</category>
            <enclosure url="https://simplelocalize.io/blog/yaml-vs-json-translation-files.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Translation vs. Transcreation: What's the difference?]]></title>
            <link>https://simplelocalize.io/blog/posts/translation-vs-transcreation</link>
            <guid>https://simplelocalize.io/blog/posts/translation-vs-transcreation</guid>
            <pubDate>Tue, 19 Aug 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn the key differences between translation and transcreation, when to use each, and how both approaches can elevate your localization and brand strategy.]]></description>
            <content:encoded><![CDATA[Translation and transcreation are two distinct processes in the realm of language services, each serving different purposes and requiring different skill sets.

Translation converts meaning from one language to another, prioritizing accuracy and consistency.

Transcreation recreates the message so it evokes the same intent, tone, and emotional impact in another culture, even if the words change a lot.

Use translation for UI strings, documentation, legal text, and repetitive content. Use transcreation for taglines, ads, landing pages, push notifications, app store descriptions, and high-stakes brand moments.

The best teams combine both approaches and manage them centrally in SimpleLocalize with glossaries, workflows and in-context review.

In the following sections, we will explore the definitions of translation and transcreation, their differences, and when to use each approach effectively.

What is Translation

Translation is the process of converting text from one language to another while maintaining the original meaning, context, and intent. It focuses on accuracy, consistency, and fidelity to the source material. Translators work with various types of content, including:

Product UI copy (buttons, menus, error messages)

Documentation (user manuals, help articles)

Legal texts (contracts, terms of service)

Repetitive content (emails, notifications)



The goal of translation is to ensure that the target audience understands the content as intended by the original author, without altering the message's core meaning.

Learn more about translation in software localization.

What is Transcreation

Transcreation adapts a message creatively so it lands with the same intent, emotion, and brand voice as the original. The result may depart significantly from the source wording but retains the essence of the message. Transcreation is often used for:

Brand taglines and slogans

Advertising copy (print, digital, social media)

Landing pages and hero sections

App store descriptions and screenshots captions

Push notifications and in-app messages

High-stakes brand moments (product launches, campaigns)



Transcreation requires a deep understanding of both the source and target cultures, as well as the ability to craft messages that resonate emotionally with the target audience. It often involves creative writing skills, cultural adaptation, and a keen sense of marketing.

Why transcreation matters

Transcreation is essential for brands that want to connect with diverse audiences across different cultures. Today, users don't just want to read content in their language; they want to feel it speaks to them personally.

A perfectly translated headline can still miss the moment if it fails to connect culturally. Transcreation ensures that the message is not only understood but also feels relevant and engaging to the target audience.

The key is to know when to use translation and when to use transcreation. Both processes have their place in a comprehensive localization strategy, and understanding their differences can help you choose the right approach for your content.

Translation and Transcreation: Key differences

Words or feelings? Translation and transcreation serve different purposes, and understanding their differences is crucial for effective localization. Here are the key distinctions:

| Aspect                | Translation                                      | Transcreation                                     |
|-----------------------|--------------------------------------------------|---------------------------------------------------|
| Purpose               | Convert meaning accurately                        | Evoke the same intent and emotion                  |
| Focus                 | Accuracy and consistency                          | Cultural adaptation and emotional impact           |
| Flexibility           | Limited; stays close to source text               | High; can change wording, structure, and tone      |
| Approach              | Word-for-word conversion                          | Creative adaptation of messages              |
| Skill set             | Language proficiency, subject matter expertise    | Creative writing, cultural understanding, marketing knowledge |
| Result                | Text that conveys the same meaning                | Message that resonates emotionally with the target audience |
| Content type          | UI strings, documentation, legal text            | Taglines, ads, landing pages, push notifications |
| Use cases             | Software localization, technical content         | Marketing campaigns, brand messaging              |
| Review process        | Linguistic review, QA checks                      | Creative review, cultural feedback                 |
| Time and cost         | Generally faster and less expensive               | More time-consuming and costly due to creative work |

Transcreation examples

To illustrate the difference between translation and transcreation, let's look at some examples from well-known brands that have successfully adapted their messages for different markets.

Hero section

Canva, a popular graphic design platform, uses transcreation to adapt its hero section across languages.

Canva hero section in English and Spanish

In English, the hero section reads: "What will you design today?"

In Spanish, it is transcreated as: "¿Qué diseñamos hoy?"

Instead of "¿Qué vas a diseñar hoy?" which is a direct translation, the transcreated version captures the brand's friendly tone and encourages users to engage with the platform.

The CTA is also adapted: "Quiero diseñar" instead of "Comienza a diseñar," which feels more inviting and personal.

Tagline

McDonald's is another example of effective transcreation. The brand's iconic tagline, "I'm Lovin' It," has been adapted for various markets.
In Germany, it becomes "Ich liebe es," which directly translates to "I love it." In Spanish-speaking countries, it is often transcreated as "Me encanta," which conveys the same sentiment in a culturally relevant way.

McDonald's tagline in different languages

Tagline transcreation is challenging because it must resonate with local audiences while maintaining the brand's identity. McDonald's has successfully navigated this by adapting its message to fit cultural nuances.

App store description

Another example is the app store description for the popular language learning app, Duolingo.

Duolingo app store description in different languages

English: "Duolingo - Language Lessons: Learn Languages, Math & Music"

Spanish: "Duolingo - Aprende idiomas: Aprende inglés, francés y más"

Polish: "Ucz się języków z Duolingo: Angielski, hiszpański i więcej"

In this case, the transcreated descriptions maintain the core message of learning languages while adapting the wording to fit each language's structure and cultural context. The focus is on making the description engaging and relevant to the target audience.

Marketing campaigns

Transcreation is also crucial for marketing campaigns. In the example below you can see how Old Spice adapted its famous "Smell Like a Man, Man" campaign for different markets.

Old Spice transcreation example

In the original English version, the tagline is straightforward and masculine. However, in Spanish-speaking countries, it was transcreated to "Huele como un tío, tío," which maintains the playful tone while making it more relatable to the local audience. In Turkish, it becomes "NE KADAR DA ERKEK BiR KOKU" which translates to "What a manly smell!" capturing the essence of the original message while adapting it to fit cultural expectations.

When to use translation vs. transcreation

Use translation when:

Content is technical, legal, or requires high accuracy.

Precision outweighs persuasion.

You need to scale across thousands of strings quickly.

The target audience is familiar with the source culture and language.

Use transcreation when:

Content is marketing-focused, creative, or brand-driven.

Cultural references, humor, or idioms are involved.

The copy carries your brand (taglines, hero copy, ads).

You are optimizing conversion in a market.

In many cases, a combination of both approaches is necessary. For example, you might translate the bulk of your app's UI strings while transcreating the marketing copy to ensure it resonates with local users.

Tips for effective translation and transcreation

Here are some best practices to ensure successful translation and transcreation:

Segment your content: Identify which parts require translation and which need transcreation. Tag your translation keys by intent (e.g., ux, marketing, legal) to route to the right people.

Provide context: Use screenshots, descriptions and comments to help translators and transcreators understand the context of the content. In-context review is a great way to view the content in its actual environment.

Set review criteria: Define clear guidelines for both translation and transcreation. For translation, focus on accuracy and consistency, formatting and placeholders. For transcreation, keep an eye on message fit, tone, uniqueness and cultural relevance.

Test with real users: A/B test headlines and CTAs to see which versions resonate best with your target audience. Use analytics to measure engagement and conversion rates.

Use machine translation wisely: Use MT for initial drafts of translation, but always have a human creative review for transcreation. Machine translation can speed up the process, but it lacks the cultural nuance needed for effective transcreation.

Balance creativity and fidelity: Don't force transcreation where translation will do as you don't want to overdo it and risk losing the original message. But don't skimp on transcreation where it matters most, like marketing copy, as it can make or break your brand's success in a new market.

Conclusion

For global growth, words must work and win. Use translation to scale clarity and consistency, and transcreation to connect emotionally and culturally.
Both processes are essential for effective localization, and understanding their differences can help you choose the right approach for your content.
By combining translation and transcreation, you can create a comprehensive localization strategy that resonates with diverse audiences and drives engagement.

For more insights on localization, check out our blog and documentation for best practices and tips on managing your translation projects effectively.
]]></content:encoded>
            <category>tips</category>
            <category>internationalization</category>
            <category>transcreation</category>
            <category>translation</category>
            <enclosure url="https://simplelocalize.io/blog/translation-vs-transcreation.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Enterprise translation management for large SaaS: Speed, scale & cost efficiency]]></title>
            <link>https://simplelocalize.io/blog/posts/enterprise-ready-translation-management-for-big-saas</link>
            <guid>https://simplelocalize.io/blog/posts/enterprise-ready-translation-management-for-big-saas</guid>
            <pubDate>Mon, 18 Aug 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Discover how SimpleLocalize helps enterprise SaaS teams scale localization across dozens of locales without the complexity of legacy TMS platforms.]]></description>
            <content:encoded><![CDATA[If you are running a large SaaS platform, your localization workflow is probably under pressure with dozens of locales, multiple product surfaces, daily deployments and tight budgets.

SimpleLocalize gives you an enterprise-ready translation management system designed for speed, scalability, and cost efficiency, without the complexity of legacy TMS tools. With CDN delivery, API/CLI automation, AI-assisted translation, and built-in quality checks, you can ship multilingual updates faster, reduce errors, and spend less.

The localization problem for big SaaS

Scaling a SaaS product to global markets means dealing with complex localization challenges:

Scale & velocity: Hundreds of thousands of strings, dozens of locales, constant deploys.

Cross-team complexity: Product managers, engineers, designers, and vendors need shared workflows.

Speed: Rapid feature releases and constant updates require fast translation cycles.

Quality & compliance risks: Placeholders, RTL support, audit logs, non-negotiable at scale.

Cost control: Seat-based fees, repeated translations, and bloated processes.



Legacy “enterprise” TMS platforms promise solutions but often add slow onboarding and high costs. They require complex setups, charge per seat, and lack the flexibility needed for modern SaaS workflows.

How SimpleLocalize works for enterprise SaaS

SimpleLocalize is a developer-friendly TMS that plugs straight into your CI/CD and publishes translations instantly via a global CDN. It is designed to be easy to use for non-technical team members, with a clean UI and powerful features that make managing translations a breeze.



What you get with SimpleLocalize:

CDN-hosted translations with instant publish & rollback.

API & CLI-first automation for push/pull in pipelines.

Team workflows with roles, approvals, and comments.

Wide format support: JSON, YAML, CSV/Excel, iOS .strings, Android XML, PO, and more.

Flexible integrations with GitHub, GitLab, Bitbucket, and more.

Cost-effective pricing with no surprise fees or per-seat costs.

AI-assist + human review to balance speed and accuracy.

See below how SimpleLocalize addresses the key challenges of large SaaS localization.

Scalability & performance

SimpleLocalize is built to handle large-scale localization needs with ease. Our CDN ensures that translations are delivered quickly and reliably, no matter how many locales, translation keys or strings you manage.

It can handle:

Millions of strings across hundreds of languages and customers without performance issues.

Multiple projects and surfaces, all managed from a single dashboard.

Instant updates and rollbacks so translations go live immediately without waiting for rebuilds.

Real-time updates for dynamic content, ensuring your users always see the latest translations.

Integrations with multiple products, microservices and platforms, allowing you to manage translations across your entire ecosystem.

SimpleLocalize Dashboard

SimpleLocalize's architecture is designed for high availability and performance to ensure that your translations are always accessible and up-to-date.

Continuous localization & automation

SimpleLocalize supports continuous localization, allowing you to push new strings and pull translations in real-time. This means you can update your application with the latest translations without waiting for a full release cycle.



For continuous localization, with SimpleLocalize you can:

Detect and import new or changed strings automatically.

Publish to CDN in seconds; apps fetch the latest at runtime.

Safely A/B test translations by environment or namespace.

Rollback translations instantly if issues arise.

Automate workflows with webhooks and event triggers.

CI/CD-native integration

Ship localization the same way you ship code. SimpleLocalize integrates with your CI/CD pipelines, allowing you to automate the localization process as part of your development workflow. This means you can push new strings, pull translations, and deploy updates without manual intervention.



SimpleLocalize's with developer and API-first approach means you can integrate localization into your existing workflows without disruption. Some popular integrations include:

GitHub & GitHub Actions

GitLab CI

Bitbucket Pipelines

IDE plugins for VS Code and IntelliJ

Figma for design teams

For localization workflow examples, check out our blogn on AI-powered localization workflows.

Collaboration across teams

Collaboration is key to successful localization, especially in large organizations with multiple teams involved. SimpleLocalize provides a range of features to facilitate collaboration:



Invite internal teams and vendors with role-based access.

Granular permissions for access, editing, reviewing, and publishing.

Language-scoped permissions for contractors; keep strategic locales internal.

Commenting and screenshot linking for context.

Workflow automation for reviews, approvals, and QA.

Quality & consistency

SimpleLocalize helps you maintain high-quality translations across your products. Our platform includes features to ensure consistency and accuracy:

QA checks for placeholders, formatting, and common errors run automatically.

Translation length limits prevent runtime errors.

Translation Memory to maintain consistency across products and marketing.

Machine translation (MT) + human review workflows for speed and quality balance.

Live quality checks for translations



Security & compliance

Security is a top priority for large SaaS companies, and SimpleLocalize is designed with this in mind:

Enterprise-grade security with SSO, SAML included.

Role-based access control to restrict sensitive locales.

Audit logs for tracking changes and approvals.

Data encryption in transit and at rest.

GDPR-compliant data handling and storage.

Organization projects and environment separation (dev/stage/prod).



Analytics & insights

SimpleLocalize provides analytics and insights to help you understand the impact of your localization efforts:

Translation progress tracking by language, project and team.

Time spent on translations and details of translation changes.

General statistics on translation quality, including MT vs human review.

Translation project statistics

In case you need more advanced analytics, contact us to discuss custom solutions.

Support for complex SaaS needs

SimpleLocalize is designed to handle the unique challenges of large SaaS companies:

Multi-product support: All your translation projects in one place.

Multi-environment workflows: Separate dev, stage, and prod environments.

In-context editing: Edit translations directly in your application for better context and accuracy.

Customer-specific translations: Customize translations per client or segment.

QA checks: Automated checks for placeholders, formatting, and consistency.

Tags and namespaces: Organize keys via tags or namespaces for better management.

A/B testing: Test different translations and measure their impact on conversion or engagement.

Custom workflows: Set up custom workflows to match your existing processes, including review cycles, approvals, and notifications.

Multi-format support: Import/export translation files to JSON, YAML, CSV, Excel, Android XML, iOS strings, and more.

Real cost advantages (without compromise)

Predictable pricing matters at scale. With SimpleLocalize you can:

Avoid per-seat surprises. Bring reviewers, PMs, and engineers into the process freely.

Pay only for what you use, with no hidden fees or unexpected costs.

Customize your plan with extra translation keys or MT credits as needed.

Use MT + human review for the right content types to cut costs and time.

Publish via CDN to eliminate “copy-only” rebuilds and hotfix releases.

Reduce total spend by automating repetitive tasks and minimizing manual effort.

Check out our pricing page for details and the Business plan features. For custom needs, we offer tailored solutions for large enterprises.

SimpleLocalize plans

Migration made easy

Switching to SimpleLocalize is straightforward, with tools to help you migrate your existing translations:

Import existing translations from your repo or current TMS (JSON/YAML/CSV).

Use our CLI/API to push existing translations into SimpleLocalize.

Import your translation memory to maintain consistency (contact us).

Integrate upload/download/publish into CI; set per-environment tokens.

Add users and set up roles to match your existing workflows.

Set up translation automations and webhooks to match your current processes.

Cut over to CDN fetch; monitor and roll back if needed.

We are here to help with any migration challenges and can provide support during the transition.

FAQs for enterprise buyers

Can we host translations ourselves?

Yes. You can bundle files at build time and/or use CDN hosting for instant updates. Many teams combine both.

How do we control who sees what?

Projects, roles, and language-scoped permissions keep access tight. Separate dev/stage/prod and rotate tokens per environment.

What about SSO and data residency?

Available in our Business plan. Tell us your requirements, SOC reports, SSO/SAML, and regional hosting options can be aligned to your policies.

How does SimpleLocalize handle large volumes of strings?

SimpleLocalize is designed to handle millions of strings efficiently. Our CDN ensures fast delivery, and our API and CLI allow you to automate the localization process, making it easy to manage large volumes of strings across multiple locales.

Can we use our own translation vendors?

Yes, you can invite your own translation vendors to collaborate on projects. SimpleLocalize supports role-based access control, allowing you to manage who can edit, review, and publish translations.

Can we use our own API keys for machine translation?

Yes, you can use your own API keys for machine translation services. SimpleLocalize supports integration with DeepL, Google Translate and OpenAI for machine translation, allowing you to choose the service that best fits your needs.

Get started with SimpleLocalize

As an alternative to TMS platforms like Phrase, Lokalise or Crowdin, SimpleLocalize is built for modern SaaS teams that need speed, flexibility, and cost-effectiveness.

If you are looking for a translation management system that can scale with your needs, provide enterprise-grade features, and help you ship multilingual products faster, sign up for a free trial today.

Need more time to evaluate? Contact us to request an extended free trial of the Business plan or discuss custom enterprise solutions tailored to your needs.

SimpleLocalize's Translation Editor for SaaS
]]></content:encoded>
            <category>software localization</category>
            <category>developer</category>
            <category>translation management</category>
            <category>ai</category>
            <category>developer</category>
            <category>SaaS</category>
            <category>enterprise</category>
            <enclosure url="https://simplelocalize.io/blog/enterprise-translation-management-for-large-saas.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[AI-Powered localization workflows for software translation]]></title>
            <link>https://simplelocalize.io/blog/posts/ai-powered-localization-workflows</link>
            <guid>https://simplelocalize.io/blog/posts/ai-powered-localization-workflows</guid>
            <pubDate>Wed, 13 Aug 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Use AI-powered workflows to speed up software localization, integrate with CI/CD pipelines, and ensure translations are accurate, consistent, and release-ready.]]></description>
            <content:encoded><![CDATA[AI is transforming how software teams translate and localize their products, shifting from slow, manual processes to automated, context-aware workflows that run alongside your code deployments.
With the right setup, you can go from “feature merged” to “available in five languages” in hours, not weeks.

This guide focuses on AI-powered localization workflows: how to integrate them into your development process, choose the right tools, and keep translations accurate without slowing down your releases.

Why AI is a game changer for localization

Traditional localization workflows are often slow and repetitive:

Extract text from code.

Send it to translators.

Wait for files to come back.

Merge, fix, and redeploy.

This cycle can take weeks, especially for large applications with multiple languages.

AI speeds this up by providing:

Instant draft translations for any language.

Scalable updates for new features across all supported locales.

Lower costs by reducing human translator time on first-pass content.

Integration into CI/CD so translations happen automatically with each build.

When combined with developer-friendly platforms like SimpleLocalize, AI translations can run as part of your pipeline, turning localization into just another automated build step.

Choosing the right AI provider

Each AI translation provider has strengths. Your choice depends on tone, accuracy needs, language coverage, and cost.

| Provider | Best for | Standout features |
|----------|----------|-------------------|
| OpenAI   | Natural, human-like text | Flexible tone/style prompts |
| DeepL    | European languages, high accuracy | Great with idioms and context   |
| Google Translate | Wide language coverage, low cost | Instant translations at scale      |
| Microsoft Translator | Enterprise, Azure integration | Easy ecosystem fit |

When selecting a provider, consider:

Tone requirements (marketing vs. technical documentation)

Language coverage (do you need rare languages?)

Integration ease (API, SDKs, CLI tools)

Cost (tokens vs. characters, free tiers)

For a deeper translation output comparison, see our AI & machine translation comparison.

Also, check out our complete list of machine and AI translation providers to see all available options.

Tools for smoother localization workflows

AI translation is just one piece of the puzzle. Here are some essential tools and features that make localization easier for developers:

Pseudo-localization for layout and overflow testing (e.g., using In-context Editor).

Grammar/style QA, e.g., LanguageTool.

IDE integrations to manage strings without leaving your editor (e.g., SimpleLocalize VS Code extension or IntelliJ plugin)

Continuous integration checks catch missing keys or placeholders before deployment.

Translation memory to reuse existing content and cut costs.

These tools pair well with SimpleLocalize's CLI, API, and automations for a fully scripted translation pipeline.

Example workflows for AI-powered localization

Below are five common approaches to integrating AI into localization workflows. Pick the one that fits best your release process.

CLI + manual control

A hybrid approach: manual triggers with automation for speed.

Steps:

Commit new feature code with new strings to your repository.

Extract new strings (e.g., using FormatJS CLI).

Push extracted strings to SimpleLocalize via CLI.

Run AI translation via CLI.

Download translations.

Commit & deploy.

Localization workflow with CLI and manual control

Sample pseudo code for CLI usage:

Description:

This workflow gives you full control over when translations are updated and allows manual review before deployment.
It's one of the most common approaches for teams that want to integrate AI translation without fully automating the process.
You can also move part of the process to a CI/CD pipeline depending on your preferences.

CLI + GitHub Actions

Automate the CLI steps with GitHub Actions to reduce manual work but keep review before deployment.

Steps:

Push new code to your repository.

GitHub Actions workflow runs automatically:

Extracts new strings (e.g. with formatjs extract),

Runs AI translation via SimpleLocalize CLI,

Commits translations back to the repository.

Deploy the localized build.

Localization workflow with CLI and GitHub Actions

Description:

This approach automates the translation process while still allowing you to review changes before they go live. Similar workflows can be set up with other CI/CD systems like GitLab or Bitbucket.

Fully automated publication

This is the most automated approach, ideal for teams aiming for “zero-touch” localization.

Preconfiguration steps:

Set up automation in SimpleLocalize to run AI translation automatically on new strings.

Configure automation to publish translations immediately after AI translation completes.

Localization workflow:

Commit new feature code with new strings to your repository.

Extract new strings and push them to SimpleLocalize (e.g., using FormatJS CLI).

SimpleLocalize detects changes, triggers AI translation automation, and publishes translations automatically.

Localization workflow with fully automated publication

Description:

Your app receives updated translations instantly without manual intervention or the need to redeploy.

The downside is this may lead to unreviewed translations going live, so this workflow is best when speed is more important than perfect accuracy.

Continuous localization via i18next

A popular setup for JavaScript apps that combines AI with continuous translation of missing keys using the i18next library.

Steps:

Configure the missingKeyHandler function to automatically create keys when missing translations are detected.

Set up SimpleLocalize automation to run AI translation on new keys and publish updates.

Your app always has the latest translations without manual steps.

Localization workflow with continuous localization

Description:

This approach works well for apps with frequent string changes, ensuring translations stay current automatically.
Translators can review and improve AI-generated content in the SimpleLocalize editor after generation.

The downside is it may create many unused keys, requiring manual cleanup. Check out our guide on cleaning unused keys to help with that.

CI/CD after translation changes

This workflow triggers your CI/CD pipeline automatically after translations are updated, enabling automatic deployment of localized builds. The below example uses GitHub Actions, but similar setups can be done with other CI/CD systems.

Steps:

New strings are pushed to the repository.

Configure a SimpleLocalize webhook to trigger on CHANGE events in the translation editor.

Set up a GitHub Actions workflow to listen for repository_dispatch events and run your build/deploy pipeline:

Your pipeline runs whenever translations are updated in the editor.

Localization workflow with CI/CD after translation changes

Description:

This is a great choice for teams tightly integrating localization with CI/CD and wanting to ensure translations are always included in builds without manual triggers.

The downside is it may cause frequent builds, which can be costly or time-consuming if not managed carefully.

Summary

Here's a summary of the different AI-powered localization workflows and their pros/cons:

| Workflow | Automation level | Pros | Cons | Best for |
|----------|------------------|------|------|----------|
| CLI + manual control | Low | Full control, manual review | Slower, more manual steps | Teams wanting control without full automation |
| CLI + GitHub Actions | Medium | Automates extraction and translation; allows review | Still requires manual deployment step | Teams using GitHub, want some automation |
| Fully automated publication | High | Fully automated translation and publishing | Translations may go live without review | Teams prioritizing speed over perfect accuracy |
| i18next continuous localization | High | Always up-to-date translations | May create unused keys, requires cleanup | Apps with frequent string changes |
| CI/CD after translation changes | High | Automatic deployment after translation updates | Frequent builds, may be costly |  Teams with tight CI/CD integration |

You can mix and match these approaches based on your team's needs. For example, you might use CLI + manual control for critical strings but automate everything else.

Best practices for AI-powered localization

When using AI for translations, keep these best practices in mind:

Write clear source strings for better AI output.

Preserve placeholders ({username}, %s) as some AI models can rewrite or drop them if not instructed properly.

Include context (key descriptions help models translate accurately).

Review high-impact strings manually before release (marketing copy, UI-critical text).

Batch API requests to reduce cost and improve speed.

Note that AI should assist human translators, not replace them, especially for critical content. AI gives translators a head start and helps them focus on quality rather than repetitive tasks.

Developer-friendly workflow features in SimpleLocalize

AI translation is just the start. SimpleLocalize offers developer-oriented features that fit into your existing stack:

MCP Server for secure, controlled translation workflows (Introducing MCP Server)

Automatic message extraction from source code using AI and i18n-wizard (i18n-wizard guide)

Translation memory for consistency and cost savings

Version control friendly JSON/YAML formats

CLI and API for automation and CI/CD integration

Webhooks for real-time updates

Public translation suggestions and AI fixes directly in the editor

By weaving AI into your localization pipeline, from string extraction to deployment, you can keep your product global-ready without slowing development.
]]></content:encoded>
            <category>software localization</category>
            <category>tips</category>
            <category>ai</category>
            <category>openai</category>
            <category>auto translation</category>
            <category>developer</category>
            <enclosure url="https://simplelocalize.io/blog/ai-powered-localization-workflows.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[List of AI and machine translation providers]]></title>
            <link>https://simplelocalize.io/blog/posts/top-machine-ai-translation-providers</link>
            <guid>https://simplelocalize.io/blog/posts/top-machine-ai-translation-providers</guid>
            <pubDate>Tue, 05 Aug 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Compare leading AI and machine translation providers like DeepL, Google Translate, OpenAI, and others. See how to choose the best one for your localization needs.]]></description>
            <content:encoded><![CDATA[Auto-translation is a crucial component of modern localization workflows. From SaaS platforms and mobile apps to e-commerce and internal tools, automated translation helps teams reduce localization time and costs while supporting global users efficiently.

In this guide, you will find a comprehensive overview of top translation providers, both neural machine translation (NMT) engines and AI/LLM-based systems, with details about language support, pricing, API access, developer tools, and SimpleLocalize compatibility.

Overview of translation providers

This table summarizes the key features of the top machine and AI translation providers as of 2025. It includes their type, language support, API availability, and best use cases.

| Provider                                                                                                           | Type     | Languages | API | Best for                                            |
|--------------------------------------------------------------------------------------------------------------------|----------|-----------|-----|-----------------------------------------------------|
| DeepL                                                   | NMT      | 36        | Yes | High-quality, context-aware translations            |
| Google Translate   | NMT      | 249       | Yes | Speed, affordability, wide language support         |
| Microsoft Translator                     | NMT      | 179       | Yes | Enterprise integration, Microsoft ecosystem         |
| Amazon Translate                             | NMT      | 75        | Yes | Scalable, cost-effective within AWS                 |
| SYSTRAN                                               | NMT + AI | 55+       | Yes | Secure, regulated environments                      |
| IBM Watson Language Translator | NMT + AI | 50+       | Yes | Customizable, secure translation pipelines          |
| OpenAI (ChatGPT)                               | LLM      | All       | Yes | AI-powered, conversational and creative translation |
| Anthropic (Claude)                           | LLM      | All       | Yes | Context-rich LLM translation                        |
| Mistral                                               | LLM      | All       | Yes | Open-source, customizable LLM translation           |
| Cohere                                                 | LLM      | All       | Yes | Flexible, API-driven LLM translation                |

Translation providers

These services use neural machine translation (NMT) engines to provide fast, scalable translation capabilities. They are typically used for high-volume content where speed and cost are priorities.

DeepL

DeepL is known for its high-quality translations, especially in European languages. It uses advanced neural networks and has a strong focus on context and nuance. It focuses on accuracy and tone, making it popular among professionals.

DeepL logo

Type: NMT

Languages: 36

AI Features:  Text generation, context understanding, Clarify

API: DeepL API

Web app: DeepL Translator

Mobile apps: iOS and Android

Pricing: Free tier; paid from €8.99/month

Best for: High-quality, natural-sounding translations

Strengths: Exceptional fluency in European languages; supports glossaries and context

Weaknesses: Limited language support compared to Google Translate; may not handle technical jargon as well as some competitors

SimpleLocalize Support: Yes

Google Translate / Google Cloud Translation

Google Translate is the most widely used MT system globally, translating over 100 billion words per day. With Google Cloud Translation AP they are are powerful tools for high-volume and high-speed translation across nearly every language.

Google Translate logo

Type: NMT

Languages: 249

AI Features: Context-aware translation, AutoML, Glossaries

API: Cloud Translation API

Web app: Google Translate

Mobile apps: iOS and Android

Pricing: Free tier; paid from $10 per million characters

Best for: Speed, affordability, wide language support

Strengths: Extensive language support, fast processing, integrates with other Google services

Weaknesses: May lack the nuance and context of DeepL; can produce less natural-sounding translations in some languages

SimpleLocalize Support: Yes

Microsoft Translator

Microsoft Translator is part of the Azure Cognitive Services suite, optimized for enterprise environments and integrates well with Microsoft products and Azure services.

Microsoft Translator logo

Type: NMT

Languages: 179

AI Features: Customizable models, custom glossaries, security

API: Translator Text API

Web app: Bing Microsoft Translator

Mobile apps: iOS and Android

Pricing: Free tier; paid from $10 per million characters

Best for: Enterprise integration, Microsoft ecosystem

Strengths: Customizable models, enterprise security, Azure integration

Weaknesses: May not match DeepL's quality in some languages; less focus on European languages

Amazon Translate

Amazon Translate is designed for developers working within AWS. It supports bulk processing and is cost-effective for high-volume needs.

Amazon Translate logo

Type: NMT

Languages: 75

AI Features: Custom terminology, batch translation

API: Amazon Translate API

Web app: None (API-based service)

Pricing: Free tier; paid from $15 per million characters

Best for: Scalable backend translations

Strengths: Scalable, cost-effective, solid baseline quality

Weaknesses: Limited language support compared to Google; may not handle nuanced translations as well as DeepL

SYSTRAN

SYSTRAN offers both NMT and AI-based translation solutions, focusing on on industry-specific and privacy-sensitive environments like government, legal, and healthcare.

SYSTRAN logo

Type: NMT + AI

Languages: 55+

AI Features: Custom domains, on-premise deployment

API: SYSTRAN Translate API

Web app: SYSTRAN Translate

Pricing: Free tier; paid from $15 per month (PRO API)

Best for: Secure, regulated environments

Strengths: Strong in regulated industries, customizable for specific domains, good security features

Weaknesses: Smaller language set than Google or Microsoft; may not be as fluent as DeepL in European languages

IBM Watson Language Translator

IBM Watson supports multiple domains like patents, finance, and medicine. It's suitable for industries requiring customizable and secure translation pipelines, especially where privacy and on-premise hosting are key.

IBM Watson logo

Type: NMT + AI

Languages: 50+

AI Features: CDomain adaptation, on-premise options

API: Watson Language Translator API

Best for: Industry-grade, customizable solutions

Strengths: Strong in domain-specific translations, customizable models, good security features

Weaknesses: Limited language support compared to Google; may not be as fluent as DeepL in European languages

AI and LLM-based translation providers

These providers leverage large language models (LLMs) to offer advanced translation capabilities, often with a focus on context, creativity, and conversational AI. They are ideal for applications requiring more than just literal translations.

OpenAI (ChatGPT)

OpenAI provides powerful LLMs like ChatGPT that can handle translation tasks with a focus on context and natural language understanding. They are particularly useful for creative and conversational translations. It's ideal for short strings, variable context, and user-generated content.

OpenAI logo

Type: LLM

Languages: All major languages

AI Features:  Tone matching, variable handling, contextual awareness

API: OpenAI API

Web app: ChatGPT

Mobile apps: iOS and Android

Pricing: Free tier; Pay-as-you-go (API); ChatGPT Plus for $20/month

Best for: Creative and dynamic translation

Strengths: Contextual understanding, conversational tone, flexible handling of variables

Weaknesses: May not be as accurate for technical translations; requires careful prompt engineering for best results

SimpleLocalize Support: Yes

Anthropic (Claude)

Anthropic offers Claude, a powerful LLM that excels in understanding context and generating human-like translations. It handles large-context translations well, with a focus on safety and reliability.

Anthropic logo

Type: LLM

Languages: All major languages

AI Features: Contextual understanding, safety features

API: Anthropic API

Web app: Claude

Mobile apps: None (API-based service)

Pricing: Pay-as-you-go (API)

Best for: Context-rich translations

Strengths: Strong contextual understanding, safety features, good for complex translations

Weaknesses: May not be as widely adopted as OpenAI; requires careful prompt engineering for best results

Mistral

Mistral is an open-source LLM that provides flexible translation capabilities. It allows developers to customize models for specific translation tasks, making it suitable for specialized applications.

Mistral logo

Type: LLM (Open-source)

Languages: Multilingual (depending on model)

AI Features: Fine-tuning, open weights, customizable

API: Mistral API

Web demos: Available via third-party providers (e.g., Hugging Face Spaces)

Pricing: Open-source; pay for hosting/API usage

Best for: Customizable, open-source translation

Strengths: Open-source flexibility, customizable models, good for specialized applications

Weaknesses: Requires technical expertise to set up and maintain; may not have the same level of support as commercial providers

Cohere

Cohere provides LLMs that can be used for translation tasks, focusing on flexibility and API-driven access. It allows developers to integrate translation capabilities into their applications easily.

Cohere logo

Type: LLM

Languages: Multilingual (depending on model)

AI Features: Text generation, embeddings, RAG

API: Cohere API

Web app: None (API-based, CLI tools available)

Pricing: Pay-as-you-go (API)

Best for: Flexible, API-driven translation

Strengths: Easy API integration, flexible usage, good for dynamic applications

Weaknesses: May not have the same level of language support as larger providers

Smaller and specialized providers

In addition to the major players, there are several smaller and specialized translation providers that focus on niche markets or specific languages. These can be valuable for certain use cases, such as legal, medical, or technical translations.

ModernMT: An open-source NMT engine that allows for customizable translation models, suitable for specialized domains.

LingvaNex: Offers translation APIs and SDKs for various platforms, focusing on privacy and security.

Tilde: A translation platform that combines NMT with human post-editing. Provides secure, custom MT for public institutions. Specializes in Baltic and Nordic languages.

Intento: An aggregator of multiple MT engines via unified API, allowing users to choose the best engine for their needs.

Prompt: Long-established MT provider with desktop and server solutions, strong in Russian, German, and European language pairs.

Apertium: An open-source rule-based MT system, particularly strong in Spanish and Catalan languages. It is community-driven and supports many language pairs. Used in academic and public research projects.

KantanMT: A customizable MT built for enterprises, allowing users to create their own translation models. It supports a wide range of languages and domains.

eTranslation (EU): The European Commission's translation service, providing high-quality translations for EU institutions and citizens. It supports all official EU languages and is focused on public sector needs.

Elia AI: A translation platform that combines AI and human expertise to provide high-quality translations, specialized in document translation with structure preservation. Suitable for PDFs, manuals, and technical content.

TranslateFX: A translation service that focuses on financial and legal documents, providing specialized translations with a strong emphasis on accuracy and compliance.

Reverso: A translation and language learning platform that offers contextual translations, synonyms, and examples. It is particularly useful for language learners and casual users.

Papago: A translation service by Naver, popular in South Korea. It supports multiple languages and is known for its accuracy in Asian language pairs.

How to choose the best translation provider

When selecting a translation provider, consider the following factors:

Language support: Ensure the provider supports the languages you need, especially if you have specific regional requirements.

Quality: Evaluate the translation quality for your specific content type. Some providers excel in certain languages or domains.

API access: Check if the provider offers a robust API for integration into your applications. This is crucial for automating translation workflows.

Pricing: Compare pricing models, including free tiers, pay-as-you-go options, and subscription plans. Consider your expected volume of translations and budget.

Developer tools: Look for SDKs, libraries, and documentation that make it easy to integrate the translation service into your applications.

Customization: If you have specific terminology or style requirements, check if the provider offers customization options like glossaries or domain adaptation.

Security and compliance: For sensitive content, ensure the provider meets your security and compliance requirements, especially if you operate in regulated industries.

Check out our comparison of DeepL, Google Translate, and OpenAI for more details on how these providers stack up against each other in terms of features, pricing, and performance.

Auto-translate your software with SimpleLocalize

For software localization, auto-translation is a powerful tool that can significantly speed up the process. Thanks to the integration with translation providers, you can automatically translate your software strings and content directly within your localization platform.

For example, SimpleLocalize supports the most popular translation providers, allowing you to:

Automatically translate your software strings using DeepL, Google Translate, OpenAI, and others.

Use glossaries and context features to improve translation quality.

Customize translations with your own terminology and style preferences.

Use your own API keys to connect to translation providers.

Learn more about auto-translation features in SimpleLocalize documentation and check out our tips for effective auto-translation to get the best results.

Register for a free account on SimpleLocalize and start automating your software translations today!

SimpleLocalize's translation interface
]]></content:encoded>
            <category>software localization</category>
            <category>deepl</category>
            <category>google translate</category>
            <category>openai</category>
            <category>chatgpt</category>
            <category>auto translation</category>
            <category>machine translations</category>
            <enclosure url="https://simplelocalize.io/blog/top-machine-ai-translation-providers.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[10 tips for creating a language selector in your website or app]]></title>
            <link>https://simplelocalize.io/blog/posts/language-selector-best-practices</link>
            <guid>https://simplelocalize.io/blog/posts/language-selector-best-practices</guid>
            <pubDate>Mon, 04 Aug 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to design an effective language selector for your website or app. Improve user experience, accessibility, and internationalization with these expert tips.]]></description>
            <content:encoded><![CDATA[A well-designed language selector plays a small but critical role in creating a smooth, accessible, and inclusive experience for users around the world. The way how users select their preferred language can significantly impact their interaction, engagement, and overall satisfaction with your website or app.

In this post, we will share 10 practical tips for creating an intuitive language selector, and show you how tools like SimpleLocalize can help you implement these best practices effectively.

Why is a language selector so important?

A language selector isn't just a dropdown. It's a key part of your localization strategy. When done right, it allows users to switch languages easily, ensuring they can navigate your content in a language they understand. It makes your produce feel native and accessible to a global audience, enhancing user experience and engagement.

But a poorly designed language selector? It can confuse users, damage trust, and even drive people away.

Here's how to do it right.

10 tips for creating a language selector that works

1\. Avoid using flags as language indicators

Using flags to represent languages can be misleading. Flags represent countries, not languages, and many countries have multiple official languages.

For example, Spanish is spoken in over 20 countries, and Arabic has regional variants. Using a single flag to represent a language can confuse or even offend users.

Instead, use language names in their native scripts (e.g., "Español" for Spanish, "العربية" for Arabic) to ensure clarity and inclusivity.

Example of language selector with and without flags

Read more: Flags in language selectors: Should we keep or remove them?

2\. Keep it simple and intuitive

A language selector should feel like a natural part of your interface, not a distraction. The design should be clean and straightforward, allowing users to find and select their preferred language quickly.

Stick to clean dropdowns, menus, or toggles that fit your branding. Don't clutter it with unnecessary icons or animations.

Looking for inspiration? Check out UI design examples of language selectors

3\. Show language names in both native and localized forms

Displaying language names in both the target language and the current language is super helpful. For example:

العربية / Arabic

Español / Spanish

Deutsch / German

Français / French

中文 / Chinese

日本語 / Japanese

Depending on user current language, this dual display helps them recognize their preferred language quickly, especially if they are not fluent in the current language.

Example of language selector with native and localized names

Using both forms is a perfect solution for accessibility, as it caters to users who may not be familiar with the language names in their native script. However, be careful not to overwhelm users with too much text. Keep it concise and clear.

For a simpler approach, use just the native language name, especially if your audience is familiar with it.

4\. Use standard locale codes

Leverage locale codes like en-US, fr-FR, or es-MX in your backend or codebase to manage translations more efficiently. This also helps when you want to customize content based on region-specific variants.

There are different ways of using locale codes in your URL structure, see URLs in website localization.

5\. Include a search field (for long lists)

If your website or app supports many languages, consider adding a search field to the language selector. Thanks to this, users can quickly find their preferred language without scrolling through a long list.

Search field in language selector

6\. Place it where users expect it

The placement of your language selector matters. Users typically look for it in:

Header: Top right corner is a common spot.

Footer: Some users expect to find it at the bottom of the page.

Settings menu: If your app has a settings or profile section, consider placing the language selector there.

Welcome screen: If your app has a welcome or onboarding screen, you can include the language selector there.

Example of language selector in header and footer

Wherever you place it, make sure it's easy to spot and access but not overly prominent.
Avoid hiding it behind multiple clicks or in obscure menus.

7\. Make it accessible

Accessibility is crucial for a language selector. Make sure your language selector is accessible via keyboard and screen readers. Use semantic HTML elements and ARIA labels when necessary so that everyone, including users with disabilities, can interact with it.

For more tips on making your website accessible, check out our post on website accessibility.

8\. Allow remembering language preferences

Use cookies or local storage to save the selected language for future visits. This prevents users from having to re-select their preferred language every time.
When users return to your site or app, automatically load their last selected language. It will enhances the user experience and reduce frustration.

9\. Provide context in language names

For similar languages or dialects, provide additional context in the language names. For example:

Português (Brasil) vs Português (Portugal)

English (US) vs English (UK)

Español (Latinoamérica) vs Español (España)

This helps users choose the right variant for their needs, especially in multilingual regions.

Example of language selector with context in names

10\. Test with real users

Before you ship your language selector, test it with users from different regions and backgrounds. Gather feedback on usability and make adjustments based on real behavior, not assumptions.

Bonus tip: Integrate a localization platform

Localization is more than just switching languages. It's about managing translations, reviewing content, and keeping things in sync. A tool like SimpleLocalize can help you:

Manage translations in one place

Collaborate with translators

Use locale files directly in your code

Integrate with popular frameworks like Next.js and React

Learn more: What is translation management?

Example of localization project in SimpleLocalize

Choosing the right language selector style

Depending on your website or app design, you can choose from various language selector styles. Here are some common options:

A dropdown menu in the header and/or footer

A modal or popup with a full list of languages and search

A language picker screen before onboarding or login

A settings panel option for logged-in users

The key is to match your user flow and keep language switching intuitive.

Start localizing with confidence

Want to build a multilingual app that feels native to every user?

Start localizing your website today with SimpleLocalize, the flexible translation platform that grows with you. No more copy-pasting strings or messy spreadsheets. Just fast, clean localization your way.

Explore how to build a custom language selector using Next.js and Tailwind CSS
]]></content:encoded>
            <category>language selector</category>
            <category>design</category>
            <category>developer</category>
            <category>designer</category>
            <category>accessibility</category>
            <category>tips</category>
            <category>ui</category>
            <enclosure url="https://simplelocalize.io/blog/language-selector-best-practices.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Design that speaks every language: UI tips for localization]]></title>
            <link>https://simplelocalize.io/blog/posts/ui-localization-best-practices</link>
            <guid>https://simplelocalize.io/blog/posts/ui-localization-best-practices</guid>
            <pubDate>Thu, 24 Jul 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Discover UI localization tips: handle text expansion, adjust layouts, and design for cultures to create user-friendly, multilingual apps.]]></description>
            <content:encoded><![CDATA[Localization is not only about reaching global audiences, it's about building comfort, clarity, and trust. That's why we translate and localize our content: not just to make it available, but to make it feel right. When users land on a page that reflects their language, culture, and expectations, they feel at home, and that's the experience we aim to offer.

But localization goes beyond translating strings. It shapes the way people navigate your interface, interpret icons, and understand forms. If your UI doesn't adapt with the content, the experience falls apart.

So how do you localize in a way that makes the entire interface feel natural? Let's walk through some best practices for UI localization that ensure your designs resonate with users across different languages and cultures.

Language doesn't just change words, it changes space

One of the first surprises in localization is how much space different languages need. A short button in English might double in length in German. A tightly packed layout in Japanese might feel awkward when translated to French.

Build flexible, responsive layouts that can expand and contract with the content.

Text expansion example in a website header

Flexible layout design is essential. Avoid fixed widths for buttons, nav bars, and modals. Let containers grow (or shrink) with the text. This prevents truncated content and ugly overflow, and it ensures your interface adapts to the user, not the other way around.

Tip: Try using the SimpleLocalize Figma plugin to test different languages in your UI mockups. It's a great way to spot layout issues early. Learn more about it in our Figma localization tutorial.

Layout and flow should follow the language

Text direction is another critical piece. When localizing for RTL (right-to-left) languages like Arabic or Hebrew, the entire experience should reflect that direction. Sliders, icons, pagination, and even the reading order of text should mirror the language flow.

Mirror navigation and content flow for RTL languages to match reading habits and user expectations.

RTL web translation

If your design assumes left-to-right reading by default, an RTL user might feel disoriented. Make sure your layout logic respects language direction so users feel in control and understood.

Choose fonts that speak the script

Not all fonts are created equal. Some don't support Chinese characters, Cyrillic script, or accents used in Vietnamese. Others might render in a way that feels unbalanced or cramped in certain languages.

Pick fonts that support multilingual character sets and maintain readability across scripts.

Font selection for multilingual support

Good localization includes thoughtful typography. Choose fonts with wide language support, and test how they appear with your UI. Make sure they maintain readability and visual harmony, especially at smaller sizes or in complex interfaces.

Use system fonts where possible, as they often have better support for multiple languages and scripts.

Icons, symbols, and cultural context

A thumbs-up icon might seem universally positive, but that's not always the case. Colors like red or white carry different cultural meanings. Even an envelope icon for email may not hold the same meaning globally.

Choose visuals that are culturally appropriate or swap them out entirely for certain locales.

Culturally appropriate icons

Localization isn't just about words. Visual elements carry cultural weight. It's worth reviewing icons, illustrations, and even emoji with cultural relevance in mind. Swapping out images to reflect local customs, currency, or attire can go a long way in making users feel like the product is truly for them.

Some examples of culturally sensitive icons include:

A thumbs-up (👍) icon is positive in many Western cultures, but in some places, it can be offensive.

A checkmark (✔️) might not be universally understood as "correct" or "approved"; in some cultures, e.g., in Sweden or Japan, it can signify "no" or "incorrect."

A shopping cart icon might be replaced with a basket in some cultures.

A calendar icon could be adjusted to reflect local holidays or date formats.

A piggy bank icon for savings might not resonate in cultures where saving is represented differently.

Color use: Red can signal danger in Western cultures, but in China, red symbolizes good luck and positivity. A red “error” message might feel unintentionally harsh in some locales.

Navigation arrows might need to be flipped for RTL languages.

Formats, forms, and the small stuff

Don't overlook the tiny UI elements, they matter more than you think. Date formats vary (MM/DD/YYYY vs DD/MM/YYYY), decimal points and thousands separators change by region, and name order isn't the same everywhere.

Adapt all small UI details, dates, numbers, names, addresses, to the user's locale, not your own.

Date and number formats

Forms in particular need attention. Consider:

Postal codes that don't use numbers

Phone numbers with different country codes and formats

Address structures that don't follow street-city-zip conventions

Date formats that vary widely (e.g., 01/02/2023 vs 02/01/2023)

Currency symbols that change placement (e.g., $100 vs 100€)

Time formats that differ (12-hour vs 24-hour clocks)

Units of measurement that vary (imperial vs metric)

Gendered forms that require different translations or structures

Pluralization rules that differ by language

If your UI makes assumptions based on a single country or language, localized users will hit friction, and friction drives them away.

Check out our blog post on number formatting in JavaScript for more on handling numbers and dates in a localized way.

Language selection and user control

Finally, let users choose their language. Don't assume it based on their IP address or browser settings. A user might prefer to read in a different language than the one set by default.

Provide a clear language selector that respects user choice and allows easy switching.

Language selector example

Make it easy for users to switch languages at any time. This not only respects their preferences but also allows them to explore your content in different languages, which can be a great learning experience.

Check out our examples of language selectors in popular apps for inspiration on how to implement this effectively.

Localization starts with preparation

The good news? Much of this can be handled proactively. Tools like SimpleLocalize help manage translations and make it easy to test different language versions in real context. But good localization starts even earlier, with how your UI is built.

Plan for localization early: externalize your strings, structure your UI for adaptability, and test often.

Make sure all translatable content is externalized. Use auto-resizing UI components. Build layouts that can flex. And always test each locale visually, not just in the code editor, but in the interface itself.

You can test translations directly on your website or app using the SimpleLocalize In-Context Editor. It allows you to see how translations look in real time, ensuring your UI feels right in every language.

Localization is a design process

Ultimately, localization is a design process. It's about empathy. You are not just translating, you are shaping an experience that feels familiar and intuitive to someone from a different culture, using a different script, thinking in a different language.

When localization is done well, it doesn't feel like translation, it feels like home.

The best localized apps and websites don't feel like translations. They feel like they were built right there, by someone who knows the user well. That's what makes the difference, and that's what good UI localization should aim for.

For more on localization best practices, check out our Localization Best Practices Guide.

Quick recap: UI localization tips

Here's a quick recap of what to watch for when localizing UI:

Design flexible layouts for content growth

Support RTL languages with mirrored layouts

Use fonts with wide language support

Check icons and visuals for cultural meaning

Format data like dates and numbers per locale

Localize forms to match regional expectations

Let your interface flex, don't hardcode size or content

Test every language visually, not just technically

Allow users to choose their language easily

Use tools like SimpleLocalize to streamline the process

How SimpleLocalize helps with UI localization

SimpleLocalize is designed to make localization easier, especially for UI. Here are some ways it can help:

Figma plugin: Use the SimpleLocalize Figma plugin to synchronize your design texts with SimpleLocalize, making it easy to manage translations directly from your design files.

In-Context Editor: Test translations in real time on your website or app with the SimpleLocalize In-Context Editor, ensuring your UI looks right in every language.

Translation management: Collaborate with translators, manage your translation projects, and keep everything organized in one place.

Auto-translation: Quickly add new languages using the auto-translation feature, which can save time during the initial setup.

Review and approval: Easily review and approve translations, ensuring they fit your design context before going live.

Automate workflows: Set up automated workflows for translation updates, so your UI stays current without manual intervention.

Add screenshots: Help translators understand the context by uploading screenshots of your design, making it easier for them to provide accurate translations.

Comments and feedback: Use comments to communicate with your team or translators directly within the SimpleLocalize platform.

SimpleLocalize's Translation Editor view

Conclusion

Localization is not just a checkbox, it's a commitment to your users. When you design with localization in mind, you create an interface that feels natural, intuitive, and welcoming to everyone, no matter where they are or what language they speak.

If you build your UI with localization in mind from the start, you are not just reaching more users, you are respecting them. And that's the kind of design that earns trust, loyalty, and love.
]]></content:encoded>
            <category>tips</category>
            <category>translation management</category>
            <category>software localization</category>
            <category>design</category>
            <category>ui</category>
            <enclosure url="https://simplelocalize.io/blog/ui-localization-best-practices.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[7 Best Translation Management Tools for SaaS in 2025]]></title>
            <link>https://simplelocalize.io/blog/posts/best-translation-management-software-for-saas</link>
            <guid>https://simplelocalize.io/blog/posts/best-translation-management-software-for-saas</guid>
            <pubDate>Tue, 22 Jul 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Discover the 7 best translation management systems (TMS) for SaaS companies in 2025. Compare features, pricing, integrations, and see which platform best fits your localization workflow.]]></description>
            <content:encoded><![CDATA[Shipping a SaaS product globally is much easier when your translation workflow isn't fighting you. The right translation management software makes localization smoother, faster, and more predictable for product, engineering, and content teams. Below I compare seven well-known translation management systems (TMS), focusing on features SaaS teams actually use, pricing models, and real-world costs for an app with 10,000 translation keys and 16 languages (about 50 internal users).

Quick definitions:

Translation key: a unique ID in your app, e.g. "welcome_message".

String / Term / Translation: the text value for a key in one language.

Hosted words: word count in the source language multiplied by the number of target languages.

Cost assumptions: unless noted, I assume ~5 words per key (UI copy can range 3-7); that means 10,000 keys × 5 words = 50,000 source words, and with 16 languages you host 800,000 hosted words on “hosted words” platforms. I note where vendors price by keys or strings (terms + translations) instead.

Best TMS for SaaS

Here are the top translation management systems for SaaS, with a focus on features, pricing, and real-world costs:

SimpleLocalize

SimpleLocalize is an intuitive TMS for SaaS teams with a clean UI, fast setup, and developer-friendly workflows (CLI, API, GitHub App). It uses per-key pricing with unlimited languages, which keeps costs predictable as you add markets.

SimpleLocalize's Translation Editor

Key features:

Highlights: Modern, minimal UI; customizable workflows & automations; built-in translation hosting/CDN.

Developer workflows: CLI, REST API, translation hosting/CDN, webhooks, GitHub App, IntelliJ and VS Code plugins.

TM / Glossary / QA: Translation memory, screenshots, audit logs and live QA checks.

In-context / design: In context editor, Figma.

AI / MT: Connect Google/DeepL/OpenAI or bring your own keys; AI actions.

Seats & permissions: Business includes 100 team members; unlimited contributors.

Security: SAML/SSO on Business; GDPR friendly.

Pricing type: Per key (languages don't multiply). Business includes 12,000 keys.

Cost estimation (10k keys, 16 languages)

$129/mo (or $99/mo billed annually) on Business; fits under 12k keys, languages unlimited.

Best for: Teams wanting predictable per-key pricing, clean UI, CDN hosting, and developer-friendly workflows.

Check out our SimpleLocalize pricing page for more details.

Crowdin

Crowdin offers a powerful platform with a huge marketplace of integrations and enterprise-grade automation. It prices by hosted words (source words × target languages).



Key features:

Highlights: Hundreds of integrations, robust workflows, enterprise security.

Developer workflows: CLI, API, Git, CI/CD, webhooks.

TM / Glossary / QA: Built-in TM, termbase, QA checks.

In-context / design: In-context for web/mobile; Figma, Sketch, Adobe XD.

AI / MT: Native AI translator + MT connectors.

Seats and permissions: Unlimited translators; manager seats vary by plan.

Security: SSO on Business; enterprise controls.

Pricing type: Hosted words; Team+ starts from $450/mo; you can add hosted words beyond the base cap.

Cost estimation (10k keys, 16 languages, ~5 words/key)

10,000 × 5 = 50k words; × 16 = 800,000 hosted words.

Exceeds Team+ base (500k). You'll need Team+ with additional hosted words for about $500/month.

Best for: Complex stacks needing lots of native integrations and granular automation.

Lokalise

Lokalise combines a polished editor with deep integrations and analytics. It prices by hosted keys (not multiplied by languages).



Key features:

Highlights: Mature workflows, analytics, strong automations.

Developer workflows: API, CLI, SDKs, GitHub/GitLab/Bitbucket, webhooks.

TM / Glossary / QA: TM, glossary, QA (placeholders, ICU), screenshots.

In-context / design: Figma, Sketch, Adobe XD; in-context for web/mobile.

AI / MT: Built-in MT and AI features.

Seats and permissions: 10 seats included on Essential; add more as needed.

Security: SOC2/GDPR posture publicly referenced; SAML/SSO on Enterprise.

Pricing type: Hosted keys; Essential includes 10,000 hosted keys.

Cost estimation (10k keys, 16 languages)

$270/mo (or $230/mo billed annually) on Essential covers 10k hosted keys; languages don’'t multiply usage.

Best for: Product/design-heavy teams that want hosted-key predictability and slick integrations.

POEditor

POEditor keeps things simple and fast. Pricing is by strings, where strings = terms + translations, so languages do multiply usage.



Key features:

Highlights: Quick setup, flexible formats, generous collaborators.

Developer workflows: API, CLI, GitHub/GitLab/Bitbucket, webhooks.

TM / Glossary / QA: TM, glossary, QA checks, audit log on higher plans.

In-context / design: Screenshots/context; Figma via community paths.

AI / MT: Options for MT/AI translation; pay-as-you-go extras.

Seats and permissions: Unlimited contributors on upper tiers.

Security: SSO listed in plan matrix.

Pricing type: Strings (terms + translations); Enterprise includes 100,000 strings at $199.99/mo.

Cost estimation (10k keys, 16 languages)

\~170,000 strings (10k terms + 10k×16 translations).

Exceeds 100k; expect Enterprise ($199.99/mo) + extra string capacity via add-ons (+70k strings via add-ons: $10 per 10k))

Transifex

Transifex is a long-standing enterprise TMS with robust SDKs (Live/Native) and governance. It prices by hosted words. The Growth plan starts from around $570/mo.



Key features:

Highlights: Enterprise workflows, detailed QA & reporting, SDKs.

Developer workflows: API, CLI, webhooks, Git, Figma, CMS integrations.

TM / Glossary / QA: Advanced TM, terminology, quality checks.

In-context / design: Figma, Sketch; Transifex Live for website in-context.

AI / MT: Transifex AI + MT packages.

Seats and permissions: Collaborator caps by tier (e.g., Growth).

Security: SAML/SSO and enterprise controls on upper tiers.

Pricing type: Hosted words (source words × languages).

Cost estimation (10k keys, 16 languages, ~5 words/key)

800k hosted words; expect Enterprise-level packaging (Growth-sized caps are typically lower). Growth plan for 700k words is $2240/mo.

Best for: Enterprises needing advanced governance and website in-context via Live.

Localizely

Localizely is a straightforward, developer-friendly TMS. It prices by hosted string keys with unlimited users and languages on paid tiers.



Key features:

Highlights: Clean UI, OTA for mobile, reasonable learning curve.

Developer workflows: REST API, CLI, GitHub/GitLab/Bitbucket, OTA for mobile.

TM / Glossary / QA: TM & term base; reviewer roles.

In-context / design: Figma, screenshots/context.

AI / MT: MT via integrations.

Seats and permissions: Unlimited users on paid tiers.

Security: GDPR-friendly posture; SSO not publicly highlighted.

Pricing type: Hosted string keys. Silver = 10,000 hosted string keys.

Cost estimation (10k keys, 16 languages)

$300/mo billed annually (or $250/mo monthly) on Silver for 10k keys.

Best for: SMBs whose volume fits cleanly into 5k/10k/20k key tiers and want unlimited users.

Weblate (Hosted)

Weblate is an open-source TMS with a Git-native approach and generous hosted tiers. Pricing is by strings across all languages (strings multiply with languages).



Key features:

Highlights: Open-source roots, self-host option, transparent road-map.

Developer workflows: Git-first sync, API, webhooks, automation.

TM / Glossary / QA: TM, terminology, QA checks.

In-context / design: Screenshots/context; Figma via community paths.

AI / MT: MT connectors; bring your own.

Seats and permissions: Unlimited translators/members on hosted tiers.

Security: Open source, SAML/SSO available; GDPR aware.

Pricing type: Strings across all used languages; notable tiers: 160k = €106/mo, 640k = €178/mo.

Cost estimation (10k keys, 16 languages)

\~170,000 strings total → just above 160k; safest is €178/mo (640k tier).

Best for: Teams that value open-source and may migrate to self-host later.

TMS comparison table

Here is a quick comparison of the TMS options discussed above, focusing on their pricing models, costs, and notable features:

| TMS | Pricing model | Cost (monthly) \* | Seats included | Free trial | Security |
| --- | ------------- | -------------- | -------------- | ---------- | -------- |
| SimpleLocalize | Keys | $129 | 100 | 14 days | GDPR-ready, SAML/SSO |
| Crowdin | Hosted words | $458 | 5 managers (unlimited translators) | 30 days | SOC 2, SAML/SSO |
| Lokalise | Hosted keys | $270 | 10 (extra $27/ mo) | 14 days | SOC 2, GDPR, SAML |
| POEditor | Strings (keys × langs) | $269.99 | Varies per plan; unlimited contributors | 10 days | GDPR, SAML (Enterprise) |
| Transifex | Hosted words | Enterprise+ (Growth plan $2240 not enough) | 30 (Growth) | On request | SOC 2, GDPR, SAML (Enterprise+) |
| Localizely | Hosted string keys | $300 | Unlimited | 15 days | GDPR (no public SSO info) |
| Weblate | Strings (keys × langs) | €178 (~$190) | Unlimited translators | 14 days | Open source, SAML, GDPR |

\*VAT/taxes extra. Vendors frequently discount annual prepay. Always validate current limits in-app.

Check out our blog post on SaaS localization requirements to learn more about how to choose the right TMS for your SaaS product.

How to choose

Each TMS has its strengths, so the best choice depends on your team's needs:

Predictable spend with lots of languages → Keys-priced tools: SimpleLocalize, Lokalise.

Tons of integrations & enterprise workflows → Crowdin, Transifex (budget for hosted-word scaling).

Lowest friction, classic model → POEditor, but remember strings multiply with languages.

Open-source & self-host path → Weblate.

Unlimited users at fixed key tiers → Localizely.

Notes & caveats

Here are some important considerations when evaluating these TMS options:

Pricing models matter:

Keys (SimpleLocalize/Lokalise) → languages don’t change usage.

Strings (POEditor/Weblate) → terms + translations; languages multiply usage.

Hosted words (Crowdin/Transifex) → source words × target languages; UI copy density can swing your bill.

Seats: Some tools include generous seats (e.g., SimpleLocalize 100 members on Business); others include 10 and charge for extras. Double-check before inviting your whole company.

Security: SAML/SSO is typically not on entry tiers. If you require SSO, plan for Business/Enterprise. (POEditor, Crowdin, Weblate, Lokalise list SSO at higher tiers.)

Trials: Most vendors offer free trials; terms vary (e.g., POEditor 10 days). Always sanity-check inside the app.

Last checked: August 22, 2025; vendors update pricing often.

Conclusion

Choosing the right translation management software for your SaaS product can make or break your localization efforts. By understanding the key features, pricing models, and real-world costs of these tools, you can select the best fit for your team's needs.

If you have any questions or need help getting started with SimpleLocalize, feel free to reach out to us or check out our documentation. Happy localizing!
]]></content:encoded>
            <category>software localization</category>
            <category>SaaS</category>
            <category>translation management</category>
            <category>enterprise</category>
            <enclosure url="https://simplelocalize.io/blog/best-translation-management-software-for-saas.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Introducing: Notifications]]></title>
            <link>https://simplelocalize.io/blog/posts/introducing-notifications</link>
            <guid>https://simplelocalize.io/blog/posts/introducing-notifications</guid>
            <pubDate>Tue, 15 Jul 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Stay updated with your localization projects using our new notifications feature. Get real-time alerts for comments, mentions, and translation suggestions.]]></description>
            <content:encoded><![CDATA[To enhance your experience with SimpleLocalize, we are excited to introduce our new Notifications feature! This addition aims to keep you informed about important updates and changes in your localization projects.

Check our documentation on notifications to learn more.

Translation notifications

To the existing email notifications, we have added in-app notifications that will appear in the top right corner of your SimpleLocalize project. These notifications will alert you about:

New comments on your translations

Mentions in comments

New translation suggestions

In-app notifications example

When you receive a new notification, a small red dot will appear on the notification icon in the top right corner of your project. You can click on the icon to view all notifications and access the relevant translation or comment directly.

Thanks to this feature, you will never miss important updates in your projects, and you can respond promptly to comments from your team members and suggestions from the public contributors.

Translation updates notifications

In addition to comments and suggestions, you can now receive email notifications about translation updates. You will be alerted when:

A new translation is added

A translation is updated

A translation is marked as "needs review"

Those notifications help you stay on top of changes in your localization projects, ensuring that you can act quickly when translations are modified or require attention.

Translation update notification email example

Learn how to never miss a translation update again with our detailed guide on translation update notifications.

Enable notifications

You can enable or disable notification about translation updates in your profile settings:

Enable notifications in profile settings

Choose whether you want to receive email notifications, in-app notifications, or both. You can also manage your notification preferences at any time.

If you don't need to use notifications, you can hide the notification icon for a cleaner interface. This can be done in the same profile settings.

Requests and feedback

We are always looking to improve our features based on your feedback. If you have any suggestions or requests regarding notifications or any other aspect of SimpleLocalize, please feel free to reach out to us.
]]></content:encoded>
            <category>tutorial</category>
            <category>software localization</category>
            <category>translation management</category>
            <category>product updates</category>
            <enclosure url="https://simplelocalize.io/blog/introducing-notifications.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Introducing: In-Context Editor]]></title>
            <link>https://simplelocalize.io/blog/posts/introducing-in-context-editor</link>
            <guid>https://simplelocalize.io/blog/posts/introducing-in-context-editor</guid>
            <pubDate>Mon, 14 Jul 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Edit your website or app translations directly within the context with our new In-Context Editor feature. Learn how to set it up and use it effectively.]]></description>
            <content:encoded><![CDATA[We are thrilled to announce the launch of our new In-Context Editor! This feature allows you to edit translations directly within the context of your application, providing a more intuitive and efficient way to manage your localization projects.

What is the In-Context Editor?

In-Context Editor allows you to see your translations in the context of your website or application. This means you can view and edit translations while seeing how they appear in the actual user interface, making it easier to ensure that your translations fit well within the design and flow of your application.

With the In-Context Editor, you can quickly identify any issues with translations, such as text that is too long or does not fit properly within the UI elements. It can speed up the translation process by allowing you to make adjustments on the fly, without needing to switch back and forth between different tools or interfaces.

How to enable the In-Context Editor

To integrate the In-Context Editor into your project, follow these steps:

Installation

First, add the SimpleLocalize script to your website or application, ideally in the \<head> section or just before the closing \</body> tag. This will ensure that the In-Context Editor is loaded when your page is rendered.

Make sure to replace 'your-project-token' with your actual project token from SimpleLocalize. You can find this token in your SimpleLocalize project settings (Credentials section).

Load the script only in the environments where you want to use the In-Context Editor, such as staging or development. Avoid loading it in production environments unless you are ready to edit translations live.

Configuration

Next, configure the In-Context Editor by specifying the elements you want to be editable. You can do this by adding the data-translation-key attribute to the HTML elements you want to translate. For example:

Configuration of data-translation-key for in-context editor

You can use another attribute, e.g. one you are already using for translations, as long as it is consistent across your project. To make it work, specify it in the SimpleLocalize script as dataAttributeKey:

You can also specify namespaces for your translation keys by using the data-translation-namespace attribute.

Accessing the Editor

Once the script is added and configured, you can access the In-Context Editor by clicking on the SimpleLocalize icon in the bottom right corner of your application.

Before you can start editing, you need to enter your SimpleLocalize personal access token. You can find this token in your SimpleLocalize profile in the Security section.

SimpleLocalize access button in the In-Context Editor

How to use the In-Context Editor

With the In-Context Editor open, choose the language version you would like to display and see how your translations look in the context of your application. You can switch between languages using the language selector in the top right corner of the editor.

Click on any text element to edit its translation. The editor will display the current translation and allow you to modify it directly.

Editing translation in the In-Context Editor

The editor allows you to:

Edit translations: Click on any text element to modify its translation.

Add new translations: If a translation does not exist, you can add it directly in the editor.

Preview changes: See how your changes look in real-time within the context of your application.

Save changes: Once you are satisfied with your edits, click the "Save" button to apply your changes. The updated translations will be saved in your SimpleLocalize project.

Conclusion

Enable the In-Context Editor in your project to provide a more intuitive and efficient way to manage your translations. This feature is designed to streamline the localization process, making it easier for you to ensure that your translations fit perfectly within your application's design and user experience.

We hope you find the In-Context Editor a valuable addition to your localization toolkit. If you have any questions or feedback, please feel free to reach out to us and let us know how it works for you!

For more information on how to use the In-Context Editor, check out our documentation.
]]></content:encoded>
            <category>tutorial</category>
            <category>software localization</category>
            <category>translation management</category>
            <category>product updates</category>
            <category>translation editor</category>
            <enclosure url="https://simplelocalize.io/blog/introducing-in-context-editor.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Localization SEO: Best practices]]></title>
            <link>https://simplelocalize.io/blog/posts/localization-seo</link>
            <guid>https://simplelocalize.io/blog/posts/localization-seo</guid>
            <pubDate>Fri, 11 Jul 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to optimize your multilingual content for search engines with these practical SEO tips for localization. Optimize your localized content to reach global audiences effectively.]]></description>
            <content:encoded><![CDATA[Localization and SEO go hand in hand when it comes to reaching a global audience. Localization makes your content culturally relevant, while SEO ensures it is discoverable.

But going global isn't just about translating a few strings. Search engines treat each language and region as its own ecosystem, with unique keywords, user intent, and ranking behaviors. A fully localized app or website can still fall flat in search if the SEO fundamentals aren't adapted for each language version.

This post breaks down practical and often overlooked technical, content, and strategic SEO techniques for multilingual websites and apps. From hreflang tags to localized keyword research and beyond, these tips are designed to help your content get found, and succeed, across different markets.

Let's get into the specifics that make localized content not just available, but truly visible.

Technical SEO for Multilingual Content

1\. Use hreflang tags correctly

Tell Google which language and region each page targets using hreflang tags. This helps search engines serve the right version to users based on their language and location.

Example:

Learn more about hreflang tags.

2\. Use language-specific URLs

Use clear, language-specific URLs to help search engines and users understand the content's language. This can be done with subdirectories, subdomains, or ccTLDs.

Example:

Subdirectory: example.com/en/

Subdomain: en.example.com

ccTLD: example.fr

Avoid using query parameters for language, e.g., example.com?lang=en, as they are less user-friendly and harder for search engines to index.

Subdirectories are generally recommended for SEO, as they consolidate domain authority and make it easier to manage content. Learn more about URL structures for multilingual sites in our blog post.

3\. Decide on slug translation

When localizing URLs, decide whether to translate slugs (the part of the URL after the domain). Translating slugs can improve user experience and relevance, but it requires careful planning to avoid broken links.

Example:

Original: example.com/products/shoes

Translated: example.com/es/productos/zapatos

Whether to translate slugs depends on your audience and brand strategy. If you have a global brand, keeping slugs in English may be more recognizable. If you are targeting a specific market, localized slugs can enhance relevance. Check our blog on URL and slag translation for more details on this topic.

4\. Use canonical tags wisely

Canonical tags help prevent duplicate content issues when multiple language versions of a page exist. Use them to indicate the preferred version of a page, especially if you have similar content across languages.

Example:

It means that the English version is the primary one, while the French version is an alternate.

Use canonical tags wisely to avoid confusion for search engines. If you have a page that is identical in multiple languages, use the canonical tag to point to the original version. This helps consolidate ranking signals and avoids diluting authority across multiple pages.

5\. Consider using CDN

CDN, or Content Delivery Network, can improve the loading speed of your multilingual site by caching content closer to users around the world. This is especially important for localized content, as faster loading times can lead to better user experience and improved search rankings.

In SimpleLocalize, you can easily integrate with CDNs to ensure your localized content is delivered quickly and efficiently to users in different regions. Check out our Translation Hosting feature to learn more about how to set up CDN for your localized content.

Translation hosting workflow

6\. Create a multilingual XML sitemap

Submit all language versions of your site in a multilingual XML sitemap. This helps search engines discover and index your localized content more effectively.

Example:

7\. Don't mix languages on one page

Avoid mixing languages on a single page, as this can confuse both users and search engines. For example, an English UI with Spanish content can be confusing for Google and users alike. Each page should be fully localized to one language to ensure clarity and relevance. Don't leave untranslated menu items, buttons, or other UI elements that could disrupt the user experience.

If your app has dynamic content that changes based on user input, make sure localization is complete before rendering the page.

8\. Localize meta tags and structured data

Remember to translate and localize not just the visible content, but also meta tags, titles, descriptions, Open Graph tags, and JSON-LD schema. This helps search engines understand the context of your content in each language.

Example:

9\. Localize number, date, and currency formats

Ensure that numbers, dates, and currencies are formatted according to local conventions. This not only improves user experience but also helps search engines understand the content better.

Example:

US: 1,234.56 USD (date: MM/DD/YYYY)

France: 1 234,56 € (date: DD/MM/YYYY)

Spain: 1.234,56 € (date: DD/MM/YYYY)

Learn more about ICU message formatting in our guide.

10\. Build a language selector

Language selectors is a gate to your localized content. Make sure it is easily accessible, preferably in the header or footer of your site. Use clear labels like "Language" or "Select Language" and avoid using flags, as they can be misleading.

Language selector example

Check out blog posts on how to build a language selector with Tailwind CSS and language selection inspirations for more details.

Content SEO tips for multilingual sites

1\. Translate with localization

Translation is just the first step. To truly optimize for search, you need to localize your content. This means adapting not just the language, but also cultural references, idioms, and context to resonate with local audiences.

Localization goes beyond translation. It involves adapting content to fit cultural norms, idioms, and user expectations in each market. The content should feel native to the target audience, not just a direct translation of the original.

For example, a marketing campaign that works in the US may not resonate in France due to cultural differences. Localizing content means understanding these nuances and adjusting messaging, tone, and even visuals accordingly.

2\. Do multilingual keyword research

Research keywords in each target language to understand local search behavior. Translated keywords may not always match search intent or volume and can lead to missed opportunities if you don't adapt your strategy.

Use local keyword research tools and techniques like Google Keyword Planner, Ahrefs, or SEMrush to find relevant keywords in each language. Consider local slang, idioms, and cultural references that may not have direct translations.

3\. Avoid machine translated content

Content generated by machine translation or AI tools without human review can lead to awkward phrasing, cultural misunderstandings, and poor user experience. Always have a native speaker review and edit machine-translated content to ensure it is natural and culturally appropriate.

Machine translation is a great starting point, but it should never be the final step. A human touch is essential to ensure that the content is not only accurate but also resonates with the target audience.

"Sign In" translated literally to Polish

If you are looking for a way to auto-translate your content, check out SimpleLocalize's auto-translation feature. It allows you to integrate machine translation and AI for fast translation, while still giving you control over the final output. You can easily review and edit translations in a user-friendly translation editor.

4\. Localize images and videos

When localizing content, don't forget about images and videos. Visuals should also be culturally relevant and appropriate for each market. This includes translating text in images, using local imagery, and even adapting video content to fit local norms.

For example, make screenshots in different language versions of your app or website, and ensure that any text in images is translated. If you have videos, consider adding subtitles or dubbing in the target language.

5\. Make your site accessible

Accessibility goes hand in hand with localization. Ensure that your localized content is accessible to all users, including those with disabilities. This includes using proper alt text for images, providing captions for videos, and ensuring that your site meets WCAG (Web Content Accessibility Guidelines) standards.

Check out our blog post on accessibility in localization for more tips on how to make your localized content accessible to all users.

6\. Avoid missing translations

Missing translations, or untranslated strings, can lead to a poor user experience and hurt your SEO. Make sure that all content, including UI elements, buttons, and error messages, is fully translated and localized.

To make the translation and localization process easier, use a translation management system like SimpleLocalize. It allows you to manage translations efficiently, track missing strings, and ensure that all content is fully localized before going live.

Missing translation in Kingdom Come Deliverance

Join our Discord community for more interesting cases of missing translations and localization issues.

7\. Link to localized content

When you link to other pages from a localized page, make sure the links point to the correct language version. This helps search engines understand the relationship between different language versions and improves user experience.

For example, when you translate a blog post, ensure that all internal links point to the localized version of that post. This not only helps with SEO but also keeps users engaged with content in their preferred language.

8\. Create language-specific content calendars

Events, holidays, and cultural references vary by region. Create content calendars for each language version that align with local events and trends. This helps ensure your content is timely, relevant, and resonates with local audiences.

For example, if you are targeting the Spanish market, consider creating content around local holidays like La Tomatina or Fallas. If you are targeting the US market, focus on events like Thanksgiving or Independence Day.
This not only improves user engagement but also helps with SEO by aligning your content with local search trends.

9\. Test with native speakers

Native speakers can provide invaluable feedback on the quality and relevance of your localized content. Before launching, have native speakers review your content to ensure it is culturally appropriate, natural, and resonates with the target audience.

Consider adding an options for your users to provide feedback on translations. This can help you identify areas for improvement and ensure that your content meets the needs of your audience. Check out Community Suggestions feature in SimpleLocalize to see how users can suggest translations and improvements to existing content.

User feedback on translations in SimpleLocalize

General and strategic SEO tips

1\. Track performance by language/region

Monitor the performance of each language version separately. Use tools like Google Analytics and Google Search Console to track traffic, engagement, and conversions for each language. This helps you identify which markets are performing well and which need more attention.

You can use multiple Google Analytics properties for each language version, or use filters to segment data by language. This allows you to analyze user behavior, traffic sources, and conversion rates for each language version of your site.

2\. Add multilingual customer reviews/testimonials

User-generated content, such as reviews and testimonials, can significantly boost your SEO. Encourage customers to leave reviews in their native language and display them prominently on your localized pages. This not only improves credibility but also helps with local search rankings.

Customer reviews in Spanish on a localized page

3\. Build backlinks for each language version

Backlinks are crucial for SEO, and this applies to localized content as well. Build backlinks from reputable sites in each target language to improve authority and visibility in local search results. This can include guest posts, partnerships, and collaborations with local influencers or businesses.

4\. Use social media for each language

Managing separate social media accounts for each language can help you engage with local audiences more effectively. Share localized content, interact with users in their preferred language, and promote your localized pages on social media platforms.

5\. Run A/B tests separately per language

A/B testing is essential for optimizing user experience and conversion rates. Run separate A/B tests for each language version to understand how users in different markets interact with your content.

Thanks to that, you can identify what works best for each audience and make data-driven decisions to improve performance. This includes testing different headlines, calls to action, layouts, and even content types.

Conclusion

Multilingual SEO is more than just a technical checklist, it is a strategic advantage. By aligning localization with search best practices, you can unlock new markets, drive organic traffic from around the world, and create a more native experience for every user.

The key is to treat each language version not as a copy of the original, but as its own optimized, localized presence, with the right structure, the right keywords, and the right user signals.

If you are already localizing your content with SimpleLocalize, you are one step ahead. The next step? Make sure that localized content is also findable, indexable, and tailored for search.

Ready to make your localized content SEO-ready?

Use SimpleLocalize to manage multilingual content, then apply these tips to turn language variants into high-performing landing pages.

Try it now and see how easy it is to manage translations and optimize for search at the same time.
]]></content:encoded>
            <category>tips</category>
            <category>translation management</category>
            <category>software localization</category>
            <category>seo</category>
            <enclosure url="https://simplelocalize.io/blog/localization-seo.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Why localizing your website is key to accessibility]]></title>
            <link>https://simplelocalize.io/blog/posts/localization-and-accessibility</link>
            <guid>https://simplelocalize.io/blog/posts/localization-and-accessibility</guid>
            <pubDate>Fri, 04 Jul 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Localization is about making your website accessible to everyone. Learn how language impacts usability and discover best practices for creating accessible, localized content.]]></description>
            <content:encoded><![CDATA[When we talk about accessibility, we often picture screen readers, keyboard navigation, or high-contrast modes — all essential elements of inclusive design. But there is one area that is often overlooked in accessibility conversations: language.

If your website is only available in one language (usually English) you are excluding millions of users who might not speak it fluently, or at all. Localization isn't just a UX nice-to-have, it's a fundamental part of making the web accessible to everyone.

Localization is Accessibility

Accessibility means removing barriers. For many users, language is the first barrier they encounter online.

Imagine being asked to navigate a critical service, say, a health portal or government site, in a language you barely understand. Even if you can guess what most of the buttons do, are you confident enough to complete a form or make a payment? Probably not.

Website in a foreign language - Japanese

Now apply that to any web app or website. If your content is not available in a user's native language, you are creating cognitive friction. Localization breaks that barrier by offering information in the language users feel most comfortable with, increasing comprehension, trust, and usability.

And for some usersm like those with learning disabilities, cognitive impairments, or neurodivergent traits, understanding content in a second language is even harder. In these cases, localization directly improves accessibility.

How to make localized websites more accessible

Localizing your content is a strong first step. But to make your localized content fully accessible, there are a few more things to consider:

1\. Respect semantic HTML

Use proper headings, labels, and ARIA attributes as screen readers rely on these, and they need to work regardless of language.

Semantic HTML example in a website header

2\. Design for text expansion

Languages like German or Finnish tend to be wordier than English. Your UI needs to adapt without breaking or truncating text.

Text expansion example in a website header

You can set character limits in your localization platform (check how to do that in SimpleLocalize), but it's better to design with flexibility in mind.

3\. Avoid hardcoded text in images

Screen readers can't interpret images with embedded text. Localized content should be real, selectable, and structured — not hidden in a PNG.

If you need to use images with text, make sure to provide alternative text that describes the image content in the localized language.

4\. Account for Right-to-Left (RTL) languages

Arabic, Hebrew, and others read right-to-left. Your layout, alignment, and spacing should all adapt based on language direction.



You can set the dir attribute in your HTML to rtl for these languages, and ensure your CSS supports RTL layouts.

5\. Cultural relevance matters

Idioms, jokes, or imagery might confuse or alienate users from other regions. Localization is about more than just translation — it's about context.

For example, a "hot dog" might be a fun image in the US, but translated literally, it could be confusing in other cultures. Use culturally relevant imagery and examples.

6\. Accessible fonts and contrast

Some fonts become harder to read when translated. Make sure your typography is legible in all languages, and always test for adequate color contrast.

Color contrast accessibility examples

7\. Language selector matters

A well-designed language switcher improves usability across cultures. See our post on UI language selector best practices for tips on how to do it right.

8\. Test with real users

Language affects how people navigate and interpret content. If possible, conduct usability tests in localized versions of your site, for example, using SimpleLocalize's In-Context Editor to check translations in context and correct them as needed.

In-Context Editor in SimpleLocalize

Tips for building accessible, localized products

To ensure your localized product is accessible, consider these best practices:

Plan for localization from the start. Designing with flexibility in mind avoids problems later (like broken layouts) and makes it easier to adapt your UI for different languages.

Use a dedicated localization platform like SimpleLocalize to manage translations consistently across your product and ensure all strings are properly localized.

Build translation workflows with accessibility in mind. For example, don't just send raw strings but include context or screenshots so translators understand the UI.

Don't forget about alt text and metadata. Images, form labels, page titles — all of these need localization and accessibility treatment, especially if they contain text or important information.

Image of a website with localized alt text

Label UI elements clearly. Buttons labeled “OK” or “Submit” may be too vague and not translate well. Use descriptive labels that make sense in all languages.

Use localized URLs for a more consistent user experience and SEO. Our post on URLs in website localization explains how to structure them effectively.

Keep keyboard and screen reader users in mind when designing navigation flows across all language versions of your site. Ensure that all interactive elements are accessible via keyboard shortcuts and that screen readers can interpret them correctly.

What we do at SimpleLocalize

At SimpleLocalize, we are passionate about making localization simple, scalable, and accessible. While we are not perfect, we are constantly improving.

Here are a few accessibility-focused things we've implemented:

Dark mode support — a small but meaningful improvement for visual comfort.

Keyboard shortcuts — faster navigation for power users and improved accessibility for those who rely on keyboards.

Accessible UI design — with clear contrast, consistent buttons, and semantic elements.

Not localized (yet!) — Yes, the irony isn't lost on us. We are working on it! In fact, we encourage you to do better than we did and start your localization process early.

Dark mode setting in SimpleLocalize

Conclusion

If your site is only available in one language, it's not fully accessible.

Localization isn't just about reaching global markets, it's about making sure everyone can use your product confidently. From UI clarity to cultural relevance, language plays a central role in usability.

At SimpleLocalize, we believe that accessibility and localization go hand in hand. Because a truly inclusive web is one where everyone can read, understand, and interact — no matter what language they speak.

Ready to make your product more accessible?

Start localizing with SimpleLocalize today. Your users, and future customers, will thank you.

SimpleLocalize translation platform
]]></content:encoded>
            <category>accessibility</category>
            <category>tips</category>
            <category>design</category>
            <category>developer</category>
            <category>ux</category>
            <enclosure url="https://simplelocalize.io/blog/localization-accessibility.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[URLs in Localization: How to structure and optimize for multilingual websites]]></title>
            <link>https://simplelocalize.io/blog/posts/urls-in-website-localization</link>
            <guid>https://simplelocalize.io/blog/posts/urls-in-website-localization</guid>
            <pubDate>Thu, 03 Jul 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to structure URLs for multilingual websites, optimize for SEO, and improve user experience with practical tips and best practices.]]></description>
            <content:encoded><![CDATA[When localizing a website, one of the first, and most overlooked, decisions you will make is how to handle URLs. It is not just a matter of aesthetics or convenience. Your URL structure directly affects SEO, user trust, and how easily people can find (and understand) your content in different languages.

In this post, we break down the most common URL strategies for multilingual sites, explain their impact on search and usability, and share practical tips to help you avoid costly mistakes down the road.

URL structures for localized content

Let's start with the building blocks. There are several ways to structure URLs when supporting multiple languages or regions. Each has trade-offs, technically, logistically, and from an SEO perspective.

URL structures for localization

Country Code Top-Level Domains (ccTLDs)

This method uses domain extensions tied to specific countries:

Why use ccTLDs?

Search engines treat each as a separate website, which sends strong location-based signals. Users also trust them more; a .fr domain feels more French.

Pros:

Excellent for country-specific SEO.

Builds regional trust and authority.

Great for large brands targeting distinct markets.

Cons:

Expensive and harder to maintain (hosting, SSLs, SEO strategies per domain).

Requires duplicate infrastructure.

More effort to keep UX and content consistent.

Example: Amazon uses ccTLDs for each market — amazon.de, amazon.co.uk, amazon.co.jp.

Amazon ccTLD for Germany

Subdirectories (a.k.a. Subfolders)

This is the most popular approach, and often the most practical:

Why use subdirectories?

They are simple to implement, centralize your domain authority, and make routing easier.

Pros:

Low maintenance, especially with a CMS or static site generator.

Shares SEO strength across languages.

Easier for analytics and infrastructure management.

Cons:

Weaker geotargeting compared to ccTLDs.

Some extra logic required in routing, especially if using locale-specific slugs.

Good fit for startups, SaaS platforms, and blogs looking to scale localization gradually.

Hotjar subdirectory example

Subdomains

Using subdomains is another option, where each language or region gets its own subdomain:

Why use subdomains?

They offer separation without needing full-blown ccTLDs which is good for large projects with shared infrastructure.

Pros:

Clear content boundaries.

Can use different teams or systems for each language.

Flexible for different hosting configurations.

Cons:

Less SEO value than subdirectories (unless carefully optimized).

Additional DNS and configuration work.

May split link equity across subdomains.

Stack Overflow and Wikipedia use subdomains (es.stackoverflow.com, fr.wikipedia.org), maintaining distinct language communities.

Wix subdomain example

Query parameters

Using query parameters is the least common approach for localization, where you append a language parameter to the URL:

It is technically valid, but discouraged for language targeting. Google and other search engines struggle to index and rank parameter-based URLs for localization.

Cons:

Weak SEO signals.

Can lead to duplicate content issues.

Less user-friendly, harder to link and share.

Google uses the 'hl' (host language) query parameter in its documentation, but they are the exception, not the rule.

Google query parameter example

Client- or server-side language detection

Some websites detect the user’s preferred language and serve localized content without changing the URL.

This is common in web apps and authenticated experiences, where user context is already known.

Why use it:

Good for behind-login content or personalized dashboards.

Can be layered with any of the structures above.

Reduces need for users to manually select a language.

Caution

Always give users control. Redirecting based on IP or browser language without an option to switch can frustrate users, and search engines.

Language vs. Locale in URLs

Instead of using language codes, you can also include locale information in your URLs. Locales are language-region combinations, such as en-US for English (United States) or fr-CA for French (Canada). Learn more about the difference between language codes and locale codes.

Language vs. locale

Locales allow for more precise targeting (e.g., Canadian French vs. European French). They are helpful when regional nuances matter — currency, spelling, date formats, etc.

Language and locale resources:

Language codes list

Locale codes list

If you use locale-specific URLs (e.g. /es-es/ and /es-mx/), make sure to provide a general fallback like /es/ to support other Spanish speakers.

URLs and SEO: What you need to know

When it comes to SEO, search engines care about:

Unique content per URL

Consistent and descriptive structure

Proper use of hreflang and canonical tags

Hreflang tags

Let search engines know which versions of a page exist in which languages. This is done using the hreflang attribute in the \<head> section of your HTML. It tells search engines about the language and regional targeting of your pages.

For example, if you have an English version and a Spanish version of a page, you would include:

Add hreflang tags in the \<head> section of your HTML

Also possible via HTTP headers (for non-HTML files)

Or inside your XML sitemap

Learn more about hreflang in our What is hreflang and how to use it article.

What is hreflang="x-default"?

The hreflang="x-default" attribute is used to specify a default version of a page when no other language or regional version matches the user's preferences. Add it to your language selector or fallback pages, when no specific match is found.

Canonical URLs

Avoid duplicate content penalties. If content is nearly identical across locales, set the canonical tag:

Be especially careful when using automatic translations or locale variants (e.g., en-US vs. en-GB). If the content is the same, use canonical tags to point to the primary version.

Should you translate URL slugs?

Translating URLs is a question that often comes up when localizing websites.

Short answer: it depends.

Translated slugs:

Improve clarity for native speakers

Help with SEO for language-specific search queries

Build familiarity and trust

But they also:

Add complexity when managing links across languages

Increase the chance of inconsistencies or broken links

Require solid redirects and fallback logic

To sum up, translated URLs are nice-to-have but not a must-have. For sure, it is easier to manage URLs in one language, especially if you have a lot of content. However, if your target audience is primarily speakers of a specific language, translating URLs can improve user experience and SEO.

Ahrefs uses translated slugs for blog posts, but keeps main site URLs in English. A balanced approach.

Ahrefs page and blog URLs

Make switching languages easy

To make it easy for users to switch between languages, you should provide a clear language selector on your website. This can be a dropdown menu, a list of links, or a button that opens a modal with language options.

Discord language selector

Do:

Display the current language clearly

Use the native name for each language (e.g. "Deutsch", not "German")

Respect user preferences via cookies or local storage

Use both source and target language names in the language selector for the best user experience. For example, show "English (Angielski)" or "Spanish (Hiszpański)" when switching from page in Polish.

Avoid:

Using flags as language indicators — they don't represent languagese (read more in our blog on flags in language selectors).

Auto-switching based on location/IP

Hiding the selector behind menus or icons that are not immediately obvious

For inspiration, see our post on language selector UI examples.

Practical tips

Prefer subdirectories unless you have a clear business case for ccTLDs or subdomains.

Implement hreflang and canonical tags correctly.

Keep your structure consistent across the site.

Use hyphens in URLs, avoid special characters or camelCase.

Translate slugs only when it adds value — don't overcomplicate.

Avoid machine-translated content — it hurts both SEO and trust.

Don't forget the extras: images, units, date formats — they speak, too.

Localization starts with the right URL

Setting up a multilingual site isn't just about translating text, it's about building a better experience for everyone, everywhere. And that starts with the structure you choose.

At SimpleLocalize, we help you go beyond copy-paste translation. Our platform makes it easier to manage language files, collaborate with translators, and launch multilingual projects that actually work, for people and search engines alike.

SimpleLocalize translation editor

Want to spend less time wrestling URLs and more time growing globally? Give SimpleLocalize a try and register for a free account today!
]]></content:encoded>
            <category>hreflang</category>
            <category>seo</category>
            <category>developer</category>
            <category>software localization</category>
            <category>tips</category>
            <enclosure url="https://simplelocalize.io/blog/urls-localization.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to make your website accessible]]></title>
            <link>https://simplelocalize.io/blog/posts/website-accessibility</link>
            <guid>https://simplelocalize.io/blog/posts/website-accessibility</guid>
            <pubDate>Tue, 01 Jul 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[A practical guide to making your website accessible for all users, including those with disabilities. Learn about color contrast, keyboard navigation, and localization.]]></description>
            <content:encoded><![CDATA[Accessibility is no longer optional—it is a core part of building digital products that work for everyone. From color contrast to keyboard navigation and localization, inclusive design ensures that users of all abilities can fully access and enjoy your content.

This guide is packed with real-world pitfalls, practical tips, and fast fixes you can apply today. Whether you are a designer, developer, or product owner, these insights will help make your website more inclusive without compromising design or performance.

Why accessibility matters

The internet should be for everyone. But millions of users still face barriers when accessing digital content because of poor contrast, non-intuitive navigation, or language barriers.

According to the WHO, over 1 billion people live with some form of disability. If your site isn't accessible, you are excluding a huge part of your audience.

Legal reasons aside (ADA, WCAG, etc.), accessible sites are:

Easier to use on mobile

Faster to navigate

More SEO-friendly

More inclusive for non-native speakers or neurodivergent users

What is accessibility?

Accessibility is clarity and communication. In web development, it means designing websites that can be used and understood by everyone, regardless of someone's physical or cognitive abilities.

This includes users with:

Visual impairments (e.g. color blindness, low vision)

Hearing loss

Limited mobility or fine motor control

Neurodivergent processing (e.g. ADHD, dyslexia)

Reliance on screen readers or non-standard input methods

Multilingual backgrounds or limited language proficiency

Accessibility icon

The goal of accessibility is to create a digital experience that communicates clearly, no matter how someone reads, listens, moves, or understands. When your website is accessible, you are not just meeting guidelines. You are opening the door for more people to participate fully in what you have built.

Need to support users across multiple languages? See what is software localization and how it works to learn how localization can help you reach a global audience.

Key accessibility factors

To make your website accessible, you need to consider several key factors that affect how users interact with your content. Here is a breakdown of the most important accessibility factors, along with actionable advice and technical examples you can apply right away.

Color contrast & visual cues

Poor color contrast is one of the most common accessibility issues, and one of the easiest to fix. Poor contrast makes content hard to read for everyone, not just users with low vision.

To ensure good color contrast:

Follow the WCAG contrast ratio guidelines on level AA:

4.5:1 minimum for normal text

3:1 for large text (18pt or bold 14pt)

3:1 for non-text UI components (icons, borders, etc.)

Don't rely on color alone to convey meaning

Avoid hard-to-distinguish combos (e.g. red/green or blue/purple)

Color contrast examples

For perfect AAA compliance, use a contrast ratio of 7:1 for normal text and 4.5:1 for large text. But AA compliance is often sufficient for most applications.

Color accessibility tools:

WebAIM Contrast Checker: Simply input foreground and background colors to check their contrast ratio.

Lighthouse: Built-in accessibility audits in Chrome's tool to check color contrast issues on your site.

Accessible Colors: A simple tool to test color combinations for accessibility.

Typography & text structure

Good typography is more than just aesthetics. It affects how quickly and comfortably users can read your content, especially for those with dyslexia or cognitive impairments.

Typography examples

Best practices:

Stick to clean sans-serif and readable typefaces.

Font size should be at least 12pt (16px) for body text, with larger sizes for headings.

Maintain line height of 1.5x and generous spacing.

Limit font styles and varieties.

Limit use of all-caps and ultra-light font weights.

Avoid dense blocks of text. Use spacing, paragraph breaks, and bullet lists.

Also, use semantic HTML to structure your content and clear heading hierarchy: \<h1> → \<h2> → \<h3>, without skipping levels. Instead of styling elements with CSS, use HTML (for example, \<strong> for important text instead of just making it bold with CSS). This helps screen readers understand the content structure and improves SEO.

Test legibility with the phrase "Illicit 0bserver in COde 8uilding" to spot fonts that confuse characters like I, l, 0, and O.

Images, icons, and alt text

Images must be readable to all users, including those using screen readers. Decorative visuals should not distract from the content, while informative images should enhance understanding.

To make your images accessible:

Use descriptive alt text for all meaningful images. Alt text should convey the purpose and content of the image, not just its appearance.

Image accessibility with alt-text usage

Use role="presentation" or empty alt="" for decorative images.

Avoid using images of text. Instead, use CSS for text styling. If you must use text in an image, provide a text alternative in the alt attribute.

Ensure icons have clear labels using aria-label or aria-labelledby attributes.

Aria-labels are used to provide additional context for screen readers. For example, if you have a button with an icon but no text, you can use aria-label to describe its function.

Animation & motion preferences

Motion should enhance, not distract. Some users may find animations disorienting or triggering, making it crucial to provide options for reduced motion.

To make animations accessible:

Avoid flashing elements or autoplay effects. Animations that flash more than three times in one second can trigger seizures in users with photosensitive epilepsy.

Respect users who prefer reduced motion nad provide a way to disable animations or reduce motion effects.

Use animations to enhance understanding, not distract. For example, use subtle transitions to indicate changes in state (like a button press) rather than flashy effects that draw attention away from the content.

Offer static alternatives when animation is essential.

Auto-loop and pause buttons on video

The prefers-reduced-motion media query detects user preferences for reduced motion. You can use it to apply styles that respect these preferences:

Keyboard navigation

Not everyone uses a mouse. Keyboard accessibility benefits everyone, from power users to people with motor disabilities.

To ensure keyboard accessibility:

All interactive elements must be reachable with Tab, Enter, Space, and arrow keys. This includes links, buttons, form fields, and custom controls.

Ensure that the tab order is logical and intuitive.

Use visible :focus styles to show which element is selected.

Pro Tip: Use the tabindex attribute to control the tab order of elements. Use tabindex="0" for elements that should be focusable in the natural tab order, and tabindex="-1" for elements that should not be focusable.

At SimpleLocalize, we ensure that all our UI components are keyboard-navigable. For example, our translation editor allows users to navigate through translation entries using the keyboard. Check our our blog post on using translation editor keyboard shortcuts for more tips.

Forms and error handling

Forms are common points of failure in accessibility, especially if they are not properly labeled or do not provide clear feedback.

Email address form example

To make forms accessible:

Use semantic HTML for form elements:\<label> elements associate labels with form controls.

Placeholders should not replace labels. They disappear when the user starts typing, which can be confusing.

Clearly identify required fields. Mark them with aria-required="true" and provide clear instructions for optional fields.

Use aria-describedby to link inputs to error messages and instructions.

Provide real-time validation and error messages that are clear and actionable. Use aria-live regions to announce errors without disrupting the user's flow.

Dark mode

Dark mode isn't just a UI trend. It reduces eye strain and improves readability for many users. Dark mode is often preferred in low-light environments or by users with light sensitivity.

Dark mode accessibility example

Make it accessible:

Use a high contrast ratio between text and background. Don't just invert colors; ensure legibility is preserved in both light and dark themes.

Avoid pure black (#000000) against pure white (#FFFFFF), which can create harsh visual edges. Instead, use softer shades like #121212 and #F5F5F5 to reduce eye strain.

Make sure all UI states (hover, focus, disabled) are still visually distinct in dark mode.

Test color accessibility in both light and dark themes. A color combination that passes WCAG in one mode may fail in the other.

Respect system preferences with the prefers-color-scheme media query. It automatically applies the user's preferred color scheme based on their operating system settings.

Pro Tip: Allow users to manually toggle between light and dark modes. Not everyone wants their system setting to dictate how your UI looks.

Also consider giving users custom color settings, such as:

A high-contrast color theme

Dyslexia-friendly text colors

Option to reduce visual clutter by simplifying palettes

Dark mode settings example

These small customizations can make a big difference, especially for neurodiverse users, users with low vision, migraine, or other conditions that affect how they perceive color and contrast.

Accessibility & Localization

Accessibility isn't just visual. Language is one of the biggest accessibility barriers on the web today.

Even well-designed UIs can become confusing if the translation is unclear, machine-generated, or culturally off. That is why accessibility and localization go hand-in-hand.

Effective localization goes beyond simple translation:

Use the correct lang attribute on your pages and elements.

Don't rely solely on machine translation. It often misses context and can result in confusing or misleading labels.

Check your translated UI. For example, a "Sign In" button translated into Polish might say something correct grammatically, but completely fail to convey what the button actually does.

Incorrectly translated button example

Use ARIA labels with translated text in components.

Support writing systems properly. Some languages like Japanese use multiple alphabets. HTML's \<ruby> tag can help show pronunciation aids (furigana), which are especially useful for younger users or learners.

Japanese ruby example

At SimpleLocalize, we believe accessibility and localization go hand in hand. If your app supports multiple languages but the translated version is broken, confusing, or unreadable, it's not accessible.

WCAG: The standard for web accessibility

The Web Content Accessibility Guidelines (WCAG), created by the W3C define how to make the web accessible to people with a wide range of disabilities.

At the core of WCAG are four foundational principles, known as POUR:

Perceivable: Users must be able to perceive content (e.g., using text alt for images, captions for videos).

Operable: Interface elements must be usable via keyboard or assistive tools (accessible forms, clear navigation).

Understandable: Content should be predictable and readable (simple language, consistent layout).

Robust: Works across different browsers and assistive technologies (valid HTML, use of ARIA roles).



WCAG levels of conformance

WCAG defines three levels of conformance:

Level A: The minimum level of accessibility which includes basic requirements like providing text alternatives for images and videos, keyboard navigation, basic forms accessibility, and ensuring that content is readable and understandable.

Level AA: The strong level of accessibility that includes all Level A requirements plus additional criteria like color contrast, more advanced form accessibility, and ensuring that content is navigable and understandable for users with various disabilities.

Level AAA: The highest level of accessibility. This level is often not feasible for all content, but it is the ideal goal for maximum accessibility.

Level AA should be your target for most websites, as it balances accessibility with practical implementation. It includes requirements mentioned earlier, such as color contrast, text alternatives for images, and keyboard navigation.



WCAG Level AA compliance checklist

Use this checklist as a quick reference to ensure your website meets WCAG 2.1 Level AA accessibility standards:

Perceivable

\[ ] Text alternatives: Provide descriptive alt text (≤ 125 characters) for all non-text content, including images, charts, and videos.

\[ ] Color contrast: Maintain a contrast ratio of at least 4.5:1 for normal text and 3:1 for large or bold text.

\[ ] Multimedia alternatives: Include captions for audio, transcripts for video, and audio descriptions where necessary.

\[ ] Zoom and resizing: Ensure content can be resized up to 200% without loss of functionality or content.

\[ ] Responsive design: Design layouts that adapt smoothly across different screen sizes and orientations.

Operable

\[ ] Keyboard accessibility: All functionality must be available via keyboard alone, without requiring a mouse.

\[ ] Focus visibility: Use visible focus indicators on all interactive elements (e.g., links, buttons).

\[ ] Navigation aids: Provide mechanisms such as skip links, consistent menus, and breadcrumbs for easier navigation.

\[ ] Consistent navigation: Ensure navigation structure and placement are consistent across pages.

\[ ] Avoid time limits: Do not impose time limits unless necessary; if unavoidable, offer controls to extend or disable them.

\[ ] Motion and animation: Avoid excessive animation and allow users to reduce or disable motion effects. Never use flashing content that blinks more than 3 times per second.

\[ ] Gesture-based navigation: Ensure that all functionality is available without requiring complex gestures (e.g., pinch-to-zoom).

Understandable

\[ ] Clear headings and labels: Use descriptive headings and labels for all content, including forms and buttons.

\[ ] Readable text: Write in plain language, avoiding jargon, long sentences, or complex terms.

\[ ] Error identification: Clearly identify errors in forms and provide suggestions for correction.

\[ ] Error prevention: Provide users with the ability to review, correct, and confirm before finalizing actions (e.g., submitting forms).

\[ ] Accessible forms: Ensure all form fields have labels and clear instructions; group related elements logically.

\[ ] New windows: Warn users when links open in a new window/tab (e.g., with text or an icon).

Robust

\[ ] Accessible tables: Use semantic HTML (\<th>, \<caption>, \<scope>) so screen readers interpret tables correctly.

\[ ] Downloadable content: Make PDFs and other files accessible, and indicate file type and size in the link text.

\[ ] Sitemap or search: Offer a site search or sitemap to help users locate content efficiently.

\[ ] CAPTCHA alternatives: Provide accessible alternatives (e.g., logic puzzles, email verification) for users who cannot complete traditional CAPTCHA challenges.

Practical UX tips for an accessible experience

Accessibility is not just a checklist—it's a mindset and a habit. It becomes far more effective when it's baked into your team's daily processes, tools, and collaboration.

Build accessibility into your design system

A shared design system is a powerful tool for scaling accessibility:

Use accessible components by default: buttons with clear focus states, properly labeled form fields, contrast-compliant colors.

Include ARIA guidelines and accessibility usage tips directly in design specs (e.g., in Figma or Sketch).

Provide designers with an approved color palette that meets WCAG contrast ratios.

Create reusable patterns (e.g., skip links, modals, alerts) that are already tested for accessibility.

Use SimpleLocalize's plugin for Figma to make sure translations are accessible right from the design stage. It allows you to manage translations and ensure that texts are displayed correctly in your designs in different languages.

Collaborate across roles

Accessibility isn't just a developer's job. It works best when everyone on the team shares the responsibility:

Designers should plan for keyboard navigation, clear labels, and scalable typography.

Copywriters can use plain, concise language and avoid ambiguous labels like “Click here.”

Translators should ensure that translated content is clear and contextually appropriate.

Developers should structure HTML semantically and use ARIA thoughtfully, only when needed.

Testers/QA should include assistive tech testing (e.g., screen reader basics, keyboard-only nav) in standard test cases.

Test with real assistive technologies

Automated tools can catch many issues, but real-world testing is where accessibility wins:

Try your website with a screen reader like NVDA, VoiceOver, or TalkBack.

Navigate your app using only the keyboard, no mouse or trackpad.

Check your layout and interactions in high contrast mode and with zoom enabled.

Observe how your UI behaves with prefers-reduced-motion and prefers-color-scheme enabled.

Even just a few minutes of testing with these tools can reveal major usability issues you wouldn't catch otherwise.
Start with the most critical user flows, like logging in, filling out forms, and navigating key pages.

Create an accessibility checklist that fits your stack

Having a shared, realistic checklist can help your team catch issues early:

Are headings structured semantically?

Can all interactions be completed without a mouse?

Are all images and icons properly labeled with alt text?

Do all form fields have associated labels?

Do form errors have clear, accessible feedback?

Are language attributes (lang) applied correctly?

Are animations and dark mode tested for clarity and comfort?

Integrate accessibility checks into code reviews, design QA, and even CI pipelines using tools like:

axe-core

Pa11y

Lighthouse

Think content-first, not color-first

Accessible design starts with clear communication, not just compliance:

Write UI text that's action-oriented and unambiguous.

Avoid vague phrases like "Learn more" or "Submit."

Give users enough context to understand links, buttons, and instructions, especially in translated content.

Tip: Involve localization reviewers early to ensure translated UI strings remain clear and accessible in every supported language. Check out our guide on how to control the quality of your translations using the review status.

Conclusion

Website accessibility isn't a feature—it's a foundation. It improves SEO, enhances usability, and opens your product to a broader, more diverse audience. Whether you're building a dashboard, an e-commerce site, or a mobile app, inclusive design begins with inclusive communication.

Start small: fix contrast, structure your headings, and test with a screen reader. Over time, build accessibility into your workflow, not as an afterthought, but as a default.
]]></content:encoded>
            <category>developer</category>
            <category>tips</category>
            <category>design</category>
            <category>designer</category>
            <category>ui</category>
            <category>ux</category>
            <category>accessibility</category>
            <enclosure url="https://simplelocalize.io/blog/website-accessibility.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[What are different types of translation]]></title>
            <link>https://simplelocalize.io/blog/posts/software-translation-vs-other-types</link>
            <guid>https://simplelocalize.io/blog/posts/software-translation-vs-other-types</guid>
            <pubDate>Tue, 17 Jun 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Software translation is a unique blend of technical precision and creative adaptation. Learn how it differs from other types of translation.]]></description>
            <content:encoded><![CDATA[Translation is often treated as a uniform task, simply converting text from one language to another. But in reality, the requirements, tools, and challenges vary dramatically depending on what is being translated. Literary translation is a creative art. Technical translation is about precision. But software translation? It is a unique blend of both, wrapped in a layer of code and constraints.

In this post, we will explore how software translation differs from other types of translation and why tools like SimpleLocalize.io are essential for getting it right.

Types of translation

Translation can be broadly categorized into several types, each with its own nuances and requirements:

Literary Translation: Involves translating novels, poetry, screenplays and other creative works. It is focused on capturing the author's voice, style, and cultural nuances.

Technical Translation: Deals with manuals, user guides, and other technical documents. It requires precision and a deep understanding of the subject matter.

Legal Translation: Involves translating contracts, agreements, and other legal documents. It requires a strong grasp of legal terminology and concepts.

Marketing Translation: Focuses on advertising, promotional materials, and other marketing content. It aims to adapt the message to resonate with the target audience while maintaining brand voice and blends translation with creative adaptation (transcreation).

Software Translation/Localization: Involves translating UI, apps, websites and software-related content. It must work within technical, spatial, and contextual limits while ensuring the user experience remains seamless across languages.

There are also other types of translation, such as audiovisual translation (subtitles, dubbing), scientific translation, and more. Each has its own set of challenges and requirements.

What makes software translation unique?

Software translation isn't just about text, it's about function. It requires an understanding of how software works, the context in which it operates, and the user experience it delivers. It needs to:

Fit into small UI elements (buttons, labels, tooltips)

Support variables (e.g. "You have {count} new messages")

Be maintained across versions (as software evolves, so does the text)

Handle multiple platforms and user contexts

Handle pluralization, gender, date/time formats, and other locale-specific rules

Ensure consistency across the entire application

Button translation key example

It is not uncommon for software translators to work with strings like this:

Getting this right means more than just correct grammar, it means understanding placeholders, code syntax, and context.
It also means working closely with developers, product managers, and UX designers to ensure the translation fits seamlessly into the software.

Tools of the trade

Each type of translation relies on different tools:

| Type of translation | Common tools |
|-----------------------|--------------|
| Literary | Human editors, CAT tools (e.g. SDL Trados, MemoQ), Word/Docs |
| Technical | CAT tools, terminology management systems, glossaries |
| Legal | CAT tools, legal dictionaries, glossaries |
| Software | i18n platforms (e.g. SimpleLocalize), code editors |

For software translation, specialized tools like SimpleLocalize are essential. They provide features like:

Git and CI/CD integration (automated string syncs)

JSON, YAML, and other file format support

Language fallback and version control

Contextual hints for translators

Collaboration with developers and translators in one place

Translator skills: Who's doing the work?

Each type of translation requires different skills and strengths:

| Type of translation | Required skills |
|-----------------------|-----------------|
| Literary | Creative writing, storytelling, cultural understanding, literary analysis |
| Technical | Subject matter expertise, precision, attention to detail |
| Legal | Legal terminology, attention to detail, understanding of legal concepts |
| Software | Technical awareness, placeholder handling, UX and UI context, QA mindset |

Software translators often work closely with developers, QA testers, and product managers to ensure localization is not only accurate but functional.

Translation workflows compared

Translation workflows vary significantly across different types of translation. Here is a quick comparison:

| Type of translation | Typical workflow |
|-----------------------|------------------|
| Literary | Project-based, often solo |
| Technical | Document-based, may involve small teams |
| Legal | Document-based, often involves legal experts |
| Software | Agile, continuous localization, teamwork via platforms |

In software localization, it's common to release updates weekly or even daily. Localization must keep up. That is why tools like SimpleLocalize support automated string syncs from GitHub, Bitbucket, or via CLI and API.

The integration with Figma allows designers to share translations directly from design files and provide context for translators, ensuring that the final product is not only translated but also functional and user-friendly.

Why it matters for your business

Getting software localization wrong doesn't just mean awkward translations. It can even break your app. Think:

Buttons with cut-off text

Error messages that don't make sense

Incorrect placeholders leading to confusion

Strings not showing due to missing translations

Example of a broken translation

These issues can lead to poor user experience, frustrated customers, and ultimately lost revenue.
It can also damage your brand reputation. Users expect software to work seamlessly in their language. If it doesn't, they may question the quality of your product.

Proper localization impacts user experience, international adoption, and even revenue.

Conclusion

Software translation is a discipline of its own: more technical, context-sensitive, and fast-paced than many other translation types. If you are building apps or websites that need to speak your users' languages fluently and functionally, you can't treat it like any other form of translation.

Ready to simplify your localization process? Try SimpleLocalize, a modern platform built with software translation in mind.
]]></content:encoded>
            <category>software localization</category>
            <category>translation management</category>
            <enclosure url="https://simplelocalize.io/blog/types-of-translation.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Best practices in software localization]]></title>
            <link>https://simplelocalize.io/blog/posts/best-practices-in-software-localization</link>
            <guid>https://simplelocalize.io/blog/posts/best-practices-in-software-localization</guid>
            <pubDate>Mon, 09 Jun 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn the best practices for software localization to ensure your application resonates with users across different regions and cultures.]]></description>
            <content:encoded><![CDATA[Software localization is more than just translating text. It's about adapting your application to meet the cultural, linguistic, and functional expectations of users across different regions. Done right, localization helps increase global user engagement, satisfaction, and conversion.

To ensure that your software is effectively localized and resonates with users in different regions, it is essential to follow localization best practices across general strategy, technical implementation, and content management.

General best practices for software localization

Understand the target audience

Localization is not just language, it's culture. Adapt your tone, images, and user experience to reflect local customs, holidays, idioms, and even humor. A formal tone might work in Germany, while a casual tone may be more effective in Brazil.

Use a localization management platform

Managing translations manually with spreadsheets or hardcoded JSON files doesn't scale. A platform like SimpleLocalize helps teams centralize, manage, and automate the entire translation process, from import/export to translator collaboration.

SimpleLocalize Translation Management Platform

A TMS (Translation Management System) provides a single source of truth for all translations, making it easier to translate, track changes, manage versions, and collaborate.

Plan for localization from the start

Internationalization (i18n) should be built into your app architecture early. Retroactively localizing an app leads to bugs, technical debt, and a poor user experience.

When designing your app, consider how text will expand or contract in different languages, how date formats will change, and how right-to-left languages will affect layout.

Of course, you can localize an existing app, but it is much easier to do it right from the beginning.

Maintain a consistent terminology

Establish a translation memory, glossaries, and style guides to ensure consistent word choices across languages, even if multiple translators are involved. This builds brand trust and coherence.

Use context in translations

One word can have multiple meanings depending on context. Add comments, descriptions, or screenshots to give translators a clear idea of where and how the string is used, something SimpleLocalize makes easy with its intuitive web editor.

Translation with context in SimpleLocalize

Test the localized software

Always test your product in each supported language before release. Pay attention to broken layouts, missing translations, and functionality issues caused by text expansion or RTL formatting.

Testing should include both functional testing (ensuring features work as expected) and linguistic testing (ensuring translations are accurate and culturally appropriate).

Regularly update translations

Language evolves, and your app changes too. Keep your translations up to date to avoid mismatched UI, outdated terms, and broken strings.

Plan for scalability

Design your localization system to support dozens of languages, not just two or three. Use modular translation files and scalable infrastructure that can grow with your audience.

Adding languages in SimpleLocalize

Collaborate with native speakers

Machine translation and AI can help, but nothing beats the nuance and cultural accuracy of a native-speaking human. Involve them in review and QA whenever possible.

Support right-to-left (RTL) languages

Languages like Arabic and Hebrew require special formatting: layout mirroring, RTL text alignment, and flipping icons. Build your UI with RTL support from day one.

RTL parahraph icon

Technical best practices for software localization

The technical implementation of localization is just as important as the content. Start by choosing the right i18n framework or library for your tech stack.

Use a structured file format for translations

Use formats like JSON, YAML, or XLIFF that allow for easy parsing and manipulation of translation strings. This makes them easier to update and sync across environments.

Example:

Check out the SimpleLocalize JSON format documentation for details on how to structure your translation files.

Use Unicode for character encoding

Always use UTF-8 to support all global languages and character sets, including emojis, accented characters, and non-Latin scripts.

Define a key naming convention

Use meaningful, consistent keys like auth.login.button or cart.emptyMessage. Avoid vague ones like str123. Good keys improve readability and reduce confusion.

Translation keys organization example

Check out out blog post on best practices for creating translation keys for more tips on how to structure your keys.

Avoid duplicates with reusable keys

Use a single key for repeated phrases or terms across your app. Instead of translating “OK” or “Save” multiple times, reuse standardized keys across your app.
This reduces redundancy, simplifies updates, and ensures consistency.

Avoid hardcoding text

Hardcoding text strings in your source code makes localization difficult. Instead, replace hardcoded strings with keys that reference your translation files. This allows translators to work independently of developers and makes it easier to swap languages without code changes.

Use placeholders for variables

Use placeholders for dynamic content like user names, dates, or numbers. This allows translators to adapt the text without breaking functionality.

Then pass values programmatically.

Check out out blog post about number formatting in JavaScript for more tips on how to handle dynamic content in translations.

Use tools that integrate with CI/CD

Automate translation syncing with your build pipeline. SimpleLocalize CLI lets you push and pull translation files automatically as part of your CI/CD workflow.

Localization workflow using SimpleLocalize CLI

See the list of all integrations available in SimpleLocalize.

Use fallbacks for missing translations

If a translation is missing, use a fallback mechanism to display the original language text instead of showing an empty string or error. This ensures users still see meaningful content.

In SimpleLocalize translation hosting and when you export translation files, you can set a fallback language to use when a translation is missing.

Handle plurals and genders correctly

Different languages have complex pluralization and gender rules. Use libraries or ICU Message Format to manage variations properly:

Conclusion

Localization is a complex but rewarding process that requires careful planning, technical implementation, and cultural sensitivity. By following these best practices, you can ensure your software resonates with users around the world, leading to increased engagement and satisfaction.
]]></content:encoded>
            <category>developer</category>
            <category>tips</category>
            <category>software localization</category>
            <enclosure url="https://simplelocalize.io/blog/best-practices-for-software-localization.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Introducing: MCP Server]]></title>
            <link>https://simplelocalize.io/blog/posts/introducing-mcp-server</link>
            <guid>https://simplelocalize.io/blog/posts/introducing-mcp-server</guid>
            <pubDate>Tue, 03 Jun 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[The official SimpleLocalize MCP Server allows you to integrate AI agents like Cursor AI, Claude, or GitHub Copilot with SimpleLocalize for managing translations in your projects.]]></description>
            <content:encoded><![CDATA[We are excited to announce the release of our new and official MCP Server for SimpleLocalize!
This is a locally managed model-context protocol server that allows you to integrate AI agents like Cursor AI, Claude, GitHub Copilot or any LLM that supports MCP with SimpleLocalize for managing translations in your projects
using natural language prompts.

Official MCP Server

Available tools

We focused on providing the most useful tools for managing translations in your projects. Here are the available tools in the MCP Server:

Create a translation key - add new translation keys from your code to SimpleLocalize

Update translation key - update existing translation keys in SimpleLocalize

Update translations bulk - update translations for multiple keys at once

Get all translation keys - retrieve a list of all translation keys in your project

Get translation key details - get details of a specific translation key

Get tags - retrieve all tags in your project

Create tag - create a new tag in your project

Get languages - retrieve all languages in your project

Get translations - retrieve translations for a specific key or language

You can find the full list of tools and their descriptions in the MCP Server documentation

Installation

Installation of the MCP Server is straightforward, and it looks like in all popular AI agents like Cursor AI, GitHub Copilot, or Claude Desktop similar.
Open your JSON MCP configuration file and add the following configuration:

You will need to replace SIMPLELOCALIZE_API_KEY with your actual API key from SimpleLocalize. You can create and manage API keys in SimpleLocalize > Settings > Credentials,
and start the server using the command line or directly in your AI agent.

Summary

We hope that the new MCP Server for SimpleLocalize will make it easier for developers to manage translations
in their projects using AI agents. With the ability to create, update, and manage translations using natural language prompts, you can streamline your localization workflow and focus on building great applications.
]]></content:encoded>
            <category>tutorial</category>
            <category>software localization</category>
            <category>developer</category>
            <category>product updates</category>
            <category>ai</category>
            <category>mcp</category>
            <enclosure url="https://simplelocalize.io/blog/introducing/mcp-server.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Custom integrations for SimpleLocalize]]></title>
            <link>https://simplelocalize.io/blog/posts/custom-integration-for-simplelocalize</link>
            <guid>https://simplelocalize.io/blog/posts/custom-integration-for-simplelocalize</guid>
            <pubDate>Thu, 08 May 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Create a SimpleLocalize integration for your custom translation tool. Learn the best practices and tips for building a custom integration that works seamlessly with SimpleLocalize.]]></description>
            <content:encoded><![CDATA[SimpleLocalize is an app that provides a UI to manage translations for your application—but it’s more than just a UI.
You can explore a wide range of custom-built integrations for tools like Cursor AI, VS Code, Figma, IntelliJ, the command line, and many more.
Our goal has always been to offer users maximum extensibility and flexibility, allowing them to use their preferred tools while keeping the translation workflow as simple as possible.

In this article, we’ll share advice and tips on how to create your own custom integration for SimpleLocalize. We will walk you
through some useful API endpoints and explain how to use them to ensure your integration is solid and reliable.

SimpleLocalize plugin for IntelliJ IDEA

Why would you need a custom integration?

While we offer a wide variety of pre-built integrations for many popular apps and development tools, there are still cases where you might need something more tailored.
You may want to integrate with a tool that SimpleLocalize doesn’t support yet, or perhaps you have specific workflow requirements that demand a custom solution.

Over time, we have helped many developers and organizations build their own integrations—and we are happy to help you do the same!
In this article, we’ve gathered all the essential information you need to create a custom integration with SimpleLocalize, and we’ll walk you through it step by step.

Making an impact

As a developer, you might enjoy exploring new ideas and building tools that boost your productivity.
You may want to create a custom integration for your IDE or develop a translation tool that helps you translate your app more efficiently.

Saving time

Reducing the time spent on managing translations is a strong reason to build a custom integration.
If you are already familiar with the tool or platform you want to integrate, the process can be quite manageable.
With a bit of support from us, you can build an integration that saves you a significant amount of time.

Discounts for Developers

ICreating a custom integration can be a big task, and we understand it takes time and effort.
If you are planning to build an integration that benefits the SimpleLocalize community, we’d love to support you in that process.

We’re also happy to offer a discount or extend your SimpleLocalize plan if you create an integration that others can use.
Feel free to reach out—even if you are not sure yet what kind of integration you want to build. We are here to help!

How to get started quickly?

Starting a new project can feel overwhelming—there’s test data to gather, documentation to read, and uncertainty about what’s possible.
We understand that feeling, and we are here to make it easier for you.

1\. Create a new project

The easiest way to begin is by creating a new project in SimpleLocalize. Import a sample translations file for testing using the 'multi-language-json' format to get things up and running quickly.

Download sample data (25KB)

Swagger UI for SimpleLocalize API

2\. Get your API Key

After setting up your project, retrieve the API key to authenticate your requests to the SimpleLocalize API.
Run Command Assistant (CMD + k or Ctrl + k), type 'Copy API Key' and click 'Enter' to copy the API key to your clipboard, or go to the project settings, and copy the API key manually from there.

Swagger UI for SimpleLocalize API

3\. Test the API

Use our Swagger UI to test the API. Use the API Key you copied in the previous step to authenticate your requests by using it in X-SimpleLocalize-Token header.

Swagger UI for SimpleLocalize API

Alternately, you can use tools like Postman or Insomnia to explore the API. You can create your own collection of requests by importing our OpenAPI specification file.

Integration ideas

There are many different ways to integrate SimpleLocalize with your app, and we are happy to help you with that, for example:

IntelliJ IDEA plugin - integration with IntelliJ IDEA for managing translations in IDE

VS Code extension - integration with Visual Studio Code

Figma plugin - integration with Figma, for pushing translations from Figma to SimpleLocalize

Command-line tool - integration with command-line, for managing files via CLI

Model Context Protocol - integration with LLM agents

Getting access to the API

Every project in SimpleLocalize has its own API Key and Project Token. API Key is used to authenticate your requests, and you provide it via X-SimpleLocalize-Token header.

Create personal access token

Project Token is used mostly for Translation Hosting, allowing you to fetch translations from CDN. Hosted translations are a great way
to get lightning fast access to translations on the client-side without exposing your API key to the end users.

Personal Access Tokens (PAT) are used to authorize specific endpoints and are tied to individual user accounts.. For example, you can use a PAT to get a list of all projects. The PAT is always sent in the Authorization header.
You can send it with every request, but it is not necessary.

Create personal access token

Tip: Start small—build an integration that works with a single project using the API Key. Once it’s running smoothly, you can expand it to support multiple projects using a PAT.

Understanding translation keys

In SimpleLocalize, translation keys don’t rely on a single universal identifier. Instead, each key is identified by a combination of a key name and a namespace.
The key name is the actual identifier of the translation string, while the namespace helps group related keys together.
This combination—key name + namespace—must be unique within the project.

For example, you can have a translation key named key in the namespace namespace, and another translation key with the name key in a different namespace namespace2.
Both key names and namespaces are case-sensitive, so key and Key are treated as different keys, even within the same namespace. The same rule applies to namespaces themselves

Namespaces are useful for organizing translation keys, typically by separating different parts of an application or different source files.
For instance, you might use one namespace for your login page and another for your dashboard.

Key rules to keep in mind:

Translation keys can be up to 500 characters long,

By default, SimpleLocalize uses an empty string as the default namespace.

Namespaces can be up to 128 characters long.

Important: Some i18n setups—especially in backends or mobile apps—don’t commonly use namespaces.
However, your integration should always support namespaces and never assume they will be empty.

Interacting with the API

Let's dive into the API and see how to interact with it. We will show you some of the most important endpoints you can use to create your custom integration.

Get translations list from SimpleLocalize project

1\. Fetch translation keys

One of the most common pieces of data you’ll likely need is a list of available translation keys. We offer two endpoints for this purpose:

Get translation keys with metadata



or get translations without metadata



You might wonder why we offer two endpoints for the same task. The difference lies in the amount of data each endpoint returns.

The first endpoint provides a lot of metadata about each translation key.

The second endpoint only returns the key name and namespace.

The first endpoint requires pagination, while the second one does not.

The second endpoint is much faster and easier to use. It’s perfect for checking whether a translation key exists or to identify duplicate keys across different namespaces.

2\. Project details

With one request, you can fetch all necessary details about the project, including the project name, list of languages, hosting environments, namespaces, and more.



This endpoint is also a great way to check if the project is still active, and if the API key is still valid.

3\. Basics of managing translations

SimpleLocalize offers a variety of endpoints for managing translation keys and translations. But don't get confused, you don't need to use all of them.
You can categorize the endpoints into two main groups:

Translation keys - for managing translation keys and their details

Translations - for managing translations and their details

Each of these groups can be further divided into two categories:

bulk endpoints - for managing multiple translation keys or translations at once

single endpoints - for managing one translation key or translation at a time

Bulk endpoints are generally much faster and more efficient, especially if you're working with large sets of data. They also help avoid hitting rate limits.
On the other hand, single endpoints are ideal for more specific actions, such as updating or deleting individual translation keys or translations.

4\. Auto-translation: Start and wait

If your integration needs to initiate auto-translation jobs, you’ll need to use this endpoint:



But how do you know when the job is finished? It's simple: use the following endpoint to check the job status:

Provide the jobId you received in the response of the previous endpoint to check the status of the job.
Another way, much simpler, is to fetch all running jobs for the project:



And see if any of the jobs are still running. In a number of cases, you will want to use the second endpoint, it's easier to use,
and it can help prevent you from starting a new job while others are still running.

5\. Translation hosting: Publish and get

Similarly to auto-translation, if your integration plans to publish translations, then you will have to use the following endpoint:



and you will have to wait for the job to finish. If you try to publish translations while the previous job is still running, you will get an error.

6\. List of projects

Listing projects might be a little bit tricky, as it requires using a Personal Access Token (PAT) to retrieve all projects associated with a user.
By fetching this information, you will also gain access to the API Key and Project Token for each project.

To get a list of all projects, use the following endpoint:



Keep in mind that users can reset their API Key at any time, but the Project Token remains unchanged.
If you plan to store information about a specific project, the Project Token is the best option to use.

7\. CLI-like integration

SimpleLocalize provides a command-line tool that can be used on most of the popular platforms like Windows, macOS, and Linux, including ARM-based variants.
If you want to build your own integration that behaves similarly to the CLI, you can use the following two endpoints:

Export translations from a file:



Use this to export translations from SimpleLocalize into a file format of your choice, based on the parameters you include in the request.

Secondly, you can use the following endpoint to import translations from a file:



This endpoint allows you to import translations from a file into SimpleLocalize.

Note that it supports uploading one file per request, so if you need to import multiple files, you’ll need to send separate requests for each.

Swagger

Swagger is a great way to explore our API, and it will also give you a lot of examples of how to use the API.
It also provides OpenAPI specification, which is a standard way to describe REST APIs. You can use it to generate integration code in many programming languages and frameworks.

Swagger UI

SimpleLocalize: Swagger UI is the best place to explore our API. It provides up-to-date documentation and interactive examples for each endpoint.

Swagger UI

With Swagger, you can not only test API calls but also generate ready-to-use Java model classes, TypeScript interfaces, complete API clients for any supported programming language or framework.

OpenAPI generator

You can use the OpenAPI generator CLI to automatically generate code for your integration.
This tool supports many programming languages and frameworks, making it easy to get started quickly.

The generator uses our OpenAPI specification to create client code tailored to your chosen language.

Replace \<language> with the language you want to use for your integration. You can find the list of available languages here.

TypeScript

To generate TypeScript interfaces along with an Axios-based client, run:

This command will generate a folder containing all the files you need to start using the SimpleLocalize API in your TypeScript project.

Java

You can also generate Java code for the SimpleLocalize API using the OpenAPI Generator.
Here’s a basic command to generate the full client:

If you only want to generate model classes (without full API client logic), use the following command:

Python

You can use the following command to generate Python code for the API:

Please refer to the official generators documentation for more information.

Note: It's recommended to NOT generate model classes during the build process, as this can lead to breaking your build if we make any (even minor) change to the API.

Good practices

1\. Add the 'Authorization' header

When you are using the SimpleLocalize API, always include the x-simplelocalize-token header—this is required for every request.
Optionally, you can also include the Authorization header with a Personal Access Token (PAT). While it doesn't do much currently,
it may allow enhanced functionality in the future, such as identifying which user made a request or applying user-level permissions.

2\. Set client name

You should include the x-simplelocalize-client header in your requests. This is optional but strongly recommended,
as it helps us identify and support your integration more effectively.

3\. Use the latest API version

Always use the most recent version of our API. We frequently release improvements and new features—using the latest version ensures access to the newest capabilities and best performance.

4\. Be nice to our API

You should always be nice to the API—not just SimpleLocalize's, but any API you work with. This means that you should Avoid sending large bursts of requests
or overwhelming the server with simultaneous calls. Keeping your requests within reasonable limits helps prevent rate-limiting or temporary blocks and ensures a smoother experience for all users.

5\. Never expose API keys in client-side code

Never use your API key in frontend code or expose it to end users. In the past, there was a case where a developer accidentally
included the API key and all the translation management logic directly in the production frontend. This caused a flood of requests to
the API from unaware users just browsing the website. Eventually, the project hit its rate limits, and the API became blocked for the developer.

Always handle translation updates and API interactions securely on the server side to avoid similar issues.

6\. Be prepared for changes

We are constantly working on improving our API, and we are adding new features and endpoints. This means that you should be prepared for changes in the API.
While we don’t remove or break existing endpoints, we do add new fields to responses as the API evolves.
Most modern clients handle this gracefully, but if you're using a stricter parser (like Java’s RestTemplate), make sure your deserialization logic is flexible or updated regularly.

7\. Encode request parameters

When you are sending request parameters to the API with translation key or namespace, you should always encode them. Use URLEncoder.encode() in Java, or encodeURIComponent() in JavaScript to encode the request parameters.
Failing to do so may result in failed or incorrect updates due to malformed requests.

Conclusion

We’ve put a lot of care into designing and maintaining our API, and we’re always working to make it better.
While we occasionally add new fields to enhance functionality, we make sure even our oldest endpoints continue to work as expected—ensuring your existing integrations remain reliable.

Think there’s an endpoint missing that would help your integration? Or maybe an existing one could return more data? In such cases, contact us directly.

If you need logos or icons for your integration, check out our brand assets page.
And if you’d like help or want to be featured on our website, don’t hesitate to reach out. We’re here to support you in any way we can.
]]></content:encoded>
            <category>developer</category>
            <category>integration</category>
            <category>javascript</category>
            <category>automation</category>
            <category>tips</category>
            <enclosure url="https://simplelocalize.io/blog/custom-integration/custom-integration-guide.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Introducing: IntelliJ IDEA plugin]]></title>
            <link>https://simplelocalize.io/blog/posts/introducing-intellij-idea-plugin</link>
            <guid>https://simplelocalize.io/blog/posts/introducing-intellij-idea-plugin</guid>
            <pubDate>Wed, 30 Apr 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[The new SimpleLocalize IntelliJ IDEA lets you manage translations directly in the editor. Explore key features and installation instructions.]]></description>
            <content:encoded><![CDATA[We are excited to announce the release of our new IntelliJ IDEA plugin for SimpleLocalize! This plugin allows developers to integrate our localization and translation management tools directly into the development workflow.
Designed to simplify the localization process, the plugin allows developers to manage translations and collaborate with translators seamlessly within IntelliJ IDEA.

IntelliJ IDEA for SimpleLocalize

Key features

The SimpleLocalize for IntelliJ IDEA comes packed with features that make managing translations directly in your code editor a breeze. Here's what you can do:

Auto-translate your app texts

Smart autocomplete - get suggestions for translation keys

Publish translations with just a few clicks

Open translation keys in SimpleLocalize

Edit translations from IntelliJ IDEA

Rename translation keys directly in your code

Create translation keys from text selection

Key features of IntelliJ IDEA

Installation & setup

You can install the plugin directly from the Jetbrains Marketplace. Search for "SimpleLocalize" in the IDE Marketplace tab and click "Install".

Once the plugin is installed, you will need to configure it with your Personal Access Token.

You will need to provide your personal token to authenticate the plugin with your SimpleLocalize account. You can find your personal token in your SimpleLocalize account settings, in the Security section or by following the direct link to get your token.

Next, select the project you want to work on. Once selected, you can begin using the plugin! Watch the step-by-step video guide below to learn how to configure the plugin.

Installation of SimpleLocalize plugin in IntelliJ IDEA via IDE marketplace

You can find more details regarding the configuration in our IntelliJ IDEA integration page.

IntelliJ IDEA plugin in action

Let's take a look at how the plugin works in action. Here are some examples of how you can use the plugin to manage translations directly within your code editor.

Sidebar

The plugin adds a new sidebar to your code editor that displays an overview of all translations in your project. You can see and edit all translation keys and their values.

Updating translations from IntelliJ IDEA window

All translation changes are automatically synchronized with SimpleLocalize, so you can see the changes in real-time.

On the sidebar, you can also see the recent activity and translation hosting resources.

Publish translations from IntelliJ IDEA window

Code actions

Code actions allow you to perform various actions directly in your code editor. You can:

rename translation keys

create new translation keys from text selection

edit translations

open translation keys in SimpleLocalize

Here you can see an example of creating a new translation key from text selection in your code editor.

Creating translation key from text selection

Auto-complete

Get suggestions for translation keys while typing in your code editor. This makes it easier to find the right key and avoid typos or mistakes.

Translation key autocomplete in IntelliJ IDEA

Auto-translate

Start auto-translation for your app text directly from the IDE using the "Play" button in the window or running the action from the "Actions".

Run auto-translation from IntelliJ IDEA plugin

Publish translations

The hosting tab that you can find in the plugin gives you an option
to publish translations to all of your translation hosting environments,
and browsing all the resources.

Publish translations and browse resources in IntelliJ IDEA

Summary

We hope that the new IntelliJ IDEA plugin will make it easier for developers to manage translations directly within the code editor. The plugin offers a range of features that streamline the localization process and help you keep your translations up to date.

Try out the new SimpleLocalize IntelliJ IDEA plugin and let us know what you think! We are excited to hear your feedback and suggestions for new features.

If you have any questions or need help with the plugin, feel free to reach out to us.
]]></content:encoded>
            <category>tutorial</category>
            <category>software localization</category>
            <category>developer</category>
            <category>product updates</category>
            <enclosure url="https://simplelocalize.io/blog/introducing/intellij-idea-plugin.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[How to recover lost translations in SimpleLocalize]]></title>
            <link>https://simplelocalize.io/blog/posts/recover-translations-simplelocalize</link>
            <guid>https://simplelocalize.io/blog/posts/recover-translations-simplelocalize</guid>
            <pubDate>Tue, 29 Apr 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Recover lost translations in SimpleLocalize with manual backups, automatic snapshots, uploaded files, or by using Translation Hosting files.]]></description>
            <content:encoded><![CDATA[Managing translations is a critical part of any project, and sometimes things don't go exactly as planned. Whether it's uploading the wrong file, deleting keys by accident, or simply wanting to go back to an earlier version, SimpleLocalize offers several ways to help you recover your translations.

In this post, we'll walk you through different options you have when you need to restore translations.

Manual backups

A manual backup is a full copy of your project's translations that you can create yourself. You can create and download a backup at any time by going to Settings → Backups.

If you have a backup of your project from before the changes you want to undo, you can easily restore it. Click on the backup you want to restore, and then select if you prefer to create a new project or overwrite the existing one.

Restoring manual backup

Manual backups are fully under your control, so they won't expire or disappear unless you delete them. It's a good idea to create a backup before making bigger changes to your project.

Note that backups don't include screenshots; to restore also screenshots, you need to use snapshots. Learn more about manual backups.

Automatic snapshots

SimpleLocalize automatically creates snapshots of your project at different points — sometimes even before major changes like imports or mass edits.
You can find these snapshots by going to the Activity tab and using the Filters and selecting Snapshots.

Snapshots in the Activity tab

Once you find the right snapshot, you can preview snapshot to check what the project looked like at that time and see the JSON file with the translations.

Previewing snapshot

Click on Revert changes to restore the translations directly from that snapshot.

Reverting snapshot

Reverting from a snapshot updates the translations based on the saved state, without removing any new keys that weren't part of the snapshot. It means that, unlike backups, you won't lose any new keys or translations that were added after the snapshot was created.

Reverting snapshot doesn't delete all your current data, it only updates the translations based on the saved state of the snapshot. Thanks to that, screenshots are not deleted during the reverting process. Learn more about automatic snapshots.

Uploaded and exported files

Every time you upload or export a translation file, SimpleLocalize logs it in the Activity tab.

If you need to undo a mistake, finding the last correct file you uploaded or exported can also be a good recovery method. You can simply download the file from the activity log and re-import it into your project. This can be a simple and quick way to undo mistakes without using backups or snapshots.

Uploaded files in the Activity tab

Translation hosting

If you use Translation Hosting in SimpleLocalize, you have another backup layer. Hosted translations are stored in a multi-language-json format, which can be downloaded and re-imported if needed.

Check your hosting environments in SimpleLocalize and download the \_index file for a complete list of translations in all languages.

Download hosted translations

You can also download the translations for a specific language, customer context or namespace.

Final tip

Mistakes can happen, but with manual backups, automatic snapshots, activity logs, and hosted files, you have multiple ways to protect and recover your translation data in SimpleLocalize. If you're ever unsure which method is best for your situation, don't hesitate to reach out to us for help. We're here to assist you in keeping your translations safe and sound.
]]></content:encoded>
            <category>json</category>
            <category>developer</category>
            <category>tutorial</category>
            <category>software localization</category>
            <enclosure url="https://simplelocalize.io/blog/translations-recovery.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Introducing: Markdown visual editor]]></title>
            <link>https://simplelocalize.io/blog/posts/introducing-markdown-editor</link>
            <guid>https://simplelocalize.io/blog/posts/introducing-markdown-editor</guid>
            <pubDate>Thu, 17 Apr 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Markdown visual editor is a new feature in SimpleLocalize that allows you to edit Markdown files in a user-friendly way, without needing to know the syntax.]]></description>
            <content:encoded><![CDATA[We are excited to share with you the latest addition to our text editor - the Markdown visual editor! This new feature allows you to edit Markdown files in a user-friendly way, without needing to know the syntax. You can now focus on your content and let the editor handle the formatting for you.

WYSIWYG (What You See Is What You Get) editing is a game-changer for anyone who works with Markdown files. With the visual editor, you can see how your text will look in its final form as you write, making it easier to create and edit content. No more guessing how your formatting will appear - you can see it all in real-time.

How to use the Markdown visual editor

In SimpleLocalize you can work on translations in Markdown format which is a popular markup language used for formatting text.

First, make sure that your translation has the Markdown type selected in the translation key settings. This option converts the standard translation editing input into a bigger text editor.

Markdown translation type

Open the editor and you will see the Markdown visual editor interface.
The editor provides a toolbar with formatting options, such as bold, italic, headings, lists, links, and more. You can also insert images, code snippets and black quotes easily.

Markdown visual editor

You can also switch between the visual editor and the Markdown code view at any time. This allows you to see the raw Markdown syntax if you need to make any advanced edits or adjustments.
To switch to the code view, uncheck the Markdown checkbox in the editor options.

Markdown code view

You can adjust the code view settings to your liking. You can choose to show or hide line numbers or wrap lines to make it easier to read long lines of code.

Conclusion

Markdown editor provides a more intuitive and user-friendly way to work with Markdown files in SimpleLocalize. It's a no-code solution perfect for translators and content creators who want to focus on their writing without worrying about formatting.
Translating long texts like documentation, articles, or blog posts is now easier with the WYSIWYG interface. You can focus on your content and let the editor handle the formatting for you.
]]></content:encoded>
            <category>tutorial</category>
            <category>software localization</category>
            <category>translation management</category>
            <category>product updates</category>
            <category>markdown</category>
            <category>translation editor</category>
            <enclosure url="https://simplelocalize.io/blog/markdown-visual-editor.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to keep translation keys in order]]></title>
            <link>https://simplelocalize.io/blog/posts/translation-keys-order</link>
            <guid>https://simplelocalize.io/blog/posts/translation-keys-order</guid>
            <pubDate>Wed, 16 Apr 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to keep translation keys in order in your localization files and why it matters. Explore sorting options and the use case of random order.]]></description>
            <content:encoded><![CDATA[The order of translation keys in your localization files may not seem important at first glance, but it can affect your localization process, depending on your workflow. For example, if you are using a translation management system (TMS) like SimpleLocalize, the order of translation keys can impact how translators work with the files and how they are displayed in the TMS interface.
In this blog post, we'll explore how to keep translation keys in order, why it matters, and how to sort them effectively. We will also describe the use case of working with translation keys in a random order and how to handle it.

Why to keep translation keys in order?

Keeping translation keys in order can help maintain consistency and organization in your localization files. It can also make it easier for translators to find and work with specific keys, especially in larger projects, when users are already accustomed to a specific order.
Additionally, having a consistent order can help prevent errors and confusion when merging or updating localization files.

In a TMS like SimpleLocalize, the order of translation keys can affect how they are displayed in the translation editor. By default, translation keys are displayed in alphabetical order, but you can also choose to display them in the order they appear in the source file. This can be helpful for translators who are familiar with the original file and want to work with the keys in the same order.

How to keep translation keys in import order?

SimpleLocalize allows you to keep the order of translation keys when importing localization files. This means that if you have a specific order in your source file, it will be preserved in the translation editor to make it easier for translators to work with the keys.

When importing translations, you can choose the Import order sorting option in the translation editor. This will ensure that the translation keys are displayed in the same order as they appear in the source file.

Showing translation keys in import order in the translation editor

When you change the order of translation keys in your source file, you can also choose to update the order of translation keys in the translation editor. To do this, you can use the Update order option during import.

Translation keys order during import

Use UPDATE_ORDER option for import via API or CLI.

During export, you can also choose the import order of translation keys in the exported file. This can be helpful if you want to keep the order of translation keys consistent across different files or if you want to ensure that the exported file matches the original source file.

Translation keys order option during export

Use --downloadSort IMPORT_ORDER option for export via CLI. For API export, use sort parameter with IMPORT_ORDER value.

Sorting translation keys

Translation editor in SimpleLocalize allows you to sort translation keys in different ways. You can sort them alphabetically, which is the default sorting option, or you can sort them by most or least translated keys, newest or oldest keys, last seen, last modified, by namespacer or by the order they appear in the source file.

Sorting translation keys in the translation editor

Thanks to this flexibility, you can choose the sorting option that works best for you. This setting can be adjusted by each user to their preference.

When translation keys order doesn't matter

In many localization projects, the order of translation keys doesn't actually matter. Translation files use a key-value format (like JSON or YAML), where the app just looks up the key to find the right text. It doesn't care where the key appears in the file.

If you're using a translation management system, this becomes even more true. Translators usually don't work directly with the source files—they use a clean interface that helps them search, filter, and organize translations however they want. So the original order of keys doesn't affect their work.

Here are some cases where the order of keys doesn't really matter:

When translators use a TMS instead of editing the file directly.

In automated workflows, where tools handle the translations without needing any specific order.

When the TMS sorts keys automatically, like alphabetically or by usage.

In our localization workflow guide, you can see that many modern workflows rely on automation and tools that make key order unimportant. What matters more is using clear, consistent key names and organizing your files in a way that works for your team.

In short, keeping keys in a specific order is more of a human preference—it can help with readability, but it won't affect how your app runs or how translations are done.

Conclusion

Keeping translation keys in order can be important for maintaining consistency and organization in your localization files. SimpleLocalize provides options to keep the order of translation keys during import and export, as well as sorting options in the translation editor. By using these features, you can ensure that your translation keys are displayed in a way that works best for your team and translators.

If you have any questions or need help with keeping translation keys in order, feel free to reach out to us at contact@simplelocalize.io.
]]></content:encoded>
            <category>json</category>
            <category>developer</category>
            <category>tutorial</category>
            <category>software localization</category>
            <enclosure url="https://simplelocalize.io/blog/translation-keys-order.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Context in Localization]]></title>
            <link>https://simplelocalize.io/blog/posts/context-in-localization</link>
            <guid>https://simplelocalize.io/blog/posts/context-in-localization</guid>
            <pubDate>Tue, 01 Apr 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Discover the importance of context in localization and how it can enhance the quality of your translations. Learn how to provide context to translators in SimpleLocalize.]]></description>
            <content:encoded><![CDATA[When it comes to localization, context is everything. Providing translators with the right context can significantly improve the quality of translations and ensure that the final product resonates with the target audience. In this blog post, we'll explore why context matters in localization and how you can effectively provide it to your translators using SimpleLocalize.

What is context in localization?

Context in localization refers to the information surrounding a piece of text that helps translators understand its meaning and intended use. This includes details about the content, audience, and how it fits into the overall user experience. Context can be conveyed through key names, descriptions, screenshots, and comments.

Providing context is crucial for translators to make informed decisions about word choice, tone, and style. Without it, translations may be inaccurate, leading to confusion or a misrepresentation of your brand.

Context in localization

In software localization, context is especially important because the same word or phrase can have different meanings depending on where it appears in the application. For example, the word "file" could refer to a document, a folder, or a database entry, depending on the context in which it is used.

Beyond word meaning, context also helps align translations with user intent and the application's functionality. It ensures that the wording meets user expectations and enhances usability.

Contextualization

Contextualization is the process of providing additional information about a piece of text to help translators understand its meaning and purpose.

It's a term often used in the localization industry to describe the practice of providing context to translators. Contextualization is essential for ensuring that translations are accurate, relevant, and resonate with the target audience.

Contextualization can take many forms, including:

Key names:  Use descriptive names that hint at the content's function.

Descriptions: Explain a key's purpose and usage in detail.

Screenshots: Show how the text fits into the interface.

Tags: Categorize keys based on their usage.

Namespaces: Group related keys for better organization.

Comments: Offer additional notes for clarification.

Translation memory: Provide references to previously translated strings.

Glossaries: Define key terms to ensure consistency.

Contextualization

Why context matters

Context is crucial in localization for several reasons:

Accuracy: Reduces misinterpretation and ensures precise translations.

Consistency: Maintains uniformity across translations.

Cultural relevance: Adapts content to align with the target audience.

User experience: Helps translators understand how the text fits into the overall user experience, allowing them to choose words and phrases that enhance usability and clarity.

Brand voice: Ensures the translation aligns with company messaging.

Additionally, providing context can speed up the translation process by reducing the need for back-and-forth communication between translators, developers and project managers. It improves the overall quality of translations, leading to a better user experience and higher customer satisfaction.

Translation process with context

How to provide context in localization

Providing context to translators is essential for ensuring accurate and relevant translations. Below you can find some tips on how to effectively provide context in localization using SimpleLocalize:

Use descriptive key names

When creating keys for your strings, use descriptive names that provide context about the content. For example, instead of using a generic key like button_submit, use form_submit_button to indicate that the button is part of a form.

This helps translators understand the purpose of the string and its context within the application.

Descriptive key names

Use screenshots

Providing screenshots of the application can help translators visualize how the text fits into the user interface. This is especially useful for UI elements like buttons, labels, and error messages.

Screenshots can help translators understand the context of the string and how it will appear to users. In SimpleLocalize, you can upload screenshots directly to the key details panel, making it easy for translators to access them.

Key description and screenshot

Learn more about adding screenshots to your keys.

Use tags

Using tags to categorize keys can provide additional context about their usage. For example, you can use tags to indicate whether a string is part of a specific feature, section, or module of the application.

In SimpleLocalize, you can add tags to keys in key settings. This allows translators to filter and search for keys based on their tags, making it easier to find relevant strings.

Tags in SimpleLocalize

Learn more about using tags in SimpleLocalize.

Use namespaces

Namespaces are a way to organize keys into logical groups. They are mainly used to group translation files and keys by their context within the application.
For example, you can use namespaces to group keys related to a specific feature or module of the application. This helps translators understand the context of the strings and how they fit into the overall structure of the application.

In SimpleLocalize, you can create namespaces for your keys in the key settings or upload them with your translations.

Namespaces in SimpleLocalize

Learn more about using namespaces in SimpleLocalize.

Add comments

Add comments for translators to provide additional information about the usage and context of the string. This can include notes about specific requirements for the translation, cultural considerations, or any other relevant information.

Comments are especially useful for strings that may have multiple meanings or require specific phrasing.

Comments in SimpleLocalize

Learn more about adding comments to your keys.

Use translation memory

Translation memory (TM) provides context about previously translated strings and their usage in all your projects. This can help translators maintain consistency across translations and understand how similar strings have been translated in the past.

In SimpleLocalize, you can check the translation memory for similar strings and their translations, making it easier for translators to find relevant context.

Translation memory in SimpleLocalize

Learn more about translation memory in SimpleLocalize.

Use in-context editor

The In-Context Editor allows you to edit translations directly within the context of your application. This means you can view and edit translations while seeing how they appear in the actual user interface, making it easier to ensure that your translations fit well within the design and flow of your application.

With the In-Context Editor, you can quickly find and fix issues with translations, such as text that is too long or does not fit properly within the UI elements. It can speed up the translation process by allowing you to make adjustments on the fly.

In-Context Editor in SimpleLocalize

Learn more about using the In-Context Editor in SimpleLocalize.

Context in auto-translation

Auto-translation tools, such as machine translation (MT) engines, can also benefit from context. Providing context to MT engines can improve the quality of translations by helping them understand the meaning and purpose of the text.

DeepL Glossary

DeepL Glossary allows you to provide context to the DeepL MT engine by creating a glossary of terms and phrases. This helps the engine understand the specific terminology used in your application and ensures that translations are accurate and relevant.

You can create a glossary for DeepL in SimpleLocalize to improve the quality of translations. This is especially useful for technical terms, brand names, or industry-specific jargon that may not be accurately translated by the engine.

DeepL Glossary in SimpleLocalize

Context in AI translation

AI translation tools, such as integrated OpenAI, also rely on context. You can provide context to OpenAI in SimpleLocalize using the system prompt. This allows you to define the context in which the translation should be generated, helping the AI understand the meaning and purpose of the text.

Additionally, key descriptions can be used to provide further context to the AI engine, ensuring that translations are accurate and relevant.

Context in AI translation

Learn more about using OpenAI in SimpleLocalize.

Context in translation API

SimpleLocalize also provides you with the ability to provide context through the translation API. This allows you to automate the localization process and ensure that context is consistently provided to translators.

When using the translation API, you can include key descriptions, tags, and namespaces in your requests. This helps ensure that translators have access to the necessary context when translating strings.

Learn more about using the translation API in SimpleLocalize.

Best practices for providing context

When providing context to translators, it's essential to follow best practices to ensure that the context is clear and relevant. Here are some tips for providing effective context in localization:

Be clear and concise: When providing context, be clear and concise in your descriptions and comments. Avoid jargon or technical terms that may confuse translators.

Use visuals: Use screenshots and visuals to help translators understand the context of the string. This can be especially helpful for UI elements and complex features.

Be consistent: Use consistent terminology and phrasing across your keys and descriptions. This helps translators understand the context and maintain consistency in translations.

Collaborate with translators: Involve translators in the localization process and encourage them to ask questions if they need clarification on the context. This helps ensure that translations are accurate and relevant.

Context options icons

Review and update context: Regularly review and update the context provided to translators to ensure that it remains relevant and accurate. This is especially important for applications that undergo frequent updates or changes.

Use translation memory: Leverage translation memory to provide context about previously translated strings and their usage. This helps maintain consistency and improves the overall quality of translations.

Test translations: Test translations in the context of the application to ensure that they resonate with users and enhance the overall user experience. This helps identify any issues with context and allows for adjustments as needed.

Provide feedback: Provide feedback to translators on their translations and how well they align with the context provided. This helps improve the quality of translations and encourages continuous improvement.

Conclusion

In conclusion, context is a critical component of localization that can significantly impact the quality of translations. By providing context to translators, you can ensure that translations are accurate, relevant, and resonate with the target audience. SimpleLocalize offers various tools and features to help you provide context effectively, including key descriptions, screenshots, tags, namespaces, comments, translation memory, and integration with machine translation engines.

By following best practices for providing context, you can enhance the localization process and improve the overall quality of your translations. Remember, context is everything in localization, and investing time and effort into providing it will pay off in the long run.
]]></content:encoded>
            <category>tips</category>
            <category>translation management</category>
            <category>software localization</category>
            <category>translator</category>
            <category>auto translation</category>
            <enclosure url="https://simplelocalize.io/blog/context-in-localization.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Introducing: Command Assistant]]></title>
            <link>https://simplelocalize.io/blog/posts/introducing-assistant</link>
            <guid>https://simplelocalize.io/blog/posts/introducing-assistant</guid>
            <pubDate>Wed, 26 Mar 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Command Assistant is a powerful tool that enables you to navigate through your projects, manage translation keys, and access statistics with ease.]]></description>
            <content:encoded><![CDATA[We are excited to announce the launch of Command Assistant, a new feature designed to help you manage your translations more efficiently.

Command Assistant is a powerful tool that enables you to quickly navigate through your projects, manage translation keys, search for translations and access statistics with ease.
With Command Assistant, you can search for translations and translation keys in current project or all your projects, auto-translate missing translations, publish translations, and more—all from one place.

Open Command Assistant

To open Command Assistant, use the keyboard shortcut ⌘ + K on macOS or Ctrl + K on Windows and Linux.

You can navigate through the Command Assistant using the arrow keys and the Enter key.

Command Assistant in action

Key Features

Command Assistant allows you to:

Search for translation keys and display them in the editor

Search for translations in the current project or all your projects

Open translation key settings

Copy links to translation keys

Add new translation keys

Delete translation keys

Copy project token or API key

Open project, language, and user statistics

Access project members, permission settings, and recent activities

List and open projects

Switch between different tabs

Open various resources like Swagger or documentation

Auto-translate missing translations

Sort and filter translations

Adjust editor settings

And more!

Conclusion

We hope that Command Assistant will help you manage your translations in SimpleLocalize's Translation Editor more efficiently.
If you have any questions or feedback about the available features, please let us know—we are always looking for ways to improve our product and enhance your experience.

Give Command Assistant a try and let us know what you think!

Share your feedback on Command Assistant in the SimpleLocalize feature requests board.
]]></content:encoded>
            <category>tutorial</category>
            <category>software localization</category>
            <category>translation management</category>
            <category>product updates</category>
            <enclosure url="https://simplelocalize.io/blog/introducing/assistant.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to manage shared translation keys across projects]]></title>
            <link>https://simplelocalize.io/blog/posts/managing-common-translation-keys</link>
            <guid>https://simplelocalize.io/blog/posts/managing-common-translation-keys</guid>
            <pubDate>Mon, 10 Mar 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to efficiently manage shared translation keys across multiple projects in SimpleLocalize to keep translations consistent and easy to maintain.]]></description>
            <content:encoded><![CDATA[When working on multiple projects, you'll often find yourself reusing the same translation keys across different applications. Without a structured approach, this can lead to inconsistencies, duplication, and increased maintenance efforts. But don't worry—there are effective ways to manage this!

In this article, we'll explore how to handle shared translation keys in SimpleLocalize, ensuring consistency, organization, and easy updates.

What are shared translation keys?

Imagine you have two projects in SimpleLocalize: one for your software's webpage and another for the software itself. Both projects share common translation keys like button.submit, button.login, button.cancel, home, and support.

When you update button.submit in one project, you want that translation to automatically apply to the other. This eliminates duplication, ensures uniformity, and reduces manual work.

Now, let's explore the best strategies for managing shared translation keys efficiently using SimpleLocalize.

Method 1: Using a dedicated project for shared keys

One of the best ways to maintain consistency is by creating a Shared Key Repository, a centralized project that houses all common translations. This acts as a single source of truth, ensuring seamless updates across multiple projects.

Shared Key Repository

Advantages of this approach:

You manage all shared keys in one place.

You can export shared keys as a separate file and use them in multiple projects.

You avoid duplicating the same keys across different projects.

Updating translations in one place automatically ensures consistency in all connected projects.

How to implement this:

Create a separate project in SimpleLocalize and name it something like “Common Keys".

Add all shared translation keys to this project.

Download translations from the common keys, join them with project-specific translations, and use them in your projects. You can use Translation Hosting and the SimpleLocalize CLI to automate this process.

Regularly update translations in this repository so that all projects using these shared keys stay synchronized.

With this approach, you can also create a separate project for your glossary. By managing glossary terms and translations in one place, you can use translation memory to check and reuse correct translations in other projects.

Method 2: Managing all keys in one project

Another strategy is storing all translations in a single project, differentiating between shared and project-specific keys using namespaces, tags, customers, or structured translation keys.

Namespaces

Namespaces are a powerful way to organize translation keys within one project. They help you group keys by their purpose or origin, making it easier to manage and update translations. Depending on your needs, you can use namespaces to categorize keys by project, platform, or feature.

For managing different projects and shared keys in one SimpleLocalize project, you can:

Store shared keys without a namespace.

Assign project-specific keys under namespaces like app, web.

Namespace-based organization

However, if you are already using namespaces for other purposes, this approach may not be suitable. In such cases, consider using tags, customers, or structured translation keys to differentiate shared and project-specific keys.

Learn more about namespaces in SimpleLocalize.

Tags

Tags are another way to categorize translation keys within one project. You can use tags to group keys by their purpose, platform, or feature, making it easier to manage and update translations.

Tags can be assigned regardless of the key's namespace, allowing you to customize translations for different projects without affecting others.

Tag-based organization

Learn more about tags in SimpleLocalize.

Customers

Using customer context is not an obvious approach as it bases on a different concept. Let's say, 90% of your translation keys are shared across all projects, and only 10% are project-specific.

In this case, you can create a customer context for each project and adjust translations per project without affecting others.

Customer-based organization

Using this method, you update base translations for shared keys in one place and customize translations for each project using customer context.

Learn more about customer context in SimpleLocalize.

Translation keys

Another way to manage shared and project-specific keys is to use translation keys. You can create a naming convention for translation keys to differentiate between shared and project-specific keys.

For example, you can use common.button.submit, common.button.login, common.button.cancel for shared keys and app.button.submit, web.button.login, mobile.button.cancel for project-specific keys.

This method is suitable for projects where you need to maintain a single project for all translations while customizing translations for different platforms or features. It's a flexible approach that allows you to organize and update translations based on your needs.

Translation key-based organization

Learn more about translation keys in SimpleLocalize.

Separate projects with duplicated keys

This default approach involves creating separate projects for each application or platform, with duplicated translation keys across projects. While this method is straightforward, it can lead to inconsistencies and maintenance challenges.

At the same time, this approach gives you more flexibility to customize translations for each project without affecting others. It's suitable for projects with few shared keys or where you need to maintain separate translations for different platforms.

Translation memory

Translation Memory is an additional feature that can help ensure consistency across different projects and translation approaches. It stores all translations and allows you to reuse them without manually copying text.

How Translation Memory helps:

Suggests previously used translations for the same or similar keys.

Ensures translation consistency across different projects.

Saves time and reduces translation costs.

This feature supports both approaches mentioned earlier, helping to maintain a unified and error-free translation experience.

Learn more about Translation Memory in SimpleLocalize.

Conclusion

Each method has its advantages and is suitable for different scenarios. Choose the one that best fits your needs and project requirements. By managing shared translation keys effectively, you can ensure consistency, reduce duplication, and simplify translation updates across multiple projects.

SimpleLocalize offers various customization options to help you organize and maintain translations efficiently. Whether you prefer a separate project for shared keys, a single project with namespaces, tags, customers, or translation keys, or separate projects with duplicated keys, you can find the right approach for your projects.
]]></content:encoded>
            <category>tutorial</category>
            <category>software localization</category>
            <category>translation management</category>
            <category>tips</category>
            <enclosure url="https://simplelocalize.io/blog/shared-translation-keys.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[Introducing: Automated snapshots]]></title>
            <link>https://simplelocalize.io/blog/posts/introducing-automatic-snapshots</link>
            <guid>https://simplelocalize.io/blog/posts/introducing-automatic-snapshots</guid>
            <pubDate>Mon, 27 Jan 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[Protect your translations with automatic snapshots! SimpleLocalize saves your project before big changes, so you can easily restore it if needed.]]></description>
            <content:encoded><![CDATA[The new automatic snapshots feature in SimpleLocalize ensures your translations are safe from accidental loss. SimpleLocalize now automatically creates snapshots of your project before significant changes, allowing you to restore your translations easily if something goes wrong.

How automatic snapshots work

Automatic snapshots are created before you perform any of the following actions:

Importing translations

Deleting a language

Deleting a customer context

Making extensive translations changes

Clearing all translations

With automatic snapshots, you can quickly revert your project to a previous state if the changes you made are not as expected or if an error occurs. Think of it as a built-in backup for your translations.

You can view all the snapshots in the Activity tab in your project.

Snapshots in Activity tab

Restore from a snapshot

To restore your project from a snapshot, go the the Activity tab in your project. Locate the snapshot created before the change you want to revert and click the Preview snapshot button.

The snapshot summary will display the number of translations, languages, and customer contexts at the time it was created. You can also view the translation details in JSON format.

Restore from a snapshot

Click the Revert changes button to restore your project to the state saved in the snapshot.

Once restored, SimpleLocalize will log a new activity entry, detailing the snapshot restoration and the specific changes that were reverted.

Revert changes

How to enable automatic snapshots

Automatic snapshots are enabled by default for all projects. You don't need to configure anything to start using this feature. After making changes to your project, snapshots will automatically appear in the Activity tab.

To see snapshots in the Activity tab, make sure you select the action type Snapshots & Backups from the filter dropdown.

Snapshots & Backups filter

Protect your translations with automatic snapshots and never worry about losing your work again. If you have any questions or need assistance, feel free to contact us!
]]></content:encoded>
            <category>tutorial</category>
            <category>software localization</category>
            <category>translation management</category>
            <category>product updates</category>
            <enclosure url="https://simplelocalize.io/blog/automatic-snapshots.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[The Tofu Symbol: When fonts get confused]]></title>
            <link>https://simplelocalize.io/blog/posts/tofu-symbol</link>
            <guid>https://simplelocalize.io/blog/posts/tofu-symbol</guid>
            <pubDate>Tue, 21 Jan 2025 00:00:00 GMT</pubDate>
            <description><![CDATA[The tofu symbol, a blank box in typography, appears when fonts can't display a character. Learn more about Tofu and how to avoid it in your software.]]></description>
            <content:encoded><![CDATA[Tofu is well-known as a versatile power food, but did you know it has a surprising connection to typography? In the world of fonts, "tofu" is a blank rectangular box that appears when a character cannot be displayed. Its name comes from its resemblance to a plain block of tofu.

What is the Tofu symbol and when does it appear?

The tofu symbol is essentially a placeholder that shows up when:

A font lacks a glyph (the visual representation of a character).

There is no fallback font available to provide the missing glyph.

It's essentially your computer's way of saying, “I don't know what this is supposed to look like.” In these cases, the tofu symbol replaces the character that cannot be rendered.

A glyph is the design of a character in a font. Think of it as the way a letter or symbol looks, like how “A” can be styled differently in Arial vs. Times New Roman.

Why is the Tofu symbol a problem?

Most modern web browsers and devices use fallback fonts to avoid showing the tofu symbol, so you don't see it as often as in the past. But when it does appear, it can be a problem. Missing characters make text harder to read, creating a poor experience for your audience.

Inaccessible text isn;t just frustrating—it can also make your website or app look unpolished. That's why designers and developers aim to eliminate the tofu symbol wherever possible.

Tofu as a design element

Although it's usually unwanted, the tofu symbol can still be used creatively. Some designers incorporate it into projects as a visual statement or to emphasize the absence of information. But for most of us, it's better to avoid it altogether.

Noto fonts: The No-Tofu solution

To combat the problem of tofu symbols, Google developed the Noto fonts (short for "No-Tofu"). This font family is designed to support as many writing systems as possible, ensuring that characters from a vast range of languages can be displayed correctly.

By using Noto fonts as a fallback, you can ensure your content displays correctly for readers worldwide, no matter the language or script. They are an excellent choice for websites and apps, especially when accessibility and inclusivity are priorities.

Conclusion

The tofu symbol is a small but interesting part of how fonts work. While we usually want to avoid it, it's a reminder of the challenges of designing for a global audience. Thanks to solutions like Noto fonts, the tofu symbol is becoming a rare sight—and that's a win for everyone.
]]></content:encoded>
            <category>tips</category>
            <category>translation management</category>
            <category>developer</category>
            <enclosure url="https://simplelocalize.io/blog/tofu-symbol.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[How Translation Memory works in SimpleLocalize]]></title>
            <link>https://simplelocalize.io/blog/posts/introducing-translation-memory</link>
            <guid>https://simplelocalize.io/blog/posts/introducing-translation-memory</guid>
            <pubDate>Tue, 10 Dec 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how translation memory works in SimpleLocalize and how you can use it to speed up your workflow and keep translations consistent across projects.]]></description>
            <content:encoded><![CDATA[If you translate software, websites, or documentation regularly, you've probably noticed a pattern: parts of your content tend to repeat themselves. Buttons, menu labels, onboarding flows, product features; some phrases appear over and over again.

Translation Memory (TM) is designed to make your life easier. It remembers how you translated something before, so you don't have to translate it again.

In this post, we'll explore how translation memory works in SimpleLocalize, how to use it effectively, and how to upload your own TM files to kickstart new projects, even if you don't have any translation history yet.

What is translation memory?

Translation memory (TM) is a system that stores pairs of source text and translated text so you can reuse them later. Instead of translating “Save changes” or “Try again later” from scratch every time they appear, TM suggests translations you or your teammates already created.

It's like having a searchable, automatic database of every phrase you've ever translated, ready to help whenever you need it.

Example

Let's say your team previously translated:

Add to cart → Dodaj do koszyka

Later in another project, you stumble upon a similar string:

Add item to cart

Instead of starting from zero, SimpleLocalize analyzes your translation history and finds the closest matches. You instantly get suggestions you can reuse or adapt.

How translation memory works in SimpleLocalize

SimpleLocalize automatically builds your TM from all translations across all projects you have access to. Every time you or your teammates translate something, it becomes part of the shared memory.

When you open a translation, SimpleLocalize:

Scans your translation history for similar source text

Compares factors like the source phrase, translation key, and context

Ranks suggestions by match level (e.g., exact match, partial match)

Shows you the best suggestions in the TM panel

The result? Faster translation, higher consistency.

Translation memory example

SimpleLocalize uses a matching algorithm to find the best matches for your content by comparing the source text, translation key, and other factors. It offers you a list of suggestions, ranked by relevance, so you can quickly find the best match for your translation.

Using translation memory inside the editor

Translation memory is embedded directly in the translation editor, making it easy to access whenever you need it.

Viewing suggestions

Open the more options menu (⌥) near the translation input field
and select "Translation memory" to view the suggestions for the current translation.

A panel appears with all relevant suggestions pulled from your translation history.

Translation memory in SimpleLocalize

From there, you can choose to apply the suggested translation.

Add TM to Quick Actions

For easier access to the translation memory feature, go to the editor settings and enable translation memory button in Quick Actions. This will add a button to the editor toolbar that allows you to quickly access the translation memory for the selected translation.

Translation memory in quick actions

Learn more about Translation Memory in our docs.

Importing your own translation memory

What if you're starting a brand-new project?
Or migrating from another translation tool?
Or you need consistency with past translations your team created outside SimpleLocalize?

Good news: You can upload your own TM files and use them immediately in translation memory suggestions.

TM collections upload

Imported TMX (Translation Memory eXchange) files become part of your translation memory database, so you can benefit from them right away.

Why import TMX files?

Kickstart new projects: Upload your existing TM and get suggestions from day one—even with no project history.

Migrate from other platforms: Bring your previous translation work with you.

Maintain terminology consistency: Ensure legacy translations continue to be used in new content.

Leverage old translations from agencies or freelancers: Even if they weren't done in SimpleLocalize.

Benefits of using translation memory

There are several benefits to using translation memory in SimpleLocalize:

Translate faster: Reuse previous work instead of translating recurring content from scratch.

Ensure consistency: Your product speaks in one voice across languages and platforms.

Improve quality: Reusing approved translations reduces typos and inconsistencies.

Collaborate effectively: Your whole team benefits from the shared translation database, whether built naturally or imported.

Tips for getting the most out of TM

Import existing TM files when starting new projects

Standardize terminology so TM matches are meaningful

Keep translations clear and consistent to improve match accuracy

Review suggestions carefully when context differs

Ready to get more out of your translations?

Translation memory in SimpleLocalize is a powerful companion, whether you are building up history automatically or importing your own TM files.

If you're starting a new localization project or want to unify your translation style, consider uploading your existing translation memory. It's one of the easiest ways to accelerate your workflow.

And as always, if you have questions, ideas, or feedback, we are here to help; don't hesitate to contact us anytime!
]]></content:encoded>
            <category>tutorial</category>
            <category>software localization</category>
            <category>translation management</category>
            <category>product updates</category>
            <enclosure url="https://simplelocalize.io/blog/introducing/introducing-translation-memory.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[Introducing: Visual Studio Code extension]]></title>
            <link>https://simplelocalize.io/blog/posts/introducing-vscode-extension</link>
            <guid>https://simplelocalize.io/blog/posts/introducing-vscode-extension</guid>
            <pubDate>Tue, 19 Nov 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[The new SimpleLocalize VS Code extension lets you manage translations directly in the editor. Explore key features and installation instructions.]]></description>
            <content:encoded><![CDATA[We are excited to announce the release of our new Visual Studio Code extension for SimpleLocalize! This extension allows developers to integrate our localization and translation management tools directly into the development workflow.
Designed to simplify the localization process, the extension allows developers to manage translations and collaborate with translators seamlessly within Visual Studio Code

VS Code extension for SimpleLocalize

Key features

The SimpleLocalize VS Code extension comes packed with features that make managing translations directly in your code editor a breeze. Here's what you can do:

Overview of all translations in your project

Edit translations directly in your code

Rename translation keys directly in your code

Create translation keys from text selection

Translation key autocomplete - get suggestions for translation keys

Built-in CLI to synchronize translations with SimpleLocalize

Auto-translation using SimpleLocalize CLI

Key features of VS Code extension

Installation & setup

You can install the extension directly from the Visual Studio Code Marketplace. Simply search for "SimpleLocalize" in the Extensions view and click "Install".
Or use the direct link to install the extension: SimpleLocalize - Visual Studio Code Marketplace

Once the extension is installed, you will need to configure it with your SimpleLocalize personal token.

Open the Welcome page from Help and Feedback section for setup instructions.

You will need to provide your personal token to authenticate the extension with your SimpleLocalize account. You can find your personal token in your SimpleLocalize account settings, in the Security section or by following the direct link to get your token.

Next, select the project you want to work on. Once selected, you can begin using the extension! Watch the step-by-step video guide below to learn how to configure the extension.

Installation of VS Code extension

CLI installation

The extension also includes a built-in CLI that allows you to synchronize translations with SimpleLocalize directly from the command line and use the auto-translation feature.

Follow the instructions in our CLI documentation to install the CLI and start using it with the VS Code extension.

VS Code extension in action

Let's take a look at how the extension works in practice. Here are some examples of how you can use the extension to manage translations directly within your code editor.

Sidebar

The extension adds a new sidebar to your code editor that displays an overview of all translations in your project. You can see and edit all translation keys and their values.

Updating translations from sidebar

All translation changes are automatically synchronized with SimpleLocalize, so you can see the changes in real-time.

On the sidebar, you can also see your project details with the information about the number of translation keys, list of languages, namespaces, customers and translation hosting resources.

Project details in sidebar

In Help and Feedback section you can find additional information about the extension, instructions and useful links.

Code actions

Code actions allow you to perform various actions directly in your code editor. You can:

rename translation keys

create new translation keys from text selection

convert text into a translation key

edit translations

Here you can see an example of creating a new translation key from text selection in your code editor.

Creating translation key from text selection

Explore more video examples and detailed guides on our GitHub repository.

Auto-complete

Get suggestions for translation keys while typing in your code editor. This makes it easier to find the right key and avoid typos or mistakes.

Translation key autocomplete

CLI integration

Thanks to the built-in CLI, you can synchronize translations with SimpleLocalize directly from the command line. This allows you to automate the translation process and keep your translations up-to-date.

Using the CLI, you can:

Download translations from SimpleLocalize to your project

Upload translations from your project to SimpleLocalize

Auto-translate your translations using the SimpleLocalize CLI

Publish translations to SimpleLocalize hosting resources

Pull translations from SimpleLocalize hosting resources

CLI integration

It's open-source!

The SimpleLocalize Visual Studio Code extension is open-source and available on GitHub. You can contribute to the development of the extension, report issues, suggest new features, or simply star the project to show your support.

Here you can find all the resources related to the extension:

SimpleLocalize - Visual Studio Code extension on GitHub

SimpleLocalize - Visual Studio Code extension on Visual Studio Code Marketplace

SimpleLocalize - Visual Studio Code extension documentation

Summary

We hope that the new Visual Studio Code extension will make it easier for developers to manage translations directly within the code editor. The extension offers a range of features that streamline the localization process and help you keep your translations up-to-date.

Try out the new SimpleLocalize Visual Studio Code extension and let us know what you think! We are excited to hear your feedback and suggestions for new features.

If you have any questions or need help with the extension, feel free to reach out to us.
]]></content:encoded>
            <category>tutorial</category>
            <category>software localization</category>
            <category>developer</category>
            <category>product updates</category>
            <enclosure url="https://simplelocalize.io/blog/introducing/visual-studio-code-extension.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[Automatic message extraction with AI]]></title>
            <link>https://simplelocalize.io/blog/posts/automatic-message-extraction-with-ai</link>
            <guid>https://simplelocalize.io/blog/posts/automatic-message-extraction-with-ai</guid>
            <pubDate>Wed, 30 Oct 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Quick message extraction with using npx and OpenAI. Extract messages and auto-create translation keys using AI. Get source translations in seconds from your source code.]]></description>
            <content:encoded><![CDATA[As your project grows, the addition of multi-language support is often postponed, with more code accumulating daily
through new features. Product managers push for translations, but the task of extracting messages from the source code
becomes increasingly time-consuming. How about using AI to simplify this process? 😏

In this article, I’ll introduce a straightforward command-line app written in TypeScript—a concept I considered
ever since first learning about OpenAI. The idea is simple: use AI to batch-process source code and implement something practical.

I finally decided to give it a shot, and I've built a simple CLI that:

scans the source code files one by one in a specified directory,

extracts messages from the source code files,

generates diffs to facilitate multi-language (i18n) support, and

applies these diffs to the source files.

Let’s dive into how it works!

i18n-wizard

i18n-wizard is a lightweight CLI that extracts inline texts and generates relevant translation keys.
It can also “convert” inline strings to translation keys for easy integration with your preferred i18n library.
App available for free via npx. Under the hood, the CLI is using OpenAI to generate diffs,
enabling it to insert libraries, rename variables, or make other adjustments to the source code without the need for a specialized parser.

Automatic message extraction

The CLI’s primary feature is to extract messages from the source code files.
There are many alternatives to extract messages from the source code, but they are usually bound with the specific framework or language.
Using AI makes it vendor-agnostic, so the CLI doesn't have to implement any specific parser and keep it up to date for every language or framework.

Automatic library insertion

Another feature is generating diffs for source files, allowing you to relocate inline strings to your choice of i18n library.
Same as with the message extraction, the CLI is using OpenAI to generate diffs, so it can be used to insert libraries, change variable names, or do any other changes to the source code,
without the need to implement a specific parser for every language or framework.

Though still in its early stages, the app may occasionally generate invalid diffs, so manually review and test a small subset
before running it across your project. Although it's not perfect, it can help you to speed up the process of adding multi-language support to your project.

How to use i18n-wizard

Before running the CLI on your entire project:

test on a small subset of files to see if the diffs are generated correctly,

ensure you have a source code backup since the CLI may alter files unexpectedly,

don't keep any sensitive information in the source code files, as they will be sent to OpenAI.

AI Extracted source messages from source code

Prepare a prompt file

We have to start with telling AI what we want to achieve. CLI is prepared for using custom prompts, so you can adjust it to your needs.
This part is crucial, as the quality of diffs depends on the quality of the prompt.

Create a prompt.txt file; as a starting point you can use the following prompt:

You can be more specific what language or framework you are using, so AI can generate better diffs.
Do not remove the {\__fileContent\_\_} placeholder, as it will be replaced with the actual content of the file during the process. You can also include {\__filePath\_\_} placeholder if you need it.

Prepare CLI command

To start the process, you need to run:

But before we do that, set additional parameters as necessary:

\--prompt - path to the prompt file, by default it's ./prompt.txt,

\--output - path to the output file, by default it's ./extraction.json,

\--openAiKey - OpenAI API key, you can also set it as an environment variable (OPENAI_API_KEY),

\--openAiModel - OpenAI model, default is gpt-4.1,

\--extractMessages - extract messages from the source code, by default it's false,

\--generateDiff - generate a diff file with changes made by the CLI, by default it's false,

\--applyDiff - apply the diff file to the source code, by default it's false.

In the following examples I'm going to show you how to use the CLI with different options.
I've used environment variables to set the OpenAI API key for simplicity.

Running the CLI without any options only shows which files are going to be processed.

Sample TSX file with React component

As an example, I'm going to use a simple React component that contains some text that needs to be translated.
It's a footer component that contains links to help, contact, support, privacy policy, and terms of service pages.

Run only message extraction

To extract messages from the source code, you can use the following command:

CLI resulted with the following output in extraction.json. The output file follows SimpleLocalize JSON format so it can be
imported to SimpleLocalize without any changes.

The quality of messages depends on the prompt file, so you might need to adjust it to get better results, and AI can generate different keys, and message
between runs. In the examples, below I've also used gp-3.5-turbo model, which is faster but might generate less accurate results. However, in my case, it worked very good (even better than GPT-4).

Extracted 26 messages

Run message extraction and diff generation

To extract messages and generate diffs for the source code files, you can use the following command:

Diffs generated by the OpenAI might not be valid, so you will need to review them and fix them manually before applying them to the source code. Otherwise, the CLI will fail to apply them.

Apply diffs to the source code

Once you generate diffs, you can apply them by enabling the --applyDiff option:

If the CLI fail to apply the diff, it will skip the file and move to the next one with printing the error message.
Correctly applied diffs will be automatically deleted, so you can review any issues and run the CLI again.

Conclusions

Using AI to automate message extraction from the source code is a great way to speed up the process of adding multi-language support to your project.
Although the CLI is not perfect, it can help you to move inline strings to the i18n library of your choice, reducing the amount of manual work needed.
Creating a good prompt file is crucial to get better results. Unfortunately in many cases the diffs generated by the AI are not valid,
but adjusting the prompt may still reduce the amount of manual work needed to move inline strings to the i18n library of your choice.
It's a great way to start the localization process in projects that have never been localized before, or in projects that have a lot of text that needs to be translated, but it's not a silver bullet.

i18n-wizard CLI is open-source, so you can review the code and contribute to it if you think you can improve it. I encourage you to try it and let me know what you think about it!

Known issues

OpenAI charges much more for output tokens than for input tokens, so running this CLI on large codebases may become costly.
To optimize that, I decided to ask AI to generate diffs instead of generating the whole file content.
Unfortunately, it generates invalid diff files very often, which prevents the CLI from applying the changes to the source code.

Contributing

Feel free to fork the repository, customize it to your needs, or submit PRs for new features!
If you have any questions or need help, feel free to reach out to me via email.
]]></content:encoded>
            <category>tips</category>
            <category>tutorial</category>
            <category>translation management</category>
            <category>developer</category>
            <category>ai</category>
            <category>ai translation</category>
            <enclosure url="https://simplelocalize.io/blog/automatic-message-extraction-with-ai/automatic-message-extraction-for-software-developers.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[Introducing: Public suggestions]]></title>
            <link>https://simplelocalize.io/blog/posts/introducing-public-suggestions</link>
            <guid>https://simplelocalize.io/blog/posts/introducing-public-suggestions</guid>
            <pubDate>Mon, 28 Oct 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Try out the new public suggestions feature and get feedback from your users. Enable public translations and share your project with the community.]]></description>
            <content:encoded><![CDATA[We are pleased to announce the release of the public translation feature. Public suggestions allow you to easily share your project with the community and receive feedback from your users. This feature is available for all users, including those on the free plan.

How public suggestions work

When you enable public suggestions, a link to your project is generated. You can share this link with your users, who can then submit their suggestions directly from the project page.

You can review and approve the suggestions from your project at SimpleLocalize.
Once you approve a suggestion, it automatically replaces the original translation in your project.

How to enable public suggestions

To enable public suggestions, go to the project settings and select the Public suggestions option.

Public suggestions

Enable the feature by clicking the toggle button. A link to your project will be generated, which you can share with your users.

In public suggestions settings, you can:

add your project logo

customize the project display name

add a welcome message to your users

select the languages for which public suggestions are enabled

Public suggestion settings

Public translations in action

Open the public suggestions link in your browser to see how it works. You can search for a specific translation, browse the list of translations, and filter them by language.

Click on a translation to see the details and submit a suggestion. You can suggest a new translation and optionally add a comment to your suggestion. Once you post your suggestion, it will be visible to the project administrators.

Adding a translation suggestion

In the translation view, you can also see other suggestions, check the translation context (screenshot and description), and see the source translation in the selected language for easier translation.

Notifications

When a user submits a suggestion, you will receive an email and in-app notification with the suggestion details. You can enable notifications for new public suggestions in your user settings to stay up-to-date with the latest feedback.

Email notification

Accepting public suggestions

You can see all the suggestions in the Comments section. Click on the comment icon to view the suggestion details and accept it.

Accepting public suggestions

Once you accept a suggestion, it will automatically replace the original translation in your project.

The suggestion will also be marked as accepted in the public suggestions view.

Accepted public suggestion

Activity

You can see all the activity related to public suggestions in the Activity tab. This includes all the suggestions submitted by users, as well as the comments.

Activity tab

Summary

Enabling public suggestions is a great way to involve your users in the localization process and ensure that your translations are accurate and up-to-date. This new feature is available to all users, and there is no limit to the number of suggestions you can receive.

We hope you enjoy using public suggestions and look forward to hearing your feedback. If you have any questions or need help getting started, please don't hesitate to contact us. We're here to help!
]]></content:encoded>
            <category>tutorial</category>
            <category>software localization</category>
            <category>translation management</category>
            <category>product updates</category>
            <enclosure url="https://simplelocalize.io/blog/public-suggestions.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[Step-by-step localization workflow for&nbsp;developers]]></title>
            <link>https://simplelocalize.io/blog/posts/step-by-step-localization-workflow-for-developers</link>
            <guid>https://simplelocalize.io/blog/posts/step-by-step-localization-workflow-for-developers</guid>
            <pubDate>Thu, 10 Oct 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Step-by-step guide to setting up a localization workflow for developers. Learn how to extract text for translation, manage translations, and integrate them into your app.]]></description>
            <content:encoded><![CDATA[Creating a localization workflow might seem easy, but in reality, it can be quite challenging. Often, software developers tend to over-engineer the process, leading to unnecessary complexity and extra work. The sheer number of tools, options, and settings can be overwhelming, making it easy to get lost in the process.

In this article, I’ll share a step-by-step guide for setting up a localization workflow, focusing on web applications.
However, the same principles can be applied to any software project.
I will also share some tips and best practices I’ve learned over years of working with localization during my time at SimpleLocalize.
You’ll learn the simplest way to synchronize your localization files between a translation editor and your local files. As a bonus, I’ll show you how to automate this process using SimpleLocalize automations.

This article is based on the latest SimpleLocalize CLI version (2.7.0+). If you’re using an older version, some commands may not work. See the CLI releases to update to the latest version.

SimpleLocalize CLI --version output

Source translations as a separate file

One of the most life-changing tips for localization workflows is understanding that exported translation files should be treated as code-generated files and should not be edited manually.
Some developers prefer to keep translations in Excel or CSV files, editing them manually. To accommodate this, we’ve added sorting options to the export function, but why overcomplicate the process?

Localization CLI Workflow

The best approach for configuring a localization workflow is to keep the source translations in a separate file.
It's your decision whether this file will serve as the source of truth or simply a file to push new keys and translations. Keeping it separate offers many benefits:
you can format it as you like, include personal notes, and maintain it in the order that works for you.

Such approach will result in having two files with translations for the same language, but that's perfectly fine!
In my example, I keep the source translations in a file called source.json in single-language-json format with English translations.
Here you can check out the available file formats in SimpleLocalize.

List of files for localization workflow

Uploading source translations

Let’s begin by uploading the source translations to SimpleLocalize.

Here, I specify the path to the source.json file in i18n directory, set the format to single-language-json, and use the language key en-GB for the source file.
The language key is important because it tells the system which language the source file is in, ensuring translations are matched correctly in the editor.

Upload translations

Downloading generated translations

Downloading is simple—you just need to set the download path and specifying the format.
I'll save the translations in the same directory we the source.json file but with different file names that will match the language key from the editor.

I've used {lang} placeholder so the CLI automatically includes the language key in the filename.
You can customize this with any suffix, prefix, or even put the language key as part of the directory structure.
The CLI will handle all these cases, creating directories if necessary.

Download translations

Setting up a configuration file

To make the process easier, you can create a configuration file that will store all your CLI settings, so you don't have to type them out every time.

The API Key can be stored in the configuration file as apiKey property or as an environment variable.
It's best practise to not store API Key in the configuration file, but as an environment variable.

You can override the API Key (or any other parameter) by passing it as a CLI argument.
The order of precedence for the CLI is: Command-line Parameter -> Configuration File -> Environment Variable (API Key only).

Now, your CLI commands can look like this:

Remember, that SimpleLocalize CLI looks for the configuration file in the current working directory. Head to the documentation to learn more about configuration file.

Source file as a source of truth

This approach may not be suitable for every project, but it’s worth mentioning. If you’re a solo developer or the only one responsible for translations, you can treat the source file as the source of truth.

Overwriting existing translations

If you decide to use source.json as the single source of truth, you might want to use the --overwrite parameter during the upload process.
This updates translation texts in the editor with the translations from the source file without deleting any translations not present in the file.

Update existing translations

Deleting translations not present in the source file

If you want to delete translations that are not present in the source file, you can use the --delete parameter.
This will remove any translation keys (along with their translations) that aren’t in the source file.
However, this option can lead to data loss, so it’s generally not recommended. Instead, consider deleting old and unused translation keys through the editor.
Check out our article on how to find and delete unused translation keys.

I’ve deliberately included a typo in the command to avoid accidental execution.

Delete not present translation keys

Automatically accept all source translations

If you want to mark all source translations as accepted, you can use --options MARK_AS_ACCEPTED parameter, which will automatically accept all translations that are uploaded.

Mark all translations as accepted

Automations for localization workflow

One of the great features of SimpleLocalize are no-code automations that you can configure in your project. It's a great
option to speed up the localization workflow and make it more automated, especially if you are working in a small project.

Automations for localization workflow

I've configured one automation that will run every time I change or add new translations via CLI. That means the automation will run every time I upload source.json,
but the automation will run only for changed or added translations. It's a great way to speed up the process of translating new keys.

Auto-translate strings on source translations upload

In the video, you can see how the automation is triggered after uploading the source file with changed translations for ACHIVEMENTS and ACTIVITY.COMMENT_ADD.
The system recognizes the changes and triggers the automation that automatically translates the updated keys into other languages.

It's like magic! ✨ You can write in 5 languages simultaneously without any extra effort beyond uploading a file with source translations. Isn’t that amazing?

Conclusion

In this article, I’ve walked you through setting up a localization workflow for developers.
I’ve shared valuable tips and best practices learned over the years, and as a bonus, I’ve shown you how to automate
the process using SimpleLocalize automations to instantly translate new keys after uploading the source file.
]]></content:encoded>
            <category>tips</category>
            <category>tutorial</category>
            <category>translation management</category>
            <category>developer</category>
            <enclosure url="https://simplelocalize.io/blog/localization-workflow-cli/localization-workflow-for-software-developers.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Namespaces in software localization]]></title>
            <link>https://simplelocalize.io/blog/posts/namespace</link>
            <guid>https://simplelocalize.io/blog/posts/namespace</guid>
            <pubDate>Tue, 08 Oct 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Namespaces are a great way to organize translations in software localization. Learn what namespaces are, why they are important, and how to use them in your localization process.]]></description>
            <content:encoded><![CDATA[Good software localization practices help manage translation files more efficiently, saving both time and resources. One key concept in software localization is the use of namespaces. In this article, we will explain what namespaces are, why they are important in localization, and how to use them in your localization process.

What is a namespace?

A namespace organizes code by grouping related identifiers (such as variables, functions, and classes) under a unique name. This prevents naming conflicts, especially in large projects where different parts of the code may use similar names. As a result, namespaces make code easier to manage and maintain.

Here is an example of a namespace in JavaScript:

In this example, JavaScript objects (LibraryA and LibraryB) serve as namespaces. Both objects contain a function called show, but the functions are distinguished by their respective namespaces, allowing them to coexist without conflict.

Namespaces in software localization

Namespaces are not only useful for organizing code—they also play an important role in software localization. By using namespaces, you can group related translations (e.g., for different modules or components) together, improving the efficiency of loading translations.

For example, you might have namespaces for different sections of your application, such as common, app, dashboard, or settings. This way, when a specific section of the application is loaded, only the translations relevant to that section are loaded, improving the performance of the application.

Loading translations with namespaces

How to use namespaces in software localization?

In localization, namespaces are used to divide translations into different groups based on the module, component, or context they belong to. For instance, in a project with multiple features (e.g., landing page, app, settings), each feature can have its own namespace.

Translations with namespaces

You can define namespaces within your translation files. The format and implementation may vary depending on the file type (JSON, YAML, XML, etc.) and the localization framework you're using.

Namespace file structure

There are two common ways to structure translation files with namespaces:

Single file with namespaces

All translations are stored in a single file, with namespaces used to group translations. For example:

This file structure:

Is easier to manage in smaller projects

Can become unwieldy in larger projects

Loads all translations at once, even if only a subset is needed

May lead to naming conflicts if not carefully managed

Multiple files with namespaces

Translations are stored in separate files, each representing a namespace. For example:

Here, each file represents a namespace (common and app). In this structure, language codes can be used as subdirectories to store translations for different languages:

Or namespaces can be used as subdirectories:

This file structure:

Is more scalable for larger projects

Allows for better organization and management of translations

Makes it easier to load only the necessary translations

Reduces the risk of naming conflicts

Implementing namespaces in different languages and frameworks

Depending on the programming language and framework you're using, namespaces can be implemented in different ways. Here are examples of how to use namespaces in JavaScript, React and Vue.js.

Note: Some localization frameworks may require a specific format for namespace definitions. Be sure to check the documentation for your chosen framework.

Namespace in JavaScript

If you're using JavaScript-based translation files, namespaces can be implemented as follows:

In this example, we have two translation files (landing/en.js and app/en.js) representing different namespaces (landing and app). Each file contains translations for the respective namespace.

To use translations from a specific namespace, you can import the corresponding file and access the translations as needed.

Namespace in React and i18next

In React, using a localization library like react-i18next, you can load translations with namespaces as shown below:

In this example, we are using the useTranslation hook from react-i18next to load translations for the landing namespace.

Namespace in Vue.js and vue-i18n

In Vue.js with vue-i18n, namespaces can be used like this:

In this example, we are using the useI18n function from vue-i18n to load translation for the landing namespace.

Namespace management in SimpleLocalize

If you are using SimpleLocalize for managing translations, you can define namespaces within your translation files. SimpleLocalize supports JSON, YAML, and CSV formats, making it easy to organize translations into namespaces.

When you import translations into SimpleLocalize's translation editor, namespaces are automatically detected based on the structure of your files. You can then manage and edit translations within each namespace, making it easier to work with large projects.

SimpleLocalize namespaces

You can easily filter translations by namespace, export translations for a specific namespace, and manage translations more efficiently using SimpleLocalize's translation editor.

Check the list of supported file formats in SimpleLocalize and import your translations with namespaces.

Benefits of using namespaces in software localization

Using namespaces in localization offers several advantages:

Improved Performance: Only load necessary translations, optimizing resource usage and speeding up your application.

Organized Translations: Group translations logically by module or feature, allowing independent work for different teams or parts of the app.

Avoid conflicts: By using namespaces, you can avoid naming conflicts between different parts of the software.

Scalability: As your app grows, adding new translations becomes more manageable.

Alternatives to namespaces

While namespaces are a powerful tool for organizing translations, they may not be the best solution for every project. Here are some alternatives to consider:

Context-based translations: Instead of using namespaces, you can organize translations based on the context in which they are used. For example, you could group translations by page, component, or feature, making it easier to manage translations within a specific context. This approach resembles the concept of namespaces but is more flexible and context-specific.

Modularization: If your application is too large to manage with namespaces, consider breaking it down into smaller, more manageable modules. Each module can have its own set of translation files, making it easier to manage translations for different parts of the application.

Separate projects: If your application is too complex to manage with namespaces or modularization, consider splitting it into separate projects. Each project can have its own translation files, making it easier to manage translations for different parts of the application.

Conclusion

Namespaces are a powerful concept in software localization, helping you organize and manage translation files more efficiently. By using namespaces, you can streamline your localization process, improve application performance, and avoid naming conflicts, making it easier to manage translations in large, modular applications.
]]></content:encoded>
            <category>tutorial</category>
            <category>software localization</category>
            <category>translation management</category>
            <category>developer</category>
            <enclosure url="https://simplelocalize.io/blog/namespaces.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Introducing: Statistics]]></title>
            <link>https://simplelocalize.io/blog/posts/introducing-statistics</link>
            <guid>https://simplelocalize.io/blog/posts/introducing-statistics</guid>
            <pubDate>Tue, 10 Sep 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Check your project's translation progress with the new statistics feature in SimpleLocalize. Monitor progress, untranslated keys, review status, and team performance.]]></description>
            <content:encoded><![CDATA[We are excited to introduce a new feature in SimpleLocalize: translation statistics. Using this feature, you can monitor translation progress, identify untranslated keys, view review status, and track the performance of your team members and translators.

Effective project management requires visibility into the translation process, and statistics offer a comprehensive overview of your project's status.

User statistics

You can access user statistics by navigating to the People tab in your SimpleLocalize project. Click on View activity of a specific user to see detailed statistics for that user.

Project members

User statistics provide a detailed overview of the user's translation activity, including the number of updated translations, the number of accepted translations, and the total time spent on translations.

This information helps you evaluate the performance of your team members and translators, identify areas for improvement, and optimize your translation process.

User activity

The last 30-day statistics include:

Translation changes: the number of translations added, updated, or deleted by the user.

Accepted reviews: the number of translations accepted by the user.

Assigned languages: the languages assigned to the user.

Total time spent: the total time spent on translations by the user.

You will also find a chart showing the user's activity over time, including translation changes and reviews, and the total time spent on translations. At the bottom of the page, you can see the list of top languages changed or reviewed by the user.

Clicking on the language will redirect you to the language statistics page.

Language statistics

Language statistics provide an overview of the translation progress of all languages or a selected language. You can access language statistics by navigating to the Languages tab in your SimpleLocalize project and clicking the View activity option.

Languages

The View activity option will redirect you to the project languages statistics page, where you can see the following information:

Missing translations: the number of keys that have not been translated.

Needs review: the number of keys that need to be reviewed.

Auto-translated: the percentage of auto-translated keys.

Characters: the total number of characters.

Project language activity

There, you can also find information about:

Top contributors: the users who have contributed the most to the language updates or reviews.

Auto-translation statistics: the number of keys that have been auto-translated with each translation service.

Top languages: the languages missing the most translations or needing the most reviews.

Top languages by characters: the languages with the most characters.

To see specific language statistics, click the translation progress percentage for the language you are interested in or click the language from any other statistics page.
You will be redirected to the language statistics page, where you can see detailed information about the language translation progress.

Language translation statistics

How to use statistics

Statistics provide valuable insights into your translation process. Here are some tips on how to use statistics effectively:

Monitor translation progress: Keep track of the number of missing translations and review status to ensure that your project is up-to-date.

Evaluate team performance: Use user statistics to evaluate the performance of your team members and translators. Identify areas for improvement and optimize your translation process.

Identify bottlenecks: Identify bottlenecks in your translation process by tracking the number of translations modified or reviewed by each user.

Optimize translation workflow: Use statistics to optimize your translation workflow and ensure that your project is completed on time.

Conclusion

We hope you find the new statistics feature useful and that it helps you manage your translation projects more effectively.

Please note that the statistics feature is a beta version, and we are continuously working on improving it. If you need any additional statistics or have any feedback, please let us know — we'd love to hear from you!
]]></content:encoded>
            <category>tutorial</category>
            <category>software localization</category>
            <category>translation management</category>
            <category>product updates</category>
            <enclosure url="https://simplelocalize.io/blog/introducing/statistics.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Introducing: Translation comments]]></title>
            <link>https://simplelocalize.io/blog/posts/introducing-comments</link>
            <guid>https://simplelocalize.io/blog/posts/introducing-comments</guid>
            <pubDate>Fri, 06 Sep 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Communicate with your team members and translators using comments. Learn how to use comments feature in the translation management system.]]></description>
            <content:encoded><![CDATA[We are excited to introduce a new feature in SimpleLocalize: comments. This feature allows you to communicate with your team members and translators directly within the translation management system, making collaboration more efficient.

Effective communication is crucial for successful collaboration, especially when working on translations. With comments, you can ask questions, provide feedback, discuss translation issues, and track the translation process in one place.

How to use comments?

To add a comment to a translation, open your project in SimpleLocalize and navigate to the translation key you wish to comment on. Click the Comment icon in the translation actions to open the comments section.

Comment icon

This will open the comments section, where you can view existing comments and add a new comment for the specific translation key and language.

Comments section

To add a new comment, enter your message in the text field and click the Send comment button. Your comment will appear in the comments section, and other team members and translators will be able to see it.

Add comment

In the comment editor, you can use markdown to format your text, add links, and mention specific team members or translators using the @ symbol. Alternatively, use the text formatting options provided in the editor.

Note: Comments are visible to all team members and translators with access to the translation. If a translator has view-only access, they can see comments but not add new ones.

Notifications

When a comment is added to a translation, all team members and translators with access to the translation will see a new comment icon in the translation editor.

Comment icon

If you mention a team member or translator in a comment using the @ symbol, they will receive an email or in-app notification to ensure they can respond promptly.

Mention notification

Note:  A user mentioned in a comment will see an "unseen comment" icon in the translation editor.

You can enable or disable email and in-app notifications for comments in your profile settings. This allows you to customize how you receive updates about new comments and mentions.

Notification settings

Activity

You can view all added comments in the Activity tab of your project. There, you can filter activities by Comments to see all comments added to the project. You can also filter by User to see comments made by a specific user.

Activity tab

Disable comments

Comments are enabled by default for all projects in SimpleLocalize. To disable comments for a specific project, open translation editor settings and in Quick actions you can disable "Comments" icon.

Disable comments

Use cases for comments

Using comments in the translation management system can help you streamline your translation workflow and improve collaboration with your team members and translators. Here are some use cases for comments:

Ask questions: If you are unsure about a translation or need more context, you can ask questions in the comments section.

Provide feedback: Give feedback on translations, suggest improvements, or point out errors.

Discuss translation issues: Discuss translation issues with your team members and translators to find the best solution.

Track translation progress: Keep track of the translation process by adding comments to translations.

Communicate with translators: Communicate directly with translators to clarify translation issues or provide additional context.

We hope you enjoy using the comments feature in SimpleLocalize and find it helpful for your translation projects. If you have any feedback or suggestions for improving the comments feature, please let us know!
]]></content:encoded>
            <category>tutorial</category>
            <category>software localization</category>
            <category>translation management</category>
            <category>product updates</category>
            <enclosure url="https://simplelocalize.io/blog/introducing/comments.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Introducing: Character limit in translations]]></title>
            <link>https://simplelocalize.io/blog/posts/introducing-character-limit</link>
            <guid>https://simplelocalize.io/blog/posts/introducing-character-limit</guid>
            <pubDate>Thu, 05 Sep 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Set character limits for your translations to simplify localization management. Keep your translations consistent and within the character limit of your UI.]]></description>
            <content:encoded><![CDATA[We are excited to announce the introduction of a character limit feature in translations.

This simple feature will help you keep your translations consistent and within the character limits of your UI.

By setting a character limit for each translation key, you can ensure that the translated text fits perfectly within the designated UI element.

How to set a character limit for a translation key?

Open your project in SimpleLocalize and right-click on the translation key you want to modify. Select the "Manage key" option from the context menu.

Manage key

This will open the translation key settings, where you can manage various aspects of the translation key.

Enable the "Characters limit" option and specify the character limit for the selected translation key.

Character limit

By default, the character limit is set to match the length of the default language translation. However, you can change it to any value you prefer.

Additionally, you can preview the current length of all translations for the translation key.

Character limit preview

You can also set the character limit for multiple translation keys at once during the import process. It is supported in SimpleLocalize JSON, Excel and using SimpleLocalize API.

How to use a character limit in your translations?

When a character limit is set for a translation key, the translation editor will highlight any translations that exceed the specified character limit.

Character limit exceeded

Additionally, it will trigger an issue in QA checks for translations that exceed the character limit.

QA check character limit

Learn more about QA checks in SimpleLocalize.

To view the length of the translations, open the editor settings and enable the "Translation text summary" option.
It will display the length of each translation along with the character limit for the translation key (when exceeded).

Translation text summary

Note: The character limit is not enforced in the translation editor. It is a guideline for the translators to keep the translations within the character limit.

Use cases for character limit in translations

Setting a character limit for translations can be useful in many situations. The main goal is to help translators keep the translations within the character limits of the UI.

Here are some examples of where character limits can be helpful:

Button labels: Keep the button labels short and consistent across the UI.

Titles and headings: Ensure that the titles and headings fit the UI element.

Error messages: Keep the error messages short and clear.

Menu items: Keep the menu items short and consistent.

Form labels: Ensure that the form labels fit the input fields.

Product descriptions: Keep the product descriptions short and consistent.

The character limit feature in translations is a simple yet powerful tool that can make a big difference in your localization management. Try it out and let us know what you think!

Not a SimpleLocalize user yet? Sign up for free and start managing your translations with ease.
]]></content:encoded>
            <category>tutorial</category>
            <category>software localization</category>
            <category>translation management</category>
            <category>product updates</category>
            <enclosure url="https://simplelocalize.io/blog/introducing/characters-limit.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to localize React app using i18next]]></title>
            <link>https://simplelocalize.io/blog/posts/how-to-localize-nextjs-app-i18next</link>
            <guid>https://simplelocalize.io/blog/posts/how-to-localize-nextjs-app-i18next</guid>
            <pubDate>Fri, 30 Aug 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to localize your React app using i18next and react-i18next. This step-by-step guide will show you each step of React app internationalization from scratch.]]></description>
            <content:encoded><![CDATA[React app internationalization (i18n) is a key feature for any app that wants to reach a global audience. In this step-by-step guide, you will learn how to localize your React app from scratch using Next.js and i18next with react-i18next for your app internationalization.

This guide will cover internationalization from the ground up, including:

Creating a new Next.js app

Installing i18next and react-i18next

Configuring i18next

Adding translations using SimpleLocalize

Switching between languages

The goal is to create a localized Next.js app that can be easily translated into multiple languages.

This guide was built by a complete beginner with very basic knowledge of React, so it's a great starting point for anyone who wants to learn how to localize a React app using i18next.

Table of contents

React app internationalization and localization

Internationalization (i18n) adapts your app for different languages and regions, while localization (l10n) focuses on translating content. We will use i18next for i18n and SimpleLocalize for l10n.

React logo

React is a popular JavaScript library for building user interfaces and is widely used for building web apps. It provides a component-based architecture that makes it easy to create reusable UI components.

For React app, we will use Next.js, which is a React framework that provides server-side rendering and other features that make it easier to build React apps.

Next.js logo

React app internationalization can be achieved using one of the many i18n libraries available for React, such as i18next with react-i18next, react-intl, formatjs and more. In this guide, we will use i18next and react-i18next for internationalizing our Next.js app.

i18next and react-i18next

i18next is a popular and flexible JavaScript library for internationalization, supporting multiple languages, language detection, interpolation, and more.

i18next logo

react-i18next is a React-specific extension of i18next. It integrates seamlessly with React through hooks and components, making it easy to add translations to your app.

Key differences:

i18next: A general-purpose i18n library for JavaScript

react-i18next: A React wrapper for i18next with React-specific tools (hooks, HOCs, components) that simplify working with i18next in React.

SimpleLocalize

SimpleLocalize is a translation management and localization platform that helps you manage translations for your app. It provides a web-based customizable translation editor for adding, editing, and organizing translations in multiple languages.

SimpleLocalize translation editor

SimpleLocalize also offers auto-translation features to automatically translate content using Google Translate, DeepL, or OpenAI, and translation hosting for serving translations to your app.

In this guide, we will use SimpleLocalize to add translations to our Next.js app and to host our translation files for easy access.

Setting up a new Next.js app

For this guide, we will create a new Next.js app with the App Router directory, using Tailwind CSS. It will be a simple app with a few pages and components to demonstrate how to localize a Next.js app with i18next.

Tailwind CSS logo

If you already have a Next.js app set up, you can skip this step and go to the next section.

Create a new Next.js app

We will use Next.js automatic installation with create-next-app to create a new Next.js app.

Follow the prompts to set up your new Next.js app. Here are the prompts and answers we will use for this guide:

Start the Next.js app

Once the app is created, open the project directory and start the Next.js app:

This will start the Next.js development server, and you should see the app running at http://localhost:3000.

Add a few pages and components

Next, let's add a few pages and components to our Next.js app. It will be a simple hostel website with a home page, rooms page, and contact page. We will also add header and footer components and other components for the pages.

You can see the structure of the Next.js app below:

Next.js app structure

And the final app will look like this:

Pillow Hostel webpage built with Next.js and Tailwind CSS

Our tips:

Use Tailwind CSS classes for styling

Use Next.js Link component for navigation

Make sure to create a correct folder structure for pages and components

Add language switcher

When localizing a React app, it's important to provide a way for users to switch between languages. Let's add a simple language switcher to the header component of our Next.js app.

For that, let's create two buttons for switching between English and Spanish.

Language switcher

Here is a preview of the language switcher in the app:

Language switcher in the app

In the next steps, we will configure i18next and react-i18next to handle the language switching functionality, or go to the switching between languages section.

For more advanced language switcher, check our guide on how to build a language selector using Tailwind CSS.

Installing i18next and react-i18next

To use i18next and react-i18next in our Next.js app, we need to install the necessary packages. We will also install the i18next-http-backend package to load translations from a JSON file for live-updating translations.

Install dependencies

Install the following packages using npm:

react-i18next: React-specific i18next library

i18next: i18next library

i18next-http-backend: i18next backend for loading translations

i18next-browser-languagedetector: i18next language detector

axios: Promise-based HTTP client for making requests

Configuring i18next

Now, we are ready to configure i18next in our Next.js app. We will set up i18next with the i18next-http-backend and i18next-browser-languagedetector plugins to load translations from a JSON file and detect the user's language.

Create i18n configuration file

Create a new configuration file for i18next called i18n (i18n.ts in our case) in the root of your project and add the following code:

Create translation keys

Next, we need to create translation keys for our app and assign default translations. Translation keys are unique identifiers for each piece of text that needs to be translated. To create them in i18next, we will implement the useTranslation hook in our components.

To create a translation key, we will use the t function from the useTranslation hook. Here is an example of how to create a translation key for the header component:

Creating translation keys with useTranslation hook

The default scheme for key creation is:

import { useTranslation } from 'react-i18next';

add const { t } = useTranslation(); to the component

use t("translationKey") to create a translation key

add defaultValue to the t function to set the default translation

Syntax for creating translation keys using t function:

Other ways to create translation keys in i18next are also available:

using withTranslation HOC

using Translation (render prop)

using Trans component

Once the translation keys are created, we can add translations to our app using SimpleLocalize.

Create JSON file with translations

As we are using SimpleLocalize for translation management and hosting, there is no need to create a JSON file manually. We will push translations to SimpleLocalize and get them back in real-time. Head to the next section to learn how to configure SimpleLocalize with i18next.

If you prefer to manage JSON files manually, we need to create a JSON file with translations for each language. The JSON file should contain translation keys and their translations for each language. Here is an example of a JSON file with translations for English:

Save the JSON file with translations in the public/locales directory of your Next.js app.

JSON file with translations in the public/locales directory

Next, head to the language switcher section to learn how to switch between languages in your Next.js app.

Configuring SimpleLocalize

SimpleLocalize will be the hub for managing translations for our Next.js app. We will use SimpleLocalize to add, edit, and organize translations. With live updating, we can see the changes in our app in real-time.

First, create an account in SimpleLocalize and create a new project for your Next.js app.

SimpleLocalize project creation

Next, we need to configure i18next to push translations to SimpleLocalize. We will use the i18next-http-backend plugin to load translations from a JSON file, push them to SimpleLocalize and get the translations back.

i18n configuration

To push translations to SimpleLocalize and get them back to our app, we need to configure i18next to use the SimpleLocalize API. We will use the i18next-http-backend plugin to load translations from a JSON file and push them to SimpleLocalize.

Thanks to this configuration, we can save missing translations to SimpleLocalize and get them back in real-time.

This code:

sets up the SimpleLocalize API configuration with your project token and API key

creates functions to create translation keys and update translations in SimpleLocalize

sets up a saveMissing function to save missing translations to SimpleLocalize

sets up an interval to call saveMissing every 30 seconds

configures i18next to use the SimpleLocalize API for loading translations and saving missing translations

Note:

You can get your project token and API key from the SimpleLocalize Integrations page

Push missing translations to SimpleLocalize only in development mode

The code above doesn't include namespace management. If you use namespaces, follow the instructions in the Namespaces section

Upload translations

Uploading translations to SimpleLocalize is automatic with the configuration above. When a translation key is missing in the app, it will be saved to SimpleLocalize, and then you can add translations in the SimpleLocalize editor.

Uploading translations to SimpleLocalize project

You may need to open all pages to push all missing translations.

Translate content

Now that the translations are in SimpleLocalize, you can start translating the content.

Create languages. Go to the Languages tab and add the languages you want to translate your app into.

Translate content. Go to the Translations tab and start translating the content for each language in the translation editor.

There are several ways to translate content in SimpleLocalize:

Manual translation: Add translations manually in the translation editor

Machine translation: Use the built-in auto-translation feature to automatically translate content using Google Translate, DeepL, or OpenAI

Import translations: Import translations from a CSV, JSON file, or other formats

Adding languages and auto-translation using Google Translate

Switching between languages

Now that we have set up i18next and SimpleLocalize, we can switch between languages in our Next.js app. Open your language switcher component and insert the i18n.changeLanguage function to switch between languages.

Here is my language switcher component:

Now you can switch between languages in your Next.js app. On the language switch, the app will automatically load the translations for the selected language from SimpleLocalize and update the content in real-time.

Switching between languages in the app

Use cases

Translations can be used in various ways in your Next.js app. Besides the basic translation of text content, your translations can include namespaces, variables, plurals, and other features. See below how to use them in your Next.js app.

Using namespaces

Namespaces are a way to organize translations in i18next. They allow you to group translations by a specific category or section of your app. To use namespaces in your translations, you can define them in the i18next configuration and use them in your translation keys.

For namespaces to work, you need to define them in the i18n configuration file. Here is a complete configuration file to support namespaces:

Next, you need to define namespaces in your Next.js app. You can do that by adding i18n configuration to the useTranslation hook in your components and passing the namespace as an argument.

Here is an example of how to use namespaces in your Next.js app:

The defined namespace in the useTranslation hook will be used to group translations in the SimpleLocalize editor, e.g., for our rooms page.

Namespaces in SimpleLocalize

Notes:

If there is no namespace defined, i18next will use the default namespace translation.

It makes sense to use namespaces when you have a large number of translations or when you want to group translations by a specific category or section of your app.

Add namespaces to all components that use translations.

Using variables (interpolation)

You can use variables in your translations by passing them as objects to the t function. In my example, I want to display current room availability as a variable:

First, we need to create a translation key for the availability text with variable. Before adding the defaultValue (default translation), we need to pass the variable so it can be used in the translation:

This way, we use the t function to display the availability text with the variable availableRoomsDorm.

Syntax for i18next interpolation:

Using plurals

i18next supports plurals for languages that have different forms for singular and plural. To use plurals in your translations, you can pass a count variable to the t function.

Here you can see an example of how to use plurals in your translations with i18next:

The count variable is used to determine the plural form of the translation. In the example above, we use the count variable to display the correct plural form of the availability text based on the number of available rooms.

i18Next will automatically select the correct plural form based on the count variable, and it will create the translation key for each plural form.

Plural translation keys in i18next

Syntax for i18next plurals:

i18next alternatives

i18next with react-i18next is a popular choice for internationalizing React apps, but there are other libraries available that you can use for internationalization. Here are some alternatives to i18next:

formatjs with react-intl: A powerful i18n library for React applications.

next-translate: A Next.js library for internationalization.

next-i18next: A Next.js library based on i18next for internationalization.

LinguiJS: A modern internationalization library for React and other frameworks.

Each of these libraries has its own features and benefits, so you can choose the one that best fits your needs.

Conclusion

In this guide, we have learned how to localize a Next.js app from scratch using i18next and react-i18next. We have set up i18next with the i18next-http-backend plugin to load translations from a JSON file and detect the user's language. We have also configured SimpleLocalize to manage translations for our app and push missing translations to SimpleLocalize. Finally, we have added a language switcher to switch between languages in our Next.js app.

By following this guide, you should now have a fully localized Next.js app with i18next and react-i18next. You can use the techniques and best practices learned in this guide to internationalize your React apps and reach a global audience.
]]></content:encoded>
            <category>tutorial</category>
            <category>translation management</category>
            <category>developer</category>
            <category>react</category>
            <category>nextjs</category>
            <category>i18next</category>
            <category>react-i18next</category>
            <enclosure url="https://simplelocalize.io/blog/i18n/localize-react-app-i18next.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to translate a webpage:<br/>User and Developer Guide]]></title>
            <link>https://simplelocalize.io/blog/posts/how-to-translate-webpage</link>
            <guid>https://simplelocalize.io/blog/posts/how-to-translate-webpage</guid>
            <pubDate>Thu, 22 Aug 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn to translate webpages: user tips (browser tools, services, extensions) and developer strategies (multilingual content, translation software).]]></description>
            <content:encoded><![CDATA[Any web page can be viewed in multiple languages. The translation can also be done by the developer, who can provide a translated version of the page for the user to view in their preferred language. On the other hand, the page can be translated by the user, who can then view the page in their preferred language using a browser extension or a translation service. This article will guide you through the process of translating a webpage, both from a user and a developer perspective.

Why webpage translation is important

The translation of a webpage is important because it offers various benefits to both the user and the developer.

Developer and user webpage translations

For the user, it allows them to view the page in their preferred language, which can help them better understand the content and navigate the page. A localized webpage feels more familiar and trustworthy to the user, which can improve their overall experience.

For the owner or developer, offering a webpage in different languages can help with:

expanding the reach of the page to a global audience

improving the user experience

increasing the page's visibility and rankings in search engines

building trust with the users

Providing accessible and inclusive content, thanks to translation and localization, can help the page to be more successful and reach a wider audience. It demonstrates that the provider cares about the user experience and is willing to go the extra mile to make the page accessible to everyone.

How to translate a webpage as a user

From the user's perspective, there are several ways to translate a webpage into a different language when the webpage itself doesn't offer a translation option to the desired language. Here are some of the most common methods:

User webpage translations

Using a built-in browser translation

Most modern browsers offer a built-in translation feature that can translate a webpage into the user's preferred language. Below, you can learn how to use the built-in translation feature in some of the most popular browsers:

How to translate a webpage in Google Chrome

Google Chrome uses Google Translate to automatically detect the language of a webpage and offer to translate it to your preferred language.

Click on the Translate button in the address bar to translate the page to the selected language.

Translation using Google Chrome

The translation result looks good; the text is readable and makes sense. However, the translation may not be perfect, especially for pages with a lot of text or complex content.

Note:

You can change the languages used for translation in Chrome settings.

Right-click on the page and select "Translate to \[Language]" to translate the page to your main language.

Right-click on a specific text on the page and select "Translate Selection" to translate the selected text.

How to translate a webpage in Safari

When Safari detects that a webpage is in a language different from your preferred language, it will display the Translate button in the address bar to translate the page into your preferred language.

Hit the button to translate the page to one of the preferred languages to view the translated page.

Translation using Safari

The translation isn't perfect, and it may be difficult to read when the page contains a lot of text, but it can help you understand the content of the page better.

Learn more about Safari translation options and settings.

Note:

You can change the languages used for translation in Safari in Language & Region preferences.

If you are looking to translate a specific text on the page, you can select the text and right-click to translate it using the browser's built-in translation feature.

Translate selected text in Safari

How to translate a webpage in Mozilla Firefox

Mozilla Firefox uses the Firefox translation service to provide a translation of a webpage into the user's preferred language. It also detects the language of the page and offers to translate it to your preferred language if the translation is available.

To translate a webpage in Firefox, open the page and click on the menu button in the top-right corner of the browser window. Select the Translate page from the menu to translate the page to the selected language. Choose the target language from the list of available languages and hit Translate.

Translation using Firefox

Note:

You can change the languages and translation preferences in Firefox settings.

To translate a specific text on the page, you can select the text and right-click to translate it using the "Translate Selection" option.

Some languages may not be supported yet by the Firefox translation service.

Firefox translation feature won't translate non-text elements such as images, videos, or interactive elements

Learn more about Firefox translation service.

How to translate a webpage in Microsoft Edge

Microsoft Edge uses Microsoft Translator to provide a translation of a webpage into the user's preferred language. When Edge detects that a webpage is in a different language from your preferred language, it will display the Translate option in the address bar to translate the page into your preferred language.

To translate a webpage in Microsoft Edge, click on the Translate button in the address bar and select the target language from the list of available languages. Hit Translate to view the translated page.

Translation using Microsoft Edge

Notes:

You can change the languages used for translation in Edge settings.

To translate a specific text on the page, you can select the text and right-click to translate it using the browser's built-in translation feature.

Using online translation service

Online translation services like Google Translate, DeepL, or Microsoft Translator can help you translate a webpage into your preferred language.

How to translate a webpage using Google Translate

Google Translate is a popular online translation service that can help you translate a webpage into your preferred language. To translate a webpage using Google Translate, follow these steps:

Open Google Translate in your browser.

Switch to the Websites tab.

Enter the URL of the webpage you want to translate in the box.

Select the source language of the webpage and the target language you want to translate it into.

Hit Translate to view the translated page.

Translation using Google Translate

How to translate a webpage using DeepL

DeepL is a translation service known for its high-quality translations. To translate a webpage using DeepL, you need to install the DeepL browser extension first and sign up for a DeepL Pro account.

The DeepL browser extension is available for Google Chrome, Firefox, and Microsoft Edge.

DeepL browser extension

Full-page translation is available for DeepL Pro users, but you can still translate the selected text on the page for free. For that, select the text you want to translate, right-click, and choose Translate with DeepL.

Manual translation

Manual translation involves copying the text from the webpage and pasting it into an online translation tool like Google Translate, DeepL, or even a dictionary. This method is time-consuming and may not be suitable for translating long texts or entire webpages, but it can be useful for translating specific words or phrases.

Manual translation

For manual translation, you can use online dictionaries like:

Linguee

WordReference

Reverso

Bab.la

Or online translation tools like:

Google Translate

DeepL

Microsoft Translator

Translation on mobile devices

We are using mobile devices more and more to browse the web, so it's important to know how to translate a webpage on your smartphone or tablet. Here are some of the most popular translation apps for mobile devices:

Google Translate (iOS, Android)

DeepL (iOS, Android)

Microsoft Translator (iOS, Android)

These apps allow you to translate text, text from images, and even conversations in real-time using your smartphone's camera or microphone.

Mobile translations

For website translation on mobile devices, you can use the built-in translation feature of your mobile browser or install a browser extension like DeepL or Google Translate.

How to translate a webpage on mobile - Safari

To translate a webpage in Safari on your iPhone or iPad, you can use the built-in translation feature of the browser. Follow these steps to translate a webpage in Safari:

Open the webpage you want to translate in Safari.

Tap on the aA icon in the address bar.

Select Translate Website... from the menu.

Choose the target language from the list of available languages.

Then, Safari will translate the page into the selected language. It's a quick and easy way to translate a webpage on your mobile device.

Translation using Safari on mobile

How to translate a webpage on mobile - Google Chrome

When you open a webpage in Google Chrome on your mobile device in a language different from your preferred language, Chrome will offer to translate the page to your preferred language. Tap on the Translate button to view the translated page.

Translation using Google Chrome on mobile

In case the popup doesn't appear, you can manually translate the page by tapping on the three dots in the top-right corner of the browser window and selecting Translate from the menu, or click on the Translate icon in the address bar.

How to translate a webpage on mobile - Firefox

Currently, Firefox for mobile offers a built-in translation feature only on Android devices.

To translate a webpage in Firefox on your Android device, follow these steps:

Open the webpage you want to translate in Firefox.

Tap on the translation icon in the address bar, or select Translate page from the menu.

Choose the source and target language from the list of available languages.

When you click Translate, Firefox will translate the page into the selected language.

Browser extensions for webpage translation

Browser extensions can help you translate webpages more efficiently and provide additional features like full-page translation, text-to-speech, or custom dictionaries. Here are some of the most popular browser extensions for webpage translation:

Google Translate - available for Chrome

Mate Translate - available for Chrome, Firefox, and Edge

DeepL - available for Chrome, Firefox, and Edge

ImTranslator - available for Chrome and Firefox

Lingvanex - available for Chrome, Firefox and Edge

TWP - Translate Web Pages - available for Firefox and other browsers with manual installation

To Google Translate - available for Firefox

Hola Translator - available for Safari and Chrome

How to translate a webpage as a developer

As the developer or product owner of a webpage, you can provide a translated version of the page for the user to view in their preferred language. This approach allows you to control the quality of the translation and ensure that the content is accurately translated.

Make your webpage multilingual

The very first step to translate a webpage is to make it multilingual. This means providing a translated version of the page for each language you want to support.

Here is how you can make your webpage multilingual in a few steps:

Choose a localization library or framework

There are many libraries and frameworks available that can help you translate your webpage into multiple languages. Those libraries provide tools and utilities to manage translations, switch between languages, and format the translated content.

Some of the most popular i18n libraries include:

i18next

react-intl

vue-i18n

react-i18next

next-translate

polyglot.js

gettext

LinguiJS

Globalize

Check out our article with a list of i18n libraries for React, React Native and NextJS.

Implement internationalization in the source code

Once you have chosen a library or framework for internationalizing your webpage, you can add i18n support to your source code. This usually involves creating translation files for each language you want to support and adding the necessary code to load and display the translated content.

After installing the library, start by replacing the hard-coded text in your webpage with the translation keys.

i18n implementation

Then, create translation files for each language you want to support and add the translated content to those files. Below, you can see an example of translation files in JSON format for English and Spanish:

When implementing i18n in your source code, make sure to follow the documentation of the library you are using to implement internationalization correctly.

Translate the content

Provide a translated version of the page for each language you want to support. This includes translating the text, images, and other content on the page.

You can add translations directly to the source code by editing JSON files, or use a translation management system to manage translations more efficiently. Translation management systems like SimpleLocalize allow you to store and manage translations in a central location, making it easier to update and maintain translations across multiple languages.

Translating the webpage content using SimpleLocalize

When translating the content, make sure to:

Translate all text on the page, including headings, paragraphs, buttons, and links.

Ensure the quality of the translation.

Localize the content to make it culturally relevant and appropriate for the target audience.

Test the translations to ensure that they are accurate and display correctly on the page.

Update the translations regularly to keep the content up to date and relevant.

Build a language switcher

To allow users to switch between languages on your webpage, you can add a language switcher to the page. The language switcher can be a dropdown menu, a list of flags, or any other element that allows users to select their preferred language.

When the user selects a language, the webpage should reload with the content translated into the selected language. You can use the library or framework you chose for internationalization to handle the language switching and display the translated content.

Language switcher

Check out our article on how to build a language switcher with Tailwind CSS and some examples of language switchers.

Another option is to detect the user's preferred language automatically and display the webpage in that language by default. You can use the browser's language settings or IP geolocation to determine the user's preferred language and display the webpage in that language. However, it's always a good idea to provide users with the option to switch between languages manually.

Use translation management software

At this point, you may be wondering how to manage translations efficiently and keep them up to date. Translation management software can help you with that.

Translation management software like SimpleLocalize allows you to store and manage translations in a central location, making the localization process more efficient and scalable.

With SimpleLocalize, you can:

Store all translations in one place

Manage translations for multiple languages in a simple and intuitive translation editor

Collaborate with translators and reviewers

Translate content automatically using DeepL, Google Translate or OpenAI

Automate the translation process

Control the quality of translations

Update translations easily

Host translations on a CDN for faster loading times

Instead of editing translation files manually, you can use translation management software to manage translations more efficiently and keep them up to date. This can save you time and effort and ensure that the translations are accurate and consistent across all languages.

Translation management software and editor

Let your users translate your webpage for you

Another option is to let your users translate your webpage for you. This approach is known as user-generated translation and involves allowing users to contribute translations to your webpage. It can be a cost-effective way to translate your webpage into multiple languages and engage users in the localization process. How to do that?

User-generated translations

Share a link to the translation editor with your users and ask them to contribute translations. You can provide incentives like discounts, rewards, or recognition to encourage users to contribute translations.

In SimpleLocalize, you can easily share access to your project with users and allow them to contribute translations. Depending on the permissions you grant them, users can add, edit, or review translations in the translation editor for your project.

Learn more about different ways to share your project in SimpleLocalize.

Conclusion

Translating a webpage can be done from both the user and developer perspectives. As a user, you can use built-in browser translation features, online translation services, manual translation, or browser extensions to translate a webpage into your preferred language. As a developer, you can make your webpage multilingual, provide translated content for each language you want to support, and use translation management software to manage translations efficiently.

By translating your webpage into multiple languages, you can expand its reach, improve the user experience, and build trust with users. Providing accessible and inclusive content can help your webpage be more successful and reach a wider audience. Whether you are a user or a developer, translating a webpage can help you better understand the content and navigate the page in your preferred language.
]]></content:encoded>
            <category>tutorial</category>
            <category>translation management</category>
            <category>developer</category>
            <enclosure url="https://simplelocalize.io/blog/translate-webpage.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Translation editor:<br/>How to translate Markdown files]]></title>
            <link>https://simplelocalize.io/blog/posts/markdown-translation-editor</link>
            <guid>https://simplelocalize.io/blog/posts/markdown-translation-editor</guid>
            <pubDate>Mon, 12 Aug 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to translate and auto-translate Markdown files using SimpleLocalize's Text Editor feature in the Translation Editor.]]></description>
            <content:encoded><![CDATA[Translating Markdown files is a common task for translators and localization managers. Having a good Markdown translation editor can make the process easier and more efficient. In this article, we will learn more about this file format and how to translate Markdown and other larger text files using SimpleLocalize's Text Editor feature.

What is a markdown file?

Markdown is a popular markup language used to format text files. It is commonly used for writing documentation, blog posts, and other types of content, as it makes it easy to create well-formatted and readable text files.

Markdown files are plain text files with a .md extension that contain text and formatting instructions.

Here is an example of a markdown file:

Which displays as:

Markdown sample preview

Markdown formatting

Formatted text in markdown files is created using special characters and symbols. Here are some common formatting options:

Headers: # Header 1, ## Header 2, ### Header 3, etc.

Lists: - Item 1, - Item 2, etc.

Bold text: \*\*bold text\*\*

Italic text: \*italic text\*

Link: \[Link]\(https://simplelocalize.io/)

Image: !\[Image]\(http://localhost:3000/assets/simplelocalize-logo-dark.svg)

Code block: \`code block\`

Inline code: inline code

Blockquotes: > Blockquote

For a complete list of Markdown formatting options, you can refer to the Markdown Guide.

How to translate markdown files?

Translating Markdown or larger text files can be a time-consuming and error-prone process, especially if you are working with multiple files or languages. You need to ensure that the formatting is preserved, and that the translations are accurate and consistent across all files.

Using a translation editor can help you streamline the translation process and ensure the accuracy and consistency of your translations.

Set up your project in SimpleLocalize

SimpleLocalize is a translation management platform that offers a Text Editor feature for translating Markdown and other text files. To get started, sign up to create your account, and create your project. E.g., my project is called "Blog posts" for all my blog posts that I want to translate.

New project in SimpleLocalize

Add languages

Once your project is created, head to the Languages tab and add the languages you want to translate your markdown files into. For example, I would like to translate my blog posts into Polish and Spanish.

Languages list

Learn more about adding languages in SimpleLocalize.

Upload your markdown file

In the SimpleLocalize translation editor, one Markdown file is one translation key.

You can add your markdown file to the translation editor by clicking on the Create translation keys button. There, add the translation key, so the identifier for the markdown file, e.g., the file name. Click on the "Create" button to add the translation key.

Create translation keys

The key will be added to the translation editor.

Now, let's set the editor type to Markdown. Right-click on the key and select Manage key. There, change the editor type from regular text to Markdown.

Changing editor to Markdown in Manage key

Once you have set the editor type to Markdown, you can open the editor by clicking on the text field with the Open in Text Editor option and paste the content of your markdown file.

Opening Markdown in Text Editor

Translate the markdown file

Your markdown file is now ready for translation. Open the Text Editor and start translating the content of the file. You can adjust the editor, e.g., by putting the source text on the left and the target text on the right, to make the translation process easier.

Markdown text editor

Here are some tips for translating markdown files:

Preserve formatting: Make sure to preserve the formatting of the original file, such as headers, lists, bold and italic text, links, and images.

Show line numbers: If you are working with a large file, you can enable line numbers in the editor options to keep track of the content.

Use placeholders: If the markdown file contains placeholders, such as variables or dynamic content, make sure to keep them in the translation.

Check links and images: Verify that all links and images in the file are correct and working in the translated version.

Auto-translation of Markdown files

For faster translation of markdown files, you can use the auto-translation feature in SimpleLocalize. This feature allows you to automatically translate the content of the file using machine translation services such as Google Translate, DeepL, or OpenAI.

To auto-translate a markdown file, click on the Auto-translate button in the Translation Editor in the language you want to translate the file into. The content of the file will be automatically translated, and you can review and edit the translation in the text editor.

Auto-translating text in Markdown

Auto-translation is a great starting point for translating large files, as it can help you save time and effort. However, when using auto-translation, make sure to review the translated content carefully to ensure its accuracy, quality, and formatting.

Conclusion

Translating Markdown files can be a complex and time-consuming process, especially when working with larger files or multiple languages. Using a translation editor like SimpleLocalize's Text Editor can help you streamline the translation process and ensure the accuracy and consistency of your translations. Keeping all your translations in one place and using features like auto-translation can help you save time and effort and deliver high-quality translations for your content.
]]></content:encoded>
            <category>tutorial</category>
            <category>software localization</category>
            <category>translation management</category>
            <category>markdown</category>
            <enclosure url="https://simplelocalize.io/blog/markdown/markdown-translation.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Simple AI-powered app localization with ChatGPT]]></title>
            <link>https://simplelocalize.io/blog/posts/ai-translations-chatgpt</link>
            <guid>https://simplelocalize.io/blog/posts/ai-translations-chatgpt</guid>
            <pubDate>Tue, 23 Jul 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Auto-translate your app with ChatGPT and SimpleLocalize to automate the localization process. A step by step guide on how to integrate ChatGPT with SimpleLocalize.]]></description>
            <content:encoded><![CDATA[App or website localization is a crucial step in the internationalization process, as it ensures that the software is accessible and usable by users from different regions and cultures. However, the traditional localization process can be time-consuming and expensive. Today, there are many tools and technologies available, like SimpleLocalize TMS or AI translation providers (ChatGPT by OpenAI), that can help you simplify and automate the localization process, making it faster and more cost-effective.

In this blog post, we will explore how you can simplify your app localization using SimpleLocalize and ChatGPT, powered by OpenAI.

SimpleLocalize and ChatGPT integration

ChatGPT is a powerful language model developed by OpenAI that can generate high-quality translations of text. It is trained on a large dataset of text from the internet, which allows it to generate translations that are accurate and natural-sounding.

OpenAI logo

SimpleLocalize is a translation management system that allows you to manage all your translations in one place. It provides a user-friendly interface for managing translations, as well as features like automations, translation hosting, reviews, and sharing translations with your team.

By integrating ChatGPT with your SimpleLocalize account, you can automate the translation process and generate high-quality translations of your software content in a matter of seconds. This can help you save time and money, as well as ensure that your software is accessible to users from different regions and cultures.

How to integrate ChatGPT with SimpleLocalize

Integrating ChatGPT with SimpleLocalize is a simple process that can be done in a few easy steps. It gives you access to a simple and quick way to translate your software content with the power of AI.
See below how you can do it.

Sign up for a SimpleLocalize account and create your project

Start by signing up for a SimpleLocalize account and create a new project for your app localization.

Then, there are only two steps to get started with SimpleLocalize before you can start using ChatGPT for translations:

First, import your existing translations so that you can manage them in SimpleLocalize

Add languages that you want to translate your software into

With these steps done, you will be able to see all your translations in one place and manage them easily. The project will be ready for ChatGPT auto-translation.

SimpleLocalize translation editor view

Watch this video to learn how to get started with SimpleLocalize: Getting started with SimpleLocalize

Sign up for an OpenAI account and get an API key

To use ChatGPT for translations, you need to sign up for an OpenAI account and get an API key. You can sign up for an account on the OpenAI platform website.

To get your API key, login to the platform, go to the API keys section and generate a new API key from your account dashboard.

OpenAI API key generation

Configure the ChatGPT integration in SimpleLocalize

Go to the project Settings and to the Auto-translation tab in your SimpleLocalize. Select OpenAI from the providers list.

SimpleLocalize auto-translation provider settings

Then, provide your OpenAI API key and select the GPT model version you want to use (e.g., GPT-3.5, GPT-4). You can also add a system prompt to provide context for the translations (optional).

SimpleLocalize OpenAI integration settings

Save the configuration, and now you are ready to translate using ChatGPT in SimpleLocalize!

Translate your app with ChatGPT

Now that you have set up the ChatGPT integration in SimpleLocalize, you can start translating your software content using the power of AI. Here are a few ways you can do it:

Auto-translate all languages: Head to the Languages tab, select the language you want to translate, and click the Auto-translate all keys button.

Auto-translate all languages

Here, you can also auto-translate all translations into only selected languages.

Auto-translate individual keys: In the Translation tab, where you can view and edit your translations, you can also auto-translate individual keys by clicking the Auto-translate button next to the key you want to translate.

Auto-translate individual keys

Or, you can auto-translate only selected translation keys with OpenAI using Bulk Actions.

Auto-translate selected keys

Benefits of using ChatGPT for app localization

Integrating ChatGPT with SimpleLocalize is a simple solution that can help you simplify and automate the software localization process. When used together with other features of SimpleLocalize, like automations, the localization of your software can become a breeze.

Here are some of the benefits of using ChatGPT for app localization:

Speed: ChatGPT can generate translations in a matter of seconds, allowing you to localize your software content quickly.

Cost-effective: Using ChatGPT for translations can help you save money on localization costs.

Quality: ChatGPT generates high-quality translations that are accurate and natural-sounding.

Automation: By integrating ChatGPT with SimpleLocalize, you can automate the translation process and save time on manual translations.

Accessibility: ChatGPT can help you make your software accessible to users from different regions and cultures.

If you would like to learn more about how you can simplify your app localization with SimpleLocalize and ChatGPT, have a look at our blog posts and resources below:

More about AI-powered and generative AI translations

Comparison of OpenAI, Google Translate, and DeepL translations

Auto-translation cost calculator
]]></content:encoded>
            <category>auto translation</category>
            <category>translation management</category>
            <category>openai</category>
            <category>chatgpt</category>
            <category>ai translation</category>
            <enclosure url="https://simplelocalize.io/blog/chatgpt-localization.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[AI-Powered Translations. A&nbsp;Comprehensive Guide]]></title>
            <link>https://simplelocalize.io/blog/posts/ai-translations</link>
            <guid>https://simplelocalize.io/blog/posts/ai-translations</guid>
            <pubDate>Mon, 22 Jul 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[AI translations are revolutionizing the language services industry. Learn how AI translation works, its types, and how it can be used in software localization.]]></description>
            <content:encoded><![CDATA[Translation services have been around for a long time, but with the growth of artificial intelligence, the field of translation has been revolutionized. AI-powered translations are a fast and efficient way to translate text from one language to another, and they are being used in a wide range of applications, including software localization and content translation.

In this guide, we will explore the world of AI-powered translations, how they work, and how they can be used in software localization.

What is AI translation?

AI translation is a technology-driven approach to translating text from one language to another using artificial intelligence. Unlike traditional translation methods that rely heavily on human translators, AI translation makes use of machine learning algorithms and neural networks to deliver translations that are both rapid and accurate.

How does AI translation work?

AI translation works by using machine learning algorithms to analyze and understand the text that needs to be translated. These algorithms analyze the structure, context, and meaning of the text and then generate a translation that aims to be both accurate and natural-sounding. This process involves several stages, including:

Text preprocessing: The text is cleaned and prepared for translation, removing any unnecessary characters or formatting.

Language detection: The algorithm identifies the language of the text that needs to be translated.

Analysis: The AI system breaks down the text into its grammatical and syntactical components, understanding the context and nuances.

Translation generation: Based on the analysis, the system generates a translation, often using vast databases of bilingual text corpora to enhance accuracy.

Post-processing: The translation is refined and polished to ensure that it is accurate and natural-sounding in the target language.

AI robotic arm

Types of AI translation

AI translation can be broadly categorized into several types based on the underlying technology and approach:

Rule-based machine translation (RBMT): a traditional approach that uses predefined rules and linguistic patterns to generate translations. While it can be accurate for simple sentences and specific language pairs, it struggles with complex text or idiomatic expressions.

RBMT was originally used by early translation software like SYSTRAN.

Statistical machine translation (SMT): uses statistical models to generate translations based on large bilingual text data. It learns translation patterns from data, improving over time with more data. It can struggle with rare or unseen words, producing unnatural or incoherent translations.

Google Translate and Microsoft Translator used SMT in early versions but have since transitioned to neural machine translation.

Example-based machine translation (EBMT): relies on a database of pre-translated sentence pairs and finds the best match for new translations. It is effective for translating phrases or sentences that have been seen before but can struggle with new or unseen text.

Neural machine translation (NMT): uses artificial neural networks to create more fluent and contextually appropriate translations. It is capable of understanding the nuances of language better than RBMT and SMT, making it the most advanced and widely used method today.

It is currently used by Google Translate, DeepL, and other leading translation services.

Hybrid machine translation: combines the strengths of different methods to improve translation quality. For example, it may use RBMT for grammar and syntax and NMT for context and fluency.

It is used by some translation services, like SDL Trados, to achieve better results than using a single method.

What is generative AI translation

Generative AI translation is a type of AI that uses generative models to make translations. Unlike traditional AI translation models that rely solely on pre-existing text corpora, generative AI models, such as those based on transformers (e.g., GPT-4), can generate text that is not only accurate but also contextually appropriate and creative.

These models are trained on vast amounts of data and can produce translations that are more nuanced and sophisticated, capable of handling idiomatic expressions, cultural references, and complex sentence structures.

OpenAI logo

Machine translation vs Generative AI translation

Machine translation (MT) and generative AI translation both serve the purpose of translating text using artificial intelligence, but they differ significantly in their methodologies, capabilities, and outputs. Here's a detailed look at the key differences:

Technological basis: Machine translation relies on statistical models (SMT), rule-based systems (RBMT), or neural networks (NMT) to generate translations. Generative AI translation uses advanced generative models like transformers (e.g., GPT-4) to produce translations.

Approach to translation: Machine translation focuses on translating text from one language to another, aiming for accuracy and fluency based on pre-existing text corpora. Generative AI translation goes beyond translation to generate text that is contextually appropriate, creative, and nuanced, producing more natural and human-like results.

Quality and accuracy: Machine translation can produce accurate translations for common phrases and sentences but may struggle with idiomatic expressions, cultural references, or complex text. Generative AI translation can handle these nuances and deliver translations that closely resemble human language proficiency.

Resource requirements: Machine translation requires large bilingual text corpora for training and may need frequent updates to improve translation quality. Generative AI translation needs vast amounts of data for training but can generate translations that are more contextually appropriate and creative.

Use cases: Machine translation is suitable for general translation tasks, such as website localization, document translation, or communication. Generative AI translation is ideal for applications where tone, style, and context are crucial, such as literary translation, marketing materials, or customer service interactions.

AI translation in software localization

AI translation is essential for software localization, making it easier and faster to translate software interfaces, documentation, and content into various languages. Traditional machine translation methods, like Neural Machine Translation (NMT) used by Google Translate and DeepL, ensure consistency and speed, allowing large volumes of text to be processed quickly.

AI translation providers

Generative AI translation advances software localization by offering context-aware and natural-sounding translations. Unlike traditional MT, generative AI models like OpenAI's GPT-4 handle idiomatic expressions, cultural nuances, and complex sentences more accurately. This results in polished, user-friendly localized content, maintaining the software's tone and brand voice across languages.

Generative AI is especially useful for localizing user-facing elements, such as marketing content and interactive help systems, where engaging and contextually appropriate language is crucial.

How to use AI translation in software localization

The software localization process involves several steps performed by different team members, including developers, translators, and localization managers. To make the most of software localization with AI translation, consider using a translation management system (TMS) like SimpleLocalize that integrates AI translation tools and automates the localization workflow.

SimpleLocalize logo

SimpleLocalize supports machine translation services like Google Translate and DeepL for fast and accurate translations. Using the dedicated auto-translation feature, you can translate software content in multiple languages with a single click.

It also integrates with generative AI models like OpenAI's GPT-4 for context-aware and creative translations.

Auto-translation feature in SimpleLocalize

Learn how to get started with translation management using SimpleLocalize

Using AI or gen-AI translations in software localization can significantly improve the efficiency and quality of the localization process, but it's still essential to have human oversight and review to ensure accuracy and cultural appropriateness. SimpleLocalize helps you control the quality of your translations by providing a simple translation editor with a review translations feature.

By using SimpleLocalize, you can streamline the localization process, manage translations efficiently, and deliver high-quality localized content to users worldwide.

How AI translation can help in software localization

AI translation offers several benefits for software localization, making the process more efficient, accurate, and user-friendly by improving:

Speed: AI translation can process large volumes of text quickly, reducing the time needed for localization projects.

Consistency: AI translation ensures consistent terminology and style across all localized content, maintaining linguistic accuracy and consistency.

User experience: AI translation generates natural-sounding translations that enhance the user experience, making the software more accessible and user-friendly.

Cost-effectiveness: AI translation reduces the need for manual translation, lowering localization costs and improving ROI.

Scalability: AI translation can handle large localization projects with ease, making it suitable for software with extensive content and frequent updates.

Robot emoji

Cons and pros of AI translations

As with any technology, AI translations have their advantages and disadvantages. Here are some of the pros and cons of using AI translations:

Pros

Speed: AI translations can process large volumes of text quickly, reducing the time needed for translation.

Cost-effective: AI translations are more affordable than human translations, making them a cost-effective solution for businesses.

Consistency: Maintains uniformity in terminology and style across different languages.

Scalability: Easily scales to accommodate multiple languages and frequent updates.

Cons

Accuracy: AI translations may not always be as accurate as human translations, especially for complex or nuanced text.

Cultural nuances: AI might miss cultural subtleties, potentially causing misinterpretations or offense.

Quality: Translation quality can vary depending on the complexity of the content and the language pair.

Creativity: AI translations may lack the creativity and nuance that human translators

Over-reliance: Relying solely on AI may overlook the need for human review, especially for high-stakes or sensitive content.

For generative AI translations, the pros, and cons are similar, with the added benefit of more contextually appropriate and creative translations. However, generative AI translations may still struggle with accuracy and cultural nuances, requiring human oversight to ensure quality and appropriateness.

Conclusion

AI-powered translations have revolutionized the language services industry with their ability to provide rapid and efficient translations. By using advanced algorithms and neural networks, these systems handle large volumes of text, delivering translations that are both accurate and contextually relevant.

Generative AI models, in particular, push the boundaries of translation quality by producing more nuanced and creative outputs. However, these models still face challenges with accuracy and cultural sensitivity, requiring careful oversight to ensure high-quality translations.

In software localization, AI tools streamline the process, improve the user experience, and significantly reduce translation costs. Despite their advantages, AI translations should be used alongside human expertise to achieve the best results and address any AI limitations. As AI technology continues to advance, its role in global communication is set to expand, offering even more sophisticated solutions.
]]></content:encoded>
            <category>auto translation</category>
            <category>translation management</category>
            <category>openai</category>
            <category>chatgpt</category>
            <category>deepl</category>
            <category>google translate</category>
            <category>machine translations</category>
            <enclosure url="https://simplelocalize.io/blog/ai-translations.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to control translation quality with QA checks and review statuses]]></title>
            <link>https://simplelocalize.io/blog/posts/translation-quality-review</link>
            <guid>https://simplelocalize.io/blog/posts/translation-quality-review</guid>
            <pubDate>Tue, 09 Jul 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Improve translation quality with automatic QA checks and review statuses. Learn how to detect issues early, improve review processes, and ensure high-quality translations.]]></description>
            <content:encoded><![CDATA[Quality assurance is a crucial step in the translation process, especially when you rely on auto-translation tools. In SimpleLocalize, you now have two layers of quality control:

Automatic QA checks to instantly flag issues in translations.

Review statuses to manage human verification and approval.

Together, they help you ensure that your translations are accurate, consistent, and ready to publish.

Why translation quality control matters

Whether you are working with professional translators or machine translation tools like DeepL, ChatGPT, or AI translation services, not every translation is perfect on the first try.

Mistakes can happen, and even the best tools can produce:

Inconsistent terminology

Truncated or overly long strings in the UI

Placeholders missing or in the wrong place

Punctuaction mismatches

Poor grammar or unclear phrasing

and more...

These errors can cause confusion in your app, frustrate users, and even increase customer support tickets. SimpleLocalize provides QA checks and review statuses to keep translations under control.

Learn more about quality assurance in localization.

Automatic QA checks

QA checks automatically scan your translations and highlight potential issues so you can fix them early. On every change in your translations (made in the editor, via API, CLI, during import or through integrations), SimpleLocalize runs a series of checks to ensure quality and consistency.

Examples of issues detected:

Placeholders and variables not matching the source text ({name}, %s, etc.)

Length warnings when translations are too long or too short compared to the source text

HTML tags inconsistencies

Capitalization mismatches

Punctuation issues

Whitespace problems (extra spaces, missing spaces)

QA checks examples

You will see these checks directly in the translation editor, next to each translation. If an issue is detected, a warning icon appears. Click on it to see details about the problem and suggestions for fixing it.

QA checks in action

Learn more about QA checks in SimpleLocalize.

Review statuses: human verification layer

While QA checks catch obvious issues, review statuses allow you to track human verification. Each translation can have one of two statuses:

Needs review

This status indicates that the translation needs to be reviewed by a human translator, and it requires a quality check. It's a default status for all translation keys and translations.

Review status: Needs review

When does the translation key need review?

Auto-generated translations that need manual verification.

Strings where you are unsure of terminology or tone.

Keys flagged by QA checks for issues.

Updates that require a second opinion before release.

Accepted

This status indicates that the translation has been reviewed and approved by a human translator and is ready for publication. You can assign this status to a translation when you are satisfied with the translation.

Review status: Accepted

When does the translation key get accepted?

The translation has been reviewed and approved.

Errors flagged by QA checks have been resolved.

The string is ready to go live.

Applying review statuses

Check the review status of your translations in the translation editor. The review status icon is located next to each translation key.

Change the review status of a single translation

When you are working on a single translation in the translation editor, you can easily change its review status. Simply click on the review status icon next to the translation key to switch between Needs review and Accepted.

Changing review status of a single translation

Change the review status in all translations

If you are reviewing multiple translations at once, you can change the review status of all translations for the translation key.

Hold Shift and click on the review status icon in any language in the translation key you are working on. The new review status will be applied to all translations for this key.

Changing review status in all key translations

Change the review status in multiple translations

If you want to change the review status of multiple translations in different languages, or all translations in just one language, you can do it using Bulk Actions.

Select the translation keys you want to change the review status for, click on the Bulk Actions button, and choose Change review status. Then, select the new review status and languages, and confirm the changes.

Changing review status in multiple translations

Use filters to narrow down the translations you want to change the review status for.

How to combine QA checks with review statuses

For the best translation quality control, use both QA checks and review statuses together. Here's a simple workflow you can follow:

Translate: create initial translations

First, you need to prepare your project and produce translations. You can do this by following these steps:

Create or open the project and decide which source language is “main” (the language that triggers re-reviews when changed).

Add translations manually in the editor or generate them using auto-translation (Google, DeepL, OpenAI, OpenRouter).

Provide as much context as possible for each key: descriptions, screenshots or comments so translators and reviewers know how a string is used.

Best practice: all auto-generated translations should start as Needs review.

Translation editor with review status

Learn how to import your existing translations to SimpleLocalize.

Run QA checks: catch issues automatically

QA checks highlight issues directly in the editor:

Look for the warning icon next to translations to see if there are any issues.

Click on the warning icon to see details about the issue and suggestions for fixing it.

Inspect each flagged item in place. QA checks typically point out the exact problem (e.g., “missing placeholder {name}).

Use the editor filters to show only keys with QA issues.

Fixing QA issues

Mark for review: use statuses strategically

As you work through your translations, use review statuses to track what needs human attention:

New or auto-generated translations are set to Needs review by default.

If you fix a QA issue, you can keep the status as Needs review until you or a colleague verifies it.

Once a translation is verified and looks good, change its status to Accepted.

Tip: Use Bulk Actions to set review status for multiple keys or languages at once.

Human review: verify style, meaning, and context

When reviewing, check more than just QA warnings. Use this checklist before marking a translation as Accepted:

Placeholders are present and correct.

Terminology matches your glossary and project style.

Tone and style are appropriate for your audience.

Text is fluent, natural, and appropriate for the UI.

Length fits buttons or screen limits (test it in our in-context editor).

Formatting, punctuation, and capitalization are consistent.

The translation conveys the original meaning accurately.

For example, a machine translation might give “Start session” instead of “Log in”. QA checks won't catch this, a reviewer will.

Changing review status to Accepted

Our tips for reviewing translations in SimpleLocalize:

Filter translations by review status set to Needs review to narrow down the translations that need review

Invite other team members to review the translations and get a second opinion

Use Ctrl + Enter or Cmd + Enter to quickly move to the next translation within the same language

Pay attention to the number of characters in the translation to avoid truncation issues (you can see the character count in the translation editor)

Filter translations by review status

Accept & publish: finalize translations

Once translations are marked Accepted and no QA issues remain, you can publish safely.

Export or host translations directly from SimpleLocalize.

Run a quick UI check in staging (especially for short labels like buttons or menu items).

Optionally, automate review status resets: e.g., when the source text changes, all related translations switch back to Needs review

Integrate with your CI/CD pipeline to keep translations up-to-date, e.g., using our API, CLI or GitHub integration.

Publishing translations from SimpleLocalize

Bulk actions and automations

To make the workflow even faster, you can:

Bulk change review statuses. Select multiple keys/languages and set them to Needs review or Accepted at once.

Automate review status. For example, when the main language changes, other translations automatically switch to Needs review.

Filter by QA checks. Quickly focus only on strings with detected issues.

Automating the review status application

Learn more about Bulk Actions and Automations.

Benefits of QA checks + review statuses

Using both QA checks and review statuses provides several advantages:

Early issue detection: Catch issues before they reach your users with automatic QA checks.

Consistency: Ensure terminology and formatting match across languages.

Human + machine QA: Combine automated checks with translator expertise.

Efficiency: Review only the strings that need attention.

Summary

Translation quality isn’t just about grammar. It’s about clarity, consistency, and correctness.
With SimpleLocalize:

QA checks catch common issues automatically.

Review statuses help manage human verification.

Together, they give you a complete workflow to manage translation quality, from auto-translation to final publication.

Try it out in your project and see how QA checks + review statuses streamline your localization workflow.
]]></content:encoded>
            <category>tutorial</category>
            <category>software localization</category>
            <category>translation management</category>
            <category>quality assurance</category>
            <enclosure url="https://simplelocalize.io/blog/review-status/translation-review-statuses.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Save time with SimpleLocalize Automations: Auto-translate, review & more]]></title>
            <link>https://simplelocalize.io/blog/posts/automations</link>
            <guid>https://simplelocalize.io/blog/posts/automations</guid>
            <pubDate>Wed, 26 Jun 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Speed up your translation workflow with automations in SimpleLocalize. Automatically translate, clear, or update review status when translations change. Watch the setup video.]]></description>
            <content:encoded><![CDATA[Localization doesn't need to be a slow, manual process. With SimpleLocalize Automations, you can auto-translate updates, clear outdated translations, and update review statuses automatically. For all kind of translations, automations let you move faster and keep your content up-to-date without manual intervention.

Watch the setup in action:

YouTube video on translation automations

What are Automations?

Automations in SimpleLocalize are rules that trigger specific actions whenever a translation changes. These changes can happen via the editor, CLI, or API.

With just a few clicks, you can:

Auto-translate updates across all languages

Change review statuses based on edits

Clear translations that no longer match your source language

Publish translations automatically after changes

Combine multiple actions for efficient workflows

How it works

Automations consist of two main components: triggers and actions.

Trigger: When does it start?

A trigger is an event that starts automation. It's a condition that needs to be met for the automation to be executed.

Translation change

An automation is activated when a translation is added or edited. You can define:

Which language triggers it (default, specific, or all)

Where the change comes from (editor, CLI, or API)

Review status of the translation (e.g., only trigger for translations marked as Needs review)

Auto-translation completion

Another option is to trigger automations when auto-translation is completed, which is useful for workflows that involve auto-translation. In this case, you choose the source of auto-translation (Web, CLI, API or another automation).

Automation trigger

Actions: What happens next

An action is a task that the automation performs when the trigger condition is met. You can choose from various actions, such as:

Auto-translate

Change review status

Clear translations

Auto-translate

Automatically translate a changed key into all other languages. You can filter by:

Review status (e.g., only auto-translate translations marked as Needs review)

Translation status (e.g., only auto-translate translations that are not yet translated)

Use cases:

Quickly update translations in all languages when the default language translation is edited

Auto-translate newly added keys to all languages (check example)

Auto-translate action

Learn more about auto-translation and how to set it up.

Change review status

Update the review status automatically to Accepted or Needs review when the translation is edited. You can specify:

Which review status to set

Which languages to apply the change to (all, default, only the edited language, etc.)

Use cases:

Automatically mark translations as Needs review when they are edited, so you can verify them (check example here)

Set translations to Needs review when the default language translation is updated, ensuring all translations are checked

Automatically mark translations as Accepted when they are edited in the default language, so they are ready for use

Change review status action

Learn more about review statuses and how to manage them.

Clear translations

Ensure outdated translations don't linger. Automatically clear all other languages when the default translation changes, especially helpful when the review status is Needs review.

Use cases:

When default language translation is updated, clear translations in all other languages to ensure they are up-to-date (check example)

Clear not accepted translations in other languages when the default language translation is edited

Clear translations action

Publish translations

This action allows you to publish translations to the Latest environment after auto-translation.

Use case: Automatically publish translations after auto-translation, so they are immediately available in your app

Publish translations action

How to create automations

Setting up your first automation takes less than a minute. You can create a maximum of three automations per project, and they will work in the selected order when enabled.

Automations settings

To set up automations in SimpleLocalize, follow these steps:

Go to project Settings → Automations

Click Create automation. Add the automation name to help you identify the automation later.

Choose a trigger (translation change) in the When section.

Select an action (auto-translate, change review status, or clear translation) in the Then section.

Hit Save automation.

You can enable or disable the automation at any time by toggling the switch above the automation name in the settings.

Tip: Use clear names like “Auto-translate new keys” or “Clear on default update” to stay organized.

Here, you can see an example of an automation that automatically translates edited keys to all other languages if their review status is Needs review:

Sample automation

As you can see, automation auto-translates only the translation in Polish because it is marked as Needs review. The Spanish translation doesn't meet the condition, so it won't be auto-translated.

Tip: Make sure to set your default language before creating automations. The default language is the language that all other languages are translated from.

Use cases for automations

Automations can help you automate repetitive tasks, speed up the translation process, and improve your localization workflows. Below, you can check out some examples of how you can use automations in SimpleLocalize.

Auto-translate new keys

Whenever a new key is added to the default language, you can automatically translate it to all other languages. This way, you can quickly update translations in all languages without having to do it manually.

This automation is very simple: When translation changes, auto-translate it to all other languages.

Auto-translating new keys

Clear translations on source update

This automation clears translations in all other languages when the default language translation is updated. This way, you can make sure that all translations are up-to-date and consistent with the default language translation.

Automation: When translation changes, clear translations in all other languages.

Clearing other translations when default language translation is updated

Mark as needs review after edit

Whenever a previously accepted translation is edited, you may want to verify translations to other languages. In that case, the automation can change the review status to Needs review for all translations in other languages.

Automation: When translation changes, set review status to Needs review for all other languages.

Changing review status when translations are updated

Publish translations after auto-translation

If you want to make sure that translations are immediately available in your app after auto-translation, you can use the Publish translations action. This way, you can automatically publish translations to the Latest environment after auto-translation.

Automation: When auto-translation is completed, publish translations to Latest environment.

Combine multiple automations

When you create multiple automations, they will run one after another in the order you set them up. This way, you can combine actions to automate more complex tasks.

If we keep the order of automations from the examples above, the following actions will be performed when the default language translation is updated:

other languages will be auto-translated

the review status will be changed to Needs review

publish translations after auto-translation

Changing order of automations

Summary

The Automations feature can be a great help in speeding up your localization workflows by automating repetitive tasks. They can help you save time and effort by automatically performing certain actions on your translations, so you don't have to perform them manually or remember about them. SimpleLocalize will do it for you.
]]></content:encoded>
            <category>tutorial</category>
            <category>software localization</category>
            <category>translation management</category>
            <category>automation</category>
            <enclosure url="https://simplelocalize.io/blog/automations/automations.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Organize translation keys with Tags]]></title>
            <link>https://simplelocalize.io/blog/posts/translation-editor-tags</link>
            <guid>https://simplelocalize.io/blog/posts/translation-editor-tags</guid>
            <pubDate>Fri, 31 May 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Organize translation keys with tags in SimpleLocalize. Learn how to create, assign, and filter tags to streamline your localization workflow and team collaboration.]]></description>
            <content:encoded><![CDATA[Tags are a powerful feature that can help you organize your translations and make it easier to find the translations you need. In this article, we will show you how to use tags in SimpleLocalize's Translation Editor to group and filter your translations with ease.

Why use tags in translation management?

Managing hundreds or thousands of translation keys can get messy quickly. That's where translation tags come in. By tagging your translation keys with meaningful labels, you can:

Group related content by feature, release version, or status

Quickly filter and find relevant keys

Improve team collaboration with visual cues

Control access based on tag permissions

Whether you are a developer, product manager, or translator, tags help streamline localization workflows and keep your content organized.

What are translation tags?

In SimpleLocalize, translation tags are customizable labels you can assign to translation keys. Each tag is color-coded and can have a short text label.

Translations with tags

You can apply multiple tags to a single key to represent things like:

Feature (e.g. "Checkout", "Dashboard")

Status (e.g. "Needs Review", "Approved")

Version (e.g. "v2.0", "Beta")

Tags are visible directly in the List View of the translation editor and make it easy to organize, search, and collaborate on translations.

Besides using tags, make sure that your translation keys are well-structured and follow a consistent naming convention. Learn more about it in our blog post describing best practices for creating translation keys.

How to create translation tags

Head to your project Settings, and in the General section, you will find the Translation key tags list. Here you can add new tags, edit or delete existing ones, and also see how many translation keys are assigned to each tag.

Tags in project settings

To create a new tag, click the Create tag button, enter the name of the tag, and choose its color. You can also edit or delete existing tags by clicking the Manage button in the tags list.

Watch a demo of creating a translation tag

Showing tags in the translation editor

You can show the full tag name in the translation editor by hovering over the tag circle, or you can adjust the table view to show the tag names directly.

Tag name in the translation editor

You can limit access to translations with specific tags for translators using tags permissions. Learn more about it in our documentation.

How to assign tags to translations

Assigning tags to translations is easy, and there are two ways to do it, depending on your needs:

Assign tags to a single translation key

Choose a translation key in the translation editor and choose the Manage key option. There, you can edit the key details and assign tags to it.

Assigning tags to a translation key

💡 You can also right-click on a translation key to access the tag management menu:

Right-click and assign tags

Assign tags to multiple keys at once

If you want to assign the same tag to multiple translation keys at once, you can use the Bulk Actions feature.

Select the translation keys you want to tag, click the Bulk Actions button, go to Change key settings and choose Update tags option. Then, select the tag you want to assign and click Apply changes.

Assigning tags to multiple translation keys

To remove tags in bulk, follow the same steps but use the Clear assigned tags option.

Filtering translations by tags

Now that you have assigned tags to your translation keys, you can use them to filter your translations in all translation editor views.

Click the Filters option and select one or more tags to narrow down your view.
You can also filter by:

Specific tag combinations

Keys without any tags (select No tags)

Filtering translations by tags

Best practices and use cases for tags

Here are practical ways teams use tags in localization projects:

Feature Grouping: Tag all keys related to a feature like Profile, Settings, or Search.

Versioning: Label translations added in v1.0, v2.0, etc., to manage rollouts.

Review Flags: Mark keys as Needs Review, Pending Approval, etc.

Access Control: Use tag-based permissions to restrict translator access to sensitive keys.

By using tags, you can make it easier to find the translations you need and keep your translation keys organized. They are an easy and effective way to help you in your translation management process.

Final thoughts

Translation tags in SimpleLocalize aren't just labels, they are a powerful organization tool that enhances clarity, improves workflows, and simplifies localization management. Start using tags today to bring structure and control to your translation process.

🔗 Want to learn more? Explore our full documentation.
]]></content:encoded>
            <category>tips</category>
            <category>translation editor</category>
            <category>translation management</category>
            <category>software localization</category>
            <enclosure url="https://simplelocalize.io/blog/tags/translation-key-tags.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[ChatGPT and DeepL translation context in auto-translation]]></title>
            <link>https://simplelocalize.io/blog/posts/chatgpt-deepl-context</link>
            <guid>https://simplelocalize.io/blog/posts/chatgpt-deepl-context</guid>
            <pubDate>Fri, 17 May 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn what is context in auto-translation and how to use ChatGPT and DeepL translation context feature to improve the quality of your auto-translation using SimpleLocalize.]]></description>
            <content:encoded><![CDATA[Auto-translation is a powerful tool that can help you translate and localize your content quickly and efficiently. However, it can sometimes be challenging to get the translation just right, especially when dealing with complex or nuanced text. In this article, we'll show you how to use ChatGPT and DeepL translation context to improve the quality of your auto-translations.

Context in auto-translation

When translating text, context is key. Without context, it can be difficult for translation tools to accurately capture the meaning of the original text. This is where ChatGPT and DeepL translation context come in.

Both ChatGPT and DeepL allow you to provide context when translating text. This context can help the translation tools better understand the meaning of the text and produce more accurate translations. By providing context, you can help ensure that your translations are accurate and convey the intended meaning of the original text.

Context can come in many forms, such as:

The topic of the text, e.g., technology, finance, or healthcare

The tone of the text (formal or informal)

The intended audience, e.g., general readers or industry professionals

The formality of the text, e.g., academic or conversational

The style of the text, e.g., humorous or serious

and much more.

Context in auto-translation with ChatGPT and DeepL

ChatGPT, powered by OpenAI, is a language model that can generate human-like text based on the input it receives. When using ChatGPT for auto-translation, you can provide context to help the model generate more accurate translations.

Learn more about ChatGPT and how to use it for auto-translation in SimpleLocalize.

DeepL is a popular machine translation tool that uses artificial intelligence to produce high-quality translations. DeepL supports context in auto-translation, allowing you to provide additional information to help the tool generate more accurate translations.

In SimpleLocalize, you can provide context to ChatGPT and DeepL in two different ways:

Context prompt

You can provide a general context prompt that describes the topic, tone, audience, or style of the text you want to translate. This prompt can help ChatGPT or DeepL generate more accurate translations by providing additional information about the text. This prompt will be applied to all translation keys in your project.

Conext field is available for ChatGPT integration as System prompt and for DeepL as Context.

Context prompt for ChatGPT

Context per key

You can provide context for each translation key in your project using translation key description from the translation editor. This allows you to provide specific context for each key.

Mark Include descriptions option in ChatGPT or DeepL integration settings to include translation key descriptions as context.

DeepL translation context

You can use both methods to provide context to ChatGPT or DeepL and improve the quality of your auto-translations.

Additionally, DeepL supports glossaries that can be used to provide context for specific terms or phrases. Learn how to use it during auto-translations.

DeepL context guidelines

When using DeepL for auto-translation, it's essential to follow the guidelines for providing context to ensure the best results. Here are some tips for providing context in DeepL:

Context should be formed as complete sentences relevant to and descriptive of the source text (2-5 sentences tend to yield the best results).

Context should be written in the same language as the source text.

Commands or instructions like "Do not translate this" should not be included in the context (use DeepL glossaries for this purpose).

Examples of context in auto-translation

Adding context to your auto-translations can make a huge difference in the quality of the translations. Let's look at an example to see how context can improve auto-translation.

As an example, let's say we want to translate the word "spirit" from English to Polish. The meaning of the word "spirit" can vary depending on the context. It can refer to a ghostly entity, a person's mood or attitude, or a distilled alcoholic beverage. In our case, let's say we use the word "spirit" in the context of an alcoholic beverage.

Here you can see the difference in translation when providing context:

Context when translating "spirit"

Another example, the word "bank" can refer to a financial institution or the side of a river. If we try to translate the sentence "Sitting by the bank." without context, the translation tool may not know which meaning of "bank" to use. However, if we provide context that the text is about the bank of the river, the translation tool can generate a more accurate translation.

Context when translating "bank"

The context was provided in the form of translation key description for ChatGPT translations.

Context in ChatGPT translation key description

By providing context, you can help ChatGPT or DeepL generate more accurate translations that better capture the meaning of the original text.

Conclusion

Context is essential in auto-translation to help translation tools like ChatGPT or DeepL better understand the meaning of the text and produce more accurate translations. By providing context, you can improve the quality of your auto-translations and ensure that your translations convey the intended meaning of the original text.

Learn more about auto-translation feature in SimpleLocalize and how to use ChatGPT and DeepL for auto-translations in our documentation.
]]></content:encoded>
            <category>deepl</category>
            <category>openai</category>
            <category>chatgpt</category>
            <category>tips</category>
            <category>auto translation</category>
            <enclosure url="https://simplelocalize.io/blog/context-in-auto-translation.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[AI vs MT: Auto-translation comparison with examples]]></title>
            <link>https://simplelocalize.io/blog/posts/deepl-google-translate-openai-comparison</link>
            <guid>https://simplelocalize.io/blog/posts/deepl-google-translate-openai-comparison</guid>
            <pubDate>Thu, 25 Apr 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Check out our comparison of DeepL, Google Translate, and OpenAI for auto-translation with examples, quality check and cost estimation.]]></description>
            <content:encoded><![CDATA[Auto-translation services have become essential tools for breaking down language barriers in today's world. Among the most popular providers are DeepL, Google Translate, and OpenAI. In this blog post, we'll delve into how each of these platforms handles translations, analyze examples, compare results, and assess the cost and efficiency of translation.

What is machine translation?

Machine translation is the process of automatically translating text from one language to another using computer software. It's a powerful tool that can help translate large volumes of text quickly and efficiently, making it easier to communicate across language barriers.

Machine translation is widely used in various industries, including software localization, e-commerce, and travel, to help businesses reach a global audience.

It uses algorithms to analyze the structure of a sentence in one language and generate an equivalent sentence in another language. These algorithms can be rule-based, statistical, or neural network-based, with each approach having its own strengths and weaknesses.

Common issues with machine translation

While machine translation has come a long way in recent years, it still has some limitations. Here are a few common issues you might encounter when using machine translation:

Accuracy: Machine translation systems can struggle with idiomatic expressions, slang, and other nuances of language.

Context: They don't always take context into account, which can lead to errors in translation.

Tone: Capturing the tone and style of a text can be difficult, affecting the overall quality of the translation.

Domain-specific terminology: They may not be able to accurately translate specialized terminology used in specific fields, such as medicine or law.

Language pairs: Not all language pairs are supported, limiting their usefulness in certain situations.

Auto-translation examples

To illustrate how DeepL, Google Translate, and OpenAI handle translations, let's look at some examples. We will translate a few simple phrases from English to Spanish and Polish using each of these platforms. Our texts come from a hotel website and include common phrases that you might encounter when traveling, thus providing a good test of the platforms' capabilities.

Here are our translation keys with text in English:

Translation keys

Auto-translation will be performed using the SimpleLocalize translation editor, integrated with DeepL, Google Translate, and OpenAI.

Learn how to use auto-translation in SimpleLocalize.

Auto-translation using DeepL

DeepL is a popular machine translation service known for its high-quality translations. It was created by Jarosław Kutylowski, a Polish entrepreneur, and is based on deep learning technology that can generate accurate translations in multiple languages. The main advantage of DeepL is its ability to produce natural-sounding translations that are close to human quality.

Let's see how DeepL handles our example phrases when translated into Spanish and Polish.

Auto-translation to Spanish:

DeepL auto-translation to Spanish

Auto-translation to Polish:

DeepL auto-translation to Polish

The translations are accurate and natural in both Spanish and Polish. DeepL has done a good job of capturing the meaning of the original English text and producing high-quality translations.

For better results, you can use additional options provided by DeepL, such as glossary, context, and using key description for additional context when translating with SimpleLocalize.

Glossary - a predefined list of terms and translations that can be used by DeepL to improve translation quality. Learn more about the DeepL glossary

Context - additional information about the translated text, like format, style, or purpose

Description - translation key description that can provide additional context for the specific translation

Auto-translation using Google Translate

Google Translate is one of the most widely used machine translation services, offering translations in over 100 languages. It uses a combination of rule-based and statistical machine translation techniques to generate translations.

Let's see how Google Translate translates our texts into Spanish and Polish.

Auto-translation to Spanish:

Google Translate auto-translation to Spanish

Auto-translation to Polish:

Google Translate auto-translation to Polish

At the first glance, the translations seem accurate, but there are some issues. For example, the term "Executive lounge" was translated to Polish as "Salon wykonawczy" which is not accurate, such a term doesn't exist. The correct translation should be "Sala VIP", "Salon Executive" or "Sala Executive".

Auto-translation using OpenAI

OpenAI is a leading provider of AI technology that can be used for machine translation. It offers a range of language models that can generate high-quality translations in multiple languages. OpenAI's translation models are based on deep learning and can produce accurate translations that are close to human quality.

Learn more about OpenAI translations

Let's see how OpenAI handles our translations to Spanish and Polish.

Auto-translation to Spanish:

OpenAI auto-translation to Spanish

Auto-translation to Polish:

OpenAI auto-translation to Polish

We can see that only OpenAI retained the original term "Pillow Menu" as its own name, although translated. All translations are accurate and natural in both Spanish and Polish.

Similar to DeepL, OpenAI provides additional options that can be used to improve translation quality, like context and key description.

Comparison

Let's gather all the translations in one place and compare them side by side.

English to Spanish:

Comparison of translations to Spanish

English to Polish:

Comparison of translations to Polish

Observations

All three platforms produced accurate translations in both Spanish and Polish for simpler, more general, and widely known phrases, like Do not disturb or Welcome amenities. However, we can see how differently they approach the translation of texts whose translations are not that straightforward, where phrases can be used in different ways in the target language, like Room service in Polish.

DeepL uses more natural language when compated to Google Translate and OpenAI, especially for longer phrases.

Late check-out - all platforms translated the term correctly, but to make it more natural, it could be left as is in English, as it's a term that can be understood in many languages.

All services decided to translate Pillow Menu instead of keeping the original term. It makes sense, as translation makes the text more understandable for people who don't speak English, but it's worth considering keeping the original term in some cases, especially if it's a brand name.

Accuracy and quality

While Google Translate is widely known for its speed and convenience, its translations can sometimes be less accurate than those produced by other services like DeepL. We can see that in our examples (Executive lounge translated to Polish).

OpenAI, similar to DeepL, produces high-quality translations that are close to human quality. The translations of all three services show some differences in terms of style and naturalness, but all are accurate and understandable.

Here is our rating of the translations in terms of accuracy and quality, based on the examples we analyzed:

Comparison of translations in terms of accuracy and quality

It's worth noting that the quality of translations can vary depending on the language pair and the complexity of the text. For more complex texts, it's recommended to use additional options provided by the translation service, like glossary, context, or key description, which can be used with auto-translation with DeepL and OpenAI.

Cost of translation

Regarding costs, they are calculated differently by each provider. Below, you can see an estimation of translating with each service, and below, you can check the pricing details and calculation for each provider.

We estimate the cost of translating 500 000 and 1 000 000 characters into another language using DeepL, Google Translate, and OpenAI:

|                      |        DeepL        |   Google Translate   |        OpenAI        |
|:--------------------:|:-------------------:|:--------------------:|:--------------------:|
|                      |    per character    |     per character    |       per token      |
| 500 000 characters   |         free        |         free         |         $1.5         |
| 1 000 000 characters |         $25         |          $10         |          $3          |

Important notes

The first 500 000 characters per month are free for DeepL API and Google Translate.

The cost of translation with OpenAI is based on the number of tokens, not characters. The number of tokens can vary depending on the language and the complexity of the text.

In case of OpenAI, the cost depends on how many translation keys and languages you have in your project. More keys, more languages and extra context or key description mean more tokens and higher costs. See in the section below the details of how the cost of translation with OpenAI is calculated.

DeepL pricing details

DeepL offers a translation API that charges based on the number of characters in the text you want to translate. According to DeepL pricing, the cost of translating text with DeepL is $20 per 1 million characters, plus $5.49/month for the API subscription. The free tier includes 500 000 characters per month.

Google Translate pricing details

Google Translate offers more flexible pricing options, depending on the volume of text you need to translate. The cost of using Google Translate is based on the number of characters in the text you want to translate. According to Google Cloud pricing, the cost of translating text with Google Translate is $10 per 1 million characters.

Google Translate pricing

OpenAI pricing details

The calculation of the cost of translation with OpenAI is a bit more complex. ChatGPT uses tokens as a billing system, and there is no direct conversion from "token" to "character". According to OpenAI, 1 token equals about 4 characters, or 3/4 of a word when using English as a source text. Note that ChatGPT requires providing some "command" and "context" to request the translation, so it will require more credits/tokens than just a source text.

For example, if we translate Executive lounge to Spanish, the prompt sent to OpenAI is something like:

Translate the text in double quotes from 'English (en-US)' to 'Spanish (es-ES)': "Executive lounge". Please don't include this prompt in the translations and do not add this symbol " at the end and beginning of translations if it wasn't present in the source text.

Such a prompt has about 58 input tokens (264 characters) according to the OpenAI tokenizer tool, and the output is: Sala ejecutiva which is gives us 5 output tokens (14 characters).

OpenAI tokenizer

According to OpenAI pricing, translating the text from the example using 'gpt-3.5-turbo-0125' would cost:

for input: $0.0000005 \* 58 input tokens = $0.000029

for output: $0.0000015 \* 5 output tokens = $0.0000075

Sums to: $0.000029 + $0.0000075 = $0.0000365 for the translation.

Cost estimation

If we assume the worst-case scenario that 1 token translates into 1 character and for every translation we need additional 200 tokens for the "command" and context and our project has 5000 translation keys, then it would be:

50,000 source characters -> 50,000 input tokens \* $0.0000005 per input token = $0.025

5000 translation keys \* 200 tokens for command and context -> 1,000,000 input tokens \* $0.0000005 per input token = $0.50

50,000 translated characters -> 50,000 output tokens \* $0.0000015 per output token = $0.075

This sums to: $0.025 + $0.50 + $0.075 = $0.6 per translating 50 000 characters into another language.

Conclusion

In conclusion, all three platforms - DeepL, Google Translate, and OpenAI - offer high-quality translations that are accurate and natural. However, there are some differences in terms of style and naturalness, with DeepL and OpenAI producing more natural-sounding translations compared to Google Translate.

When choosing a translation service, it's important to consider factors like accuracy, quality, cost, and speed. DeepL and OpenAI are great choices for high-quality translations, while Google Translate is a good option for quick and convenient translations.

If we compare DeepL and OpenAI, DeepL offers a more straightforward pricing model with very natural translations, while OpenAI provides more flexibility and customization options at lower costs but with a bit more complex pricing model.

However, in all cases, machine translation should be treated as a starting point for further editing and proofreading by a human translator, especially for more complex texts or specialized terminology. A translation review by a professional translator can help ensure that the final text is accurate, natural, and culturally appropriate.
]]></content:encoded>
            <category>deepl</category>
            <category>google translate</category>
            <category>openai</category>
            <category>chatgpt</category>
            <category>auto translation</category>
            <category>machine translations</category>
            <category>tips</category>
            <enclosure url="https://simplelocalize.io/blog/machine-translations/deepl-google-openai-comparison.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Cloudflare Workers and Website Localization (2/5)]]></title>
            <link>https://simplelocalize.io/blog/posts/data-i18n-key-translation-extraction</link>
            <guid>https://simplelocalize.io/blog/posts/data-i18n-key-translation-extraction</guid>
            <pubDate>Wed, 17 Apr 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[In this tutorial, how to extract translation keys and translations from a HTML website and upload them to SimpleLocalize using the SimpleLocalize CLI.]]></description>
            <content:encoded><![CDATA[In the previous tutorial, we've shown you how to use Cloudflare Workers to localize any website with no additional dependencies.
Today we will show you how to extract translation keys and translations from HTML files and upload them to SimpleLocalize using the SimpleLocalize CLI.

Let's get started!

Prerequisites

Before you begin, you will need a SimpleLocalize account, and a website with 'data-i18n-key' attributes in HTML elements containing the strings that need to be localized.
HTML files must be stored in a directory that the SimpleLocalize CLI can search for.

How it works

We will run a command-line tool that will find all translation keys and translations in HTML files to store them
in a JSON file. The JSON file will be uploaded to SimpleLocalize where you will be able to manage translations.
From there, you can auto-translate the keys and translations and publish them to the CDN to serve localized content to the users,
thanks to the Cloudflare Workers that we have configured in the previous tutorial.

How Cloudflare Workers and SimpleLocalize CLI work together

Sample website

For this tutorial, we will use a simple HTML website with a few strings
that we have created before. It has a few strings with 'data-i18n-key' attributes that need to be localized, and three buttons to switch between languages.

Static HTML website hosted on GitHub Pages

Example of the HTML element with the 'data-i18n-key' attribute:

Setting up SimpleLocalize CLI

Before we configure the CLI, we need to create a new project to get the API Key for it.

Empty SimpleLocalize project

Then, we need to install the SimpleLocalize CLI. You can do it using one of the following commands depending on your operating system:

Once it's done, you can run the following command to verify the installation:

and you should see the version of the CLI, for example:

Next, let's create a configuration file for the CLI, in the main folder of our website project, and name it simplelocalize.yml:

Replace the YOUR_API_KEY with your SimpleLocalize API key. You can find it in the 'Settings > Credentials' section of your project.

In the configuration, we have specified the following options:

projectType - type of project that the CLI will use to extract translation keys and translations,

searchDir - directory where the CLI will search for matching files for the project type,

uploadPath - specifies the file which should be uploaded,

uploadFormat- specifies the format of the file that will be uploaded,

uploadOptions - additional options for the upload process, e.g., REPLACE_TRANSLATION_IF_FOUND to overwrite translations if found.
By default, translations will only be added if they are not found.

You can learn more about the configuration options in the Getting started with CLI page.

Extracting translation keys and translations

Now, we can run the following command to extract translation keys and translations from the website and upload them to SimpleLocalize:

The CLI will search for all HTML files in the ./public directory and extract translation keys and translations from the elements with the data-i18n-key attribute,
and store them in the extractions.json file. Next, we will upload the file to SimpleLocalize:

Uploading translations with CLI

The CLI will upload the extractions.json file to the SimpleLocalize project specified in the configuration file.
The --languageKey option specifies the language in which the translations have been extracted.
Make sure to replace en with the correct language code, and make sure that the language exists in the project.

After the upload is complete, you can see the translation keys and translations in the SimpleLocalize Translation Editor.

Uploaded translations in the Translation Editor

Managing translations

From now on, you can manage translations in the SimpleLocalize Translation Editor. You can add more languages to the project
and run auto-translation to translate the content. Once you are done, you can publish the translations to the CDN to serve localized content to the users.
The Cloudflare Workers that we configured in the previous tutorial will handle the routing and serve the localized content based on the user's preferred language.

Conclusion

In this tutorial, we've shown you how to extract translation keys and translations from a website and upload them to SimpleLocalize using the SimpleLocalize CLI.

In the following tutorials, we will show you how to:

use the accept-language header to detect the user's preferred language,

use the Cloudflare Workers KV to store and serve the localized content, and

configure Worker routes to match your website domain and path.

Stay tuned for the next tutorials!
]]></content:encoded>
            <category>developer</category>
            <category>cloudflare</category>
            <category>integration</category>
            <category>tutorial</category>
            <enclosure url="https://simplelocalize.io/blog/data-i18n-key/extracting-data-i18n-key.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to translate a website or app using OpenAI?]]></title>
            <link>https://simplelocalize.io/blog/posts/how-to-translate-with-openai</link>
            <guid>https://simplelocalize.io/blog/posts/how-to-translate-with-openai</guid>
            <pubDate>Tue, 26 Mar 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to translate your website or app with OpenAI and SimpleLocalize. Explore benefits, limitations, and step-by-step integration setup for smooth translations.]]></description>
            <content:encoded><![CDATA[When translating a website or app, you can use the help of different machine translation providers, like DeepL or Google Translate, to auto-translate the content. Besides those well-known options, there is now a new approach, offered by OpenAI and its advanced language models. How does it work? How to use it for translations with SimpleLocalize? In this blog post, we will explain and present to you how to use OpenAI for translations.

What is OpenAI?

OpenAI is an artificial intelligence research lab that focuses on developing advanced AI models and technologies. It was founded in 2015 and has since become known for its cutting-edge research in natural language processing, machine learning, and other AI fields.

It is known for its advanced language models, like ChatGPT, which goes beyond just generating text. OpenAI can handle translations too, by training its models on large datasets of parallel texts in different languages, allowing them to learn the mappings between languages and generate translations.

OpenAI logo

Does OpenAI work for translations?

OpenAI's language models, like ChatGPT, can be used for translating content between different languages. They can work great when you need to quickly and accurately translate large volumes of text while maintaining the context and meaning of the original content. OpenAI can be a great help for translators to speed up the translation process and reduce the time and effort required to translate content manually.

However, it's important to note that while AI translation has improved significantly recently, it may still have limitations, especially with complex or specialized content. Therefore, human review or post-editing may be necessary to ensure the highest quality translations.

OpenAI for translations

OpenAI pros

There are several advantages to using OpenAI for translating content:

Speed: quick auto-translation of large volumes of text compared to traditional human translation services. It's great for time-sensitive projects.

Cost-effective: AI translation services are often more cost-effective than standard translation services, especially for large-scale translation projects.

Quality: OpenAI's translation models often produce translations that are comparable in quality to those of DeepL and Google Translate.

Languages: support for a wide range of language pairs

Customization: flexible customization options, e.g., by adding context, for tailored results

OpenAI cons and limitations

While AI translations have improved significantly, they still require a human eye to review the translated content. Some potential drawbacks or limitations to consider when using them for translating content are:

Accuracy and quality: especially when translating complex or nuanced content. Certain languages or language pairs may also be more challenging for the model to translate accurately.

Contextual understanding: AI models may sometimes struggle to understand the full context of a sentence or document, leading to mistranslations or misinterpretations.

Specialized Terminology: AI models may not always be able to accurately translate specialized terminology or industry-specific jargon.

Possible biases or inaccuracies due to training data reliance

AI translation can provide a good starting point, but it may still require human review and post-editing to ensure the quality and accuracy of the translated content.

How to translate your app or website using OpenAI and SimpleLocalize?

The integration of OpenAI in SimpleLocalize allows you to quickly and easily translate your web or app content to different languages. See below for how to get started.

Create your project and upload translations

If you are new to SimpleLocalize, it's a simple yet effective translation management software that can help you and your team in your translation workflow and data management. You can learn more about it in our documentation.

To translate your website or app using OpenAI, start by creating an account at SimpleLocalize. Then, create and set up a new project for your content, following the instructions in the app.

Next, add your translation keys to the project. You can do it in several ways:

upload from file (e.g., JSON, Excel, CSV and more supported formats)

upload via API (great for automation)

upload with CLI (for developers)

Or just create some translation keys manually if you would like to start with a small set of keys and test the auto-translation feature.

Creating translation keys

Finally, add other languages you want to translate your content into. You can do it in the Languages tab.

Make sure to add actual translations to your keys, e.g. in your default language, so you can see the results of the auto-translation process.

Setup integration with OpenAI

To start using OpenAI for translations in SimpleLocalize, you need to set up the integration. Here's how to do it.

Go to your project Settings and find the Auto-translation section. There, at the top, you can set up the integration with ChatGPT, OpenAI's language model. For that, you need to:

provide your OpenAI API key (you can get it from your OpenAI account)

select the GPT model version (e.g., GPT-3.5, GPT-4)

add System prompt to provide context for the translations (optional)

SimpleLocalize OpenAI integration settings

Scroll down to the bottom of the page and click Save to apply the changes.

The integration is set up per project. You can have multiple projects in SimpleLocalize, each with its own settings and integrations.

Auto-translate using OpenAI

Now, you can start auto-translating your content using OpenAI. SimpleLocalize offers several options for that:

Auto-translate just one translation key (great for testing). Just click on the Auto-translate text button in the target language.

Auto-translate a single translation

Auto-translate selected translation keys. Hold Ctrl or ⌘ to access the multi-select mode, then click on the keys you wish to translate, and then the Bulk Actions button. Choose Auto-translation option and follow the instructions.

Auto-translate selected translation keys

Auto-translate all translation keys in one language. Head to the Languages tab, select the language you want to translate, and click the Auto-translate all keys button.

Auto-translate one language

Auto-translate all translation keys in all languages. Click the Auto-translate all keys button in the Languages tab.

Auto-translate all languages

Translations context

The OpenAI integration in SimpleLocalize allows you to provide context for the translations, which can help the model generate more accurate and relevant translations. You can do that by adding a System prompt in the integration settings.

For example, a system prompt can contain additional information about:

the type of content you are translating (e.g., website, app, marketing materials)

the target audience or region

the style or tone of the content (e.g., formal, informal)

any specific terminology or jargon used in the content

System prompt in OpenAI integration settings

Conclusions

OpenAI's language models, like ChatGPT, can be a great tool for translating content quickly and accurately. By integrating OpenAI with SimpleLocalize, you can easily auto-translate your web or app content to different languages, saving time and effort in the translation process. Remember that while AI translation can provide a good starting point, it may still require human review and post-editing to ensure the quality and accuracy of the translated content.

For more information or if you have any questions about using OpenAI for translations in SimpleLocalize, feel free to contact us. We are here to help you with your translation needs!
]]></content:encoded>
            <category>deepl</category>
            <category>google translate</category>
            <category>openai</category>
            <category>chatgpt</category>
            <category>auto translation</category>
            <category>machine translations</category>
            <category>tutorial</category>
            <enclosure url="https://simplelocalize.io/blog/openai/translating-with-openai.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Best practices for creating translation keys]]></title>
            <link>https://simplelocalize.io/blog/posts/best-practices-for-translation-keys</link>
            <guid>https://simplelocalize.io/blog/posts/best-practices-for-translation-keys</guid>
            <pubDate>Wed, 20 Mar 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Discover best practices for creating translation keys that are clear, consistent, and easy to manage to improve and optimize your app localization process.]]></description>
            <content:encoded><![CDATA[Translation keys are fundamental to software localization, providing a framework for translated content and simplifying the development and localization processes. In this blog post, we'll outline the best practices for creating translation keys, along with tips and tricks to improve your localization workflow. Let's dive in!

Understanding translation keys

A translation key is a reference or identifier used in localization and translation processes, linking the original source text with its corresponding translated content. It works as a guide for translators, helping them accurately match text to its equivalent in another language or dialect.

Translation keys and translations

Therefore, the structure and creation of translation keys are crucial for their effectiveness. They should be readable and decipherable while containing sufficient information about the translation context. In the sections below, we will describe best practices for creating translation keys and things to remember when doing so.

To learn more about translation keys and see examples, please refer to our blog post 'What is a Translation Key?'
where we explain the concept in detail.

Best practices

Below are some best practices and tips for creating translation keys that are simple, comprehensive, and effective in the software localization process.

Be descriptive

Use descriptive keys that provide a context for the translation. This makes it easier for translators to understand the intended meaning and ensure more accurate translations.

For example, instead of using an abbreviated version like btn_next, opt for a more descriptive version such as button_next.

Descriptive translation keys

Maintain consistency

Consistency in key naming conventions across the project is crucial to avoid confusion and simplify maintenance.

Choose a format and stick to it; for instance, use log_in and log_out instead of log_in and logOut.

Organize hierarchically

Organize keys hierarchically to reflect the structure of your application. This helps in maintaining a clear and organized translation file.

Include the page or component name before the actual translation key. For example, login.label_username indicates the label text element in the login component, not in any other place in your app.

Translation keys hierarchy

Avoid over-complicating

Avoid linking keys with placeholders or variables, as this can make translations harder to manage. Instead, include placeholders or variables inside the actual translation.

For instance, use welcome_message translation key with translation Welcome home, {username} instead of translation key including variable: welcome_message\_{username}.

Choose meaningful names

Select meaningful names for translation keys that reflect their purpose and usage in the application. Avoid creating unreadable and undecipherable keys like xyz123.

Enhance readability

Ensure that translation keys are easy to read for everyone by using dots, camel case, or underscores. Additionally, make sure that translation keys are not too long - they will be harder to read.

Instead of errormessageinvalidemail, create error_message_invalid_email or errorMessageInvalidEmail.

Design for scalability

Design keys to accommodate future additions and modifications to the content. Instead of mirroring the original text 1:1, create unique yet descriptive keys.

For example, instead of welcome.search.enter-your-name-or-booking-id-here, create a simple key welcome.search.label. It will work even if the label text changes over time.

Conclusions

By following the best practices outlined above, you can create translation keys that are clear, consistent, and easy to manage, ultimately improving the localization process. For an optimized localization experience, consider integrating a translation management solution like SimpleLocalize into your workflow.
]]></content:encoded>
            <category>json</category>
            <category>developer</category>
            <category>tutorial</category>
            <category>software localization</category>
            <enclosure url="https://simplelocalize.io/blog/best-practices-for-translation-keys.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Cloudflare Workers and Website Localization (1/5)]]></title>
            <link>https://simplelocalize.io/blog/posts/cloudflare-website-localization</link>
            <guid>https://simplelocalize.io/blog/posts/cloudflare-website-localization</guid>
            <pubDate>Tue, 27 Feb 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to localize a static website using Cloudflare Workers and SimpleLocalize, no dependencies required. Works with HTML, React, Vue, and more.]]></description>
            <content:encoded><![CDATA[In this tutorial, we will show you how to use Cloudflare Workers to create a simple website localization feature, without the need to install any additional dependencies.
We will localize a simple static HTML website hosted on GitHub Pages, but you can use the same approach to localize any website, including those built with popular frameworks like React, Angular, or Vue.js.

Let's get started!

Prerequisites

Before you begin, you will need the following:

Cloudflare account

SimpleLocalize account

Basic knowledge of JavaScript and web development

How it works

Cloudflare Worker will act as a proxy between the user and the website. It will intercept incoming requests and serve the appropriate localized content based on the lang query parameter or
use a default language if the lang query parameter is not present. In the further examples, will use the accept-language header to detect the user's preferred language
if the lang query parameter is not present.

proxy

We will use the SimpleLocalize Translation Hosting to fetch the localized content for the website.
SimpleLocalize provides a CDN for translations, so the localized content will be served quickly and efficiently.

Sample website

For the purpose of this tutorial, we will use a simple HTML website with a few strings.
The website has a few strings that need to be localized, and three buttons to switch between languages.

Static HTML website hosted on GitHub Pages

I've added data-i18n-key attribute to the HTML elements that need to be localized, for example:

and buttons to switch between languages:

The way how the keys are created is up to you. You can use any naming convention you like, but it's a good practice to use a hierarchical structure to keep the keys organized.
You can learn more about the best practices for naming keys on our blog post What is a translation key?.

Setting up SimpleLocalize

I already have a SimpleLocalize project with translation keys from the sample website, and auto-translated content into Spanish and Polish.

SimpleLocalize project with translation keys

I've also published the translations to the CDN, so they are available at the following URLs:

https://cdn.simplelocalize.io/{your-project-token}/\_latest/en

https://cdn.simplelocalize.io/{your-project-token}/\_latest/es

https://cdn.simplelocalize.io/{your-project-token}/\_latest/pl

Setting up Cloudflare Workers

First, we need to set up a Cloudflare Worker to handle the localization logic.
You can create a new Worker by navigating to the Workers section in the Cloudflare dashboard and clicking on the "Create application" button
in the "Workers & Pages" section.

Create Cloudflare Worker

Next, you can paste the following code into the Worker editor and replace the placeholders with your project token from SimpleLocalize, default language, and website URL.
The addEventListener function is used to intercept incoming requests.

Let's add two classes to the Worker code: ElementHandler and LangHandler.

The ElementHandler class will be used to replace the content of HTML elements with the localized version, e.g.:

The LangHandler class will be used to set the lang attribute of the HTML element to the specified language.

Next, we need to add the getTranslations function to fetch the localized content from SimpleLocalize based on the specified language key.

Finally, we need to add the handleEvent function to handle incoming requests and serve the appropriate localized content.

You can find the complete code in the Cloudflare Workers and Website Localization repository.

Once you have added the code to the Worker editor, you can click on the "Save and Deploy" button to deploy the Worker to the Cloudflare network.

i18n Cloudflare Worker

Remember that you have to open the website from the Cloudflare domain to see the changes. If you open the website from the original domain, the Worker will not be triggered.
You can also configure Worker routes to match your website domain and path in the "Routes" section of the Cloudflare dashboard. We will cover this in the following tutorials.

Testing the Cloudflare Worker

To test the Cloudflare Worker, you can add the lang query parameter to the URL of your website to specify the desired language.
For example, you can add ?lang=es to the end of the URL to specify Spanish as the desired language.

Triggering CloudFlare Worker to serve localized website

Conclusion

In this tutorial, we showed you how to use Cloudflare Workers to create a simple website localization feature.
We used the lang query parameter to specify the desired language to serve the appropriate version of the website, and SimpleLocalize as a single source of truth for translations.

In the following tutorials, we will show you how to:

extract all i18n keys from the website and upload them to SimpleLocalize,

use the accept-language header to detect the user's preferred language,

use the Cloudflare Workers KV to store and serve the localized content, and

configure Worker routes to match your website domain and path.

Stay tuned for the next tutorials!
]]></content:encoded>
            <category>developer</category>
            <category>cloudflare</category>
            <category>integration</category>
            <category>tutorial</category>
            <enclosure url="https://simplelocalize.io/blog/cloudflare-workers/cloudflare-workers-and-zero-dependency-website-localization.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[What is a translation key? A guide with examples]]></title>
            <link>https://simplelocalize.io/blog/posts/what-is-translation-key</link>
            <guid>https://simplelocalize.io/blog/posts/what-is-translation-key</guid>
            <pubDate>Mon, 26 Feb 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn what is a translation key, how to create them, and how they look like in your project and SimpleLocalize.]]></description>
            <content:encoded><![CDATA[When navigating SimpleLocalize's documentation, pricing page, or the software itself, you'll frequently come across the term 'translation key.' In this blog post, we'll explain what a translation key is, how to create them, and how to manage translation keys in your project. Let's dive in!

What is a translation key?

A translation key is a unique identifier for translations within your project files. Each translation key corresponds to a single text element in your app or website. The content within a translation key can range from a single word to longer text blocks. Using translation keys simplifies the process of creating and managing translations in software development.

A single translation key can be translated into multiple languages, allowing the text inside that key to vary depending on the selected language.

Translation keys and translations

Translation key for developers

Developers can easily identify or create translation keys, as they originate from the source code of the website or application.

The formatting of translation keys varies based on the library used and the internal guidelines for managing them. Here are some examples:

TRANSLATION_KEY

TRANSLATION.KEY

tranlsationKey

tranlsation_key

If your project supports only one language, and you add texts directly into the code of your website or app, the translation key refers to the entire text element. For example, the header or paragraph below:

HTML texts

When using multiple languages, in the translation files in your project, you will find the translation key as a source to identify the translation. For example, below you can see translation keys with translations in English in a JSON file:

JSON file with translation keys and translations

Translation keys in SimpleLocalize

At SimpleLocalize, we love to make things easier. Instead of calculating words or characters to determine your project volume or scope, we count the number of translation keys.

As illustrated below, it's quite straightforward. In the translation editor, all translations assigned to specific translation keys are visible. While they may consist of multiple languages and various lengths, the translation key remains unique.

Translation keys in SimpleLocalize's translation editor

Thanks to that, regardless of the length of your translations or the number of languages you use, the quantity of translation keys remains the same. Naturally, this changes if you create additional translation keys, such as when incorporating new features and texts that necessitate translations.

To determine the SimpleLocalize plan suitable for your project,
simply check how many translation keys your project currently holds.
Opt for the best-fitting plan, and as you add more translation keys,
simply add a pack of extra keys to expand your current plan.

Read our blog post about calculating translation keys in SimpleLocalize.

How to create translation keys?

For optimal clarity and simplicity in translation management, there are some general rules for creating translation keys. While not mandatory, they significantly enhance the ease of use for both developers and translators.

General rules for creating translation keys:

Descriptive and contextual. Translation keys should be self-explanatory and describe the content clearly. For example, GUEST_DETAILS.BIRTHDATE_LABEL. By looking at it, you should know what translation is inside.

Consistent. Maintain consistency in naming conventions and structure of your translation keys. For example, button.next, button.cancel. Keeping the same structure will make it easier to find translation keys and edit translations.

Readable. They should be easy to read and comprehensive for everyone. Use dots, camel case, or underscore to make it easier to visually read the translation key.

Scalable. Design keys to accommodate future additions and modifications to the content. Instead of mirroring the original text 1:1, craft unique yet descriptive keys. For example, instead of welcome.search.enter-your-name-or-booking-id-here, create a simple key welcome.search.label.

Additionally, there are also some other rules applied directly by the translation libraries. For instance, i18next can additionally use namespaces added to translation keys, and translation keys elements must be separated by dots.

Our recommendations for creating translation keys

Besides the general rules, we wanted to share with you some of our 'dos and don'ts' about creating translation keys that can be helpful for getting started:

Don't use spaces. They will make the key harder to read and can be confused with translations.

Don't use special characters.

Create actual translation keys instead of just using existing text from the original language.

Don't use abbreviations - they may be clear for you but not for the translator or another developer.

For buttons or elements that repeat in multiple places, use one general translation key instead of multiple ones that duplicate them.

Don't use unreadable keys, like s0xD2\_#.

Avoid creating too long keys - remember that they must be easy to read.

Whether opting for lowercase, uppercase, dots, or underscores, keep in mind the general rules and our tips for creating translation keys for effective translation management and simpler workflows for your team.

Read more about best practices for translation keys.

For more about translation management, visit our other blog posts or contact us if you have any questions!
]]></content:encoded>
            <category>json</category>
            <category>developer</category>
            <category>tutorial</category>
            <category>software localization</category>
            <enclosure url="https://simplelocalize.io/blog/what-is-translation-key.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Hosted country flags]]></title>
            <link>https://simplelocalize.io/blog/posts/hosted-flag-icons</link>
            <guid>https://simplelocalize.io/blog/posts/hosted-flag-icons</guid>
            <pubDate>Mon, 12 Feb 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Simplify flag management and learn how to keep country flags in sync in your software project with SimpleLocalize.]]></description>
            <content:encoded><![CDATA[Country flags often work as intuitive language indicators within language selectors, improving the overall user experience and interface functionality.
At SimpleLocalize, we understand the importance of seamless integration and visual consistency. That's why we offer hosted country flag icons for effortless integration into your projects, ensuring a cohesive workflow and UI design.

Managing country flags in your software project

Including country flags in software projects can significantly improve the user interface's visual appeal and functionality.
At SimpleLocalize, we streamline this process by using the Flag Icons project, which contains a comprehensive collection of flags in SVG format. We use it to display country flags within the SimpleLocalize user interface.

Starting today, you can seamlessly integrate these flags into your project using the following URL:

Here, {icon} corresponds to the value from your hosted languages resource, which you can access via:

Learn more about getting a language list for your project from Translation Hosting.

Configuring flags

To begin, head to the Languages tab in your project to configure flags.

It's important to note that flags auto-detected by SimpleLocalize won't automatically appear in the \_languages section. Therefore, explicit configuration is required. Be sure to manually select the language flag in each language configuration.

Watch the video tutorial below to learn how to set up flags for your languages:

Setting up flags in the Languages tab

Publishing changes

Once flags are configured, make sure to publish the changes to make them readily available in your project environment.

The publish option updates the hosted translations with newly set-up language flags.

Publishing changes after setting up flags

Integrating flags into your project

With flags configured and changes published, you can now seamlessly integrate them into your project using the icon field's values.

Use flags in your project

Check out sample hosted icons below.

How to make flags look good on every background?

While colorful flags look good by adding vibrancy to your UI, always make sure they remain visually appealing across various backgrounds. For example, flags with light colors may appear washed out on white backgrounds, while darker flags may blend into darker backgrounds.

To address this, consider using the box-shadow property with the inset option, to make the flag look good on every background:

This adjustment won't make the flag colors look different on the edges, but it will enhance its visibility on diverse backgrounds.

How to show flags on white background

For further exploration, have a look at our blog post on alternative flag projects, and you should definitely check out our
World Data Resources for comprehensive flag, country, and language-related data to best suit your project requirements.

Hosted flags and icons

If you are building your custom language selector, then you can check out our blog post about language selectors inspirations,
where we gathered the best examples of language selectors from the web.
]]></content:encoded>
            <category>developer</category>
            <category>ui</category>
            <category>language selector</category>
            <category>design</category>
            <category>designer</category>
            <enclosure url="https://simplelocalize.io/blog/hosted-flag-icons/hosted-flags-and-icons.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[DeepL Glossary in auto-translation: A guide with examples]]></title>
            <link>https://simplelocalize.io/blog/posts/deepl-glossary</link>
            <guid>https://simplelocalize.io/blog/posts/deepl-glossary</guid>
            <pubDate>Thu, 08 Feb 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Improve auto-translation results with DeepL glossaries. Create preferred translations for your language pairs for a consistent and accurate translation.]]></description>
            <content:encoded><![CDATA[Auto-translation is becoming more common, delivering excellent results, especially in software translation. It's also a big help for translators, speeding up their workflow. Translation engines like DeepL offer extra translation features, like glossaries, which further enhance the accuracy and quality of auto-translation.

In this blog post, we will explore DeepL glossaries, learn how to set them up with SimpleLocalize, and see some examples and use cases.

What is a DeepL glossary?

DeepL, a popular translation engine, offers a translation glossary that can help during the auto-translation process. DeepL's translation glossary is a feature designed to improve translation quality by allowing users to specify preferred translations for specific terms.

A glossary consists of predefined translations between a pair of languages: the source language and the target language. It can be just a word or a phrase. DeepL utilizes the glossary during auto-translation, ensuring that it integrates seamlessly into the context of the translated text.

Glossary example - pair of languages

How does the DeepL glossary work?

First, you create a glossary by providing specific translations for terms or phrases you wish DeepL to prioritize during translation.

DeepL includes these preferred translations in its neural network model during training, giving it a better understanding of how to translate those terms in context. When translating text, DeepL considers these preferred translations from your glossary and uses them to choose the most appropriate translation for the given context. This results in more accurate and consistent translations for those terms.

How to create DeepL glossary in SimpleLocalize

To use DeepL glossary in SimpleLocalize auto-translation, first, you need to create preferred translations. Head to your project settings and then to the Glossary tab.

Choose languages for the preferred translation, add the texts, and hit the Create entry button to create a new glossary.

Creating new glossary

And that's it! Once a glossary is created, check if there are no configuration issues, and you are ready to start auto-translations.

Learn how to auto-translate your project.

Glossary setup issues

Before starting auto-translation, make sure there are no issues with your created glossaries.

Glossary setup issues

There are two common issues to watch out for:

The selected language is not supported by DeepL as a glossary language.

Languages currently supported in DeepL glossaries are: Chinese (simplified), Dutch, English, French, German, Italian, Japanese, Polish, Portuguese, Russian, and Spanish.

The selected language lacks auto-translation language setup in the language settings.

To resolve this issue, navigate to the Languages tab in your SimpleLocalize project, choose the language used in the glossary, click Edit, and select the auto-translation language from the list.

Auto-translation language setting

If an existing glossary is not correct, delete the incorrect entry and create a new one.

DeepL glossary usage example

Let's test the DeepL glossary with an example. Suppose we have a website for a hostel named Orange Hostel. We offer a Pillow Menu where guests can select their preferred pillow type.

As you can see, both terms can easily be mistranslated into different languages, affecting the hostel's identity and services.

If we run auto-translation for the below sentence without any glossary, the results will not make sense for our case:

Auto-translation without glossary

Now, let's add glossaries for these translations. We want to maintain Orange Hostel in Polish but use hostal in Spanish. Pillow Menu should be the same accross all languages.

Glossary example

Now, when we auto-translate the text again with created glossaries, we can see a huge difference:

texts are comprehensible, retaining their original meaning,

proper names remain untranslated.

Auto-translation with glossary

This way we can easily auto-translate many phrases, knowing that they will be translated precisely and accurately.

Tip: if you are not seeing a good result of auto-translation, verify whether the translation remains consistent when directly used in the DeepL translator.

Glossary use cases

The glossary feature helps maintain translation accuracy and consistency, especially for:

technical jargon

legal terminology and phrasing

brand-specific terminology, slogans, and product names that should be translated consistently to maintain brand identity across different languages

product, software or app-specific terms and user interface elements

scientific terms and concepts

In summary, DeepL glossaries make auto-translation results better and keep the wording consistent. With DeepL and SimpleLocalize, you can easily set up preferred translations, making sure the translations are accurate.

Using platforms like SimpleLocalize makes managing translations and glossaries easier. Give it a try today to simplify translation management and auto-translation of your projects.
]]></content:encoded>
            <category>deepl</category>
            <category>auto translation</category>
            <category>tutorial</category>
            <category>machine translations</category>
            <enclosure url="https://simplelocalize.io/blog/deepl-glossary.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to find and delete unused translation keys]]></title>
            <link>https://simplelocalize.io/blog/posts/delete-unused-translation-keys</link>
            <guid>https://simplelocalize.io/blog/posts/delete-unused-translation-keys</guid>
            <pubDate>Sun, 21 Jan 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Clean up your translation files by deleting unused translation keys. Find old translation keys and delete them for clear overview of your translations.]]></description>
            <content:encoded><![CDATA[Have you ever experienced the frustration of managing an ever-growing list of translation keys with each software update? As your application evolves, new features are added, and old views may be removed, leading to an expanding translation key list. The challenge arises when old and unused translation keys linger, cluttering your files. Fortunately, SimpleLocalize offers a solution to effortlessly clean up your translation files, ensuring that your keys stay organized with every software update.

What causes clutter in translation keys?

Without a translation management system, it becomes challenging to keep track of translation changes and remove unused keys. Several factors contribute to this clutter, including:

Replacing features without cleaning up: Adding new translation keys without addressing the removal of old ones.

Unused languages: Keeping translations for languages that are no longer supported or needed.

Redundant keys: Sometimes, similar or identical keys might exist across different sections or modules, leading to unnecessary duplication.

Outdated Content: If the source text undergoes changes, but the corresponding translations are not updated, it can lead to outdated and inaccurate translations. Check how you can use Review status to resolve this issue.

Lack of proper management: Absence of a system to track and manage translation changes effectively.

Identify and clean unused translation keys

To tackle the issue of cluttered translation keys, the first step is to distinguish between actively used and unused keys. SimpleLocalize provides an integrated management system, a smart localization workflow, and insights into translations that haven't been used for an extended period.

Upload translations to SimpleLocalize

Start by uploading your all translation keys to SimpleLocalize. Integrate it into your development workflow, whether by manually importing files through the interface, using SimpleLocalize CLI or API for a quick import and easy access.

Importing JSON translation files

Learn more about importing translation files to SimpleLocalize

Last seen date of translations

The last seen date indicates when a translation key was recently updated, whether through modifications or imports. This information is crucial for identifying actively used keys.

Upon deploying new updates, the last seen date is updated for keys included in the upload.

Last seen date

Keys not seen recently are likely no longer in use, and you can identify them easily using the Filters in the translation editor.

Filter translations

Using filetrs you can easily find all translation keys by their last seen date. For instance, you can search for keys last seen before your latest translation upload to identify those that are no longer in use.

Filtering translation keys by last seen date

Delete unused translation keys

Once you've filtered out unused translations, clean up your files by deleting these keys.

Hold Ctrl or ⌘ key on your keyboard and click on any translation key to open Bulk Actions. From there, select all keys or manually choose the ones for deletion and use the Delete keys option.

Deleting unused translation keys

After this cleanup, your exported translations will consist only of keys actively used in your software or website.

Automate translation keys updates

Say goodbye to manual processes by integrating SimpleLocalize into your development workflow. Explore different tools like Translation Hosting for fast CDN access or leverage GitHub Actions integration for an automated workflow encompassing upload and access to your translations.

Thanks to this seamless integration, you can effortlessly identify, find, and delete unused translation keys, optimizing your files and making them more translator-friendly. Keep your translations organized and stay in control of your evolving software with SimpleLocalize.
]]></content:encoded>
            <category>software translation process</category>
            <category>translation management</category>
            <category>tutorial</category>
            <category>continuous-localization</category>
            <enclosure url="https://simplelocalize.io/blog/deleting-unused-translation-keys.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Automate translation updates with review statuses]]></title>
            <link>https://simplelocalize.io/blog/posts/manage-translation-changes-with-review-status</link>
            <guid>https://simplelocalize.io/blog/posts/manage-translation-changes-with-review-status</guid>
            <pubDate>Tue, 19 Dec 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[Automate translation updates with review statuses in SimpleLocalize. Keep translations consistent across languages and versions with less manual effort.]]></description>
            <content:encoded><![CDATA[Keep your translations aligned with the source language, even when things change. Learn how to manage translation updates using review statuses and automations in SimpleLocalize to maintain consistency across all your languages.

Why do translation changes matter?

Every time you change a sentence in your primary language, usually English, you risk introducing inconsistencies across your localized content. Even small edits like rewording a button label or tweaking a product description can leave other language versions outdated or incorrect.

If you're managing a multilingual product, website, or app, this scenario probably sounds familiar:

You correct a typo in the English version of your UI. But your Spanish, French, and German translations still show the old version. You launch an update, and users notice the mismatch.

Translation changes like these can easily slip through the cracks, especially in fast-moving development cycles. That is why it is crucial to track and review translations when the source content changes.

Review status of translations

How SimpleLocalize helps: review statuses

To make translation change tracking easier, SimpleLocalize offers review statuses. This feature lets you mark translations as either:

Accepted - The translation is up-to-date and verified.

Needs Review - The translation may be outdated or needs to be checked by a translator.

You can assign review statuses per translation, per language, or for multiple keys at once using the interface or Bulk Actions.

Review status icon in the translation editor

How to use review statuses to track changes

1\. Set your source language as the reference point

Usually, this will be English or your default application language. Once you've verified those translations, mark them as Accepted.

You can do this quickly using Bulk Actions:

Select all English translations

Click Bulk Actions → Change review status

Set status to Accepted

This tells your team: "These translations are current. Use them as the baseline."

Marking translations as Accepted using Bulk Actions

2\. When you change a translation, mark others as “Needs review”

Every time you update a translation in your source language, it can affect other language versions. With SimpleLocalize, you can:

Manually update review statuses. After changing a string in the default language, click the review status icon to mark translations in other languages as "Needs review."

Use bulk updates. Select affected translation keys and apply status changes across multiple languages.

Use filters. Quickly find translation keys that were recently edited or have status “Needs review.”

Example of changing translation review status

3\. Automate review status updates with rules

To avoid doing it all manually, take advantage of SimpleLocalize Automations. When you update a phrase in your primary language, other languages are automatically marked as Needs Review.

Benefits of automation:

🕒 Save time: No need to manually flag each affected translation.

🎯 Reduce errors: Stay on top of updates and avoid mismatches.

🤝 Improve teamwork: Translators instantly know what needs attention.

For example, you can set up a rule like:
🔁 When a translation in the main language changes, mark the same key in other languages as Needs review.

In this case, when you change the English text: "Arrival time" to just: "Arrival", all corresponding translations in other languages will be automatically marked as Needs Review, signaling translators to verify or update them.

Review status automation

Learn more about automating translation updates in our Automations documentation.

Collaborating with review statuses

Review statuses don't just help with tracking, they are also a collaboration tool.

Here's how:

Translators can filter for “Needs review” translations and focus only on those.

Developers know which content is ready to be published and which is still under review.

Project managers can monitor translation progress and identify languages falling behind.

You can invite team members to collaborate in real time with project roles and permissions, making it easy to divide work between translators and reviewers.

Example workflow: Translation changes with review control

Let's walk through a simple workflow:

Mark all current translations as Accepted.

You update 15 keys in English for a new feature.

An automation rule marks those keys in Spanish, French, and German as Needs review.

Translators filter by “Needs review,” edit and save the new translations.

They mark them as Accepted once reviewed.

Translations are exported or hosted with confidence they're up to date.

Bonus tip: Combine review statuses with version control

You can integrate SimpleLocalize into your CI/CD workflow using the CLI or API. This lets you:

Sync translation files during deployments

Automatically apply review status logic

Keep translations in sync with your codebase

For example, you can configure your build process to update translation files and re-check review statuses before release.

Conclusion

Translation updates don't have to be a guessing game. With SimpleLocalize's review statuses, automatic QA checks and automation rules, you get clear visibility into which translations are current, which need attention, and who should take action next.

It's a straightforward system that brings structure and quality control to your localization workflow, without slowing things down.

Ready to try it out?
Create a free account and start managing translations with confidence.
]]></content:encoded>
            <category>translation management</category>
            <category>tutorial</category>
            <category>continuous-localization</category>
            <category>automation</category>
            <enclosure url="https://simplelocalize.io/blog/review-status.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Get notified about translation changes with SimpleLocalize Webhooks]]></title>
            <link>https://simplelocalize.io/blog/posts/simplelocalize-webhooks</link>
            <guid>https://simplelocalize.io/blog/posts/simplelocalize-webhooks</guid>
            <pubDate>Sat, 02 Dec 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[Improve your translation updates workflow using SimpleLocalize Webhooks and integrations with Slack, Discord and Microsoft Teams.]]></description>
            <content:encoded><![CDATA[Translation management is all about staying up-to-date. But it's not only about keeping translations up-to-date, but also about making sure that your entire team stays in the loop when crucial translation updates take place. That's why SimpleLocalize Webhooks integrate with your software and your Discord and Slack channels, guaranteeing that your team is immediately informed whenever essential translation changes occur.

What are webhooks?

A webhook is a mechanism that allows SimpleLocalize to notify external services or applications, like Slack or Discord, when there are changes in your translation project.

The principle behind webhooks is simple but effective: they dispatch HTTP POST requests to a predefined URL (provided by the external service or application) whenever a certain event occurs. In SimpleLocalize, these events include, for example, the creation, update, or deletion of translation keys, ensuring that any changes in your translation project trigger immediate notifications.

This real-time communication is a game-changer for teams relying on accurate and up-to-date translations. The webhook sends a payload (request content) containing relevant information about the event (e.g., translation publication to the test environment) and the data associated with it. Below you can see a sample webhook payload triggered on publication to testing environment.

How webhooks facilitate communication

Imagine a scenario where a developer makes a crucial translation update. With webhooks in place, this change triggers an instant notification to your team members on Discord or Slack, ensuring everyone is promptly informed.

Webhooks facilitate a more dynamic and responsive workflow, enabling teams to adapt swiftly to changes in translation projects. Whether it's updating translation files, publishing translations, or triggering auto-translations, webhooks automate various aspects of the localization process.

See more use cases for implementing webhooks into your workflow

Setting up webhooks

SimpleLocalize Webhooks can be easily configured from your SimpleLocalize account and integrated with your software, Slack, Discord, or Microsoft Teams. Head to the Settings tab in your project and add a webhook to get notified about your translation updates.

Webhooks configuration

Trigger events

Triggers are events that invoke the webhook's execution. It means that when a certain event occurs, for example, when a translation is changed, SimpleLocalize will send the request with event details to the selected URL.

Triggers that can call SimpleLocalize Webhook are:

Translations change

Translations revert

Publication to latest, production, or custom environment

File import or export

Successful or failed auto-translation

As you can see, you can get notified about all important changes in your translations, and you can choose which events you would like to be notified about.

Default webhook

In the default webhook option, you can enter a custom URL that will receive the webhook request. It's the best option for your internal notifications, reporting, or any workflow.

There are three points to set up your webhook:

Webhook URL - the URL of the webhook endpoint

Request headers — custom webhook headers that will be added to the webhook payload (request content)

Triggers - decide when webhook should be triggered and send notifications

Default webhook configuration

Slack webhook

By enabling webhooks with Slack, Discord, or Microsoft Teams, you can easily and efficiently start automatic notifications about your translations to your team members on your communication channels.

To set up webhooks for Slack, the first step is getting the webhook URL from your Slack account for the selected channel.

Create app for your Slack workspace => Create your Slack app

Activate Incoming Webhooks to allow accepting requests from SimpleLocalize

Add new Webhook to Workspace to generate the webhook for SimpleLocalize

Configuring Slack webhook

Check Slack docs for more information about configuring your webhook URL

Next, paste your webhook URL from Slack to the SimpleLocalize Webhook configuration and choose trigger actions:

Slack webhook configuration

Send test webhook to check if the connection works! Click on the test option to get an instant sample notification on Slack if the setup is correct.

Save the webhook and that's all! You will get a short message on Slack with the update details whenever trigger actions happen.

slack-notification

Discord webhook

If you are communicating with your team using Discord, it's very easy to set up webhooks and notifications about translation updates.

In Discord, go to Edit Channel, and next to Settings. Choose the Webhooks option and click the New Webhook button. Discord will automatically create a webhook for you, so you can just open it to get your webhook URL.

Next, activate the webhook in SimpleLocalize. Choose Discord when adding a new webhook, select notification triggers, and hit the Create webhook button.

Setting up Discord webhook

In less than a minute, you can set up instant notifications about your translation updates!

Use cases

Thanks to SimpleLocalize Webhooks and integration with Slack, Discord, or Microsoft Teams, you can improve and help automate localization workflows with your team by:

Instant team communication. When your development team is busy with a crucial software release and needs a quick translation update, SimpleLocalize Webhooks alert the team on Slack or Discord about the change. This ensures everyone is informed and can adjust their work, avoiding potential delays.

Automated quality checks. Before a big product launch, your QA team needs to validate translations. When translations are published to the testing environment, a webhook automatically notifies QA members, allowing them to focus on testing specific translations and maintaining a high-quality localized product.

Workflow notifications. Webhooks notify team members automatically when translation keys are created, updated, or deleted, streamlining the workflow. Thanks to that, everyone is on the same page and can adjust their tasks without the need for manual communication.

Custom workflow alerts. Using SimpleLocalize's default webhook option, you can integrate notifications into your custom workflow. For instance, set up a webhook to notify your project management tool when translations are successfully auto-translated, promoting transparency and collaboration.

Multi-channel updates. SimpleLocalize Webhooks can send notifications to both Slack and Discord channels simultaneously. This guarantees that, regardless of the preferred communication platform, all team members receive timely updates on translation changes, encouraging cross-channel collaboration.

Conclusion

SimpleLocalize Webhooks ensure your translation team stays instantly updated on crucial changes, fostering smooth collaboration. Whether it's through workflows or notifications on Slack and Discord, these webhooks make translation management easy and efficient. Start using SimpleLocalize Webhooks for a more connected and responsive team experience in your localization projects.

Important links:

Sign up to SimpleLocalize

Docs about all webhook integrations

Contact us and give feedback
]]></content:encoded>
            <category>tutorial</category>
            <category>translation management</category>
            <category>slack</category>
            <category>webhooks</category>
            <category>discord</category>
            <category>developer</category>
            <enclosure url="https://simplelocalize.io/blog/webhooks-slack-discord.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Translation management with&nbsp;Figma plugin]]></title>
            <link>https://simplelocalize.io/blog/posts/localization-with-figma-plugin</link>
            <guid>https://simplelocalize.io/blog/posts/localization-with-figma-plugin</guid>
            <pubDate>Tue, 14 Nov 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[Localize your Figma designs effortlessly with the SimpleLocalize plugin. Manage translations, collaborate with teams, and see your design in multiple languages.]]></description>
            <content:encoded><![CDATA[Efficient localization in design projects is now more critical than ever. Ensuring that your design resonates across languages and cultural contexts is integral to delivering a complete design experience.  In this blog post, we'll explore how your designs can speak every language, thanks to the powerful integration of SimpleLocalize with Figma.

🎨 Figma Plugin for translation management

Localization in design projects

Localization transforms your design into a polyglot that seamlessly adapts to different countries or locations. It goes beyond just a translation; it's about making your design feel at home in different cultures.

Quick start with localization in Figma 🎨

Why localization matters

Localization is the bridge that transforms a design from a universal concept into a personalized experience. It considers cultural nuances, linguistic subtleties, and user preferences, ensuring that your design speaks the language of each user, both literally and metaphorically.

When showcasing your design, the aim is to get as close to the customer as possible and demonstrate how it can be expressed in different languages. Localization of your design makes it possible, and thanks to SimpleLocalize's Figma plugin, you can connect localization and creative design into an effective duo.

Designer challenges:

Designers face numerous puzzles when dealing with the localization of their design projects, making the process complex and time-consuming. Some challenges include:

Linguistic nuances: Translating idioms or cultural references accurately without working closely with translators can be challenging.

Multilingual content design: Balancing content in multiple languages without compromising design integrity requires careful consideration and planning.

Text expansion and contraction: Languages vary not only in words but also in the space those words occupy, posing a layout challenge. What fits perfectly in English might turn into a design puzzle in German or Spanish.

Maintaining consistency across versions: Adjusting and refining designs for different languages while ensuring consistency is a delicate task.

Collaboration with translators: Effective collaboration with translators is key, but conveying design intent and receiving accurate translations can be a communication challenge.

Version control: Keeping track of different versions for each language iteration can become a logistical headache.

The goal when managing designs in different languages is to make the design look as good as possible while maintaining a high level of localization. SimpleLocalize comes to the rescue, simplifying the complex processes and challenges of project localization.

Design localization with SimpleLocalize's Figma plugin

With its user-friendly interface and simple workflows, SimpleLocalize aims to simplify the complex process of adapting designs for global audiences. The integration with Figma, a beloved design tool, creates a harmonious synergy, promising designers a smoother and more efficient workflow.

SimpleLocalize online translation editor

Thanks to the Figma integration with SimpleLocalize, you can:

Manage all your Figma project translations and localization.

Collaborate with a team on project localization.

Share design texts with translators via SimpleLocalize to request translations.

Receive always updated translations for your designs.

Help translators by uploading text screenshots from your design to SimpleLocalize.

Check how designs look in different languages.

Quickly add more languages using the auto-translation feature.

Easily create new localization projects in SimpleLocalize from new Figma designs.

Manage different design and translation projects within the same SimpleLocalize account.

Figma plugin configuration

Getting started is a breeze. If your designs in Figma are ready, integrate them into SimpleLocalize by creating an account and initiating your localization journey.

Create project in SimpleLocalize

Start by creating a new project and adding a name. Next, add your project's existing languages and any other languages you would like to support. At this point, you can invite your team members or translators to assist with the translation management.

Creating project and languages configuration

Learn how to invite team members and translators to your localization project in SimpleLocalize.

Setup Figma plugin

Now, let's set up the SimpleLocalize Figma plugin. Head to Resources, then switch to Plugins and search for SimpleLocalize. Click on it to run the plugin.

SimpleLocalize plugin in Figma Resources

Next, configure the plugin by adding your personal access token generated on SimpleLocalize and choosing which SimpleLocalize project you would like to connect with the opened Figma design.

Creating project and languages configuration

Localize your Figma designs

Once the initial setup is ready, we can get started with actual translations of your Figma designs.

SimpleLocalize plugin settings

Before synchronizing texts from your design with SimpleLocalize, have a look at the plugin configuration. In the Settings tab, you can find some extra options and the rule for creating translation keys.

Synchronization settings

The below synchronization settings are activated by default. You can disable them according to your preferences.

In synchronization with Fimga, SimpleLocalize:

Omits untranslatable elements (e.g., elements with only numbers or symbols).

Omits locked elements; if an element in Figma is locked, it won't be included in SimpleLocalize.

Omits hidden elements.

Includes basic text formatting. E.g., "Hello World" will appear in SimpleLocalize as "Hello \<b>World\<b>".

Uploads screenshots of frames with text elements and key screenshots.

Synchronization settings

Translation key creation

Decide how the translation keys should be created in SimpleLocalize from your text elements. By default, the key format is my-frame.button.continue. For example, the Next button in my design will be created with the translation key welcome.button.next.

You can adjust this configuration by changing the case, separator, using frame as a key namespace, or including the page name.

Key creation settings

Figma: Push translations to SimpleLocalize

And now it's time to synchronize all texts from your Figma design with SimpleLocalize. On Push translations, Figma will send all text elements from your design to your SimpleLocalize project.

Synchronizing translations to SimpleLocalize

You can send only selected elements to SimpleLocalize to test the integration and make sure all texts are created correctly as translation keys. If some were not correct, you can easily delete problematic keys using Bulk Actions.

SimpleLocalize: Add translations

At this point, the texts from Figma are already SimpleLocalize translation editor, so it's time for translation.

You can add translations manually, edit the texts directly in the translation editor, or invite translators to help you with the job. You can also use auto-translation for quick translation.

Auto-translating strings from Figma

Customize the translation editor for more comfortable and effective work.

Figma: Get translations

When your translations are ready in SimpleLocalize, you can now download them to Figma. Click on the Pull translations button to update all texts and available languages.

Pulling translations from SimpleLocalize

Figma: Switch your design language

Now, you can also check how your design looks with texts in different languages. In SimpleLocalize plugin, go to the language selector and try changing the language to another one. See how the texts on your design change.

Getting texts in different languages from SimpleLocalize

Conclusion

In conclusion, the SimpleLocalize Figma plugin is a transformative tool that simplifies the connection between design and localization. Providing a seamless interface and collaborative features ensures that your design not only speaks every language but speaks it well. Get started today and localize your design with ease!
]]></content:encoded>
            <category>tutorial</category>
            <category>translation management</category>
            <category>figma</category>
            <category>design</category>
            <category>ui</category>
            <category>designer</category>
            <category>integration</category>
            <enclosure url="https://simplelocalize.io/blog/figma/figma-localization-plugin.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to manage set of translations and keys with Bulk&nbsp;Actions]]></title>
            <link>https://simplelocalize.io/blog/posts/bulk-actions-updating-multiple-translation-keys</link>
            <guid>https://simplelocalize.io/blog/posts/bulk-actions-updating-multiple-translation-keys</guid>
            <pubDate>Wed, 25 Oct 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[Simplify translation management with SimpleLocalize's Bulk Actions — delete, update, review, or auto-translate multiple keys at once for efficient localization.]]></description>
            <content:encoded><![CDATA[For businesses and projects requiring effective website and application localization, managing translations for many texts can be challenging, especially when dealing with hundreds or thousands of translation keys. SimpleLocalize's Bulk actions feature in our intuitive translation editor streamlines this process, optimizing project localization through a fast and user-friendly tool for batch translation management.

This post will explore the topic of bulk updating translation keys and demonstrate how SimpleLocalize simplifies and accelerates the management of these keys, making the localization process more efficient.

Use cases for bulk translation key changes

If you're wondering whether you need an option to bulk update translation keys, the answer is a resounding yes. Imagine deleting multiple translation keys one by one or removing the entire project due to errors. Simple tasks, like auto-translating selected keys, can turn into headache.

Thanks to Bulk Actions in SimpleLocalize, you can easily:

Delete incorrect translation keys, e.g., if uploaded in an incorrect format or namespace.

Remove unused translation keys.

Mark multiple translations as reviewed and accepted in the selected language.

Auto-translate only selected keys and languages.

Clear translations.

Copy shared translation keys from one project to another.

And much more.

Bulk actions, coupled with translation filters, allow you to update your list of translation keys quickly and effectively, eliminating the need for repetitive and manual tasks.

How to update multiple translation keys?

In this section, we'll explore how to bulk update translation keys in different ways.

Start by opening the Translation Editor to display a list of translation keys. Hold down Ctrl or ⌘ key on your keyboard, select the translation keys you want to adjust, and click the Bulk Actions option.

Selecting multiple translation keys

Use translation filters and search to streamline the process of selecting all filtered-out keys with just one click.

If you would like to apply changes to all translations or to the filtered results only, use the Select all by filter option to mark all filtered translation keys and proceed to Bulk Actions.

Selecting all or filtered out translation keys

Delete multiple translation keys

Once you've selected the keys, use the Delete keys button to remove them from your project. Confirm the action and save the changes. It's that simple!

Deleting selected translation keys

This option is handy for deleting incorrect or unused translation keys.

Clear selected translations

After selecting translation keys, go to Bulk actions and choose the Clear translations feature. This removes translations from selected languages in the chosen keys. Confirm the change by clicking the Clear translations button. The translations will be removed instantly.

Clearing translations from selected keys

If translations are incorrect or need a new translation, clearing them can indicate which translations are not yet done.

Change the review status

While checking translations in List View, you can mark selected translation keys as accepted or not accepted without changing each translation individually.

In Bulk Actions, choose Change review status, select the desired status and language, and click the 'Change review status' button to confirm the change.

Changing selected translations' review status

With Bulk Actions, you can quickly set all default language translations as accepted if you are confident they are correct.

Change or assign a namespace

The namespace is a part of the translation key construction and creates the translation file structure. With Bulk actions, you can change or apply a namespace to selected translation keys or all of them.

Select the keys, open Bulk Actions and choose the Change namespace option. Pick the desired namespace and confirm the change by clicking the 'Change namespace' button.

Assigning a namespace to selected translation keys

If you assigned a namespace by mistake, use the Change namespace option to apply the "No namespace" option and remove namespace from selected translation keys.

Auto-translate selected keys

Auto-translation is an essential feature that speeds up the translation process. If you need to auto-translate a batch of keys, use Bulk actions.

Select the keys and choose Auto-translate from Bulk actions. Pick the language or languages for auto-translation, confirm the translation provider and settings, and click Start auto-translation button. After a few clicks, the translations will be ready for your review.

Auto-translating least translated keys

Use auto-translation if you are unsure how to translate a text; it helps you find a translation, and you can adjust it later for a better fit.

Copy and paste translation keys into another project

When managing different projects with similar translation keys, use the Merge into another project option. It copies and pastes all translations key details and translations to a selected project in SimpleLocalize.

Copying translations into another project

Make sure the source and target projects have the same languages and language codes added for the merge feature to work correctly.

Benefits of using Bulk Actions

As demonstrated in the options and cases described above, Bulk Actions greatly assist in managing multiple translation keys. They contribute to:

Improved efficiency.

Faster updates of translations in the editor.

Enhanced collaboration and review of translations.

Reduced cost for auto-translation when used only for selected keys.

Faster and easier namespace organization.

Easier translation transfer between projects.

Conclusion

Wrapping it up, handling translation keys for multiple texts doesn't have to be a headache anymore. With SimpleLocalize's Bulk actions, managing translations becomes more efficient, collaborative, and organized. Trying out this feature might just be the key to making your translation management hassle-free. Give it a try and see how it transforms your localization workflow!
]]></content:encoded>
            <category>tutorial</category>
            <category>software localization</category>
            <category>translation management</category>
            <enclosure url="https://simplelocalize.io/blog/bulk-actions/updating-multiple-translations-with-bulk-actions.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Getting started: Invite team members and translators]]></title>
            <link>https://simplelocalize.io/blog/posts/invite-team-members-and-translators</link>
            <guid>https://simplelocalize.io/blog/posts/invite-team-members-and-translators</guid>
            <pubDate>Mon, 02 Oct 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to work together using SimpleLocalize! Invite team members, share access, and make localization easy.]]></description>
            <content:encoded><![CDATA[Ready to take your software localization to the next level? Look no further than SimpleLocalize, an easy-to-use and intuitive platform designed to streamline the localization process. In this guide, we'll walk you through the simple steps to invite team members and translators to your SimpleLocalize project. Let's get started!

Collaborate and translate

Collaboration between different teams is the key to successful project localization. With SimpleLocalize, you can work seamlessly with your team members and translators to ensure that your software speaks the language of your target audience. Here's why it matters:

Efficiency: Working together reduces the time and effort needed to translate and maintain multiple languages.

Quality: A diverse team of translators ensures accuracy and cultural sensitivity in your translations.

Scaling: As your project grows, adding more team members and translators becomes effortless.

Sign in to your SimpleLocalize account

If you haven't already done so, sign up for a SimpleLocalize account. You will start with a 14-day free trial and after the free trial, your account will be automatically set to the free Community plan. You can check out the feature comparison for different plans on our pricing page.

Once you're logged in, you'll have access to the dashboard for your localization projects.

Sign up to SimpleLocalize

Create and set up a project

If you're starting from scratch, create a new project by clicking the New project button. If you already have a project set up, click on it to open the project view.

At that point, if you haven't imported your translations, now is the time to import them. See the instructions below to import your existing translation files, or add your translation keys manually.

Add languages to your project

Import your existing translation keys and translations

Dashboard with list of translation projects

Invite team members

Invite your team members: developers, designers, product managers, support team and others involved in the translation and localization process. Invite them directly to specific projects, or grant them access to all your projects as a Team Administrator.

Team administrators

As the Subscription Owner and Team Administrator in SimpleLocalize, you have the power to invite others into the fold. Team administrators gain access to all your projects, including those created by fellow administrators. Here's how to add a new Team Administrator:

Go to your Profile (located in the top right corner)

Open the Team settings - there you will find the list of your current Team administrators.

Click on the Invite team administrator button.

Enter the email address of the team member you wish to invite.

List of Team administrators

The invited user will receive an invitation email. They must accept this invitation to join the team. Until they do, their status will appear as pending in the list of team administrators. Once accepted, they'll have full access to all your projects.

✅ Team administrators are allowed to:

create new projects on behalf of the Subscription owner,

manage translation projects,

invite other project members with Translator or Administrator role.

⛔️ Team administrators are not allowed to:

delete projects,

manage subscription and view invoices,

manage team administrators,

increase auto-translation limit.

Project administrators

Project administrators have access to specific projects, and you can assign them this role directly from the project itself. Administrator rights for project administrators are identical to those of project owners (you). The only distinction between these two roles is that project administrators cannot delete projects.

List of Project members

To invite a project administrator, follow these steps:

Open the project and navigate to the People tab.

In Project members section, click the Invite project member button.

Enter the email address of the team member you want to invite.

Select the user role as an Administator and send the invitation.

Invite new Project member

The invited user will appear in the list of "Pending invitations." They will receive an email containing an invitation link, which they must click to accept. Once they accept the invitation, they will gain access to the project.

Invite Translators

SimpleLocalize offers a robust role-based permission system to ensure that each team member has the appropriate level of access. When inviting Translators, you retain control over the specific access rights granted to them.

By default, translators are granted access to the following project tabs: 'Translations', 'Languages', 'Activity', and 'Data'.

To invite a Translator, follow these steps:

Open the project and navigate to the People tab.

In Project members section, click the Invite project member button.

Enter the email address of the translator you want to invite.

Select the user role as a Translator.

Translator user permissions

Here you can fine-tune the user permissions according to your needs before sending the invitation:

Grant or restrict the ability to add, edit, or delete languages.

Control access to manage translation keys.

Enable or disable the Auto-translation option.

Allow publishing of translations to hosting environment.

Allow import / export of translation files.

Allow access to project Activity.

Additionally, you can precisely specify language access, determining which languages the user can view and edit.

Translator languages access

Once the invitation is sent, the Translator receives an email with an invitation link that provides them with access to your project. They can then start translating based on the permissions you've set up for them.

Share project access with more people

In every project, you have the option to create a shareable access link with specific permissions, including Administrator and Translator roles. This allows you to easily share access to the project with groups of Translators or Volunteers, enabling them to directly access the project and start working on translations.

To generate a shareable access link for your project, go to People tab and click the Get shareable link button.
SimpleLocalize will then generate unique links for each Administrator and Translator role, which you can share publicly with your intended audience or collaborators.

Generate shareable links for project access

You also have the option to reset or delete these links to deactivate any previously shared access.

Managing access and permissions

As the project owner, you have full control over who can do what within your project. Use the role-based permission system to assign specific roles and access levels to team members and translators. This ensures the security and integrity of your project data.

To change user permissions, click on the role in the project members list to change the user settings.

And there you have it - you've successfully invited team members and translators to your SimpleLocalize project! Now you can collaborate efficiently to make your software accessible to a global audience.

Remember, SimpleLocalize is designed to simplify the localization process, so you can focus on building amazing products while we handle the translation intricacies. Happy localizing!
]]></content:encoded>
            <category>software localization</category>
            <category>translation management</category>
            <category>tips</category>
            <category>tutorial</category>
            <enclosure url="https://simplelocalize.io/blog/learn-how-to-work-together-using-simplelocalize.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to share translation keys across multiple apps?]]></title>
            <link>https://simplelocalize.io/blog/posts/translation-keys-database</link>
            <guid>https://simplelocalize.io/blog/posts/translation-keys-database</guid>
            <pubDate>Tue, 05 Sep 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[Easily manage translations across multiple apps with SimpleLocalize's key merging feature. Save time, reduce duplication, and keep your localization consistent.]]></description>
            <content:encoded><![CDATA[Managing translations for multiple apps or websites can quickly become messy, especially when many of them reuse the same UI elements like buttons, menus, and error messages. Manually copying translation keys between projects? That's inefficient and error-prone.

SimpleLocalize makes this easy with powerful features like translation key merging, shared repositories, and even customer-specific contexts. In this guide, you will learn how to keep your translations consistent across apps with minimal manual work.

Common shared translation keys

In the process of translating and localizing apps or websites, there are certain elements and texts that are often shared or similar across different apps and websites. These elements are usually part of the user interface and provide a consistent user experience. Here are some common examples of shared translation keys:

Menu items and navigation: home, settings, profile, logout

Buttons: cancel, save, submit, register

Form fields and labels: name, email, password

Error mssages: invalid_email, required_field, password_too_short

Confirmation messages: account_created, changes_saved, item_deleted

Instead of recreating or importing these into every project manually, you can share them efficiently across projects.

Option 1: Merge translation keys across projects

When translation keys keys are identical in different projects, you would rather not add them manually to each project or import them every time to all the apps. Instead, SimpleLocalize allows you to merge selected keys from one project to another, saving time and avoiding duplication.

How it works:

Each app corresponds to a project in SimpleLocalize. Therefore, you'll create separate projects for each application.

List of translation projects

1\. Import or manage your translation keys to one of the projects, including keys that are shared with other apps. This can act as your main source of truth.

See here how you can import your translations to SimpleLocalize.

2\. In the Translation Editor, select the keys you want to share by holding Ctrl/⌘.

Selecting multiple translation keys

3\. Click on Bulk Actions, and choose Merge into another project option.

4\. Choose the target project and the languages to copy, and then confirm the merge. It's that simple!

Merging translation keys to a different project

✅ This will copy selected translation keys, descriptions, screenshots, and their translations into the other project.

SimpleLocalize will add the selected translation keys along with their translations in the chosen languages to the target project.

All translation key details, such as descriptions and screenshots, will also be transferred.

If a key already exists in the target project, it will be overwritten by the merge option.

Option 2: Create a shared key repository

For teams managing many apps or projects, a scalable approach is to set up a shared translation key project, a centralized place to store common translations.

Shared Key Repository

How to set it up:

Create a new SimpleLocalize project, e.g., Keys Database, that will serve as your shared translation keys repository.

Add commonly used keys to this project only.

Use the Merge function or CLI tools to export/import translations into other apps as needed.

Keep this repo up to date, so changes here can flow to all connected projects.

This way, you can ensure consistency and keep track of where shared translation keys are stored. You'll always know where to make changes and from where to merge them.

This approach is especially useful for large teams or enterprise localization setups. You can also use Translation Memory in your other projects to maintain consistency across all content.

Option 3: Use customer contexts to customize shared translations

If most translation keys are shared, and you only need to tweak a few for specific apps or clients, you can use Customer contexts.

Customer-based organization

In this setup:

All apps share one translation project.

You define a customer (or app) context for each app.

Shared keys are translated once.

Only the keys that differ are customized per context.

When to use it:

90% of your translation keys are the same across projects.

You want one project to maintain everything centrally.

You need per-app or per-customer overrides for just a few strings.

Organize with tags or namespaces in one project

If you prefer to manage everything in one project, use namespaces or tags to distinguish between shared and app-specific keys:

Use common.submit, common.cancel for shared keys.

Use app.home, web.settings for project-specific ones.

Namespace-based organization

This keeps everything tidy and avoids key collisions in one large project.

Conclusion

Managing shared translation keys doesn't need to be messy. With SimpleLocalize's merge and shared project features, you can:

Merge translations across projects.

Centralize shared keys in a dedicated repository.

Customize only where needed using Customer Contexts.

Keep everything clean with namespaces and tags.

Choose the method that fits your team size and complexity best. With the right setup, you will keep translations consistent, reduce duplication, and scale your localization smoothly.

Ready to simplify your localization? Start now with SimpleLocalize.
]]></content:encoded>
            <category>software localization</category>
            <category>translation management</category>
            <category>internationalization</category>
            <category>tips</category>
            <enclosure url="https://simplelocalize.io/blog/shared-translation-keys.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[Translation Hosting: How to update translations automatically?]]></title>
            <link>https://simplelocalize.io/blog/posts/how-to-update-app-translations-automatically</link>
            <guid>https://simplelocalize.io/blog/posts/how-to-update-app-translations-automatically</guid>
            <pubDate>Fri, 18 Aug 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[Save time with automatic translation updates. Try SimpleLocalize Translation Hosting to keep your app's translations up to date effortlessly in any environment.]]></description>
            <content:encoded><![CDATA[In today's globalized world, reaching a diverse audience is essential for the success of your app. Localization plays
a crucial role in this process, allowing you to seamlessly adapt your app's content to different languages and cultures.
However, keeping up with frequent updates and translations can be a time-consuming task. That's where SimpleLocalize
translation hosting comes in. In this blog post, we will explore how to leverage SimpleLocalize to automate the process
of updating app translations and save time on manual updates, making localization a breeze.

The power of localization and translations

Localization plays an important role in reaching a global audience. In a world filled with variety and consideration for cultural differences, adapting your app to different dialects and cultures is crucial.

By localizing your app, you create a personalized experience that resonates with users on a deeper level, establishing trust and increasing user engagement. The process of localization not only removes language barriers but also demonstrates your dedication to recognizing and accommodating the diverse requirements and preferences of various users. It is a powerful tool that can help your app transcend borders and connect with users around the world.

Languages in a localization project

Translation management challenges

Managing app translations manually can pose significant challenges, particularly when dealing with frequent updates. As an app evolves and new features are introduced, the content that requires translation keeps expanding. Coordinating translations across multiple languages can quickly become a time-consuming and error-prone task. Here are some of the most common challenges for handling translation updates:

manual work on updating translation files

tracking changes in translations

ensuring consistency across all language versions

coordinating collaboration with translators

handling version control

maintaining translation quality

These challenges make it clear that relying solely on manual translation management is not sustainable in a fast-paced development environment. That's where translation hosting comes in.

Introducing SimpleLocalize Translation Hosting

Translation hosting simplifies app localization by centralizing and automating the translation management process. SimpleLocalize generates translation files for different environments, such as development, staging, and production. These files are conveniently available through a superfast CDN, allowing seamless integration into your app workflow.

Developers can automatically download updated versions whenever changes are made, eliminating the need for manual updates. See below for more details about SimpleLocalize translation hosting.

Translation hosting feature

How does translation hosting work?

Translation Hosting is a content-delivery network (CDN) that gives you the option to fetch translations in JSON from anywhere with lightning speed and use them without any additional configuration in your project. Here's a breakdown of how translation hosting works:

Automatic translation file generation and updates: When you click the "Publish" button in our translation editor, SimpleLocalize generates translation files in JSON format. These files can be fetched automatically every time your app refreshes, ensuring that you always have the most up-to-date translations without any manual effort.

Fast translation retrieval: With translation hosting, you can effortlessly fetch translations in JSON format from anywhere with remarkable speed. By using the CDN infrastructure, translations are readily available without the need for any complex setups.

Real-time translation updates: Translation hosting allows you to update translations in your app without the need for redeploying your application. All translation messages are loaded directly from the cloud, ensuring that your app always reflects the latest translations.

You can create different translation hosting environments for your project in SimpleLocalize and use different links for your development, staging and production environments, facilitating seamless updates between your various development stages.

By leveraging the translation hosting feature, you can simplify app localization and streamline the process of updating translations in your app. No manual deployments or file uploads are required, and your app always benefits from the most recent translations.

Translation hosting different environments

How much does translation hosting cost?

Translation hosting offers a fast and secure solution for sharing translation files with the public. One of the advantages is that there are no rate limitations, so you can freely make requests without worrying about restrictions. This makes it a reliable choice for client-side applications as well.

Fetching data from Translation Hosting is available in all pricing plans, including the free 'Community' plan. Whether you choose the free plan or opt for a paid plan, you can enjoy the benefits of translation hosting without incurring any additional costs.

To determine the best plan for your project, you can explore the different pricing options available. Each plan offers a range of features and resources to cater to different needs. You can take advantage of the 14-day free trial period to experience the benefits of translation hosting firsthand and evaluate its suitability for your specific requirements.

How are the translations updated automatically?

When using translation hosting, translations are updated automatically without any manual intervention. Whenever a change is made to the translations in the translation editor, clicking the "Publish" button triggers the generation of updated translation files in JSON format. These files are then seamlessly integrated into your app workflow.

Translation hosting schema

With each refresh of your app, the latest version of the translations is automatically fetched from the translation hosting service. This ensures that your app always reflects the most up-to-date translations without requiring developers to manually download and update the files.

Translation hosting streamlines the translation update process, saving time and effort for developers.

Getting started with SimpleLocalize

Getting started with SimpleLocalize is quick and easy. Here's a step-by-step guide to help you get up and running:

Create an Account: Sign up for an account on SimpleLocalize's website. You'll enjoy a 14-day free trial, giving you time to explore and experience all the features.

Upload Your Translations: Once you have an account, you can start uploading your translations to SimpleLocalize. There are multiple methods available for uploading translations, including JSON files, Excel spreadsheets, fetching translations using the CDN, or importing them via the API or CLI.

Translate and Collaborate: Dive into the translation editor within SimpleLocalize. It's a user-friendly interface that lets you effortlessly manage keys, add languages, and even invite translators to join your project.

Set Up Translation Hosting: To take full advantage of SimpleLocalize's translation hosting feature, refer to the detailed instructions in the next section.

By following these steps, you can begin leveraging the powerful features of SimpleLocalize to streamline your localization process and effectively manage your app's translations.

SimpleLocalize translation editor

How to set up Translation Hosting?

When setting up Translation Hosting and integrating it into your existing app workflow, it's important to note that the configuration process may vary slightly depending on the specific library or framework you are using. However, the overall goal remains the same: fetching translations from SimpleLocalize's translation hosting using SimpleLocalize CDN.

Begin by understanding the CDN access options provided by SimpleLocalize. This allows you to fetch translations from selected environments and languages. You can find detailed information on how to access translations via the CDN in the SimpleLocalize documentation.

Check out our step-by-step guide on configuring translation hosting using FormatJS (react-intl) i18n library.

Automating translations with SimpleLocalize

Automating translations with SimpleLocalize is a game-changer for developers. With SimpleLocalize's automatic translation update process, the tedious task of manually updating translations becomes a thing of the past. Here are some compelling benefits of automating app translations with SimpleLocalize:

Saves time by automating the translation update process

Reduces the risk of errors and inconsistencies in translations

Eliminates the need for manual tracking and updating of translation files

Seamless integration of updated translations into the app workflow

Flexibility in retrieving and updating translations through API integrations and CLI tools

Streamlines the localization process for developers

Ensures a consistent and accurate user experience across languages

Increases developer productivity by freeing up time for other tasks

Simplifies the management of translated content in the app

Enhances overall app quality and user satisfaction with up-to-date translations

Translation hosting

Conclusion

With SimpleLocalize translation hosting, updating app translations becomes a seamless and automated process. By integrating SimpleLocalize into your app development workflow, you can save time, improve collaboration, and ensure accurate and up-to-date translations for your global audience.

Remember, the key to success in today's global market is not just reaching users in their own language, but providing an immersive and localized experience that resonates with their cultural nuances. Start automating your app translations with SimpleLocalize and unlock the full potential of your global user base.
]]></content:encoded>
            <category>software localization</category>
            <category>translation management</category>
            <category>internationalization</category>
            <category>translation hosting</category>
            <category>continuous-localization</category>
            <enclosure url="https://simplelocalize.io/blog/intro-to-translation-hosting.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to auto-translate JSON files]]></title>
            <link>https://simplelocalize.io/blog/posts/how-to-auto-translate-json-files</link>
            <guid>https://simplelocalize.io/blog/posts/how-to-auto-translate-json-files</guid>
            <pubDate>Mon, 31 Jul 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[Simplify your localization process by learning how to auto-translate JSON files with SimpleLocalize's translation editor and auto-translation feature.]]></description>
            <content:encoded><![CDATA[If you have ever handled localization for a multilingual app or website, you know that working with translation files, especially JSON, can get tedious fast. Multiple files, missing translations, confusing version histories, and manual updates can turn even simple changes into hours of work.

This guide covers how to use SimpleLocalize to automatically translate JSON files, reduce manual work, and keep your localization organized. It explains each step in the process, from importing files to exporting translated content, along with screenshots and examples.

Check also our quick video guide about auto-translating JSON files:

YouTube video about auto-translating JSON files

Why use JSON files for translations?

JSON (JavaScript Object Notation) is a lightweight data format that's widely used in modern applications. It's especially popular for storing translation strings because:

Human-readable: JSON files are easy to read and edit, making them accessible for developers and translators alike.

Structured: JSON's key-value pairs allow for clear organization of translation strings, making it simple to manage multiple languages.

Compatibility: It integrates well with frontend frameworks like React, Vue, and Angular, which often use JSON for localization.

Widely supported: It works seamlessly with localization libraries like i18next or react-intl, making it a preferred choice for many developers.

But maintaining JSON translation files across many languages isn't easy, especially at scale. That's where a dedicated translation platform like SimpleLocalize helps.

What is SimpleLocalize?

SimpleLocalize is a cloud-based translation management system that helps you organize, translate, and maintain your localization files. It was built for developers to simplify the localization process, and for teams to collaborate on translations efficiently.



With a user-friendly layout, instead of juggling translation files manually or using spreadsheets, you get a dedicated environment to:

Import and export translations

Collaborate with your team and translators (invite your team, add comments and track changes)

Auto-translate missing strings using OpenAI, DeepL, or Google Translate

Review and edit translations with full context (in-context editing, screenshots and more)

Version control to track changes and roll back if needed (backups, automatic snapshots)

Automate workflows with integrations (GitHub, GitLab, CI/CD pipelines) and translation automatinos

Host your translations securely in the cloud with Translation Hosting

Step-by-step: Auto-translate JSON files

Auto-translating JSON files with SimpleLocalize is a quick and convenient way to update missing translations or add new languages to your project. Below, you can find our step-by-step guide for auto-translating your JSON files.

1\. Import your JSON files

Start by creating a project in SimpleLocalize and importing your existing translation files. They will serve as a base for further translations.

You can import single or multi-language JSON files, depending on your project structure.

Single language JSON - each language is an individual JSON file, e.g., en.json, es.json

Multi language JSON - one file contains all translations, e.g., index.json

SimpleLocalize JSON - a format used by SimpleLocalize, which is similar to multi-language JSON but with additional metadata

After import, you'll see your content structured as translation keys with values.

Importing translations from JSON files

2\. Add new languages

Once your translation keys are imported, you can work on the translation in the translation editor and modify existing translations. If you want to add new languages, you can do so in the Languages tab.

Click the Add language button, select the languages you want to add, and hit Add. You can also set a default language for your project.

Adding languages to the project

3\. Auto-translate missing content

With your new languages added, it's time to auto-translate.

Still in the Languages tab, click Auto-translate all. This will fill in missing translations for all languages using machine translation services powered by OpenAI, DeepL, or Google Translate.

Depending on the number of strings, it may take a few seconds to a minute. You'll see a confirmation once it's complete.

Auto-translating existing and new languages

You can choose which translation provider you prefer and review translations before finalizing.

It is also possible to auto-translate only specific languages or translation keys. Learn more about auto-translation in our docs.

4\. Review and edit translations

After auto-translating, use the Translation Editor to review, tweak, and improve translations. You'll see the original key, the translated value, and even translation context to help with accuracy.

SimpleLocalize translation editor

Key features in the editor:

Edit translations directly in the browser

Customize the editor layout to fit your workflow

See where each key appears in your app (use screenshots or in-context editing)

Track changes and revert if needed in the Activity tab

Add comments for team discussions

Work with collaborators in real time

Mark translations as reviewed or approved

5\. Export translated JSON files

Once your translations are ready, export them in the JSON format your app uses. Go to the Data tab and choose your JSON file format in the Export translations section.

SimpleLocalize supports multiple file formats, so you can customize the output to match your framework or backend.

Exporting translated JSON files

You can also export only selected translations. Just filter the keys you want to export, and then click the Export button directly in the Translation Editor.

This way, you have added new languages and translated them in just a few minutes. Sounds easy, right?

Recap: From JSON upload to translated files

To summarize, here are the steps to auto-translate JSON files with SimpleLocalize:

| Step | Description |
| --- | --- |
| 1. Import | Upload your existing JSON files |
| 2. Add languages | Define new languages for your project |
| 3. Auto-translate | Use AI services to generate translations |
| 4. Review & edit | Fine-tune translations in the editor |
| 5. Export | Download translated files in your preferred format |

Frequently asked questions (FAQ)

Can I use my own translation memory?

SimpleLocalize allows you to reuse existing translations across projects and offers a backup/restore feature to manage version history. If you would like to use your own translation memory, contact us at contact@simplelocalize.io.

How accurate is the auto-translation?

Machine translation quality has improved drastically in recent years. While it may not be perfect for nuanced or legal text, it's excellent for UI strings, error messages, and general-purpose app content. Human review is still recommended for production use.

How do I switch translation providers?

You can choose your preferred provider in the language settings. SimpleLocalize supports OpenAI, DeepL, and Google Translate. You can also configure API keys for each service.

Is this suitable for mobile apps?

Yes! You can import/export in JSON or other formats (like iOS .strings or Android .xml), depending on your needs.

Do I need a paid plan for auto-translation?

You don't need a subscription to use the auto-translation feature, but you will need to purchase translation credits to use machine translation services. You can find more details in our pricing section.
Every paid plan includes a certain number of translation credits, which you can use for auto-translation.

Conclusion

Localizing your product doesn't have to be painful. With SimpleLocalize, you can cut down on repetitive translation work, automate updates across multiple languages, and keep everything organized in one place.

If your team deals with internationalization, give it a try.
Start your first translation project today →
]]></content:encoded>
            <category>json</category>
            <category>developer</category>
            <category>tutorial</category>
            <category>software localization</category>
            <category>openai</category>
            <category>chatgpt</category>
            <enclosure url="https://simplelocalize.io/blog/how-to-auto-translate-json-files.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to get started with a Translation Management System (TMS)]]></title>
            <link>https://simplelocalize.io/blog/posts/how-to-get-started-with-tms</link>
            <guid>https://simplelocalize.io/blog/posts/how-to-get-started-with-tms</guid>
            <pubDate>Tue, 27 Jun 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to get started with a Translation Management System (TMS) and set up an efficient localization workflow using SimpleLocalize as an example.]]></description>
            <content:encoded><![CDATA[As soon as a product needs to support more than one language, translation quickly becomes a workflow problem, not just a linguistic one. Files get out of sync, keys go missing, and updates become harder to track. This is where a Translation Management System (TMS) becomes essential.

In this guide, you'll learn what a TMS is, when you need one, and how to get started step by step using SimpleLocalize as a practical example.

What is a Translation Management System (TMS)?

A Translation Management System (TMS) is a tool that helps teams manage, update, and deliver translations across software products, websites, and applications.

A TMS acts as a central hub for:

translation keys and text

multiple languages and locales

collaboration between developers and translators

versioning and updates

Instead of sending files back and forth or editing translations manually, a TMS keeps everything organized and connected to your development workflow.

Check out more details about translation management.

When do you need a TMS?

You will benefit from a TMS if:

your product supports more than one language

translations change frequently

developers and translators work asynchronously

you want to automate updates instead of copying files manually

Even small projects often reach this point sooner than expected.

Benefits of using a TMS

Using a TMS like SimpleLocalize brings practical advantages:

Centralized translation management

Better translation quality

Faster localization cycles

Scalability

Collaboration

What is SimpleLocalize?

SimpleLocalize is an online Translation Management System designed for software and web localization. It focuses on simplicity, automation, and smooth integration with development workflows.

SimpleLocalize translation editor

Key capabilities include:

cloud-based translation editor

support for common localization file formats

automatic key syncing via CLI or API

translation hosting and delivery

access control for team members

backups and versioning

integration options (CLI, API, webhooks, GitHub, Webflow etc.)

Getting started with a TMS using SimpleLocalize

1\. Create an account

Start by creating an account in SimpleLocalize. New accounts begin with a 14-day Team plan trial, allowing you to test all features. After that, you can continue with a free plan for small projects.

Sign-up page

View pricing and plans.

2\. Create a project and add languages

After signing in, create your first project. A project groups:

translation keys

supported languages

integration settings

Choose the languages you want to support; you can always add more later.

Adding languages

3\. Import existing translations (optional)

If you already have translations, you can import them directly. SimpleLocalize supports formats such as:

JSON (single- and multi-language)

CSV, XLSX

YAML, XML, PO

XLIFF, RESX

and more...

Check the full list of supported file formats.

You can import translations via:

file upload

CLI

API

upload using integrations (e.g., GitHub, Figma etc.)

Importing translations from JSON file

Tip: Instead of uploading translation files, you can start by adding a few custom keys and translate them for a quick test.

4\. Translate content using the editor

Once your project is set up, translations are managed in the cloud editor. The editor allows you to:

edit translations inline

use keyboard shortcuts

switch between list and table views

add descriptions and screenshots for context

check QA issues

apply review statuses

add comments for collaboration

and much more!

Context helps translators understand where text appears in the product, which improves quality and consistency.

Translation editor settings

Learn how to get started with the translation editor.

5\. Auto-translate content (optional)

SimpleLocalize includes auto-translation powered by engines such as OpenAI, DeepL, and Google Translate. You can also connect your own API keys for these services and use different LLM models through OpenRouter integration.

You can:

auto-translate individual keys

translate all missing keys in a language

use machine translation as a starting point for human review

Auto-translate feature in SimpleLocalize

Learn more about the auto-translation tool.

6\. Export or deliver translations

Once translations are ready, you can:

export files in your required format

sync translations automatically using CLI or API

host translations and deliver them dynamically

Exporting translation files

This removes the need for manual copying and keeps your app in sync with translation updates.

YouTube: Import and export translation files video

Managing translations over time

After the initial setup, you will need to manage translations as your product evolves. SimpleLocalize provides tools to help with this:

Translation keys, context, and screenshots

Keys can be added manually or synced automatically from code. You can attach:

descriptions

screenshots

namespaces

tags

This helps translators understand usage and prevents errors.

In the translation editor, you add translation keys manually. There may be multiple translation keys with translations in the selected language at once, and you can even assign them a namespace.

Creating translation keys

Backups and version control

Localization changes over time. SimpleLocalize allows you to:

create manual backups

restore previous versions

copy translations between projects

Additionally, it creates automatic snapshots of your project before major changes, such as bulk imports or auto-translations.

List of project backups

Learn more about backups.

Integrating a TMS into your workflow

CLI

Webhooks

API

Integrations

Conclusion

A Translation Management System helps teams move from manual, error-prone translation handling to a scalable localization workflow. With a TMS like SimpleLocalize, translations become part of your development process, not a bottleneck.

If you are just starting with localization or looking to improve an existing workflow, setting up a TMS is one of the most impactful steps you can take.

Ready to get started? Create your SimpleLocalize account today!
]]></content:encoded>
            <category>internationalization</category>
            <category>translation management</category>
            <category>tutorial</category>
            <category>software localization</category>
            <enclosure url="https://simplelocalize.io/blog/what-is-tms.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[Keyboard shortcuts for Translation Editor]]></title>
            <link>https://simplelocalize.io/blog/posts/translation-editor-keyboard-shortcuts</link>
            <guid>https://simplelocalize.io/blog/posts/translation-editor-keyboard-shortcuts</guid>
            <pubDate>Thu, 16 Mar 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to use the Translation Editor keyboard shortcuts to speed up your translation workflow with SimpleLocalize.]]></description>
            <content:encoded><![CDATA[If you're a novice or experienced SimpleLocalize user,
mastering keyboard shortcuts for frequently used actions can significantly enhance your productivity.
To simplify the translation process, we have compiled a list of the most useful SimpleLocalize keyboard shortcuts that you'll use regularly.
These shortcuts include frequently used actions and features that are likely to be part of your workflow.

Note: macOS users should use the ⌘ button instead of Ctrl.

Save changes

You can save your changes by clicking the Save button in the Translation Editor. You can also use the keyboard shortcut Ctrl + s to save your changes.

Saving changes using keyboard shortcuts

Open create translation dialog

You can open the Create Translation dialog by clicking the Ctrl + . button. This dialog allows you to create a new translation key and add translations for it.

Open Assistant

You can open the Assistant by clicking the Ctrl + k button. The Assistant provides helpful suggestions and tips to improve your translations.

Go to next/previous string

Moving from one translation to another is standard during the translation process. To make it faster, you can use the Tab and Shift + Tab buttons to go to the next or previous string.

Going to next or previous translation using keyboard shortcuts

Go to next/previous string within the same language

You can use the Ctrl + Enter and Ctrl + Shift + Enter buttons to go to the next or previous string for translation key in the same language.

Going to next or previous translation within the same language using keyboard shortcuts

Move around the table

Now you can move around the table without touching the mouse. Here is a table with shortcuts:

| Shortcut                        | Action                                           |
|---------------------------------|--------------------------------------------------|
| Tab                  | Go to the next string                            |
| Shift + Tab          | Go to the previous string                        |
| Ctrl + Enter         | Go to the next string with the same language     |
| Ctrl + Shift + Enter | Go to the previous string with the same language |

Moving around the translation editor table using keyboard shortcuts

Open row with translations

Do you want to quickly check translations or description in List View? Use the Enter button to open the selected row with translations.
You can also quickly jump into the translation input by clicking the Tab button.

Opening a row with translation details using keyboard shortcuts

Delete translation key

Do you need to delete a translation key? You can click on the row and use Delete or Backspace buttons to delete the selected translation key.
After deleting the translation key, the translation editor will automatically select the next translation key.

Deleting translation keys using keyboard shortcuts

Select multiple translation keys with mouse

Select multiple translation keys by holding down the Ctrl button and clicking on the translation keys.

Selecting multiple translation keys by clicking on them with 'Ctrl' button

Select multiple translation keys with keyboard

Don't want to use the mouse? You can also select multiple translation keys with the keyboard. Use the Space button to select multiple translation keys.

Selecting multiple translation keys by clicking a 'Space' button

Focus on search input

You can use the Ctrl + f button to focus on the search input.
After focusing on the search input, you can start typing to search for translation keys and translations

Change review status for all translations

You can change the review status for all translations within the selected language by holding the Shift button and clicking on the review status icon.
]]></content:encoded>
            <category>translation management</category>
            <category>tips</category>
            <category>software localization</category>
            <enclosure url="https://simplelocalize.io/blog/translation-editor-keyboard-shortcuts.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Flags in language selectors: Why they may hurt UX in 2025]]></title>
            <link>https://simplelocalize.io/blog/posts/flags-as-language-in-language-selector</link>
            <guid>https://simplelocalize.io/blog/posts/flags-as-language-in-language-selector</guid>
            <pubDate>Tue, 14 Mar 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[Flags in language selectors often cause confusion and cultural issues. Learn why and explore best practices and accessibility-focused alternatives for language representation in UI design.]]></description>
            <content:encoded><![CDATA[It is becoming increasingly rare to see flags in language lists on many websites. Instead, we see a written list of languages, either in their original writing or in English. Flags seem to be disappearing from website UIs. And you, have you added flags to the language selector in your application?

People have become more aware of language inclusion issues, so using flags to display languages has become less popular than just a few years ago. It is also an interesting UI vs. UX issue: flags look nice, but they may insult some users. In this blog post, we will explore the issue of language representation in selectors from different perspectives and review some alternatives and best practices.

For a deeper dive into how language selectors can impact user experience and how to design them effectively, check out our dedicated post on language selector UX.

Language selectors and language representation issue

With the increasing globalization of the internet, language selectors are becoming an essential tool to make sure that a website is accessible to all audiences. They allow users to select a language they’re comfortable with, improving accessibility and enhancing the user experience. But choosing the right language selector and deciding where to put it on a website isn't as easy as it sounds.

Language selectors are often represented by flags, which can be problematic. Flags represent a country and not necessarily the language spoken in that country. This can lead to confusion and misunderstanding when it comes to representing different languages.

For example, Spanish is spoken in many countries, but the Spanish flag represents only Spain. The language is used in Chile, Argentina, Mexico and many other countries. Why should the Spanish flag represent Mexicans, Chileans, or other Spanish speakers who don't identify with Spain? Similarly, French is spoken in multiple countries, but the French flag only represents France. How do Canadians and Belgians feel about their language represented by the French flag?

Image showing different countries with Spanish language / flag

Flags don't accurately represent languages and can lead to miscommunication between people from different countries who speak the same language. However, they are still in use and have many votes in favor, as they simplify the language selection and simply look nice. But, is this enough of an excuse? Let's go deeper and analyze the pros and cons of using flags to represent languages.

Pros of using flags in language selectors

Flags have long been used as a way of representing cultures and languages around the world. While flags can be a powerful symbol of identity and pride, they can also be controversial due to their potential to cause political divisions.

Here are some of the pros of using flags as language representation in language selectors:

Flags are easy to understand

Flags are seen instantly

Flags save space

Below you can read more about each of these pros.

Pros: Flags are easy to understand

Flags are a powerful and universal, iconic language representation. They represent nations, countries, states, cultures, and ideologies in an easy-to-understand way. Their simplicity makes them easy to remember and recognize, which makes them an effective way to represent language in any format. When entering a website with the United Kingdom, Spain and German flags, users instantly know what languages the website supports.

Sample language selector with language flags

Pros: Flags are seen instantly

Without flags as indicators, it can be more difficult to find the language selector. The flag icons are immediately associated with the option to select languages, so when the users see the flag, they immediately know where they can change the language on the site. Flag icons are more visual than the language name or code in written form.

Pros: Flags save space

Flags offer a compact, efficient way to represent multiple languages, especially on websites or software interfaces where space is limited. A little round or rectangular icon will tell the user which language they are choosing and show all the languages available.

Cons of using flags in language selectors

While flags can be a powerful symbol of identity and pride, they can also be controversial due to their potential to cause political divisions. Here are some of the cons of using flags as language representation in language selectors:

Flags can cause misrepresentation

Flag icons are limited

Using a flag as a representation of a language can be seen as cultural insensitivity

Flags add to the language inclusion problem

Flags unite but also divide people

Cons: Flags can cause misrepresentation

Flags are ubiquitous symbols of national pride, but when it comes to representing languages, they can be severely misleading. While many countries share the same flag, each may have a diverse collection of languages spoken within its borders. This means that simply relying on flags to represent language can lead to oversimplifications and even misunderstandings of the complexities of global communication.

Cons: Flag icons are limited

Flags only represent countries, so there is no flag to represent languages that are spoken in multiple countries or regions. Furthermore, there are no flags to represent some non-official or semi-official languages, for example, Marathi (used in India), Corsican or Cherokee. Naturally, we can try using a region flag, but what about people who use that language but don't identify with a region or country, or live in entirely different locations?

Cons: Using a flag as a representation of a language can be seen as cultural insensitivity

Some flags may carry negative cultural or historical associations, so using them to represent a language can be insensitive or offensive to some users.

For example, using the Spanish flag to represent the Spanish language can be culturally insensitive because it may be seen as ignoring the other official languages spoken in Spain, such as Catalan, Basque, and Galician. These languages have their own distinct cultures and histories and are important to the people who speak them.

Furthermore, it can also be connected to Spain's historical colonization and conquest of much of Central and South America. The use of the Spanish flag to represent the Spanish language in Mexico or Argentina may be particularly sensitive due to the country's history of colonization and subjugation under Spanish rule.

Cons: Flags add to the language inclusion problem

Some languages, such as indigenous languages or dialects, may not have a recognized or official flag, so using flags may exclude certain languages or cultures.

Flags often carry political or historical connotations that may be sensitive or offensive to certain groups of people. For example, the use of the Chinese flag to represent the Mandarin language can be controversial in Taiwan, where Mandarin is also spoken but the Taiwanese flag is more appropriate.

In some countries, multiple languages may be spoken, but using a single flag to represent the entire country's language can exclude or downplay the importance of minority languages.

Cons: Flags unite but also divide people

On one hand, flags can unite people under a shared banner and create a sense of pride in their common language. On the other hand, flags can also be used to divide people and exclude those who don't fit into a particular category.

Flags as language selectors and UX

By displaying the flag of the user's language, it can enhance the user experience and make it easier for them to find content in their preferred language. On the other hand, however, they can generate negative emotions for visitors who are unfamiliar with the language or culture associated with a certain flag. The use of flags as language representation can lead to confusion and misunderstanding, which can ultimately affect the user experience.

Paradoxically, a visually cleaner and more appealing UI that uses flag icons for language selection may actually lead to poorer UX and overall worsen the experience of using the site.

Alternatives to flag icons for international sites

When it comes to designing language selectors for international sites, many designers tend to rely on flag icons to represent different languages. However, as discussed above, this approach may not always be the best choice, so it is important to consider alternative options for language selectors.

For a complete breakdown, check our language selector best practices guide.

Use language names

Using language names in their native scripts or using simple text labels may be the best and the simplest option. Users should be able to easily find the language name in its native script. Additionally, to make it easier for the user, order the list of languages alphabetically.

Language selector with language names

Use neutral, universal icons

Another option for language selectors is to use culturally neutral icons or symbols that are universally recognized, such as a globe, a book, or a speech bubble. They will look nice and won't cause misunderstandings.

Language selector with universal icons

Use language codes instead of flags

This option clearly shows the differences between languages, without causing unnecessary friction. Use Spanish for Spain as es_ES, es_CL for Chile, es_CO for Colombia, ca for Catalan etc. Language codes are more widely recognized and understood than flags. This not only makes the language selector more accessible, but also helps to avoid any potential confusion or offense.

Use language name and country flag together

An interesting option is to use both the flag icon and the language name together. The language name represents the actual language used for translations, and the flag will work as a visual country indication for where the language is used the most.

LanguageTool - language switcher

If you're looking for lightweight, customizable icons, check out our hosted flag icons library for modern flag sets.

Apply language automatically for user's region

By applying language automatically to the user's region, you can create a seamless and personalized user experience. This not only saves time for the user, but also makes the website more accessible and user-friendly. However, note that not all users are fans of automatic localization, they might prefer to read the site content in English rather than in the language used in their region.

In this case, make sure the option to switch language is accessible and easy to find!

Make language selector accessible

This is an essential topic when creating a language selector. Make sure that the language selector is easily accessible and prominently placed on the website. This not only makes it easier for visitors to navigate the site but also shows that you value inclusivity and diversity.

By making the language selector accessible and easy to find, you can attract a wider audience and improve the user experience for all visitors. Follow WCAG accessibility standards when designing your language selector to ensure it's usable for all users.

Example of placement of language selector in website's footer

Read more in our post on localization and accessibility.

Is it time to move away from flag representation?

The language selector is a crucial feature for websites with a global audience. However, the traditional way of displaying language options through flags may not be the most effective method.

The use of flags can often lead to confusion and misinterpretation, particularly if the flag does not match the language of the user. Moreover, flags are typically associated with countries rather than languages, which can lead to cultural insensitivity. This is especially relevant when it comes to languages that are spoken in multiple countries, such as English or Spanish.

Alternative methods may be more effective in ensuring accurate language selection. Overall, it may be time for businesses to reconsider their use of flag representation in language selectors and explore alternative options that are more user-friendly and culturally sensitive.

In SimpleLocalize, we gave our users an option to choose the language representation method for languages in our i18n translation editor. Languages always have their name or language code which defines the language best, but it is also possible to use flags for language representation or use a generic icon and just the language key.

Flag and language icon options in SimpleLocalize languages

Our advice: Be practical and consider how users who speak different languages will experience your site. If you offer a service for European countries and your customer base is in Europe, and your website is translated into just a few languages, it will be probably ok to use the Spanish flag for the Spanish language, and the UK flag for English. The flag can indicate that written English on this site is English as written in the United Kingdom, or Spanish is Castilian Spanish.

What is important, is that you are here because you are creating or considering creating a language selector on your website or app. Providing multilingual, localized content for your audience shows that you care about your users and customers.

Localization is the key for happy customers and growing businesses, so think about getting SimpleLocalize to help you in this process and assist you in your daily work with your software translations. Register now and use our software created for simple translation management.

Best practices for language selectors

As the web continues to evolve, so do the expectations around accessibility and design. Here are a few updated best practices for building inclusive, user-friendly language selectors:

Avoid relying solely on flags. While visually appealing, they fail to represent languages accurately and can cause confusion.

Make accessibility a priority. Use clear focus indicators, keyboard navigation, and ARIA roles.

Support user preferences. Auto-detect location but always let users switch easily.

Use native language names. Present language names in their own script, like “Français” instead of “French”.

Combine visuals + text. For improved UX, show both language name and icon (optional flag, globe, etc.).

See our updated guides on UI localization best practices and localization & accessibility for more insights.

FAQs about flags in language selectors

Q: Is it okay to use flags in language selectors?

A: It's not recommended, as flags represent countries, not languages, and may confuse or offend users.

Q: What are the alternatives to flag icons?

A: Use native language names, language codes, or neutral icons like a globe.

Q: Are language selectors important for accessibility?

A: Absolutely. A poor language selector can make your site harder to use for international or disabled users.
]]></content:encoded>
            <category>ui</category>
            <category>language selector</category>
            <category>design</category>
            <category>designer</category>
            <enclosure url="https://simplelocalize.io/blog/language-flags.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Country flag icons: Free & paid resources for developers]]></title>
            <link>https://simplelocalize.io/blog/posts/list-of-country-flag-icon-projects</link>
            <guid>https://simplelocalize.io/blog/posts/list-of-country-flag-icon-projects</guid>
            <pubDate>Fri, 10 Mar 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[xplore the best country flag icon libraries for developers and designers in 2025. Compare SVG, emoji, GIF, and React-ready options, free and paid.]]></description>
            <content:encoded><![CDATA[Looking to add country flags to your website, app, or language selector? This 2025 update highlights the top free and paid country flag icon libraries for developers and designers. From React components and inline SVGs to emoji flags and CDN-hosted options, this guide compares the most practical solutions for modern UI projects. Each library is reviewed for integration ease, customization, and format support, helping you choose the best fit for your workflow.

I omitted projects that are just wrappers around other listed libraries as they tend to be outdated and not maintained.

Looking for a quick side-by-side comparison? Visit the country flags page to see how different libraries render flags in a real UI.

Country flag projects comparison

Quick overview: Flag icon options

First, let's take a look at the available options for country flag icons in 2025. Below is a table summarizing the most popular libraries and their features:

| Library | Format | React support | CDN | License | Style |
| --- | --- | --- | --- | --- | --- |
| Flag-icons | SVG + CSS | ⚠️ Indirect | ✅ | MIT | Classic/Accurate |
| Circle-flags | SVG (Stylized) | ✅ | ✅ | MIT | Round/Minimalist |
| FlagCDN | SVG/PNG/JPG/WebP | ❌ | ✅ | Free | Basic/Versatile |
| React-world-flags | Inline SVG | ✅ | ❌ | MIT | Accurate/Lightweight |
| FlagKit | PNG/SVG | ✅ (Apple) | ❌ | MIT | High-res/iOS ready |
| WorldData GIFs | GIF | ❌ | ❌ | Paid | Retro/Animated |
| Emoji flags | Unicode | ⚠️ Platform-based | ❌ | Free | Native Emoji |

Flag-icons: SVG flags with CSS support

Flag-icons is a collection of all country flags in SVG format, styled using CSS classes.
Sourced from Wikipedia, it supports 4x3 and 1x1 aspect ratios.

flag icons project

Installation

You can install the library using npm:

Usage

To use the flags in your project, you need to import the CSS file:

Then, you can use the flags in your HTML or JSX like this:

fi is the base flag class,

fis forces a square aspect ratio,

fi-{country_code} shows the country (e.g., fi-us for the USA).

Flags are identified by lowercase two-letter ISO 3166-1 alpha-2 codes ({COUNTRY_CODE}), such as fi-pl for Poland or fi-br for Brazil. This library is a great choice if you need accurate representations of flags with CSS support.

Circle-flags: Round SVG flags

Circle-flags offers a stylized set of circular SVG flags.
These aren't pixel-perfect representations (they are simplified), but they work beautifully in tight UI layouts.

circle-flags project

You can hotlink directly:

The project uses only two-letter ISO 3166-1 codes for country codes.

Or install the package via npm:

React support: react-circle-flags

The library also includes language and locale flags: language flags directory.

FlagCDN: Free hosted flag API

FlagCDN is a free content delivery network offering flags in SVG, PNG, JPG, and WebP formats. Ideal for projects needing reliable hosting without bundling images.

Flags are available in multiple sizes:

waving flags in 4:3 aspect ratio (e.g., 16x12, 32x24)

width-based flags (e.g., w20, w40, w80)

height-based flags (e.g., h20, h24, h40)

Example usage:

FlagCDN project

React-world-flags: Inline SVG components

React-world-flags offers inline SVG rendering for country flags using a simple React component. Supports multiple country code formats: Alpha-2, Alpha-3, and numeric.

Installation:

Usage example:

This renders flags as inline SVGs with no external CSS or CDN needed, ensuring they scale well and look sharp on all devices. The height prop allows you to control the size easily.

React World Flags

FlagKit: High-res icons for iOS & web

FlagKit offers beautifully designed SVG and PNG flags for every country. Ideal for iOS/macOS developers thanks to its Asset Catalog and integration with Apple frameworks.

You'll get flags as individual files or bundled assets.

Flags by FlagKit for iOS developers

WorldData.info: Retro GIF flags

If your project calls for a vintage aesthetic, WorldData.info offers a set of 249 retro-styled GIF flags (190x114 pixels). You can download them for €8 and use them in your project.

These aren't modern, but they suit certain creative applications well.

WorldData retro GIF flags

Emoji flags: Unicode-based country flags

Emoji flags are supported natively by most modern systems and require no images or dependencies.

Example:

You can use them in your project by simply copying and pasting the flag from the list below.
However, emoji rendering varies by platform and may display differently across devices.

Emoji flags

You can fetch emoji-based country data with:

Each entry contains a flag property you can use directly.

The JSON contains a list of countries with emoji flags in the flag property.

Choosing the right flag icon library

Each flag library serves a different use case:

Need CDN hosting? → FlagCDN

React app with inline SVG? → React-world-flags

Small-space UI with visual uniformity? → Circle-flags

Design-heavy Apple apps? → FlagKit

Classic SVG with CSS? → Flag-icons

Retro look? → WorldData GIFs

Lightweight and native? → Emoji flags

When choosing a library, consider:

Format: SVG is best for scalability, while PNG/JPG/WebP are good for static images.

React support: If you're using React, look for libraries with components.

Customization: Some libraries allow you to style flags with CSS, while others are fixed.

Hosting: If you prefer not to bundle images, use a CDN like FlagCDN.

License: Ensure the library's license fits your project's needs.

Related articles on language selectors and flags

Check out these related articles for more insights on using flags in language selectors and UI design:

Should you use flags in language selectors? — A critical look at the pros and cons of using flags to represent languages.

How to create a language selector with Next.js and Tailwind — A step-by-step guide with code examples.

How to host flag icons yourself — Learn how to self-host flags for better performance and control.

Top language selector UX examples — A collection of well-designed language selectors to inspire your UI.

Why localizing your website is key to accessibility — Understand the importance of localization and how it improves user experience.

Conclusion

Choosing the right flag icon set depends on your tech stack, design goals, and performance needs. This updated 2025 guide ensures you're not relying on outdated wrappers or libraries. For more details and real-world previews, check out the full flag library demo.
]]></content:encoded>
            <category>developer</category>
            <category>ui</category>
            <category>language selector</category>
            <category>design</category>
            <category>designer</category>
            <enclosure url="https://simplelocalize.io/blog/country-flags/collection-of-country-flags-for-your-software-project.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to create a language selector with Tailwind CSS]]></title>
            <link>https://simplelocalize.io/blog/posts/create-language-selector-with-nextjs-and-tailwind</link>
            <guid>https://simplelocalize.io/blog/posts/create-language-selector-with-nextjs-and-tailwind</guid>
            <pubDate>Thu, 09 Mar 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to create a language selector for your website easily using Tailwind CSS. Follow our step-by-step guide for seamless localization.]]></description>
            <content:encoded><![CDATA[If you want to jump straight to the code, you can find it on GitHub,
and the most important part is in the src/components/LanguageSelector.tsx.
However, we recommend reading the whole article to understand how exactly building a language selector works.

The article assumes that you have some basic knowledge of React and Tailwind CSS.
We also assume that you already configured Next.js, Tailwind and any internationalization library in your project.

For a very long time, SimpleLocalize was not showing flags next to languages in our languages' lists because we wanted to avoid making it wrong. We did not want to assume that a language is always associated with a country.
However, eventually, we have decided that flags are a must because they highly improve user experience and translation performance;
it is far easier to just look at the flag and determine the language this way instead of reading the language name.

Languages with flags in SimpleLocalize

Recently, we also started getting many requests from our users to add flags to the Translation Hosting or
add an option to download them, mostly for the need of using them in language selectors.
In response, we would like to share our solution. We are going to show you how to create a language selector with flags using Tailwind CSS.

What are we going to build?

We will create a language selector that allows users to switch between different languages.
The language selector will be a dropdown that will show a flag next to each language.
For that purpose, we will use Tailwind as CSS framework, Next.js as a React framework, react-i18next package
for translations of our mini app, and flag-icons package for flags.

Language selector demo with Tailwind

Get country flags

We will start by creating a component that will display a flag for a given country. We will use the
lipis/flag-icons package to show flags.

First, install the package using npm or yarn.

Let's now import the CSS in \_app.tsx from the node_modules and we are ready to use the flags.

The usage of the library is straightforward, and it looks as follows:

Use the fi class to display a flag,

use the fis class to display a flag in a square,

and the fi-{COUNTRY_CODE} class to display a flag for a given country.

{COUNTRY_CODE} is always a two-letter country code (ISO 3166), for example pl for Poland.
Letters are always lowercase. Below, you can see a list of all available country codes and their flags from the package.

SimpleLocalize flags page

See the full list of flags.

Build a language selector

Now that we have a component that displays a flag, we can create a language selector component.
We will use the useTranslation hook from the react-i18next package to get the list of languages and the current language.

Fetch application languages

We will start by fetching the list of languages from the SimpleLocalize CDN. We will use the \_languages endpoint to get the list of languages.
However, it is optional, as you can also hard-code the list of languages in your application.

Let us create a new state variable called languages and use useEffect hook to fetch a list of available languages from the CDN using fetch API.
But you can use any other HTTP client library you prefer, like axios, superagent or useQuery.

Configure outside click handler

Whenever we click outside the language selector, we want to close it. We will use the useEffect hook to add a click handler to the window object.

In this example, we use the closest method to find the closest parent element that matches the selector.

Add selected language button

Now that we have all the necessary data, we can create the language selector. We will start by creating a button that will display the selected language.
We will use i18n.language to get the currently selected language for the app to find the language object for the selected language key.
Language object will be used to display the flag and the name of the language.

Language selector button

FlagIcon component is a wrapper around the span element that displays the flag. It's useful because we can override a flag for a given language.

The svg element is used to display the chevron icon that indicates whether the dropdown is open or not.
You can extract it later into a separate component or use any other icon of your preference.

onClick handler will toggle the dropdown.

id attribute will be used to identify the button for the outside click handler.

Add language selector dropdown

Now we can create the language selector dropdown that will appear when isOpen state is set to true and load inside the list of languages based on the languages state variable.
We used grid grid-cols-2 gap-2 classes to display the list of languages in two columns.
We also used rounded-r and rounded-l classes to round the corners of right and left language entries.

Language selector dropdown

Ready to use language selector

In this tutorial, we created a language selector component that uses flags to represent languages.
We used the react-i18next package to get the list of languages, the current language and translate our mini application.

With those few steps, we created a language selector that can be used in any React application.

Tailwind language selector demo

Our tips for creating a language selector

Building a language selector is not a trivial task. There are many things to consider,
and we will share some of our tips that we learned while building many language selectors over the years.

Languages don't have flags

Remember that the country's flag might not be the best option to represent a language.
For example, the flag of the United Kingdom is used to represent English, but it is also used to represent Welsh, Scottish Gaelic, and Cornish.
However, flags are a good option if you plan to support only a few languages, so they will not overlap with the countries. They also look nice and are easy to understand.

Learn more about pros and cons of using flags in language selectors.

White parts of flags can be problematic

Some flags have a white part, which can be problematic when used on a light background. In this tutorial, we solved this
by setting an inset border on the flag, to make it stand out from the background.

The inset border is a box-shadow property, which makes it appear inside the element.
Look how the Polish, French and Italian flags are looking with and without the inset border.

add box-shadow with inset for flags

It will make the white part stand out from the background and will not affect the rest of our flags significantly.

Complex flags in small sizes might look bad

Some flags are more complex than others. For example, the flag of Spain has a coat of arms in the middle.
In this case, we can use a simple trick to make it look good. We can use a background-size property to make the flag smaller.

Complex flags icon problem

In small sizes, the coat of arms is not visible, and it does not look as good as other flags. All flags are in SVG format, so we can adjust them to our needs.
But note that altering flags is not always a good idea because it can be considered as a violation of the flag code.

Country codes are always lowercase

Country codes are always lowercase. This is important because flag-icons package uses lowercase country codes in the CSS class names.
Remembering about this can save you a lot of time because you will not have to debug why your flags are not showing up. 😉

Flag icons CSS

More language selector inspiration

If you are looking for real-world inspiration or want to explore different UX patterns and design approaches, check out our curated guide:

Language selector examples and UX tips

I hope this tutorial was helpful, and you learned something new. Thanks for reading!
]]></content:encoded>
            <category>developer</category>
            <category>ui</category>
            <category>language selector</category>
            <category>design</category>
            <category>designer</category>
            <enclosure url="https://simplelocalize.io/blog/tailwind-language-selector.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[SimpleLocalize: Tips & Tricks]]></title>
            <link>https://simplelocalize.io/blog/posts/simplelocalize-tips-and-tricks</link>
            <guid>https://simplelocalize.io/blog/posts/simplelocalize-tips-and-tricks</guid>
            <pubDate>Tue, 07 Mar 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn our tips for using SimpleLocalize. Take advantage of the i18n editor's capabilities, automate the translation process and localize your software.]]></description>
            <content:encoded><![CDATA[Localization is an important part of any software development project. With SimpleLocalize, you can easily localize your application and make sure that it is accessible to users all over the world. In this article, we'll share with you our tips and tricks on using SimpleLocalize. So if you are looking for ways to improve your localization process, then read on!

SimpleLocalize provides an in-app localization tools and interface designed with the goal of simplifying the localization process for everyone involved, from developers to translators. It will guide you through the localization of your app and stand by your side when reaching new clients.

Below, you can find our list of tips and tricks for efficient and effective work with translations in SimpleLocalize. These are some tips for the UI adjustments that help you customize the translation layout and adjust it to your preferences. Besides, we have some tips for developers regarding translation hosting or project translation versioning. Let's go!

Hide the top bar on the project page

Translation can be a challenging job. It requires knowledge, precision, and an understanding of not only words and grammar, but also context, culture, and people. When facing a problematic term or phrase, sometimes you need to delve into the work or phrase and forget everything else.

SimpleLocalize comes to help you to focus on your work. Open the app in full screen and work on translations only. Use the option to hide the top bar on the project page to view translations in full size.
It is a good option if you don't use the top bar a lot and want to clear up your workspace.

Hide top bar option in settings

View comparison with and without top bar

Auto-translation: exclusions

Automatic translation is one of the most used features of SimpleLocalize. As useful and easy it is to translate our texts automatically, the translation services like Google Translate or DeepL do not know everything nor read our minds (so far).

They can greatly help in translating software, yet we need to indicate them which parts we do not want them to translate. Chunks of code, given names or even our project name: these elements we do not want to change to other languages, they would lose their function and meaning.
By default, SimpleLocalize excludes variables from auto-translation (e.g., {firstName} or %{count}), but you can also change the brackets used for variable exclusion in project settings.

Additionally, you can exclude selected words or whole phrases from automatic translation. Put there your project name or any given name you use, to make sure it won't be translated to another language!

Exclude words from auto-translation

Incorporate webhooks to store translations on your hosting

There is no better nor easier way to automate the translation management workflow than using webhooks. Incorporating webhooks with SimpleLocalize allows for automatic updates of translations stored on your hosting platform.

By setting up a webhook in SimpleLocalize and configuring it to trigger on translation updates, the hosting platform can be updated with the latest translations without manual intervention. This ensures that your application always displays the most up-to-date translations.

Add webhooks for your project in the Settings tab to take full advantage of translation automation. Get notified, update or read translations and let SimpleLocalize work for you with webhook automations.

Webhooks sample setup

Version projects using backups

SimpleLocalize allows you to create different versions of your translation projects and store them in the cloud for easy access. This way, you can always track the changes made to each version so that you know exactly when something has been updated or modified. You can also quickly restore any version with just a few clicks, making sure that all your translations are up-to-date and accurate.

Create a backup of the current translation status for your project and name it with your version. It will help you to identify the project status. Use it for regular versioning, e.g., 2.1.0, or use it for creating different translation versions for your customers' specific needs.

translation project backup list

Restore the selected version with one click to apply it to the existing project or create a new project from it without unneeded copying of project files.

restore translation project version

Change language order

A simple yet significant change for translators. If you (like me) find it hard to work with not ordered lists, this easy option will make your life complete and balanced.

After importing translations to SimpleLocalize, you can find languages in different order. If it bothers you, then fear no more. Go to the Languages tab and simply drag and drop the languages in the list to the desired order.

Change languages order

Now, the languages will appear in selected order in all views. Now you can work and translate in peace of mind. ☀️

Keyboard shortcuts

Keyboard shortcuts are a great way to speed up your work.
They allow you to perform actions without having to use your mouse.
SimpleLocalize has a few keyboard shortcuts that can help you work faster and more efficiently.

Check out our keyboard shortcuts blog post to learn how to use them.

Going to next or previous translation within the same language using keyboard shortcuts

Final thoughts

We hope that these tips and tricks will help you to improve your localization workflow and make it more efficient.
If you have any questions or suggestions, feel free to contact us at contact@simplelocalize.io.

Remember to check this post regularly as we will be updating it with new tips and tricks!
]]></content:encoded>
            <category>tips</category>
            <category>i18n</category>
            <category>developer</category>
            <category>translators</category>
            <enclosure url="https://simplelocalize.io/blog/tips-and-tricks-for-simplelocalize-translation-management.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[ICU message format: Guide to plurals, dates & localization syntax]]></title>
            <link>https://simplelocalize.io/blog/posts/what-is-icu</link>
            <guid>https://simplelocalize.io/blog/posts/what-is-icu</guid>
            <pubDate>Thu, 02 Feb 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn ICU message formatting with real-world examples for plurals, numbers, dates, and more. Understand how ICU improves software localization and translation quality.]]></description>
            <content:encoded><![CDATA[ICU message format is the standard way developers handle plurals, dates, numbers, and other localized text in software. It's part of the internationalization (i18n) toolkit that ensures your messages are grammatically correct, culturally accurate, and easy to translate, no matter the language or region. By using ICU, you can avoid common localization bugs like “1 rooms” or incorrect date formats, while keeping translations consistent across all platforms.

Used by Google, Microsoft, and countless frameworks like React Intl and Angular, ICU allows you to define all variations of a message in one place, making life easier for both developers and translators.

Quick start: ICU in one minute

Here's an ICU message format example that handles plurals:

Why this matters for localization

Plural rules are applied automatically for each locale.

Translators see all variations in one place, so no missing forms.

The same syntax works for dates, numbers, gender forms, and more.

Want to learn ICU step-by-step? Scroll down for syntax, examples and localization tips.

What is ICU?

International Components for Unicode (ICU) is an open-source, cross-platform library that supports Unicode and global text handling.

ICU is widely used in software development to ensure that applications can work with text in multiple languages, formats, and scripts, supporting different format numbers, dates, times, currencies, and other locale-sensitive data.

Created in 1999 by Taligent (later acquired by IBM), ICU was designed to address the complexity of building software for multiple languages and cultural rules.
Today, it's used by Google, Microsoft, Amazon, Apple, Oracle, Adobe, and many others.

How does it work?

ICU provides APIs and data to convert, search, compare, and format text in any supported language.
By combining Unicode (a universal text encoding system) with ICU's locale data, you can build applications that adapt naturally to any script or writing system.

ICU covers all text and language related issues like:

date and time formatting

number formatting

currency formatting

pluralization

gender-specific forms

custom variables

sorting and searching text

Download ICU from GitHub repository and read the documentation.

Problems ICU solves

Without ICU, localization is harder and error-prone:

Hard-coded plurals (“1 rooms” problem)

Date/number formats that confuse users

Gender-specific language errors

Inconsistent translation files

ICU solves these issues by providing a standardized way to handle text formatting, pluralization, and other language-specific features. It allows developers to create messages that adapt to the user's locale, ensuring that translations are accurate and culturally appropriate.

Check our blog on best practices for software localization for more tips on how to improve your i18n process and localization quality.

What is Locale?

Locale defines the user's language, region, and cultural conventions. It is used to format and display text, dates, numbers, and other data in a way that is appropriate for a specific region or culture. For example, the date format and currency symbol used in the United States is different from that used in Spain.

Locale affects:

Date and time formats

Number and currency style

Text sorting and comparison rules

It differs from the Language which is a more general term that refers to the language itself, without any specific regional or cultural context. For example, "English" is a language, while "en_US" is a locale that specifies English as spoken in the United States.

For detailed resources check ICU documentation for Locale and our blog post about differences between language and locale.

ICU Messages Formatting syntax

Messages are user-visible texts that may contain both static text and variable elements (names, dates, numbers, etc.). ICU's MessageFormat class uses curly braces { } for variables, with optional formatting instructions.

General pattern:

variable is the name of the variable to be formatted

type specifies the type of formatting (e.g., date, number, plural, select)

format is the specific style or rule to be applied to the variable

ICU variables

In ICU, variables let you insert dynamic content,like numbers, dates, or names, into messages. They are defined with the MessageFormat class, which makes translations adapt to different conditions.

A simple variable without formatting works for fixed grammar, but can break in other languages:

To handle grammar rules such as plurals, you can add ICU formatting directly to the variable:

This ensures messages follow language rules for every locale.

Plurals

Pluralization rules vary depending on the language, and its grammar. The rules are different in English, Polish, or Arabic - for different locales.

For example, English has two forms: one and other.
Polish adds few and sometimes more, while Arabic has even more variations.
You can explore each language's rules in the Unicode CLDR specs.

In ICU, the plural argument selects the correct sub-message based on a number and the locale's plural rules.

Syntax for plural messages is:

Where forms are the plural categories for that language.

Example in English and Polish:

Tip: The other form is always required, it's your fallback for unexpected values.

This format gives translators all plural cases for a language, ensuring accuracy in every locale.

Select

The ICU select format lets you choose different message variants based on the value of a variable, typically a string or keyword. This is useful for handling cases like gender, status, or other categorical data where the message changes depending on the value.

The syntax looks like this:

Example:

if bookedRoom is dorm, it shows "a bed in dorm room"

if bookedRoom is private, it shows "a private room"

if bookedRoom is anything else, it defaults to "a room"

Combining plurals and select

ICU messages let you combine plural and select formats to handle complex variations in your messages based on multiple variables.
For complex cases, nest plural inside select (recommended order).

Here's an example that combines both plural and select formats:

It shows how to handle complex messages with multiple variables:

Use select for gender-specific forms (her/his/their).

Use plural for different numbers of guests.

Nest these formats to cover all variations in one message.

This structure keeps messages clear and easy to translate, even for complicated cases.

Number formatting

The way numbers are formatted can vary depending on the language and country. It applies to different aspects of
displaying numerical values, like:

decimal formatting (thousand separator, rounding)

currencies

measurement units

percentages (placement of the % symbol)

scientific notations

compact notation

ICU provides a powerful way to format numbers using the NumberFormat class, which allows you to format numbers according to the conventions of a specific locale.

Syntax:

Where format covers all number formats.

Common ICU NumberFormat formats are integer, currency and percent.

For more examples, details, and tips regarding number formatting, check Jakub's blog post about number formatting in JavaScript.

Note: ICU uses the Unicode CLDR data to provide locale-specific number formatting rules. This means that the same number can be formatted differently depending on the user's locale settings.

Date and Time Formatting

Date and time formats vary widely across countries. They differ in separators, order, and the way days, months, and years are displayed.

For example, most European countries use the format DD/MM/YYYY, while in the US and Canada, MM/DD/YYYY is common. So, September 2nd, 2023 can be written as either 02/09/2023 or 09/02/2023. This difference can confuse users if your software doesn't adjust to their local conventions. That's why localizing date and time formats properly is essential for international applications.

See the ICU date symbols table for all date patterns and syntax.

In ICU, the DateFormat class formats dates and times according to the rules of a specific locale. It is an abstract base class used for this purpose.

Syntax:

Where format is the specific date or time format you want to use.

ICU offers four standard date formats:

short, e.g., 2/9/23

medium, e.g., Sept. 2nd, 2023

long, e.g., September 2nd, 2023

full, e.g., Saturday, September 2nd, 2023 AD

For time, ICU provides these default formats:

short: 9:30 AM

long: 9:30:28 AM

full: 9:30:28 AM CET

Here’s an example of date formatting in action:

ICU vs other formats

ICU message format is widely used in software localization, but there are other formats that can be used for similar purposes.

| Feature | ICU Message Format | Fluent | FormatJS | i18next |
|---------|---------------------|--------|----------|---------|
| Plural support | Yes | Yes | Yes | Yes |
| Gender/select support | Yes | Yes | Yes | Partial (via plugins) |
| Adoption | Very high | Low | High | Very high |
| Ecosystem/Plugins | Medium | Low | Medium | Very high |
| Learning curve | Medium | High | Medium | Low |

Notes:

ICU Message Format is perfect for complex plural/gender/date/number formatting

Fluent focuses on readability and natural language patterns

FormatJS with react-intl builds on ICU for JavaScript frameworks

i18next is a popular i18n framework for JavaScript and beyond, often combined with ICU formatting via plugins for richer syntax

ICU Message Syntax Tester

To test ICU message syntax, you can use the ICU Message Syntax Tester. It is a tool that allows you to test ICU message syntax and see how it will be formatted in different languages.

You can enter a message with ICU syntax and see how it will be formatted for different locales. This can help you ensure that your ICU messages are formatted correctly and will display correctly in different languages.

Try it here

ICU Message Syntax Tester screenshot

Conclusion

To sum up, ICU is a powerful library that provides support for the world's languages, scripts, and locales. It provides a set of APIs and data files that enable applications to work with any language. ICU helps applications to display text correctly in different languages, formats date and time according to local custom, and sort text according to local conventions.

Key benefits of ICU include:

Unicode support: Handles text consistently across many languages and scripts.

Extensive locale data: Offers rich locale-specific information like date, number, and language formats.

Platform-independent: Works across multiple platforms and languages, making integration easy.

Robust and Reliable: Widely used and maintained by the Unicode Consortium, ensuring robustness.

Customizable: Allows tailoring of locale data to meet specific needs.

Together, these features make ICU an essential tool for developers who want to internationalize and localize software efficiently and accurately.

Working with i18n content

Software localization brings many challenges for all involved teams, from developers, to translators and managers. The
main issue is usually localization quality.

Using ICU messages for multilingual content helps address this by providing detailed context and coverage of language variations. This leads to higher translation quality and better user satisfaction.

SimpleLocalize simplifies translation management with developer-friendly tools and easy integrations. It automates workflows and offers a centralized platform for your entire team.

SimpleLocalize translation management platform

Get started for free and import your translation files to get started with translation management.

Useful links

For more information about ICU, you can check the following resources:

ICU official homepage or GitHub repository

ICU documentation

Unicode CLDR specs

Number formatting in JavaScript

ICU date symbols table

ICU Message Syntax Tester

Java internationalization guide

FAQs

What is ICU message format used for?

ICU message format is used to create text that automatically adapts to different languages, grammatical rules, and formatting conventions. It handles plurals, genders, dates, numbers, and more—ensuring translations work for every locale.

Do I always need to include other in plural rules?

Yes. The other category is mandatory in ICU plural formatting because it acts as a fallback for numbers that don't match other specified rules.

How is ICU different from libraries like i18next or Fluent?

ICU is a formatting standard, it defines how messages should be structured. Libraries like i18next or Fluent are i18n frameworks that may use ICU internally or have their own syntax for translations.

Can ICU handle gender-specific translations?

Yes. ICU's select syntax lets you choose message variations based on gender, role, or any other fixed set of values.

How do I test my ICU messages?

You can use online ICU syntax testers, such as SimpleLocalize ICU Tester, to preview how messages will look in different languages.

Is ICU only for JavaScript?

No. ICU is available in many languages, including Java, C/C++, and via wrappers for Python, PHP, and others.

What's the difference between locale and language in ICU?

A language is just the spoken language (e.g., English), while a locale includes the region and formatting rules (e.g., en_US for U.S. English vs. en_GB for British English).

Where can I find plural rules for my language?

All plural rules are defined in the Unicode CLDR specifications, which ICU uses internally.
]]></content:encoded>
            <category>developer</category>
            <category>javascript</category>
            <category>i18n</category>
            <category>localization</category>
            <category>icu</category>
            <enclosure url="https://simplelocalize.io/blog/icu-unicode.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Java 24: Internationalization]]></title>
            <link>https://simplelocalize.io/blog/posts/java-internationalization</link>
            <guid>https://simplelocalize.io/blog/posts/java-internationalization</guid>
            <pubDate>Sat, 19 Nov 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how Java 24 handles internationalization and localization using `Locale`, `ResourceBundle`, and formatting for dates, numbers, and currencies.]]></description>
            <content:encoded><![CDATA[Introduction

In this article, we will learn how to use Java 24's internationalization features to format dates, numbers, and work with localized content.
We will explore the java.text package, the java.time package, and learn how to use ResourceBundle for retrieving localized messages.
This guide includes practical tips for Java developers building internationalized applications.

Java 24 note: This version includes improved Unicode support, enhanced formatting capabilities, and better performance for internationalization operations. Make sure you're using the latest JDK for optimal i18n performance.

Locale class changes

Since Java 19, all constructors of the Locale class have been deprecated.
Instead, you should use the Locale.of static constructors to create a new Locale instance
or use the Locale.Builder class to create a new Locale instance.

Number formatting

The NumberFormat class offers a number of methods for returning different instances for formatting numbers.

getPercentInstance(Locale) - formats numbers as percentages.

getCurrencyInstance(Locale) - formats numbers as currency values.

getIntegerInstance(Locale) - formats numbers as integers.

getNumberInstance(Locale) - formats numbers as general-purpose numbers.

getCompactNumberInstance(Locale, NumberFormat.Style) - formats numbers as compact numbers.

Percentage formatting

Different countries use different symbols for percentages. For example, in the US, the percentage symbol is %, while in the UK, it is £.

Long numbers formatting

Compact numbers are a method of formatting numbers in a more compact way. For example, instead of writing 1,000,000
you can write 1M.
They are useful when you want to display a large number in a small space. Every locale has its own set of compact
numbers. There are 4 different styles of compact numbers:

NumberFormat.Style.SHORT - the shortest form of the compact number. For example, 1M for 1,000,000.

NumberFormat.Style.LONG - the longest form of the compact number. For example, 1 million for 1,000,000.

Numbers formatting

The NumberFormat class provides a number of methods for formatting numbers.

Money formatting

Currency formatting is useful when you want to display a number as a currency value. For example, instead of joining
currency symbol and number you can use the NumberFormat instance which does it for you in the best possible way,
taking into account the locale.

Note that different locales use different symbols for decimal separators and grouping separators. For example, in the US, the decimal separator is ., while in Poland and France, it is ,.

Symbols and currencies

NumberFormat are powerful tool, but what if you want to display a currency symbol or a decimal separator? You can use the DecimalFormatSymbols class to get the symbols for a given locale.

Note that we took Polish currency (złoty polski) and Locale.FRANCE and Java returned the French name of the currency (zloty polonais).
If we took Locale.US and Polish currency, Java returned the English name of the currency (Polish zloty).

Returning symbols works in the same way:

The DecimalFormatSymbols class provides a set of symbols (such as the currency symbol) that are used to format numbers.

Date formatting

After previous sections, you should be familiar with formatting values using getXXXInstance methods and Locale
objects. You shouldn't be surprised if I tell you that dates formatting works the same way!

The DateFormat class provides a number of methods for formatting date and time.

getDateTimeInstance(int dateStyle, int timeStyle, Locale locale) - returns a DateFormat instance that formats dates and times.

getDateInstance(int dateStyle, Locale locale) - returns a DateFormat instance that formats dates.

getTimeInstance(int timeStyle, Locale locale) - returns a DateFormat instance that formats times.

All methods need a style of date or time and locale. The DateFormat class provides a number of constants for formatting dates and times, there are 4 main styles:

DateFormat.SHORT - the shortest form of the date or time.

DateFormat.MEDIUM - the medium form of the date or time.

DateFormat.LONG - the longest form of the date or time.

DateFormat.FULL - the full form of the date or time.

Time has been automatically converted to the local time zone in the first line, where we passed local time and converted it into the UTC time zone.

Getting messages from resource bundles

The ResourceBundle class is a collection of key-value pairs. The keys are strings and the values are objects. The ResourceBundle class provides a number of methods for getting values from the bundle.

getString(String key) - returns a string for the given key.

getObject(String key) - returns an object for the given key.

getKeys() - returns an Enumeration of the keys contained in this ResourceBundle and its parent bundles.

Put the following content in the src/main/resources/messages_pl_PL.properties file.

Now, we can read the messages using ResourceBundle object.

As you can see, the title message contains a placeholder {0}. We can use the MessageFormat class to replace the placeholder with a value.

One of the advantages of using ResourceBundle instead just reading from text files is that it supports inheritance.
You can create a bundle that extends another bundle. In this case, the ResourceBundle class will look for the key in the current bundle and if it doesn't find it, it will look for it in the parent bundle.

String normalization

Normalization is the process of converting a string to a normalized form. The java.text.Normalizer class provides a number of methods for normalizing strings.

The Normalizer.Form class provides a number of constants for normalization forms.

Normalizer.Form.NFC - Canonical decomposition, followed by canonical composition.

Normalizer.Form.NFD - Canonical decomposition.

Normalizer.Form.NFKC - Compatibility decomposition, followed by canonical composition.

Normalizer.Form.NFKD - Compatibility decomposition.

What is canonical and compatibility decomposition?

In simple words, not technical and unprofessional words, it means that the string with diacritics will be converted to the string without diacritics.
Normalizer splits the string into a sequence of characters and then combines them into a new string without diacritics.

When else might it be useful? When you work with strings that contain special characters, you should normalize them
before comparing them. Or you want to normalize half-width to full-width characters. Half-width characters are common in
Japanese and Chinese languages, and they were used before the computer era.

Java localization updates

Looking up Default Locale

In Java 21, you can display the default locale using the java -XshowSettings:locale command.
This command displays the default locale and the supported locales based on the system settings.

It's a good way of debugging issues related to localization be verifying whihc locale the JVM is using by default.

Changing the default locale

You can change the default locale using the java.util.Locale.setDefault method.

Swedish language updates

Collation rules have been updated in Java 21 for the Swedish language to distinguish between v and w

Old rules: va, wb, vc

New rules: va, vc, wb

Old rules are still available with Locale.forLanguageTag("sv-co-u-trad") in case you need them.

The collation rules, also known as collating rules or sorting rules, are a set of guidelines or algorithms used to determine the order in which characters are sorted and compared in a given language or character set.

Tzdata & CLDR update

Java 21 includes updates to the timezone data and locale data:

The Common Locale Data Repository (CLDR) has been updated to version 41 in Java 21.

The CLDR is a repository of locale data used by many software systems, including Java.

The tzdata has been updated to version 2023c in Java 21.

Tips and tricks

Regardless of the Java version you are using, there are some tips and tricks that can help you with internationalization and localization in Java.

Handle missing translations

Provide fallback mechanisms for missing translations:

Cache NumberFormat and DateFormat Instances

Creating formatter instances is expensive. Cache them for better performance:

Use Locale-aware string operations

Be careful with string operations that depend on locale:

In Turkish, the letter I is not converted to i but to ı, which is a dotless i. This behaviour is described in Java docs for String.toLowerCase.

Format classes are not thread-safe

DateFormat and NumberFormat are not thread-safe. Use ThreadLocal or create new instances:

Detect Right-to-Left (RTL) languages

When dealing with RTL languages like Arabic or Hebrew:

Conclusion

In this article, we didn't cover every problem when it comes to internationalization and localization, but we learned
how to face the most common challenges in international Java projects.
We learned how to use the Locale class and saw what news Java 19 brings and what it deprecates. We learned how to get
messages from resource bundles, normalize strings and format dates and numbers.

Java 24: Locale class

Java 24: NumberFormat class

Java 24: DecimalFormatSymbols class

Java 24: Currency class

Java 24: Locale.Builder

Java 24: Normalizer class

Java 24: ResourceBundle class

Java 19: List of supported locales

Spring Boot 3.2: Simple internationalization

Billy Korando: Internationalization in Java

Billy Korando: Looking up Default Locale in Java 21

Half-width kana

Sean Patrick Floyd: Normalization example
]]></content:encoded>
            <category>tips</category>
            <category>i18n</category>
            <category>developer</category>
            <category>java</category>
            <enclosure url="https://simplelocalize.io/blog/java-internationalization.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Spring Boot 3.5: Internationalization (i18n) with messages.properties]]></title>
            <link>https://simplelocalize.io/blog/posts/spring-boot-simple-internationalization</link>
            <guid>https://simplelocalize.io/blog/posts/spring-boot-simple-internationalization</guid>
            <pubDate>Fri, 18 Nov 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to implement internationalization in Spring Boot 3.5 application. Translate page and email using message.properties files, Thymeleaf templates, LocaleResolver, and more.]]></description>
            <content:encoded><![CDATA[Introduction

Internationalization (i18n) is the process of designing your application to be adapted to various languages, regional
peculiarities, and technical requirements of a target market.
Internationalization is a crucial step in the process of localizing your product. In this tutorial, we will show you how
to use Spring Boot to create a simple internationalized application,
how to get translated messages from messages_xx.properties files, render translated HTML from HTML template
using Thymeleaf and how to use LocaleResolver to change the language of the application.

Used technologies

Java 21+ (LTS recommended)

Spring Boot 3.5.4

Thymeleaf 3.1.3

Maven

Spring Boot 3.5 with i18n

Configuration

1\. Create messages_xx.properties files

The messages are stored in the messages_XX.properties files. The XX is the language code. For
example, messages_pl_PL.properties is the Polish version of the messages.

With SimpleLocalize, managing translations is effortless. Upload your source language from \*.properties, and get translations in other
languages automatically using machine translation, AI, or by collaborating with your own translators. You can automate uploading and downloading messages_xxx.properties files via SimpleLocalize CLI.

Downloading messages_xx.properties files via SimpleLocalize CLI

2\. Configure messages_xx.properties location

The default location for messages is src/main/resources/messages.
You can change this by setting the spring.messages.basename property in your application.properties file
or by providing your ResourceBundleMessageSource bean.

Application properties configuration:

Java Configuration using ResourceBundleMessageSource:

Please note that not every setting is available in application.properties file.

Managing messages.properties in IntelliJ IDEA

3\. Configure resolving locale from requests

The default locale resolver is AcceptHeaderLocaleResolver which resolves the locale from the Accept-Language header.
You can change this by setting the spring.mvc.locale-resolver property in your application.properties file or by
providing your LocaleResolver bean,
creating LocaleChangeInterceptor and registering it via addInterceptors method (see WebMvcConfigurer class).

4\. Create HTML template with Thymeleaf

One of the most common use cases for internationalization in Spring Boot is to render HTML pages (or emails) with translated messages.
In this case, we will use Thymeleaf as it's one of the most popular template engines in the Java ecosystem and it works great with Spring Boot, and it supports internationalization out of the box.

You might want to learn about what is 'hreflang' and how to use it if you are creating multilingual app or website.

Quick Thymeleaf guide:

th:attr="lang=${lang}" - sets the language of the document

th:text="#{message}" - gets a message with message key from messages_xx.properties

th:utext="#{title(${userName})}" - same as th:text, but allows you to use variables in the message, and it does not escape HTML characters

th:href="${url}" - inserts a value of the url variable

Tip: If you are creating email templates, you may want to check mjml.io that allows you to create responsive email templates using a simple markup language.

Get translated messages

Use MessageSource to get translated messages. This is the default way to get translated messages in Spring Boot.

Translate API exceptions

You can return translated API exceptions by using standard Spring Boot @ControllerAdvice.
For these purposes, we will create a custom ErrorController that handles exceptions and returns translated messages.

@ExceptionHandler(Exception.class) - catches all exceptions not caught by other methods

@ExceptionHandler(IllegalArgumentException.class) - catches IllegalArgumentException exceptions

Both methods gets Locale from LocaleContextHolder and returns translated message from messages_xx.properties file
using MessageSource bean.

By default, Spring Boot uses Accept-Language header to resolve user locale,
but in this tutorial we changed this behavior by registering custom LocaleChangeInterceptor bean.
To change the language of exception, you need to use lang parameter, e.g. /api/my-health?lang=pl_PL.

Translated Spring Boot exceptions

The number of ways to return translated messages is endless,
but the solution above might be one of the best ones
as we keep all the logic and translation keys for exceptions in one place.

Translate @Validation messages

Spring Boot provides support for localizing validation error messages using the Bean Validation API (@Validated, @Valid) with custom message properties.

Create a LocalValidatorFactoryBean bean to configure the validation messages:

Create a request DTO with validation annotations and localized messages:

Make sure to create the corresponding messages in your messages_xx.properties files:

Create a sample controller to handle user creation requests with validation:

Create a global exception handler to handle validation errors and return localized messages:

Translate web pages

You can also return translated web pages (HTML) by using standard Spring Boot @Controller.
Spring Boot will automatically resolve user locale and render HTML from my-html-template.html template with translated
messages.

This is the default way to return translated web pages in Spring Boot.

Run the application and open http://localhost:8080/welcome in your browser.
You can change the language by adding ?lang=pl_PL to the URL.

Changing the 'lang' query parameter in Spring Boot 3.5

Translate any HTML content

Use ThymeleafEngine bean to render HTML with translated messages. This is probably the most
popular way to render HTML with translated messages in Spring Boot.

Rendering custom HTML with translated texts

Handling Accept-Language Header

Default Behavior with AcceptHeaderLocaleResolver:

Spring Boot uses AcceptHeaderLocaleResolver by default, which automatically parses this header:

Custom Accept-Language Processing:

For more control over Accept-Language processing, you can create a custom resolver:

Testing Accept-Language Header:

You can test different language preferences using curl or browser developer tools:

When using LocaleChangeInterceptor with query parameters (like ?lang=pl), it takes precedence over the Accept-Language header.

Sanitization of user input

When rendering user input in HTML templates or email, you watchout for XSS (Cross-Site Scripting) attacks.
For example, if you render user input directly in the HTML template without sanitization, it can lead to XSS vulnerabilities.

Thymeleaf automatically escapes HTML characters in text attributes, like th:text:

but if you use th:utext to render unescaped HTML, you must ensure that the content is safe or sanitize it before rendering.

For example, if you render user input directly in the HTML template using th:utext, it can lead to XSS vulnerabilities:

utext stands for "unescaped text" and it allows you to render HTML content without escaping it.

To prevent XSS vulnerabilities, you can use a library like OWASP Java HTML Sanitizer to sanitize the user input before rendering it in the HTML template:

Related resources

IntelliJ IDEA plugin for localization

Spring Boot 3.5: Internationalization

Spring Boot: WebMvcConfigurer

Spring Boot: LocaleResolver

Java 24: Internationalization

Full code: simplelocalize/spring-boot-i18n
]]></content:encoded>
            <category>tips</category>
            <category>i18n</category>
            <category>developer</category>
            <category>java</category>
            <enclosure url="https://simplelocalize.io/blog/spring-boot-simple-internationalization.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to translate your app without hiring translators?]]></title>
            <link>https://simplelocalize.io/blog/posts/how-to-translate-without-hiring-translators</link>
            <guid>https://simplelocalize.io/blog/posts/how-to-translate-without-hiring-translators</guid>
            <pubDate>Tue, 08 Nov 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to translate your app without hiring professional translators. Save time, money and provide your users with accurate translations with just one click.]]></description>
            <content:encoded><![CDATA[Nowadays, many apps seek to build and improve ties with their audiences and, at the same time, expand their operations
to other countries. The glue that connects these two things – improving relationships with existing customers and
expanding into other markets and winning a new audience – is translation. But how to translation an app? Should you hire
professional translators to ensure the translation quality and accuracy? Or maybe there are other ways with similar
results? In this blog post, we will reply to those questions by checking pros and cons of using different translation
methods.

To translate or not to translate?

Software translation is a response to the need to build relationships with users and to expand its operations in other
countries and cultures. Translation allows you to communicate information directly and understandably to the recipient.
It creates a direct communication and a sense of connection between the user and an app.

First question is, do you need to translate your app, or it is ok to keep it in just one language? What are the benefits
of adding more languages to your app? See below the comparison of one language app with multi-language projects.

One language app without proper language management

simple one-language texts

limited to predefined audience (who speaks given language)

text blocks added directly in the code, which makes it more difficult to maintain

Multi-language app with proper translation management

diverse content, tailored to the language, culture, and habits of the users

unlimited audience – add new language and localize your app to open up to new markets

increased visibility of your app thanks to keywords translation

better relations and increased engagement with your app users

easy translation and maintenance with auto-translate option

simple translation files and cleaner code

How to translate a website or app?

Translation of a website or app usually involves different teams and areas of work. Thus, it seems complicated at the
start, but with a proper translation management, it is 100% worth the effort as we could see in the comparison above.

Translation process starts from developers, who create a translation file structure in the source code, choose, install
and configure an i18n framework like next-i18next, and build a base for future localization. Usually, it is on
developer's side to connect the app to a translation management software for easier app localization and translation
maintenance.

Translation methods

The next step it to translate the app. What is the best way to do that, you ask? Well, there are different approaches
and each of them has some pros and cons:

Hire professional translators or localization specialists

✅ you can be certain that translations will be accurate and well-done, with proper spelling, grammar and consistent
terminology
❌ may be expensive, depending on the languages into which you want to translate the application
❌ more work for you to control the translation process, send source language translation and update translated
texts
❌ complicated translation updates and maintenance when you add new translations to your app or modify it

Ask your team or friends for translations

✅ low-cost solution 
✅ easier translation maintenance if it is done by your team members 
❌ limited to the languages your teammates/friends know 
❌ probably lower quality of translations, they may not be so accurate as translations done by a professional
translator 
❌ may carry pressure/stress if translations are needed now but your team members or friends are not available or
occupied with more important tasks

Use automatic translation

✅ the fastest solution which translates to selected languages in a few minutes
✅ quick way to add new languages to your app
✅ unlimited languages (machine translation services like DeepL or Google Translate offer many languages – if one doesn't
have one language yet, you will probably find it in the other)
✅ no need to hire additional people or ask for translations, you can run auto-translation with just one click
✅ easy and fast translation updates
❌ may require additional review from given language users
❌ translation accuracy may be slightly lower than translations prepared by professional translators

Translate with Google Translate

What is automatic translation

Automatic translations is a response to the need of expanding to other markets and opening up to users language and
culture. Because not every app creator can afford to pay for professional translator services, auto-translation is a
great way to expand without sacrificing quality or results.

Auto-translation is the use of machine translation services, like DeepL or Google Translate, to translate a text from
one language to another. The biggest advantage of using auto-translation is saving time – translation takes only few
seconds, and you can translate to multiple languages at once
with SimpleLocalize auto-translation feature.

Start auto-translation window

This feature combines the characteristics of pros and cons of hiring professional translators and doing translations by
yourself or with your team members and friends help (who would probably use Google Translate anyway). The translation is
fast, done on time, mostly accurate, but may require additional verification of native language users to address some
minor issues. Moreover, it can be done by just one person, it's low cost, and you can run the auto-translation for all
newly added texts and features in your app.

Conclusion

Software localization is one of the best ways to build relationships with users. It creates a bond, makes the user feel
cared for, taken care of and understood. Even if you cannot afford to hire professional translators, automatic
translation is a great tool that will help you save your time and money.

The response for translating a website or app without hiring professional translators is using auto-translation software
like SimpleLocalize, which comes with a simple, intuitive translation management system. It is the best solution for
small projects who want to start with their app localization and expand their offer and visibility to other countries.
]]></content:encoded>
            <category>deepl</category>
            <category>google translate</category>
            <category>auto translation</category>
            <category>machine translations</category>
            <enclosure url="https://simplelocalize.io/blog/content-translations-methods.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[12 Most Popular Acronyms in Software Localization]]></title>
            <link>https://simplelocalize.io/blog/posts/12-localization-acronyms</link>
            <guid>https://simplelocalize.io/blog/posts/12-localization-acronyms</guid>
            <pubDate>Wed, 12 Oct 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[L10n, TMS, i18n. Are those terms familiar to you? Learn the most popular acronyms used in software translation and localization.]]></description>
            <content:encoded><![CDATA[L10n, TMS, i18n and more. Do those terms sound familiar to you? If you have already started translating your website or
app, you probably already heard at least one of them.

In this blog post, we will decode and explain the most used and popular acronyms and key localization abbreviations in software
translation to help you discover and navigate the world of localization.

Acronyms in translation and localization

Acronyms are shorter, abbreviated forms of words, usually created from the initial letters that are used in a given
phrase. An example of an acronym is NATO (North Atlantic Treaty Organization) where the first letter of
each word created a new abbreviated term.

We use acronyms to make it easier and faster to read certain words and terms. Instead of writing and reading a 4-word
organization name, like the National Aeronautics and Space Administration, we simply write and pronounce it as NASA. It is
the same with localization and translation terminology. Instead of using long, repetitive terms, we used shorter and
simpler forms of them, like MT (machine translation) or l10n (localization).

Software localization is a complex process that involves many steps. It also introduces many new terms, which happen to
be quite long (e.g., internationalization) and similar to each other. To simplify the process for you, we created a
glossary of the most common software localization acronyms.

To make use of acronyms, you need to know what they mean, what words they are shortened from. Without that, xl8 or i18n
will be only a strange assemblage of words. Here is a list of acronyms you may come across when translating your
software.

Key acronyms in software localization

Here is a simple list of the most popular acronyms used in software localization:

l10n – localization

t9n – translation

i18n – internationalization

g11n – globalization

xl8 – translate

m17n – multilingualization

ICU – International Components for Unicode

TMS – Translation Management System

MT – Machine Translation

TM – Translation Memory

CAT – Computer-Aided Translation

SL and TL – Source Language and Target Language

Below you will find a detailed explanation of each acronym.

l10n – localization

l10n in an acronym for localization. The acronym shortens the actual word, by adding the number of characters
between the first and last letter. This way, the result is: l-10(ocalizatio)-n.

Localization is a process of adjusting a website or app to user language, culture, and location (region). It consists of
adapting an internationalized app for a specific region or language by adding locale-specific components, such as
translated messages, time zones, currency symbols, and fonts.

t9n – translation

t9n is an acronym for translation. It is created in the same ways a l10n, by shortening the word by adding the
number of characters inside.

Translation is a process of transferring words and phrases from one language to another with the best possible
representation of the original meaning of the text.

i18n – internationalization

i18n is an acronym for internationalization. The acronym makes a long and complicated word easier to write.

What is internationalization? It is a process of adapting software to different languages, making it international, by
considering regional and technical requirements of the target language. i18n is a broad term that refers to the process
of designing an application, so it can be localizable to a variety of languages and regions without engineering changes.

g11n – globalization

g11n is an abbreviation of globalization. Globalization is a process in which a business starts to operate on an
international scale. The globalization process consists of internationalization, translation, and localization.

xl8 – translate

xl8 is an abbreviation for translation, and it is used widely as a hashtag in social media. X is for "trans", then
we add an l and 8 (ate).

xl8 is also a group
of translation management systems.

m17n – multilingualization

m17n is an acronym of multilingualization. This term consists of adapting or localizing a website or app into
multiple languages. Multilingualization can be done in many ways, including translation, localization, and
internationalization.

ICU – International Components for Unicode

ICU is an acronym for International Components for Unicode. It is a library of software tools that implement
Unicode and ISO 10646 standards. It provides functions for handling text data in different languages, including
normalization, case conversion, text segmentation, and transliteration.

TMS – Translation Management System

TMS is an acronym for Translation Management System. It is a software that helps with the management of
translations in one or more languages.

Companies use translation management systems to manage the process of translating text from one language to
another. TMSs are helpful because they allow companies to translate documents, texts, and content in multiple languages
at once and make sure that the text is translated accurately and in a timely manner.

MT – Machine Translation

MT stands for Machine Translation. MT is the use of computer software to translate text from one language to
another. Some examples of MT software are OpenAI, DeepL, Google Translate or Bing Microsoft Translator.

TM – Translation Memory

TM is an acronym of Translation Memory. The term refers to a database that stores previously translated words,
sentences, paragraphs or segments, for the future use by translators.

CAT – Computer-Aided Translation

CAT is an acronym of Computer-Aided Translation or machine-assisted translation. It is the use of computer software
to assist a human translator in the translation process. There are a number of tools and features that the CAT systems
offer to help translate various types of texts, like translation memory or built-in use of machine translation.

SL and TL – Source Language and Target Language

SL/TL are acronyms of Source Language and Target Language. Translators widely use these acronyms. Source
language is the language that is to be translated to another language. Target language is the language that receives the
translated text.

If you would like to learn more about software translation, visit
our complete guide to software localization where we explain how to get started.
]]></content:encoded>
            <category>internationalization</category>
            <category>software localization</category>
            <category>translation management</category>
            <enclosure url="https://simplelocalize.io/blog/software-localization-acronyms-list.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[What is CORS?]]></title>
            <link>https://simplelocalize.io/blog/posts/what-is-cors</link>
            <guid>https://simplelocalize.io/blog/posts/what-is-cors</guid>
            <pubDate>Tue, 04 Oct 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[Article explains what is CORS, popular among web developers, what are the common problems and how to fix them.]]></description>
            <content:encoded><![CDATA[In this article, I will explain what CORS and CORS errors are and why you might run into them. I will present possible
solutions and explain
what preflight requests, CORS headers are, and why they are important in the communication between parties.
The article assumes you have some basic knowledge of web development and the HTTP protocol.
I tried to write the article in a way that is easy to understand for beginners and to fill it with knowledge while trying to avoid too many technical nuances that are not tightly connected to the CORS topic.
If you spotted any mistakes or have any suggestions, do not hesitate to contact me. In some places, I made a
simplification where a service means server and vice versa.

What is CORS?

Cross-Origin Resource Sharing (CORS) is an HTTP-based security mechanism controlled and enforced by the client (web browser).
It allows a service (API) to indicate any origin other than its own from which the client can request resources.
It has been designed in response
to the same-origin policy (SOP)
that restricts how a website (HTML document or JS script) loaded by one origin can interact with a resource from another
origin.
CORS is used to explicitly allow some cross-origin requests while rejecting others.

CORS is implemented primarily in web browsers, but it can also be used in API clients as an option.
It's present in all popular web browsers like Google Chrome, Firefox, Opera, and Safari.
The standard has
been accepted as a W3C Recommendation in January 2014.
Based on that, we can assume that it is implemented in all currently available and other than listed web browsers.

How does it work?

Everything starts on the client side, before sending the main request. The client sends a CORS preflight request to a
service for resources with parameters in HTTP headers (CORS headers).
The service responds using the same headers with different or the same values. The client decides, based on the CORS preflight response, whether it can or cannot send the main request to the service.
The web browser (client) will throw an error if the response does not meet the requirements of CORS preflight.

CORS preflight requests are sent regardless of the libraries or frameworks used to send requests from a web browser.
That's why
you won't need to conform CORS requirements when working with API from your backend application.

CORS is not going to prevent users from requesting or downloading resources. You can still make a successful request
for a resource using apps like curl, Insomnia,
or Postman. CORS is only going to prevent the browser from accessing the resource if the
CORS policy does not allow it.

What is a CORS preflight?

When a browser sends a request to a server, it first sends an HTTP Options request.
This is called a CORS preflight request. The server then responds with a list of allowed methods and headers.
If the browser is allowed to make the actual request, it sends the actual request. If not, it shows an error and does not continue to send the main request.

CORS preflight: Server-Client Requests Scheme

CORS Headers

CORS headers are regular HTTP headers that are used to control the CORS policy. They are used in requests where the browser sends a CORS preflight request to the server, and the server responds with:

Access-Control-Allow-Origin indicates what origin can fetch resources. Use one or more origins, e.g.: https://foo.io,http://bar.io.

Access-Control-Allow-Methods indicates what HTTP methods are allowed. Use one or more comma-separated HTTP methods, e.g.: GET,PUT,POST.

Access-Control-Allow-Headers indicates what request headers are allowed. Use one or more headers, e.g.: Authorization,X-My-Token.

Access-Control-Allow-Credentials indicates if sending cookies is allowed. Default: false.

Access-Control-Max-Age - indicates how long the request result should be cached, in seconds. Default: 0.

If you decide to use Access-Control-Allow-Credentials=true, then you need to be aware of the fact you cannot use
wildcards \* in Access-Control-Allow-\* headers. It's required to explicitly list all allowed origins, methods, and headers.

See a full list of CORS headers.

CORS request and response headers

Why is request blocked by CORS policy?

If you are a web developer, you have probably already seen or heard about CORS errors, and you have searched for solutions many times. The most common problem is that the browser blocks the request because of CORS policy. The browser will throw an error and show a log in the console:

The CORS error above notifies a user that the browser couldn't access a resource (https://localhost:8080) from an
origin (https://localhost:3000) because
the server didn't allow it. It happened because the server didn't respond with Access-Control-Allow-Origin header with
the origin or with a wildcard \* in the CORS preflight response.

A request may be blocked by CORS policy not only because of an incorrect origin, but also because of an incorrect HTTP header, HTTP method, or Cookie header.

How to fix CORS error?

The fundamental idea of "fixing CORS" is to respond to "OPTIONS" requests sent from a client with proper headers.
There are many ways to start responding with proper CORS headers. You can use a proxy server, or you can use middleware in
your server.

Response to preflight request doesn't pass access control check

Remember that Access-Control-\* headers are cached in a web browser according to the value set
in Access-Control-Max-Age header.
Please make sure that you clear the cache before testing the changes. You can
also disable caching in your browser
.

1\. Configure your server

By default, if you are a server owner, you need to configure CORS responses in your server and this is the only way to
address the issue properly.
You can achieve this in multiple ways and on multiple layers of your app. The most common way is to use a reverse proxy, API gateway, or any other routing service that offers the ability to add headers to responses.
There are many services that you can use to do this, some of them are: HAProxy, Linkerd, Istio, Kong, nginx, Apache,
Traefik.
If your infrastructure contains only an application without any additional layers, then you can simply add CORS support
in the application code.

Successful CORS preflight requests in Firefox Developer console

Here are some popular examples of enabling CORS:

Apache: modify .htaccess file,

CloudFlare: use Transform Rules -> Modify Response Header

Nginx: modify configuration file,

Traefik: use middlewares,

Spring Boot: use @EnableCORS annotation,

Express.js: use app.use(cors()),

Next.js: use request helpers.

Here you can find more examples of enabling CORS in different frameworks and
languages: enable-cors.org.

If you cannot enable CORS in the service, but you still want to make a request to it, then you need to use one of the following solutions described below.

2\. Install a browser extension

Using a browser extension might be a quick and easy way to solve your problems with CORS in your developer environment.
The biggest advantage of using a browser extension is that you don't need to change your code or configuration.
On the other hand, you need to install an extension on every web browser that you use for testing your web application.

Use browser extension to overcome CORS error

Browser extensions alter incoming preflight requests by adding the necessary headers to trick the browser.
It's a handy solution to work locally with the production API that accepts requests only from the production domain.

You can find extensions in Google Web Store or
in Mozilla Add-ons Library.
In some cases, the default extension configuration might not be enough; make sure that the installed extension is
configured properly.
You should also be aware that leaving the extension turned on indefinitely may cause problems on some websites. It's
recommended to use them only for development purposes.

3\. Disable browser CORS checks

You can disable CORS checks in your browser completely. To disable CORS checks in Google Chrome, you need to close the
browser and start it with the --disable-web-security and --user-data-dir flags.
By doing that, Google Chrome will not send CORS preflight requests and will not validate CORS headers.

All of those commands above start Google Chrome in an isolated sandbox. They will not affect your main Chrome profile.

Disable security in Google Chrome to overcome CORS error

See list of all available flags for Google Chrome.

4\. Set up a proxy server

If you are looking for a solution that doesn't require you to change the browser settings, then you should look at the
proxy server solution.
This option helps you to overcome CORS errors without changing anything in the browser itself.
The idea of using a proxy server is to send all requests to your server, and then the server will send the request to
the actual service you want to use.
You can build a proxy server on your own in a language and framework of your choice. You will need to configure CORS and implement functionality to pass received requests to another service.

Use proxy server to overcome CORS error

Proxy server is a good solution if you don't have access to the service you intend to use.
There are ready to use and open-source proxy server services, but you should always ensure that they are not trying to
intercept your requests with authorization headers and pass them to any 3rd party service.
Such security breaches could be catastrophic failure for you and potential users of the service.

List of open-source CORS services that you can find on the internet:

https://github.com/Freeboard/thingproxy

https://github.com/bulletmark/corsproxy

https://github.com/Rob--W/cors-anywhere

Please review the code of the newest version before using any of those services.

How to test CORS?

Using a browser to test your CORS configuration might be a tedious task.
You can use a tool like CORS Tester or,
if you are familiar with the command line, you can use curl to test your CORS configuration.

Free and open-source web-based CORS tester

Beware of false CORS errors

In some cases, when a service is behind an additional layer with rate-limiter, load balancer or authorization server,
you can get a false CORS error. Blocked or rejected requests by a server should respond with error status codes. E.g.,:

401 unauthorized,

403 forbidden,

429 too many requests,

500 internal server error,

any other than 2XX or 3XX.

You may see that the request is blocked due to failed preflight request, but in fact, a service just rejects it. You
should always check the status code and response body of the response to avoid unnecessary debugging.
The browser properly alerts you when a CORS preflight request fails, but the reason for the failure is not necessarily
connected to the CORS configuration.

Conclusion

In this article, I tried to explain what CORS is, and what are the most common problems with it. I suggested 4 ways to
fix CORS issues and explained the advantages and disadvantages of each one.
I also explained how to configure CORS responses properly and how to test them. Moreover, I showed what are the most
common issues with recognizing false CORS errors.
I tried to put everything in simple terms and avoid technical nuances. If you have any questions, doubts, or
suggestions, please do not hesitate to contact me.

Happy coding!

Resources

https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS/Errors

https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy

https://enable-cors.org/

https://stackoverflow.com/a/42024918/1133169
]]></content:encoded>
            <category>developer</category>
            <category>cors</category>
            <category>tips</category>
            <enclosure url="https://simplelocalize.io/blog/what-is-cors.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to optimize your website for AI translation]]></title>
            <link>https://simplelocalize.io/blog/posts/how-to-optimize-website-for-ai-translation</link>
            <guid>https://simplelocalize.io/blog/posts/how-to-optimize-website-for-ai-translation</guid>
            <pubDate>Fri, 19 Aug 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to translate your website with AI translation services like OpenAI ChatGPT, DeepL or Google Translate and optimize your website for translation.]]></description>
            <content:encoded><![CDATA[AI translation is a technology that has been around for years, and it is getting smarter and more efficient each day. In
this blog post, you will learn how to optimize your website for AI translation and make it easier for machines to
translate your content into other languages.

The use of AI translation services is growing in popularity as the technology becomes more advanced and accessible. This
is because AI-powered translation services like OpenAI ChatGPT, DeepL or Google Translate provide a high-quality translation with
minimum human intervention. AI can translate text in real time, which can be helpful not only for instant translation,
but also for translating the whole website or app content in just a few seconds.

AI translation options for your website

The visitors of your website usually have two options to see its content in their language. First is enabled on your
side, by creating multilingual website and an option to support different languages. Second one is using browser
extensions or built-in translation services by the user. Both can base on machine translation, and thus both need some
website optimizations and things to consider when preparing content for AI translation.

Website localization

Website localization involves not only translation but more importantly, adapting the site to the language, culture, and
habits of the recipients. Creating your website in new languages can be challenging at first, but it has many benefits:

users can access the website content in their mother tongue

it is easier to find the website in different languages in search engines

website can load instantly translated and localized to in the user language

boosting website traffic and making it visible for users from other markets

increasing customers base

improving customer satisfaction and relations by more personalized content

Translation on the browser side

Most browsers, like Google Chrome, offer an option to translate pages to the recipient language using AI translation,
like Google Translate. Besides that, there are multiple extensions also in other browsers that run the AI translation
and translate the website content automatically for the client.

It is a great tool to translate websites in less used languages which do not have their version in English and other
languages. However, note that not everyone knows that there is such an option and how to use it. Those users simply
won't find nor get to your website at all. If your website is not optimized for AI translations, the results may not be
so accurate.

Website optimization for AI translation services

For any type of website or app translation, especially those that use AI translation, it is recommended to optimize its
content and structure, for the best translation quality. Good optimization makes translation management easier and
improves the software internationalization process.

Translation of not optimized website cannot be accurate, and occasionally, it can make no sense for the end user. To
avoid such inconsistency and misrepresentation of content on your website, consider the following optimization tips and
bring your website in line with AI translation services.

UX writing and translations

User-experience writing focuses on user impressions of all your website content. The goal is to keep all forms of texts
as simple as possible, at the same time conveying the information in a precise but user-friendly manner. Users should
perceive the content as something natural, understand it and feel the website's message effortlessly.

UX writing is inseparable from translations and their accuracy. Your website must feel right in all language version,
not only in English. That is why; for the start, we need to create translation-friendly content in the website source
language.

Here are some advices that, when applied in your source language, can highly improve AI translation results in other
languages:

Create simple, not complex phrases and short sentences. Texts must be easily understandable by users from
different countries whose English in not their first language. This is also great for getting more accurate machine
translation results.

Use relative pronouns like “that” and “which” in the source language to build the complete sentence. It will make
texts clearer and at the same time improve AI translation quality and precision.

Be precise when writing the main text, focus on the meaning of the text. Choose words that have only one meaning
if possible to avoid misinterpretation by translators or machines.

Avoid using passive voice. It is great advice for content writing in general, and it helps in text optimization
for AI translation too.

Avoid abbreviations. Sometime abbreviations may not be known or recognized correctly by AI, so it is better to
avoid them or add the expansion next to the abbreviation itself.

Avoid colloquialisms and idioms as they may not be properly translated by AI, as they may not have their
corresponding in the target language.

Character Length and Text Wrapping

Translated texts in some languages like German or Dutch can result much longer than the English version. Keep that in
mind when creating your website UI by adjusting the site to accommodate longer words or sentences. Decide on the
maximum characters count that that specific key can work with, and also the width of the whole text. Try adding some
extra space for a bit longer translations.

For longer paragraphs, have in mind also how texts are displayed. A sentence in one line in English can result with two
lines in Spanish. To manage such cases of text expansion, use text wrapping to break texts into more lines if the
translation text is longer than the element width. Estimate text expansion and how much space it can take to decide if
text-wrapping is necessary.

Avoid string splitting

String splitting is a situation when one block of text is divided into smaller chunks. It usually happens when there is
some value inside that block, that is taken from the database.

Let's check an example. “From $12 per night”, this block is logically coherent when in one sentence, but to make it work
in different places, with different prices, developers need to replace $12 with a value from the database. To achieve
that, they split the block into different fragments: From, {roomPrice} and per night.

Such string splitting creates two different translation keys, FROM and PER_NIGHT. In this case, AI will translate
them separately, not knowing that there is something between those keys that makes them one logical sentence.

In such cases, to improve AI translation results, it is better to use {} placeholder instead to not split the
string. The correct source text in this case would be:

From {roomPrice} per night

Set up words excluded AI translations

Sometimes you don't want AI to translate some words or expressions to other languages because they are proper nouns or
proper names. Translating them to another language would make no sense or could entirely change the meaning of the
text. Imagine translating your company proper name in a sentence, the output would not be accurate.

In SimpleLocalize, you can create a list of words or expressions that you want to exclude from
the auto-translation process. OpenAI ChatGPT, DeepL or Google Translate will consider them
as proper names and won't ever translate them.

Do you need a review of machine translated texts?

AI translation, although very well-developed, also has some drawbacks. There are still some words and phrases that
cannot be translated correctly, even with AI assistance.
Currently, AI translation still cannot replicate the nuances of the original language. This is why, if you care about
translation quality and accuracy, it needs to be reviewed by a professional translator before being published.

How to help translators in AI translation review?

Translation review is a crucial step in translation management to provide users with accurate and localized content. To
make the review easier and more efficient for professional translators, make sure to give them the following
information:

Context of the translation keys and where they are located on the website, so they can verify the accuracy of the
translated text. Note that context is not only the location, but the overall use of the text, when it appears for the
user, on what action it shows up, in what situation it appears. This is important as the way of translating texts is
strongly connected to its context.

Does the translation key work as a button or heading, or maybe it is used in the footer of the website? The usage,
function of the key will define and affect the translation. You can translate differently a simple key “Book Now”
for a button (“Book Now”), for a headline (“Book now and start your experience”) or a footer (“Booking button”). It
can have different translations for different text functions, so make sure you add this information for translators.

Translation formality and style – to whom is this text directed? Who is the recipient? How to address them? The
formality differs in many languages. Your text may be very straightforward and direct in English, but should it be the
same in German or Spanish in Spain or Chile? AI might not always be that accurate to catch those differences, but
professional translators will be able to verify and correct the text formality to make it suitable for the recipient.

Length of translation – translators can see and compare number of characters of source text and translations to
make sure they are not significantly different.

How to translate your website using AI translation?

Make your website multilingual with AI translation services like OpenAI ChatGPT, DeepL or Google Translate and SimpleLocalize
a translation management system. It is a great way to get started with your website content translation
and software localization.

Start with uploading your translation keys and source language to SimpleLocalize, add new languages and use
an auto-translation option to translate them in seconds!
SimpleLocalize translation editor will help you to update and manage
translations and review texts translated by AI.

Using a translation management system helps not only in translating your website or app, but also provides with:

translation hosting

seamless updates of your translation files

intuitive and customizable translation editor

team workflow and tools for developers, translators and managers

easy import and export of translation files

translation project sharing

machine translation with OpenAI, DeepL and Google Translate

Explore our simple and intuitive translation editor

Are you ready to start translating your website content with AI translation
services? Register now to SimpleLocalize and start managing your website translations and add new
languages with just a few clicks. Get started with a 14-day trial or use our free Community plan for your website
localization!
]]></content:encoded>
            <category>deepl</category>
            <category>google translate</category>
            <category>auto translation</category>
            <category>machine translations</category>
            <category>tips</category>
            <category>developer</category>
            <category>openai</category>
            <category>chatgpt</category>
            <enclosure url="https://simplelocalize.io/blog/how-to-prepare-text-for-google-translate.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[7 not obvious benefits from translating your application]]></title>
            <link>https://simplelocalize.io/blog/posts/7-benefits-from-translating-your-app</link>
            <guid>https://simplelocalize.io/blog/posts/7-benefits-from-translating-your-app</guid>
            <pubDate>Tue, 26 Jul 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[Discover 7 surprising benefits of translating your app, from cleaner code to faster development and better UX. Perfect for developers and product teams!]]></description>
            <content:encoded><![CDATA[Translating your app may seem like a huge task; from choosing the right localization tools, assigning developer resources, and hiring translators. But the effort pays off far beyond just reaching a global audience.

While the common benefits of app localization, like expanding your customer base and increasing engagement, are widely known, many developers overlook how translation can improve their workflows, code quality, and product design.

Here are 7 not-so-obvious benefits of translating your app, with real examples of how tools like SimpleLocalize help you scale without extra hassle.

1\. Cleaner, more maintainable code

Embedding long UI texts directly in your source code clutters your components and reduces readability. Translating your app encourages key-based localization, replacing paragraphs with semantic identifiers like ABOUT_US.

Before:

After:

This not only declutters your code but also separates logic from content, a best practice in modern development.

2\. Consistent UI text across the app

Reusing translation keys ensures that all identical buttons or labels (like “Save” or “Cancel”) use the same wording. This avoids typos, inconsistencies, and UX bugs.

By centralizing translations in a JSON file or a tool like SimpleLocalize, you ensure UI consistency at scale.

Save button translation consistency

3\. Faster, centralized proofreading

Proofreading scattered text across multiple code files is painful. Translating your app means content lives in one place, often in a simple key-value file or visual editor.

With tools like SimpleLocalize's translation editor, reviewers can check all copy in one dashboard, reducing proofreading time and errors.

Quick review of all translations

4\. Add new languages without developer involvement

Once your app is translation-ready, adding a new language becomes a non-technical task.

With SimpleLocalize:

Open the Languages tab

Add a new language

Use auto-translation to generate instant translations

No developer time required

Add new languages to your application

This is a huge time-saver for teams wanting to grow into new markets quickly.

5\. Lower risk of typos and grammar errors

When developers write UI text directly in code, typos and grammar mistakes are common. Translating your app means content is separated from logic, allowing for better proofreading and review processes.

With SimpleLocalize, you can run AI spelling and grammar checks across all translations, catching errors before they reach users.

AI spellcheck in SimpleLocalize

6\. Easier A/B testing of messaging

Want to test different headlines or button texts? With translation keys, it's easier to swap or experiment with copy without touching the code.

Just update the translation file or manage versions inside your localization platform. This makes your team more agile and creative when optimizing user flows.

7\. Improves accessibility and user experience

Localized apps aren't just about language. They improve user trust and comfort. Clear and culturally relevant text helps:

Build brand credibility

Reduce cognitive friction

Make your app feel native to users, wherever they are

This leads to higher retention rates and better conversion.

Translation management made simple

Ready to unlock the full potential of localization? Try SimpleLocalize and explore:

A user-friendly translation editor

Fast integration with frameworks like React, Next.js, and Vue

Auto-translation powered by AI

AI proofreading and spellcheck

Centralized translation management

Collaboration for developers and translators

SimpleLocalize translation editor

Start your 14-day free trial, or use the free tier for smaller projects.

New to localization? Learn what SimpleLocalize is and how it works.

Need help? Contact us or join our Discord community for support.
]]></content:encoded>
            <category>internationalization</category>
            <category>translation management</category>
            <category>tips</category>
            <category>software localization</category>
            <category>developer</category>
            <enclosure url="https://simplelocalize.io/blog/benefits-from-translating-app.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[What is SimpleLocalize? Localization and Translation Management for your project]]></title>
            <link>https://simplelocalize.io/blog/posts/what-is-simplelocalize</link>
            <guid>https://simplelocalize.io/blog/posts/what-is-simplelocalize</guid>
            <pubDate>Thu, 30 Jun 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[SimpleLocalize is a simple and user-friendly solution for translation management which helps in localization process and translation files management.]]></description>
            <content:encoded><![CDATA[In a world where digital products are expected to support multiple languages, SimpleLocalize offers an approachable and efficient way to handle translations. It is not just another localization tool, it is a solution designed to help developers, translators, and product teams manage translations with less hassle and more clarity.

Whether you are building a multilingual website, mobile app, SaaS platform, or desktop tool, SimpleLocalize gives you the tools to manage, edit, and deploy translations, without digging through JSON files or manually syncing language updates.

What is SimpleLocalize?

SimpleLocalize is a translation management platform that focuses on simplicity, clarity, and real-time collaboration. It helps teams manage their localization process more effectively by offering:

A clean and intuitive translation editor

Multiple import/export options (JSON, CSV, Excel, YAML, etc.)

Auto-translation powered by DeepL, Google Translate and OpenAI (ChatGPT)

Translation hosting through a global CDN

Role-based access for teams

Custom translations for individual customers

It's designed to work well for both technical and non-technical users, making it a great choice whether you are a developer, translator, or project manager.

SimpleLocalize logo

How translation management works in SimpleLocalize

Instead of editing files manually or relying on outdated spreadsheets, SimpleLocalize gives you a structured process to follow. Here is how it works:

1\. Import translations

Start by uploading your existing translation files. You can use files in formats like JSON, CSV, Excel, or YAML. Prefer automation? Use our REST API or open-source CLI tool to integrate SimpleLocalize into your development workflow.

Check out the list of supported formats to see what you can import.

2\. Translate in a user-friendly editor

Once your keys are imported, you can begin translating using SimpleLocalize's online editor. It offers two customizable views:

Table View: A spreadsheet-style layout perfect for translators. It's easy to scan, edit, and filter translations.

List View: Great for longer texts and metadata management. You can view a translation key’s description, associated namespace, and history.

Translation editor interface

You can also enable useful translation hints like character counts, word summaries, and see which strings were translated using auto-translate.

Learn more about the translation editor features and check out the translation editor documentation.

3\. Download or host your translations

After your translations are complete, you can download them in your preferred format or take advantage of SimpleLocalize's translation hosting. Hosting allows you to deliver up-to-date translations via a CDN, so you don't need to redeploy your app every time a translation changes.

Translation hosting

Key features that make a difference

🔄 Auto-translation

Need to add a new language quickly? With one click, SimpleLocalize can automatically translate your entire project using DeepL, Google Translate or OpenAI. Machine translations are flagged, so you can easily review and refine them later.

Auto-translate with DeepL, Google Translate or ChatGPT

Check out the auto-translation documentation to learn how to set it up.

💡 Public suggestions

If you want to crowdsource translations, SimpleLocalize allows you to enable public suggestions. This lets users contribute translations directly in the editor, which you can then review and accept.

Public suggestions

Learn more about public suggestions and how to set them up.

👥 Team collaboration

Invite your teammates to your SimpleLocalize project. Assign roles, control access levels, and monitor progress in real time. Whether you are working with freelance translators or an internal QA team, everyone has a clear role.

Translation editor view

Check out the project sharing documentation to learn how to invite team members and manage roles.

🌐 Host translations on a global CDN

SimpleLocalize offers translation hosting, which allows you to serve language files from a fast and reliable CDN. This feature helps you:

Avoid manual file syncing

Deploy updated translations instantly

Integrate easily into frontend frameworks like React, Vue, or Next.js

This is especially helpful for SaaS platforms and single-page apps that require dynamic, multilingual content.

Learn more about translation hosting and how to set it up.

🧩 Customer-Specific Translations

Need to personalize language for different users? SimpleLocalize supports customer-specific translations, so you can create unique versions of your app for particular clients or user segments.

You don't need complex code to manage this, it's built into the platform.

Customer specific translations

Learn more about customer-specific translations and how to set them up.

🧠 Built for developers, loved by translators

SimpleLocalize integrates with popular tools and frameworks like:

React, Angular, Vue, Svelte

i18next, FormatJS

GitHub, Bitbucket, GitLab

Use the CLI or API to automate updates and version control, while your translators work in a clean, easy-to-use UI.

Check out our doccumentation on integrations to see how SimpleLocalize can fit into your existing workflow.

👋 Who we are

SimpleLocalize was started by Jakub Pomykała in 2019 with a simple mission: to create a localization tool that's easy to use, developer-friendly, and doesn't overcomplicate the process.

Today, SimpleLocalize is trusted by companies all over the world and built on stable, privacy-first infrastructure using Amazon Web Services, Cloudflare, and GitHub.

We are a small, dedicated team that believes good software doesn't need to be bloated to be powerful.

Jakub and Kinga

Contact us if you have any questions or would like to give us some feedback!
]]></content:encoded>
            <category>translation management</category>
            <category>software localization</category>
            <category>i18n</category>
            <enclosure url="https://simplelocalize.io/blog/what-is-simplelocalize.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to translate NextJS app with next-i18next?]]></title>
            <link>https://simplelocalize.io/blog/posts/next-i18next</link>
            <guid>https://simplelocalize.io/blog/posts/next-i18next</guid>
            <pubDate>Mon, 23 May 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[Localize your NextJS app with next-i18next framework. Manage and synchronize localization files with ease. Add new languages in your application.]]></description>
            <content:encoded><![CDATA[NextJS, a well-known framework among React developers, provides multiple libraries that create a very developer-friendly environment. The most popular ones are i18Next, next-translate and, our main focus in this blog post, next-18next, a translation library that does a fantastic job helping in translation management. The following blog post will show you how to set up next-i18n in your NextJS app and manage translations with SimpleLocalize. Take a look at our demo app for the reference.

About next-i18next

Next-i18next is a NextJS framework that completes and expands the possibilities of NextJS basic i18n setup, which focuses mainly on automation of i18n routing using locales. Next-i18next uses i18next and react-i18next at its core, but it is simple to install, and the configuration takes only a few steps. 

Next-i18next offers additional benefits for NextJS app localization, like:

easy integration with translation content management like SimpleLocalize

components/hooks for React components translation

production ready with SSG/SSR support (Static Site Generation and Server-Side Rendering)

allows namespaces

customizable interpolation

supports code-splitting

easy setup and configuration

The standard file structure for next-i18next with namespaces will look like this:

There are four languages in our app (en, es, it and pt) and two namespaces, common and home. A namespace is usually one page of your website or app. In such a multiple-file setup, next-i18next loads only the translations that it needs to display from a selected locale.

translation files with namespaces sample (i18next)

Next-i18next configuration

The basic next-i18next configuration takes only few steps and will allow you to improve translation management in your app. See the below step-by-step guide to get started.

Install next-i18next

Use the simple command below to start with next-i18next installation with NPM or Yarn:

Create i18n configuration file

Now, create a configuration file in the project's root, ./next-i18next.config.js.

Add next-i18next to your NextJS app

The last step in the configuration is importing next-i18next configuration into next.config.js file.

Create your file structure 

When next-i18next is installed and configured, create your file structure for translations with languages and namespaces. Check the standard structure we described at the beginning of this blog post.

The root directory for your translations is /locales/{lang}/{ns}.json where lang is your locale (en, es, it, pt) and ns is your namespace (common, home). 

How to manage next-i18next translation files?

Next-i18next is a great framework which makes translation management way easier. Use it together with SimpleLocalize translation editor to manage localization process of your app like a pro. 😎

With SimpleLocalize, you can easily add new languages, manage existing translations and even auto-translate all translations! See how to get started and connect your NextJS app with next-i18next and SimpleLocalize.

Install SimpleLocalize CLI

Use SimpleLocalize CLI to easily extract translation keys from your project and upload them to SimpleLocalize translation editor. 

Issue the command below to start the installation.

Next, create a configuration file that will integrate your project with your SimpleLocalize account in no time.

Upload your translation files to SimpleLocalize

To upload your translations to SimpleLocalize project, use the installed CLI by running the command below:

Or check more import options available for multiple file formats.

Uploading translations with namespaces for next-i18next

Translate your app with SimpleLocalize online editor

Now, the best part of translation management begins. Log in to your SimpleLocalize account, open your project and start managing your translations. Use SimpleLocalize online translation editor to edit translations, add more languages, or translate them automatically with DeepL or Google Translate. Share the project with your team members and send access to translators using intuitive access sharing options.

Manage your translation strings in Translation Editor

Sign up for free Community plan and start managing your localization process in your way in our feedback-driven app.

Download translations to your app

When you are done with editing your translation, download localized files using CLI, or with one of multiple supported file format.

Downloading translations with namespaces for next-i18next

Next-i18next demo app

To try out how next-i18next goes with NextJS and SimpleLocalize and check an example of NextJS localization, run our demo app locally on your computer. Download the files from Github repository and test how it works.

Example next-i18next project with NextJS

Localize your NextJS app with SimpleLocalize

App or website localization can be a challenging  task, but you can make it a pleasant experience with great tools and localization frameworks. NextJS has a variety of external libraries that create a comfortable base for your work. Not only next-i18next, but also next-translate or next-intl and much more. Integrating your app with SimpleLocalize will improve your satisfaction during your app localization process.

import multi-language-json to simplelocalize

In case you have any doubts or need help with integrating your project with SimpleLocalize, check our documentation or contact Jakub directly at jakub@simplelocalize.io.
]]></content:encoded>
            <category>next-i18next</category>
            <category>nextjs</category>
            <category>developer</category>
            <category>react localization</category>
            <enclosure url="https://simplelocalize.io/blog/quick-start-with-next-js-and-i18next.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Software localization explained: Examples, benefits, and best practices]]></title>
            <link>https://simplelocalize.io/blog/posts/software-localization</link>
            <guid>https://simplelocalize.io/blog/posts/software-localization</guid>
            <pubDate>Sat, 30 Apr 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[Software localization explained with real examples. Learn how it differs from translation, why it matters for UX and SEO, and how teams localize apps and websites effectively.]]></description>
            <content:encoded><![CDATA[Software localization is often misunderstood as just translating an app. In reality, teams that take this approach usually run into the same problems: broken layouts, awkward wording, confusing UX, and poor adoption in new markets.

In this guide, we explain what software localization really is, how it differs from translation, and how teams localize software successfully. You will find clear definitions, real-world examples, and practical best practices you can apply to websites, SaaS products, and mobile apps.

What is software localization

Software localization is the process of adapting a website, application, or digital product to a specific language, region, and culture. It goes beyond translating text and focuses on making the product feel natural and familiar to its target users.

Localization includes adapting:

language and tone

UX and UI patterns

formats for dates, numbers, and currencies

visuals, symbols, and cultural references

The goal is simple: the product should feel as if it was designed specifically for the local user.

From the user's perspective, well-localized software feels:

natural and intuitive

easy to understand

culturally appropriate

respectful of local habits and expectations



Software localization usually becomes relevant when a business expands into new markets. Adding new languages is often the first step, but localization is much more than translation. Its primary focus is improving user experience by tailoring the product to how people actually read, think, and interact in a given region.

Because of this, localization touches many areas: development, content, design, and marketing. It requires attention to detail and a good understanding of cultural context. When done correctly, localization strengthens trust and makes the product easier and more enjoyable to use.

Software localization examples

Software localization goes far beyond translating UI strings. Common examples include:

Translating interface text while adapting tone and formality to the local culture

Adjusting date, time, and number formats (for example, 12/10/2026 vs 10.12.2026)

Using local currencies and pricing formats

Adapting images, icons, colors, and symbols for cultural relevance

Handling pluralization and grammatical gender correctly in different languages

Localization vs translation

Translation and localization are closely related, but they are not the same. The table below highlights the key differences.

| Aspect                   | Translation         | Localization               |
|--------------------------|---------------------|----------------------------|
| Scope                    | Text only           | Text, UX, formats, visuals |
| Focus                    | Meaning             | User experience            |
| Cultural adaptation      | ❌                  | ✅                         |
| Includes dates & numbers | ❌                  | ✅                         |
| Includes translation     | —                   | ✅                         |

Translation focuses on converting text from one language to another while preserving its meaning. The goal is accuracy and clarity in the target language.

Localization builds on translation and adapts the entire product to a specific culture and region. It considers how users perceive content, interact with interfaces, and interpret visuals.

Key differences to remember:

Localization covers much more than text, including images, formats, and UX patterns

The localization process is more complex and often involves translators, developers, designers, and marketers

Localization includes translation, but elevates it by accounting for regional language variants and cultural expectations

Check also: Translation vs. Transcreation: What's the difference?

Common localization acronyms

As localization becomes more common, you will encounter many abbreviations and technical terms. Below are the most important ones to know.

Core localization terms

l10n (localization) – adapting a product to a specific language, region, and culture.

i18n (internationalization) – preparing software so it can be easily adapted to different languages and regions.

g11n (globalization) – expanding a product or business to international markets using i18n, translation, and localization.

t9n (translation) – converting text from a source language to a target language.

locale – a combination of language and region, such as es-ES or es-CL.

Translation-related terms

TMS (translation management system) – software used to manage and automate translation workflows.

TM (translation memory) – a database of previously translated segments reused in future translations.

MT (machine translation) – automatic translation performed by software.

CAT – software that assists human translators.

SL/TL – source language and target language.

Glossary – a list of approved terms and definitions to ensure consistent translations.

Other related terms

xl8 – shorthand often used to describe translation tools or systems.

m17n (multilingualization) – supporting multiple languages in a product.

a11y (accessibility) – designing software so people with disabilities can use it effectively. (Learn more about web accessibility in our blog post.)

Why is localization so important?

Localization matters because users trust products that feel familiar. Software that ignores local language, formats, and conventions feels foreign, even when it is technically translated.

Effective localization:

Improves customer satisfaction by making products easier to understand and use.

Shows respect for users and their culture.

Helps expand into international markets and grow a global customer base.

Avoids one-size-fits-all content and focuses on local relevance.

Strengthens the emotional connection between users and the product.

Improves SEO by helping content rank in local search results.

Software localization process (step by step)

You can start localizing at any stage, but the earlier you plan for it, the smoother the process will be.

1\. Decide which markets and languages to support

Start by identifying the countries and audiences you want to reach. Research language variants, cultural norms, and user expectations. Look at how similar products operate in those markets and identify what needs to change for your product to feel local.

2\. Prepare for localization

On the technical side, prepare your codebase for localization and internationalization. Choose appropriate libraries and define a clear translation structure so content can be easily managed and updated.

Check our list of best i18n libraries for React, React Native & NextJS.

3\. Translate content

Once your product is ready, translate all user-facing content. To streamline the process:

Use professional translators or machine translation with human review to ensure quality and accuracy.

Plan how you will manage updates and new features that require translation.

Consider using a translation management system (TMS) to organize and automate the workflow.

Design UI layouts with text expansion in mind, as some languages take up more space than others.

Create a glossary to ensure consistent terminology across languages.

4\. Localize formats, UX, and visuals

Text alone is not enough. Pay close attention to regional conventions:

Numbers – decimal and grouping separators vary by region.

Dates and time – formats and 12/24-hour clocks differ.

Currencies – symbol placement and decimal usage vary.

Images and icons – symbols may carry different meanings across cultures.

UI and UX– design preferences and expectations are not universal.

Lean more about ICU and number formatting in Javascript.

5\. Test and iterate

Test localized versions with native speakers whenever possible. Collect feedback on usability and clarity, then refine the product continuously.

Localization tips and resources

If you want to go deeper, these resources can help you improve your localization workflow:

i18n tips and tricks

10 tips to make your localization workflow more productive

Best practices in software localization

How to handle pluralization across languages

11 common localization mistakes (and how to avoid them)

Design that speaks every language: UI tips for localization

10 tips for creating a language selector in your website or app

Localization SEO: Best practices

What is localization software

Localization software helps teams manage translations and localization workflows in one place. It typically supports automation, collaboration, and fast deployment of language updates.

Common features include:

automated translation workflows

centralized translation management

instant updates to development and production environments

version history and change tracking

support for multiple file formats and frameworks

role-based access for translators and managers

QA and review tools

Because localization involves many stakeholders, a dedicated tool can significantly reduce friction and speed up delivery.

SimpleLocalize translation management software

Software localization FAQ

Is software localization the same as translation?

No. Translation is part of localization, but localization also includes UX, formatting, and cultural adaptation.

When should you localize software?

Ideally before entering a new market or when international users begin using your product regularly.

What types of software need localization?

SaaS products, mobile apps, e-commerce platforms, and any user-facing software.

Does localization improve SEO?

Yes. Proper localization helps rank content in local search results and improves user engagement.

How can I test localized software?

Use native speakers for usability testing and gather feedback on clarity and cultural relevance.

Conclusions

Software localization is about meeting users where they are, linguistically, culturally, and contextually. While it requires planning and coordination across teams, the payoff is significant: better UX, stronger trust, and sustainable international growth.
]]></content:encoded>
            <category>internationalization</category>
            <category>software localization</category>
            <category>translation management</category>
            <enclosure url="https://simplelocalize.io/blog/software-localization-complete-guide.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[How to translate NextJS app with next-translate?]]></title>
            <link>https://simplelocalize.io/blog/posts/next-translate</link>
            <guid>https://simplelocalize.io/blog/posts/next-translate</guid>
            <pubDate>Thu, 07 Apr 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[Next-translate is a great choice for managing your translations in your NextJS application. Check how to install it and integrate with SimpleLocalize software.]]></description>
            <content:encoded><![CDATA[NextJS, as a very popular framework among React programmers, offers a variety of features and external libraries,
that create a very developer-friendly environment. One of them is next-translate, a translation library that well known for its simple set up and use.
In this blog post, you will learn to configure next-translate in your NextJS app,
and to manage translations with SimpleLocalize assist.

About next-translate

Next-translate is a great choice for managing your translations in your NextJS application. It is easy to configure and use, even for beginners.
It supports basic internationalization (i18n) like plurals or Trans component (to use HTML inside translated text),
loads only necessary translations which extremely saves your app memory, and it doesn't take a lot of storage. 

The library uses namespaces that allow you to split translations into multiple files. The standard file structure looks like this:

There are four languages in our app (en, es, fr and pl) and two namespaces, common and home. A namespace is usually one page of your website or app. Such file structure is clear and easy to manage. Thanks to this setup, next-translate will only load the translations that are needed to display translated content in a selected locale. 

Sample common namespace with translations in JSON

Next-translate configuration

The configuration of next-translate takes only a few steps, and they are straightforward to follow. See below the step-by-step setup for your NextJS app.

Install next-translate

To get started, install next-translate. You can do that with either NPM or Yarn. Simply run the command in your console.

Create i18n configuration file

Create a configuration file, i18n.json, in your project's root. It will look like below, where you set the locales you will use in your project, the default language and your namespaces (one for each page).

Create your namespaces file structure

The next step is to create your file structure with languages and namespaces. Check the example above for the file structure. 

The root directory for your translations is /locales/{lang}/{ns}.json where lang is your locale (en, es, fr, pl) and ns is your namespace (common, home).

Add next-translate to your app

The last step of the configuration of next-translate is to add it to your app, to next.config.js file.

And that's all. With those four steps, you are ready to translate your app with SimpleLocalize.

How to manage next-translate translation files?

SimpleLocalize can help you translate your keys automatically and manage them in a great translation editor. Adding a new language will become as effortless as you could ever imagine. How to get started, then?

Install SimpleLocalize CLI

SimpleLocalize CLI will get translation files from your project, extract them and upload to SimpleLocalize.

Run the command below to start the installation.

Next, create a configuration file to smoothly integrate your project with your SimpleLocalize account.

Upload translations to SimpleLocalize

You can use the installed CLI to upload your translation files to your project in
SimpleLocalize. Run the command below:

Uploading translations with namespaces for next-translate

Use SimpleLocalize to translate your app

Now, the fun begins. Use SimpleLocalize translation editor to change your translations, add new languages, or translate the keys automatically with DeepL or Google Translate. Translation editor features will help you control translation progress and work with translators within one translation management system. 

Manage your translation strings in Translation Editor

Sign up for free Community plan to get your translations on track for you and your team.

Download translations to your project

When your translation changes are ready, you can download
them to your project with a CLI command:

Downloading translations with namespaces for next-translate

Next-translate demo app

You can try how i18n next-translate library works in a NextJS app with our demo.
Check the GitHub repository and run it locally on your computer.

Example next-translate project with NextJS

Localize your NextJS app with SimpleLocalize

Localization of a website or app can be a challenging task. Fortunately, there are great tools that help both developers and translations to do their job with ease. SimpleLocalize connects the workflow for all team members of the project and helps to manage the translation process efficiently. Next-translate is a great start to begin the i18n of your NextJS app. 

import multi-language-json to simplelocalize

In case you have any doubts or need help with integrating your project with SimpleLocalize, check our documentation or contact Jakub directly at jakub@simplelocalize.io.
]]></content:encoded>
            <category>next-translate</category>
            <category>nextjs</category>
            <category>developer</category>
            <category>react localization</category>
            <enclosure url="https://simplelocalize.io/blog/quick-start-with-next-js-and-next-translate.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Translation Editor Explained]]></title>
            <link>https://simplelocalize.io/blog/posts/translation-editor-explained</link>
            <guid>https://simplelocalize.io/blog/posts/translation-editor-explained</guid>
            <pubDate>Fri, 25 Mar 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[Explore features and functionalities of SimpleLocalize translation editor, learn how to use them and get started with translation management for your project.]]></description>
            <content:encoded><![CDATA[In this blog post, I will describe to you the most powerful feature of SimpleLocalize, the translation editor.
It is an essential tool that helps managers, developers and translators in website, app, or any other type of digital content translations.

Localization became one of the most important steps in expanding customer bases and reaching to more people all around the world in their local language.
It's a considerable task, but SimpleLocalize can help you to simplify the process and support you in daily translations work with great tools, that I describe below.

Translations view

SimpleLocalize provides with two different views for editing translations. Each of them has specific features and is adjusted to user's role.

Table View

Table view is a simple, and  at the same time powerful, default spreadsheet-like view. It can store thousands of keys and translations in multiple languages.
It is easy to use for any type of user. To start translating, simply click on text input and enter your translation in the selected language.

Translation manager table view

You can customize the table view with different options, to make your work more efficient. All view options you can find in the Settings button in the top-right corner of the table.

Languages filter

By default, the table will display all project languages. If you are a translator, you can select only languages that you need for your work, for example, source and target languages.

Translation manager languages filter

Key descriptions

Have you ever encountered a problem with locating the translation key and finding out where was it placed in your app? Key descriptions are great help in such cases. 

You can put some help text there, or even add a link to a screenshot with key location! The link with a screenshot of the location will be clickable, and it will open in a new tab automatically. Key description will add more information and context to the key and save translators time, so they don't need to search for details or ask other team members for guidance.

Translation manager translation key descriptions

If you are using descriptions directly in your source code, you can also show them in the editor with Code Description option from view settings. 

Number of characters

Fitting translation texts in different languages to a fixed width element on your website or app, can be a challenging task. Use description column to determine maximum number of characters for keys in problematic locations, and translators will see their text characters count in the editor! 

Characters count indicator in translation manager

Save time on counting characters, checking if texts fit well enough. Translation text summary setting in SimpleLocalize will help you control such cases from the start.

Auto-translation indicator

Have you already tried the auto-translation feature? It's a great help in speeding-up the translation process for all users! When a key is auto-translated, you can use the option to show the auto-translation indicator near the affected text area. It will look like this, showing the translation service:

Auto-translation indicator in translation manager

With that option, you can see which keys were auto-translated and need to be verified. Editing such a translation manually will remove the auto-translation indicator. Use that feature to revise and confirm your translations with ease!

Search and sort your keys

Do you care only about new or not translated keys? Use sort option to quickly see the newest keys, recently modified translations or missing ones! Search bar will help you find a key or translation text. Those simple filters help in your daily work, when you need to update specific translations, or add and translate new keys.

Search and sort translation keys

List View

If you need a simple list of all keys with their properties and translations, switch to List View. It's a great option for more advanced projects that require specific information about the key or translation, like when it was created or its source file.

List view contains the list of keys separated in rows. You can expand each key to see translations for each language, key description and information when the key was created or last seen.

SimpleLocalize translation list view

Another option for the list view is Side-by-side view. It splits the view into two columns, so you can see two languages at one. Set the source at the left and target language on the ride side of the view. Below, you can show more information like key details, key or code descriptions.

SimpleLocalize translation list view

See all your keys

In this view, you can see all your project keys at once, and it's a great option for bigger projects, as it can easily store and display multiple keys. In just one view, you can see the progress of translations to all languages for each key and quickly check translations for selected language with  view options.

Quick translations reviewing

Moreover, list view has options to sort and search translations, as it works in table view.

For longer texts

List view is a great option for translating longer texts. In view settings, you make text areas bigger and choose the option to wrap text, so you can see all content without scrolling or expanding the area manually.

Translation editor for long translations

The option to show text summary with number of characters, words and white spaces will help you to control the text length.

Key namespace for multi-file translations

If you are using translations uploaded from multiple files, the list view can show you the key namespace (like file path). With that option, you can see from which file the key was uploaded, and that is very useful when you want to upload only the keys from your landing page (one of multiple folders) or from just one language.

Translation management and namespaces

Learn more about uploading and downloading translation files with CLI and multi-file option.

Customer-specific translations

List view gives you an option to translate your keys in multiple versions for one language. This feature, customer-specific translations, allow creating different translation version for specific customer's need. With that feature, you can tailor your app to your customer's needs or requirements, without changing the text and their meaning for other users of your product.   

Customer specific translations

Translation management

Wondering how to start with SimpleLocalize? Sign in with our free community plan and upload your translations. You can do it by importing an Excel file, with API or CLI. With your keys in the system, you can start translating them, adding more languages and sharing the project with your team. Use auto-translation feature to quickly translate your keys to new languages. 

For any doubts, contact Jakub, the creator of SimpleLocalize at jakub@simplelocalize.io.
]]></content:encoded>
            <category>tutorial</category>
            <category>tips</category>
            <category>translators</category>
            <category>developer</category>
            <category>software localization</category>
            <category>translation management</category>
            <category>translation editor</category>
            <enclosure url="https://simplelocalize.io/blog/translation-manager-explained.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[CLI 2.0 with multi-file support]]></title>
            <link>https://simplelocalize.io/blog/posts/multi-file-upload-download</link>
            <guid>https://simplelocalize.io/blog/posts/multi-file-upload-download</guid>
            <pubDate>Fri, 18 Mar 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn how to upload and download translations from complex project structures. Split translations into multiple files to improve loading speed.]]></description>
            <content:encoded><![CDATA[Hey there! In the latest update, I implemented a frequently requested feature which is multi-file support in a new version of SimpleLocalize CLI, and I wanted to share with you how to use it.
See the below updates that should help you in your daily translation and management work with SimpleLocalize. ☺️

How to download translation using command-line tool

Multi-file support

Multi-file support gives you a possibility to upload and download files which have a structure like below.

The newest version of CLI will automatically detect if you are trying to upload or download files with namespaces and/or languages.
Namespaces in the example above are home and common, and languages are ca, en, es.

How to upload translations?

To upload such a structure of translations, you can run command like below:

In the example above, {ns} is a namespace and {lang} is a language.

See upload command documentation page.

How to download translations?

Once you finish translating your content, you can run a download command to update translation files or/and add new ones!

See download command documentation page.

Options flag is now available

You can use CLI to download all available file formats. Some formats offer additional options, for example if you would like to download
an Excel file with translations and translation key descriptions, you can run:

You can see currently available options in the 'Data' tab in the project view, when Developer mode is turned on in the top-right corner.

export translations section

Additional options are also supported in the Upload command, and you can apply them respectively with --uploadOptions parameter.

Faster CLI and smaller file size

SimpleLocalize CLI 2.0 brings many small improvements, one of those is much smaller CLI size. The newest version is only 15 megabytes, comparing to the previous 1.1.x version with 50 megabytes. CLI still has zero dependencies,
which means you don't need to have Java, Python, node or any other software to run the CLI.

Other improvements:

better compatibility between operating systems,

new API which responds much faster for CLI requests,

better error handling,

more meaningful error messages.

How to update or install CLI?

To install CLI version 2.x, you can invoke the command below. It will automatically detect your operating system and download SimpleLocalize CLI.
If you would like to download CLI executable manually, without the script, you can find all CLI releases on GitHub.

How to check what CLI version I'm running?

You can simply check what is your current CLI version by running CLI with --version parameter.

Troubleshooting

If you have any troubles with CLI, please visit troubleshooting page for solutions.
You can also report the problem on GitHub.

What's next?

In the upcoming weeks, we would like to focus on adding more CLI small features based on the given feedback.

Stay tuned for more updates and new features! 🚀
]]></content:encoded>
            <category>product updates</category>
            <enclosure url="https://simplelocalize.io/blog/cli-multi-file-support.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to use auto-translation?]]></title>
            <link>https://simplelocalize.io/blog/posts/how-to-use-auto-translation</link>
            <guid>https://simplelocalize.io/blog/posts/how-to-use-auto-translation</guid>
            <pubDate>Thu, 10 Mar 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[Auto-translation is a powerful feature which helps you translate your app, website, game or other digital content to multiple languages with just one click.]]></description>
            <content:encoded><![CDATA[Auto-translation is a powerful feature which helps you translate your app, website, game or other digital content to multiple languages with just one click.

Using machine translation services for auto-translations can be extremely helpful to those who want to expand their reach on a global level without having to hire translators. Auto-translation works great for a start of app localization process, it creates translations instantly and with great results.

How auto-translation works?

SimpleLocalize is integrated with two most popular machine translation services, DeepL and Google Translate. You can choose between those two providers for the best translation results for your project.

Google Translate is a well-known translation service, and it provides a significant number of available languages. It's a great option if you need a translation to a less popular or uncommon language.

DeepL provides sightly more accurate translations than Google Translate and works better with idioms and slang. What's important in web translations, it can preserve custom translation format like HTML. DeepL works really well with texts written in Markdown. It offers 24 languages with many varieties, e.g., Portuguese and Portuguese (Brazilian). A really nice feature is also tone formality — you can select between formal or informal version in selected languages.

How to start auto-translation for many languages at once (March 2023)

Auto-translation by default won't override your existing translations, unless you decide to replace them. You can auto-translate only selected languages or all of them at once. Translations will be based on the source language, the best matching one for the machine translation service.

Auto-translation options

Glossary. With DeepL glossaries, you can create a predefined translation of a word or phrase in selected language pairs. A glossary will be applied during auto-translation using DeepL, and it's especially useful for auto-translating brand- or product-specific names.

deepl glossary

Excluding variables from translations. You can exclude selected text from auto translation using brackets { and } or another character type like \[], <> or (). Simply wrap the text, like here: There are {charsCount} characters left, to exclude it from translation. This option will help you translate texts with code snippets inside.

Excluding selected words or phrases. In Auto-translation settings, you can create a list of words or expressions that will be excluded from auto-translation. You can put there your company name or other proper names that you don't want to get translated.

auto-translation settings

Auto-publishing translations to CDN to the latest environment – if you are using SimpleLocalize translation hosting, auto-translated keys can be deployed to your development or staging environment directly.

Translating keys if no translation is available – if your source language has no translation, SimpleLocalize can use the key to work as the source for your translation.

With auto-translation, you can translate your app or website to a new language with just a few simple steps that we describe below.

How to translate your app with Google Translate or DeepL?

There are only 3 simple steps to auto-translate your app or website using SimpleLocalize. First, import your existing keys and translations to SimpleLocalize. Second, run auto-translate option. And final step, export ready to go translation files and add them to your project repo, or upload them with one click using SimpleLocalize translation hosting.

Import your translations to SimpleLocalize

There are multiple ways of importing translations to SimpleLocalize. You can use Excel, JSON or CSV file formats or import them automatically using CLI or API. Check out documentation for all details and instructions.

Import translations window

Start auto-translation

When your existing translation files are already imported to SimpleLocalize, you are good to go and start working on missing translations or add new languages to your project.   Auto-translation is a great help in the translation process. It can speed up the translation by providing a base for translator's review.

Auto-translate single translation

Sometimes you just need some help with translating a single translation key. Here comes our quick auto-translate option, which you can use directly in the translation editor in all editor views. Just click on the auto-translate icon in the language you are working on, confirm the settings and source language and hit Auto-translate.

How to auto-translate a single string in Translation Editor

Within a second, you can have a ready translation, without copying and pasting texts back and forth to the editor and machine translation provider.

Auto-translate languages

To translate all translations from selected languages, or all languages at once, go to the Languages. There, you can use the option Start auto-translation for selected language or Auto-translate all to use machine translation for all languages (more selected ones) with one click.

Auto-translate language

When you choose one of those options, you will see auto-translation settings with extra options. Select a translation service (DeepL or Google Translate), decide on extra options and start translation. You will see translation progress in the languages view.

Start auto-translation window

Export translations for your project

When the translations are ready, you can export the files and upload them to your project source code. Translation can also be updated automatically with SimpleLocalize CLI or CDN hosting.

Export translations to file

Automatic translation option is available in all SimpleLocalize plans, you can test it now and see how it works in your project. Create account in SimpleLocalize to start managing translations more efficiently and expand your business to new levels.

YouTube: How to quickly auto-translate JSON files?

Auto-translation advantages

Translating a website or app is a significant step in the process of expanding your business. It is a necessary part of localization, and will help you reach more customers who don't speak your native language.

There are many benefits to auto-translation, such as saving time and money on translation services. It also allows you to translate your website into any language without having to know the language yourself. It significantly speeds up the translation process, and using a translation management system, like SimpleLocalize, will help you to keep track of all changes in your project localization. 
]]></content:encoded>
            <category>deepl</category>
            <category>google translate</category>
            <category>auto translation</category>
            <category>machine translations</category>
            <category>tutorial</category>
            <enclosure url="https://simplelocalize.io/blog/auto-translation-how-to-use-it.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Product Update: Better Language Management]]></title>
            <link>https://simplelocalize.io/blog/posts/better-project-languages-management</link>
            <guid>https://simplelocalize.io/blog/posts/better-project-languages-management</guid>
            <pubDate>Thu, 03 Feb 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[See what's new in SimpleLocalize and learn how to use new features. This update focuses around language management and export menu.]]></description>
            <content:encoded><![CDATA[Hey there! Recently, a lot of new features and updates were added to SimpleLocalize, and I wanted to share some of them with you.
See the below updates that should help you in your daily translation and management work with SimpleLocalize.

Rearrange language order

Now, you can rearrange language order which will affect order in the translations view, and in the exported files. You can save languages order for the whole project, which will be used as default order for every
project contributor. Every user can rearrange the languages order on their own. Translators cannot change project order, but they can adjust the view for themselves.

To change language order, simply drag-and-drop the languages on the list. When the order is done, save the changes for the project or just for your own use.

SimpleLocalize: rearrange languages

Change language flags

Now you can change a flag for languages regardless of the language key. Adjust the flag manually for your project needs, so they correspond to the selected language.
Flags setup is a great way to organize your project, as you can recognize the language and location with just a glance.

SimpleLocalize: change flags for languages

Improved translation export menu

With the new update, you can export only selected languages to Excel formats. Use this option to export translation files for your translators, so they can see the file with just the source and target languages.
See the translation level with one click and decide which languages need to be exported for translators.

SimpleLocalize: export translations menu

What's next?

In the upcoming days, I would like to focus on:

adding subscription administrators

improving the table translation view

command-line interface app for software developers

option to review translations

and more

Stay tuned for more updates and new features!
]]></content:encoded>
            <category>product updates</category>
            <category>excel</category>
            <enclosure url="https://simplelocalize.io/blog/better-language-management.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[The complete guide to managing translation projects with Excel]]></title>
            <link>https://simplelocalize.io/blog/posts/excel-translation</link>
            <guid>https://simplelocalize.io/blog/posts/excel-translation</guid>
            <pubDate>Sun, 28 Nov 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[This complete guide will teach you how to manage translations with Excel spreadsheets. Start translating your project efficiently with Excel and our Excel auto-translation option.]]></description>
            <content:encoded><![CDATA[Excel is a very popular tool for translation management, especially in smaller projects. It can be used to maintain an overview of translation keys, translators, languages, and deliverables at the same time.

The benefits of Excel are that it is flexible, collaborative, scalable, and easy to use. It can meet the needs of small-scale translation projects as well as projects with many active translators and large-scale translations.

How to use Excel as a translation management tool

Excel is a great tool to start translation management in a new project. With a simple Excel file, you can check the current translation version, progress of translating new keys or languages, and share the file easily with your team members.

How to create a spreadsheet for project translations

How to get started? Create a new file in Excel or Google Sheets and start by naming your columns. The best way is to extract or copy translation keys from your project, and put them in the first column.

Next, add language columns and their translations in corresponding cells. Have a look at the sample translation for our PlaceFlare app. Quite easy, right?

Translations in Google Sheets

This is a basic and simple translation template which will work perfectly for your project.

Here are some useful tips for translating in Excel:

Freeze key column to easily scroll between languages if there are many.

Add an extra column where you put a screenshot or image of the translated area — sometimes you may not remember where the key came from. With the screenshot, you can associate the key and its location.

Use international codes for naming language columns (e.g., en, es) together with its locale like en-GB, es-ES, es-CL. It will be easier to start with internationalization sooner than deal with it later.

Make one language your main one and fully translate it first. It will be a base for translating other languages.

How to work with Excel translation files?

An Excel file is a great tool for translations, but it still needs to be uploaded to your app or website. The file allows you to control easily updated texts, add languages and modify translations, but it doesn't connect directly with the source code.

Translations in Microsoft Excel and JSON

Usually, you need to convert the Excel file to JSON. Remember that when translation changes, there is a new feature or update, you have to edit the file and give the updated version to your dev team to replace the existing translations in the code.

Auto-translation in Excel

Today we can use a variety of online resources to automatically translate texts with a very high level of precision. The most popular tools online are DeepL and Google Translate or OpenAI ChatGPT. You can use them as a great help with translating texts, or use built-in translation features or plugins. Here are some examples of auto-translation option for Excel files:

Google Sheets translation formula

You can translate text in Google Sheets with integrated formula from Google Translate. Just type in a selected cell this formula: =GOOGLETRANSLATE(cell to translate, “source language”, “target language”), for example:

Translations in Google Sheets

Then spread the formula for the entire column and work the same way for other languages.

Microsoft Excel Translate

Microsoft Excel has a special function for automatic translations, called Translate. You will find it under Review tab. Check how to use this option in the official Excel translation guide.

Auto-translate with OpenAI, DeepL or Google Translate

Instead of the manual work with Excel options, you can use a translation management tool which has dedicated options for seamless automatic translations.

Auto-translation with SimpleLocalize

How does it work?
Login to SimpleLocalize with free Community plan and create your project. Then, with one click, upload your existing Excel file and hit Start auto translation button.

SimpleLocalize will auto-translate with OpenAI, Google Translate or DeepL for selected languages. In a few seconds, you can have your project fully translated and ready to go!

Auto-translation with SimpleLocalize

When your translations are ready, you can export them to many supported formats, also Excel, or upload translations automatically with CLI.

Pros and Cons of using spreadsheets for translation Management

Using spreadsheets as translation management tool is a popular choice for many projects, but it has its pros and cons, especially compared with a dedicated translation app:

Pros:

simple to import and export data

helps to track changes in a translation file

easy to use and well known for everyone

allows sharing files with the team

no, or very low cost

Cons:

a lot of manual work with copy-pasting texts and formulas

not so user-friendly and simple enough for translations (not designed to be a translation management tool)

requires frequent file changes and manual uploads of new translations

difficult to keep track on new translations and removing not used translation keys as its very time-consuming task

SimpleLocalize translation editor

Easy Excel file translation with SimpleLocalize

SimpleLocalize is a simple, intuitive way to manage internationalization in Excel. It's data-driven, easy to use, and saves time on tedious processes that are otherwise challenging to automate.

Import your current Excel files to SimpleLocalize and start translating your projects efficiently with auto translation features. Start now with our free Community plan and check how SimpleLocalize can help you in your work!
]]></content:encoded>
            <category>excel</category>
            <category>auto translation</category>
            <category>translation management</category>
            <category>deepl</category>
            <category>software localization</category>
            <enclosure url="https://simplelocalize.io/blog/translations-in-excel.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[GitHub Actions available!]]></title>
            <link>https://simplelocalize.io/blog/posts/github-actions-for-localization</link>
            <guid>https://simplelocalize.io/blog/posts/github-actions-for-localization</guid>
            <pubDate>Sun, 28 Nov 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[GitHub Actions integration for Continuous Localization is available on GitHub Market! Connect your GitHub repository to SimpleLocalize i18n editor for free!]]></description>
            <content:encoded><![CDATA[GitHub Actions is a new way for developers to automate their work.
Actions are simple, yet powerful, pieces of code that can be written in
any language, and run in the cloud. They're designed to help you ship great software faster by enabling your whole team to collaborate
on building and maintaining automation pipelines.

Github Actions Market - Upload Translations from File Action

GitHub Actions integration for Continuous Localization is available on GitHub Market! Connect your GitHub repository to SimpleLocalize i18n editor for free!
The integration with GitHub Actions enables customers to build a workflow where content is automatically added to SimpleLocalize i18n editor.
You can import translations on every branch update or just on pull request. Mange, edit, or review translations in SimpleLocalize Editor and once you are ready, push them to the CDN or save changes and download using GitHub Actions.

How to start?

It's simple, create a new yml file in .github/workflows directory and put SimpleLocalize actions code to download or upload file with translations.

Github Actions - example download translations action

Resources:

Sample Project with continuous localization

Upload Action

Download Action
]]></content:encoded>
            <category>github</category>
            <category>developer</category>
            <category>integration</category>
            <enclosure url="https://simplelocalize.io/blog/github-app/github-actions-for-localization.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Number formatting in JavaScript]]></title>
            <link>https://simplelocalize.io/blog/posts/number-formatting-in-javascript</link>
            <guid>https://simplelocalize.io/blog/posts/number-formatting-in-javascript</guid>
            <pubDate>Sun, 28 Nov 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[Discover the power of 'toLocaleString' functions in JavaScript. Format numbers, currencies, and units without any 3rd party localization library.]]></description>
            <content:encoded><![CDATA[Discover the power of toLocaleString() function in JavaScript. Format numbers, currencies, and units without any 3rd party localization library.
In simple words, the toLocaleString() method converts a number into a string, using locale format. By default, it uses locale from web browser language, but you can specify it manually.

Syntax

Parameters

locale (optional) - if not provided, then the method will use the host environment's current locale (e.g., : default browser language)

options (optional) - object with formatting options

Limit to two significant digits

Use default locale and custom number formatting

Put undefined as first parameter, to use default locale set in browser.

Change formatting style

Style property can have 3 different values:

decimal (default)

currency

percent

unit

In this article, we go through every style.

Style: Currencies

Use style property in options object with value currency to format number into a string.

You can adjust currencyDisplay property to change currency formatting. Possible values are:

symbol (default)

code

name

Style: Percentages

Percentage localization is a non-trivial task in some languages.
Not in every language, percentage sign comes after a number.
For example, in Arabic languages.

Style: Units

Units style is one of the most understated JavaScript locale features. It allows you to format
number into any popular units with proper formatting for given locale.

Example with liter unit

Use unit property in options object to set a desired unit.

You might also want to adjust unitDisplay property to show full word instead just one letter.

The shortest version you will get with narrow value in unitDisplay.

List of JavaScript number locale units

Below, you can check all possible values for unit property.

unit value |
\--- |
acre
bit
byte
celsius
centimeter
day
degree
fahrenheit
fluid-ounce
foot
gallon
gigabit
gigabyte
gram
hectare
hour
inch
kilobit
kilobyte
kilogram
kilometer
liter

unit value |
\--- |
megabit
megabyte
meter
mile
mile-scandinavian
milliliter
millimeter
millisecond
minute
month
ounce
percent
petabyte
pound
second
stone
terabit
terabyte
week
yard
year

Kilometer per hour

You can combine two values using per keyword, like X-per-Y. For example, kilometer-per-hour.
JavaScript will choose the best-fit localized pattern to format this compound unit.

Terabyte per gram

The unit property doesn't have to make sense, it accepts any combination. 😊

Resources:

tc39.es/ecma402

React Localization libraries
]]></content:encoded>
            <category>javascript</category>
            <category>developer</category>
            <enclosure url="https://simplelocalize.io/blog/number-formatting-in-javascript.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Localization: Tips & Tricks]]></title>
            <link>https://simplelocalize.io/blog/posts/i18n-tips-and-tricks</link>
            <guid>https://simplelocalize.io/blog/posts/i18n-tips-and-tricks</guid>
            <pubDate>Sat, 27 Nov 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[Avoid common problems with localization by following these practical tips. These insights will help you save time, avoid UX issues, and improve your i18n strategy.]]></description>
            <content:encoded><![CDATA[Localizing your product is a powerful way to reach global markets and grow your user base. But localization done poorly can actually hurt your product, confuse users, and increase support tickets.

Here are practical tips to help you avoid common localization issues and build better internationalized products.

1\. Give your texts enough space

Always plan your UI with expansion in mind. A good rule of thumb: if English text fits, make sure the translation can be up to 2× longer and still fit gracefully. Languages like German or Finnish often produce longer translations, and long compound words can easily break tight layouts.

Use the soft hyphen character \&shy; to allow elegant word breaking. It only shows the hyphen when needed.

You can use online tools to insert hyphenation points:

ushuaia.pl

hyphenation24.com

hyphenator.net

juiciobrennan.com/hyphenator

Text expansion examples in German

2\. Check translations in context

A translated string that looks fine in isolation might completely break the layout, UI flow, or user expectations. Always test translations in context, either:

in a staging environment,

using in-context translation tools,

or with visual QA review post-deployment.

Set character limits in your TMS to match the UI space where translations appear. A 40-character string in English might turn into 70 characters in Finnish: plan accordingly. Small overflows can cause serious UI glitches.

Example of a character limit rule in SimpleLocalize

3\. Don't rely on AI or machine translation alone

Machine translation has come a long way, but it's not a substitute for human review. AI often misses context, idioms, cultural nuances, or correct formatting.

Poorly translated content gives users the impression that your product wasn't localized with care, and that reflects on your brand. Worse, it can create misunderstandings or legal issues in regulated industries.

Always have a native-speaking reviewer check translations, especially for customer-facing content.

Example of a machine translation error

4\. Be mindful of HTML elements in translatable strings

When your strings include HTML or UI markup, placement matters. Different languages have different sentence structures, word order, and emphasis.

For example, if your English string is:

In some languages, the correct emphasis might fall on a different part of the sentence. Make sure you allow for flexible tag placement or provide translators with context so they know what can move and what can't.

E.g. in Polish, the translation might be:

5\. Keyword research ≠ Translation

If you're localizing marketing content, don't just translate your keywords—research them. Direct translations often have zero search volume in the target market.

Use tools like:

Google Keyword Planner (set target language/region)

Google Trends - compare keyword volume by country/language

Ahrefs Keywords Explorer - Deep keyword data with search volume per language/country

Semrush Keyword Magic Tool - Comprehensive keyword research tool

Native speakers or SEO experts

Translated vs researched keyword

6\. Automate updates, but review carefully

Use automation to keep translations up to date when source content changes. For example:

When the original English text changes,

Automatically re-translate the string,

Flag it for review by a human.

This hybrid approach (automation + review) keeps content fresh without sacrificing quality. Check out our blog post on automating translation updates for more details.

Auto-translation and review automation

7\. Format numbers & dates properly

Numerical formatting varies across languages:

Use toLocaleString() (check details on MDN Web docs) or internationalization libraries to display locale-specific formats. The same applies to percentages, where spacing and placement vary:

50% in English

%50 in Turkish

٥٠٪ in Arabic

8\. Keep datetime in UTC

Handling datetime correctly is crucial for a consistent user experience across time zones. Here are best practices:

Always keep datetime in database in UTC.

Always return datetime from backend in UTC.

Adjust datetime on UI layer using timezone information from user or web browser.

Accept datetime in backend with any timezone.

You don't need any special library to format time from UTC to local for users. You can use standard JavaScript Date object like above.

The main benefit to that is that the time is always guaranteed to be consistent.
However, if you would like to reproduce some bug for a user in different timezone, it might be more challenging.
You will be forced to change timezone in your web browser to get the same data as your users sees.

9\. Watch out for Greek question marks

The Greek question mark ; is often mistaken for a semicolon ;.
The former marks the end of a sentence or phrase, while the latter is used to separate clauses in the same sentence.

Greek question mark

10\. Use 'ruby' tag for Japanese furigana

Japanese text often includes furigana (small phonetic characters above or beside kanji). Use the \<ruby> HTML element to mark these up correctly:

This ensures proper rendering across browsers and devices. Avoid using images for furigana, as they don't scale well and are not accessible.

Ruby usage in a Japanese website

11\. Try pseudo-localization to catch issues early

Pseudo-localization is a technique where you replace original text with “accented” versions or add padding to simulate translation:

This helps identify hardcoded strings, layout and truncation issues, or missing translations before real localization starts.

12\. Support right-to-left (RTL) languages

Languages like Arabic, Hebrew, Persian, and Urdu require right-to-left layout support. This is not just text direction, but full mirroring of your UI:

Use dir="auto" or dir="rtl"at the document or component level.

Mirror layout direction: navigation, icons, progress bars, sliders, etc.

Use logical CSS properties:

instead of margin-left, use margin-inline-start

instead of float: left, use float: inline-start

Test your UI with RTL languages to ensure everything displays correctly (e.g. with lang="ar" and dir="rtl" set in \<html>.)

Check out the guide on RTL styling 101 for more details on how to implement RTL support.

13\. Extract translatable texts properly

Hardcoded strings are localization's biggest enemy.

Use i18n frameworks (e.g., react-intl, i18next, vue-i18n) that extract strings from your code.

Avoid putting user-facing text in:

JS logic (e.g., if (error === "User not found"))

CSS (e.g., content: "Loading...")

You can use AI to help extract translatable strings from your codebase. Check out our blog post on automatic string extraction with AI for more details.

Example of extracted strings

14\. Avoid concatenating translatable strings

Concatenation creates grammar and context issues. Instead of:

Use

Even better: use pluralization support for locale-aware grammar:

Make those variables clear for translators. TMS like SimpleLocalize provide a translation editor that allows translators to see the context and variables used in the string.



15\. Use locale-aware sorting

When sorting lists, use locale-aware functions to ensure correct order:

This sorts items according to the rules of the specified locale, taking into account case and accents.

16\. Provide fallback translations

Don't leave users with missing translations.

E.g., if fr-CA isn't available, fall back to fr or even en.
Use a fallback mechanism in your i18n library:

17\. Use a translation management system (TMS)

A TMS like SimpleLocalize helps you manage translations efficiently:

Centralize all your translations in one place.

Automate updates and sync with your codebase.

Collaborate with translators and reviewers.

Track translation progress and run QA checks.

Provide in-context editing for translators.

Integrate with your CI/CD pipeline for seamless updates.

Support multiple file formats (JSON, YAML, etc.).

Using a TMS saves time, reduces errors, and improves translation quality. It also allows you to scale your localization efforts as your product grows.

Try SimpleLocalize and see how it can make your localization process smoother and more efficient.
]]></content:encoded>
            <category>tips</category>
            <category>i18n</category>
            <category>developer</category>
            <enclosure url="https://simplelocalize.io/blog/localization-tips-and-tricks.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Top language selector UX examples]]></title>
            <link>https://simplelocalize.io/blog/posts/ui-design-language-selector-examples</link>
            <guid>https://simplelocalize.io/blog/posts/ui-design-language-selector-examples</guid>
            <pubDate>Sat, 13 Nov 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[Discover 10+ of the best language selectors used by global brands like Duolingo, Canva, and Shopify. Get UX inspiration for your multilingual website.]]></description>
            <content:encoded><![CDATA[A well-designed language selector does more than change text — it empowers global users, improves accessibility, and elevates the overall user experience.

Choosing the right design can be challenging. Flags, dropdowns, auto-detection — what works best, and when? To help answer that, we analyzed and categorized dozens of real-world examples. This guide highlights common patterns, compares design choices, and offers practical UX insights for building better multilingual interfaces.

Read our guide on building a language selector with Tailwind CSS.

Top 10 language selector examples

Here, we present a list of the most beautiful and interesting language selectors we have found, along with a brief description of each. These examples showcase various approaches to language selection, from dropdowns to flag-based selectors, and highlight the importance of user experience in multilingual applications.

Canva

Canva, the popular graphic design platform, features a language selector in the footer of its website. This discreet placement allows users to change languages without interrupting their design workflow.

Canva language selector

Company: Canva

Selector type: Dropdown

Placement: Footer

Uses flags: No

URL structure: /{locale}, e.g., /en_gb

Special features: Search bar

What sets Canva's language selector apart is the built-in search bar, enabling users to quickly find their preferred language, especially useful with such a large list of available options.

Canva currently supports over 100 languages (104 at the time of writing), underscoring its global reach. Localization is clearly a priority for Canva, and the language selector reflects this commitment to accessibility and inclusivity.

Canva offers seven Spanish language variants — for Argentina, Colombia, Latin America, Mexico, Spain, and the United States — making it an excellent example of how to handle regional language variations in a multilingual product.

The URL structure is also localization-friendly, using clear locale codes like /en_gb or /es_mx. This approach not only simplifies language-specific linking and sharing but also aligns with SEO best practices.

Ahrefs

Ahrefs, a leading SEO tool, goes beyond simple translation by localizing content for specific regions, significantly boosting traffic and user engagement. You can learn more about their strategy in the Ahrefs blog post on localization SEO.

Ahrefs language selector

Company: Ahrefs

Selector type: Dropdown

Placement: Header & Footer

Uses flags: No

URL structure: /{language_code}/, e.g., /es/, /fr/

Ahrefs features its language selector in both the header and footer, making it easy for users to switch languages no matter where they are on the site. The selector is a clean dropdown list, accompanied in the header by a globe icon — a universally recognized symbol for language selection that enhances usability.

Currently, Ahrefs offers its platform in 14 languages, including Korean, Japanese, and Indonesian. This multilingual approach reflects the company's strong focus on international growth and accessibility.

By prioritizing localized content and user experience, Ahrefs has seen notable growth in traffic from non-English-speaking markets — a compelling case for investing in localization.

Their URL structure follows a simple and user-friendly pattern, with each language version organized under a dedicated language code (e.g., /es/ for Spanish, /fr/ for French). This approach not only aids navigation and SEO but also helps users share links in their preferred language.

JetBrains

JetBrains, a well-known software development company, features a language selector in both the header and footer, ensuring that users can easily change languages at any point during their visit.

JetBrains language selector

Company: JetBrains

Selector type: Dropdown

Placement: Header & Footer

Uses flags: No

URL structure: /{locale}, e.g., /es-es/

JetBrains uses a wide dropdown layout for its language selector, with language options organized in columns. This structure improves readability and ease of use, especially when offering multiple languages.

The selector is marked by an icon that combines a Chinese character ("文") with a Latin letter "A" — a widely recognized symbol representing multilingual or translation options.

JetBrains currently supports 9 languages, catering to a global audience of developers and engineers. The selector's minimalistic design makes it easy for users to switch languages without visual clutter or distraction.

The inclusion of a country/region selector allows JetBrains to further tailor its content and services based on the user's geographic location.

Their URL structure follows a clear locale-based pattern (e.g., /es-es/), ensuring that language-specific content is easily accessible and shareable.

Prezi

Prezi, known for its dynamic presentation software, takes a slightly different approach to localization and language selection. Instead of a traditional dropdown or flag-based menu, Prezi features a simple language selector in the footer.

Prezi language selector

Company: Prezi

Selector type: List

Placement: Footer

Uses flags: No

URL structure: None (uses server-side localization)

The language options are presented as a plain text list in the footer, allowing users to select their preferred language with a single click. This minimalist design is clean and unobtrusive while still providing essential functionality.

Prezi currently supports 13 languages, and its language handling differs from most websites: there is no distinct URL structure for each language version. Instead, Prezi uses server-side localization, meaning content is dynamically served based on the user's language preference.

This approach ensures a consistent URL across languages, which can be beneficial for user experience and content management, though it may have some trade-offs for SEO and link sharing.

Prezi's design reflects a focus on simplicity, removing visual noise while still offering clear access to multilingual support.

Notion

Notion is a versatile productivity workspace for teams and individuals, and it has implemented a language selector that is both functional and user-friendly.

Notion language selector

Company: Notion

Selector type: Dropdown

Placement: Footer

Uses flags: No

URL structure: /{language_code}, e.g., /es

Special features: Dual-language labels

Notion's language selector is located in the footer of the website, making it accessible without interfering with the core user experience. It features a minimal, clean dropdown menu for selecting the preferred language.

What makes Notion's implementation stand out is its dual-language labeling. Language names are shown in both the current site language and the target language — for example, "Deutsch / Allemand" — which improves clarity and makes selection easier for multilingual users or those switching languages in unfamiliar interfaces.

Notion currently supports 10 languages, including regional variants such as Spanish (Spain) and Spanish (Latin America). This reflects Notion's continued commitment to localization and accessibility for its growing global user base.

Notion's dual-language design is a thoughtful touch that enhances usability and inclusivity, especially for users navigating in a second or third language.

The URL structure is simple and clean, using locale codes (e.g., /es) to distinguish different language versions.

Wix

Wix, one of the most popular website builders, offers a thoughtfully designed language selector to support its global audience. It allows users to easily switch between languages and explore Wix’s services in their preferred language.

Wix language selector header view

Wix language selector

Company: Wix

Selector type: Overlay

Placement: Header

Uses flags: No

URL structure: Subdomain, e.g., es.wix.com

Wix's language selector is placed in the header, indicated by a globe icon with language initials. When clicked, it opens a large full-screen modal that displays available languages in a clean, spacious layout. This format allows for additional context (like region or site variations) and provides a better experience when dealing with many language options.

Currently, Wix supports 22 languages and uses a subdomain-based structure for localization (e.g., es.wix.com for Spanish). This setup not only enhances SEO but also makes it easy for users to share language-specific links.

Wix's use of a full-screen modal provides both clarity and scalability — a user-friendly solution for multilingual websites with many localization options.

Mango

Mango, a global fashion and lifestyle brand, takes a unique approach to localization by using a region selector instead of a traditional language dropdown or flag-based menu.

Mango region selector

Company: Mango

Selector type: Region selector

Placement: Pre-website entry

Uses flags: No

URL structure: /{country}/{language_code}, e.g., /gb/en

When users first visit the site, they are greeted with a pre-entry region selector, where they choose their country — and in some cases, their preferred language. This selection determines not only the language of the site but also the available products, prices, and shipping options, tailoring the experience to the local market.

This method ensures a seamless and localized shopping experience from the first interaction. However, it's worth noting that language is tied to the selected country, which means users can't easily switch languages independently of their region.

The site's URL structure reflects the chosen country and language in a clear and SEO-friendly format (e.g., /gb/en for English in the UK). This makes localized pages easier to share, bookmark, and index.

Mango's region-first approach is ideal for global e-commerce, prioritizing relevance and logistical accuracy over flexibility in language switching.

Duolingo

As a leading language learning platform, Duolingo places a strong emphasis on accessibility and multilingual user experience. Its language selector is designed to be both highly functional and visually intuitive.

Duolingo language selector

Company: Duolingo

Selector type: Dropdown (Header) & List (Footer)

Placement: Header & Footer

Uses flags: Yes

URL structure: Subdomain, e.g., es.duolingo.com

Duolingo features two language selectors:

A primary dropdown in the header, prominently labeled with "Site language” alongside the currently selected language.

A comprehensive list of languages in the footer, offering a quick-access overview for users who scroll to the bottom.

The header dropdown includes flag icons next to each language, which adds a visual cue and makes the menu more engaging — though flags may be controversial, they are commonly used in language learning platforms and serve a clear purpose here.

Duolingo displays flag icons next to each language — a visually engaging, but sometimes debated design choice. Read more about the pros and cons of using flags in language selectors.

Duolingo language selector footer

Duolingo currently supports 28 website languages, enabling users across the globe to navigate the platform in their native tongue. The site uses a subdomain structure for localization (e.g., es.duolingo.com for Spanish), which is effective for SEO and link sharing.

Duolingo's multi-placement approach — pairing a visible, user-friendly dropdown with a complete footer list — reinforces its mission of making language learning accessible and inclusive for everyone.

Discord

Discord is a popular communication platform used by gamers, creators, and communities worldwide. Its language selector reflects the platform's modern design and commitment to accessibility.

Discord language selector

Company: Discord

Selector type: Dropdown

Placement: Footer

Uses flags: No

URL structure: None (uses server-side localization)

The language selector is located in the footer, offering a non-intrusive way for users to switch languages. It features a clean dropdown menu that lists all available languages in plain text, maintaining a minimalist and intuitive interface.

Discord intentionally avoids using flags, opting for language names only. This decision minimizes potential confusion and ensures a more inclusive, neutral design across cultural contexts.

The platform currently supports 31 languages. Rather than using separate URLs or subdomains for different languages, Discord implements server-side localization, meaning content is dynamically rendered based on the selected language, providing a seamless and consistent experience.

Shopify

Shopify, a leading e-commerce platform, offers a thoughtfully designed language selector that enhances usability for its global audience.

Shopify language selector

Company: Shopify

Selector type: Dropdown

Placement: Footer

Uses flags: No

URL structure: /{country}-{language_code}, e.g., /es-es?country=es\&lang=es

Special features: Multiple languages per country

Shopify's language selector is located in the footer, represented by a globe icon accompanied by the current country and language. When clicked, it opens a large dropdown menu that allows users to choose both their region and preferred language.

What stands out is Shopify's support for multiple languages within the same country. For example, users in Spain can select English instead of Spanish, offering greater flexibility and a more personalized experience. This is especially valuable for international users living abroad or businesses with multilingual teams.

The selector is clean and intuitive, avoiding the use of flags in favor of clear text labels. This design choice avoids potential cultural misrepresentations and keeps the interface accessible and neutral.

Shopify uses a well-structured URL format, combining country and language codes with query parameters, such as es-es?country=es\&lang=es. This format supports both localization and SEO, while making it easy to share language-specific links.

If you are using Shopify for your online store, check out our guide on how to localize your Shopify store with SimpleLocalize.

More inspirations

Check out below some additional language selector examples that showcase different design approaches and functionalities. Draw inspiration from these designs to create a language selector that fits your website's needs.

Mews and Figma development teams have created simple and elegant language selectors that can be easily integrated into your projects.

Mews & Figma language selectors

Airbnb offers an option to automatically translate content that is not available in user's language, and presents the list of available languages in a dropdown menu.

Miro also has a simple language selector in the footer, allowing users to switch languages easily.

Airbnb & Miro language selectors

Booking.com and Trustpilot have decided to use a more visual approach, displaying flags next to the language names in their selectors. This can be helpful for users who are more visually oriented.

Booking.com & Trustpilot language selectors

Spotify presents a language selector in the footer, displaying the language names in their native scripts and current language. It is great solution to make it easier for users to find their preferred language.

GoDaddy, a popular web hosting and domain registration company, has a language selector in the footer of its website. The selector is a simple list of countries with their respective languages, allowing users to easily switch between them.

Spotify & GoDaddy language selectors

Ikea and Wise include location selection in their language selectors to match their offerings to the user's region. This approach ensures that users see content relevant to their location, such as product availability or local services. Wise allows users to additionally selected a different language than the one spoken in their country, providing flexibility for multilingual users.

Ikea & Wise language selectors

Automa.net and Fundeen have implemented language selectors that are pulling translations from SimpleLocalize. This integration allows for easy management and updates of translations, ensuring that users always have access to the latest content in their preferred language.

Check out how they are using our translation management software to manage their multilingual content effectively:

Automa.net case study: Automa.net case study

Fundeen case study: Fundeen case study

Automa.net & Fundeen language selectors

If you know any other interesting language selector examples, please let us know at contact@simplelocalize.io and we will add them to the list!

8 lessons from great language selector UX

After analyzing these language selectors, we can draw several key observations and conclusions about effective design and functionality:

Make it accessible – Keep selectors visible in headers or footers.

Keep it minimal – Avoid visual clutter; dropdowns work well.

Avoid flags – Many brands now use plain text for cultural neutrality.

Add a search bar – Helpful for platforms with many languages.

Use dual-language labels – Improves clarity for non-native users.

Account for regions – Regional variants (e.g., es-MX vs es-ES) matter.

Optimize URL structure – Use /locale, subdomains, or query strings.

Consider server-side rendering – Great for consistency, but impacts SEO.

Not sure what the difference between a language and a locale is? We've got you covered.

How to manage your website translations

If you're looking for an easy way to manage your website translations, give SimpleLocalize a try. It's a powerful yet user-friendly translation management system (TMS) that lets you manage translations, collaborate with your team, and integrate multilingual content into your app or website effortlessly.

With SimpleLocalize, you can:

Manage translations easily: Add, edit, and organize translations with a simple UI.

Collaborate with translators: Invite team members or professional translators to your project.

Integrate with your website: Use our integration guides to connect with your frontend or backend stack.

Automate translation updates: Sync translations with your codebase using CLI or CI/CD tools.

Host translations in the cloud: Secure, fast, and accessible translation hosting from anywhere.

Get expert support: Our team is here to help you succeed.

SimpleLocalize's translation editor

Ready to create a better language selector for your site or app?
Try SimpleLocalize — a powerful and developer-friendly translation management system.

Manage strings, invite translators, sync with your codebase, and deliver a seamless multilingual experience.
]]></content:encoded>
            <category>language selector</category>
            <category>design</category>
            <category>developer</category>
            <category>designer</category>
            <category>accessibility</category>
            <category>ui</category>
            <enclosure url="https://simplelocalize.io/blog/language-selector-examples.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to create a multi-language website in GatsbyJS?]]></title>
            <link>https://simplelocalize.io/blog/posts/gatsby-i18n</link>
            <guid>https://simplelocalize.io/blog/posts/gatsby-i18n</guid>
            <pubDate>Mon, 09 Aug 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[Create a multi-language GatsbyJS website with a few simple steps. A multi-language website is a great way for your company to reach a wider audience.]]></description>
            <content:encoded><![CDATA[Background

In this article, I will show you how to create a multi-language landing page in GatsbyJS.
I assume you already set up a Gatsby project, and we will start right from adding multi-language pages.

Check our template repository on GitHub.

Install dependencies

I will use FormatJS library as it's one of the most popular React library for internationalization, and it plays nice
with a Gatsby plugin system.

Create i18n configuration file

Create a i18n.js file in your src directory to keep all i18n configuration in one place.

Add utility functions

Create a new file with utility functions. I named it linkUtils.js and I put this next to i18n.js file in the src directory.

getTranslatedPath Function returns a route to a page with the same language as the current page.

getCurrentPageLanguage Function returns language from current page path.

Create custom link component

To give a user to navigate through our website and keep the page language, we need to create a custom \<a/> element.

Now we can use LinkTranslated same as a regular \<a/> tag from HTML.
We can pass a href property with base link to some page, and it will be converted into a translated link.

Learn more about hrefLang attribute.

I used Location component from @reach/router, to get access to the location object.

Add a wrapper for IntlProvider

The main role of this component is to simplify a usage of \<IntlProvider/> on every page.

Add translations

Create a i18n-translations.json file with translations for all languages.

Managing a big JSON file like this might be hard and done only by a software team. This is the reason we created
SimpleLocalize where you can manage JSON files like this with ease, automatically upload and download them and use
OpenAI, Google Translate or DeepL to auto-translate the texts. Try it for free now

Configure multi-language page generation

Now, edit your gatsby-node.js configuration file and override onCreatePage function like below.

Many things are happening here, right? Let start from the beginning.

First of all, import translations.json file from root directory

Use deletePage to remove default page created by Gatsby

Iterate over all languages from i18n.js

Add /{language} to path if the language is not the default one

Get translations for given language from messages object

Add language and messages to a page context

Use createPage to recreate a page with a new path and translations

Create a first multi-language page

Create index.js in /src/pages directory and paste code below:

SimpleLocalize Component will provide a \<IntlProvider/> and intl object for \<FormattedMessage/> components.

Create second multi-language page

Create file about.js in /src/pages directory and paste code like below:

Result

Now, start your project with npm run develop and you should see

Multi-language Gatsby project example

Full code can be found on GitHub: github.com/simplelocalize/multi-language-gatsby-example

Message extraction

Uploading extracted translation keys to translation editor

In the repository, you will also find additional scripts in package.json.

I installed @formatjs/cli as a devDependency to extract all translations and IDs from \<FormattedMessage/> components.

I used simplelocalize-cli to upload found IDs and download ready-to-use translations.

Scripts explanation:

npm run extract script will extract translations to i18n-extracted.json

npm run sync script will upload found translation keys from i18n-extracted.json and download the latest translations from the server to i18n-translations.json

Once you change a translation in JSON file, you need to restart GatsbyJS to see the effect. Sometimes you might not see a changed translation, then you need to run npm run clean before npm run develop.

Editing translations in SimpleLocalize

Below you see a screenshot from a sample project which I pushed on GitHub. Now, I can manage all translations from one place, add more languages and use OpenAI ChatGPT, DeepL or Google Translate to automatically translate them and use in my Gatsby page.

Manage your translation strings in Translation Editor

Multi-language content with properly used hrefLang attributes will score much higher in SEO results.
]]></content:encoded>
            <category>gatsby</category>
            <category>react-intl</category>
            <category>format-js</category>
            <category>react</category>
            <category>i18n</category>
            <category>developer</category>
            <enclosure url="https://simplelocalize.io/blog/gatsby-multi-language.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to use code splitting with JSON files in React application]]></title>
            <link>https://simplelocalize.io/blog/posts/lazy-loading-resources</link>
            <guid>https://simplelocalize.io/blog/posts/lazy-loading-resources</guid>
            <pubDate>Fri, 06 Aug 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[Lazy load JSON resource with language translations to speed up your React application. Use built-in code-splitting feature to load JSON files.]]></description>
            <content:encoded><![CDATA[Code-splitting for resources

Code-splitting is a built-in function in many code bundlers like Webpack. It's used mostly to lazy load only required JavaScript code or other resources.
It helps in improving application performance by loading only required parts of the application, instead of fetching all resources at once.
This is a perfect solution for localization purposes to load translations for only one language instead of all of them to speed up your web application.

Medium-sized web application with about 1000 unique translation keys can contain about 50kb translated messages for one language. If you would
support 10 languages in your app, whole translation file could have size nearly 1 megabyte.

Learn more about code-splitting in React.

How to lazy load JSON file in React?

Here is the asynchronous function TypeScript, which accepts languageKey as a string and returns a loaded JSON file as an JavaScript object.

How to use lazy load in React app?

Here is the full example code for lazy loading translations from local JSON files. The code is written in TypeScript,however, it should be easy to convert into plain JavaScript.

React will invoke:

the first useEffect hook only once on every page re-render. We are getting the language from web browser. Learn more about navigator.language object.

the second useEffect hook when locale value is changed to lazy load different JSON file with translations.

You cannot invoke async functions in useEffect React hook, that is why we create a new loadJsonAsync function.

Check example how to load translations from backend using a standard fetch API.

Use loaded JSON messages with IntlProvider

To use loaded JSON messages with FormatJS, you can simply pass locale variable and messages object as props
to IntlProvider.

children variable should contain your React component or even a whole application (e.g., \<App/>) in which you want to provide translations.
]]></content:encoded>
            <category>react localization</category>
            <category>javascript</category>
            <category>json translations</category>
            <category>lazy loading</category>
            <category>developer</category>
            <category>typescript</category>
            <enclosure url="https://simplelocalize.io/blog/webpack-json-resource-lazy-loading.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to auto-translate your app with OpenAI, DeepL & Google]]></title>
            <link>https://simplelocalize.io/blog/posts/how-to-translate-app-automatically</link>
            <guid>https://simplelocalize.io/blog/posts/how-to-translate-app-automatically</guid>
            <pubDate>Wed, 04 Aug 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[Auto-translate your app using OpenAI, Google Translate, or DeepL via SimpleLocalize. Localize faster with AI-powered translations and flexible plans.]]></description>
            <content:encoded><![CDATA[Want to grow your app internationally without hiring a team of translators or manually managing dozens of language files? That's where automatic translation comes in. Tools like OpenAI, DeepL, and Google Translate make it possible to translate thousands of strings in seconds, all without touching a line of code.

In this guide, you will learn how SimpleLocalize uses these tools to automate translations, speed up development, and help you reach users in any language in minutes.

What is machine translation?

Machine translation (MT) (or Automated translation (AT)) is the use of AI or translation software to automatically convert text from one language to another, without human intervention. Think of tools like OpenAI (ChatGPT), Google Translate, or DeepL.

It's not just about swapping words. MT tools aim to understand grammar, tone, and context to deliver accurate translations across languages with different structures.

Learn more about benefits of AI translation.

Different languages often express the same idea in very different ways. For example, when you say “hello”, people in other countries may respond with culturally specific greetings. Some languages let you drop the subject altogether or use personal phrasing, like “Good morning” as a standalone phrase.

Other languages require much more information to make a sentence clear. Take the phrase “Be nice” — in English, it's short and universal. But in many other languages, you might need to specify who should be nice, to whom, and in what situation, making the translation less straightforward.

That's why high-quality machine translation engines are trained not just on vocabulary, but on millions of real-world examples, helping them capture nuance and intent, not just syntax.

How machine translation works in SimpleLocalize

SimpleLocalize makes automatic translation simple by connecting your project with advanced machine translation engines like OpenAI, DeepL, and Google Translate.

Here's how it works in a nutshell:

You upload your existing translations via API, CLI, or manually.

SimpleLocalize uses your default language (usually English) as the source.

It applies the translation provider depending on your settings and preferences.

It sends the content to the provider, receives translations, and updates your project, keeping your variables and formatting intact.

Language auto-translation configuration

If there is no text in the source language, SimpleLocalize will use match the best available translation for the target language.

It's that easy on the surface, but behind the scenes, SimpleLocalize handles all the complexity of choosing languages and translations for best possible results.

Using OpenAI (ChatGPT) for app translation

OpenAI's models (like GPT-4) bring a contextual understanding of language that goes beyond traditional translation engines.



Instead of translating sentence-by-sentence, OpenAI looks at the whole message, including placeholders, tone, and intent. This makes it especially useful for:

User interface texts

Tooltips and prompts

Error messages

Marketing copy

Dialogues or conversational UIs

For example, if your translation includes custom syntax or variables like:

OpenAI understands not to touch class="text-bold button" and will only translate the visible text (My bold text), keeping your layout safe.

You can also pass extra context to improve translation accuracy, e.g., specifying that a message is a button label or a system prompt. Learn more about context in localization and how it helps improve translation quality.

Check out our guide on auto-translation with OpenAI for more details on how to set it up.

DeepL for automated translation

DeepL is known for its precision and natural-sounding output, especially with shorter sentences. It's great when you want polished results without tweaking too much. It supports over 30 languages.



DeepL also does a good job respecting your application's syntax. For example, in this HTML:

DeepL correctly translates only the user-facing text and leaves code intact, saving developers time.

Text with source code translated in DeepL

Google Translate for automated translation

Google Translate is a solid option for longer texts and supports over 200 languages. It's especially effective with full sentences or paragraphs.



However, it can sometimes misinterpret app-specific code or structure. For instance, this line:

may end up translated as:

Google Translate mistakenly translates the class attribute, which can break your layout or styling. Thankfully, SimpleLocalize can detect and protect such syntax using text extraction techniques to avoid translation errors.

Text with source code translated in Google Translate

OpenAI vs. DeepL vs. Google Translate

Heres a quick comparison of the three major translation engines:

| Feature                | OpenAI (ChatGPT) | DeepL          | Google Translate |
|------------------------|------------------|----------------|------------------|
| Code-friendly output | Yes              | Yes            | Sometimes        |
| Context-aware         | Yes              | Limited        | No          |
| Best for short UI strings | Yes              | Yes            | Limited               |
| Best for long texts | Yes               | Limited            | Yes              |
| Customizable context | Yes              | No             | No               |
| Speed                | Slightly slower             | Fast           | Fast             |
| Cost efficiency | High for large volumes | Moderate       | Low              |

SimpleLocalize allows you to choose the provider that fits your project, or mix and match!

Check out our complete list of machine and AI translation providers and comparison of DeepL, Google Translate, and OpenAI to find the best fit for your needs.

DeepL vs. Google Translate

There is not much difference between those two services in general. DeepL has advantage that they keep application source code context. In most cases, DeepL
translation output is very accurate for short sentences. Google Translate is a much cheaper solution if you use it for large translation volumes.
Google Translate is better in translating longer texts with multiple sentences, while DeepL can have hiccups.

How to use machine translations in app?

Here are the steps to get started with automatic translations in your app using SimpleLocalize:

First, upload your translations using:

Manual file import,

API file import,

Add translations using API,

Upload translations with CLI.

Learn more about supported file formats.

Translation messages in translation management software

How to use auto-translation feature?

It's simple! Add a new language in the Languages tab, and click Start auto translation button next to the language you want to translate.

How to use automated translations in SimpleLocalize

Choose your preferred translation provider (OpenAI, DeepL, or Google Translate):

Auto-translation configuration in SimpleLocalize

Translation messages, which have been auto-translated, have a small provider logo next to the input to indicate it has been translated
automatically. This icon will disappear once you edit translation manually.

Example of auto translated texts in SimpleLocalize editor

How much does it cost?

Translating your app can be 100% free. Here's how:

Community plan — Free forever

up to 250 translation keys

Unlimited words & strings

Access to auto-translation

Option to buy extra translation characters without a paid plan

Free trial on Team plan

14 days free trial

Get started with a package of translation characters for testing

Evaluate OpenAI, Google Translate, and DeepL in real projects

Upgrade for higher monthly translation limits

Tip: Auto-translation is available across all plans. You can purchase more translation characters anytime, even on the free plan.

View our pricing page, register and start translating your app today!
]]></content:encoded>
            <category>deepl</category>
            <category>google translate</category>
            <category>openai</category>
            <category>chatgpt</category>
            <category>auto translation</category>
            <category>machine translations</category>
            <category>tutorial</category>
            <enclosure url="https://simplelocalize.io/blog/auto-translate-application.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to keep translations up to date with every release?]]></title>
            <link>https://simplelocalize.io/blog/posts/how-to-keep-translations-up-to-date</link>
            <guid>https://simplelocalize.io/blog/posts/how-to-keep-translations-up-to-date</guid>
            <pubDate>Tue, 13 Jul 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[Keep software translations in sync with each release. Learn to manage, update, and clean up translation keys for a smooth and scalable localization process.]]></description>
            <content:encoded><![CDATA[Keeping translations in sync with your software releases is more than a technical task, it's a vital part of delivering a seamless experience to users worldwide. Every deployment introduces new UI components, changes in copy, or entire features that require up-to-date localization. Without proper planning, it's easy for translation files to become inconsistent, incomplete, or outdated—leading to a fragmented experience across languages.

This article outlines the most effective ways to keep your translations current, avoid common pitfalls, and maintain localization quality as your product evolves.

Why keeping translations updated matters

Managing translations is often overlooked in fast-paced development environments. However, neglecting this aspect can lead to several issues that directly affect your product's performance, user perception, and scalability:

Untranslated strings: These disrupt the user interface, making your app look unfinished or unprofessional.

Outdated content: Translations that don't match updated features or terminology can confuse users and increase support tickets.

Localization debt: Just like technical debt, ignoring translation upkeep can snowball into a major refactoring task down the line.

Team slowdowns: Developers and translators waste time resolving discrepancies manually or chasing missing keys.

SEO damage: Missing or poorly translated content can hurt your search rankings in different regions, reducing discoverability.

Translated button

Maintaining high-quality translations isn't just about reaching more users; it's about ensuring every user, regardless of language, enjoys the same level of clarity and trust in your product.

Common challenges in translation maintenance

Before diving into solutions, it helps to identify where the typical localization process can break down:

New translation keys are added but not flagged for translators.

Old or deprecated keys linger in files, increasing noise and complexity.

Translations live in the codebase, requiring developers to manage them.

There's no single source of truth, leading to duplication and inconsistencies.

Translators lack context, making it difficult to produce accurate content.

To build a scalable translation workflow, these challenges must be addressed systematically.

Three practical ways to keep translations in sync

First, plan it. Think of the translation process of your software, what are the weaknesses in your current solution, and how can you improve it. Who will be responsible for the translations, and at what stage of development? What the whole process should look like?
We prepared 3 tips that should help you in keeping the translation process on track.

1\. Build a translation workflow into your development process

Localization should be treated as a first-class part of your release cycle. It's not a one-off task, it's continuous, just like coding, testing, and deployment.

Integrate translation updates with each code commit e..g using SimpleLocalize CLI.

Set up Webhooks to notify translators instantly about new or updated keys.

Define clear roles using project roles and permissions to streamline collaboration between developers, translators, and reviewers.

Use organization features like namespaces and tags to logically group translation keys by feature or context.

Automate repetitive steps using automations such as auto-translating new keys or publishing updates to your CDN.

Icons representing translation process

2\. Manage translations visually with a dedicated editor

Instead of editing raw JSON or YAML files, use a translation management platform like SimpleLocalize's web-based translation editor. This lowers the barrier to entry for non-developers and improves accuracy.

Key features include:

Auto-Translation: Quickly translate content using providers like OpenAI ChatGPT, Google Translate, or DeepL.

Contextual information: Provide translators with screenshots, descriptions, and comments to help them understand how text is used in-app.

Live collaboration with features like real-time updates, mentions, and change tracking.

Flexible UI customization to let translators work in a way that suits them best.

This approach speeds up the translation process and reduces back-and-forth clarifications.

translation editor

3\. Regularly clean up unused or outdated translation keys

As your app evolves, some translations will inevitably become obsolete. Keeping your translation files lean helps performance, clarity, and consistency.

Track translation usage with “last seen” data to identify which keys are no longer used in production.

Use bulk actions to remove, or edit outdated keys efficiently.

Discover automatic snapshots using SimpleLocalize's snapshot feature for auto-back uofp your translation state before making changes.

Implement automated cleanup routines during CI/CD to prevent unused keys from accumulating over time.

Last seen date of translations

Learn how to find unused translation keys in your project and remove them to keep your translation files clean and efficient.

Advanced capabilities to support a global localization strategy

When managing localization at scale, additional tools can significantly boost your translation efforts:

Per-customer translations allow you to offer personalized content for specific clients or enterprise users.

Public suggestions let your end users propose improvements, especially helpful in community-driven projects or open-source apps.

Translation memory ensures consistent phrasing across projects and speeds up translation for repeated content.

Integration with dev tools like SimpleLocalize CLI, REST API or GitHub lets you fit localization into your current toolchain with minimal friction.

These capabilities help teams deliver high-quality translations faster and with greater consistency.

Public suggestions

Get started with SimpleLocalize

Whether you're building a new app or maintaining a large multilingual product, it's never too late to optimize your translation workflow. SimpleLocalize helps teams stay organized, responsive, and confident in their localization quality.

Start your free trial and explore the platform.

Dive into the documentation for feature guides and best practices.

Reach out to our support team for personalized help.

Maintaining accurate translations with every release doesn't have to be a burden. With the right process and tools, your team can deliver a truly global user experience, without the chaos.
]]></content:encoded>
            <category>software translation process</category>
            <category>translation management</category>
            <category>translation hosting</category>
            <category>tutorial</category>
            <category>continuous-localization</category>
            <category>developer</category>
            <enclosure url="https://simplelocalize.io/blog/sync-translations-with-code-and-cloud.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Language vs Locale: What's the difference?]]></title>
            <link>https://simplelocalize.io/blog/posts/language-vs-locale</link>
            <guid>https://simplelocalize.io/blog/posts/language-vs-locale</guid>
            <pubDate>Mon, 10 May 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn the key differences between language and locale in software localization, with examples, code, and tips for a truly local user experience.]]></description>
            <content:encoded><![CDATA[When localizing software, language and locale are not the same. Language is the words and grammar people use; locale is the cultural and regional context that affects dates, currency, and formatting. Ignoring locale can confuse users even if the translation is correct.

If you have seen “color” in one app and “colour” in another, or a price like 1.000,00 €, you have experienced the difference.

In this guide, we will break down language vs locale and share practical tips for handling both in software localization, so your product feels truly local, wherever it's used.

If you are looking for a list of locale identifiers, you can find it in our Locale codes list and Language data list.

Language vs Locale: Quick comparison

Here is a quick comparison of language and locale to help you understand the main differences:

| Feature       | Language                          | Locale                               |
|--------------|-----------------------------------|--------------------------------------|
| Definition   | System of words, grammar, and syntax used for communication. | The cultural and regional context of a language |
| Codes | en (English), es (Spanish), fr (French)                | en-US (English – United States), es-ES (Spanish – Spain), fr-FR (French – France) |
| Focus        | Words and meaning       | Formats, symbols, cultural context  |
| Includes        | Vocabulary, spelling, grammar rules        | Date/time formats, currency, measurement units, idioms |
| Example | "Hello" in English, "Hola" in Spanish | $1,000.00 vs 1.000,00 € |

What is Language?

Language is the linguistic system people use to communicate. It's the foundation of translation work and includes:

Vocabulary: The set of words used in a language.

Grammar: The rules that govern how words are combined to form sentences.

Syntax: The structure of sentences and phrases.

When translating, the goal is to convert content from a source language (e.g., English) to a target language (e.g., Spanish).

Language code example for translation

What is Locale?

A locale goes beyond words as it adapts content to the cultural and regional norms of a specific audience.

Locale includes:

Date formats → MM/DD/YYYY (US) vs DD/MM/YYYY (UK)

Currency symbols → $ (US) vs € (EU)

Measurement units → Miles (US) vs Kilometers (EU)

Time formats → 12-hour clock (US) vs 24-hour clock (EU)

For example, English speakers in the US, UK, and Australia all understand each other, but their locale preferences differ in spelling, currency, and formatting.

Locale code example for translation

Why locale matters in software development

Multilingual apps and websites are becoming increasingly common as businesses expand globally. However, simply translating text is not enough. Understanding the difference between language and locale is crucial for creating a user-friendly experience that feels natural to users in different regions.

When developing software, the translation and localization process is about adapting language and locale so the product feels native to each audience. Ignore locale, and you risk confusing users or even causing critical errors (e.g., wrong currency or misinterpreted dates).

Ignoring locale in software can:

Cause bugs (e.g., 03/04/2025 being read as March 4th or April 3rd)

Confuse payment processing with incorrect currency symbols

Lead to poor user experience because the product feels “foreign”

Result in miscommunication due to cultural differences in expressions or idioms

How to implement locale

In the code of an application or webpage, a locale identifier is used to specify the language code and region where the language variation is used.

A locale identifier is typically formatted as language-REGION, where language is the ISO 639-1 code for the language, and REGION is the ISO 3166-1 alpha-2 code for the country or region.

For example, English is spoken in different parts of the world. It is adapted to local audiences using locale identifiers such as en-GB for the UK, en-AU for Australia, or en-US for the United States.

Below you can see an example of locale translations of the word "computer" to Spanish for different regions:

Spanish locale translations example

Check our list of locale identifiers for a complete overview of locale codes.

Locale formatting

The format of the locale identifier can vary depending on the environment used in the project. For instance, Java uses underscores (\_) instead of hyphens (-), which are commonly used in other environments.

Standard Locale format: language-REGION

Alternative Locale format: language_REGION (used in environments like Java or Windows)

Locale identifiers in code

Modern programming languages offer built-in support for locale-aware formatting.
For example, in JavaScript, you can use toLocaleDateString() for quick conversions, or Intl.DateTimeFormat for more control.

Example 1: Quick locale formatting

Example 2: Custom formatting with Intl.DateTimeFormat

Here:

en-US sets the locale to US English.

options controls how the date is displayed (full month name, numeric day, numeric year).

By simply changing en-US to en-GB or fr-FR, you can instantly adapt the format to different regions.

Learn more about number formatting in JavaScript.

Locale in localization

In localization, locale identifiers are used to manage translations and regional settings. They help ensure that the right content is displayed based on the user's language and region preferences.

For example, in a localization file, you have:

Locale codes are also used in your URL structure to serve different content based on the user's locale. For example, a URL might look like this:

This allows the application to serve the correct language and regional settings based on the user's locale.

Learn more about URL localization.

Common locale identifiers

Here are some common locale identifiers for different languages and regions:

en-US: English - United States

en-GB: English - Great Britain

es-ES: Spanish - Spain

es-MX: Spanish - Mexico

fr-FR: French - France

fr-CA: French - Canada

de-DE: German - Germany

de-AT: German - Austria

pt-BR: Portuguese - Brazil

pt-PT: Portuguese - Portugal

it-IT: Italian

zh-CN: Chinese - China

zh-TW: Chinese - Taiwan

ja-JP: Japanese - Japan

ko-KR: Korean - South Korea

For more locale identifiers, you can refer to our Locale codes list and Language data list.

List of common locale codes

Conclusion

By considering both language and locale, developers and translators can deliver software that feels native to every user. Locale-aware formatting ensures correct dates, currency, and measurements, providing a seamless global experience.

FAQs

Is a locale the same as a dialect?

No. Dialects are language variations in vocabulary and pronunciation. Locales include cultural formatting rules as well.

Can two countries share the same language but have different locales?

Yes. Example: en-US vs en-GB. Both are English but differ in spelling, dates, and currency.

What happens if I only translate the language but ignore the locale?

Users may understand the words but find your product hard to use or untrustworthy.

How do I choose the right locale for my audience?

Consider the primary language spoken, regional preferences, and cultural norms of your target audience. Use locale identifiers to specify these preferences in your application.
]]></content:encoded>
            <category>locale</category>
            <category>language vs locale</category>
            <category>translation management</category>
            <category>software localization</category>
            <category>i18n</category>
            <enclosure url="https://simplelocalize.io/blog/language-vs-locale.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Translation management explained: What it is and why you need it]]></title>
            <link>https://simplelocalize.io/blog/posts/what-is-translation-management</link>
            <guid>https://simplelocalize.io/blog/posts/what-is-translation-management</guid>
            <pubDate>Thu, 22 Apr 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[Translation management is the process of managing texts in multiple languages. Learn how it works, why it matters, and how a TMS like SimpleLocalize helps your team scale localization efficiently.]]></description>
            <content:encoded><![CDATA[At first sight, translation management might seem straightforward: it's just about translating text. In reality, it's much more than that. Effective translation management ensures that software and digital content are consistently adapted for multiple languages, formats, and cultural contexts while saving time and reducing errors.

In this guide, we'll explain what translation management really means, how it works for developers, translators, and project managers, and why using a TMS like SimpleLocalize can make a huge difference.

What is translation management

Translation management is the process of organizing, coordinating, and streamlining translations across a software project or digital product. It involves managing text strings, translation workflows, updates, and collaboration between teams.

Without proper translation management, localization can become slow, error-prone, and costly, especially as your product expands to new markets.

Translation management in software projects

No matter your role: developer, translator, or product manager, you interact with translations. As your project grows, you may need to support multiple languages, manage new features, and ensure updates are consistent.

Here's how translation management works in real-world scenarios.

Developer perspective

Scenario 1: Without translation management

Imagine you need to translate your web and mobile apps into three new languages. Your project currently uses English only.

You manually convert text into i18n keys, create JSON files, and distribute them to translators:

Each new feature requires manually updating the JSON files, copying translations, and waiting for deployment. It's time-consuming, repetitive, and error-prone.

Scenario 2: With translation management (TMS)

With a TMS like SimpleLocalize:

New keys are automatically detected from the source code.

Translators work directly in the intuitive cloud editor.

Translations are pushed to your app automatically: no copy-pasting required.

Developers can focus on building features instead of managing translations.

SimpleLocalize translation editor

Translator perspective

Without a translation system, translators might work in Excel, manually tracking changes and versions, a tedious process prone to mistakes.

With a TMS:

Translators can filter and track translation progress.

Missing translations are clearly flagged.

Context, screenshots, and descriptions help ensure accurate translations.

The system handles updates automatically, keeping all languages synchronized.

QA checks help maintain quality.

Project Manager / Sales perspective

Missing translations can harm your product's professional appearance. A salesperson presenting your app might see untranslated strings in front of a client, creating a poor impression.

Missing translation

With a TMS, your team can:

Keep translations up to date.

Remove unused keys automatically.

Push translations live immediately.

Ensure consistent quality across all languages.

Provide a polished experience for users and clients.

Why you need translation management

Effective translation management improves workflow for all teams:

Developers: Automate updates and integration with source code.

Translators: Work efficiently with context, screenshots, and progress tracking.

Project managers & sales teams: Ensure a polished, professional product in all supported languages.

Using a TMS like SimpleLocalize allows you to:

Scale your localization process as your business grows.

Save time and reduce errors.

Deliver a consistent experience for international users.

Learn more about best practices in software localization to enhance your translation management strategy.

Getting Started with SimpleLocalize

Check how SimpleLocalize can help your project with a 14-day free trial at SimpleLocalize.io or test a free plan for smaller apps and websites. Learn more in our getting started guide.

Translation management isn't just about text, it's about efficiency, quality, and giving your users a product that feels natural in every language.
]]></content:encoded>
            <category>software localization</category>
            <category>translation management</category>
            <enclosure url="https://simplelocalize.io/blog/translation-management.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[Customer-specific translations management made easy]]></title>
            <link>https://simplelocalize.io/blog/posts/customer-specific-translations</link>
            <guid>https://simplelocalize.io/blog/posts/customer-specific-translations</guid>
            <pubDate>Fri, 26 Mar 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[Deliver personalized translations for each customer with SimpleLocalize. Manage per-customer translation variants and easily export or host customized translations.]]></description>
            <content:encoded><![CDATA[If you are a SaaS or product company, you probably know the feeling: one customer loves your “Book now” button, but another wants it to say “Reserve today.” A hotel chain might want “Book your stay” instead. You have just entered the world of customer-specific translations, and managing them manually can quickly become a headache.

With SimpleLocalize, you can easily create per-customer translation variants (also known as customer overrides) without duplicating your project or code. Let's explore how this works and how the new Customer Context features make it even more powerful.

What are customer-specific translations?

Customer-specific translations let you create customized text variants for individual customers, perfect when you are offering a white-label or multi-tenant solution where each client wants to use slightly different terminology.

For example:

| Translation key | Default Translation | Grand Hotel | Pillow Hostel |
|-----------------|---------------------|-------------|---------------|
| book_now        | Book Now            | Reserve Today | Book your stay |
| contact_us      | Contact Us          | Get in Touch | Reach Out     |
| pay_later      | Pay Later          | Pay at Check-In | Pay upon Arrival |

In this case, your booking app keeps one base translation set ("Book now", "Contact Us", "Pay Later"), while Grand Hotel and Pillow Hostel each have their own localized overrides. The system automatically applies the correct text for each customer ID.

This approach saves time, keeps your translations consistent, and makes your product feel tailor-made for every client.

Why traditional custom translations are painful

Without a proper localization workflow, customer-specific requests are difficult to manage. Developers often end up duplicating files, branching codebases, or hardcoding one-off text replacements.

A small tweak, like changing “Pay Later” to “Pay at Check-In” may require editing several files, testing multiple environments, and ensuring it doesn't affect other customers. Multiply that by 20 customers, and you've got chaos.

That is why SimpleLocalize introduced Customer Contexts, a clean, scalable way to manage customer-based localization directly in your translation editor.

If you are new to organizing your localization process, check out our step-by-step localization workflow for developers. It's a great guide on setting up efficient translation management that scales with your product.

Customer Contexts in SimpleLocalize: how it works

With Customer Context, you can assign translations to a specific customer (using their customer ID) and control them separately from your default translations.

When you create a Customer Context in SimpleLocalize, a new column appears in your translation editor for that customer. You can enter custom translations for any key, while leaving others blank to fall back to the default.

Learn more in our Customer Contexts documentation.

Step 1: Create a customer context

Add a new context for each customer, for example, customer ID: 12345 or grand_hotel. You can add a name and description to identify them easily.

Create customer context

Step 2: Add translation variants

Once a context is created, you will see a dedicated line in the translation editor. Add your customer-specific translations only where changes are needed. If a field is left empty, SimpleLocalize automatically falls back to the default translation, displayed as a placeholder.

This makes it easy to see what will be used in production and ensures no missing strings.

Add translation variants

Step 3: Review, filter, and manage efficiently

Here are some handy features to help you manage customer-specific translations:

Filters: Focus on a specific customer's translations or return to the global default view.

Review: You can review changes per customer context and mark them as reviewed when done.

Default placeholders: Empty fields show the default translation as a placeholder, so you always know what text will be used.

Easy exports: Export only the customer's translations or all variants together.

Translation hosting integration: Fetch the right translations automatically in your app by passing a customerId parameter.

Permissions: Control who can view or edit customer-specific translations by assigning permissions to team members.

API support: Manage customer contexts programmatically via SimpleLocalize's Customer API.

These additions make managing and deploying customer-specific content more efficient than ever.

Customer translation with review status

Want to learn more about optimizing your review process? See our post on how to automate translation updates with review statuses to keep your translations consistent and up-to-date.

Example: customer-based localization in the hotel industry

Imagine you are running a booking platform used by multiple hotel brands.

The default translation for the main button is “Book now”

The Grand Hotel wants to change it to “Book your stay”

The Beach Resort prefers “Book now – best deal!”

Each hotel's guests now see a version that fits their tone of voice and marketing style, without affecting the others. Meanwhile, your developers maintain just one shared product and translation setup.

This is what customer-based localization is all about: one product, multiple voices.

Collaborate and control access

SimpleLocalize also lets you invite customers directly to their translation context. You can assign permissions so that each customer can only access and modify their own translations and view the default ones.

Assigning permissions to customers

This is perfect for white-label solutions or enterprise customers who want to manage their own localized content variants safely.

If you are designing software for a diverse audience, consider how accessibility fits into your localization strategy. Our guide on how to make your website accessible explains how thoughtful content and translations improve user experience for everyone.

Integrate with translation hosting and exports

Need to deliver the right translations dynamically?

With translation hosting, your app can automatically fetch the correct version by sending the customerId when loading translations.

This ensures every customer's users see the correct copy instantly, wherever they are.

You can also export customer-specific translations via the SimpleLocalize API or directly from the editor.

Benefits of per-customer translations

Adopting customer-specific translation management offers tangible benefits for product teams:

Personalization at scale: Make each customer feel like your product was built just for them.

No duplication: One project, unlimited translation variants.

Stronger relationships: Respond quickly to customer requests without engineering bottlenecks.

Better localization workflow: Review, filter, and manage translation variants from one place.

Higher value product: White-label, multi-tenant, and enterprise customers expect personalized localization options.

Conclusion

Customer-specific translations used to be complex and error-prone. With SimpleLocalize's Customer Contexts, you can now manage all translation variants per customer in one centralized platform making it easy to review, filter, host, and export.

Whether you are managing 5 clients or 500, you will save time, reduce maintenance, and deliver a truly personalized user experience.

Try it today and see how simple customer-based localization can be. Contact us and request a trial on our Business plan to access Customer Contexts and elevate your translation management.
]]></content:encoded>
            <category>customer-specific translation</category>
            <category>software localization</category>
            <category>customer context</category>
            <category>translation management</category>
            <enclosure url="https://simplelocalize.io/blog/customer-specific-translations.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Why translation matters in modern software projects]]></title>
            <link>https://simplelocalize.io/blog/posts/translation-importance</link>
            <guid>https://simplelocalize.io/blog/posts/translation-importance</guid>
            <pubDate>Tue, 09 Mar 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[Imagine using software you can't understand. Translation and localization make apps usable, relatable, and successful for global audiences.]]></description>
            <content:encoded><![CDATA[What if your app couldn't speak your user's language? Imagine trying to navigate settings, fill out forms, or get support — all in a language you don't understand. That's what poor or missing translation feels like in software projects.

In a world where software is global from day one, translation isn't a “nice to have.” It's a fundamental part of product design, user experience, and customer retention.

What is translation (in a software context)?

Translation is a very beginning of the localization process. It is the first step to make your software accessible to users who speak different languages.
But it is more than converting words, it's about conveying meaning in context. In software, that includes:

UI elements (buttons, menus)

Onboarding screens and help tips

Notifications and error messages

Support content and chatbot replies

Bad translations confuse users and erode trust. Good ones feel native, like the software was made just for them.

Translation vs Localization: What's the difference?

Let's clarify two often-mixed terms:

Translation is converting text from one language to another.

Localization adapts content to local culture, language variation, and user expectations.

📌 Example: A "Checkout" button might be translated directly in Japanese, but localized wording could change entirely to match cultural norms.

Localization also includes:

Formatting (dates, currencies, units)

Tone and formality

Cultural references and idioms

Legal and regulatory adjustments

Why translation matters in software projects

Translation and localization impact far more than language: they influence how users feel, act, and engage. Here is why it is essential:

Global reach: Make your app accessible to non-English-speaking users.

Improved UX: Clear, native-feeling content reduces user friction.

Better conversions: Localized interfaces increase trust and engagement.

Clarity in complex domains: Accurate language in technical or sensitive content prevents misunderstandings.

Legal and compliance: Ensure accuracy in privacy policies, terms, and disclosures.

Language icon

Common pitfalls in software translation

Avoid these mistakes if you want your translations to succeed:

❌ Relying solely on machine translation

❌ Hard-coding text strings into your code

❌ Failing to provide translators with context

❌ Ignoring regional language differences (e.g., Brazilian vs European Portuguese)

❌ Skipping translation QA with native speakers

Best practices for localization in software development

Here is how to build global-ready software:

Internationalize your codebase: Separate content from code and use i18n libraries.

Use a translation management system (TMS): Tools like SimpleLocalize help manage, organize, and automate translations efficiently.

Provide context: Use screenshots, descriptions, and keys that help translators understand usage.

Collaborate with native speakers: Involve them in testing and QA.

Automate where possible: Integrate localization into your CI/CD pipeline.

SimpleLocalize translation editor

The human side of translation

Even with today's AI-powered tools, human translators are irreplaceable for understanding cultural nuance, creating natural, idiomatic phrasing, or navigating ambiguous or technical content.
They bring empathy and creativity that machines can't replicate.

A well-localized product should not feel like a translation. It should feel like it was written just for that user.

Users icon

Conclusion

Translation in software is not just about accessibility, it is about creating meaningful, trusted, and enjoyable experiences for users around the world.

When done right, translation and localization remove barriers. They open up markets, empower users, and help software become truly global. And as powerful as automated tools are today, it is still humans who ensure that our digital experiences feel human too.

Using a platform like SimpleLocalize can help your team translate faster, localize better, and build products that truly resonate across languages and cultures. Register for free and start your localization journey today!
]]></content:encoded>
            <category>internationalization</category>
            <category>software localization</category>
            <category>translation management</category>
            <enclosure url="https://simplelocalize.io/blog/translation-in-software-projects.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Best i18n libraries for React, React Native & NextJS]]></title>
            <link>https://simplelocalize.io/blog/posts/the-most-popular-react-localization-libraries</link>
            <guid>https://simplelocalize.io/blog/posts/the-most-popular-react-localization-libraries</guid>
            <pubDate>Fri, 12 Feb 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[Top i18n libraries for React, React Native, Expo, and Next.js. Learn how to properly localize your React apps with the right tools.]]></description>
            <content:encoded><![CDATA[Localization is no longer optional, it's a competitive advantage. A CSA Research study shows that 66% of business users are more likely to pay for a localized product. Even fluent English speakers prefer software that "speaks their language."

If you're building React apps, including React Native, Expo, or Next.js, you'll need a robust i18n setup. In this post, we compare the top React i18n libraries to help you choose the right one for your project.

Access our full list of localization libraries and tools on GitHub. You are welcome to add your resources as a pull requests or just create a new issue.

Top React localization libraries

See our list of the best React libraries we gathered. We focused mainly on ReactJS, React Native and Expo libraries.

1\. react-intl (FormatJS)

FormatJS is a comprehensive internationalization (i18n) framework for web applications. It offers several packages, including react-intl, which is specifically built for React.

react-intl provides React components and utilities for formatting messages, dates, times, and numbers based on the user's locale. It also includes support for pluralization, gender variations, and rich ICU message formatting.

FormatJS logo

Key info

Package name: react-intl

GitHub: formatjs/react-intl

NPM: react-intl

Documentation: FormatJS documentation

Pluralization: Yes

ICU Message Format: Yes

TypeScript support: Yes

Last updated: Actively maintained

Bundle size: ~20KB (minified and gzipped)

See also

Integration guide: translations hosting - check how to use SimpleLocalize with FormatJS library

Extract i18n keys from FormatJS project - learn more about message extraction with SimpleLocalize CLI

Blog post: FormatJS and React application localization

GitHub repository: example project - sample project code with configured FormatJS

Live demo - see live demo of FormatJS (react-intl) and SimpleLocalize integration

FormatJS library

2\. react-i18next

React-i18next is one of the most popular localization libraries among React developers.
It is a powerful and flexible React binding for the popular i18next i18n framework. It supports all major features like plurals, formatting, interpolation, and async loading.

Integrates well with SSR, Next.js, and even React Native. Highly customizable and widely adopted.

react-i18next logo

Key info

Package name: react-i18next

GitHub: i18next/react-i18next

NPM: react-i18next

Documentation: react-i18next documentation

Pluralization: Yes

ICU Message Format: Not direct, but can be used with i18next-icu plugin

TypeScript support: Yes

Last updated: Actively maintained

Bundle size: ~6KB (minified and gzipped)

i18next was originally created for React only, but the community gathered among the library created integrations for other frontend frameworks such as AngularJS, Vue.js and more.

See also

Integration guide: translations hosting - check how to use SimpleLocalize with the i18next library

Extract i18n keys from i18next library - use SimpleLocalize CLI to find translation keys used in the project

Blog post: i18next in 3 steps - blog post about integrating SimpleLocalize with i18next

GitHub repository: example project - sample i18next project with 'http-backed' and 'loadpath'

Live demo - see live demo of i18next with configured http-backend and 'loadpath'.

i18next React localization

3\. LinguiJS

LinguiJS is a modern i18n library for React (and JavaScript in general) with a focus on minimalism, performance, and developer experience.
It uses ICU message syntax and supports automatic message extraction and compile-time translations.

It integrates well with TypeScript and has CLI tools for automatic extraction and compilation.

LinguiJS logo

Key info

Package name: @lingui/react

GitHub: lingui/js-lingui

NPM: @lingui/react

Documentation: LinguiJS documentation

Pluralization: Yes

ICU Message Format: Yes

TypeScript support: Yes

Last updated: Actively maintained

Bundle size: ~2KB (minified and gzipped)

See also: Comparison of LinguiJS with react-intl

LinguiJS

4\. next-i18next

next-i18next is a wrapper around react-i18next optimized for Next.js apps. It supports server-side rendering, static site generation, route-based namespaces, and more.

next-i18next logo

Key info

Package name: next-i18next

GitHub: i18next/next-i18next

NPM: next-i18next

Documentation: next-i18next documentation

Pluralization: Yes

ICU Message Format: Optional via i18next plugins

TypeScript support: Yes

Last updated: February 2025

Bundle size: ~5KB (minified and gzipped)

See also

Integration guide - check how to use SimpleLocalize with next-i18next library

Blog post: How to translate NextJS app with next-i18next?

5\. zero-intl

zero-intl is a lightweight and modern localization library for React applications. It focuses on simplicity and performance, providing a minimal API for managing translations and formatting messages.

Zero-Intl logo

Key info

Package name: zero-intl

GitHub: zero-intl/zero-intl

NPM: zero-intl

Pluralization: Yes

ICU Message Format: Yes

TypeScript support: Yes

Last updated: Actively maintained

Bundle size: ~15KB

6\. next-intl

next-intl is a powerful internationalization library built specifically for Next.js. It supports both the App Router and Pages Router, offering integration with Server Components, dynamic routing, and static rendering.

It provides features like ICU message formatting, type-safe translations, localized routing, and fine-grained control over when and how translations are loaded.

next-intl logo

Key info

Package name: next-intl

GitHub: amannn/next-intl

NPM: next-intl

Documentation: next-intl documentation

Website: next-intl.dev

Pluralization: Yes

ICU Message Format: Yes

TypeScript support: Yes

Last updated: Actively maintained

Bundle size: 457B (minified and gzipped)

7\. react-localization

react-localization is a lightweight localization library for React. It allows defining translations in simple JavaScript objects and switching languages on the fly. Ideal for small-to-medium apps that don't need full ICU or complex formatting.

Key info

Package name: react-localization

GitHub: stefalda/react-localization

NPM: react-localization

Pluralization: No built-in pluralization

ICU Message Format: No

TypeScript support: Yes

Last updated: April 2025

Bundle size: ~2KB (minified and gzipped)

8\. next-translate

next-translate is a lightweight translation library designed specifically for Next.js, especially the Pages Router. It uses a file-based translation system and supports dynamic route-based language loading.

next-translate logo

Key info

Package name: next-translate

GitHub: aralroca/next-translate

NPM: next-translate

Pluralization: Yes

ICU Message Format: Partial (via interpolation)

TypeScript support: Partial (types provided, but not fully type-safe)

Last updated: Maintained (minor updates in 2024–2025)

Bundle size: 498B (minified and gzipped)

It all started when the developers realised how important i18n is for SEO, and thanks to the community, Next.js decided to introduce internationalized routing which became available in Next.js 10.

See also: How to translate NextJS app with next-translate - step-by-step localization with next-translate

next-translate

9\. messageformat

MessageFormat.js is a powerful ICU message formatting library that supports pluralization, gender, and select statements for complex localization scenarios. It works with JavaScript and can be easily integrated into React or other frameworks. MessageFormat helps create fully customized messages with robust linguistic rules.

MessageFormat.js logo

Key info

Package name: messageformat

GitHub: messageformat/messageformat

NPM: messageformat

Documentation: MessageFormat.js documentation

Pluralization: Yes

ICU Message Format: Yes

TypeScript support: Yes

Last updated: Actively maintained

Bundle size: ~8KB (minified and gzipped)

See also: Integration with React: check how to use MessageFormat.js with React.

MessageFormat.js library

10\. typesafe-i18n

typesafe-i18n is an opinionated, fully type-safe, lightweight localization library for TypeScript and JavaScript projects with no external dependencies. It supports React, Svelte, Vanilla JS, and more.

In React, it works well with hooks and context, offering strongly-typed translation functions and autocompletion for translation keys.

Key info

Package name: typesafe-i18n

GitHub: ivanhofer/typesafe-i18n

NPM: typesafe-i18n

Pluralization: Yes

ICU Message Format: Partial (custom message formatting system)

TypeScript support: Yes (fully type-safe)

Last updated: 2023

Bundle size: ~1KB runtime + codegen files

Great for teams prioritizing strict type safety and developer experience in React apps.

typesafe-i18n - demo

Comparison of React localization libraries

Check the table below to compare the most popular React localization libraries and find the best one for your project.

| Library          | React |  React Native | Next.js | Typescript | Bundle Size | Best for |
|------------------|-------|---------------|---------|------------|------------------------|----------|
| react-intl | ✅ | ✅ | ✅ | ✅ | ~20KB | Complex apps needing rich ICU formatting |
| react-i18next | ✅ | ✅ | ✅ | ✅ | ~6KB | Flexible, popular choice for all apps |
| LinguiJS | ✅ | ✅ | ✅ | ✅ | ~2KB | Compile-time, dev-friendly i18n |
| next-i18next | ❌ | ❌ | ✅ | ✅ | ~5KB | SSR support with Next.js |
| zero-intl | ✅ | ❌ | ✅ | ✅ | ~15KB | Lightweight, modern, minimal |
| next-intl | ❌ | ❌ | ✅ | ✅ | 457B | Best for new Next.js apps (App Router) |
| react-localization | ✅ | ✅ | ✅ | ❌ | ~2KB | Simple apps, no ICU needed |
| next-translate | ❌ | ❌ | ✅ | Partial | 498B | File-based i18n for Next.js Pages Router |
| messageformat | ✅ | ✅ | ✅ | ✅ | ~8KB | Custom ICU message formatting |
| typesafe-i18n | ✅ | ✅ | ✅ | ✅ | ~1KB runtime + gen | Teams needing strict type safety |

Utility libraries & CLI tools

Below are some utility libraries and CLI tools that can help with localization in React projects. They are not full-fledged i18n libraries, but they provide useful functionality for managing translations, extracting messages, or integrating with translation management systems.

react-native-localize

React-native-localize is a utility library that helps React Native apps detect and adapt to the device's locale settings.

It's often used alongside i18n frameworks like i18next or formatjs to trigger the correct translations based on system language. It is a toolbox for your React Native app localization.

Key info

Package name: react-native-localize

GitHub: zoontek/react-native-localize

NPM: react-native-localize

Pluralization: No (focuses on locale detection)

ICU Message Format: No (focuses on locale detection)

TypeScript support: Yes

Last updated: Actively maintained

Bundle size: Native module (~6KB JS + native bindings)

Best used with a translation library, not as a standalone i18n solution.

react-native-localize

FormatJS CLI

The FormatJS CLI is a command-line tool for extracting messages from projects using the FormatJS ecosystem (such as react-intl). It scans your codebase for translatable strings and outputs message JSON files, ready for translation.

If you are using FormatJS with SimpleLocalize, you can upload these extracted messages to our platform with ease.

Learn how to upload extracted translation messages to SimpleLocalize.

Key info

Tool type: CLI (FormatJS tool)

Usage: Extract messages for translation

Supports: FormatJS, react-intl

formatjs cli

SimpleLocalize CLI + TMS

SimpleLocalize is a complete translation and localization platform that helps developers and teams manage multilingual content at scale.
It offers a CLI, API, and a visual TMS to streamline the process of uploading, editing, and distributing translations.
You can create your account here.

1\. Upload translations

Upload your translation files using SimpleLocalize CLI, API or import translations using our web app and file format of your preference.
SimpleLocalize supports popular file formats including .json, .po, .xliff, .csv, and more.

How to upload translation files with command-line tool

2\. Manage translations in online editor

Use the developer-friendly editor to:

Add and manage translation keys and values

View key descriptions or usage context

Collaborate with translators

Automatically translate with OpenAI, Google Translate or DeepL

How to change translation in Translation Editor

3\. Download translations

When the translations are ready, you can download them in multiple ways. Export translations inside SimpleLocalize or use or CLI and API to get ready to use translation files.

How to download translation using command-line tool

4\. Localization hosting (CDN)

Host your translation files in the cloud using SimpleLocalize translation hosting.
Fetch localized content at runtime with a superfast CDN, no need to redeploy your app after each translation update.

See also:

i18next: integration guide

FormatJS: integration guide

FormatJS CLI: integration guide

Docs: translation hosting

Docs: Getting started with CLI

Legacy React localization libraries

These libraries are not actively maintained, but they can still be useful for legacy projects or specific use cases. They may not have the latest features or best practices, but they can still provide basic localization functionality.

react-i18nify

React-i18nify is a simple group of translation and localization components and helpers for your React application.

react-i18nify

react-littera

react-littera is a modern library for React localization.
It was created to make maintaining and managing translations easier. It allows placing translations right beside your component, as well as storing translations globally. Littera's structure was inspired by react-jss.

react littera for managing translations

react-persian

react-persian is a library for Persian localization in React. It provides a set of components for Persian localization.
Are you developing an application for a Persian audience? You should definitely check this library out.

react-persian

react-translate

bloodyowl/react-translate is a set of React utilities for simple i18n handling.
The library is a bit outdated, last commit was in 2019, and last release is dated to end of 2016.

If some reason you didn't like FormatJS, then the library is worth checking.

react-translate

react-translated

react-translated is a dead simple way to add complex translations in a React project.
The library is a bit outdated but definitely work checking!

react-translated

We hope this gave you a clearer picture of the i18n landscape in React.

Have a favorite i18n tool? Or a question we didn't cover? Let us know, we would love to hear from you.

👋 Thanks for reading!
]]></content:encoded>
            <category>javascript</category>
            <category>react</category>
            <category>typescript</category>
            <category>nextjs</category>
            <category>react-native</category>
            <category>expo</category>
            <category>developer</category>
            <enclosure url="https://simplelocalize.io/blog/react-i18n-libraries-list.png" length="0" type="image/png"/>
        </item>
        <item>
            <title><![CDATA[What is 'hreflang' and how to use it]]></title>
            <link>https://simplelocalize.io/blog/posts/what-is-hreflang</link>
            <guid>https://simplelocalize.io/blog/posts/what-is-hreflang</guid>
            <pubDate>Wed, 03 Feb 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[Learn about the hreflang attribute, its importance for SEO, and how to implement it correctly to serve the right language version of your content.]]></description>
            <content:encoded><![CDATA[When building a website or web application, it's essential to define the language of each page to ensure proper indexing and visibility in search engines. While you might be familiar with the \<lang> attribute in HTML, there is another important attribute that serves a different, but equally vital, SEO purpose: hreflang.

Let's explore what hreflang is, how it works, and how to implement it correctly.

What is hreflang?

The hreflang attribute is used to tell search engines which language and optionally which region a specific page is targeting. It helps Google and other search engines serve the correct language or regional version of your content to users in different locations.



Unlike the \<lang> attribute, which identifies the language of the page content, hreflang acts as a mapping tool: it tells Google about alternate versions of the same content in other languages or for other regions.

A typical hreflang value includes:

Language code: A two-letter code representing the language (e.g., "en" for English, "es" for Spanish in ISO 639-1 format).

Region code (optional): A two-letter code representing the country or region (e.g., "US" for the United States, "ES" for Spain, "CL" for Chile in ISO 3166 format).

Format: hreflang="language-region" (e.g., en-US, es-ES)

Check out or blog post on differences between language and locale for more details.

Where to use hreflang?

You can specify hreflang in three places:

In the \<head> section of your HTML document using  \<link rel="alternate" hreflang="..." href="..."> tags

In HTTP headers (for non-HTML resources like PDFs)

In XML sitemaps



Using all three methods is allowed, but not required. Choosing just one is sufficient, and combining them does not provide extra benefit.

Most common method: in the HTML \<head>

Each page should reference all alternate versions, including itself. This is known as bidirectional linking: if Page A references Page B with hreflang, Page B must also reference Page A.

You can use tools like the W3C Link Checker to validate URLs and ensure they are correct.

Why hreflang is important

Correct hreflang implementation helps:

Serve the right content to users based on their language and region

Improve SEO by avoiding duplicate content issues

Enhance user experience by directing users to the appropriate version of your site

Increase visibility in search results for different languages and regions

Search engines treat hreflang as a strong signal when determining which page to display in localized search results. Without it, your Spanish-speaking visitors in Chile might end up on your English homepage which is not ideal for engagement or conversions.

Best practices for hreflang implementation

Here are some best practices to follow when implementing hreflang:

Each language/region version must list all other versions, including itself

Use valid language and region codes

Insert the tags in the \<head> before scripts

Use hreflang generators or SEO tools for accuracy

Include an x-default tag to handle unmatched languages

The x-default value is recommended by Google as a fallback when no specific language or region matches the user's preferences.

Example of a subpage with hreflang

Here is an example of how to implement hreflang for a contact page that is available in multiple languages:

It shows the contact page in English, Spanish (Spain), and Spanish (Chile). Each version is linked to its corresponding URL, allowing search engines to understand the language and regional targeting of each page.

Note that in the URL the language and region are included as subdirectories (e.g., /es-ES/ for Spanish in Spain). This is a common practice, but you can also use subdomains or ccTLDs (country code top-level domains) if preferred.

Check out our blog post on URL structure for multilingual websites for more details.

rel="alternate" vs. rel="canonical"

When using hreflang, you will often encounter two other attributes: rel="alternate" and rel="canonical".

rel="alternate" tells search engines that the page is an alternate version in a different language or format (like mobile).

rel="canonical" indicates the preferred version of a page when there are multiple pages with similar content.

These two can coexist, but make sure your canonical URL is consistent across versions and does not conflict with the alternate links.

Example:

FAQ

Do I need hreflang if my website targets only one language?

No. If your site is built for a single language or region, hreflang is not necessary. Use the correct  \<html lang="..."> attribute instead.

What about country-specific domains like .it or .fr?

Search engines will assume a country focus based on the top-level domain (TLD), so if you are targeting another audience (e.g., English users on a .it domain), it's best to use hreflang to clarify your intent.

Can I use hreflang without translating the page?

Technically yes, but it's not recommended. Hreflang is intended to distinguish content that is either translated or localized. If all versions are in the same language with no regional customization, hreflang may confuse search engines rather than help.

What happens if hreflang tags are incorrect or missing?

Google may ignore them entirely. If you use invalid language/region codes, mismatched links, or unidirectional references (Page A points to B, but B doesn't point back), the tags won't be used. This could lead to the wrong version showing up in search results or no regional targeting at all.

Is it okay to have multiple hreflang tags with the same language code?

Only if the region codes are different. For example, having both es-ES and es-CL is valid because they represent different Spanish-speaking audiences. But using multiple hreflang="es" tags with different URLs is invalid.

Should I use hreflang on every page or just the homepage?

You should add hreflang tags on every localized version of every page, not just the homepage. Each translated page must reference all other language versions of that same page, not just the domain root.

Can hreflang be used with JavaScript-rendered websites?

Yes, but with caution. If you are injecting hreflang tags with JavaScript, make sure they are rendered before search engine crawlers parse the page. For best results, include them server-side in the static \<head> section.

Does hreflang influence rankings?

Indirectly. Hreflang doesn't boost rankings like backlinks do, but it improves relevance, which can reduce bounce rates and increase engagement. That in turn supports better performance in search results.

What's the difference between localization and translation in this context?

Translation is simply converting content from one language to another. Localization goes further: adapting content, tone, currency, date formats, and cultural references for a specific region. Hreflang supports both. Learn more about software localization in our blog.

Conclusion

Adding hreflang helps localize your website content and ensures that search engines show users the most relevant version of your site. It enhances SEO, user experience, and can reduce bounce rates by serving content in the visitor's preferred language.

SimpleLocalize can help you manage translations and localization smoothly. Start with our free trial today and optimize your multilingual experience with ease!

SimpleLocalize translation management platform
]]></content:encoded>
            <category>hreflang</category>
            <category>seo</category>
            <category>developer</category>
            <enclosure url="https://simplelocalize.io/blog/hreflang-tag.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[10 tips to make your localization workflow more productive]]></title>
            <link>https://simplelocalize.io/blog/posts/easy-localization</link>
            <guid>https://simplelocalize.io/blog/posts/easy-localization</guid>
            <pubDate>Mon, 11 Jan 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[Want faster, cleaner software localization? Discover 10 practical tips to improve your i18n workflow, manage translation keys, use automation, and clean up unused strings.]]></description>
            <content:encoded><![CDATA[Tried to fix your localization setup, only to hit the same problems again? You are not alone. After working with dozens of teams over the past few years, we have seen the same mistakes pop up over and over. Here is a clear list of what actually works, based on real-world experience, to make localization faster, more reliable, and easier to maintain.

1\. Use unique translation keys

For each translation, use a separate translation key. Don't try to cheat the system. If you reuse one key in different places, you’ll eventually change a translation and break something you didn't expect. That's because the same text doesn't always fit every situation. Keep one key per translation.

Learn more:

Best practices for creating translation keys

What is a translation key?

2\. Don't capitalize with CSS

When you reuse a key in many places, you might end up needing one version with capital letters and one without. You may think text-transform: uppercase will solve that. It won't. Different languages have different grammar rules. In some, weekdays are not capitalized. In others, it depends on the sentence structure.

Users will notice grammar issues, and that can break trust. Just create separate keys for each version, and write them the way they should appear.

3\. Use same translation keys in buttons

If some action in your service always does the same thing, like "Save", "Submit", or "Cancel", then you should use the same translation key for every button. This is one of the few places where key reuse makes sense.

Thanks to that, you will keep consistency in your app. Users will recognize familiar actions faster and feel more confident using your product.

Save button translation example

4\. Avoid nested translation keys in JSON files

How many times have you tried to create a fancy directory structure to keep everything clean and tidy? Probably many. After a few days, you end up with the same mess, because instead of searching for the correct directory, you just drop files into a “temporary” folder.

It's the same story with translations.

In many i18n libraries, it's common to use nested translation structures, like:

Don't do this. The tidiness is artificial, and it won't help in the long run. Your app will evolve, because the only constant in software development is
change.
Moving translations around will become a nightmare. After some time, the translation key may not belong under its original parent node anymore, and then you will be forced to pick a new group or rework the structure completely.

5\. Keep flat structure

If you think grouping translation keys into directories is a good idea, then try using prefixes instead. In some cases, this is actually useful, for example with navigation or button labels.

You can write keys like:

nav-product-solution
or
nav.product-solution

This way, you will always know what a key is used for, without nesting or digging through folders.

6\. Use a translation management tool for localization

Translation management becomes a bigger topic as your project grows. Most i18n libraries use JSON files. They are readable, but they don't scale well.

Imagine you have separate files like:

Now you want to add a new phrase. You need to update every file, send it to translators, wait for changes, check that nothing's broken…

It's slow and error-prone. That's why we built SimpleLocalize: a clean, simple, and developer-friendly system to handle i18n. You can extract translation keys from your project using our CLI tool, manage translations in a visual editor, and integrate it with libraries like i18next, FormatJS, and mobile platforms like Android and iOS.

Watch our Quick Start Guide on YouTube to see how your life can be easier with the SimpleLocalize!

easy localization progress

7\. Translate with AI, then review

You don't have to translate everything manually anymore. Use AI to generate first versions of your translations, using ChatGPT, DeepL, Google Translate, or Microsoft Translator. Then review them before publishing.

SimpleLocalize supports automatic translations and lets you flag new phrases for review. This makes the process faster while keeping quality in check.

8\. Add a review step

Mistakes in translations are easy to miss. That's why adding a review step is important. With a proper i18n tool, you mark translations as "accepted" or "need review". This way, you can ensure that only high-quality translations are used in your app.

It's a small change that helps avoid embarrassing mistakes in production.

Localization progress graph showing reviewed translation

9\. Finding unused translation keys

One of the biggest issues in agile teams is that things move fast. Features change, and some translation keys stay behind. Over time, your project grows, and you end up with 10x more keys than you actually use.

Some keys are still useful, but no longer used in the code. Others have been replaced, but it's not clear if they can be deleted. The solution? Use SimpleLocalize CLI to find unused translation keys. It's open source, so it can be
used in an enterprise project.

Sort keys by last occurrence and clean them up confidently.

Learn more: How to find and delete unused translation keys

10\. Add screenshots for context

Short labels like “Open”, “Submit” or “Close” can mean different things depending on where they appear. Is "Open" referring to a file? A dropdown? A door?

You can avoid confusion by attaching screenshots to translation keys. That way, translators see exactly where the text appears. This reduces back-and-forth and improves translation quality.

translation key with screenshot

Conclusions

App localization is not an easy topic. Many people tried to invent a new smart way of handling it, and failed due to over-engineering.

How about keeping everything simple and clean?

Follow the KISS rule. Avoid clever tricks. Use one key per translation, flat structures, automated workflows, and a simple management system. That's how professional software teams handle i18n today.

Give SimpleLocalize a try and spend less time worrying about translations.
]]></content:encoded>
            <category>internationalization</category>
            <category>translation management</category>
            <category>tips</category>
            <category>software localization</category>
            <enclosure url="https://simplelocalize.io/blog/efficient-localization-tips-and-tricks.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[4 app categories that need multi-language support]]></title>
            <link>https://simplelocalize.io/blog/posts/2020-12-26-should-i-translate-my-app</link>
            <guid>https://simplelocalize.io/blog/posts/2020-12-26-should-i-translate-my-app</guid>
            <pubDate>Sat, 26 Dec 2020 00:00:00 GMT</pubDate>
            <description><![CDATA[See examples of apps that need translation management to reach a global audience. Learn why travel, eCommerce, SEO, and business apps need multi-language support.]]></description>
            <content:encoded><![CDATA[Reaching global audience

Did you ever wonder which apps need translation management because handling translated content is time-consuming?
Especially when you provide more than 2 languages! Continuous changes in-app translation can take a lot of resources of
your team, and at some point, everybody will stop carrying about all languages except the default one. How to stop
wasting resources on app translation, and still provide high-quality translations?

reaching global audience

1\. Travel apps

Travel apps need content translation to reach a global audience. A good example is our second project
called PlaceFlare with hand-picked places from a few countries like Italy, Great Britain,
Spain, Czech Republic, and Poland. The app contains about ~250 unique translation keys, which are gathered from the
application source code using SimpleLocalize CLI. All keys are
transferred to the SimpleLocalize Web Editor
where everything can be translated by native speakers and volunteers. When they finish work, somebody (translator or
project admin) can publish changes and voilà! Everything is done, there is no need for re-deploying the app or
re-building the project. Translations are fetched in real-time from the SimpleLocalize CDN, where all translations sit.

placeflare travel app with 5 languages

2\. eCommerce apps

The global market is one of the best things which gave us access to the Internet. Buying stuff has never been easier,
you can be based in Eastern Europe and sell your products to the locals, or the next day you will get an order from Brazil. What stops your clients more from buying your products online than long-distance? Fear that they will fill up
the order form wrong, and they will lose money. They will return to your page many times thinking about buying from you, and on the second screen, they will be looking for local stores. What can you do with it? Make them confident that in case of a problem, they will be able to get help from you. Being a professional seller with a global audience gives you many benefits.

online shop with multi language support

Many online shops have great translations, and they are perfectly faking that they are local stores. The client will
notice that it's not the local store, only then when he will get the package. Numerous online shops and retail stores
offer from 4 to 20 languages for visitors.

3\. SEO systems

If you are providing SEO service, you know the best that application which is available for your customers in native
language converts much better than the others. Many professional tools have at least 5 languages to choose from because
SEO tools are the kind of services that are used globally to increase the audience. Not every SEO expert or SEO novice
knows English perfectly to understand how your search engine optimization app will work for him. He/she will be familiar
with the basic words, but to explain them more you will need translation management.

multi language SEO optimization

I'm sure you heard about ahrefs we are also using this tool. Currently, the app supports 13
languages!
Wow! Maybe this is the reason the page is so popular among SEO experts!

4\. Business products

The most important apps need to be translated and have high-quality translations. Mobile and web systems must be
translated by humans to achieve the best possible explanation. Specialized vocabulary which occurs in such systems
should be consistent with the other business apps. If the potential client won't find words which he is familiar in your
system or landing page, then he may leave your page. Try to reach native speakers to get the best possible translation.

Another way is to check your competitor's page and try to match words, so your potential clients will know that they are
on the right page. Most of our clients support more than 18 languages in their apps. A good starting point should be at
least 5 languages which include: English, French, Italian, Spanish, and German. In many cases, you will also want to
support your language. Selling service on your local market is always a little easier than going global right away.

business apps add more languages

Example business apps with translation management systems

A good example of business apps:

Translation agency Luisa.ee from Estonia supports 5 languages on their site,

VendingMetrics is the vending company that provides mobile, and web app both of them
provides 5 languages to choose,

Estonian startup Getid.ee which provides fast identity verification for global businesses,

ReactJS documentation supports more than 20 languages. Every documentation page has an individual GitHub repository where people are translating content.

Nederland company print.com that lets you order every print product at lightning speed!

Conclusions

The rule of thumb on deciding if an app needs multi-language support is simple. If your app is targeted to people who
are not very technical, then you should consider adding multi-language support.
What if you don't have time or resources to translate the content right away? It's simple! There are libraries
like FormatJS
provides an option to display default content. Using FormatJS you can determine the translation key which you will use
in the future, and the default language value for now if translation won't be found. You don't have to use any other
external tool to do it.

An excellent approach is to add i18n support, even if you don't plan to add more languages now. Such an approach will
help you in the future in adding the next languages effortlessly. Not using specialized tools right away may cause that
your application will suffer from unprofessional and 'partial' translation. Developers often forget to add a special
piece of code to use translated content someplace.
]]></content:encoded>
            <category>tips</category>
            <category>software localization</category>
            <category>translation management</category>
            <enclosure url="https://simplelocalize.io/blog/app-categories-that-need-multi-language-support.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Introducing: Project API Keys]]></title>
            <link>https://simplelocalize.io/blog/posts/introducing-api-keys</link>
            <guid>https://simplelocalize.io/blog/posts/introducing-api-keys</guid>
            <pubDate>Sun, 15 Nov 2020 00:00:00 GMT</pubDate>
            <description><![CDATA[Check out the newest naming convention. Learn more about API keys, which are replacing project upload tokens, upload tokens, and API tokens.]]></description>
            <content:encoded><![CDATA[Background

To provide the best experience from our product, we needed to make important changes in our naming convention.
From now uploadToken, projectUploadToken, apiToken will now be known as: apiKey.

Why are we changing this?

In the future, this will allow us to offer multiple API keys per project. When we started working on SimpleLocalize, we had the option to add new keys and edit them in Web UI. Today, we are giving offering much more than a simple upload/import feature.
Our product offers:

translation key extraction CLI,

content delivery network,

import translations from Excel file,

export translations to JSON from Excel file,

unlimited rollbacks,

more important API access, which allows you to manipulate translations.

We know that many of you are using SimpleLocalize as a tool to save time and build your integrations.
We hope that this change will help our future clients and won't be and an obstacle for our current clients.

use api key to rule them all

What do I need to do?

Changes are transparent for your current 3rd party integrations.
There is no need to update anything. We are changing our naming convention to simplify our platform.
If you are using SimpleLocalize CLI
then please read the next section.

Patching your SimpleLocalize CLI configs

Update your simplelocalize.yaml configuration file and rename uploadToken property to apiKey.
uploadToken will be supported until November 2021.

change to

Where can I find my API Key?

Every project has assigned one unique API Key. You will find it in the project 'Integration' tab in the 'Custom Integration' section.

api-key-in-integration-tab

Check out updated API Documentation

For any questions, please contact us: contact@simplelocalize.io
]]></content:encoded>
            <category>product updates</category>
            <enclosure url="https://simplelocalize.io/blog/simplelocalize-api-key.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[FormatJS and React application localization]]></title>
            <link>https://simplelocalize.io/blog/posts/formatjs-reactjs-internationalization</link>
            <guid>https://simplelocalize.io/blog/posts/formatjs-reactjs-internationalization</guid>
            <pubDate>Wed, 07 Oct 2020 00:00:00 GMT</pubDate>
            <description><![CDATA[FormatJS - add more languages to your React app. Zero configuration required. Simple setup with 2-minute guide.]]></description>
            <content:encoded><![CDATA[React localization is one of the topics discussed vividly among developers. There are many i18n libraries built for React, React Native, and NextJS, that focus on app internationalization. Website or app translation is so important because it positively affects the product visibility and performance, increases the customer base and satisfaction by creating a special relation. It's all thanks to adjusting the product to their language, customs, and culture. Developers have a great choice of tools and libraries that can help them in i18n of the product, and one of them is FormatJS. 

About FormatJS

FormatJS, originally yahoo/react-intl, is a localization and internationalization set of libraries built mainly for React apps. It helps in i18n process, focusing on numbers, dates, and strings formatting. It provides i18n tools and packages that help with localization and app translation management.

A sample i18n file structure in FormatJS looks like this: 

In lang we create json files with supported languages, for example, en-US or fr. FormatJS focuses or improving development process of app internationalization and helps in future translation management.

How to translate React app with FormatJS?

The installation and translation process is quite straightforward. We will start with creating a sample project, then FormatJS installation and setup, and finally building and translating our app. Sounds fun, right? 😎

Create a sample project

Let's start with something simple. I will create a new project using create-react-app. Use NPM or Yarn like in the example below.

Or download the demo app from GitHub repository.

Install dependencies

Add react-intl library to your newly created project.

Add Language Context

In this project, I will use Context to keep translations and option to change language in real-time.

Read more about React Context API.

react-intl configuration

Let's create main configuration for i18n with react-intl and SimpleLocalize wrapper.

This wrapper will keep translations in our LanguageContext and it will also provide a function to change language in fly.

Translate your app with FormatJS and SimpleLocalize

Now, it's time to work on i18n and localization process. We use SimpleLocalize to extract translation keys and as a translation management and i18n online editor.

Create project

Create a SimpleLocalize.io project to get your unique messages variable. For this demo project, you can use the messages from the example above!

Wrap your application

Now let's use our newly created SimpleLocalize wrapper to provide translations for React application.

Done! React will now fetch translations from SimpleLocalize CDN and provide them to your app.
Let's check how to use it in the source code.

Translating React app

Now, let's start using translations, and create a basic web page.

FormatJS setup

See below how to apply translations for your React app. For that, we will use FormattedMessage component which wraps up all translation keys.

FormattedMessage component

\<FormattedMessage/> usage is very easy:

React will convert FormattedMessage tag into span tag and put concrete translation into it. You can also use \<FormattedHTMLMessage id="TRANSLATION_WITH_CSS"/> which will also produce a message with HTML inside span tag.

A sample translation key could look like the following:

Switch between languages

In the presented example, I used LanguageContext.Consumer to provide function. This function can trigger language change and fetch proper messages from the CDN.

You need Language.Consumer tag only in places where you would like to change the language. It's not needed for \<FormattedMessages/> tags.

Let's try it!

Note that translation works in real-time! How cool is that? Very cool!

React Localization with FormatJS

See live version

Project code is available on GitHub.

Translation management for FormatJS

FormatJS is a great tool for translating your React app. It is intuitive and not too complicated to introduce to your project. Using react-intl together with SimpleLocalize can really speed up the translation process with great auto translation tools (OpenAI, DeepL or Google Translate), many integrations and easy to use i18n online editor. It's a great help in development process thanks to SimpleLocalize CLI for FormatJS, which extracts all translation keys from your project with a simple command.

i18n online editor

Check our docs for FormatJS integration in SimpleLocalize and translate your app in our feedback-driven app. Get in touch or send us your feedback at contact@simplelocalize.io.
]]></content:encoded>
            <category>react</category>
            <category>react-intl</category>
            <category>format-js</category>
            <category>tutorial</category>
            <category>i18n</category>
            <category>developer</category>
            <category>software localization</category>
            <enclosure url="https://simplelocalize.io/blog/formatjs-localization-guide.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[i18next and React application localization in 3 steps]]></title>
            <link>https://simplelocalize.io/blog/posts/i18next-reactjs-localization</link>
            <guid>https://simplelocalize.io/blog/posts/i18next-reactjs-localization</guid>
            <pubDate>Thu, 01 Oct 2020 00:00:00 GMT</pubDate>
            <description><![CDATA[How to localize ReactJS application with i18next internationalization library. Learn how to manage localization in software project]]></description>
            <content:encoded><![CDATA[i18next - Background

We took original post inspiration from an awesome guy called Aryclenio Xavier Barros, who presented a sample app for localizing app with i18next. You can read it here.
We expanded the idea by adding a section about integrating i18next with translation management system.

How to start with i18n in ReactJS?

Thanks to that ReactJS is super popular library, we got so many options. The most popular i18n libraries are i18next and yahoo/react-intl. Today, I will show you how to integrate i18next into your ReactJS application.

Create a sample project

I will start with very beginning, and I will create sample app in ReactJS with TypeScript

Install dependencies

Now we are ready to start!

Configuring i18next

I will create i18n.ts file where I will put whole i18next configuration, and after that, we will import this file in index.ts.
My i18n.ts looks as following:

Project loadPath variable

Create a SimpleLocalize.io project to get your unique loadPath variable. For this demo project, you can use the loadPath from the example above!

Create missing translation keys automatically

I used property saveMissing with value true to tell i18next to function missingKeyHandler to automatically when the library won't find a translation key.
Create on backend missing translation keys with default translation.

Enable i18next in application

Configuration is completed when you import i18n.ts file in index.ts just by adding import './i18n'; Whole index.ts file should look like this:

We are done! i18next library is ready to use.

Using translations in the app

Now, let's use translations, and create a basic web page.

Import useTranslation hook

To import the i18next hook, we use the following code:

The t variable is a function used to load translations for a given key.

Using t in application code

t usage is very simple and clean:

in HTML, it would look like the following:

Switching between language

Now it's a time to add option to switch languages. I will use simple buttons without any fancy CSS styles. :) I added 3 buttons for English, Spanish and Polish language.

Let's check it!

Notice that translation is done in real-time! How cool is that? Very cool!

React Localization with i18next

see live version

Project code is available on GitHub.
]]></content:encoded>
            <category>react</category>
            <category>i18next</category>
            <category>i18next-backend</category>
            <category>tutorial</category>
            <category>continuous-localization</category>
            <category>developer</category>
            <enclosure url="https://simplelocalize.io/blog/i18next-localization-guide-with-translation-management.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Start with software project localization]]></title>
            <link>https://simplelocalize.io/blog/posts/start-with-software-project-localization</link>
            <guid>https://simplelocalize.io/blog/posts/start-with-software-project-localization</guid>
            <pubDate>Sun, 26 Jul 2020 00:00:00 GMT</pubDate>
            <description><![CDATA[Modern localization goes beyond translation. With SimpleLocalize, deliver personalized, multilingual experiences at scale through automation and collaboration.]]></description>
            <content:encoded><![CDATA[Localization is essential when adapting your app or website for global users. It's not just about translation, it's about tailoring your product to fit the language, culture, and expectations of a specific audience.

Whether you are launching a mobile app in Brazil or onboarding users in Japan, a localized product increases adoption, engagement, and customer satisfaction.

Benefits of localization in 2025

Localization significantly enhances the user experience by:

Presenting content in the user's native language

Respecting cultural nuances, symbols, and idioms

Improving accessibility and trust in global markets

Boosting SEO in local markets with language-specific keywords

Enabling compliance with local legal and formatting standards

In today's global digital economy, users expect personalized, local experiences. With each additional supported language, you open the door to a new segment of loyal users.

SimpleLocalize localization

How localization works — beyond translation

Localization goes deeper than translating words. It includes:

Regional language variations (e.g., Spanish for Mexico vs. Argentina)

Date, time, and number formatting

Cultural references and idioms

Symbol usage and iconography differences

Right-to-left (RTL) support for languages like Arabic and Hebrew

This level of detail ensures your product feels intuitive and natural, not foreign, to each target audience.

Check out our blog post on number formatting in JavaScript to learn more about how to handle different number formats in your code.

Meet SimpleLocalize: Modern localization for developers & teams

SimpleLocalize is a full-featured translation management system that integrates easily into your development and release workflows. Here's what makes it stand out in 2025:

✅ Translation Editor

Use the Translation Editor to manage your translations with ease. It supports key-value pairs, namespaces, and even complex JSON structures.

SimpleLocalize Translation Editor

🌐 Automatic Hosting via Translation CDN

Deploy your translations instantly using the SimpleLocalize CDN. This eliminates manual file handling and enables zero-downtime updates.

SimpleLocalize CDN Hosting

🤖 AI-Powered Translations

Speed up your workflow with AI translations. Use machine translations as a starting point, then refine them with your team.

SimpleLocalize AI Translations

🔄 GitHub Integration & CLI Tool

Sync your translations with GitHub or manage them locally using the SimpleLocalize CLI. Automate i18n key extraction, upload/download files, and more.

SimpleLocalize GitHub Integration

👥 Collaboration & Permissions

Invite team members, set granular permissions, and collaborate in real time on multiple projects.

SimpleLocalize Team Collaboration

💬 Community suggestions

Let your users contribute translations and suggestions. Use the Public Suggestions feature to gather feedback and improve your translations.

SimpleLocalize Public Suggestions

📝 Markdown translations

Write translations in Markdown format to maintain rich text formatting across languages. This is especially useful for blogs, documentation, and marketing content.

SimpleLocalize Markdown Translations

Why teams choose SimpleLocalize

SimpleLocalize is made to be developer-friendly and easy to use for teams of all sizes. Here are some key benefits:

Fast onboarding — get started in minutes

Developer-friendly — JSON, YAML, CSV, iOS/Android, and more

Great for SaaS — real-time updates with CDN hosting

Custom translation workflows — via API, CLI, or UI

Affordable for startups and scalable for enterprises

Ready to try it?

Don't just translate. Localize with precision and confidence.

Try SimpleLocalize free and experience how easy and powerful localization can be in 2025. No credit card required.
]]></content:encoded>
            <category>translation management</category>
            <category>software localization</category>
            <enclosure url="https://simplelocalize.io/blog/start-with-software-project-localization.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Internationalization tool for yahoo/react-intl]]></title>
            <link>https://simplelocalize.io/blog/posts/yahoo-react-intl</link>
            <guid>https://simplelocalize.io/blog/posts/yahoo-react-intl</guid>
            <pubDate>Fri, 26 Jun 2020 00:00:00 GMT</pubDate>
            <description><![CDATA[FormatJS - quick guide for localizing React apps and translation files management. Simple setup with 2-minute guide.]]></description>
            <content:encoded><![CDATA[Introduction to software localization

Are you struggling with keeping your app translations up to date, and your dreams are filled with empty keys to translate? No worries, we know that feeling very well. To make the whole localization process easier, we created a simple and effective solution which will improve the quality of translations and help you keep them in track!

simplelocalize flow diagram workflow

How does it work?

SimpleLocalize is a tool created to help developers manage translations in their apps. You can use import tool to upload all keys from your project to a cloud editor, translate them in the easy and clean spreadsheet and that’s all you have to do! Translated keys will be synchronized automatically with your project and vice versa, when you add a new key, it will appear in SimpleLocalize cloud ready to add the translation. You can use SimpleLocalize-CLI to find internationalization keys in the source code automatically, or you can import and export files manually. We support multiple formats, like yahoo/react-intl, Android XML String resources, iOS, Jekyll, Java properties and of course Excel and CSV files. Sounds interesting?

simplelocalize flow diagram workflow

i18n keys auto-discovery feature

SimpleLocalize is created to automatize your work and help you keep all translations up to date. You can create multiple projects and share them with your team, or give access to selected projects to the translators' team. When their job is completed, you can publish changes to the CDN, refresh your deployed application and voilà! Everything is translated now! You can easily check the progress of the project translations, track the missing keys and use as many languages as you want. Make your app available worldwide thanks to the professional and always updated translations.

How to start?

First, head to SimpleLocalize.io and sign up to get an account, the basic plan it's free, and allows you to handle a medium-sized translation repository. Create a new project by adding its name. Select the project type which will define the way the translations will be exported, for example, just CDN is the most common for web applications like ReactJS with yahoo/react-intl.

create project

Open the project and go to Settings. Download configuration properties with the one click on the button Download CLI Properties:

api credentials page

in downloaded file, set projectType: property to yahoo/react-intl  and it should look now like follows:

Read more about CLI projectType property. Save the file in your project root directory. Next, run the CLI tool in your project directory using the command line:

It will search for the keys in your project directory according to projectType defined in the configuration file and send them to the SimpleLocalize cloud, where you can easily check how many translations are missing and manage them in one place.

spreadsheet

Done, you successfully configured the project!

Add translations and publish changes to check how the keys are updated in your project! When you click Publish button all translations will be sent to your frontend app through the CDN, it works even when the application is deployed. That means you can change text on the page without rebuilding and redeploying the whole application. Pretty useful, huh?

Now you can fetch translations using url like follows:

https://cdn.simplelocalize.io/:projectToken/\_latest/:languageKey

or use SimpleLocalize CLI to download translations.

project list

Ready to start?

Give it a try and test the new internationalization tool we have created. It is designed to help you to keep all translations up to date, easily manage new keys and translations changes and work on multiple project at the same time, in one place. Integrate your web or mobile app with SimpleLocalize and work with your clients efficiently without Excel spreadsheets and translations files, instead use the clean and user-friendly interface of SimpleLocalize and control the i18n process in much pleasant way.
Create account, no credit card required!
]]></content:encoded>
            <category>react</category>
            <category>react-intl</category>
            <category>format-js</category>
            <category>developer</category>
            <enclosure url="https://simplelocalize.io/blog/yahoo-react-intl-localization.jpg" length="0" type="image/jpg"/>
        </item>
    </channel>
</rss>