Hubbry Logo
logo
Locale (computer software) avatar
Locale (computer software)
Community hub

Locale (computer software)

logo
0 subscribers
Read side by side
Locale (computer software)
View on Wikipedia
from Wikipedia

In computing, a locale is a set of parameters that defines the user's language, region and any special variant preferences that the user wants to see in their user interface. Usually a locale identifier consists of at least a language code and a country/region code. Locale is an important aspect of i18n.

General locale settings

[edit]

These settings usually include the following display (output) format settings:

  • Number format setting (LC_NUMERIC, C/C++)
  • Character classification, case conversion settings (LC_CTYPE, C/C++)
  • Date-time format setting (LC_TIME, C/C++)
  • String collation setting (LC_COLLATE, C/C++)
  • Currency format setting (LC_MONETARY, C/C++)
  • Paper size setting (LC_PAPER, ISO 30112)
  • Color temperature setting
  • UI font setting (especially for CJKV language)
  • Location setting (country or region)
  • ANSI character set setting (for Microsoft Windows)

The locale settings are about formatting output given a locale. So, the time zone information and daylight saving time are not usually part of the locale settings. Less usual is the input format setting, which is mostly defined on a per application basis.

Programming and markup language support

[edit]

In these environments,

and other (nowadays) Unicode-based environments, they are defined in a format similar to BCP 47. They are usually defined with just ISO 639 (language) and ISO 3166-1 alpha-2 (2-letter country) codes.

International standards

[edit]

In standard C and C++, locale is defined in "categories" of LC_COLLATE (text collation), LC_CTYPE (character class), LC_MONETARY (currency format), LC_NUMERIC (number format), and LC_TIME (time format). The special LC_ALL category can be used to set all locale settings.[1]

There is no standard locale names associated with C and C++ standards besides a "minimal locale" name "C", although the POSIX format is a commonly used baseline.

POSIX platforms

[edit]

On POSIX platforms such as Unix, Linux and others, locale identifiers are defined in a way similar to the BCP 47 definition of language tags, but the locale variant modifier is defined differently, and the character set is optionally included as a part of the identifier. The POSIX or "XPG" format is [language[_territory][.codeset][@modifier]]. (For example, Australian English using the UTF-8 encoding is en_AU.UTF-8.)[2] Separately, ISO/IEC 15897 describes a different form, language_territory+audience+application,sponsor_version, though it's highly dubious whether it is used at all.[3]

In the next example there is an output of command locale for Czech language (cs), Czech Republic (CZ) with explicit UTF-8 encoding: 

$ locale
LANG=cs_CZ.UTF-8
LC_CTYPE="cs_CZ.UTF-8"
LC_NUMERIC="cs_CZ.UTF-8"
LC_TIME="cs_CZ.UTF-8"
LC_COLLATE="cs_CZ.UTF-8"
LC_MONETARY="cs_CZ.UTF-8"
LC_MESSAGES="cs_CZ.UTF-8"
LC_PAPER="cs_CZ.UTF-8"
LC_NAME="cs_CZ.UTF-8"
LC_ADDRESS="cs_CZ.UTF-8"
LC_TELEPHONE="cs_CZ.UTF-8"
LC_MEASUREMENT="cs_CZ.UTF-8"
LC_IDENTIFICATION="cs_CZ.UTF-8"
LC_ALL=

Specifics for Microsoft platforms

[edit]

Windows uses specific language and territory strings. The locale identifier (LCID) for unmanaged code on Microsoft Windows is a number such as 1033 for English (United States), or 2057 for English (United Kingdom), or 1041 for Japanese (Japan). These numbers consist of a language code (lower 10 bits) and a culture code (upper bits), and are therefore often written in hexadecimal notation, such as 0x0409, 0x0809 or 0x0411. Microsoft is starting to introduce managed code application programming interfaces (APIs) for .NET that use this format. One of the first to be generally released is a function to mitigate issues with internationalized domain names,[4] but more are in Windows Vista Beta 1.

Starting with Windows Vista, new functions[5] that use BCP 47 locale names have been introduced to replace nearly all LCID-based APIs.

A POSIX-like locale name format of language[_country-region[.code-page]] is available in the UCRT (Universal C Run Time) of Windows 10 and 11.[6]

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Locale (computer software)

View on Grokipedia
from Grokipedia
In computer software, a locale is a set of parameters that defines the language, regional, and cultural conventions for user interfaces and data processing, including formats for dates and times, numeric and monetary values, character classification, and collation orders.[1][2] These settings enable software to adapt to diverse user environments, supporting internationalization by separating cultural-specific behaviors from core program logic.[3] Locales are essential for ensuring usability across global audiences, handling variations such as right-to-left scripts, decimal separators, and currency symbols.[4] The concept of locales was formalized in the POSIX.1 standard (IEEE Std 1003.1-1988), which standardized interfaces for Unix-like operating systems to promote portability and support for multiple languages and regions.[5] This standard introduced environment variables like LC_ALL and category-specific ones (e.g., LC_TIME for date formatting) to control locale behavior, with the "C" or POSIX locale serving as the default minimal configuration.[1] Subsequent evolutions, such as the Unicode Common Locale Data Repository (CLDR), have expanded locale support by providing comprehensive, crowdsourced data for over 300 locales, including patterns for calendars, measurement units, and transliterations.[6] Modern standards like BCP 47 from the IETF further refine locale identifiers, using formats such as "en-US" for English (United States) to combine language codes (ISO 639) with region codes (ISO 3166).[7] In practice, locales are implemented across platforms through libraries like the International Components for Unicode (ICU) or system APIs, allowing applications to query and apply settings dynamically.[4] For instance, POSIX defines six core categories—LC_CTYPE for character handling, LC_COLLATE for sorting, LC_MONETARY for currency, LC_NUMERIC for numbers, LC_TIME for temporal data, and LC_MESSAGES for localized text—to modularize cultural adaptations.[1] Operating systems such as Windows and Linux expose these via APIs (e.g., GetLocaleInfo in Windows), while web technologies like JavaScript's Intl object leverage CLDR data for browser-based localization.[2][8] This framework underpins software globalization, reducing errors in cross-cultural deployments and complying with accessibility requirements.

