# 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.

By Alexandr Bykov, OxiSoft. Published 16 November 2026.
Canonical: https://oxisoft.io/blog/flutter-or-native-how-we-choose/

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](/blog/flutter-desktop-in-production/). 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](/blog/go-or-rust-how-we-choose/).

## 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.
