Forem: Petr Hodný

How to localize Go app with go-i18n and Localazy

Petr Hodný — Wed, 21 Jul 2021 10:52:30 +0000

Are you looking for a straightforward approach how to localize your Go app into other languages? Seek no more - Localazy will take care of it for you.

Localazy is a universal translation management platform that supports a wide variety of formats and frameworks. It is a platform tailor-made for developers.

Thanks to the Localazy CLI, you can easily set up the download and upload commands to be part of your automation once and never be bothered by key extraction, file merging, and looking up which translations are still missing ever again.

Or you can just upload everything once, translate and download back manually. The choice is yours, and the localization possibilities are endless.

🚩 Localization with go-i18n

This article will show you how to prepare your Go project for localization using a very popular go-i18n package.

You will learn how to connect your Go app to Localazy, include your source keys in your main language in the application, and resolve the messages by their keys for both singular and plural variants in your primary language as well as others. Let's dive into it!

🙄 tldr;

sign up for Localazy ,
create an app with English as source language and Use community translations (ShareTM) option enabled,
select Go integration option and install Localazy CLI,
include go-i18n in your app,
create localazy.json in root and paste in and modify the configuration,
create locales folder and in it create en.json. Add any translation key-value pair,
run localazy upload,
in Localazy, add any language. Then review it and accept the suggested phrases,
run localazy download and check locales folder for the new locale,
run the app go run main.go

🕹️ Sign up and app creation

First of all, let's set up a new Localazy account and create a new application. In this article, we'll use English as the source language, but you can generally choose any other. Make sure that the Use community translations (ShareTM) option is enabled.

ShareTM is highly accurate translation memory. Thanks to it, most new applications have as much as 50 % of strings automatically pre-translated into 80+ languages.

Proceed to create the app. Then, select Go on the integration screen. We'll use the powerful CLI tool to manage the upload and download of phrases. Installation is available for Linux, macOS, and Windows.

Note the read and write keys from step 2 somewhere. We'll need them shortly.

🛠️ Set up Go app

If you don’t want to follow the step-by-step guide here, you can take a look at the finished repo. Otherwise, stay awhile and listen.

Configuration

First of all, initialize a Go module which is a core tool for managing dependencies. Since we'll be using Go packages, it just makes dependency management easier.

Just run:

go mod init go-i18n-example

The next thing to do is to integrate Localazy. Create localazy.json in the root of your application and paste the following configuration. Use the write and read keys from the step 2 of the integration guide page.

{
    "writeKey": "your-write-key",
    "readKey": "your-read-key",

    "upload": {  
      "type": "json",
      "files": "locales/en.json",
      "features": ["plural_object"]  
    },

    "download": {
      "files": "locales/${lang}.json"
    }
}

The upload section is for locating the source language file and uploading all of the source keys. Note the plural_object option, this configures to recognize plural variants using key-value approach.

The download section is configured to download the published languages in Localazy back to the locales folder under the language's tag name.

However, the English language file is still missing. So create en.json within the locales folder. Since we’ve set English to be the source language, this file will contain the source keys for our application. You can fill in any key-value pair you like. I’ll add this:

{
    "listen": "Stay a while and listen",
    "person": {
        "one": "person",
        "other": "people"
    }
}

Go code

Got the pun? Go (as verb) code?😅 Anyways, create a main.go file in the root folder and paste in the following code.

// main.go
package main

import (
    "encoding/json"
    "fmt"

    "github.com/nicksnyder/go-i18n/v2/i18n"
    "golang.org/x/text/language"
)

func initLocalizer(langs ...string) *i18n.Localizer {
    // Create a new i18n bundle with English as default language.
    bundle := i18n.NewBundle(language.English)

    // Register a json unmarshal function for i18n bundle.
    // This is to enable usage of json format
    bundle.RegisterUnmarshalFunc("json", json.Unmarshal)

    // Load source language
    bundle.LoadMessageFile("./locales/en.json")

    // Initialize localizer which will look for phrase keys in passed languages
    // in a strict order (first language is searched first)
    // When no key in any of the languages is found, it fallbacks to default - English language
    localizer := i18n.NewLocalizer(bundle, langs...)

    return localizer
}