Definition and Fundamentals

Definition of Locale

In computer software, a locale is a collection of data that specifies cultural, linguistic, and regional conventions affecting program behavior, including user interface language, date and time formats, numeric and monetary representations, and sorting orders.[3] This set of parameters ensures that software outputs and interactions align with user expectations based on their geographic and cultural context, such as displaying dates in month-day-year order or using appropriate currency symbols.[9] Locales play a central role in internationalization (i18n), the process of engineering software to handle multiple languages, regions, and cultural norms seamlessly without altering the underlying code.[10] By referencing locale data at runtime, applications can dynamically adapt interfaces and data presentation to user preferences, distinguishing i18n from localization (l10n), which focuses on translating strings and customizing content for particular markets.[10] This separation allows developers to build portable applications that support global deployment efficiently. A practical illustration of locale influence appears in numeric formatting: the value 1234.56 renders as "1,234.56" in the en_US locale, employing a comma for thousands grouping and a period for the decimal point, while in de_DE, it formats as "1.234,56", reversing the separators to match German conventions.[11] Such variations extend to other elements like collation rules for text sorting, where alphabetic order may prioritize accented characters differently across locales. Fundamentally, a locale is denoted as a named identifier combining an ISO 639 language code (e.g., "en" for English), an ISO 3166 territory code (e.g., "US" for the United States), and optional modifiers like a codeset (e.g., "UTF-8" for Unicode encoding), yielding conventions such as "en_US.UTF-8".[12] This structured naming enables precise selection of locale data from system libraries or databases during program execution.

Historical Development

The concept of locales in computer software emerged in the 1970s alongside the development and international spread of Unix systems, where the limitations of the ASCII character set became evident for supporting multi-language terminals and non-English users. As Unix was ported to various institutions worldwide, including its introduction in Japan in 1976, early efforts focused on adapting terminal handling to accommodate diverse character encodings and input methods beyond English ASCII, laying the groundwork for cultural and linguistic adaptability in operating systems.[13][14] Initial formalized support appeared in BSD Unix around 1980, with the introduction of the termcap database in 1978 by Bill Joy, which enabled programs to query and adapt to the capabilities of different terminals, including those supporting extended character sets for international use. In the 1980s, key milestones advanced this further, particularly with the introduction of LC_ environment variable categories (such as LC_CTYPE, LC_COLLATE, and LC_MESSAGES) in Unix System V Release 4 (SVR4) in 1988, which provided a structured framework for categorizing locale-specific behaviors like character classification and message formatting; this was influenced by emerging standards like X/Open Portability Guide Issue 3 (XPG3) and POSIX.1-1988, allowing dynamic configuration of language and regional settings without recompiling software.[15][16] The 1990s saw accelerated evolution driven by the growth of the internet, which highlighted the need for globalization in software to handle increasing international collaboration and data exchange. SVR4's Multi-National Language Supplement (MNLS) enhanced internationalization by supporting multi-byte character sets for languages like Japanese and Chinese, marking a shift from hardcoded cultural assumptions in pre-1980s software to dynamic locale loading via environment variables and databases. The adoption of Unicode in the late 1990s further broadened character support, with UTF-8 integration in Unix-like systems enabling seamless handling of diverse scripts; this was propelled by the post-2000 surge in non-English internet users, as English-speaking users dropped from over 80% in 1996 to about 27% by 2010, necessitating robust locale mechanisms for global scalability.[16][17][18]

Core Components

Language and Territorial Settings

In computer software, locales identify the primary language using codes from the ISO 639 standard, which provides two- or three-letter abbreviations for languages such as "en" for English and "fr" for French.[19] These codes form the foundational element of a locale, enabling software to select appropriate linguistic resources like translations and terminology. Variants of the same language are distinguished by combining the primary code with additional subtags, ensuring precision in multilingual environments. Territorial specifications in locales employ ISO 3166 codes, which are two-letter abbreviations for countries or regions, such as "US" for the United States and "CA" for Canada.[20] These regional codes influence user preferences related to geographic contexts, including legal conventions, without altering the core language selection. By incorporating territorial details, locales adapt software behavior to location-specific norms while maintaining consistency across international deployments. The standard naming convention for locales, particularly in POSIX-compliant systems, follows the format language_territory[.codeset][@modifier], where the language and territory are separated by an underscore, the codeset (character encoding) by a period, and any modifier by an at symbol.[21] For instance, "fr_FR.ISO8859-1@euro" denotes French ("fr") as used in France ("FR"), with ISO-8859-1 encoding and a euro-specific modifier. This structure allows flexible specification, with optional components omitted if not required, and integrates with character sets for text handling.[22] To address multilingualism and script variations, locales increasingly adopt BCP 47 language tags, which extend ISO 639 and ISO 3166 with subtags like scripts from ISO 15924, as in "zh-Hans-CN" for Simplified Chinese ("zh-Hans") in China ("CN").[23] These tags, using hyphens for separation, support complex scenarios such as distinguishing Traditional from Simplified scripts in Chinese or regional dialects, promoting interoperability across platforms like Windows and web standards.[7]

Formatting and Cultural Conventions

