Software localization (often abbreviated as l10n) and internationalization (i18n) are crucial processes for companies looking to reach global markets. Understanding the terminology associated with these processes is essential for effective communication between localization and development teams. This article provides a comprehensive A to Z list of key terms in software localization.

A

API (Application Programming Interface)

An API, or Application Programming Interface, is a set of rules and protocols for building and interacting with software applications. It acts as a bridge allowing different software programs to communicate with each other. APIs can help do the following:

• Automate the testing of localized versions of software
• Automate the transfer of content between content management systems (CMSs) and translation management systems (TMSs)
• Integrate version control system (like Git) with localization platforms

Agile Localization

Agile localization is the practice of integrating localization processes into agile development methodologies. Here’s how the process looks:

1. Project Setup

• Define the scope, languages, and assemble the team
• Establish tools and resources (localization platform, style guides, glossaries)

2. Sprint Preparation

• Rank localization tasks by priority
• Set sprint targets and assign tasks

3. Content Workflow

• Extract content that needs translation
• Translate, then review the content
• Merge translations back into the software

4. Testing and Validation

• Perform both linguistic and functional tests
• Fix issues and improve translations

5. Deployment and Feedback

• Deploy localized versions
• Collect and analyze user feedback

6. Sprint Reflection and Iteration

• Review the success of the sprint
• Plan improvements for the next cycle
• Start the next iteration

This process allows for the continuous delivery of localized content as the product evolves.

B

BiDi

BiDi is an initialism for Bidirectional text. It refers to the handling and display of text that includes both left-to-right (LTR) and right-to-left (RTL) scripts, often within the same context. This is especially important for languages like Arabic, Hebrew, Persian, and Urdu, which use RTL scripts. 

In localization, BiDi support ensures that these languages are displayed correctly and readably, with text, punctuation, and numbers properly arranged. It also impacts user interface layout, text input fields, and overall formatting, requiring careful adaptation to switch between LTR and RTL layouts. Proper BiDi support is essential for providing a seamless and accessible experience in multilingual software, particularly in global markets targeting RTL language users.

Bitbucket

Bitbucket is a web-based version control repository hosting service owned by Atlassian, primarily used for managing Git repositories. It provides a platform for developers to collaborate on projects, track changes, and manage code versions effectively.

In the context of software localization, Bitbucket can be integrated with various localization management systems, allowing teams to synchronize their translation files and streamline the localization process. For example, tools like Localyzer can connect with Bitbucket to automate the import and export of strings for localization, making it easier for developers and localization managers to collaborate effectively.

C

Code Branching

Code branching allows developers to create separate lines of development within a codebase, enabling parallel work and experimentation without affecting the main branch code. In the context of software localization, code branching allows to manage translations and ensure that localization updates do not interfere with ongoing development.

Here’s how it works:

• A dedicated branch is created for localization-specific changes, such as updating translation files or adding new languages.
• While the main branch continues to evolve, the localization branch remains independent, allowing developers and localization managers to focus on their respective tasks without conflicts.
• Once the localization updates are complete and tested, the localization branch is merged into the main branch, ensuring that the latest translations are included in the final product.

This approach helps maintain a clean and organized codebase while efficiently delivering a multilingual product.

CJK

CJK refers to the three East Asian languages: Chinese, Japanese, and Korean. These languages have unique characteristics that can significantly influence localization and development efforts.

Key Influences on Software Development:

• Character Encoding: CJK languages require proper character encoding (like UTF-8) to display characters correctly. Developers must ensure their applications support this.
• Text Expansion: Translated text may vary in length compared to the original language, necessitating adjustments in UI design to prevent overflow or layout issues.
• Contextual Differences: CJK languages have unique contextual meanings. Collaboration with localization managers is essential to ensure translations are appropriate and culturally relevant.
• Input Methods: Specific input methods are needed for typing CJK languages. Developers should support these to enhance user experience.
• Fonts and Typography: Choosing the right fonts is crucial, as not all fonts support CJK characters. Developers must select legible and visually appealing fonts.

LEARN MORE: Software localization, CJK Languages & Input Method Editors (IME)

Continuous Localization 