We have prepared a factory function for initialization of localizer object from the go-i18n package that is responsible for looking up strings in selected language by it's key.

As you can see, the initLocalizer function is defined as variadic which means it can take an arbitrary number of arguments. That is convenient since you may want, in certain scenarios, to look up the string in several languages, especially when you're just searching for regional variants.

Now, let's add the rest of the example code that will print a single message that combines the simple key and the plural key we've defined earlier in the json localization file.

You could also use other formats if you prefer, such as TOML or YAML.

I will already predefine Latin American Spanish as the first desired language and then *Spanish * as a first possible fallback. We don't have those translations yet, but we will shortly.

// main.go

...

func main() {
    //
    localizer := initLocalizer(
        language.LatinAmericanSpanish.String(),
        language.Spanish.String(),
    )

    simpleMessage, _ := localizer.Localize(&i18n.LocalizeConfig{
        MessageID: "listen", // source key identifier
    })

    pluralMessage, _ := localizer.Localize(&i18n.LocalizeConfig{
        DefaultMessage: &i18n.Message{ID: "person"}, // another source key identifier
        PluralCount:    2, // would use "one" variant if the count was 1
    })

    fmt.Println(simpleMessage + ", " + pluralMessage)
}

Your project structure should look like this at this point:

.
├── locales
│   └── en.json
├── go.mod
├── go.sum
├── localazy.json
└── main.go

You can already test it out. Run go run main.go and you should see Stay a while and listen, people message in your terminal. Since the localizer could not find those keys in either Spanish variant, it has fallen back to the English language.

~/go-i18n-example $ go run main.go

Stay a while and listen, people

↪️ Uploading and downloading strings

Upload using CLI

Let's upload the English file to Localazy. From the root folder, run the following command

localazy upload -s

The -s argument stands for simulate. It is a good practice to test out the configuration without uploading anything to assure that nothing unexpected happens (such as some of the key-value pairs are incorrectly matched and override each other).

The output should be something along these lines, depending on the CLI version.

Localazy CLI, v1.4.5
Command-line tool for the Localazy platform.

Read more information at https://localazy.com/docs/cli

Parameters:
  - deprecate missing: false
  - import as new: false
  - force current: false
  - filter source: true
  - app version: 0
  - groups: (default only)
  - folder: .

Processing files...

locales/en.json
(file: file.json, lang: inherited, type: json)

Verifying...

Validating...

Done.

And now, let's let upload it for real.

localazy upload

Translate and review with the power of ShareTM

Refresh your app page and you should see the English language on the list. Open the Add languages tab and there you find a couple of languages with info about the percentage of automated translations.

It is possible that you will see either 50 % or 100 %. The automated matching with ShareTM improves all the time and it's likely that thanks to this article you would have all the strings automatically translated. How cool is that? 🙂

One way or another, look up Spanish and Latin American Spanish and add them to your app. You'll see that there is a review button. Every time ShareTM provides a translation suggestion, it will have candidate status. This means that it will be ready for review, and any reviewer can either approve it or decline it. Go ahead and approve the suggested text(s).

In case that the ShareTM did not translate 100 %, come back to the languages list and notice that the review button now reads translate. Localazy recognizes that there is nothing to review but still something to translate, so it offers you the next most likely action in one click.

Translate the remaining texts (you may use one of the suggestions on the translation page). This time you do not need to go through the review process since you are a trusted translator as owner by default, so the translation is immediately approved.

Use newly translated languages

It's time to go back to the Go project. 🙃

localazy download

With this command, you'll download all the recently accepted translations and newly added languages. In the locales folder, we can see there are newly created es.json and es-419.json files.

This how your final project structure should look like:

.
├── locales
│   ├── en.json
│   ├── es-419.json
│   └── es.json
├── go.mod
├── go.sum
├── localazy.json
└── main.go

Let's include these translations in the application. Add the following lines to the initLocalizer function just below where you load the English file.

bundle.LoadMessageFile("./locales/es-419.json")
bundle.LoadMessageFile("./locales/es.json")

Now when you rerun the app, you'll see that Localazy correctly translated the strings to Spanish.

~/go-i18n-example $ go run main.go

Quédate un rato y escucha, Personas

✔️ Closing words