Locales define specific rules for formatting numbers, dates, times, and other data elements to align with cultural expectations, ensuring that software displays and processes information in a manner familiar to users in a given territory. These conventions are primarily governed by standards such as the POSIX locale categories and the Unicode Locale Data Markup Language (LDML) used in the Common Locale Data Repository (CLDR). For instance, the POSIX LC_NUMERIC category specifies non-monetary numeric formatting, including decimal points and grouping separators, while LC_MONETARY handles currency formats, and LC_TIME defines date and time patterns. Similarly, LDML provides extensible XML-based patterns for these elements, allowing for locale-specific variations like en-US versus fr-FR.[1][24] Numeric formatting conventions vary significantly across locales to reflect regional preferences for readability and punctuation. In the en-US locale, the decimal separator is a period (".") and the thousands grouping separator is a comma (","), resulting in formats like "1,234.56" for the number 1234.56, as defined in LDML's number symbols and patterns. In contrast, the fr-FR locale uses a comma (",") for decimals and a non-breaking space for grouping, yielding "1 234,56". Currency formatting follows similar locale-sensitive rules; for example, the USD in en-US appears as "$1,234.56" with the symbol preceding the amount, whereas the EUR in fr-FR is formatted as "1 234,56 €" with the symbol following. Percent and scientific notations also adapt: en-US renders 1.23 as "123%" or "1.23E3", while fr-FR uses "123 %" and "1,23E3". These patterns, part of LDML's element, ensure consistent application in software for parsing and display.[24][25][24] Date and time formats are equally locale-dependent, with patterns designed to match user expectations and reduce ambiguity. The POSIX LC_TIME category includes keywords like d_t_fmt for combined date-time strings, such as "%a %b %e %H:%M:%S %Y" yielding "Sun Jan 1 12:00:00 2023" in en_US. LDML extends this with skeleton-based patterns in and , supporting full, long, medium, and short styles across calendars. For en-US (Gregorian calendar), the medium date pattern is "MMM d, y" (e.g., "Jan 1, 2023"), while fr-FR uses "d MMM y" (e.g., "1 janv. 2023"), reflecting month-day-year versus day-month-year orders. Time formats follow suit: en-US often uses 12-hour with AM/PM (e.g., "1:00 PM"), whereas many European locales prefer 24-hour (e.g., "13:00"). LDML supports alternative calendars like Buddhist or Japanese, where eras and numbering adjust accordingly, such as using "BE" for Buddhist Era years.[26][27] Beyond core data types, locales incorporate broader cultural specifics to guide software behavior in everyday applications. Paper sizes are standardized via LDML's element, with "A4" as the global default (territories="001") under ISO 216, but "US-Letter" specified for regions like the US and Canada to match 8.5x11-inch formats. Measurement units draw from CLDR's , defaulting to "metric" worldwide (e.g., kilometers, Celsius) but "US" for imperial/customary units in the United States (e.g., miles, Fahrenheit), with "UK" for British imperial variants. Address formats, outlined in LDML's section, vary by territory; for example, en-US typically places the postal code after the city and state (e.g., "New York, NY 12345"), while fr-FR uses "75001 Paris" with the code first, adhering to postal standards like ISO 19160-4 for international consistency. These elements ensure software outputs align with local printing, measurement, and mailing norms.[28][29] These formatting conventions profoundly influence data processing in software, particularly parsing and validation, by requiring locale-aware mechanisms to interpret user input accurately and prevent errors. For instance, ambiguous date strings like "07/04" could parse as July 4 in en-US but April 7 in fr-FR, leading to incorrect data handling unless locale metadata is applied during serialization and deserialization, as recommended in W3C internationalization specifications. Numeric parsing must accommodate variant separators and even shaped digits (e.g., Eastern Arabic numerals in ar-SA), with validation checks ensuring conformity to the expected locale to maintain data integrity. Failure to implement such sensitivity can result in misinterpretation, such as treating "1.234" as one thousand two hundred thirty-four in de-DE (where "." is thousands separator) instead of one point two three four, underscoring the need for neutral formats in machine-to-machine exchanges while enabling cultural adaptation in user interfaces. Collation for sorting formatted data builds on these conventions but is addressed separately.[30][31][24]

Collation and Character Handling

Collation sequences in computer locales define the rules for ordering characters during sorting operations, tailored to linguistic conventions of specific languages and regions. These sequences determine how strings are compared and arranged, ensuring culturally appropriate results such as dictionary or phonebook orders. For instance, in English locales, sorting follows a standard alphabetical order based on the Latin script, where accented characters like é are typically placed after e. In contrast, Swedish locales tailor the sequence to treat å, ä, and ö as distinct letters positioned after z in dictionary order, as seen in standard CLDR tailorings where "zo" sorts before "åsa", which precedes "äpple" and "öl". This variation highlights how locales adapt the base collation to reflect native orthographic practices, preventing mismatches in applications like databases or text processors.[32] Character sets and encodings in locales specify the mapping of characters to byte sequences, enabling proper representation of diacritics, ligatures, and non-Latin scripts. Locales often associate with specific codesets, such as UTF-8 for universal compatibility or the ISO-8859 series for regional Latin-based scripts; for example, ISO-8859-1 (Latin-1) supports Western European languages with diacritics like ñ and ü, while ISO-8859-5 handles Cyrillic. In POSIX-compliant systems, the LC_CTYPE category governs character classification and encoding interpretation, allowing locales like en_US.UTF-8 to process multibyte Unicode characters seamlessly alongside single-byte legacy sets. This association ensures that software handles diverse scripts correctly, such as rendering Devanagari in Indian locales via UTF-8 without corruption. Handling diacritics involves normalization rules to treat composed forms (e.g., e + ¨ as ë) equivalently to precomposed ones, supporting scripts like Vietnamese with multiple tone marks.[33][34] Search and matching rules in locales extend collation principles to enable flexible string comparisons, often ignoring case, accents, or ligatures based on cultural norms. In German locales, for example, the sharp s (ß) is treated as equivalent to "ss" during matching, allowing "Straße" to match "Strasse" in case-insensitive or accent-insensitive searches, which is essential for user queries in databases or search engines. These rules are implemented through strength levels in collation algorithms, where primary strength compares base letters, secondary handles diacritics, and tertiary addresses case differences. This approach facilitates intuitive retrieval, such as finding "café" when searching for "cafe" in French locales, while preserving exact matches when needed. The POSIX LC_COLLATE category influences these behaviors, providing a framework for locale-specific string functions like strcoll().[35][33] Unicode integration in locales relies on the Unicode Collation Algorithm (UCA), which provides a default global ordering that locales tailor for consistency across scripts. UCA decomposes strings into collation elements—primary weights for base characters, secondary for diacritics, and tertiary for case—and allows tailoring via rulesets to adjust weights for specific needs, such as repositioning ö in Swedish after z. Common Locale Data Repository (CLDR) supplies these tailorings, ensuring implementations like ICU produce identical results for the same locale regardless of platform. This enables global applications to sort multilingual text correctly, for instance, intermixing Latin, Han, and Arabic characters in a single list while respecting each locale's conventions. Tailoring maintains UCA's stability and backward compatibility, with over 500 locales supported as of CLDR version 48 (2025).[36][37][6]

