![]() |
About Mobile and Tablet Applications |
Many companies build the same application for all the popular mobile and tablet platforms, Android and iOS. There are several ways to do it. Whatever you choose, you can use Soluling to localize your applications and reuse the translations between applications and platforms. See the list of supported mobile applications.
The most obvious way to build a mobile application is to make a native application. This means that you use the default programming language, the standard development tool, and the native API of each platform.
| Platform | Programming language | IDE | UI framework | Development OS |
|---|---|---|---|---|
| Android | Kotlin or Java | Android Studio | Jetpack Compose or Android views | Windows, macOS, or Linux |
| iOS and iPadOS | Swift or Objective-C | Xcode | SwiftUI or UIKit | macOS |
The toolchains are different on each platform. You need to master two programming languages, two development tools, and two APIs, and you need a Mac for iOS development. The process is not easy, but it gives the best possible user experience. In most cases, you need a programmer or a team for each platform.
Once you have written your applications, the localization process is the same for both: Soluling localizes the resource files of the application.
.iml) or the string resource files (res\values\strings.xml) and creates the localized resource files (res\values-fi\strings.xml), which you build into your application. Soluling can also localize a compiled application file (.apk), but you then have to sign the localized file again, and Google Play requires App Bundles (.aab), so localizing the resource files is the recommended method. See Android..xcodeproj) or the resource files (.strings, .stringsdict, .storyboard, and .xib) and creates the localized resource files, which you build into your application. Soluling does not yet support Xcode String Catalogs (.xcstrings). See iOS.You can reuse the translations of one application in the other through the translation memory.
If you do not want to maintain several projects but only one, use a cross-platform framework. You write the application once, and it runs on Android and iOS, and often also on desktop platforms.
| Framework | Language | Resource files that Soluling localizes |
|---|---|---|
| Flutter | Dart | ARB files (.arb) |
| .NET MAUI | C# | Resource files (.resx), or the project (.csproj) |
| FireMonkey | Delphi (Object Pascal) or C++ | The Delphi project (.dproj) |
| React Native | JavaScript or TypeScript | JSON resource files of i18next or React Intl (.json) |
Flutter is Google's framework. It draws its own user interface with its own widgets, so the application looks the same on every platform. Its localization uses ARB files with ICU plurals and selects.
.NET MAUI is Microsoft's cross-platform framework and the successor of Xamarin, which Microsoft no longer supports. It uses C# and Visual Studio. You share the code and the user interface between the platforms, and you can still use the native APIs of each platform when needed.
FireMonkey uses Delphi or C++Builder. It compiles native applications that do not need a runtime, and it supports mobile APIs such as multi-touch, location, and sensors. Like Flutter, it draws its own user interface, so the user interface is the same on all platforms but does not look exactly like a native one. To localize a FireMonkey application, select the Delphi project file (.dproj), and Soluling creates a multilingual resource file that you add to your application.
React Native uses JavaScript or TypeScript and native controls. Its localization libraries, such as i18next and React Intl, use JSON resource files, which Soluling localizes.
If you want even more platform independence, you can build a web-based application: a progressive web app (PWA) that runs in the browser of the device, or a web application inside a native wrapper, such as Capacitor. The application runs on any device, but the user experience and the access to the device APIs are more limited than in native and cross-platform applications. The localization process is the same as for web applications.
The following table shows some pros and cons of each method.
| Method | Pros | Cons |
|---|---|---|
| Native |
|
|
| Cross-platform |
|
|
| Web-based |
|
|
Whatever method you use, you can localize your applications with Soluling.
You can localize the resource files of mobile applications (e.g., Android strings.xml, iOS .strings and .stringsdict, and .resx) with Soluling Desktop, or upload them directly to Soluling Cloud and translate them in Translate. To localize a project file (e.g., .iml, .xcodeproj, .csproj, or .dproj) or Flutter .arb files, create the project in Soluling Desktop and upload it to Soluling Cloud. The page of each platform describes the Desktop and Cloud processes.
Visual editors are essential for localization. To localize user interface strings properly, you need to know the context of each string and the space available for it. Soluling uses native visual editors: each platform has its own visual editor that uses the native controls of the platform. The Visual C++ editor uses the standard Windows controls, the Delphi editor uses the Delphi components, and so on. This works as long as the operating system that runs Soluling can run the code of the platform. This is not the case with mobile platforms, whose applications run only on the device or in an emulator. This is why the visual editor of a mobile platform uses code that mimics the platform. It gives you a good idea of the user interface, but the presentation is not 100% accurate.
Mobile user interfaces have challenges that desktop user interfaces do not. The screen is much smaller, so mobile user interfaces are compact, and there is little space for string expansion. Translations may be considerably longer than the original strings. The visual editor and the validation help, but because the editor is not 100% accurate, you might need to check the maximum string length too. Soluling can check the length of the translations either by character count or by pixels. If you specify a maximum length, Soluling does not let you enter a translation that is longer. To make the check as accurate as possible, Soluling tries to detect the font that is used in the context. If it cannot detect the font, you can enter it.
Another mobile-specific issue is orientation. The user can rotate the device between portrait and landscape, and the system usually lays out the application again. The rotate and size buttons of Soluling's visual editor help you check how the translated user interface works in different orientations and screen sizes.
Visual editors and length checks make sure that your translated user interface works as well as the original one.