I hope you've enjoyed this sneak peek at what Localazy can do for you and understood how easy it is to start localizing any Go app with it. If you would like to play around with the prototype, you can check it out on Replit. The whole git repository is available on GitHub.

If you have any questions, just join us on our Discord for a chat.

How to convert Android XML to iOS .strings using Localazy

Petr Hodný — Tue, 20 Jul 2021 07:36:38 +0000

Localizable file format conversion is not an easy task, considering the required transformation, the different support for plural forms, and the many other challenges of converting one file to another format.

Fortunately, Localazy comes with the Format Conversions feature and vast support of formats and integrations you can utilize by downloading our multiplatform command-line interface (CLI) tool.

🔖 Why Android XML to iOS .strings?

Android and iOS are, without a doubt, the most used mobile operating systems, both with billions of users and with the largest app stores in the global market.

Android and iOS app development differs, but you can preserve the content. So, you can develop an Android app first, and as long as you keep the strings and the remaining content (audio, images, video, etc.) external, you'll be able to reuse it to develop an iOS version of the app.

This approach allows you not to have to do everything from scratch again and save your time.

❓ What are localizable file format conversions?

To localize a project, we need to keep everything the user sees external to ensure that whenever we need to adapt the project to different areas/regions/countries, we won't have to fiddle with the code every time we want to add a new locale.

Read our guide on How to prepare your app for i18n & l10n

The text is how we mainly communicate with the user, and so we need to keep the strings outside the code, stored in a file with a determined format. This format depends on the framework/library we are using, as different frameworks/libraries have specific structures they work with.

So, what will happen if we want to adapt our product to new platforms or integrate new tools and utilize different localizable file formats? Will your files be unusable? No, Localazy got your back; we'll convert the file formats for you with our Format Conversions feature.

Is localizable file conversion with Localazy free or paid?

Format Conversions are available for all users with the Localazy Professional tier and up.

See the pricing page for options

It will pay off with the first single conversion you perform—no limitations as of formats, number of operations, or conversion data volume. Once you make it a part of your workflow and automate converting localizable files, your dev life will get easier, we can guarantee that. 🤩

📋 Sample Android XML to iOS .strings conversion

To demonstrate the feature, we'll create an XML file, and we'll do an example conversion to .strings.

Simple setup

Let's start by creating a directory to keep our files organized. It will have the following layout :

.
├── locales
├── converted
├── localazy.exe
└── localazy.json

The locales folder is where we will keep the file we want to convert, and in the converted folder, we will store the converted files. All of this will have to be configured in our localazy.json file.

The localazy.exe file is the Localazy CLI; if you use a different OS, you might not have to have it downloaded and stored here.

For more information about the Localazy CLI, check The Basics – Localazy

Inside our locales folder, we'll create an Android XML file with a few strings, we'll name it en.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="android">"Android was developed by Google"</string>
    <string name="conversion">"I\'m converting files"</string>
    <string name="ios">"iOS was developed by Apple"</string>
    <string name="weather_answer">"It\'s rainy and cold"</string>
    <string name="weather_question">"How\'s the weather outside?"</string>
</resources>

Our directory will now look like this:

.
├── locales
│   └── en.xml
├── converted
├── localazy.exe
└── localazy.json

You have to configure the localazy.json file depending on what we are doing. In this case, we are doing a simple conversion between two formats, so we'll keep the configuration simple:

{
   "writeKey":"your-write-key",
   "readKey":"your-read-key",
   "upload":{
      "type":"android",
      "files":"/locales/en.xml"
   },
   "conversion":{
      "actions":{
         "type":"ios-strings",
         "output":"converted/${lang}.lproj/Localizable.strings"
      }
   }
}

As you can see, we have two sections. The upload section is built to configure the upload properties, and the conversion section is built to configure how and to what you want to convert your uploaded files into.

We also have the writeKey and readKey fields. Here you have to place your project's keys.

To get your keys, log in to your Localazy account and create a new project by choosing the format you'll use to upload. When you create the project, you'll get the keys, and then you can place them in the localazy.json configuration file.

Remember that the Format Conversions feature is only available for users with the Professional tier and up, meaning that the following steps will not function if you are on the Free plan and the feature is locked. However, you can activate a 7-day trial of the Professional plan to try everything out.

