If you built your app with Rork before it switched to native code, you have an Expo (React Native) project, and Rork now offers to rebuild it in Swift. Your Rork Expo app still works: you can keep building it, publishing it and exporting it to GitHub. For most live apps, staying on Expo is the safer default. Rebuild in Swift only for a specific reason, and if you do, protect four things before you ship: the store listing, your signed-in users, your subscribers and your data.
This guide covers what changed, how to decide and what breaks when a live app moves from Expo to Swift.
What changed with Rork and Expo?
Rork used to build every mobile app with Expo. You can no longer create Expo projects in Rork. Rork’s own docs say new iPhone apps are Swift (SwiftUI), new Android apps are Kotlin (Jetpack Compose) and new web apps are React. Rork’s reason is simple: on its internal benchmarks, the agent wrote better Swift apps than React Native apps.
Existing Expo projects keep working. You can build them, publish them and sync them to GitHub as before. But Rork “strongly recommends” moving them to Swift, and you’ll see a Make this app native iOS card next to the preview with an Add iOS app button.
Clicking it doesn’t convert your code. The agent recreates your screens, navigation, data flows and design as a new SwiftUI app in the same project. Your Expo app stays untouched beside it. Android is a separate step: add a Kotlin app from the + menu above the preview.
That last part matters more than it sounds. A React Native app is one codebase for iPhone and Android. After the switch you have two native apps: Swift for iPhone, Kotlin for Android. They share the backend and the chat, but not the code. Rork’s docs say it plainly: the two apps can drift, and the agent is how you keep them in sync.
Is Rork’s Swift rebuild a code conversion?
No. Rork’s conversion guide describes it as a rebuild with each platform’s native components, keeping the same screens, flows and data. It isn’t a line-by-line translation.
That’s a good thing for the end result, but it changes how you should treat it. A rebuilt app is a new app that happens to look like your old one. Every screen, every edge case and every bug fix you made over the past months has to be checked again. Treat it like a new release, not an upgrade.
Should you rebuild your Rork app in Swift?
Here’s how I’d decide:
| Your situation | My advice |
|---|---|
| Live app with paying users, works well, no missing features | Keep Expo. Rebuild later, for a reason |
| You need widgets, Live Activities, Apple Watch, HealthKit, CarPlay or AR | Rebuild in Swift. These are where native pays off |
| Your users are almost all on iPhone | Rebuild in Swift when you have time to test properly |
| You need iPhone and Android, and have no developer | Keep Expo for now. Two codebases is twice the upkeep |
| The Expo app is still a prototype with no real users | Rebuild in Swift. It’s cheap now and costly later |
| The Expo code is a mess of fix loops and you’re stuck | Rebuild, or get the Expo app fixed first. Don’t port the mess |
Rork’s own Swift vs React Native page lists what a native iPhone app does better: home screen and lock screen widgets, Live Activities, Apple Watch and Health integration, background work, advanced motion tracking, AR and games. If your product needs those, Swift is the right call. If it’s a form, a feed, a list and a paywall, Expo does that well, and many production apps ship that way.
The other honest factor is cost. Rebuilding uses credits, a day or two of testing at minimum and a new review. With paying users, the risk isn’t the code. It’s breaking something they rely on.
What breaks when you move a live app from Expo to Swift
If your Expo app is already in the App Store or Google Play, this is the part most guides skip. The rebuild is easy. Swapping it in under existing users is where things go wrong.
1. The store listing (bundle ID and package name)
Your app’s identity in the App Store is its bundle ID, such as com.yourcompany.yourapp. Apple’s App Store Connect reference says you can’t change it after you’ve uploaded a build.
So the Swift app must use exactly the same bundle ID as your Expo app. Then it ships as an update to the existing listing, with your reviews, ratings, rankings and users. In Rork, each app in a project has its own bundle identifier, set in Project Settings. Check it before you publish, because a new app in the project may not inherit the old one.
Use a different bundle ID and you get a brand-new App Store app with zero ratings, and your existing users never get the update. You’d also have two near-identical apps live, which is an easy way to get a Guideline 4.3 spam rejection.
Also set a higher version number than the live Expo app. Find both values in your Expo project’s app.json:
{
"expo": {
"version": "1.4.0",
"ios": { "bundleIdentifier": "com.yourcompany.yourapp" },
"android": { "package": "com.yourcompany.yourapp", "versionCode": 14 }
}
}
Android works the same way, with stricter rules. Google Play’s update rules say the update’s package name must be the same, the version code must be higher and the bundle must be signed with the same signature as the current version. If any of those don’t match, Play won’t accept the Kotlin build as an update.
2. Signed-in users
Rork’s sign-in docs say Rork Auth keeps the session in SecureStore in an Expo app and in the Keychain in a Swift app. Those are stored differently, so plan for users to be signed out when the Swift version installs, and make sure signing back in is quick and obvious.
The accounts themselves don’t disappear, as long as you keep the same sign-in model. Rork projects use either Rork Auth (Google and Apple) or Supabase Auth (email, magic links, phone), never both, and Rork warns that switching later means existing users have to sign up again. Don’t change sign-in methods as part of the rebuild. Do one big change at a time.
3. Data on the device
Data in your backend (Rork Cloud or Supabase) is safe. Rork’s docs say the Swift app talks to the same backend as the Expo one.
Data stored only on the phone is a different story. Drafts, settings, offline lists or anything the Expo app saved locally (for example with AsyncStorage) won’t automatically be readable by the Swift app. Search your Expo code for local storage before you rebuild. Anything users would miss should either move to the backend first, or be migrated by the new app on first launch.
4. Subscriptions and in-app purchases
Purchases belong to the App Store app record, not to your code. Keep the same bundle ID and the same product IDs, and existing subscriptions carry on.
What can break is how your app recognises them. If you use RevenueCat:
- Use the same RevenueCat project and app, so customers and their history stay in one place.
- Identify users the same way. If the Expo app logged users in to RevenueCat with their account ID, do the same in Swift, and their entitlements come straight back.
- If you relied on anonymous IDs, subscribers will need to restore. RevenueCat’s restore behaviour settings decide how purchases move between IDs.
Either way, keep a visible Restore Purchases button. Apple’s guidelines already expect a restore mechanism for restorable purchases, and after a rebuild it’s the difference between a subscriber who’s annoyed and one who’s gone. If purchases don’t show up during review, my guide to Guideline 2.1(b) covers that.
5. Over-the-air updates
If you’ve been pushing quick fixes to the Expo app with EAS Update, that stops. A Swift app has no JavaScript layer to update over the air. Every change, including a one-line fix, goes through a new build and review. Plan your first weeks on Swift accordingly.
6. Push notifications and deep links
Check both on a real device. Make sure the Swift app asks for notification permission at a sensible moment and sends its device token to the backend, so existing users keep getting notifications. If your Expo app used universal links or a custom URL scheme (password reset, magic links, sign-in with Google), the Swift app needs the same associated domains and scheme, or those links will stop opening the app.
How to migrate a live Rork app safely
If you’ve decided to rebuild, here’s the order I’d do it in:
- Export the Expo code first. Connect the project to GitHub (Rork’s code export needs a paid plan) and tag the version that’s live. That’s your rollback.
- Write down what’s live. Bundle ID, package name, version, sign-in method, RevenueCat setup, product IDs, local storage, push and deep links. This list is your test plan.
- Add the Swift app in the same project and check its bundle ID and version in Project Settings before anything else.
- Test it as an update, not a fresh install. On a test iPhone, install the live App Store version, sign in, make a sandbox purchase and save some data. Then install the TestFlight build over it and check what survived.
- Release in phases. Apple’s phased release rolls automatic updates out over 7 days, and you can pause it if something’s wrong.
- Keep the Expo project until the Swift app has been stable for a few weeks. If you need an urgent fix in the meantime, it’s still there.
- Do Android separately, after iPhone is settled, with the same checks against the Play listing.
If you keep Expo: what you need to watch
Staying on Expo is a fine decision, but it isn’t zero work. You can keep building and publishing in Rork, or export the code and build it yourself with EAS Build and EAS Submit.
What you have to keep up with is the platform. Apple has required apps to be built with Xcode 26 and the iOS 26 SDK since 28 April 2026, and Apple says that from April 2027 uploads must use the iOS 27 SDK. That means keeping your Expo SDK and libraries current enough to build with each new Xcode. With Rork’s agent now focused on Swift, make sure someone owns those upgrades for your app, whether that’s you, a developer or Rork.
When to bring in a developer
You can run a rebuild yourself in Rork. It’s worth getting help when:
- The app has paying subscribers and you can’t afford to lose any in the switch
- You’re not sure your bundle ID, signing or RevenueCat setup will carry over
- The Expo app is stuck in a fix loop, and you need to decide between fixing it and rebuilding
- You want to stay on Expo but need someone to keep the SDK, builds and store requirements up to date
- You need iPhone and Android to stay in sync after the split into Swift and Kotlin
That’s work I do for founders: fixing and maintaining Rork apps, and planning migrations so users don’t notice anything except a better app. See how I fix Rork apps, or look at my services. If you’re weighing up the switch now, send me your project and I’ll tell you whether to stay on Expo or rebuild, and what it would take.
FAQ
Can I still use Expo in Rork?
Yes, for existing projects. You can’t create new Expo projects in Rork, but projects you already have keep working: you can build, publish and export them to GitHub. New projects are Swift for iPhone, Kotlin for Android or React for web.
Will my users have to download a new app if I rebuild in Swift?
Not if the Swift app uses the same bundle ID as your Expo app and a higher version number. Then it ships as a normal update to the same App Store listing. A different bundle ID creates a separate app, and your existing users won’t get it.
Will my subscribers lose access after the switch?
They shouldn’t, but test it. Subscriptions belong to the App Store app record, so keep the same bundle ID and product IDs. If you use RevenueCat, use the same project and identify users the same way. Keep a Restore Purchases button for anyone who needs it.
Is a Swift app better than an Expo app?
It depends on the app. Swift gives you the most native features and a polished iPhone feel, and it’s what Rork’s agent now writes best. Expo gives you one codebase for iPhone and Android. For a simple app that already works, the switch often costs more than it gains.
Does Rork convert my Android app too?
Not in the same step. Add a native Android app separately from the + menu above the preview, and Rork rebuilds it in Kotlin. You then have two native apps that share the backend and the chat, but not the code.
Further reading
- What happened to Expo? (Rork)
- Convert your app between iOS, Android, and web (Rork)
- Swift vs React Native: iPhone, Android, or web (Rork)
- Add accounts and sign-in to your app (Rork)
- App information: bundle ID (Apple)
- Update or unpublish your app (Google Play)
- Restore behavior (RevenueCat)