Localising an iOS app for Australia and beyond
An iOS app can look complete in development while quietly assuming one language, one currency, and one cultural setting. If its labels are hard-coded, a user in Brisbane may see text that clashes with local expectations, while a speaker of another language may encounter strings that cannot fit. Localisation turns those assumptions into deliberate, testable behaviour.
Localisation is broader than translating buttons. It also covers dates, numbers, currencies, names, images, permission prompts, reading direction, and the conventions that make an app feel native. Internationalisation is the preparation that lets content vary: separating language from logic and asking the system to supply the correct regional format.
Xcode’s String Catalog workflow gives Swift developers a practical centre for this work. You define stable keys, attach translations, let Foundation format dynamic values, and test the resulting experience under real locales. A maintainable approach matters because every new screen can introduce another hard-coded string or locale assumption.
Prepare the app for localisation
Start with an audit of every user-facing string. Search for literals assigned to text properties, navigation titles, alerts, empty states, and accessibility labels, and check Info.plist values such as camera and notification permission messages. Replace each with a stable semantic key such as profile.empty_title; descriptive names help translators understand the context without exposing variable names or implementation details.
Decide which language and regional combinations the product actually supports. For an Australia-specific build, en-AU is the appropriate baseline, including spelling such as colour, organise, and favourite. English spoken in London or Auckland can use a different regional identity. Language and region are separate choices, so do not duplicate every English resource merely to change punctuation or number presentation.
Build translation into source control rather than editing a built app. Give translators the key, source copy, screenshots, and notes about tone or placeholders, then record their decisions as reviewed changes. For a project that also passes through other IDEs, importing Eclipse projects with NetBeans is a separate migration task and should not be mixed with Xcode’s localisation configuration.
Create and manage a String Catalog
A String Catalog keeps translatable text, comments, and placeholders in one Xcode-managed resource. Create it in the project, add the target languages, and translate the source entries without renaming the underlying keys. This is cleaner than scattering loose .strings files through the project and gives reviewers one focused place to check language coverage.
Read localised values through Swift rather than selecting them by hand. String(localized:) works well for an explicit key, NSLocalizedString remains common in UIKit code, and LocalizedStringKey lets SwiftUI infer localisation from a string literal. All three connect the lookup to the appropriate resource, making missing translations easier to detect during testing.
Treat placeholders as part of the translation contract. A message such as “(count) new items” needs the count to occupy the position chosen by each language, and some languages require several plural forms. A String Catalog can define those variations, so let the catalog select the grammatical form instead of appending “s” in Swift. Add translator comments wherever context, gender, abbreviation, or formatting could otherwise be guessed incorrectly.
Format dates, numbers, and prices
Never assemble dates, currencies, or measurements from format strings copied into the app. Use Date.FormatStyle, number formatting styles, or NumberFormatter with a locale, and set the time zone when a result represents a specific place. The formatter then adapts separators, symbol placement, calendar rules, and numeral conventions without requiring another translated resource.
Australian examples make the difference visible. Use en-AU for English conventions, render Australian dollars with the AUD currency code, and let the formatter choose between $ and A$ where needed. Consumer prices generally include GST, although receipts and accounting records may show it separately, so tax treatment should follow the product context rather than being embedded in every amount. Most Australian dates are read day first, followed by month and year; a fixed MM/dd/yyyy pattern would reverse that order.
The same rule applies beyond Australia. Arabic may require Arabic-Indic numerals, European languages may place currency symbols differently, and calendars can differ from the Gregorian system. Send raw dates, amounts, and measurements to the presentation layer, or format them with an agreed locale at the boundary. Localisation should change representation without changing the underlying value.
Support different scripts and screen sizes
Design for change before translating. German and Finnish often need more horizontal room, while Japanese and Chinese can use fewer characters for the same idea; neither assumption should determine the layout. Let labels wrap, use flexible constraints and stack views, and test at the largest Dynamic Type size you support. A screen that works only because an English sentence is short is not ready for another language.
For right-to-left languages such as Arabic and Hebrew, rely on leading and trailing anchors rather than fixed left and right constraints. Flip icons only when their meaning is directional, preserve the logical reading order, and test mixed strings containing numbers, URLs, and usernames. Automatic mirroring can solve geometry, but it cannot decide whether a custom illustration or gesture has the right cultural meaning.
Accessibility is part of localisation. Translate accessibility labels and grouped labels, keep them concise enough for VoiceOver, and verify that the VoiceOver language matches the displayed content. Localise permission explanations so they answer why the feature matters in the user’s language, not merely which system permission is being requested. Images with embedded words also need localised variants or graphics that do not rely on text.
Test every language and region
Test from the user’s perspective, not only by changing compiler settings. Xcode can launch a scheme with an app language and region override, allowing the same binary to be checked under each supported locale. Walk through onboarding, authentication, purchases, sharing, error recovery, and background states. Search for truncation, missing glyphs, unexpected line breaks, wrong plural forms, and formatting that appears twice.
Automate a small set of locale-sensitive tests so regressions surface before a release. Assert that a formatted price contains the expected currency identifier, that a date uses the selected calendar, and that a translated key returns different, non-empty copy. Pseudo-localisation can also expose fragile assumptions by expanding text and adding accented characters, although it cannot reproduce every grammar rule.
Australian market testing should include users or reviewers in Sydney, Melbourne, Brisbane, and Perth rather than treating the country as one homogeneous audience. Check whether the app’s tone matches local usage, and include relevant languages from multilingual communities. Work involving Aboriginal or Torres Strait Islander languages should involve community reviewers and approved language resources, never an unreviewed machine translation. In settings such as public events or education programs, an Acknowledgement of Country may be expected; include it only with local guidance and avoid presenting a generic acknowledgement as a substitute for genuine engagement.
Publish and maintain localised releases
Before submission, localise the App Store Connect listing as well as the binary. Translate the app name where permitted, subtitle, promotional text, release notes, and screenshot captions; review each market’s metadata for cultural accuracy. If the app depends on server content, schedule translations and content approvals before the corresponding App Store release rather than exposing mismatched screens and descriptions.
Choose a content strategy based on who owns the text and when it changes. The main trade-offs are visible across common approaches:
| Content approach | Best suited to | Main advantage | Main limitation |
|---|---|---|---|
Manual .strings files |
Small or legacy apps | Direct control over each resource | More files and manual coordination |
| Xcode String Catalog | Most UIKit and SwiftUI apps | Centralised keys, comments, plurals, and placeholders | Translations still require careful human review |
| Server-managed copy | Frequently changing content | Fast updates across published versions | Requires fallback handling, caching, synchronisation, and reliable offline behaviour |
Keep the catalog and its translations in version control, require review for copy changes, and record which markets receive each release. A translator should be able to understand the source context without opening the codebase, while a developer should be able to see which keys affect a feature. When a language falls behind, keep the fallback copy deliberate and improve it in planned updates rather than shipping obvious placeholders.
The principle to remember is simple: keep language out of business logic, use locale-aware formatting for every value that changes, and judge the result as a complete user experience rather than a set of translated strings. A well-localised app adapts its words, formats, layout, and accessibility behaviour while preserving one coherent product.