Most work is done, now you'll have to open your CMD in the root of your directory and run:

localazy upload

When this command is finished, run:

localazy download

Your directory will now look like this:

.
├── locales
│   └── en.xml
├── converted
|   └── en.lproj
|       └── Localizable.strings
├── localazy.exe
└── localazy.json

The Localizable.strings file will contain the following:

"android" = "Android was developed by Google";
"conversion" = "I'm converting files";
"iOS" = "iOS was developed by Apple";
"weather_answer" = "It's rainy and cold";
"weather_question" = "How's the weather outside?";

Easy right?

Plurals

This far, we only showed you the basics of our Android to iOS file format conversion, and our example was pretty simple with a few strings.

But, what if we throw in some plurals as well?

Let's add the following strings to our Android XML original file:

<plurals name="availableSongs">
    <item quantity="one">%d song found.</item>
    <item quantity="other">%d songs found.</item>
</plurals>

Because we're converting to iOS, our plurals will have to be placed in a .stringsdict file, meaning that we'll have to configure our localazy.json file to distinguish the plain strings from the plurals and put them in the different file format.

{
   "writeKey":"your-write-key",
   "readKey":"your-read-key",
   "upload":{
      "type":"android",
      "files":"/locales/en.xml"
   },
   "conversion":{
      "actions":[
         {
            "type":"ios-stringsdict",
            "output":"converted/${lang}.lproj/Localizable.stringsdict",
            "params":{
               "variable":"COUNT"
            }
         },
         {
            "filterPlurals":true,
            "type":"ios-strings",
            "output":"converted/${lang}.lproj/Localizable.strings"
         }
      ]
   }
}

Because we are generating a .stringsdict file, we are required to add the field variable inside params.

When we run Localazy CLI's upload and download commands, our directory will now look like this:

├── locales
│   └── en.xml
├── converted
|   └── en.lproj
|       └── Localizable.strings
|       └── Localizable.stringsdict
├── localazy.exe
└── localazy.json

Our plain strings are in the Localizable.strings file, and our plurals are in the Localizable.stringsdict file.

The Localizable.strings file should look like this:

"android" = "Android was developed by Google";
"conversion" = "I'm converting files";
"ios" = "iOS was developed by Apple";
"weather_answer" = "It's rainy and cold";
"weather_question" = "How's the weather outside?";

And Localizable.stringsdict like this:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
    <dict>
        <key>availableSongs</key>
        <dict>
            <key>NSStringLocalizedFormatKey</key>
            <string>%#@COUNT@</string>
            <key>COUNT</key>
            <dict>
                <key>NSStringFormatSpecTypeKey</key>
                <string>NSStringPluralRuleType</string>
                <key>NSStringFormatValueTypeKey</key>
                <string>d</string>
                <key>one</key>
                <string>%d song found.</string>
                <key>other</key>
                <string>%d songs found.</string>
            </dict>
        </dict>
    </dict>
</plist>

Platform Specific Key Filtering

In some cases we might need to filter some strings, for that we have the platform key filtering option.

Let's add a few strings that contain 'Android' into our Android XML file. For simplification we are not including the Plurals section here, as we only want basic strings:

<?xml version="1.0" encoding="utf-8"?>
<resources
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="android">"Android was developed by Google"</string>
    <string name="conversion">"I\'m converting files"</string>
    <string name="ios">"iOS was developed by Apple"</string>
    <string name="weather_answer">"It\'s rainy and cold"</string>
    <string name="weather_question">"How\'s the weather outside?"</string>
    <string name="android_love">"I love Android"</string>
    <string name="android_best">"Android is the best mobile OS"</string>
</resources>

We probably won't use the strings showing our Android affection in the iOS version of our app, so what now?

Let's add one more field in the localazy.json file:

{
   "writeKey":"your-write-key",
   "readKey":"your-read-key",
   "upload":{
      "type":"android",
      "files":"/locales/en.xml"
   },
   "conversion":{
      "actions":{
         "excludeKeys":[
            "CONTAIN:android"
         ],
         "type":"ios-strings",
         "output":"converted/${lang}.lproj/Localizable.strings"
      }
   }
}

The excludeKeys field allows you to filter out strings depending on the content of their keys.