Continuous localization is an ongoing process that integrates localization into the software development lifecycle, allowing for real-time translation and adaptation of content as it is created or updated. This approach contrasts with Waterfall which often involve waiting for the end of a development cycle or specific sprints to begin localization.

Here are the steps and the place of localization in Continuous Development:

1. Setup and System Integration

• Deploy Localization Automation Tools
• Connect content management systems

2. Automated Content Monitoring and Extraction*

• Automatically identify and extract translatable strings
  *Leverage Localyzer for automated content extraction and other advanced features.

3. Translation Workflow

• Dispatch content to human translators or machine translation systems
• Apply translation memory and glossaries

4. Real-time Translation Syncing*

• Automatically merge translated content

5. Ongoing Quality Assurance

• Conduct automated linguistic and functional validation

6. Continuous Deployment and Refinement

• Deploy localized versions continually

For developers, adopting continuous localization means being proactive about localization from the outset. By collaborating closely with localization managers and integrating localization practices into daily workflows, developers can create a seamless experience for users across different languages.

💡 Key Aspects of Continuous Localization: Real-Time Updates: As developers update the code, text is automatically sent for translation, keeping localized versions up-to-date. Automation: Automates text extraction, integrates with translation systems, and uses translation memory for consistency. Collaboration: Encourages teamwork between developers, translators, and managers to catch localization issues early. Faster Time to Market: Speeds up product launches in multiple languages, reaching global markets faster. Feedback Loop: Enables ongoing feedback from users in different regions for continuous improvements.

Concatenation

Concatenation is a programming technique that combines multiple strings or variables into a single string.  

For example: “Hello, ” + name + “!” or “You have ” + count + ” unread messages.”.

While useful for developers, concatenations can pose challenges for localization managers, and here is why: 

Order and structure: order and structure of the strings may need to be adjusted for different languages.

Context problems: lack proper context, making it difficult for translators to provide accurate translations.

Potential for errors: if the order or composition of the strings is not handled properly it can lead to unexpected results.

Recommendations for Developers:

1. Avoid Concatenations: Whenever possible, use placeholders or templates instead of concatenations to provide more context for translators.For example, use “Hello, {name}!” instead of “Hello, ” + name + “!”.
2. Provide Context: If concatenations are necessary, provide additional context or comments to help translators understand the purpose and usage of the concatenated string.
3. Test Localization: Always test the localized versions of your application to ensure that concatenated strings are properly handled and that the translated text looks and functions as expected.

Culturalization

Culturalization is the process of adapting content not just linguistically but also culturally to resonate with the target audience. It involves considering cultural norms, values, customs, and preferences to ensure that the product is relevant and appealing to users in different regions.

Video games are one of the primary areas where culturalization plays a crucial role. As immersive, interactive experiences, games offer a unique opportunity to connect with players from diverse cultural backgrounds.

Recommendations for Developers:

1. Collaborate with localization managers. Work closely with localization managers to understand cultural nuances and how they may affect the product. This collaboration can help identify potential cultural pitfalls early in the development process.
2. Be open to feedback. Once the product is localized and culturalized, be receptive to feedback from local users. Continuous improvement based on user input can enhance the product’s relevance and success in different markets.
3. Build flexibility into your design and development processes. This might include allowing for different layouts, content formats, or even language options

LEARN MORE: Culturalization as a part of localization

D

Dynamic Content

Content that is generated in real-time based on various factors such as user behavior, location, device, time of day, user interactions, or other variables.

Typical examples of dynamic content include:

• Personalized greetings which can be in a user’s language. 
• Different versions of a page, shown based on the user’s location or language preferences.
• Dynamic pricing based on user location and preferable currency.
• Special sales that are promoted during local holidays in one country but not in others.

Managing large volumes of dynamic content is challenging. But localizing it is even more complex. However, it’s achievable. Most challenges can be overcome with the help of AI and by consulting a culturalization or localization specialist. The most important aspect of localizing dynamic content is identifying the bottlenecks. We have listed the most common ones below.

