Notes

3 min read

What “native on both phones” really means

SwiftUI on iPhone, Jetpack Compose on Android, one design, the same meaning on both, and a choice of how alike they look.

“Native” is a word many tools use loosely. Here is exactly what it means in Burrow.

Real code for each phone

When you design an app in Burrow, the app that comes out is written in each phone’s own way. On iPhone, that is SwiftUI, Apple’s own toolkit. On Android, that is Jetpack Compose, Google’s own toolkit.

It is not a web page inside an app shell. It is not one engine drawing its own buttons on both phones. Each phone gets the code its own platform expects, so scrolling, text, gestures and accessibility come from the platform itself.

One design, the same meaning

You design once. The two apps mean the same thing: the same screens, the same data, the same steps when someone taps a button. Where the two phones truly differ, for example in how a back gesture works, Burrow says so plainly and does what each phone’s people expect.

This matters because a team should not keep two copies of one product in step by hand. One design is the source. Both apps follow it.

Three looks, your choice

A product team often asks whether the app should look the same everywhere. There is no single right answer, so Burrow lets you choose:

  • Native to each. The iPhone app looks like an iPhone app. The Android app looks like an Android app. People feel at home.
  • Same on both. One look, your brand’s look, on both phones. Good when the brand is the product.
  • Different per phone. A separate design for each phone when you want one. You are not forced into it, and you are not blocked from it.

You can also build for one phone first and add the other later. The design does not have to change.

The Mac question

Apple requires its own tools to build the final iPhone app, and those tools run only on a Mac. That is Apple’s rule, not ours, and we do not try to work around it.

So here is how the work is split. Almost everything, from design to checking the Swift that Burrow writes, can happen on any computer, Windows included. The last step, compiling and packing the iPhone app for the store, happens on a Mac. Android needs no such step.

Why native is worth the trouble

A native app uses the phone’s own parts. Text scales the way the person has set it. Scrolling has the weight the phone’s people expect. Screen readers, large type, dark mode and the keyboard all behave as they do in every other app on the phone.

These small things are most of what people mean when they say an app feels right. They are also the things a web view or a drawn-from-scratch engine has to imitate, and imitations drift out of date each time the phone’s system changes. Using the platform’s own toolkit means those updates reach your app for free.

Native also opens the door to everything the phone can do: the camera, maps, payments, notifications and more. Burrow is built to reach them through each phone’s own interfaces, and the app library that does so is being built after the language.

What is true today

Android apps built from Burrow’s language build and run today. The iPhone side is being built: the Swift that Burrow writes is checked on a PC, and the first runs on a real Mac come next. Until a Mac has run it, we mark each iPhone feature as checked, not yet run.

Read next

How Burrow is built for apps that grow

Read it