In this case we just added the operation CONTAIN which filters out keys that contain the declared value. There are various operations available and you can add multiple operations inside an array.

Check all the available operations in the documentation

Let's run our CLI once again, and the result is:

"conversion" = "I'm converting files";
"ios" = "iOS was developed by Apple";
"weather_question" = "How's the weather outside?";
"weather_answer" = "It's rainy and cold";

📌 Closing Words

As you can see, it's effortless to convert localizable file formats with the Format Conversions feature of Localazy.

It's time to expand your project to other platforms. If file conversion is something you are battling within your CI/CD , consider getting the Localazy Professional plan and make your dev life easier with automatic file format conversions. ✌️

An overview of software localization and i18n tools (2021)

Petr Hodný — Fri, 14 May 2021 06:53:33 +0000

As a developer, you have pretty extensive software internationalization options, language localization, and phrase translation solutions. But when it comes to decision making, the wide variety makes it harder to make a qualified decision on which solution is the best for you and your project. How could one navigate in such a plethora of options?

Let's take a closer look at it!

🎌 Difference between internationalization and localization

Internationalization (i18n) is the preparation of software for multilingual support. Localization (l10n) is the process of aligning internationalized software with particular cultures' needs, whether you align language, meanings, values, beliefs, or visual code.

🤔 Many factors coming into the decision process

Technologic compatibility
Service accessibility
Service availability
Technical debt
User experience
Easiness of adoption and maintenance
Business compliance
Business model/pricing policy

🛠️ Types of software i18n&l10n&t9n solutions

i18n frameworks, formats
language technology providers
language service providers
software localization services

🗃️ i18n frameworks, formats, and language technology providers

There are multiple i18n frameworks and formats worldwide you can use for your software internationalization project. All of them have some specialties.

For example:

And many more, which you can find on the Localazy Integrations page. If you think something is missing, kindly let us know, and we will make sure Localazy supports your platform.

Lost in localizable file format conversions?

Activate the Format Conversions add-on and seamlessly output your translations in many different formats. Format conversions come especially handy when you are developing your app simultaneously on multiple platforms or when you need to share texts between the front-end and back-end of your project.

Once you activate the Format Conversions add-on, you can start using new commands in the Localazy CLI tool to convert your localizable files into different formats. Make it a part of your workflow and automate file format conversions to output your translations in many different formats seamlessly.

Language technology providers

The language technology provider will enable you to use their technology to translate your software; however, they will most probably not offer complete localization services, including phrase translations. It is then only your responsibility to implement the technology and use it to localize your software projects.

Language service providers

Language service providers usually provide you with the underlying technology. Still, their core business is preferably in the localization services itself - they help you translate phrases using professional translators, provide you with cultural expertise, and so on. LSPs are, by principle, more expensive because there is an increased portion of human work, and technology is just a part of the workflow. You may still want to check if your LSP uses proper technology, not adding pennies to your bill because of tech debt and non-effective workflows.

Software localization services

Highly specialized providers focused on software. While language tech and service providers can offer you to localize software and content in general, software localization services dedicate themselves to the SW development vertical. They are thus highly qualified for your kind of job, frequently from i18n to l10n of user interfaces.

Going further in the software category

The software localization category can go even further. Notably, there are companies focused on the gaming industry, such as Keyword Studio. And there are companies focused on single developers and small digital teams, such as Localazy. If you want to localize your software as an expert, but enterprise solutions are not a cup of your coffee, give us a try.

Combined solutions / A lá carte

Within the market, you can, of course, find combined / A lá carte solutions for your project. Just make your choice of the service you need and order. Do you need only technology? Or do you need just translations? Or maybe both?

No problem.

📌 List of i18n/l10n/t9n services and frameworks

Let's dive into the actual tools you can use for localization and translation management. Which one should you pick? That depends on your budget, goals, expectations, and the size of your team and project. Allow us to introduce some of them in the following section.

Editor's pick

🔵 Localazy.com

Which localization tool is the best? You guessed it. 😎 Obviously, it's Localazy! 😀 Why?

By developers, for developers

Localazy is a developer-friendly automated localization platform. With the powerful CLI tool and comprehensive integrations, any developer can localize their project conveniently.

