Choosing between native runtimes and shared frameworks involves complex architectural trade-offs. Many evaluations rely on trivial benchmarks rather than systematic metrics.
An empirical study published on arXiv evaluates five implementations of a standardized plant-management application. Guided by ISO/IEC 25010, the research examines time behavior, implementation footprint, source-code organization, and rendering responsiveness.
For technical leads building modern application ecosystems, these findings clarify where shared frameworks save engineering effort and where native code retains a performance edge.
In short
- •
Native implementations achieve the lowest non-UI client subtotals across operating systems, while Kotlin Multiplatform emerges as the closest cross-platform challenger.
- •
Shared frameworks significantly reduce authored mobile source code compared to separate native codebases, trading raw performance overhead for delivery velocity.
- •
Operation and UI-wrapper rankings vary heavily by specific task, proving that cross-platform selection requires workload-specific benchmarking rather than blanket assumptions.
Benchmark Methodology and Workload Scope
The study compares native iOS, native Android, Flutter, React Native, and Kotlin Multiplatform implementations against a shared functional contract. The eight total variants process identical domain logic and interact with synchronized backend services.
Each variant undergoes 2,000 completed benchmark runs covering authenticated retrieval, cached data access, image decoding, list scrolling, local synchronization, and media upload.
Backend preparation and framework-specific UI drivers are isolated from primary client workflows to ensure that measurement data reflects actual runtime behavior rather than server-side latency.
Source Footprint Versus Runtime Overhead
Cross-platform frameworks consistently reduce the volume of authored source code required to target both major mobile operating systems. This reduction directly impacts maintenance overhead and initial development velocity.
However, native runtimes maintain an advantage in client subtotal execution times. Kotlin Multiplatform bridges this gap more effectively than UI-heavy abstractions on specific subtasks.
Architects must weigh the reduction in codebase size against the rendering responsiveness and synchronization latency introduced by bridge layers.
Architectural Guidance for Engineering Teams
Do not pick a cross-platform stack based on marketing claims alone. Audit your specific workload requirements, such as heavy image decoding or frequent list scrolling, against empirical benchmarks.
When cross-platform delivery speed is vital, accept that certain UI interactions will incur minor rendering overhead. Isolate complex domain logic into shared modules to retain flexibility.
Appamass teams design connected product ecosystems by matching framework boundaries directly to operational workloads, ensuring that cross-platform efficiency never compromises core user experience.
Systematic evaluation helps engineering leaders select mobile architectures based on concrete runtime data rather than intuition.
Balancing code reuse with strict performance requirements keeps production applications responsive as feature sets expand.
Source
ArXiv: Cross-Platform vs Native Mobile Development Study
https://arxiv.org/html/2609.21544v2