If you build mobile apps for the Saudi market, you quickly discover that a few requirements show up in almost every project. The app has to work properly in Arabic and English, which means right-to-left (RTL) and left-to-right (LTR) layouts in the same codebase. Typography has to look right in both scripts, with Arabic fonts that render cleanly and do not clip. Navigation, gestures and animations need to respect reading direction, not just static layouts. And because many users switch language depending on context, the app should handle that switch gracefully rather than treating Arabic as a separate product.
None of this is exotic, but it does change how you evaluate frameworks. This post walks through the practical trade-offs of Flutter, React Native and fully native development for bilingual Saudi apps, with a focus on the details that tend to bite late in a project.
Why Cross-Platform Is the Default Conversation
For most business apps, the first architectural question is whether one codebase can serve both Android and iOS. Cross platform mobile app development is attractive because it lets a single team ship features to both stores at roughly the same time, share business logic and UI, and keep behaviour consistent across devices.
The trade-off is that you add an abstraction layer between your code and the platform. That layer is excellent most of the time and occasionally in your way. The question is not "is cross-platform good?" but "where will the abstraction get in my way, and can I live with it?"
RTL Support: The Detail That Decides a Lot
Bilingual RTL support is where frameworks differ in ways that matter for Saudi apps.
Flutter
Flutter handles directionality through the Directionality widget and locale settings. If you use directional widgets and properties, layouts mirror correctly when the locale switches to Arabic:
// Prefer directional values so layouts mirror automatically
Padding(
padding: const EdgeInsetsDirectional.only(start: 16, end: 8),
child: Row(
children: const [
Icon(Icons.store),
SizedBox(width: 8),
Text('My orders'),
],
),
);
The common mistake is mixing EdgeInsets.only(left: ...) with EdgeInsetsDirectional, which produces screens where half the layout mirrors and half does not. A lint rule or code review checklist that flags left/right usage quickly earns its keep.
React Native
React Native supports RTL through I18nManager. Flexbox rows reverse automatically when RTL is enabled, and you should use start/end style properties instead of left/right:
import { I18nManager } from 'react-native';
// Usually set once, based on the user's chosen language
I18nManager.allowRTL(true);
I18nManager.forceRTL(isArabic);
const styles = {
card: { paddingStart: 16, paddingEnd: 8, flexDirection: 'row' },
};
The catch is that changing forceRTL at runtime typically requires an app reload to take full effect, so in-app language switching needs a deliberate UX, for example a confirmation and restart.
Native (Swift/Kotlin)
Both platforms have mature RTL support. On iOS, Auto Layout's leading/trailing constraints and semantic content attributes handle mirroring; on Android, start/end attributes and android:supportsRtl="true" do the same. Native gives you the finest control, but you implement and test it twice.
Things All Three Share
Whatever you pick, a few RTL details need explicit attention:
- Icons with direction: back arrows, chevrons and progress indicators should flip; logos, media controls and checkmarks usually should not.
- Mixed-direction strings: an Arabic sentence containing an order number, English brand name or phone number can render in surprising order. Test with real content, not lorem ipsum.
- Numerals: decide whether to display Western Arabic (0-9) or Eastern Arabic numerals and apply it consistently, especially in order numbers, quantities and OTP fields.
- Fonts: check Arabic glyph rendering, line height and truncation. Text that fits in English often wraps in Arabic.
- Dates: some users and contexts expect Hijri dates alongside Gregorian ones.
Arabic Typography: Fonts Deserve Their Own Ticket
Font handling is where many bilingual apps look unfinished. Default system fonts render Arabic acceptably, but brand fonts often ship with Latin glyphs only, and the fallback creates a jarring mix on the same screen.
In Flutter, you can declare a fallback chain so Arabic text picks up a font that actually contains the glyphs:
const TextStyle bodyText = TextStyle(
fontFamily: 'BrandSans',
fontFamilyFallback: ['NotoSansArabic'],
height: 1.5, // Arabic usually needs more line height
);
In React Native, a common pattern is to choose the font family per language rather than per component, so every Text gets the right face without manual overrides. Whichever stack you use, check three things on real screens: line height (Arabic diacritics and descenders clip easily), truncation (ellipses should appear on the correct side), and weight mapping (a "bold" Latin weight may not have an Arabic equivalent in the same family).
Performance and UI Fidelity
For typical business apps such as catalogues, booking flows, dashboards and forms, both Flutter and React Native perform well on modern devices.
- Flutter renders its own UI, so you get consistent visuals across platforms and smooth animations, with the trade-off that widgets imitate rather than use native controls.
- React Native uses native components, so controls feel platform-appropriate, but complex animations or long lists need care to stay smooth.
- Native remains the strongest choice for apps leaning heavily on device capabilities, background processing or demanding graphics.
Navigation Mirroring
Layouts are only half of RTL. Navigation has direction too, and users notice when it feels backwards.
- Swipe gestures: in Arabic, "back" is usually a swipe from the right edge. Check that your navigation library mirrors gestures, not only icons.
- Screen transitions: push animations should slide in from the left in RTL so movement matches reading direction.
- Tab bars and carousels: the first tab or slide should sit on the right, and horizontal lists should scroll in the matching direction.
- Progress steps: multi-step flows should advance from right to left so "next" feels forward.
A Hypothetical Walkthrough: A Riyadh Food Delivery Startup
This is an illustrative scenario for discussion, not a real project.
Imagine a small Riyadh startup building a customer app and a courier app. The team has three developers comfortable with JavaScript and a launch window that does not allow two separate native builds.
They choose React Native for both apps, sharing a component library and API client. Early, they enforce start/end styles through linting and build an in-app language switch with a clear restart prompt. A designer reviews every screen in Arabic first, which catches clipped text and unmirrored arrows before they reach testers. The courier app needs reliable background location, which they implement natively behind a small JavaScript interface.
In this scenario, the two apps share most of their code, with native code written only where the platform genuinely demanded it. A Flutter team could have reached a similar outcome with platform channels. The lesson is that cross-platform works best when you plan for the native edges up front.
Things to Consider Before Choosing a Stack
- Team skills: a framework your team knows well usually beats a theoretically better one they do not.
- RTL from sprint one: design and build both directions from the start; retrofitting is painful.
- Native dependencies: list every SDK (maps, messaging, analytics, push notifications) and check its support for your framework.
- Testing matrix: test Arabic and English on a range of Android devices and iOS versions, not just one flagship phone.
- Long-term maintenance: framework upgrades, OS releases and store policy changes all create ongoing work.
- Backend design: a clean API layer makes it easier to change client technology later if needed.
FAQ
1. Is cross platform mobile app development a good fit for Arabic-first apps?
Yes, as long as you use directional layout properties from the start and test with real Arabic content. Both Flutter and React Native have solid RTL support.
2. When should I go fully native?
When the app depends heavily on device features, background processing, demanding graphics, or SDKs that lack reliable cross-platform support.
3. Can I mix approaches?
Yes. Many apps are mostly cross-platform with native modules for specific features. That hybrid approach is common and often the most pragmatic.
Wrapping Up
There is no universally correct choice between Flutter, React Native and native. For Saudi apps, the deciding factors are usually RTL quality, typography, SDK support, team skills and long-term maintenance. Get those right and the framework becomes an implementation detail.
If you are planning a bilingual app and want a second opinion on architecture, teams such as Sara in Riyadh work across both native and cross platform mobile app development for businesses in the Kingdom. Either way, start RTL on day one; your future self will thank you.
Suggested DEV tags (4): mobile, flutter, reactnative, rtl
Top comments (0)