Standardization Efforts

POSIX Locale Framework

The POSIX locale framework provides a standardized model for handling internationalization in portable operating systems, dividing locale information into independent categories to allow fine-grained control over language, cultural conventions, and character processing. This framework, defined in the POSIX.1 standard, enables applications to adapt to different regional settings without hardcoding assumptions about user preferences. Each category addresses a specific aspect of localization, such as string sorting or numeric formatting, ensuring that software can operate consistently across diverse environments. The core locale categories are specified through environment variables prefixed with LC_, with LC_ALL serving as an override for all categories. LC_COLLATE governs string collation order, determining how characters are compared and sorted in operations like sorting lists or pattern matching. LC_CTYPE defines character classification and behavior, including properties like alphabetic, digit, or printable, which affect functions for case conversion and multibyte character handling. LC_TIME controls date and time formats, such as the structure of timestamps (e.g., "%Y-%m-%d" for year-month-day) and abbreviations for days and months. LC_NUMERIC specifies non-monetary numeric formatting, including decimal points and thousands separators (e.g., using a comma as the decimal separator in some locales). LC_MONETARY handles monetary values, defining currency symbols, placement (before or after the amount), and formatting rules like positive and negative signs. LC_MESSAGES manages language-specific message formatting, including yes/no responses and error message catalogs. Environment variables in POSIX systems control locale activation, with LANG providing a default for unspecified categories by setting a base locale name (e.g., "en_US.UTF-8" for American English with UTF-8 encoding).[38] If LC_ALL is set, it overrides LANG and all individual LC_* variables, enforcing a uniform locale across the application; unsetting LC_ALL allows individual LC_* settings to take precedence over LANG.[38] This hierarchical overriding mechanism, processed in Unix shells during process initialization, ensures predictable behavior when running programs in varied cultural contexts.[39] The POSIX locale database stores compiled locale data in binary format, typically under directories like /usr/lib/locale, derived from source definition files often located in /usr/share/i18n/locales. These source files, processed by the localedef utility, include sections for each LC_ category; for instance, charmaps define character encodings (e.g., mapping bytes to Unicode code points), while collation rules specify sorting sequences using directives like "collating-element" for multi-character units.[40] Numeric and monetary rules outline format strings, such as "%n %p" for currency placement, ensuring the database supports efficient runtime queries without parsing source text. POSIX.1 compliance requires support for the basic locale categories and environment variables to enable portable internationalization, with the "C" locale as the default for ASCII-based, invariant behavior. Extensions in XPG4 (X/Open Portability Guide issue 4) build on POSIX.1 by adding advanced internationalization features, such as support for the localedef command to compile locale archives and additional categories like LC_ADDRESS for postal formatting, facilitating broader global software deployment.[41] These XPG4 enhancements, part of the XSI (X/Open System Interfaces) option, promote consistency in handling complex scripts and cultural data beyond POSIX.1's minimal requirements.[33]

ISO and Unicode Standards

The International Organization for Standardization (ISO) and the Unicode Consortium have developed key standards that define and support locale handling in computer software, focusing on consistent cultural and linguistic adaptations beyond basic operating system frameworks. These standards emphasize collation, data repositories, language identification, and registration procedures to enable global interoperability in software applications.[42][6] ISO/IEC 14651 specifies a reference method for international string ordering and comparison, applicable to character strings from the ISO/IEC 10646 repertoire (aligned with Unicode). It defines collation procedures using a Common Template Table that orders all encoded characters, allowing for locale-specific tailoring through declared differences (deltas) to adapt sorting rules for particular languages or regions while maintaining a baseline international order. This tailorable approach ensures that software can implement culturally appropriate sorting, such as alphabetic variations in European languages or script-specific rules in Asian locales.[42] The Unicode Common Locale Data Repository (CLDR), maintained by the Unicode Consortium since 2005, serves as a centralized, XML-based repository of locale data essential for software internationalization. It provides comprehensive datasets for formatting conventions (e.g., dates, numbers, currencies), collation sequences, translations of locale identifiers, and cultural elements like plural rules and measurement units, covering over 200 locales with contributions from global stakeholders. CLDR data, specified in Unicode Technical Standard #35 (LDML), enables developers to integrate standardized locale support without proprietary implementations, and it integrates with POSIX frameworks by supplying compatible locale definitions.[6][43][44] BCP 47, formalized in RFC 5646, establishes a standardized format for language tags used to identify locales in software protocols, metadata, and content negotiation. These tags combine subtags for language (e.g., from ISO 639), script (ISO 15924), region (ISO 3166-1), and variants, producing identifiers like "fr-CA" for Canadian French, which supersede older, less flexible ISO-based formats such as those in RFC 3066 by offering extensibility and stability through an IANA-maintained registry. This enables precise locale specification in applications, supporting features like language-specific rendering and user preferences.[45] Despite these advancements, gaps persist in locale standards, particularly in coverage for diverse cultural nuances; ISO/IEC 15897 addresses this by outlining procedures for registering cultural specifications, including POSIX locales and charmaps, with extensions via ISO/IEC TR 14652 for repertoiremaps that enhance support for European languages through detailed character and cultural element mappings. The standard's registry mechanism also facilitates ongoing updates for emerging regions by incorporating narrative and machine-readable (e.g., XML) specifications, ensuring evolving cultural data can be formally integrated into global software ecosystems.[46]

