How to Translate Text Localization Files

Translating plain text and properties files is quick and easy. Follow these steps to get accurate translations for your app while preserving the original structure and ensuring your app reaches a global audience.

1. Paste your text content: Copy and paste your localization strings into the text area above. Supported formats include key=value pairs, .strings files, .ini files, CSV/TSV, .properties files, and plain text.
2. Set the target language: Enter the language code you want to translate to (e.g., fr for French, de for German, ja for Japanese).
3. Click Translate: Our AI will process your content, preserving the original structure, keys, placeholders, and formatting.
4. Copy or save the result: Once translation is complete, copy the translated text to your clipboard or save it as a file.

What Are Text Localization Files?

Plain text and properties localization files are simple, human-readable files used to store translatable strings for software applications. Unlike structured formats like JSON or XML, these plain text files use straightforward key-value pairs, section headers, or line-based content to organize translations.

These files are widely used across mobile apps, desktop software, web applications, games, and embedded systems. Their simplicity makes them easy to edit, version-control, and integrate into automated build and deployment pipelines.

Common plain text and properties localization formats include .strings (iOS/macOS), .ini (Windows/PHP), .properties (Java), .cfg, .txt, and CSV/TSV files. Each format uses a slightly different syntax, but they all share the core principle of mapping keys to translatable text values.

Supported Text Localization File Formats

Our AI translation supports a wide variety of text-based localization formats commonly used in app development:

• .strings files (iOS/macOS): Apple's native localization format, using "key" = "value"; syntax. Used by Xcode for iOS, macOS, watchOS, and tvOS app localization.
• .ini files (Windows/PHP): Configuration and localization files organized into [sections] with key = value pairs. Widely used in Windows applications, PHP projects, and game engines like Unity and Unreal Engine.
• .properties files (Java): Java's standard localization format using key=value pairs. Used by Java SE, Spring Framework, Android (legacy), and enterprise Java applications.
• CSV/TSV files: Comma or tab-separated files with columns for keys and translations. Commonly used for bulk translation management, spreadsheet-based workflows, and data-driven localization.
• Plain text (.txt): Simple line-based text files with translatable content. Ideal for documentation, help files, release notes, and content that doesn't require key-value structure.
• Custom key-value formats: Application-specific formats using key=value, key: value, or similar delimiters. Our AI detects and preserves the format structure during translation.

.strings File Example

Here is a typical .strings-style localization file with key-value pairs and comments:

# App Name
app_name = My Application

# Login Screen
login_title = Sign In
login_username = Username
login_password = Password
login_button = Log In
login_forgot_password = Forgot your password?

# Dashboard
dashboard_welcome = Welcome back, {username}!
dashboard_notifications = You have {{count}} new notifications

.ini File Example

Here is a typical .ini localization file with sections and key-value pairs:

[General]
app_name = My Application
version = 1.0

[Messages]
greeting = Hello, World!
farewell = Goodbye!

[Errors]
not_found = The requested page was not found.
server_error = An internal server error occurred.

CSV Localization Example

Here is a CSV file used for localization with key and language columns:

key,en
greeting,"Hello!"
farewell,"Goodbye!"
welcome_message,"Welcome to our app, {name}!"
error_not_found,"Page not found."

Text Files in Application Localization

Plain text localization files play a critical role in app localization — the process of adapting your application's user interface, messages, and content for different languages and regions. Whether you're building a mobile app, desktop software, or web application, text-based localization files are often the simplest and most efficient way to manage translations.

App localization involves more than just translating strings. It includes handling right-to-left (RTL) languages, date and number formatting, pluralization rules, and cultural adaptations. Plain text and properties files serve as the foundation for all these localization workflows.

By using AI-powered translation for your plain text and properties files, you can accelerate your time-to-market for new languages while maintaining consistent quality across all your app's translations.

Mobile App Localization

Mobile platforms rely heavily on text-based localization files to deliver multilingual experiences:

• iOS / macOS (.strings, .stringsdict): Apple platforms use .strings files for simple key-value translations and .stringsdict for pluralization rules. Xcode's localization workflow is built around these text-based formats.
• Android (strings.xml, .properties): Android uses XML-based strings.xml but also supports .properties files for legacy Java-based components and Gradle build configurations.
• Flutter / Dart (.arb): Flutter uses Application Resource Bundle (.arb) files, which are JSON-based but often managed alongside plain text translations in multi-platform projects.
• React Native (JSON, .properties): React Native apps commonly use JSON files via i18next or react-intl, but native modules may require platform-specific text formats.

Desktop App Localization

Desktop applications across all major platforms use text-based localization:

• Electron (.json, .properties): Electron apps built with web technologies use JSON or properties files for localization, often with libraries like i18next or electron-i18n.
• .NET / WPF (.resx, .properties): .NET applications use resource files (.resx) and properties files for managing localized strings across Windows desktop applications.
• Qt (.ts, .ini): Qt applications use translation source files (.ts) and .ini files for configuration and localization of cross-platform desktop software.
• Java Desktop (.properties): Java Swing and JavaFX applications use .properties files as the standard localization mechanism with ResourceBundle.

