Flutter or Native Swift and Kotlin? How We Choose for Each App

Every app we ship is built with Flutter, yet a few parts are written natively. Here is how we decide, and what it means for cost, updates and your privacy.

· 7 min read

If you are paying someone to build an app, sooner or later you hear the question: one shared codebase, or a separate native app for iPhone and one for Android? The answer changes your budget, how fast fixes reach your users, and how much of your product depends on one developer who knows one platform.

We have made this choice for every app we ship. All of them are built with Flutter, one codebase that becomes the iPhone, Android, Mac and Windows app. And yet almost every one of them also contains a little native code, written in Swift for Apple systems or Kotlin for Android. This post is about where that line sits and why.

One codebase is a business decision first

The usual debate is about performance and how “native” an app feels. For a small studio, and for most clients, the bigger questions are money and time.

With a separate app per platform you pay for the same feature twice. Then you pay for it twice again every time it changes. Worse, the two versions drift. The Android app gets the new setting a month after the iPhone app, a bug fixed on one side lives on for weeks on the other, and support has to ask “which phone do you have?” before answering anything.

With one codebase:

  • A feature is written once and appears on every platform the app supports.
  • A fix ships everywhere in the same release. Nobody waits for “the other team.”
  • Behaviour matches across devices. A user who switches from Android to iPhone finds the same app, the same buttons and the same data rules.
  • Privacy rules are written once, too. If an app keeps your data on the device, that rule lives in one place, not in two versions that each have to get it right.

That last point matters to us more than the cost. Every promise we make about data has to hold on every platform. A single implementation is far easier to keep honest than two that are supposed to behave the same.

What we actually ship

Our current apps cover a fair spread: puzzle and arcade games, a habit tracker, a speedometer, a calculator, a Pomodoro timer, a menu bar calendar for the Mac, a typing game for Mac and Windows, and a private messenger on its way. Every one of them is a Flutter app.

Some run on two platforms, some on four, and the platform list is a product decision rather than a technical limit. Adding a platform later means new store listings and some testing, not a second app. Our Sudoku runs on iPhone, Android and the Mac from one codebase.

Desktop deserves a note. One codebase across three desktop systems is mostly true, but each system still has its own quirks around packaging and windows. We wrote about those in what broke when we shipped Flutter on desktop. The short version: a few days of platform fixes, instead of three separate apps.

Where native code still wins

Flutter draws the app’s screens and runs its logic. What it does not do is replace the operating system. Some jobs only the system can do, and for those we write native code. Here are real cases from our apps, each a small piece of Swift or Kotlin:

  • Sharing into a messenger. When you tap “Share” on a photo in any iPhone app and pick our messenger, iOS starts a tiny separate program called a share extension. Apple gives it very little memory and expects it to be quick, so we wrote it in Swift. It hands the photo over and gets out of the way. The full app picks it up and asks who to send it to.
  • Keeping data out of the cloud backup. Our to-do app syncs with its own server, so a phone backup to the cloud would only create a second, confusing copy. Telling iOS “do not back up these files” is a few lines of Swift. On Android a small native part does the same job.
  • Asking the phone for its time zone. A habit reminder at 8:00 must ring at 8:00 where you are, after you travel too. The exact time zone comes straight from the operating system.
  • Not nagging people without Google. People who install our apps from F-Droid often run phones without Google services. Before the Sudoku shows the “rate this app” popup, a small Kotlin check asks whether the Play Store is even there. If not, the popup never appears.
  • Notification permission. Newer Android versions ask before an app may show a notification. The speedometer asks once, at the first start of a trip, through a short native call. Tracking works either way.

Notice how small these are. Across our apps, native code is roughly one line in a hundred, often less. The messenger, with the most system integration of all, sits just above that.

There is one more kind of code inside our apps that is neither Flutter nor native: Rust, for sensitive or heavy work such as encryption, which has to behave identically on every device. That choice has its own story in Go or Rust, how we pick the language.

When we would build the whole app natively

Some products are mostly operating system. If the core of an idea is a home screen widget, an Apple Watch app, a custom keyboard or a deep hook into the system, the screens Flutter would draw are a minor part of it. Home screen widgets have to be built with each platform’s own tools anyway, and Apple Watch apps are outside what Flutter targets. For a product like that, native is the honest choice.

The same goes for an app that will only ever exist on one platform and leans on that platform’s newest features from day one. We have one Android-only experiment written entirely in Kotlin for exactly that reason.

Swift and Kotlin are excellent at what they are made for: being the operating system’s own language. We treat native as a tool with its own job, never as the plan B for when Flutter runs out of road.

How we decide, in practice

For each new app we ask a few questions, roughly in this order:

  1. Is the product mainly screens and logic, or mainly the system? Screens and logic: Flutter. Mostly system: native.
  2. Will it live on more than one platform, now or later? If yes, one codebase pays for itself early. If the answer is “maybe later,” we still lean towards Flutter, because “later” usually arrives.
  3. Which system features does it need? We list them up front: sharing, widgets, background work, payments, notifications. Each one becomes either a small native piece or a reason to go native for the whole app.
  4. Who maintains it in three years? One codebase needs one set of skills. Two native apps need two, and both have to be around when the bug report arrives.

Most of the time the answers point to Flutter with a thin native layer, each tool doing the part it is best at.

What to ask your developer

If you are choosing a vendor for a cross platform app, a few questions tell you a lot:

  • Which parts will be native, and why? “None” is a warning sign for any app that shares files, shows widgets or runs in the background. “All of it” should come with a reason better than habit.
  • Does a fix on one platform reach the other in the same release? If not, ask how they keep the two in step.
  • Where do your privacy rules live? One place is easier to check than two.

A good team picks per app and can explain the pick in plain words. A shared codebase for what users see, native code for what only the system can do, and nothing more complicated than the product needs.

Share