Platform Implementations

Unix-like and POSIX Systems

In Unix-like and POSIX-compliant systems, locales are managed through a combination of environment variables, runtime functions, and system utilities that adhere to the POSIX locale framework, which defines categories such as LC_CTYPE for character classification and LC_COLLATE for string collation. These systems enable users and applications to query and modify locale settings dynamically, ensuring consistent handling of internationalization aspects like date formatting and text sorting across diverse environments. Command-line tools play a central role in locale management. The locale(1) utility displays the current locale environment or lists all available locales on the system, providing output in a categorized format that reveals settings for variables like LANG and LC_ALL.[47] For programmatic control, the C library function setlocale() allows runtime changes to the locale by category or globally, returning the previous locale name upon success and enabling applications to adapt to user preferences without restarting.[48] These tools are standardized across POSIX systems but may include vendor-specific options for querying detailed collation rules or character mappings. Implementations vary between distributions, particularly in how locales are compiled and stored for efficiency. In Linux systems using GNU libc (glibc), locales are often compiled into a single binary archive file called locale-archive located at /usr/lib/locale/locale-archive, which reduces memory usage and startup time by memory-mapping multiple locales on demand rather than loading separate files.[49] In contrast, BSD systems like FreeBSD store locales as individual binary files or directories in /usr/share/locale, without a centralized archive, which can lead to higher disk usage but simpler per-locale maintenance.[50] macOS, as a BSD-derived Unix-like system, follows a similar approach with locale data in /usr/share/locale but provides higher-level APIs through the Foundation framework, such as the NSLocale class, for accessing user-selected languages, regions, and formatting conventions. NSLocale integrates POSIX categories with system-wide settings from the Language & Region preferences, often using ICU for underlying data and supporting dynamic querying via methods like currentLocale or preferredLanguages.[51] These differences stem from glibc's extensions beyond POSIX for performance optimization in resource-constrained setups. Locale settings significantly impact file system operations, especially in handling filenames with international characters. In UTF-8 locales such as en_US.UTF-8, commands like sort(1) apply language-specific collation rules from LC_COLLATE, ordering filenames based on cultural conventions—for instance, treating accented characters like 'é' as variants of 'e' rather than distinct symbols, unlike the byte-order sorting in the default C locale. This ensures intuitive file listing and searching in tools like ls(1), but requires proper locale generation to avoid fallback to ASCII-only behavior. Common challenges arise in embedded systems or minimal installations, where full locale support is often omitted to conserve storage and memory. For example, in lightweight distributions like those built with Yocto Project for embedded Linux, only the POSIX ("C") locale may be included by default, leading to warnings or failures in applications expecting UTF-8 collation or character classification, necessitating manual addition of locale data during build configuration. Similarly, stripped-down server installs might lack generated locales, forcing users to run localedef or equivalent tools post-installation to enable internationalization features.

Microsoft Windows Specifics

In Microsoft Windows, locale support is primarily handled through the National Language Support (NLS) API, which provides functions for managing language, regional formats, and cultural conventions on a per-thread or system-wide basis.[52] Although the traditional NLS API uses locale identifiers (LCIDs), which are 32-bit values combining a primary language ID and sublanguage ID, modern applications should prefer locale names in BCP 47 format (e.g., "en-US") as recommended by Microsoft, with updated functions like GetLocaleInfoEx supporting both. LCIDs remain functional for legacy compatibility.[53] For example, the LCID 0x0409 represents English (United States).[53] Key NLS functions include GetLocaleInfo, which retrieves information about a specified locale, such as the short date format or decimal separator, based on an LCID (or locale name in extended versions) and a locale type constant like LOCALE_SSHORTDATE.[54] Another essential function is SetThreadLocale, which sets the current thread's locale to a given LCID, allowing applications to adapt to user preferences without affecting other processes.[55] These functions rely on predefined LCIDs rather than runtime-generated ones for consistency, though custom locales can be handled via names.[56] User-specific locale preferences are stored in the Windows registry under HKEY_CURRENT_USER\Control Panel\International, where values like sShortDate define formats for dates, times, and numbers tailored to the user's selection in the Region settings.[57] System-wide defaults, applicable to all users, reside in HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Nls, including language groups and code page mappings that influence non-Unicode applications.[58] The Multilingual User Interface (MUI) framework, introduced in Windows 2000, extends locale support by allowing dynamic switching of user interface languages without reinstalling the operating system.[59] MUI achieves this through resource DLLs in language-specific subdirectories, enabling applications to load UI strings in the user's preferred language at runtime via functions like LoadString.[60] Unlike the POSIX locale model, which supports dynamic loading of locale data from files via environment variables, Windows employs a fixed set of predefined LCIDs and code pages for stability and performance, supplemented by locale names for extensibility.[52] For instance, code page 1252 (CP1252) is designated for Western European languages, mapping characters to byte values in legacy ANSI applications.[61] Collation in Windows NLS uses SortKey objects generated by APIs like LCMapString to produce binary keys for locale-aware string comparisons.

Cross-Platform Libraries

