Flutter vs Kotlin - how do they stack up?
Flutter and Kotlin - two important technologies in the app development world.
What are the key similarities and differences? Which should you consider for your app development project?
In this article we’re going to answer these questions. We’ll introduce Flutter and Kotlin, go through their merits and drawbacks, and guide you through the essential features of each.
First let’s introduce the basics of Flutter (go here for more detail).
What is Flutter?
Flutter was released by Google themselves in 2017.
At the fundamental level - Flutter is a powerful framework for building cross platform mobile apps.
That means that you use Flutter to develop apps for iOS and Android from one single codebase.
This makes app development faster and more efficient than traditional native development - which involves writing separate codebases for each platform.
Flutter’s core features are:
- Widget-Based Architecture: Flutter’s foundation is widgets, reusable and modifiable UI components that are combined to create the UI
- High Performance: Flutter apps compile to native code that runs on a low level on the device, giving great performance comparable to native apps
- Ecosystem: Flutter has a vast range of widgets, tools, and general resources thanks to support from Google and a large, growing community
The key thing about Flutter - everything is a widget.
Widgets are just reusable pieces of Dart (Flutter’s programming language) code, that define UI components. They can be thought of as the basic building blocks of Flutter apps.
There are hundreds of core widgets for everything from the text and images to complex layout, animation and interactivity features.
The widgets are combined by Flutter developers into a tree. This builds the UI, which is rendered onto the device’s screen via Skia, Flutter’s own graphics engine, giving granular control of every pixel.
Flutter has shot to the top of the app development world over the past few years, powering countless apps including AliBaba, ByteDance, Google Classroom, and other huge brands.
You can read about Flutter in much more depth in our Flutter 101 article, but now let's move on to Kotlin.
What is Kotlin?
Kotlin is not a framework like Flutter, but is rather a programming language.
It was developed by JetBrains - a well known company behind several successful developer tools - and designed to fully interoperate with Java.
Back in the early days of Android development, Java was king, and the foundation of every app’s codebase.
After Kotlin was released in 2016 though, it was steadily embraced by the Android community thanks to its elegance, concise syntax, and excellent safety features.
It seemed to solve a lot of the core pain points of Java when it came to app development.
In 2017, Google announced official full support for Kotlin, and since then adoption has been rapid indeed.
And because Kotlin is interoperable with Java, developers were able to incrementally introduce Kotlin into their apps without needing to rewrite them from scratch.
This interoperability is powerful. It means that Kotlin can leverage the vast ecosystem of Java libraries, frameworks, and the JVM too.
Now, Kotlin has displaced Java as the king of Android programming. By 2021, 90% of active Kotlin developers had switched directly from Java according to JetBrains:
Though Kotlin is famous for Android development - you can do a lot more with it too.
It supports backend development, web development, and even cross-platform mobile app development.
Though the majority of Kotlin developers use it for mobile development, other use cases aren’t far behind:
So Kotlin is a versatile programming language, supported by Google and typically associated with Android development - although it can be used for much more.
Now let’s get a little deeper into the comparison.
Framework vs Language
The first thing to understand when comparing Flutter with Kotlin is that Flutter is a framework and Kotlin is a programming language.
Let’s define these terms.
A programming language is a bit like a human language, except it is for communicating with a computer. It has a set of rules like syntax, semantics, and grammar - that allow developers to write programs that run on computers.
The language defines the commands, operations and instructions that can be executed by the machine.
You probably know plenty of programming languages like Python, JavaScript, C++, and many more.
Kotlin is one such language.
Flutter, on the other hand, is a framework.
You can think of a framework as a set of tools for using a specific programming language for a specific purpose.
Frameworks typically have a set of libraries, APIs and tools for handling common tasks.
Flutter, as a framework, allows developers to use the Dart programming language for developing cross platform applications.
Which is better for Cross Platform Development?
Which is better for developing cross-platform applications? They both have cross-platform capabilities, but in a very different sense. Let’s find out how.
Flutter is the most popular cross-platform development framework around today.
Thousands of apps are built with it because of its amazing ability to write one codebase and have it compile to native code for iOS and Android.
Flutter gets this functionality from a few of its core components:
- The Dart programming language: Dart’s just-in-time compilation enable features like hot reload, which allows developers to rapidly preview changes across platforms, and its ahead-of-time compilation for production builds compiles into native machine code for each platform, ensuring great UX and performance
- Widgets: everything in a Flutter app UI is a widget, and widgets are platform independent, allowing Flutter developers to build consistent UIs that look and perform the same across operating systems
- Rendering engine: Flutter uses open-source 2D graphics engine Skia to render the UI from scratch across platforms, allowing for pixel-perfect replication of the UI independent of OS
There are other factors that contribute to Flutter’s powerful capabilities, but everything about the framework and its ecosystem is tailored toward this aim.
Flutter’s cross platform capabilities are all about the UI. You create the UI once, then it can look and perform the same not only on iOS and Android but across any screen size or device.
Kotlin Multiplatform is very different. It allows for the sharing of business logic, data models, and key functions across platforms - while the UI is left to be implemented in the native code of each.
If Flutter is “front end” multiplatform, then Kotlin Multiplatform is geared towards the backend.
This means that it is not possible to just “write once, deploy everywhere” in the same way. You can share the backend logic but still need to build the actual apps separately with separate codebases.
This could be particularly useful if you have an existing codebase in Kotlin, for example for an Android app. Kotlin Multiplatform could allow you to leverage existing code and expertise and extend it onto iOS.
You’d still need to build the iOS front end from scratch though!
By contrast, Flutter is better for building cross-platform apps rapidly and efficiently, and allows complete reuse of 90%+ of UI code.
Performance
When it comes to cross-platform frameworks, Flutter is known for excellent performance.
Unlike cross-platform alternatives like React Native, Flutter’s architecture allows it to communicate directly with the underlying platform, without the need to “bridge” to native components.
This results in fast and dynamic apps that feel native on iOS and Android. Kotlin performance is arguably even better.
Kotlin is a first-class language for Android, meaning it compiles into bytecode and executes on the JVM, giving Java-equivalent performance.
It is completely interoperable with Java - the language of Android’s standard libraries and SDK. This means that performance on Android can be truly optimal, and it can also fully access all native APIs and hardware features.
Through Kotlin multiplatform, it can also achieve excellent performance on iOS, although the actual iOS front end will not be written in Kotlin but rather in Swift, so this point is debatable.
Overall - both Kotlin and Flutter have excellent performance, but Kotlin could have the edge here on Android.
Flutter vs other platforms
If you're hungry for more Flutter analysis - we also compared it to other app development options as part of this series.
- Flutter vs React Native
- Flutter vs Swift
- Flutter vs Ionic
- Flutter vs PWAs
- Flutter vs Xamarin
- Flutter vs native development
- Flutter vs Expo
You can take a read of them to learn about how Flutter stacks up against other options too. For now though, let’s wrap up the comparison with Kotlin.
Flutter vs Kotlin ideal use cases
So we’ve covered the most important differences between Flutter and Kotlin. Let’s summarize by going over the ideal use cases.
Flutter is best suited for:
- Projects that require rapid development
- Projects that require a single codebase for the UI on multiple platforms
- UI driven applications where very custom or sophisticated interfaces are key
Use Flutter if you are building UI-focused apps from scratch, fast and more efficiently than native development.
On the other hand, Kotlin is ideal for:
- Android app projects that require deep integration with native APIs
- Applications that need to share a lot of back end business logic written in Java
- “Extending” existing Android applications to iOS through Multiplatform
Kotlin can’t be beaten for Android development specifically, but you may well be able to achieve the same results with Flutter and get apps for iOS on top. Flutter on the other hand is more nimble, efficient, truly multiplatform, and powerful when it comes to animations and graphics.
Convert your site into native apps instead
Although Flutter and Kotlin are very different, they share a few common downsides:
- Cost - developing apps with either costs $50k+
- Time - native app development takes many months
- Risk - can you get ROI? With such a high cost, it's hard to say
- Commitment - the apps require expensive updates and maintenance forever
MobiLoud is a way to offset these downsides, and still get fantastic apps.
With MobiLoud, we convert your existing site or web app into high end, cross platform apps that we publish for you on iOS and Android.
If you have a solid web app, website, or online store - you already have everything you need. If it works for the web it’ll work in the apps and vice versa. With MobiLoud you’ll keep everything from the web in the apps.
We take the web foundation, and we add all the native elements needed for a great app UX - including dozens of features like unlimited push notifications, native navigation, and much more.
From your perspective, they’re a powerful extension of your existing tech stack, which will update with any changes you make on the web. From your users’ perspective, they’re high end native apps that could have been built with Kotlin or Flutter.
The apps will be ready in weeks not months, and will cost <10% of the typical price tag.
The model works great - MobiLoud powers thousands of apps with millions of users, from small startups to multibillion dollar brands.
MobiLoud is a proven, hyper-efficient platform that gets you all the benefits of iOS and Android apps with practically none of the risk. We also handle all ongoing updates and maintenance as part of our full service.
You can even preview what your app would look like, or even better - get in touch with one of our app experts, and have all your questions answered.