💡 Challenges in Localizing Dynamic Content: 1. Content Variability: Dynamic content changes based on user interactions, requiring real-time translation, which is technically challenging. 2. Technical Constraints: Technologies like JavaScript and JSON complicate traditional translation methods, making integration with translation tools complex. 3. Cultural Adaptation: Beyond translation, content must be adapted to local cultural nuances to resonate with audiences. 4. Consistency and Quality Assurance: Maintaining consistency in dynamically generated content is crucial to avoid errors and ensure a positive user experience. 5. Tool Integration: Integrating with translation tools can be difficult, especially if the CMS lacks native support. Localizing dynamic content demands a strategic approach, combining advanced technology, cultural understanding, and efficient workflows to deliver high-quality, consistent content across different locales.

E 

Encoding

The method of converting text into a specific format for storage and transmission. Common encodings include UTF-8, which supports multiple languages and special characters. There are some others, like ASCII (American Standard Code for Information Interchange) and ISO-8859 (Latin-1), which don’t support such a wide range of special characters.

Imagine an eCommerce platform offering product descriptions in multiple languages, including German and Japanese. If it initially uses an encoding system like ISO-8859-1, the Japanese descriptions might appear as garbled text or question marks. This can result in a poor user experience and loss of important product information. You might have seen it below:

Externalization

The process of separating translatable content from the codebase, making it easier to manage translations without altering the underlying code.

Example: Imagine a software application having various text elements like buttons and error messages hard-coded into its source code. Managing and translating this hard-coded text becomes difficult as the application supports more languages. You would end up with multiple versions of the code for every language and a maintenance nightmare. It would also be easy for a translator to accidentally break the code.

Externalization Solution: The development team moves all text into resource bundles, for example,`.properties` files for each language.

Result: Translators can translate text in `messages_fr.properties` directly, without changing the code.

Embedded String

An embedded string (an interpolated string or a hard-coded string) is a string directly coded into the source code.

For example:

Follow these tips to prevent problems with embedded strings:

• Avoid embedding text directly in code; export strings to a resource file with unique identifiers.
• Use the resource file to load UI elements dynamically based on the user’s language.
• Store UI strings as key-value pairs in resource files, creating a separate file for each locale to ensure the correct one is loaded.

LEARN MORE: The challenges of embedded strings to effective internationalization (i18n)

F

File Format

The specific structure and syntax used to store localized strings and their translations. These formats determine how translation data is saved and accessed by localization tools. Here are some common localization file formats: JSON (.json), PO (.po), XLIFF (.xliff, .xlf), RESX (.resx), Strings (.strings).

G

Globalization (g11n)

Globalization is a broad concept that includes both localization and internationalization. It focuses on creating software that can be used and sold worldwide. Internationalization adapts the code, localization adapts the experience, and globalization adapts the framework.

Sometimes, the term globalization is shortened to a numeronym g11n, where “11” represents the number of characters in the word.

Glossary

A list of key terms and their definitions specific to a project or industry. It serves as a reference tool for translators to ensure consistent and accurate use of terminology across all localized content.

For example, you have “User Interface” in your software. In your glossary, you’ll have:

• English: User Interface
• Spanish: Interfaz de Usuario
• French: Interface Utilisateur

Git Connector

A Git Connector is a tool or integration that connects a localization platform or translation management system (TMS) with a Git repository. It provides the following functions:

• Automatically pulls translatable content.
• Ensures that translations are always in sync with the latest version of the software.
• Manages multiple branches (e.g., feature branches, release branches) within the Git repository.
• After translation, the Git Connector can automatically merge the localized content back into the appropriate branch, ensuring it is included in the correct version of the software.
• Integrates with continuous integration/continuous deployment (CI/CD) pipelines.
• Tracks changes in the source and translated content, maintaining a history of updates.
• Reduces the risk of human errors, such as missing files, incorrect versions, or mismatched content.

💡Many of them have limited extraction, synchronization, branching, and other capabilities. Additionally, there’s no file checking, so if there’s an issue, someone down the line needs to fix it. Many problems won’t surface until much later, making it more difficult to pinpoint where the issue occurred. Git Connectors may not support various file formats, locale naming conventions, or APIs. This is where specialized tools like Localyzer come into play. Localyzer is more than just a Git Connector; it offers numerous additional functions, such as inspecting the software’s source code and detecting over 40 potential issues (e.g., missing curly brackets, duplicate string IDs), thereby simplifying the work of all the teams involved.

GitHub