See the list of available integrations and supported file formats
Learn how to integrate Localazy into your project

Flexible and affordable pricing

You can use Localazy for free and enjoy all core localization features without any recurring payments. Zero compromises, unlimited localization features.

The free plan includes:

Unlimited apps
Unlimited languages & translations
Unlimited machine translations
All integrations & formats
200 managed source phrases

Localazy offers affordable plans suitable for single developers and bigger teams alike.

See our pricing

Instant translations with ShareTM technology

We are developers; we share our code, we cooperate, share our knowledge and libraries. We have this in our DNA. It saves us time and money; it helps us to move forward faster and produce better software. ShareTM is what makes Localazy unique and different from other translation platforms.

ShareTM is a pro-active translation memory that translates your app automatically to new languages. It works like magic!

Powerful features

Discover add-ons that make translating and maintaining your project even more enjoyable.

Connected Apps share translations across backend and frontend, from Android to iOS, or anything else you would like. Many-to-many translation shared memory.
Format Conversions allow you to convert translated files between different formats.
Release Tags allow you to release translation updates iteratively only when you want. Test translations on stage before pushing to production.
Additional MT will give you three other powerful machine translation engine suggestions to help you make more accurate translations and unlock other features.

Translation on auto-pilot

Focus on what's important and use Virtual Translator (VT) to automatically translate and review your phrases to selected languages. Choose between human-assisted machine translation or professional translations, and we will handle everything from there!

Unique review process

Our review process is a pro-active tool that helps you verify translations and keep track of all changes that happened on Localazy while you spent your precious time making your product better.

The primary function of the review process is to help you with verifying new translations from your contributors. You can accept or reject translations or mark them as acceptable but not good enough, etc.

As an addition to the approve/reject mechanism, you can directly edit the suggested translation and alter it. That's extremely useful for minor changes. The translation may be perfect but with a small issue such as a missing exclamation mark or typo, which is something you can quickly fix on your own.

Learn more about the review process

Clean and user-friendly UI

Even though software developers might be fairly used to encountering obscure tools and outdated interfaces, we strive to make all of our users feel at home and pay great attention to UX and design our interfaces thoughtfully.

Clean UI displaying all of the important information with minimal clutter will help you focus better and get things done quickly.

Read a review of Localazy UI by an experienced translator Michał Tosza

Stellar support and community engagement

Our users frequently mention our dedication to customer support and fast response times in their reviews and testimonials. Please chat with us whenever you have a question or encounter an issue on your localization journey! We are here to help. 😊

We also love to communicate with our users and involve them in the development process. Whether we ask for feedback, invite them to test new features early, or just exchange banter in the forum, we are always happy to talk!

CDN and OTA updates

Our CDN allows you to use translated files directly in your project without needing to rebuild and publish. Just get the link, and you won't have to worry about updates of translations.

Android developers can integrate our Gradle plugin that will do the work for them. Integrate Localazy OTA updates without a single change of your source code.

Other popular tools

The following section will list some of the other most popular translation management platforms for software developers. They are listed in no particular order, and you can compare each with Localazy to see who will fit your needs better.

🟠 Lokalise.com

Trusted by prominent brands like Revolut, Daimler, and TESCO, Lokalise is without a doubt a well-established tool for localization and translation management. A great variety of valuable features such as real-time translations for support tickets and in-context editing makes Lokalise an excellent choice for teams requiring distinct localization approaches in their daily operations.

But, even though Lokalise offers a 14-day trial to test out their Enterprise plan, with the Start plan starting at 90 dollars (billed annually), Lokalise is one of the pricier options out there.

Localazy offers core localization features for free up to 200 phrases, why not give us a shot?

Compare Lokalise vs. Localazy

🟣 Smartling

Smartling is considered a market leader in the computer-assisted translation field. With customers like Shopify, Pinterest, Vimeo, and other big names, we can only agree that it is a valid assumption. Smartling emphasizes the human aspect of CAT and prides itself in connecting customers directly with their translators. Smartling also offers a robust infrastructure and a unique approach to translation performance tracking.

However, the pricing is not transparent, so you can't know how much Smartling will cost you without asking them first. Becoming a part of Smartling might prove expensive, but their linguistic asset management services look promising in increasing translation quality control for any language.