Cross-platform libraries enable developers to implement consistent locale handling across diverse operating systems, abstracting away platform-specific variations in formatting, collation, and cultural conventions. These libraries are particularly valuable in multi-platform applications, where relying on native OS locale services could lead to inconsistencies in behavior or incomplete Unicode support. By leveraging standardized data sources like the Unicode Common Locale Data Repository (CLDR), they ensure portability and reliability.[62] The International Components for Unicode (ICU) library, developed by IBM and now maintained by the Unicode Consortium, is a foundational cross-platform solution for locale services. Released initially in 1999, ICU provides comprehensive APIs for internationalization tasks, including date/time formatting, number parsing, message translation, and collation based on CLDR data. Its collation service, compliant with the Unicode Collation Algorithm (UCA) since version 1.8, supports tailoring for locale-specific sorting rules and handles complex scripts like Arabic and Indic languages with full Unicode coverage. ICU is available in C/C++ and Java implementations, making it widely portable across Windows, Linux, macOS, and embedded systems.[62][63][64] For C and C++ developers, libraries like GNOME's GLib and Boost.Locale offer utility-level locale abstractions. GLib, a core component of the GNOME ecosystem, includes functions such as g_get_locale() and g_get_language_names() to query and manipulate locale identifiers, supporting UTF-8 string handling and internationalization via gettext integration for consistent behavior on Unix-like systems and beyond. Boost.Locale, introduced as part of the Boost C++ Libraries around 2011 and derived from the CppCMS web framework, extends the C++ standard library's locale facilities with features like boundary analysis for word/line breaks, culturally sensitive collation, and codecvt facets for encoding conversions, ensuring high-quality localization without platform dependencies.[65][66][67] In mobile and web assembly environments, frameworks such as React Native and Flutter provide locale abstractions to unify handling across iOS, Android, and web targets. React Native achieves cross-platform consistency through JavaScript-based i18n libraries like react-i18next, which interface with native device locales via bridges to support dynamic language switching and formatting without duplicating platform-specific code. Flutter's built-in internationalization system, powered by the intl package and flutter_localizations delegate, enables declarative locale resolution and supports over 70 languages out-of-the-box, abstracting device locale detection for seamless rendering of localized widgets on multiple platforms.[68][69] These libraries mitigate operating system differences by providing uniform implementations, such as ICU's complete UCA compliance, which surpasses native locale services in some platforms that offer only partial or legacy collation support, thereby reducing bugs in global applications and simplifying maintenance.[63][70]

Programming Support

Low-Level Language Integration

In the C standard library, locale support is primarily provided through the setlocale function, which allows programs to initialize or query the current locale settings. Calling setlocale(LC_ALL, "") initializes the locale to the system's default environment settings, enabling culturally appropriate behavior across various categories.[71] For instance, the LC_NUMERIC category influences numeric formatting in functions like printf, determining the decimal point character (e.g., a comma in some European locales) and digit grouping separators for floating-point output in formats such as %f or %g. This ensures that output adapts to regional conventions without hardcoding values. Error handling in setlocale is critical for robustness; the function returns a null pointer if the requested locale cannot be loaded, leaving the existing locale unchanged, which typically defaults to the "C" locale at program startup for portability.[71] The "C" locale provides a neutral, POSIX-compliant baseline using ASCII encoding and invariant formatting, serving as a reliable fallback to prevent application crashes from unsupported locales. C++ builds upon this foundation with the <locale> header, introducing the std::locale class as an immutable container for locale-specific behaviors via facets—pluggable components that encapsulate rules for tasks like formatting. For numeric handling, the std::numpunct facet customizes punctuation, such as thousands separators and decimal points, which can be accessed through std::locale::numpunct. Streams like std::cout integrate these via the imbue method, applying the locale to all I/O operations on the stream for consistent, locale-aware output. For GNU-specific extensions to C locale handling, such as enhanced internationalization features in the GNU C Library (glibc), programs may require linking against the libintl library using the -lintl flag during compilation to access functions like bindtextdomain that complement basic locale setup. This integration aligns with POSIX standards for setlocale, as detailed in the POSIX locale framework.[71]

High-Level Language Features

In high-level programming languages, locale support is typically provided through object-oriented classes and modules that abstract cultural and regional variations, enabling developers to create locale-sensitive applications with minimal low-level configuration. In Java, the java.util.Locale class serves as the core representation of a specific geographical, political, or cultural region, encapsulating language, country, and variant information to tailor operations such as formatting and collation.[72] This class includes static methods like getDefault() to retrieve the system's default locale and a Builder pattern for constructing custom locales programmatically, facilitating flexible internationalization (i18n) without direct reliance on underlying system calls.[72] Java integrates locale awareness deeply into its text processing APIs, particularly through the java.text package, where classes like DateFormat and NumberFormat use a Locale instance to produce region-appropriate outputs. For instance, DateFormat.getDateInstance(int style, Locale locale) generates date strings formatted according to the specified locale's conventions, such as day-month-year order in European locales versus month-day-year in U.S. ones. Similarly, in Python, the built-in locale module provides high-level access to POSIX locale data, allowing developers to set the active locale via locale.setlocale(locale.LC_ALL, '') and adapt string formatting functions like strftime() to respect cultural norms for dates, times, and numbers.[73] This module handles category-specific settings (e.g., LC_TIME for temporal formatting) and integrates with the C standard library's locale functions, ensuring consistent behavior across platforms.[73] For more advanced i18n needs, Python's third-party Babel library extends locale support by interfacing directly with the Unicode Common Locale Data Repository (CLDR), offering tools for locale-specific number formatting, date localization, and message translation. Babel's Locale class, for example, provides methods like localize() to apply CLDR-derived patterns, making it suitable for web and desktop applications requiring robust, standards-compliant localization. In Java, resource bundles enhance this capability by enabling locale-sensitive resource management; the ResourceBundle class, particularly its PropertyResourceBundle subclass, loads key-value pairs from properties files named according to locale conventions (e.g., messages_en_US.properties), allowing seamless substitution of strings, labels, and other assets based on the runtime locale.[74] Developers can retrieve values using getBundle(baseName, locale).getString(key), which automatically selects the best-matching bundle from a fallback hierarchy. Since Java 8, released in 2014, the java.time package has introduced modern, immutable classes for date and time handling that are inherently locale-aware, replacing the legacy java.util.Date and Calendar with more robust alternatives like LocalDate and ZonedDateTime. The DateTimeFormatter class within this package accepts a Locale parameter to format temporal objects according to regional patterns, such as abbreviating month names or adjusting numeral shapes for locales like Arabic.[75] This enhancement draws from the JSR-310 specification and incorporates CLDR data for accuracy, significantly improving thread-safety and precision in locale-dependent applications. Java's implementation of these features has been influenced by the International Components for Unicode (ICU) library, which provides foundational support for Unicode and CLDR integration.[76]

