Deciding which mobile app development framework to use when starting a new mobile application is never an easy task. In this article, I will consider the pros and cons of native mobile development vs different UI cross-platform solutions like React Native, Flutter, and Compose Multiplatform, enabling you to make an informed choice that aligns with your project’s specific needs.
Disclaimer: Some thoughts in this article are objective, while others are subjective opinions. It’s okay if you don’t completely agree with everything. This is just a guide to help you decide which framework best suits your needs
Choosing which frameworks to analyze
First and foremost, I believe it’s essential to eliminate certain options. The array of frameworks available is extensive, and I opine that some of them may not be worth considering in 2023.
- Xamarin: Microsoft announced that Xamarin will no longer be supported after May 1, 2024. Even when they are replacing it for a new framework, I have a preference for more lightweight and platform-agnostic solutions.
- Apache Cordova / Ionic: I believe that frameworks that rely on webviews should be discarded, they might be good for very small and simple apps though.
- Unity: It is primarily used for game development which is not the focus of this article.
- Kotlin Multiplatform: It is not a cross-platform UI framework but rather a way to share business logic, I will analyze JetBrains Compose Multiplatform but not Kotlin Multiplatform itself.
Of course there are other frameworks, but these are the most popular technologies that I have omitted from my analysis.
That said, we will be considering:
- Native mobile development
- React Native
- Flutter
- JetBrains Compose Multiplatform
Budget
Let’s assume it: native applications are expensive, time consuming, and complex to build and maintain.
Budget is probably the main reason of why cross-platform solutions are chosen over native.
Just let’s think about a new startup that has low budget and needs to go to market as soon as possible and fail fast as well.
In a scenario like this, the startup needs to get into its hands an app very quickly, so that it can validate the product or service it is offering. It would not be good to spend a lot of money on some new project, build a native app and then realize that the product is not going to succeed.
So whether your company doesn’t have a lot of budget for the project or you’re an individual developer with limited time, cross-platform solutions are probably a better solution for you.
Winner: cross-platform solutions
Learning curve
JavaScript is one of the most popular languages out there and React is also one of the most popular JavaScript libraries. So when Facebook released React Native, it was great news for React developers: they could create mobile apps with the same knowledge they already had for web development.
For someone coming from React, moving to React Native is pretty straightforward, therefore it seems like the most reasonable choice for React developers.
Regarding Flutter, I think that this is the easier framework to learn unless you are a React developer. The dart language is easy to learn and has a lot of similarities with C-style languages and Flutter itself is a very simple yet powerful framework.
Regarding Compose Multiplatform, it leverages Kotlin-based declarative UI development, which makes it accesible to developers familiar with Kotlin/Android, if you are an Android developer with experience in Compose, then Compose Multiplatform is almost identical.
On the other hand we have Native, I can say with confidence that learning native can be a tough journey. Swift and Kotlin are powerful modern languages, and each operating system gives you a lot of control over your app. But this control comes with a cost: it requires a lot of time and practice to master.
Winner: Flutter
User experience
As a developer and a user, I believe that user experience is a non-negotiable requirement for any mobile app. A bad user experience can lead to users uninstalling the app, even if it has great features.
Native rendering
Native frameworks (iOS & Android platforms) expose a layer over the rendering engine, this layer is composed of the most common UI widgets, and each platform has it own way of rendering these widgets. For instance, Android use a 2D rendering engine library called Skia.
Rendering on cross-platform frameworks
Some cross-platform frameworks add another layer over the system UI widgets, which generally results in worse performance. Currently, React Native uses this technique and renders platform widgets. On the other hand, both Flutter and Compose Multiplatform use Skia.
Migration to new Architectures
It is worth mentioning that both React Native and Flutter are migrating to new architectures.
On one hand, Flutter is migrating from the Skia render engine to Impeller, which is supposed to achieve better performance, particularly on iOS. On the other hand, React Native is migrating its rendering engine to Fabric, which is also supposedly to achieve better performance and interoperability between React and host platforms
Flutter and Compose Multiplatform use the Skia library to render their UIs. Skia is a high-performance and portable 2D graphics library. However, one disadvantage of using Skia is that components/views may not look exactly like native views.
Native widgets vs self rendering
It is important to mention the differences in using the native UI widgets vs directly using a rendering engine like Skia. The following table summarizes pros and cons.
| Pros | Cons | |
| Native Widgets approach | Look and feel identical to native | Performance impact |
| Self rendering approach | It can offer better performance by reducing an additional layer in the rendering process. | The experience might not be exactly the same as a native application and you might need to implement platform-specific code. |
It is worth mentioning that in Android, Compose Multiplatform user experience is exactly the same as a native Android app.
Overall, all these frameworks are capable of providing an acceptable user experience, but I don’t see a clear winner between the cross-platform solutions, so I will let you decide which one best suits your app. However, if you are looking for the best possible user experience, then native development is the way to go.
Winner: Native
Community Support
| Framework | Tagged questions on Stack Overflow |
| React Native | 310,507 |
| Flutter | 224,338 |
| Compose Multiplatform | 15,733 |
Community support is an important factor to consider when choosing a framework. A strong community can provide valuable resources, such as documentation, tutorials, and support forums. It can also help you to stay up-to-date on the latest developments and trends in the framework.
React Native and Flutter have both a large and active community. There are also many resources available online, such as documentation, tutorials, and blog posts.
Compose Multiplatform is a newer framework, so the community is not big. However, the Compose Multiplatform community is growing rapidly, and there is a good number of tutorials and posts.
Native development have the largest and most active communities. This is because native development has been around for longer than cross-platform development. There are a huge amount of resources available for native development.
Winner: Native
Dealing with Deprecations and Framework Changes
The mobile development world is always changing, there are always new libraries, techniques, and tools out there that try to replace old ones. This is cool, but it can also be a problem when you have to update your entire app just to support a new library, technique, or framework.
I am not sure about a particular winner here, as it is a struggle even in native development, but I think I can identify two main losers: since I first heard of React Native, it has changed too much. I believe it has become to a more stable phase, but anyway, I feel like this framework is constantly changing. On the other hand, Compose Multiplatform is still in Alpha for iOS, which means it can seriously change before it gets stable.
If I have to declare a winner, for me it is Native since it is less likely to have big changes. Even though Google frequently deprecates libraries.
Winner: Native
App Requirements and Complexity
When it comes to choosing the right framework for your mobile app, the complexity and specific requirements of your project are vital considerations. While cross-platform solutions like Flutter, React Native, and Compose Multiplatform offer many advantages, there are scenarios where the native approach remains the clear winner.
When your app’s complexity and requirements extend to hardware-specific APIs, offline support, database intensive operations, and intricate user interfaces, choosing a native approach is often the wisest decision.
Winner: Native
Conclusion
The decision between native and cross-platform mobile app development is a nuanced one. While each approach has its unique merits, the choice hinges on the specific needs and constraints of your project. If time and budget are pivotal, cross-platform frameworks like Flutter, React Native, and Compose can be invaluable. They offer quicker development cycles and code reuse, aligning with cost-efficiency and faster time-to-market. However, it’s crucial to remember that user experience, app specific requirements, and performance must not be forgotten. Striking the right balance between these factors is the key to successful app development – where the choice between native and cross-platform becomes more art than science. It’s about harnessing the best of both worlds to create exceptional mobile experiences.
Personally, in most cases I lean towards a combination of Native development and Kotlin Multiplatform. I think this solution has the best of both worlds: native performance while allowing you to share your business logic (and even presentation logic). However, if budget and time are significant concerns, then I’d probably choose Flutter.
One Comment
Comments are closed.