Web App Localization

Modern web applications use various text-based formats for internationalization:

• Angular (XLIFF, JSON): Angular's built-in i18n uses XLIFF, but many Angular projects also use JSON or plain text files with ngx-translate or Transloco libraries.
• React (JSON, .properties): React applications commonly use JSON files with react-intl or i18next, and may use .properties files for Java backend integration.
• Vue.js (JSON, YAML): Vue.js projects use vue-i18n with JSON or YAML translation files, sometimes alongside plain text formats for content management.
• Next.js (JSON, .properties): Next.js applications use next-intl or next-i18next with JSON files, supporting both server-side and client-side translation loading.

AI Glossary Generation for Text Localization Files

Our AI Glossary Generation feature helps you maintain consistent terminology across your .strings, .ini, .properties, and CSV localization files. Enable it by toggling Generate Glossary in the translation options:

• Consistent terminology — the AI analyzes your source text content and existing target translations to build a glossary of key terms, ensuring product names, UI labels, and technical terms are translated consistently across all your app's localization files.
• Domain-specific terms — provide a sample of already-translated text content in the target strings field. The AI learns your preferred terminology and applies it to new strings automatically.
• How to use it — paste your translated text content into the optional target strings field that appears when glossary generation is enabled. The AI extracts recurring term pairs and uses them as a translation guide. If no target content is provided, the AI generates a glossary from the source content alone.

Why Use l10n.dev for Text File Translation?

• AI-Powered Translation: Our translation engine uses advanced AI to deliver accurate, context-aware translations that understand your app's terminology and user interface patterns.
• Format Preservation: Keys, section headers, comments, and structural elements are preserved during translation. Only the translatable values are modified.
• Placeholder Handling: Variables like {username}, %d, %@, and {{count}} are detected and preserved in the translated output.
• Multiple Format Support: Translate .strings, .ini, .properties, CSV/TSV, and app text files — all from a single tool.
• Context-Aware Results: The AI considers surrounding strings and app context to produce translations that are consistent and natural-sounding.
• Starting from 10,000 free characters. View Pricing
• Optimized for Large Content: Efficiently handles large localization files with thousands of strings, maintaining translation quality throughout.

Common Use Cases for Text File Translation

Plain text translation is used in a wide variety of application localization scenarios:

• Mobile App Localization (iOS, Android, Flutter): Translate .strings, strings.xml, and .arb files to reach users in new markets with native-language app experiences.
• Game Localization: Translate in-game text, dialogue, UI strings, and configuration files stored in .ini, .cfg, .csv, or custom text formats used by game engines like Unity, Unreal Engine, and Godot.
• Desktop Software: Translate .properties, .ini, and .resx files for Windows, macOS, and Linux desktop applications built with .NET, Java, Qt, or Electron.
• Web Applications: Translate JSON, YAML, and text-based localization files for web apps built with Angular, React, Vue.js, Next.js, and other modern frameworks.
• Embedded Systems & IoT: Translate compact text files used in embedded firmware, IoT device interfaces, and industrial control panels where resource efficiency is critical.
• CMS & Marketing Content: Translate plain text content, email templates, notification messages, and marketing copy stored in text-based formats.
• Documentation & Help Files: Translate README files, help documentation, release notes, and user guides stored as plain text or Markdown.

Text Files vs. Other Localization Formats

Plain text localization files offer the simplest approach to managing translations. Unlike JSON, YAML, or XML, plain text files don't require parsing libraries or schema validation — they can be read and edited with any text editor. This simplicity makes them ideal for small projects, rapid prototyping, and scenarios where developer tooling is limited.

However, structured formats like JSON and XLIFF provide advantages for complex projects: nested key hierarchies, metadata support, pluralization rules, and tooling integration. For large-scale enterprise localization, XLIFF is the industry standard. For web applications, JSON is the most popular choice.

Our AI translation handles all these formats equally well. Whether you paste plain text key-value pairs, .strings content, .ini sections, or CSV data, the AI preserves the exact structure and translates only the values — giving you production-ready localized files.

Frequently Asked Questions

What text formats can I translate?

You can translate any text-based localization format, including .strings (iOS/macOS), .ini (Windows/PHP), .properties (Java), CSV/TSV, and plain text files with key-value pairs. The AI automatically detects the format and preserves the structure during translation.

How do I translate my plain text localization files?

Simply paste your text content into the editor above, set your target language code (e.g., fr, de, ja), and click Translate. The AI will translate the values while preserving keys, comments, section headers, and formatting. You can then copy the result or save it as a file.

Are placeholders and variables preserved during translation?

Yes. The AI detects and preserves common placeholder patterns including {name}, %s, %d, %@, {{variable}}, and ${expression}. These placeholders remain unchanged in the translated output.

Can I translate large localization files?

This page processes content in real-time and works best for smaller to medium-sized content. For large localization files (over 5,000 lines), we recommend using the I18N File Translation page, which supports file uploads up to 5 MB and provides more reliable delivery for large-scale translations.