Localazy offers a transparent pricing model with many core features free.

🔵 Phrase.com

Previously known as PhraseApp, Phrase.com is an established all-in-one software localization platform with many features for the whole team. The idea of the Phrase platform is centered around translation workflow management and different roles employed in the process.

However, Phrase is not outfitted with machine translations (MT), so you are either on your own, or you can order professional translation services on the platform. Phrase allows a 14-day trial, and the Basic plan starts at 23 dollars a month at the date of publishing this post.

Localazy offers machine translations for all users to speed up the process and minimize the localization headache.

Compare Phrase vs. Localazy

🔵 AppLanga.com

AppLanga is an online translation management platform that specializes in the localization of native mobile apps and games. AppLanga offers its' own SDK, integration with leading platforms for mobile app development, in-context editor, and OTA updates to speed up the delivery of localization changes to users.

There is no phrase limit, and you can even use AppLanga free of charge for a small project with under 1000 MAU (monthly active users). To access more features such as glossary and invite team members, you have to upgrade to the Pro plan, which is 500 dollars per month.

With Localazy, you can use the Glossary and invite your teammates to help you with translation even on the free plan!

Compare AppLanga vs. Localazy

🟢 Localise.biz (Loco)

Loco is a simple platform for translation management supporting 14 file formats. With the free plan, you can translate two projects into up to 10 languages. Loco is an affordable option with the Pro plan starting at only 6 dollars a month, and you can increase the limit with additional monthly charges. You can also automate the distribution of localization files with the Loco API.

However, Loco does not offer any translation services or MT engines, and you have to handle the translations on your own. Loco is also available as a free WordPress plugin for a user-friendly localization of themes and plugins, making it perfect for indie WordPress developers or handy site owners who are looking for a free option to localize their WordPress site.

With Localazy, you can set up the Virtual Translator to translate your apps or use machine translations. On top of that we don't limit the number of projects or languages!

Compare Loco vs. Localazy

🟣 Transifex.com

Transifex is a cloud-based localization platform trusted by some of the world's tech leaders such as Atlassian, Trello, or Disqus, to name a few. Transifex offers a variety of integrations not only for developers but for designers, support platforms, and e-commerce solutions as well. With Transifex, you can also manage localization workflows, order professional translations and view comprehensive reports to measure your efforts.

You can try Transifex for free. The Basic plan starts at $70 / month and offers up to 50,000 words, unlimited projects, and essential tools to start localizing your project. However, the initial setup might not be the easiest out there, according to some reviews.

Integrate Localazy in minutes with our developer friendly CLI tool and try Localazy for free.

Compare Transifex vs. Localazy

🟠 ICanLocalize

Focusing on professional translation delivery between over 400 language pairs, ICanLocalize is a great choice for one-time projects. They also offer transparent pricing with rates that start at 0.09 USD per word and no additional storage fees. Since ICanLocalize is the company behind the WPML plugin for WordPress, using their services for translating WordPress websites should be easy.

Translating Android or iOS apps is possible with ICanLocalize too, but you have to upload files manually every time you make a change in your project, which means you must add an extra step into your workflow. You can also upload any documents for translation, and with their Instant translation service, translating short texts is possible within minutes for common language pairs.

You can fully automate the localization process with Localazy and forget about handling files manually thanks to our CLI, and CDN.

🔵 OneSkyApp.com

OneSky offers an end-to-end localization solution with 50+ Languages, 1,000+ Translators, and 19 compatible file formats. OneSky is an established platform that has helped many companies localize their mobile apps and games, including HubSpot, Ubisoft, and Microsoft. Pricing at OneSky is pay per word, starting at $0.04 for translation and $0.05 for review, and offers only translators with technical experience and industry-specific knowledge suitable for your project.

Additionally, OneSky offers App Store Integration for description translation and On-Device Testing to ensure your UI won't break in other language versions, emphasizing their specialization in apps and games.

Localazy offers a wider variety of approaches to the localization process. You can translate your apps on your own, invite volunteers or order the Virtual Translator. We don't push you to pay per translated word if you don't want to!

Compare OneSkyApp vs. Localazy

🟢 i18nexus