GitHub is an online platform that helps people work together on coding projects. It allows developers to store their code in one place, track changes over time, and collaborate seamlessly with others. 

1. GitHub uses a system called Git. It allows developers and other counterparts to keep track of changes made to files. For localization managers, this means you can easily monitor updates to source text and ensure translations stay in sync with the latest versions.
2. GitHub’s platform is heavily used for open-source projects, meaning many projects are public.
3. GitHub offers CI/CD through GitHub Actions. It allows for automation of tasks like testing and deploying code, including localization processes. However, these features are add-ons rather than the deeply integrated, built-in solutions that GitLab offers.
4. GitHub can connect with various translation management systems (TMSs) and other tools you might use.
5. GitHub allows you to create and manage “issues” or tasks related to localization. You can assign tasks, set priorities, and track progress.

GitHub is a strong choice for teams that prioritize collaboration and access to a wide range of tools.

LEARN MORE: Crucial aspects of GitHub

• Bitbucket
• Git
• GitLab

GitLab

GitLab is a web-based platform that helps teams manage and develop software projects. It allows developers to store and share their code, collaborate on changes, and automate parts of the software development process.

1. GitLab uses Git to track changes in files. It allows managing different versions of translated content.
2. The platform allows for seamless collaboration with developers and translators. You can review, discuss, and approve translation updates directly within GitLab before they’re integrated into the project.
3. GitLab provides tools for managing localization tasks. You can create tasks (called “issues”), assign them to team members, set deadlines, and monitor progress—all from within the platform.
4. Localization process can be automated in GitLab. For instance, when new translation files are added, GitLab can automatically run checks for errors and deploy updates if everything passes.
5. GitLab integrates well with translation management systems (TMS). This helps to sync your translation work between GitLab and your other tools.

💡Difference between GitLab and GitHub: GitLab is an all-in-one solution with built-in tools for the entire development process, including CI/CD. It also offers a popular self-hosting option for greater control over data. GitHub, on the other hand, is more focused on code hosting and collaboration, with a larger community and more third-party integrations.

LEARN MORE: GitLab and i18n: Streamlining the Development Process

H

Hard-Coded Strings

Strings that are directly embedded in the source code.

💡 Hard-coded strings should be avoided in favor of externalized resource files, as they make localization impossible.

Hard-coded strings usually look like this:

Instead of them, it’s better to use something like this:

Here, localizationManager.getString(“welcome_message”) retrieves the string “Welcome to our app!” or its equivalent in another language based on the current locale. This approach makes it easier to collect and manage translatable strings, allowing localization specialists to work with them more efficiently.

LEARN MORE: What should we consider in Hard-Coding?

I

Internationalization (i18n)

Internationalization, often shortened to i18n, is the process of designing software so that it can be easily localized for different languages and regions without requiring significant changes to the code. It’s about making your software ready for translation and localization from the start.

Internationalization Best Practices for Developers:

1. Text Separation. Keep all user-facing text out of the code and in external files. This allows localization managers to translate content without altering the code.

2. Date, Time, and Number Formats. Make sure the software can handle different formats for dates, times, numbers, and currencies, which vary from one region to another.

3. Right-to-Left (RTL) Support. If using the software in languages like Arabic or Hebrew, ensure it supports right-to-left text.

4. Character Encoding. Use Unicode (like UTF-8) to ensure that characters from all languages are displayed correctly.

5. Layout Flexibility. Design interfaces that can accommodate text expansion (some languages take up more space than others) and different word orders.

Learn more: What is i18n?

In-context Editing

A feature that allows translators to see how their translations will appear in the actual software interface. Instead of working with strings in isolation, localization specialists can make changes while viewing the actual layout, design, and context of the text in the application or website.

Imagine a localization manager or UI designer using a Figma plugin that displays the app’s design within the Figma interface. They navigate through the app’s screens directly in Figma, editing labels like “Transfer Money” or “Account Balance” in place. As they adjust the translation, they can immediately see if the text fits within the buttons or causes any overflow issues. They might shorten “Transfer Money” to “Transfer” or “Send Funds” in their language.

Tools like the Figma plugin by Lingoport allow translators to see and edit text within the design files, ensuring translations fit the design before development.

