Skip to Main Content

Native vs. Cross-Platform Mobile App Development

Follow along as we break down what to consider when choosing a platform for developing your next mobile app. In this article, we’ll compare Native to hybrid solutions Xamarin, React, and NativeScript.

Are cross-platform mobile app development  tools are worth the hype over native development? It’s true that developing apps natively lets you work with a high level of craftsmanship and community support. However, for most common app requirements, you can use platforms like Xamarin, React Native, and NativeScript to build apps cross-platform with only minimal loss of user experience (UX) while saving time and cutting costs. 

To help you determine which option is right for you, we’re going to take a closer look at the functionality of cross-platform frameworks and see how they stack up against native. Then we’ll take a look at UX/UI considerations for your app. Finally, we’ll discuss how the team at Aptera decides when to use native and when to use hybrid solutions for developing mobile apps.

Functionality Considerations

Most any device function offered natively can now also be leveraged in a hybrid solution.

At this point, Xamarin, React, and NativeScript all claim 100% support of native functionality through their APIs. Additionally, NativeScript and React also supplement their platform shortcomings with third-party plugins and support for Cocoapods and Maven.

React Native supports native functionality through what it calls modules. Not all native functionality is supported via a module, but there is the option to include any native code (Java, Swift, Obj-C) via native modules. Native modules are considered an anti-pattern to the framework, however. Most native functionality support can be found in third-party libraries too, however, its unclear how easy they are to use and if they even follow similar conventions to React Native itself.

Developer Effort Requirements

The chart below demonstrates the effort required by developers to implement the following features/functionality in each platform based on ease of implementation and developer support.

100% Support     Requires Support     Zero Support    
  Hybrid 3rd party library available for iOS and Android    

NativeXamarinReact NativeNativeScript
Notifications    
Offline Capabilities    
Camera    
Data Storage    
Fingerprint    
Sensors    
Geolocation    
Bluetooth    
Microphone    
Permissions    
Wearables ( Watchkit / Android Wear )  N/AN/A

Developer Experience Quality

This chart depicts the developer experience by category with green representing a high degree of quality, that’s well-documented and fast.

100% Support     Requires Support     Zero Support    
NativeXamarinReact NativeNativeScript
Platforms    
Tools    
Device / Debugging Support    
Community Support    
Deployment / CI Framework    
Testing    
Dependency Managers (Cocoapods / Maven) and 3rd Party Support    
Reuse of Web Components & Business Logic    
IPA and APK Security / Hackability    
Styling    


Platforms

Hybrid development frameworks target only a specific set of platforms. Xamarin is able to target iOS, Android, Windows, macOS, and Linux with other smaller platforms also supported and more on the way. React Native and NativeScript are limited to only iOS and Android.

Tools

Native development is limited to a handful of integrated development environments (IDEs) specifically designed for each, with Android Studio as the preferred tool for Android and Xcode or AppCode for iOS. With Xamarin, Visual Studio is the only option on both Windows and Mac. React Native and NativeScript apps can really be written using any text editor preferred since they are CLI driven, but the community generally steers towards Visual Studio Code as it contains a healthy library of supporting plugins. It should be noted that developing iOS apps requires a Mac and Xcode no matter which option is chosen.

Device/Debugging Support

Native IDEs and tools will always offer the best, fastest, and most thorough support of debugging and profiling apps. Most of the hybrid frameworks support deploying to physical devices, debugging/logging errors, live coding updates, and profiling. It should be noted that the performance and simplicity of doing so is not as straightforward when developing in native.

Community Support

The community is larger for native platforms because they are the originals! Customizations through third-party tools, questions posted in forums, and updates to the platforms themselves are more abundant natively. While large communities do surround each open source, cross-platform framework, the reality is that they will not match the support that native gets.

Testing

All frameworks support testing through unit or automated UI tests. It should be noted that native development will require you to write the unit tests twice for each platform. For automated UI tests, there are testing frameworks that target one platform or framework (native iOS only, native Android only, Xamarin only, React Native only, etc.) and other frameworks that allow you to perform those tests in a cross-platform way no matter how it was developed.

Cocoapods/Maven Support

Native platforms support third-party customizations through Cocoapods and Maven. Xamarin does not include support for these. React Native and NativeScript offer support for native libraries, however with a varying amount of increased difficulty over native.

Reuse of Logic

Logic written in one native platform cannot be reused on another without introducing some server-side backend to host business logic. Logic written in C# and Xamarin can be reused across projects and can even be packaged up into a Nuget. React Native allows reuse of logic when it is written in React. Likewise, NativeScript allows reuse of logic when written in Angular.

Styling

All frameworks can take advantage of native styling and theming concepts and understanding native styling at its core is a good starting point. Xamarin leverages XAML styling definitions (locally or globally). Most of the basic styling concepts are honored; however more fine-tuned styling requires custom effects/renderers to be implemented natively. NativeScript leverages CSS styling. There is no new terminology to learn as a large portion of CSS properties web developers already know can be used. CSS files can be split into common and platform specific files to provide another level of customization.

UX/UI Design Considerations

Cost savings by leveraging shared code are only realized when designs are simple enough to not require platform-specific accommodations to be made for UI designs and functionality. In situations where a rich, beautiful design is required with smooth animations, scrolling, and/or transitions, it may be more economical to leverage the deep repository of native libraries offered by the much larger native open source community. That said, a simple design can be quickly constructed with out of the box Xamarin, React Native, or NativeScript tools.

Development Effort by Platform

This chart visually displays the increase in development effort with many platforms as the design complexity of your app increases.

NativeCross-Platform
Complex app functionality that requires native
  1. 3D rendering components (OpenGL, SceneKit, Metal)
  2. Unity AR/VR Components
Platforms that require native
  1. Access to native APIs not exposed with Xamarin
  2. Access to C/C++ libraries that require compilation (encoders, 3D libraries, etc.)
  3. Access to native 3rd party libraries not supported by cross-platform toolset (Firebase, some AWS, etc.)
Other considerations for going native
  1. Targeting a single platform (iOS or Android)
  2. Bleeding edge concepts
  3. App is consumer app which requires speed and a quick, smooth, and thoughtful user experience
Simple App Complexity
  1. Simple design
  2. Minimal device feature interaction
Code Reuse
  1. Significant business code in C# nuget packages
  2. Significant business/UI code in React components
  3. Significant business logic in Angular

If none of the native qualifiers above apply, a hybrid solution with a shared code-base between platforms is not only feasible but recommended. Choosing which tools to use should largely be driven by opportunities to share code and which technology stack your developers are most familiar with (e.g. C#, Xamarin, JavaScript/CSS, React Native, Angular, NativeScript Angular). If code reuse isn’t possible and development team is versatile in C#, JavaScript, and CSS, our recommendation is Xamarin or React Native due to a stronger platform viability (see Google Trends graph below).

Platform Interest via Google Trends

group-145

Additional Resources

Start a Conversation

From our mobile moment strategies to our cross-platform expertise and agile delivery methods, Aptera can set you up for success in the ever-evolving mobile landscape.