i18nexus allows you to quickly edit, automate, and manage your translations and connect them to your website, app, or video game with the i18next framework. i18next is a flexible JSON approach that works with all modern tech stacks, including libraries for React, Angular, Node, iOS, Ruby on Rails... i18next is one of the top open-source internationalization frameworks and Localazy supports i18next as well!

i18nexus translates your app using Google Translate immediately, but you have to source professional translators yourself and invite them to i18nexus if you want to localize your app professionally. The free plan is quite generous, offering up to 500 strings for free; the basic plan (up to 3000 strings) starts at $14 / mo.

Localazy allows you to automate your i18next project localization and order professional translators when you are ready. You can fully focus on development and improvement of your software, while Localazy handles the rest for you!

🟣 Lingoport

Lingoport is a full-service solution that provides a broad range of software internationalization services customized to fit your release goals, technologies, engineering resources, and budget. Established in 2001, Lingoport is trusted by the world's largest software companies, including Snapchat, VISA, or Dell.

Lingoport Suite consists of three products: Globalyzer, Localyzer, and Localyzer QA that work together to support i18n, L10n, and QA. All Lingoport Suite products offer various license choices ranging from cloud hosting, private cloud installation, and on-premise installation. On the other hand, you can't easily find the pricing models for any of the options offered by Lingoport, so you would have to contact them with your specific case.

Automate the localization of your project with Localazy, start for free and upgrade when you need. Deliver your translations via our CDN or OTA updates, and don't waste time on complicated setup and maintenance.

🟡 GitLocalize (part of Alconost)

Aimed at single developers and small teams, GitLocalize is a free and simple-to-use translation management tool that integrates directly with your GitHub repository. GitLocalize tracks changes in your repository and pulls them into the project. Translations are then sent to the repository via a pull request.

Setup is easy, and translations can be managed statically on a file level and compared to the original by segment. Since the tool is free, you shouldn't expect any built-in machine translation help or professional translation services, so this important part of the localization process has to be sourced elsewhere.

Localazy can do the same as GitLocalize and much more for you, e.g.:

translate your project with machine translations and ShareTM,
fully automate the localization process with the Virtual Translator
deliver translations to your users via CDN...

⚫ Babble-on

Babble-on is an expert team of native translators and writers. With their app localization service, you can have your app translated professionally into any language of your choice. Babble-on supports around 20 file formats. You can sync via Github or Bitbucket or send them the latest export of your strings to get your translated files back in a few days.

Babble-on can handle the whole process for you, or you can join their translation system and participate by adding context & screenshots, answer translators' questions, and remove texts you don't want to translate. Pay $0.21 per word, with zero monthly fees. Babble-on can also help you with your app descriptions and press releases in different languages.

With Localazy, you can translate your apps on your own with the help of machine translation engines, invite volunteers or order the Virtual Translator to translate your project automatically and pro-actively.

🔵 locize.com

Locize is a translation management system with a variety of features built by the creators of i18next. You'll find features aimed at teams, contributors, and managers, as well as single developers + other essential tools for efficient translation management. Locize also offers professional translations, and machine translations are included within the system as well.

On top of that, you can translate your website directly from your browser with their InContext Editing tool. Locize employs a variable "pay as you go" pricing model that might be hard to understand at first, and the UI might seem cluttered for some users, but you can try a 14-day trial to see if Locize is what you are looking for.

Translate your app comfortably and enjoy the clean and user-friendly interface of Localazy. Also, please don't get lost in pricing calculations, take a look at our transparent and easy to understand pricing ;-)

Compare Locize vs Localazy

and more...

This list is not exhaustive, if you would like to see a comparison with your current platform or service not included in the list, kindly let us know. ;-)

✔️ In conclusion

We hope this article helped serve as a broad overview of solutions available for software localization and translation management.

At Localazy, we are working very hard to become the go-to option for software developers in need of a localization platform. We believe that everyone should be able to enjoy software in their native language. We want to bring together developers, users & translators that believe in the same thing and provide them with an effortless way of translating their projects.

We value the feedback of our current or potential users. Whether you are a developer or freelance translator, join our forum and let us know what you think!

💖 Why developers love Localazy?

Whether you are a single developer or an agency, you can rely on Localazy when it comes to i18n & l10n!
Read our testimonials!