Markup and Data Formats

XML and HTML Locale Handling

In XML documents, the xml:lang attribute specifies the natural language and optionally the locale of the content within an element and its descendants, using language tags defined by BCP 47 (RFC 5646).[77] This attribute, part of the XML namespace, inherits to child elements unless overridden, enabling processors to apply locale-specific behaviors such as text rendering, validation against language-dependent schemas, and formatting during transformations.[78] For instance, xml:lang="fr-CA" indicates Canadian French, influencing how tools handle hyphenation or quotation marks in validation or rendering processes.[45] In HTML documents, the lang attribute serves a similar purpose to xml:lang, declaring the primary language and locale for an element's content, and it too follows BCP 47 language tags.[79] Applicable to any HTML element, lang inherits to descendants and guides browser rendering, such as font selection, speech synthesis, and directionality, while also aiding accessibility tools like screen readers.[79] Browsers detect preferred locales via the HTTP Accept-Language request header, which lists language ranges with quality values (e.g., Accept-Language: en-US;q=1.0, en;q=0.9), allowing servers to negotiate and serve appropriately localized content.[80] In XML-based HTML (XHTML), both lang and xml:lang may appear, but their values must match for consistency.[79] For locale-aware processing in transformations and schemas, XSLT 2.0 and XPath 2.0 integrate language information from xml:lang to support functions like format-number(), which formats numeric values according to locale-specific conventions such as decimal separators or grouping.[81] The function uses the dynamic context's language setting—derived from the nearest ancestral xml:lang—to apply appropriate decimal formats defined via xsl:decimal-format elements, ensuring output aligns with regional standards (e.g., using commas for thousands in English locales).[82] XML schemas can enforce xml:lang usage through declarations in XML Schema Definition (XSD), promoting validation that respects language-tagged content for internationalization.[83] Best practices for XML and HTML locale handling emphasize combining markup attributes with server-side content negotiation using the Accept-Language header to dynamically select document variants, while including a Content-Language response header to confirm the chosen locale.[84] This approach ensures fallback to a default language if no match exists and uses the Vary: Accept-Language header to inform caches of dependency on user preferences, enhancing global accessibility without relying solely on client-side detection.[80]

Other Document Standards

In data interchange formats like JSON, commonly used in RESTful APIs, locale specifications are often embedded directly in request or response payloads to enable server-side localization of content, formatting, and behavior. For instance, a client might include a field such as {"locale": "fr-FR"} in the JSON body of a POST request to indicate preferences for French language and French regional conventions, allowing the API to return localized dates, currencies, or messages accordingly. This approach contrasts with header-based methods like Accept-Language and provides explicit control for user-specific or session-based localization in services such as user authentication or data submission endpoints.[85] Database management systems incorporate locale support through standardized SQL mechanisms and collation configurations to handle internationalization in storage, querying, and retrieval. In PostgreSQL, locale settings are established during database initialization via parameters like LC_COLLATE for sorting order and LC_CTYPE for character classification, with runtime adjustments possible for categories such as LC_MONETARY and LC_TIME using SET lc_monetary = 'fr_FR.[UTF-8](/page/UTF-8)'; to influence functions like to_char for formatted output. These settings ensure consistent handling of locale-dependent operations, such as case-insensitive searches or numeric formatting, across queries. Similarly, MySQL employs collations tied to character sets for locale-aware comparisons; the utf8mb4_unicode_ci collation, for example, supports full Unicode (including emojis and supplementary characters) with case-insensitive sorting based on the Unicode Collation Algorithm (UCA), making it suitable for multilingual applications where precise, locale-neutral ordering is required.[86] Configuration files in plain-text formats like INI and YAML frequently define locale keys to configure application-wide or component-specific internationalization settings, simplifying deployment across diverse environments. In INI files, particularly for PHP applications, directives such as intl.default_locale = "en_US" in php.ini establish the baseline locale for internationalization extensions, affecting string collation, date formatting, and message translation without requiring code changes.[87] YAML configurations, prevalent in tools like Docker Compose or Ansible, use hierarchical keys like locale: fr-FR under sections such as app or i18n to specify regional preferences, enabling easy overrides for testing or production while maintaining readability through indentation-based structure. For .NET applications, the app.config file (an XML-based format) supports locale via custom entries in the <appSettings> section, such as <add key="DefaultLocale" value="de-DE" />, which applications read programmatically using ConfigurationManager.AppSettings["DefaultLocale"] to set CultureInfo for UI rendering and resource loading. Internationalized Domain Names (IDNs) extend locale support to web addressing through the IDNA protocol, permitting domain names in users' native scripts while maintaining DNS compatibility. As outlined in RFC 5891, IDNA maps Unicode-based labels (U-labels) to Punycode-encoded ASCII labels (A-labels, prefixed with "xn--") during registration and resolution, with local software performing character set conversion to Unicode based on the application's locale before processing. This facilitates locale-aware URLs, such as café.example.com rendered in French or مثال.شركة in Arabic, ensuring seamless access to resources in non-Latin locales without altering the underlying ASCII-restricted DNS infrastructure.[88]