Context can also be gathered with Localyzer and associated with each string. This also reduces the frequency of translation errors.

Icu Formatting

ICU (International Components for Unicode) formatting is a system for handling complex text formatting in different languages. It’s particularly useful for localization because it helps manage things like pluralization, gender, and date/time formatting in a way that works correctly across multiple languages. ICU formatting allows developers to write the rules for formatting them once, and then the software automatically applies the correct format based on the language.

To better understand ICU formatting, imagine you have a notification that says, “You have 1 new message” or “You have 2 new messages” depending on the quantity. In English, this is easy, but in other languages, the word for “item” might change more depending on the number. With ICU formatting, you can set up a rule like this:

This rule automatically adjusts the text based on the number (count) and the language’s pluralization rules.

LEARN MORE: Mastering ICU Message Formats: Best Practices and pitfalls to Avoid

J

JSON Localization Files

JSON files used to store key-value pairs for localized strings, commonly used in web applications. In software localization, each key represents a specific piece of text (like a button label or error message), and the value is the translation of that text in a particular language.

These files make it easy to manage translations because all the text is organized in one place. Each language has its own JSON file

K

Key

A unique identifier for a specific string of text in the software. Keys are used in localization files to map translations to their corresponding text in the application. For example,

Button Text:

• Key: button.submit
• English Value: “Submit”
• French Value: “Soumettre”

L

Localization (l10n)

The process of adapting software for a specific region or language by translating text, adjusting cultural references, and modifying graphics and layouts. This goes beyond just translating; it involves adjusting the content and user interface to meet cultural, linguistic, and technical requirements of a specific locale.

Locale

A locale is a set of parameters that defines the user’s language, country, and regional preferences. It tells the software how to format dates, times, numbers, and currencies, and which language to display. For example, the locale en_US stands for English (United States), while fr_FR stands for French (France). By using locales, your software can adapt its content and formatting to match the user’s cultural and regional norms.

LEARN MORE: Locale settings in the software

Localization Kit

A Localization Kit, often called a “Loc Kit,” is a collection of all the resources, files, and guidelines needed to localize a software project. It typically includes:

• Original text files
• Glossaries
• Style guides
• Instructions
• Specific cultural considerations

The Localization Kit helps translators and localization teams understand the project requirements and ensures that the final product is consistent, accurate, and culturally appropriate for each target market.

M

Machine Translation (MT)

The process of automatically translating text from one language to another using software or algorithms. It’s a quick way to get translations, but the quality can vary depending on the complexity of the text and the language pair.

Popular MT tools include Google Translate, Microsoft Translator, Amazon Translate, DeepL, IBM Watson Language Translator, SYSTRAN, SDL Language Cloud (RWS), and Bing Translator.

💡 Raw Machine Translation vs. Post-Edited Machine Translation Raw Machine Translation is the direct output from the machine without any human intervention. While fast, it often lacks accuracy, cultural nuance, and context. Post-Edited Machine Translation (PEMT) involves human translators reviewing and refining the machine’s output to correct errors and improve the quality. This step is crucial to ensure that the translation is accurate, natural-sounding, and culturally appropriate.

Human oversight in PEMT is essential to achieve high-quality translations that machines alone cannot provide.

N

Non-Functional Testing

Non-Functional Testing is a type of software testing that focuses on how well the system operates rather than what it does. It evaluates aspects like performance, usability, reliability, and security to ensure the software meets quality standards and provides a good user experience. 

For example,

• Usability Testing: Ensuring the software is easy to use and navigate, with an intuitive interface for users.
• Load Testing: Testing how the application performs under heavy user loads, like during peak usage times.
• Localization Testing: Checking if the software correctly adapts to different languages, regions, and cultural norms.

O

Open-Source Localization

Open-Source Localization is the process of translating and adapting open-source software for different languages and cultures. Since the source code is freely available, volunteers and communities worldwide can help make the software accessible to more people by providing translations, cultural adjustments, and region-specific content.

Wikipedia, Mozilla Firefox, and WordPress are excellent examples of open-source localization. These platforms rely on a global community of volunteers to translate their content into multiple languages.

P

Pseudo-Localization

