Verified
The three architectures, defined by what runs inside the binary. Native: the screens are built with the platform’s own UI frameworks, SwiftUI on iPhone, Jetpack Compose on Android, in the platform’s languages, Swift and Kotlin, one app per platform. Cross-platform framework: one codebase in a third language; React Native, in Rork’s documentation, is “a cross-platform approach: one JavaScript codebase that renders native UI on both iOS and Android”, while Flutter, in Dart, draws its widgets with its own rendering engine rather than using the platform’s components. Web in a wrapper (often called hybrid): a web app running inside a native web view, packaged for the stores with a tool such as Capacitor, with plugins for camera, push and storage. All three ship as an .ipa and an .aab. The differences are in who owns the UI layer, how the app follows the platform when the platform changes, what an engineer needs to work on it, and how many codebases there are.
How to choose: three questions
1. Does the app need to feel like the phone’s own apps, and follow the platform when it changes? Navigation, gestures, system sheets, accessibility, the new device shapes: native gets these from the platform’s own components, and platform changes arrive there first. The current example is iPhone Duo, where Apple’s standard containers adapt to the fold by themselves and an app built with an older SDK runs at “a familiar size and aspect ratio” until rebuilt, iPhone Duo apps: what changes. A cross-platform framework follows after the framework updates; a web view follows the browser engine.
2. Who will work on it in a year? A native project needs an iOS engineer and an Android engineer, or an AI agent that writes both; a React Native or Flutter project needs a developer in that framework; a web wrapper needs a web developer. Hiring, contracting and acquisition due diligence all read this column. Code export vs no-code lock-in covers what each leaves you owning.
3. Does a website already exist, and is the phone app the same product or a different one? If the web app is the product and the phone app is the same screens in your pocket, the wrapper is the shortest route, subject to Apple’s bar for it. If the phone app has its own jobs, camera, offline, notifications, widgets, the home screen, it is a different product and should be built as one, in whichever of the first two architectures question 1 picks.
Native vs cross-platform vs hybrid, compared
The table compares the three architectures on the columns a product person decides on. Rows are architectures, not products; the builders that produce each are on cross-platform app builder and best native app builders.
| Architecture | What runs inside the binary | Codebases | Follows the platform | Who works on it | Opens in Xcode / Android Studio | Store bar |
|---|---|---|---|---|---|---|
| Native (Swift + Kotlin) | SwiftUI on iPhone, Jetpack Compose on Android | Two, or one project rendering natively on each (Modaal) | First, with each OS release | iOS + Android engineers, or an AI agent writing both | Yes, both | Standard review |
| Cross-platform framework (React Native) | JavaScript/TypeScript bridging to native UI components | One, plus platform-specific code | After the framework updates | React Native developer | Generated projects, framework toolchain needed | Standard review |
| Cross-platform framework (Flutter) | Dart; widgets drawn by Flutter’s own engine | One, plus platform-specific code | After the framework updates | Flutter developer | Generated projects, Dart toolchain needed | Standard review |
| Web in a wrapper (Capacitor, PWA) | Your web app in a native web view (WebKit on iOS) | One, the website | At the browser engine’s pace | Web developer | Wrapper project only | Guideline 4.2 Minimum Functionality applies |
Architectures, not products. All four rows ship as an .ipa and an .aab. Framework descriptions from vendor documentation read 10–25 September 2026; no performance figures by design.
1. Native (Swift + Kotlin), best for products that live on the phone
What runs inside: SwiftUI on iPhone, Jetpack Compose on Android, in Swift and Kotlin. Codebases: two, one per platform, unless the tool writes the feature logic once and renders it natively on each, which is Modaal’s model: from its documentation, “Each feature’s logic, its state, the actions that change it, the effects it requests, is written once,” and “The iPhone app renders that state in SwiftUI; the Android app renders it in Jetpack Compose.” Follows the platform: first; new device classes, system components and accessibility arrive in these frameworks with each OS release, and Apple’s rule that from April 2027 uploads must be built with the iOS 27 SDK or later is a rule about exactly this layer. Who works on it: an iOS engineer, an Android engineer, or an AI agent writing both; the projects open in Xcode and Android Studio. Best for: camera, offline, notifications, widgets, the lock screen and StandBy, a paywall that has to pass review, anything where the phone is the product. Cost of the choice: two UI implementations, which is the reason the framework tier exists.
2. Cross-platform framework (React Native, Flutter), best for one team, two stores, standard screens
What runs inside: for React Native, JavaScript or TypeScript that “renders native UI on both iOS and Android” through a bridge to the platform’s components; for Flutter, Dart drawing its own widgets with the framework’s engine. Codebases: one, with platform-specific code where the framework does not reach. Follows the platform: after the framework does; a new system component or device class appears when the framework ships support for it. Who works on it: a React Native or Flutter developer; the project needs that toolchain in addition to Xcode and Android Studio. Best for: a product with mostly standard screens, lists, forms, feeds, where one team shipping to both stores matters more than the platform’s newest behaviour. The full decision against native, including what each framework reaches and what it does not, is on React Native vs native.
3. Web in a wrapper (Capacitor, PWA), best for an existing web app that needs to be in the stores
What runs inside: your web app, in a native web view, with plugins for the native APIs it needs; on iOS, apps that browse the web must use WebKit (guideline 2.5.6). Codebases: one, the website. Follows the platform: the browser engine’s pace; system navigation, sheets and device classes are re-implemented in web code or not at all. Who works on it: a web developer. Best for: a product whose web app is the product and whose phone app is the same screens with push notifications and an icon. The bar: Apple’s guideline 4.2, Minimum Functionality: “Your app should include features, content, and UI that elevate it beyond a repackaged website. If your app is not particularly useful, unique, or ‘app-like,’ it doesn’t belong on the App Store.” What passes and what does not, with the three routes from a website, is on turn a website into an app. Whether the product needs an app at all is a prior question, do you actually need a native app?
Capacitor vs React Native vs native, head to head
Capacitor vs React Native. Both let one team ship one codebase to both stores; the difference is what draws the screen. A Capacitor app runs your web app in the platform’s WebView, so every screen is HTML and CSS. A React Native app runs JavaScript that “renders native UI on both iOS and Android”, so lists, buttons and navigation are the platform’s own components. Capacitor is the shorter route when a web app already exists; React Native is the shorter route to screens that feel like the platform, at the cost of a new codebase. Capacitor vs Despia compares the two ways to run the wrapper route.
React Native vs native. Both put platform components on screen; the difference is the layer in between. Native is SwiftUI on iPhone and Jetpack Compose on Android, written in the platform’s language, with new system components available the day Apple or Google ships them. React Native reaches them after the framework adds support. React Native vs native has the full decision.
Capacitor vs native. These are the two ends of the scale: the same web app in a native shell, or the app rebuilt from the platform’s parts against the same backend. Apple’s guideline 4.2 is the line that matters most at the Capacitor end, and it does not come up at the native end.
Which should you use?
The phone app is the product, it uses the camera, works offline, sends notifications, has widgets, sells a subscription through the store: native. If the objection is two codebases, the answer in 2026 is a tool that writes the feature once and renders it natively on both, rather than a framework in between.
One small team, two stores, standard screens, nothing platform-specific on the roadmap: a cross-platform framework, chosen on React Native vs native with the roadmap in hand, the moment a platform feature appears on it, the framework’s reach becomes the constraint.
A web app exists and the store version is the same product: a wrapper, built to clear guideline 4.2 by doing something the website does not, offline content, native navigation, push, camera.
Validating an idea, launch not planned: the fastest of the three; keep the spec, treat the build as disposable. When it graduates to a product, re-run question 1.
The native case with one project: in Modaal the PRD is the first prompt; the agent writes a plan you approve, then the feature logic once and the SwiftUI and Jetpack Compose screens for each platform; the Xcode and Android Studio projects stay on your disk. The Free plan covers one project with unlimited prompts on one platform; Pro is €9 per user per month billed annually, €15 monthly, and adds both platforms and TestFlight, /pricing.
Native on both platforms, from one project
Write the feature once; the iPhone app renders it in SwiftUI and the Android app in Jetpack Compose. Xcode and Android Studio projects on your disk, your own AI agent, a plan to approve before code. Free for one project.
Keep reading
- React Native vs native
The framework decision in depth.
- Do you actually need a native app?
The question before this one.
- Turn a website into an app
The wrapper route and guideline 4.2 in full.
- Best native app builders
Four questions that settle “native” with any vendor.
- Code export vs no-code lock-in
What each architecture leaves you owning.
- Convert an iOS app to Android
What carries over from an existing iOS app.
- Build a mobile app with AI: every route
Where this decision sits in the whole workflow.
- Capacitor vs Despia
Two ways to run the wrapper route.