References

  1. Locale - The Open Group Publications Catalog
  2. Locale - Globalization - Microsoft Learn
  3. What Is a Locale?
  4. Locales and Resources | ICU Documentation
  5. [PDF] IEEE standard portable operating system interface for computer ...
  6. Unicode CLDR Project
  7. Standard locale names - Globalization - Microsoft Learn
  8. Locale - Glossary - MDN Web Docs - Mozilla
  9. locale(7) - Linux manual page - man7.org
  10. Internationalization and Localization Defined
  11. Format numbers - Globalization - Microsoft Learn
  12. What Is a Locale? - International Language Environment Guide
  13. USENIX Timeline
  14. The UNIX System -- History and Timeline
  15. History of the Unix Terminal: How Video Killed the Printer Star
  16. [PDF] Developer's Guide to Internationalization - Oracle Help Center
  17. UTF-8 and Unicode FAQ for Unix/Linux
  18. English is no longer the language of the web - Yahoo
  19. ISO 639 — Language code
  20. ISO 3166 — Country Codes
  21. Locale Names (The GNU C Library)
  22. Locale naming conventions - IBM
  23. Understanding the New Language Tags - W3C
  24. Unicode Locale Data Markup Language (LDML) Part 3: Numbers
  25. https://pubs.opengroup.org/onlinepubs/007904875/basedefs/xbd_chap07.html#tag_07_03_04
  26. https://pubs.opengroup.org/onlinepubs/007904875/basedefs/xbd_chap07.html#tag_07_03_05
  27. Unicode Locale Data Markup Language (LDML) Part 4: Dates
  28. Unicode Locale Data Markup Language (LDML) Part 2: General
  29. ISO 19160-4:2017 - Addressing — Part 4: International postal ...
  30. https://www.w3.org/TR/international-specs/#loc_neutral_neutral
  31. https://www.w3.org/TR/international-specs/#loc_numbers_shape_parse
  32. Swedish - Unicode
  33. Locale
  34. https://www.unicode.org/reports/tr10/
  35. Linguistic Sorting and Matching - Database - Oracle Help Center
  36. UTS #10: Unicode Collation Algorithm
  37. Collation Guidelines - Unicode CLDR Project
  38. Environment Variables - The Open Group Publications Catalog
  39. Understanding locale environment variables - IBM
  40. charmap(5) - Linux manual page - man7.org
  41. The XPG4 Core Operating System Calls and Libraries Test Suite
  42. ISO/IEC 14651:2020 - Information technology — International string ...
  43. Common Locale Data Repository (CLDR) Project - Unicode
  44. https://www.unicode.org/reports/tr35/
  45. RFC 5646 - Tags for Identifying Languages - IETF Datatracker
  46. ISO/IEC 15897:2011 - Information technology — User interfaces
  47. locale(1) - Linux manual page - man7.org
  48. setlocale(3) - Linux manual page - man7.org
  49. Locales - glibc wiki
  50. Chapter 25. Localization - i18n/L10n Usage and Setup
  51. National Language Support - Win32 apps - Microsoft Learn
  52. Locale Identifiers - Win32 apps - Microsoft Learn
  53. GetLocaleInfoA function (winnls.h) - Win32 apps - Microsoft Learn
  54. SetThreadLocale function (winnls.h) - Win32 apps - Microsoft Learn
  55. National Language Support Functions - Win32 apps | Microsoft Learn
  56. Globalization issues in ASP and ASP.NET - Microsoft Support
  57. NLS Terminology - Win32 apps - Microsoft Learn
  58. Overview of MUI - Win32 apps | Microsoft Learn
  59. Multilingual User Interface - Win32 apps - Microsoft Learn
  60. Code Pages - Win32 apps
  61. ICU - International Components for Unicode
  62. Collation | ICU Documentation
  63. International Components for Unicode (ICU) - Win32 apps
  64. GLib.get_language_names
  65. GLib – 2.0: Internationalization
  66. Boost.Locale
  67. react-i18next documentation: Introduction
  68. Internationalizing Flutter apps
  69. Unicode Collation Algorithm-based collations - IBM
  70. setlocale - The Open Group Publications Catalog
  71. Locale (Java SE 24 & JDK 24) - Oracle Help Center
  72. locale — Internationalization services — Python 3.14.0 documentation
  73. PropertyResourceBundle (Java Platform SE 8 ) - Oracle Help Center
  74. DateTimeFormatter (Java SE 17 & JDK 17) - Oracle Help Center
  75. [PDF] Internationalization Guide - Oracle Help Center
  76. Language tags in HTML and XML - W3C
  77. Extensible Markup Language (XML) 1.0 (Fifth Edition) - W3C
  78. https://html.spec.whatwg.org/multipage/semantics.html#the-lang-and-xml:lang-attributes
  79. https://datatracker.ietf.org/doc/html/rfc9110#section-12.5.4
  80. https://www.w3.org/TR/xslt-20/#format-number
  81. https://www.w3.org/TR/xslt-20/#decimal-formatting
  82. Best Practices for XML Internationalization - W3C
  83. When to use language negotiation - W3C
  84. Localization for REST APIs [closed] - Stack Overflow
  85. Documentation: 18: 23.1. Locale Support - PostgreSQL
  86. Runtime Configuration - Manual - PHP
  87. YAML | Lokalise Help Center: Documentation and helpful resources
  88. RFC 5891 - Internationalized Domain Names in Applications (IDNA)
User Avatar
No comments yet.