A testing method used in software localization to simulate how the application will look and behave when translated into different languages. Instead of actual translations, the source strings are altered in specific ways to mimic the characteristics of various languages.

How It Works:

For example, a source string like “Order placed successfully!” might be pseudo-localized to:

“[Öŕðéŕ þļåçéð šûççéššƒûļļý!————- П國カ내]”

Rules of Pseudo-Localization:

1. Start and End Characters: Pseudo-localization software adds brackets or other symbols at the beginning and end of the string, like [ ], to clearly mark where the string starts and ends. This approach helps detect issues with string concatenation in the code.
2. Character Expansion: The string is expanded by adding extra characters or symbols. This simulates how translations might increase the length of the text. It helps check if the UI can accommodate longer strings.
3. Character Substitution: Replace some characters in the string with accented characters or those from other writing systems (like Cyrillic or Asian scripts). This technique tests how the software handles different character sets and ensures that you catch encoding and font issues early.

LEARN MORE: How Pseudo-Localization relates to the i18n process?

Pull Request

A pull request is a way for developers to propose changes to a codebase in version control systems, such as Git. When a developer makes changes in a separate branch of the project, they create a pull request. It asks others to review and merge their changes into the main codebase. Pull requests allow team members to discuss, review, and improve code before it becomes part of the main project.

LEARN MORE: How Pull request benefits the development process?

Q

Quality Assurance (QA)

The process of ensuring that a product, like software or a localized version of it, meets the required quality standards before it’s released. 

In localization, QA involves:

• Checking translations for accuracy, cultural appropriateness, and consistency.
• Testing the software to ensure that all text displays correctly.
• Verifying that the user interface works well in all languages.
• Ensuring there are no bugs related to the localization.

R

Resource Files

Files that store all the translatable text and other content (like images or icons) used in your software or website.

💡Optimal Approach Resource files are useful to handle UI strings as they allow you to centralize and manage all translatable content in one place. They enable easy updates and modifications without altering the source code.

Resource file formats are used to store translatable content, like text, images, or other assets, in a structured way. They are designed to be easily readable and editable by both developers and localization tools. 

Common resource file formats include:

• .JSON: Stores text in key-value pairs for web and app localization.
• .XML: Organizes text and other resources in Android apps.
• .PO/MO: Manages translations using the Gettext system.
• .RESX: Used by .NET applications to store resources like strings, images, and other data.

S

String

A string is a piece of text, like a word, sentence, or paragraph, that is displayed to the user. Strings are the primary elements that require translation during software localization. 

A button labeled “Submit” or a message saying “Thank you for your purchase” are both strings. They are usually stored in resource files, making it easier to manage and translate them across multiple languages.

String Extraction

String extraction is the process of identifying and pulling out all the translatable text (strings) from the software’s code and placing it into resource files. 

This step is crucial in software localization because it allows translators to work on the text separately from the code. By extracting strings, you ensure that all user-facing text is collected, organized, and ready for translation.

Static Analysis

Static analysis is the process of examining the source code of software without actually running it. This technique helps identify potential errors, bugs, or vulnerabilities early in the development process. 

Static analysis can be useful for software localization in several ways:

• Ensuring proper structure of the code for localization
• Checking for hard-coded strings
• Verifying that the project has externalized all translatable content into resource files
• Catching issues that could complicate the localization process before they become bugs

LEARN MORE: How Static Analysis Helps in i18n?

T

Translation Memory (TM)

A database that stores previously translated text segments, like sentences or phrases, along with their corresponding translations. When new content needs translation, the TM suggests existing translations that match or are similar. This speeds up the translation process and reduces costs by reusing previously translated content.

Terminology Management

Terminology Management involves managing and standardizing the terms used in translations. It consistently translates important words, such as product names or technical terms, throughout a project. By maintaining a centralized glossary, translators can easily find and reference these terms, which leads to more accurate and cohesive software localization.

Translation Management System (TMS)

A Translation Management System (TMS) is a software platform that helps manage the entire translation process. A TMS performs the following functions:

• Centralizing all aspects of translation: organizing projects, tracking progress, integrating translation memories and terminology databases.
• Streamlining collaboration between translators, reviewers, and project managers.
• Ensuring efficient workflows, consistency in translations, and easier handling of large localization projects.

Some popular TMSs include: SDL Trados Studio, Phrase, MemoQ, XTM, Smartling, Crowdin, Smartcat.

U

Usability Testing

Testing the localized software with real users to ensure that the interface is intuitive and culturally appropriate for the target audience. It ensures that translated text fits well within the UI, that the layout makes sense, and that users from different regions can navigate the software smoothly. 

Unicode

Unicode is a universal character encoding standard that allows computers to consistently represent and display text in any language. It includes a vast range of characters, symbols, and scripts from around the world. It ensures correct display of all characters from Western, Asian, or other languages across different platforms and devices.

LEARN MORE: What is Unicode in i18n and l10n?

• UTF-16
• UTF-8

UTF-16

UTF-16 (Unicode Transformation Format 16-bit) is a type of Unicode encoding that represents characters using 16-bit units. It can handle a wide range of characters from different languages and scripts, making it suitable for global applications. It ensures that your software can accurately display text from languages with more complex character sets like Chinese, Japanese, and emojis.

LEARN MORE: How to use UTF-16 for Multilingual Support in i18n?

• UTF-8
• Encoding

UTF-8

UTF-8 (Unicode Transformation Format 8-bit) is a type of Unicode encoding that represents each character using 1 to 4 bytes. It’s the most common and widely used encoding on the web because it can efficiently handle all characters from any language while being compact for texts primarily in English. It ensures that your software can display text correctly in any language, from English to more complex scripts like Chinese or Arabic, across different platforms and devices.

LEARN MORE: How UTF-8 links to the i18n process?

• UTF-16
• Encoding

UI STRINGS

UI strings are the pieces of text that appear in the user interface of a software or application, such as button labels, menu items, error messages, and tooltips. These strings are what users see and interact with directly.

LEARN MORE: Localization of UI Strings

V

Version Control

Version control is a system that tracks and manages changes to files, such as source code or translation files, over time. It allows teams to work on different parts of a project simultaneously, keep a history of changes, and revert to previous versions if needed. 

Version control organizes translations, tracks changes, and manages multiple content versions across different languages.

W

Waterfall Model

The Waterfall Model is a linear and sequential approach to software development where each phase of the project—like design, implementation, and testing—must be completed before the next one begins. Each step flows into the next, like a waterfall.

In the Waterfall Model, localization typically happens towards the end, after the main development and testing phases are completed. This approach means that software localization is a distinct phase. This can lead to delays, limit flexibility and collaboration, as issues are found late in the process.

LEARN MORE: Waterfall model of approaching software development

X

XML (eXtensible Markup Language)

XML is a flexible text format used to store and organize data in a structured way. It’s often used to store translatable content, such as UI strings, in a way that is both human-readable and machine-readable. This makes it easier to manage and export content for translation.

XLIFF

XLIFF is an initialism for XML Localization Interchange File Format – a standardized file format specifically designed for localization. 

It is used to exchange translatable content, such as text strings, formatting, metadata, and context information, between different systems. It keeps the original structure and context intact. XLIFF allows you to easily import, export, and track translatable text across various software and platforms.

LEARN MORE: What is XLIFF in Localization?

Z

Zero-Day Localization

Zero-Day Localization refers to the process of releasing a product in multiple languages simultaneously on the same day it launches in its original language. This approach to software localization requires translating and localizing content in parallel with development, so that all versions are ready at the same time.

Zero-Width Space

A Zero-Width Space is an invisible character used in text that doesn’t create any visible gap but acts as a breakpoint for word wrapping or line breaks. In localization, it can be useful for controlling how text flows in different languages. It helps in ensuring that the text displays correctly without unwanted line breaks.

Zero-width space is unicode character U+200B and can be represented by numeric character references ​ or ​

Conclusion

Understanding these key terms in software localization and internationalization is essential for anyone involved in the process. Whether you are a project manager, translator, or developer, familiarity with this terminology will enhance your communication and collaboration efforts, ultimately leading to more successful localization projects. By mastering the A to Z of software localization, you can better navigate the complexities of reaching global audiences.

And if you want to adapt software for international markets, consider Lingoport. Lingoport offers products and services to scan and process billions of lines of code, streamlining and simplifying localization.